Linux Audio

Check our new training course

Loading...
v5.4
   1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 *  compress_core.c - compress offload core
   4 *
   5 *  Copyright (C) 2011 Intel Corporation
   6 *  Authors:	Vinod Koul <vinod.koul@linux.intel.com>
   7 *		Pierre-Louis Bossart <pierre-louis.bossart@linux.intel.com>
   8 *  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   9 *
 
 
 
 
 
 
 
 
 
 
 
 
 
  10 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
  11 */
  12#define FORMAT(fmt) "%s: %d: " fmt, __func__, __LINE__
  13#define pr_fmt(fmt) KBUILD_MODNAME ": " FORMAT(fmt)
  14
  15#include <linux/file.h>
  16#include <linux/fs.h>
  17#include <linux/list.h>
  18#include <linux/math64.h>
  19#include <linux/mm.h>
  20#include <linux/mutex.h>
  21#include <linux/poll.h>
  22#include <linux/slab.h>
  23#include <linux/sched.h>
  24#include <linux/types.h>
  25#include <linux/uio.h>
  26#include <linux/uaccess.h>
  27#include <linux/module.h>
  28#include <linux/compat.h>
  29#include <sound/core.h>
  30#include <sound/initval.h>
  31#include <sound/info.h>
  32#include <sound/compress_params.h>
  33#include <sound/compress_offload.h>
  34#include <sound/compress_driver.h>
  35
  36/* struct snd_compr_codec_caps overflows the ioctl bit size for some
  37 * architectures, so we need to disable the relevant ioctls.
  38 */
  39#if _IOC_SIZEBITS < 14
  40#define COMPR_CODEC_CAPS_OVERFLOW
  41#endif
  42
  43/* TODO:
  44 * - add substream support for multiple devices in case of
  45 *	SND_DYNAMIC_MINORS is not used
  46 * - Multiple node representation
  47 *	driver should be able to register multiple nodes
  48 */
  49
  50static DEFINE_MUTEX(device_mutex);
  51
  52struct snd_compr_file {
  53	unsigned long caps;
  54	struct snd_compr_stream stream;
  55};
  56
  57static void error_delayed_work(struct work_struct *work);
  58
  59/*
  60 * a note on stream states used:
  61 * we use following states in the compressed core
  62 * SNDRV_PCM_STATE_OPEN: When stream has been opened.
  63 * SNDRV_PCM_STATE_SETUP: When stream has been initialized. This is done by
  64 *	calling SNDRV_COMPRESS_SET_PARAMS. Running streams will come to this
  65 *	state at stop by calling SNDRV_COMPRESS_STOP, or at end of drain.
  66 * SNDRV_PCM_STATE_PREPARED: When a stream has been written to (for
  67 *	playback only). User after setting up stream writes the data buffer
  68 *	before starting the stream.
  69 * SNDRV_PCM_STATE_RUNNING: When stream has been started and is
  70 *	decoding/encoding and rendering/capturing data.
  71 * SNDRV_PCM_STATE_DRAINING: When stream is draining current data. This is done
  72 *	by calling SNDRV_COMPRESS_DRAIN.
  73 * SNDRV_PCM_STATE_PAUSED: When stream is paused. This is done by calling
  74 *	SNDRV_COMPRESS_PAUSE. It can be stopped or resumed by calling
  75 *	SNDRV_COMPRESS_STOP or SNDRV_COMPRESS_RESUME respectively.
  76 */
  77static int snd_compr_open(struct inode *inode, struct file *f)
  78{
  79	struct snd_compr *compr;
  80	struct snd_compr_file *data;
  81	struct snd_compr_runtime *runtime;
  82	enum snd_compr_direction dirn;
  83	int maj = imajor(inode);
  84	int ret;
  85
  86	if ((f->f_flags & O_ACCMODE) == O_WRONLY)
  87		dirn = SND_COMPRESS_PLAYBACK;
  88	else if ((f->f_flags & O_ACCMODE) == O_RDONLY)
  89		dirn = SND_COMPRESS_CAPTURE;
  90	else
  91		return -EINVAL;
  92
  93	if (maj == snd_major)
  94		compr = snd_lookup_minor_data(iminor(inode),
  95					SNDRV_DEVICE_TYPE_COMPRESS);
  96	else
  97		return -EBADFD;
  98
  99	if (compr == NULL) {
 100		pr_err("no device data!!!\n");
 101		return -ENODEV;
 102	}
 103
 104	if (dirn != compr->direction) {
 105		pr_err("this device doesn't support this direction\n");
 106		snd_card_unref(compr->card);
 107		return -EINVAL;
 108	}
 109
 110	data = kzalloc(sizeof(*data), GFP_KERNEL);
 111	if (!data) {
 112		snd_card_unref(compr->card);
 113		return -ENOMEM;
 114	}
 115
 116	INIT_DELAYED_WORK(&data->stream.error_work, error_delayed_work);
 117
 118	data->stream.ops = compr->ops;
 119	data->stream.direction = dirn;
 120	data->stream.private_data = compr->private_data;
 121	data->stream.device = compr;
 122	runtime = kzalloc(sizeof(*runtime), GFP_KERNEL);
 123	if (!runtime) {
 124		kfree(data);
 125		snd_card_unref(compr->card);
 126		return -ENOMEM;
 127	}
 128	runtime->state = SNDRV_PCM_STATE_OPEN;
 129	init_waitqueue_head(&runtime->sleep);
 130	data->stream.runtime = runtime;
 131	f->private_data = (void *)data;
 132	mutex_lock(&compr->lock);
 133	ret = compr->ops->open(&data->stream);
 134	mutex_unlock(&compr->lock);
 135	if (ret) {
 136		kfree(runtime);
 137		kfree(data);
 138	}
 139	snd_card_unref(compr->card);
 140	return ret;
 141}
 142
 143static int snd_compr_free(struct inode *inode, struct file *f)
 144{
 145	struct snd_compr_file *data = f->private_data;
 146	struct snd_compr_runtime *runtime = data->stream.runtime;
 147
 148	cancel_delayed_work_sync(&data->stream.error_work);
 149
 150	switch (runtime->state) {
 151	case SNDRV_PCM_STATE_RUNNING:
 152	case SNDRV_PCM_STATE_DRAINING:
 153	case SNDRV_PCM_STATE_PAUSED:
 154		data->stream.ops->trigger(&data->stream, SNDRV_PCM_TRIGGER_STOP);
 155		break;
 156	default:
 157		break;
 158	}
 159
 160	data->stream.ops->free(&data->stream);
 161	if (!data->stream.runtime->dma_buffer_p)
 162		kfree(data->stream.runtime->buffer);
 163	kfree(data->stream.runtime);
 164	kfree(data);
 165	return 0;
 166}
 167
 168static int snd_compr_update_tstamp(struct snd_compr_stream *stream,
 169		struct snd_compr_tstamp *tstamp)
 170{
 171	if (!stream->ops->pointer)
 172		return -ENOTSUPP;
 173	stream->ops->pointer(stream, tstamp);
 174	pr_debug("dsp consumed till %d total %d bytes\n",
 175		tstamp->byte_offset, tstamp->copied_total);
 176	if (stream->direction == SND_COMPRESS_PLAYBACK)
 177		stream->runtime->total_bytes_transferred = tstamp->copied_total;
 178	else
 179		stream->runtime->total_bytes_available = tstamp->copied_total;
 180	return 0;
 181}
 182
 183static size_t snd_compr_calc_avail(struct snd_compr_stream *stream,
 184		struct snd_compr_avail *avail)
 185{
 186	memset(avail, 0, sizeof(*avail));
 187	snd_compr_update_tstamp(stream, &avail->tstamp);
 188	/* Still need to return avail even if tstamp can't be filled in */
 189
 190	if (stream->runtime->total_bytes_available == 0 &&
 191			stream->runtime->state == SNDRV_PCM_STATE_SETUP &&
 192			stream->direction == SND_COMPRESS_PLAYBACK) {
 193		pr_debug("detected init and someone forgot to do a write\n");
 194		return stream->runtime->buffer_size;
 195	}
 196	pr_debug("app wrote %lld, DSP consumed %lld\n",
 197			stream->runtime->total_bytes_available,
 198			stream->runtime->total_bytes_transferred);
 199	if (stream->runtime->total_bytes_available ==
 200				stream->runtime->total_bytes_transferred) {
 201		if (stream->direction == SND_COMPRESS_PLAYBACK) {
 202			pr_debug("both pointers are same, returning full avail\n");
 203			return stream->runtime->buffer_size;
 204		} else {
 205			pr_debug("both pointers are same, returning no avail\n");
 206			return 0;
 207		}
 208	}
 209
 210	avail->avail = stream->runtime->total_bytes_available -
 211			stream->runtime->total_bytes_transferred;
 212	if (stream->direction == SND_COMPRESS_PLAYBACK)
 213		avail->avail = stream->runtime->buffer_size - avail->avail;
 214
 215	pr_debug("ret avail as %lld\n", avail->avail);
 216	return avail->avail;
 217}
 218
 219static inline size_t snd_compr_get_avail(struct snd_compr_stream *stream)
 220{
 221	struct snd_compr_avail avail;
 222
 223	return snd_compr_calc_avail(stream, &avail);
 224}
 225
 226static int
 227snd_compr_ioctl_avail(struct snd_compr_stream *stream, unsigned long arg)
 228{
 229	struct snd_compr_avail ioctl_avail;
 230	size_t avail;
 231
 232	avail = snd_compr_calc_avail(stream, &ioctl_avail);
 233	ioctl_avail.avail = avail;
 234
 235	switch (stream->runtime->state) {
 236	case SNDRV_PCM_STATE_OPEN:
 237		return -EBADFD;
 238	case SNDRV_PCM_STATE_XRUN:
 239		return -EPIPE;
 240	default:
 241		break;
 242	}
 243
 244	if (copy_to_user((__u64 __user *)arg,
 245				&ioctl_avail, sizeof(ioctl_avail)))
 246		return -EFAULT;
 247	return 0;
 248}
 249
 250static int snd_compr_write_data(struct snd_compr_stream *stream,
 251	       const char __user *buf, size_t count)
 252{
 253	void *dstn;
 254	size_t copy;
 255	struct snd_compr_runtime *runtime = stream->runtime;
 256	/* 64-bit Modulus */
 257	u64 app_pointer = div64_u64(runtime->total_bytes_available,
 258				    runtime->buffer_size);
 259	app_pointer = runtime->total_bytes_available -
 260		      (app_pointer * runtime->buffer_size);
 261
 262	dstn = runtime->buffer + app_pointer;
 263	pr_debug("copying %ld at %lld\n",
 264			(unsigned long)count, app_pointer);
 265	if (count < runtime->buffer_size - app_pointer) {
 266		if (copy_from_user(dstn, buf, count))
 267			return -EFAULT;
 268	} else {
 269		copy = runtime->buffer_size - app_pointer;
 270		if (copy_from_user(dstn, buf, copy))
 271			return -EFAULT;
 272		if (copy_from_user(runtime->buffer, buf + copy, count - copy))
 273			return -EFAULT;
 274	}
 275	/* if DSP cares, let it know data has been written */
 276	if (stream->ops->ack)
 277		stream->ops->ack(stream, count);
 278	return count;
 279}
 280
 281static ssize_t snd_compr_write(struct file *f, const char __user *buf,
 282		size_t count, loff_t *offset)
 283{
 284	struct snd_compr_file *data = f->private_data;
 285	struct snd_compr_stream *stream;
 286	size_t avail;
 287	int retval;
 288
 289	if (snd_BUG_ON(!data))
 290		return -EFAULT;
 291
 292	stream = &data->stream;
 293	mutex_lock(&stream->device->lock);
 294	/* write is allowed when stream is running or has been steup */
 295	switch (stream->runtime->state) {
 296	case SNDRV_PCM_STATE_SETUP:
 297	case SNDRV_PCM_STATE_PREPARED:
 298	case SNDRV_PCM_STATE_RUNNING:
 299		break;
 300	default:
 301		mutex_unlock(&stream->device->lock);
 302		return -EBADFD;
 303	}
 304
 305	avail = snd_compr_get_avail(stream);
 306	pr_debug("avail returned %ld\n", (unsigned long)avail);
 307	/* calculate how much we can write to buffer */
 308	if (avail > count)
 309		avail = count;
 310
 311	if (stream->ops->copy) {
 312		char __user* cbuf = (char __user*)buf;
 313		retval = stream->ops->copy(stream, cbuf, avail);
 314	} else {
 315		retval = snd_compr_write_data(stream, buf, avail);
 316	}
 317	if (retval > 0)
 318		stream->runtime->total_bytes_available += retval;
 319
 320	/* while initiating the stream, write should be called before START
 321	 * call, so in setup move state */
 322	if (stream->runtime->state == SNDRV_PCM_STATE_SETUP) {
 323		stream->runtime->state = SNDRV_PCM_STATE_PREPARED;
 324		pr_debug("stream prepared, Houston we are good to go\n");
 325	}
 326
 327	mutex_unlock(&stream->device->lock);
 328	return retval;
 329}
 330
 331
 332static ssize_t snd_compr_read(struct file *f, char __user *buf,
 333		size_t count, loff_t *offset)
 334{
 335	struct snd_compr_file *data = f->private_data;
 336	struct snd_compr_stream *stream;
 337	size_t avail;
 338	int retval;
 339
 340	if (snd_BUG_ON(!data))
 341		return -EFAULT;
 342
 343	stream = &data->stream;
 344	mutex_lock(&stream->device->lock);
 345
 346	/* read is allowed when stream is running, paused, draining and setup
 347	 * (yes setup is state which we transition to after stop, so if user
 348	 * wants to read data after stop we allow that)
 349	 */
 350	switch (stream->runtime->state) {
 351	case SNDRV_PCM_STATE_OPEN:
 352	case SNDRV_PCM_STATE_PREPARED:
 
 353	case SNDRV_PCM_STATE_SUSPENDED:
 354	case SNDRV_PCM_STATE_DISCONNECTED:
 355		retval = -EBADFD;
 356		goto out;
 357	case SNDRV_PCM_STATE_XRUN:
 358		retval = -EPIPE;
 359		goto out;
 360	}
 361
 362	avail = snd_compr_get_avail(stream);
 363	pr_debug("avail returned %ld\n", (unsigned long)avail);
 364	/* calculate how much we can read from buffer */
 365	if (avail > count)
 366		avail = count;
 367
 368	if (stream->ops->copy) {
 369		retval = stream->ops->copy(stream, buf, avail);
 370	} else {
 371		retval = -ENXIO;
 372		goto out;
 373	}
 374	if (retval > 0)
 375		stream->runtime->total_bytes_transferred += retval;
 376
 377out:
 378	mutex_unlock(&stream->device->lock);
 379	return retval;
 380}
 381
 382static int snd_compr_mmap(struct file *f, struct vm_area_struct *vma)
 383{
 384	return -ENXIO;
 385}
 386
 387static __poll_t snd_compr_get_poll(struct snd_compr_stream *stream)
 388{
 389	if (stream->direction == SND_COMPRESS_PLAYBACK)
 390		return EPOLLOUT | EPOLLWRNORM;
 391	else
 392		return EPOLLIN | EPOLLRDNORM;
 393}
 394
 395static __poll_t snd_compr_poll(struct file *f, poll_table *wait)
 396{
 397	struct snd_compr_file *data = f->private_data;
 398	struct snd_compr_stream *stream;
 399	size_t avail;
 400	__poll_t retval = 0;
 401
 402	if (snd_BUG_ON(!data))
 403		return EPOLLERR;
 404
 405	stream = &data->stream;
 
 
 406
 407	mutex_lock(&stream->device->lock);
 408
 409	switch (stream->runtime->state) {
 410	case SNDRV_PCM_STATE_OPEN:
 411	case SNDRV_PCM_STATE_XRUN:
 412		retval = snd_compr_get_poll(stream) | EPOLLERR;
 413		goto out;
 414	default:
 415		break;
 416	}
 417
 418	poll_wait(f, &stream->runtime->sleep, wait);
 419
 420	avail = snd_compr_get_avail(stream);
 421	pr_debug("avail is %ld\n", (unsigned long)avail);
 422	/* check if we have at least one fragment to fill */
 423	switch (stream->runtime->state) {
 424	case SNDRV_PCM_STATE_DRAINING:
 425		/* stream has been woken up after drain is complete
 426		 * draining done so set stream state to stopped
 427		 */
 428		retval = snd_compr_get_poll(stream);
 429		stream->runtime->state = SNDRV_PCM_STATE_SETUP;
 430		break;
 431	case SNDRV_PCM_STATE_RUNNING:
 432	case SNDRV_PCM_STATE_PREPARED:
 433	case SNDRV_PCM_STATE_PAUSED:
 434		if (avail >= stream->runtime->fragment_size)
 435			retval = snd_compr_get_poll(stream);
 436		break;
 437	default:
 438		retval = snd_compr_get_poll(stream) | EPOLLERR;
 
 
 
 439		break;
 440	}
 441out:
 442	mutex_unlock(&stream->device->lock);
 443	return retval;
 444}
 445
 446static int
 447snd_compr_get_caps(struct snd_compr_stream *stream, unsigned long arg)
 448{
 449	int retval;
 450	struct snd_compr_caps caps;
 451
 452	if (!stream->ops->get_caps)
 453		return -ENXIO;
 454
 455	memset(&caps, 0, sizeof(caps));
 456	retval = stream->ops->get_caps(stream, &caps);
 457	if (retval)
 458		goto out;
 459	if (copy_to_user((void __user *)arg, &caps, sizeof(caps)))
 460		retval = -EFAULT;
 461out:
 462	return retval;
 463}
 464
 465#ifndef COMPR_CODEC_CAPS_OVERFLOW
 466static int
 467snd_compr_get_codec_caps(struct snd_compr_stream *stream, unsigned long arg)
 468{
 469	int retval;
 470	struct snd_compr_codec_caps *caps;
 471
 472	if (!stream->ops->get_codec_caps)
 473		return -ENXIO;
 474
 475	caps = kzalloc(sizeof(*caps), GFP_KERNEL);
 476	if (!caps)
 477		return -ENOMEM;
 478
 479	retval = stream->ops->get_codec_caps(stream, caps);
 480	if (retval)
 481		goto out;
 482	if (copy_to_user((void __user *)arg, caps, sizeof(*caps)))
 483		retval = -EFAULT;
 484
 485out:
 486	kfree(caps);
 487	return retval;
 488}
 489#endif /* !COMPR_CODEC_CAPS_OVERFLOW */
 490
 491/* revisit this with snd_pcm_preallocate_xxx */
 492static int snd_compr_allocate_buffer(struct snd_compr_stream *stream,
 493		struct snd_compr_params *params)
 494{
 495	unsigned int buffer_size;
 496	void *buffer = NULL;
 497
 498	buffer_size = params->buffer.fragment_size * params->buffer.fragments;
 499	if (stream->ops->copy) {
 500		buffer = NULL;
 501		/* if copy is defined the driver will be required to copy
 502		 * the data from core
 503		 */
 504	} else {
 505		if (stream->runtime->dma_buffer_p) {
 506
 507			if (buffer_size > stream->runtime->dma_buffer_p->bytes)
 508				dev_err(&stream->device->dev,
 509						"Not enough DMA buffer");
 510			else
 511				buffer = stream->runtime->dma_buffer_p->area;
 512
 513		} else {
 514			buffer = kmalloc(buffer_size, GFP_KERNEL);
 515		}
 516
 517		if (!buffer)
 518			return -ENOMEM;
 519	}
 520	stream->runtime->fragment_size = params->buffer.fragment_size;
 521	stream->runtime->fragments = params->buffer.fragments;
 522	stream->runtime->buffer = buffer;
 523	stream->runtime->buffer_size = buffer_size;
 524	return 0;
 525}
 526
 527static int snd_compress_check_input(struct snd_compr_params *params)
 528{
 529	/* first let's check the buffer parameter's */
 530	if (params->buffer.fragment_size == 0 ||
 531	    params->buffer.fragments > U32_MAX / params->buffer.fragment_size ||
 532	    params->buffer.fragments == 0)
 533		return -EINVAL;
 534
 535	/* now codec parameters */
 536	if (params->codec.id == 0 || params->codec.id > SND_AUDIOCODEC_MAX)
 537		return -EINVAL;
 538
 539	if (params->codec.ch_in == 0 || params->codec.ch_out == 0)
 540		return -EINVAL;
 541
 542	return 0;
 543}
 544
 545static int
 546snd_compr_set_params(struct snd_compr_stream *stream, unsigned long arg)
 547{
 548	struct snd_compr_params *params;
 549	int retval;
 550
 551	if (stream->runtime->state == SNDRV_PCM_STATE_OPEN) {
 552		/*
 553		 * we should allow parameter change only when stream has been
 554		 * opened not in other cases
 555		 */
 556		params = memdup_user((void __user *)arg, sizeof(*params));
 557		if (IS_ERR(params))
 558			return PTR_ERR(params);
 
 
 
 
 559
 560		retval = snd_compress_check_input(params);
 561		if (retval)
 562			goto out;
 563
 564		retval = snd_compr_allocate_buffer(stream, params);
 565		if (retval) {
 566			retval = -ENOMEM;
 567			goto out;
 568		}
 569
 570		retval = stream->ops->set_params(stream, params);
 571		if (retval)
 572			goto out;
 573
 574		stream->metadata_set = false;
 575		stream->next_track = false;
 576
 577		stream->runtime->state = SNDRV_PCM_STATE_SETUP;
 
 
 
 578	} else {
 579		return -EPERM;
 580	}
 581out:
 582	kfree(params);
 583	return retval;
 584}
 585
 586static int
 587snd_compr_get_params(struct snd_compr_stream *stream, unsigned long arg)
 588{
 589	struct snd_codec *params;
 590	int retval;
 591
 592	if (!stream->ops->get_params)
 593		return -EBADFD;
 594
 595	params = kzalloc(sizeof(*params), GFP_KERNEL);
 596	if (!params)
 597		return -ENOMEM;
 598	retval = stream->ops->get_params(stream, params);
 599	if (retval)
 600		goto out;
 601	if (copy_to_user((char __user *)arg, params, sizeof(*params)))
 602		retval = -EFAULT;
 603
 604out:
 605	kfree(params);
 606	return retval;
 607}
 608
 609static int
 610snd_compr_get_metadata(struct snd_compr_stream *stream, unsigned long arg)
 611{
 612	struct snd_compr_metadata metadata;
 613	int retval;
 614
 615	if (!stream->ops->get_metadata)
 616		return -ENXIO;
 617
 618	if (copy_from_user(&metadata, (void __user *)arg, sizeof(metadata)))
 619		return -EFAULT;
 620
 621	retval = stream->ops->get_metadata(stream, &metadata);
 622	if (retval != 0)
 623		return retval;
 624
 625	if (copy_to_user((void __user *)arg, &metadata, sizeof(metadata)))
 626		return -EFAULT;
 627
 628	return 0;
 629}
 630
 631static int
 632snd_compr_set_metadata(struct snd_compr_stream *stream, unsigned long arg)
 633{
 634	struct snd_compr_metadata metadata;
 635	int retval;
 636
 637	if (!stream->ops->set_metadata)
 638		return -ENXIO;
 639	/*
 640	* we should allow parameter change only when stream has been
 641	* opened not in other cases
 642	*/
 643	if (copy_from_user(&metadata, (void __user *)arg, sizeof(metadata)))
 644		return -EFAULT;
 645
 646	retval = stream->ops->set_metadata(stream, &metadata);
 647	stream->metadata_set = true;
 648
 649	return retval;
 650}
 651
 652static inline int
 653snd_compr_tstamp(struct snd_compr_stream *stream, unsigned long arg)
 654{
 655	struct snd_compr_tstamp tstamp = {0};
 656	int ret;
 657
 658	ret = snd_compr_update_tstamp(stream, &tstamp);
 659	if (ret == 0)
 660		ret = copy_to_user((struct snd_compr_tstamp __user *)arg,
 661			&tstamp, sizeof(tstamp)) ? -EFAULT : 0;
 662	return ret;
 663}
 664
 665static int snd_compr_pause(struct snd_compr_stream *stream)
 666{
 667	int retval;
 668
 669	if (stream->runtime->state != SNDRV_PCM_STATE_RUNNING)
 670		return -EPERM;
 671	retval = stream->ops->trigger(stream, SNDRV_PCM_TRIGGER_PAUSE_PUSH);
 672	if (!retval)
 673		stream->runtime->state = SNDRV_PCM_STATE_PAUSED;
 674	return retval;
 675}
 676
 677static int snd_compr_resume(struct snd_compr_stream *stream)
 678{
 679	int retval;
 680
 681	if (stream->runtime->state != SNDRV_PCM_STATE_PAUSED)
 682		return -EPERM;
 683	retval = stream->ops->trigger(stream, SNDRV_PCM_TRIGGER_PAUSE_RELEASE);
 684	if (!retval)
 685		stream->runtime->state = SNDRV_PCM_STATE_RUNNING;
 686	return retval;
 687}
 688
 689static int snd_compr_start(struct snd_compr_stream *stream)
 690{
 691	int retval;
 692
 693	switch (stream->runtime->state) {
 694	case SNDRV_PCM_STATE_SETUP:
 695		if (stream->direction != SND_COMPRESS_CAPTURE)
 696			return -EPERM;
 697		break;
 698	case SNDRV_PCM_STATE_PREPARED:
 699		break;
 700	default:
 701		return -EPERM;
 702	}
 703
 704	retval = stream->ops->trigger(stream, SNDRV_PCM_TRIGGER_START);
 705	if (!retval)
 706		stream->runtime->state = SNDRV_PCM_STATE_RUNNING;
 707	return retval;
 708}
 709
 710static int snd_compr_stop(struct snd_compr_stream *stream)
 711{
 712	int retval;
 713
 714	switch (stream->runtime->state) {
 715	case SNDRV_PCM_STATE_OPEN:
 716	case SNDRV_PCM_STATE_SETUP:
 717	case SNDRV_PCM_STATE_PREPARED:
 718		return -EPERM;
 719	default:
 720		break;
 721	}
 722
 723	retval = stream->ops->trigger(stream, SNDRV_PCM_TRIGGER_STOP);
 724	if (!retval) {
 725		snd_compr_drain_notify(stream);
 726		stream->runtime->total_bytes_available = 0;
 727		stream->runtime->total_bytes_transferred = 0;
 728	}
 729	return retval;
 730}
 731
 732static void error_delayed_work(struct work_struct *work)
 733{
 734	struct snd_compr_stream *stream;
 735
 736	stream = container_of(work, struct snd_compr_stream, error_work.work);
 737
 738	mutex_lock(&stream->device->lock);
 739
 740	stream->ops->trigger(stream, SNDRV_PCM_TRIGGER_STOP);
 741	wake_up(&stream->runtime->sleep);
 742
 743	mutex_unlock(&stream->device->lock);
 744}
 745
 746/*
 747 * snd_compr_stop_error: Report a fatal error on a stream
 748 * @stream: pointer to stream
 749 * @state: state to transition the stream to
 750 *
 751 * Stop the stream and set its state.
 752 *
 753 * Should be called with compressed device lock held.
 754 */
 755int snd_compr_stop_error(struct snd_compr_stream *stream,
 756			 snd_pcm_state_t state)
 757{
 758	if (stream->runtime->state == state)
 759		return 0;
 760
 761	stream->runtime->state = state;
 762
 763	pr_debug("Changing state to: %d\n", state);
 764
 765	queue_delayed_work(system_power_efficient_wq, &stream->error_work, 0);
 766
 767	return 0;
 768}
 769EXPORT_SYMBOL_GPL(snd_compr_stop_error);
 770
 771static int snd_compress_wait_for_drain(struct snd_compr_stream *stream)
 772{
 773	int ret;
 774
 775	/*
 776	 * We are called with lock held. So drop the lock while we wait for
 777	 * drain complete notification from the driver
 778	 *
 779	 * It is expected that driver will notify the drain completion and then
 780	 * stream will be moved to SETUP state, even if draining resulted in an
 781	 * error. We can trigger next track after this.
 782	 */
 783	stream->runtime->state = SNDRV_PCM_STATE_DRAINING;
 784	mutex_unlock(&stream->device->lock);
 785
 786	/* we wait for drain to complete here, drain can return when
 787	 * interruption occurred, wait returned error or success.
 788	 * For the first two cases we don't do anything different here and
 789	 * return after waking up
 790	 */
 791
 792	ret = wait_event_interruptible(stream->runtime->sleep,
 793			(stream->runtime->state != SNDRV_PCM_STATE_DRAINING));
 794	if (ret == -ERESTARTSYS)
 795		pr_debug("wait aborted by a signal\n");
 796	else if (ret)
 797		pr_debug("wait for drain failed with %d\n", ret);
 798
 799
 800	wake_up(&stream->runtime->sleep);
 801	mutex_lock(&stream->device->lock);
 802
 803	return ret;
 804}
 805
 806static int snd_compr_drain(struct snd_compr_stream *stream)
 807{
 808	int retval;
 809
 810	switch (stream->runtime->state) {
 811	case SNDRV_PCM_STATE_OPEN:
 812	case SNDRV_PCM_STATE_SETUP:
 813	case SNDRV_PCM_STATE_PREPARED:
 814	case SNDRV_PCM_STATE_PAUSED:
 815		return -EPERM;
 816	case SNDRV_PCM_STATE_XRUN:
 817		return -EPIPE;
 818	default:
 819		break;
 820	}
 821
 822	retval = stream->ops->trigger(stream, SND_COMPR_TRIGGER_DRAIN);
 823	if (retval) {
 824		pr_debug("SND_COMPR_TRIGGER_DRAIN failed %d\n", retval);
 825		wake_up(&stream->runtime->sleep);
 826		return retval;
 827	}
 828
 829	return snd_compress_wait_for_drain(stream);
 830}
 831
 832static int snd_compr_next_track(struct snd_compr_stream *stream)
 833{
 834	int retval;
 835
 836	/* only a running stream can transition to next track */
 837	if (stream->runtime->state != SNDRV_PCM_STATE_RUNNING)
 838		return -EPERM;
 839
 840	/* next track doesn't have any meaning for capture streams */
 841	if (stream->direction == SND_COMPRESS_CAPTURE)
 842		return -EPERM;
 843
 844	/* you can signal next track if this is intended to be a gapless stream
 845	 * and current track metadata is set
 846	 */
 847	if (stream->metadata_set == false)
 848		return -EPERM;
 849
 850	retval = stream->ops->trigger(stream, SND_COMPR_TRIGGER_NEXT_TRACK);
 851	if (retval != 0)
 852		return retval;
 853	stream->metadata_set = false;
 854	stream->next_track = true;
 855	return 0;
 856}
 857
 858static int snd_compr_partial_drain(struct snd_compr_stream *stream)
 859{
 860	int retval;
 861
 862	switch (stream->runtime->state) {
 863	case SNDRV_PCM_STATE_OPEN:
 864	case SNDRV_PCM_STATE_SETUP:
 865	case SNDRV_PCM_STATE_PREPARED:
 866	case SNDRV_PCM_STATE_PAUSED:
 867		return -EPERM;
 868	case SNDRV_PCM_STATE_XRUN:
 869		return -EPIPE;
 870	default:
 871		break;
 872	}
 873
 874	/* partial drain doesn't have any meaning for capture streams */
 875	if (stream->direction == SND_COMPRESS_CAPTURE)
 876		return -EPERM;
 877
 878	/* stream can be drained only when next track has been signalled */
 879	if (stream->next_track == false)
 880		return -EPERM;
 881
 882	retval = stream->ops->trigger(stream, SND_COMPR_TRIGGER_PARTIAL_DRAIN);
 883	if (retval) {
 884		pr_debug("Partial drain returned failure\n");
 885		wake_up(&stream->runtime->sleep);
 886		return retval;
 887	}
 888
 889	stream->next_track = false;
 890	return snd_compress_wait_for_drain(stream);
 891}
 892
 893static long snd_compr_ioctl(struct file *f, unsigned int cmd, unsigned long arg)
 894{
 895	struct snd_compr_file *data = f->private_data;
 896	struct snd_compr_stream *stream;
 897	int retval = -ENOTTY;
 898
 899	if (snd_BUG_ON(!data))
 900		return -EFAULT;
 901
 902	stream = &data->stream;
 903
 
 904	mutex_lock(&stream->device->lock);
 905	switch (_IOC_NR(cmd)) {
 906	case _IOC_NR(SNDRV_COMPRESS_IOCTL_VERSION):
 907		retval = put_user(SNDRV_COMPRESS_VERSION,
 908				(int __user *)arg) ? -EFAULT : 0;
 909		break;
 910	case _IOC_NR(SNDRV_COMPRESS_GET_CAPS):
 911		retval = snd_compr_get_caps(stream, arg);
 912		break;
 913#ifndef COMPR_CODEC_CAPS_OVERFLOW
 914	case _IOC_NR(SNDRV_COMPRESS_GET_CODEC_CAPS):
 915		retval = snd_compr_get_codec_caps(stream, arg);
 916		break;
 917#endif
 918	case _IOC_NR(SNDRV_COMPRESS_SET_PARAMS):
 919		retval = snd_compr_set_params(stream, arg);
 920		break;
 921	case _IOC_NR(SNDRV_COMPRESS_GET_PARAMS):
 922		retval = snd_compr_get_params(stream, arg);
 923		break;
 924	case _IOC_NR(SNDRV_COMPRESS_SET_METADATA):
 925		retval = snd_compr_set_metadata(stream, arg);
 926		break;
 927	case _IOC_NR(SNDRV_COMPRESS_GET_METADATA):
 928		retval = snd_compr_get_metadata(stream, arg);
 929		break;
 930	case _IOC_NR(SNDRV_COMPRESS_TSTAMP):
 931		retval = snd_compr_tstamp(stream, arg);
 932		break;
 933	case _IOC_NR(SNDRV_COMPRESS_AVAIL):
 934		retval = snd_compr_ioctl_avail(stream, arg);
 935		break;
 936	case _IOC_NR(SNDRV_COMPRESS_PAUSE):
 937		retval = snd_compr_pause(stream);
 938		break;
 939	case _IOC_NR(SNDRV_COMPRESS_RESUME):
 940		retval = snd_compr_resume(stream);
 941		break;
 942	case _IOC_NR(SNDRV_COMPRESS_START):
 943		retval = snd_compr_start(stream);
 944		break;
 945	case _IOC_NR(SNDRV_COMPRESS_STOP):
 946		retval = snd_compr_stop(stream);
 947		break;
 948	case _IOC_NR(SNDRV_COMPRESS_DRAIN):
 949		retval = snd_compr_drain(stream);
 950		break;
 951	case _IOC_NR(SNDRV_COMPRESS_PARTIAL_DRAIN):
 952		retval = snd_compr_partial_drain(stream);
 953		break;
 954	case _IOC_NR(SNDRV_COMPRESS_NEXT_TRACK):
 955		retval = snd_compr_next_track(stream);
 956		break;
 957
 958	}
 959	mutex_unlock(&stream->device->lock);
 960	return retval;
 961}
 962
 963/* support of 32bit userspace on 64bit platforms */
 964#ifdef CONFIG_COMPAT
 965static long snd_compr_ioctl_compat(struct file *file, unsigned int cmd,
 966						unsigned long arg)
 967{
 968	return snd_compr_ioctl(file, cmd, (unsigned long)compat_ptr(arg));
 969}
 970#endif
 971
 972static const struct file_operations snd_compr_file_ops = {
 973		.owner =	THIS_MODULE,
 974		.open =		snd_compr_open,
 975		.release =	snd_compr_free,
 976		.write =	snd_compr_write,
 977		.read =		snd_compr_read,
 978		.unlocked_ioctl = snd_compr_ioctl,
 979#ifdef CONFIG_COMPAT
 980		.compat_ioctl = snd_compr_ioctl_compat,
 981#endif
 982		.mmap =		snd_compr_mmap,
 983		.poll =		snd_compr_poll,
 984};
 985
 986static int snd_compress_dev_register(struct snd_device *device)
 987{
 988	int ret = -EINVAL;
 
 989	struct snd_compr *compr;
 990
 991	if (snd_BUG_ON(!device || !device->device_data))
 992		return -EBADFD;
 993	compr = device->device_data;
 994
 995	pr_debug("reg device %s, direction %d\n", compr->name,
 996			compr->direction);
 997	/* register compressed device */
 998	ret = snd_register_device(SNDRV_DEVICE_TYPE_COMPRESS,
 999				  compr->card, compr->device,
1000				  &snd_compr_file_ops, compr, &compr->dev);
1001	if (ret < 0) {
1002		pr_err("snd_register_device failed %d\n", ret);
1003		return ret;
1004	}
1005	return ret;
1006
1007}
1008
1009static int snd_compress_dev_disconnect(struct snd_device *device)
1010{
1011	struct snd_compr *compr;
1012
1013	compr = device->device_data;
1014	snd_unregister_device(&compr->dev);
1015	return 0;
1016}
1017
1018#ifdef CONFIG_SND_VERBOSE_PROCFS
1019static void snd_compress_proc_info_read(struct snd_info_entry *entry,
1020					struct snd_info_buffer *buffer)
1021{
1022	struct snd_compr *compr = (struct snd_compr *)entry->private_data;
1023
1024	snd_iprintf(buffer, "card: %d\n", compr->card->number);
1025	snd_iprintf(buffer, "device: %d\n", compr->device);
1026	snd_iprintf(buffer, "stream: %s\n",
1027			compr->direction == SND_COMPRESS_PLAYBACK
1028				? "PLAYBACK" : "CAPTURE");
1029	snd_iprintf(buffer, "id: %s\n", compr->id);
1030}
1031
1032static int snd_compress_proc_init(struct snd_compr *compr)
1033{
1034	struct snd_info_entry *entry;
1035	char name[16];
1036
1037	sprintf(name, "compr%i", compr->device);
1038	entry = snd_info_create_card_entry(compr->card, name,
1039					   compr->card->proc_root);
1040	if (!entry)
1041		return -ENOMEM;
1042	entry->mode = S_IFDIR | 0555;
 
 
 
 
1043	compr->proc_root = entry;
1044
1045	entry = snd_info_create_card_entry(compr->card, "info",
1046					   compr->proc_root);
1047	if (entry)
1048		snd_info_set_text_ops(entry, compr,
1049				      snd_compress_proc_info_read);
 
 
 
 
 
1050	compr->proc_info_entry = entry;
1051
1052	return 0;
1053}
1054
1055static void snd_compress_proc_done(struct snd_compr *compr)
1056{
1057	snd_info_free_entry(compr->proc_info_entry);
1058	compr->proc_info_entry = NULL;
1059	snd_info_free_entry(compr->proc_root);
1060	compr->proc_root = NULL;
1061}
1062
1063static inline void snd_compress_set_id(struct snd_compr *compr, const char *id)
1064{
1065	strlcpy(compr->id, id, sizeof(compr->id));
1066}
1067#else
1068static inline int snd_compress_proc_init(struct snd_compr *compr)
1069{
1070	return 0;
1071}
1072
1073static inline void snd_compress_proc_done(struct snd_compr *compr)
1074{
1075}
1076
1077static inline void snd_compress_set_id(struct snd_compr *compr, const char *id)
1078{
1079}
1080#endif
1081
1082static int snd_compress_dev_free(struct snd_device *device)
1083{
1084	struct snd_compr *compr;
1085
1086	compr = device->device_data;
1087	snd_compress_proc_done(compr);
1088	put_device(&compr->dev);
1089	return 0;
1090}
1091
1092/*
1093 * snd_compress_new: create new compress device
1094 * @card: sound card pointer
1095 * @device: device number
1096 * @dirn: device direction, should be of type enum snd_compr_direction
1097 * @compr: compress device pointer
1098 */
1099int snd_compress_new(struct snd_card *card, int device,
1100			int dirn, const char *id, struct snd_compr *compr)
1101{
1102	static struct snd_device_ops ops = {
1103		.dev_free = snd_compress_dev_free,
1104		.dev_register = snd_compress_dev_register,
1105		.dev_disconnect = snd_compress_dev_disconnect,
1106	};
1107	int ret;
1108
1109	compr->card = card;
1110	compr->device = device;
1111	compr->direction = dirn;
1112
1113	snd_compress_set_id(compr, id);
1114
1115	snd_device_initialize(&compr->dev, card);
1116	dev_set_name(&compr->dev, "comprC%iD%i", card->number, device);
1117
1118	ret = snd_device_new(card, SNDRV_DEV_COMPRESS, compr, &ops);
1119	if (ret == 0)
1120		snd_compress_proc_init(compr);
1121
1122	return ret;
1123}
1124EXPORT_SYMBOL_GPL(snd_compress_new);
1125
1126static int snd_compress_add_device(struct snd_compr *device)
1127{
1128	int ret;
1129
1130	if (!device->card)
1131		return -EINVAL;
1132
1133	/* register the card */
1134	ret = snd_card_register(device->card);
1135	if (ret)
1136		goto out;
1137	return 0;
1138
1139out:
1140	pr_err("failed with %d\n", ret);
1141	return ret;
1142
1143}
1144
1145static int snd_compress_remove_device(struct snd_compr *device)
1146{
1147	return snd_card_free(device->card);
1148}
1149
1150/**
1151 * snd_compress_register - register compressed device
1152 *
1153 * @device: compressed device to register
1154 */
1155int snd_compress_register(struct snd_compr *device)
1156{
1157	int retval;
1158
1159	if (device->name == NULL || device->ops == NULL)
1160		return -EINVAL;
1161
1162	pr_debug("Registering compressed device %s\n", device->name);
1163	if (snd_BUG_ON(!device->ops->open))
1164		return -EINVAL;
1165	if (snd_BUG_ON(!device->ops->free))
1166		return -EINVAL;
1167	if (snd_BUG_ON(!device->ops->set_params))
1168		return -EINVAL;
1169	if (snd_BUG_ON(!device->ops->trigger))
1170		return -EINVAL;
1171
1172	mutex_init(&device->lock);
1173
1174	/* register a compressed card */
1175	mutex_lock(&device_mutex);
1176	retval = snd_compress_add_device(device);
1177	mutex_unlock(&device_mutex);
1178	return retval;
1179}
1180EXPORT_SYMBOL_GPL(snd_compress_register);
1181
1182int snd_compress_deregister(struct snd_compr *device)
1183{
1184	pr_debug("Removing compressed device %s\n", device->name);
1185	mutex_lock(&device_mutex);
1186	snd_compress_remove_device(device);
1187	mutex_unlock(&device_mutex);
1188	return 0;
1189}
1190EXPORT_SYMBOL_GPL(snd_compress_deregister);
 
 
 
 
 
 
 
 
 
 
 
 
1191
1192MODULE_DESCRIPTION("ALSA Compressed offload framework");
1193MODULE_AUTHOR("Vinod Koul <vinod.koul@linux.intel.com>");
1194MODULE_LICENSE("GPL v2");
v4.6
 
   1/*
   2 *  compress_core.c - compress offload core
   3 *
   4 *  Copyright (C) 2011 Intel Corporation
   5 *  Authors:	Vinod Koul <vinod.koul@linux.intel.com>
   6 *		Pierre-Louis Bossart <pierre-louis.bossart@linux.intel.com>
   7 *  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   8 *
   9 *  This program is free software; you can redistribute it and/or modify
  10 *  it under the terms of the GNU General Public License as published by
  11 *  the Free Software Foundation; version 2 of the License.
  12 *
  13 *  This program is distributed in the hope that it will be useful, but
  14 *  WITHOUT ANY WARRANTY; without even the implied warranty of
  15 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16 *  General Public License for more details.
  17 *
  18 *  You should have received a copy of the GNU General Public License along
  19 *  with this program; if not, write to the Free Software Foundation, Inc.,
  20 *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
  21 *
  22 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  23 *
  24 */
  25#define FORMAT(fmt) "%s: %d: " fmt, __func__, __LINE__
  26#define pr_fmt(fmt) KBUILD_MODNAME ": " FORMAT(fmt)
  27
  28#include <linux/file.h>
  29#include <linux/fs.h>
  30#include <linux/list.h>
  31#include <linux/math64.h>
  32#include <linux/mm.h>
  33#include <linux/mutex.h>
  34#include <linux/poll.h>
  35#include <linux/slab.h>
  36#include <linux/sched.h>
  37#include <linux/types.h>
  38#include <linux/uio.h>
  39#include <linux/uaccess.h>
  40#include <linux/module.h>
  41#include <linux/compat.h>
  42#include <sound/core.h>
  43#include <sound/initval.h>
  44#include <sound/info.h>
  45#include <sound/compress_params.h>
  46#include <sound/compress_offload.h>
  47#include <sound/compress_driver.h>
  48
  49/* struct snd_compr_codec_caps overflows the ioctl bit size for some
  50 * architectures, so we need to disable the relevant ioctls.
  51 */
  52#if _IOC_SIZEBITS < 14
  53#define COMPR_CODEC_CAPS_OVERFLOW
  54#endif
  55
  56/* TODO:
  57 * - add substream support for multiple devices in case of
  58 *	SND_DYNAMIC_MINORS is not used
  59 * - Multiple node representation
  60 *	driver should be able to register multiple nodes
  61 */
  62
  63static DEFINE_MUTEX(device_mutex);
  64
  65struct snd_compr_file {
  66	unsigned long caps;
  67	struct snd_compr_stream stream;
  68};
  69
 
 
  70/*
  71 * a note on stream states used:
  72 * we use following states in the compressed core
  73 * SNDRV_PCM_STATE_OPEN: When stream has been opened.
  74 * SNDRV_PCM_STATE_SETUP: When stream has been initialized. This is done by
  75 *	calling SNDRV_COMPRESS_SET_PARAMS. Running streams will come to this
  76 *	state at stop by calling SNDRV_COMPRESS_STOP, or at end of drain.
  77 * SNDRV_PCM_STATE_PREPARED: When a stream has been written to (for
  78 *	playback only). User after setting up stream writes the data buffer
  79 *	before starting the stream.
  80 * SNDRV_PCM_STATE_RUNNING: When stream has been started and is
  81 *	decoding/encoding and rendering/capturing data.
  82 * SNDRV_PCM_STATE_DRAINING: When stream is draining current data. This is done
  83 *	by calling SNDRV_COMPRESS_DRAIN.
  84 * SNDRV_PCM_STATE_PAUSED: When stream is paused. This is done by calling
  85 *	SNDRV_COMPRESS_PAUSE. It can be stopped or resumed by calling
  86 *	SNDRV_COMPRESS_STOP or SNDRV_COMPRESS_RESUME respectively.
  87 */
  88static int snd_compr_open(struct inode *inode, struct file *f)
  89{
  90	struct snd_compr *compr;
  91	struct snd_compr_file *data;
  92	struct snd_compr_runtime *runtime;
  93	enum snd_compr_direction dirn;
  94	int maj = imajor(inode);
  95	int ret;
  96
  97	if ((f->f_flags & O_ACCMODE) == O_WRONLY)
  98		dirn = SND_COMPRESS_PLAYBACK;
  99	else if ((f->f_flags & O_ACCMODE) == O_RDONLY)
 100		dirn = SND_COMPRESS_CAPTURE;
 101	else
 102		return -EINVAL;
 103
 104	if (maj == snd_major)
 105		compr = snd_lookup_minor_data(iminor(inode),
 106					SNDRV_DEVICE_TYPE_COMPRESS);
 107	else
 108		return -EBADFD;
 109
 110	if (compr == NULL) {
 111		pr_err("no device data!!!\n");
 112		return -ENODEV;
 113	}
 114
 115	if (dirn != compr->direction) {
 116		pr_err("this device doesn't support this direction\n");
 117		snd_card_unref(compr->card);
 118		return -EINVAL;
 119	}
 120
 121	data = kzalloc(sizeof(*data), GFP_KERNEL);
 122	if (!data) {
 123		snd_card_unref(compr->card);
 124		return -ENOMEM;
 125	}
 
 
 
 126	data->stream.ops = compr->ops;
 127	data->stream.direction = dirn;
 128	data->stream.private_data = compr->private_data;
 129	data->stream.device = compr;
 130	runtime = kzalloc(sizeof(*runtime), GFP_KERNEL);
 131	if (!runtime) {
 132		kfree(data);
 133		snd_card_unref(compr->card);
 134		return -ENOMEM;
 135	}
 136	runtime->state = SNDRV_PCM_STATE_OPEN;
 137	init_waitqueue_head(&runtime->sleep);
 138	data->stream.runtime = runtime;
 139	f->private_data = (void *)data;
 140	mutex_lock(&compr->lock);
 141	ret = compr->ops->open(&data->stream);
 142	mutex_unlock(&compr->lock);
 143	if (ret) {
 144		kfree(runtime);
 145		kfree(data);
 146	}
 147	snd_card_unref(compr->card);
 148	return ret;
 149}
 150
 151static int snd_compr_free(struct inode *inode, struct file *f)
 152{
 153	struct snd_compr_file *data = f->private_data;
 154	struct snd_compr_runtime *runtime = data->stream.runtime;
 155
 
 
 156	switch (runtime->state) {
 157	case SNDRV_PCM_STATE_RUNNING:
 158	case SNDRV_PCM_STATE_DRAINING:
 159	case SNDRV_PCM_STATE_PAUSED:
 160		data->stream.ops->trigger(&data->stream, SNDRV_PCM_TRIGGER_STOP);
 161		break;
 162	default:
 163		break;
 164	}
 165
 166	data->stream.ops->free(&data->stream);
 167	kfree(data->stream.runtime->buffer);
 
 168	kfree(data->stream.runtime);
 169	kfree(data);
 170	return 0;
 171}
 172
 173static int snd_compr_update_tstamp(struct snd_compr_stream *stream,
 174		struct snd_compr_tstamp *tstamp)
 175{
 176	if (!stream->ops->pointer)
 177		return -ENOTSUPP;
 178	stream->ops->pointer(stream, tstamp);
 179	pr_debug("dsp consumed till %d total %d bytes\n",
 180		tstamp->byte_offset, tstamp->copied_total);
 181	if (stream->direction == SND_COMPRESS_PLAYBACK)
 182		stream->runtime->total_bytes_transferred = tstamp->copied_total;
 183	else
 184		stream->runtime->total_bytes_available = tstamp->copied_total;
 185	return 0;
 186}
 187
 188static size_t snd_compr_calc_avail(struct snd_compr_stream *stream,
 189		struct snd_compr_avail *avail)
 190{
 191	memset(avail, 0, sizeof(*avail));
 192	snd_compr_update_tstamp(stream, &avail->tstamp);
 193	/* Still need to return avail even if tstamp can't be filled in */
 194
 195	if (stream->runtime->total_bytes_available == 0 &&
 196			stream->runtime->state == SNDRV_PCM_STATE_SETUP &&
 197			stream->direction == SND_COMPRESS_PLAYBACK) {
 198		pr_debug("detected init and someone forgot to do a write\n");
 199		return stream->runtime->buffer_size;
 200	}
 201	pr_debug("app wrote %lld, DSP consumed %lld\n",
 202			stream->runtime->total_bytes_available,
 203			stream->runtime->total_bytes_transferred);
 204	if (stream->runtime->total_bytes_available ==
 205				stream->runtime->total_bytes_transferred) {
 206		if (stream->direction == SND_COMPRESS_PLAYBACK) {
 207			pr_debug("both pointers are same, returning full avail\n");
 208			return stream->runtime->buffer_size;
 209		} else {
 210			pr_debug("both pointers are same, returning no avail\n");
 211			return 0;
 212		}
 213	}
 214
 215	avail->avail = stream->runtime->total_bytes_available -
 216			stream->runtime->total_bytes_transferred;
 217	if (stream->direction == SND_COMPRESS_PLAYBACK)
 218		avail->avail = stream->runtime->buffer_size - avail->avail;
 219
 220	pr_debug("ret avail as %lld\n", avail->avail);
 221	return avail->avail;
 222}
 223
 224static inline size_t snd_compr_get_avail(struct snd_compr_stream *stream)
 225{
 226	struct snd_compr_avail avail;
 227
 228	return snd_compr_calc_avail(stream, &avail);
 229}
 230
 231static int
 232snd_compr_ioctl_avail(struct snd_compr_stream *stream, unsigned long arg)
 233{
 234	struct snd_compr_avail ioctl_avail;
 235	size_t avail;
 236
 237	avail = snd_compr_calc_avail(stream, &ioctl_avail);
 238	ioctl_avail.avail = avail;
 239
 
 
 
 
 
 
 
 
 
 240	if (copy_to_user((__u64 __user *)arg,
 241				&ioctl_avail, sizeof(ioctl_avail)))
 242		return -EFAULT;
 243	return 0;
 244}
 245
 246static int snd_compr_write_data(struct snd_compr_stream *stream,
 247	       const char __user *buf, size_t count)
 248{
 249	void *dstn;
 250	size_t copy;
 251	struct snd_compr_runtime *runtime = stream->runtime;
 252	/* 64-bit Modulus */
 253	u64 app_pointer = div64_u64(runtime->total_bytes_available,
 254				    runtime->buffer_size);
 255	app_pointer = runtime->total_bytes_available -
 256		      (app_pointer * runtime->buffer_size);
 257
 258	dstn = runtime->buffer + app_pointer;
 259	pr_debug("copying %ld at %lld\n",
 260			(unsigned long)count, app_pointer);
 261	if (count < runtime->buffer_size - app_pointer) {
 262		if (copy_from_user(dstn, buf, count))
 263			return -EFAULT;
 264	} else {
 265		copy = runtime->buffer_size - app_pointer;
 266		if (copy_from_user(dstn, buf, copy))
 267			return -EFAULT;
 268		if (copy_from_user(runtime->buffer, buf + copy, count - copy))
 269			return -EFAULT;
 270	}
 271	/* if DSP cares, let it know data has been written */
 272	if (stream->ops->ack)
 273		stream->ops->ack(stream, count);
 274	return count;
 275}
 276
 277static ssize_t snd_compr_write(struct file *f, const char __user *buf,
 278		size_t count, loff_t *offset)
 279{
 280	struct snd_compr_file *data = f->private_data;
 281	struct snd_compr_stream *stream;
 282	size_t avail;
 283	int retval;
 284
 285	if (snd_BUG_ON(!data))
 286		return -EFAULT;
 287
 288	stream = &data->stream;
 289	mutex_lock(&stream->device->lock);
 290	/* write is allowed when stream is running or has been steup */
 291	if (stream->runtime->state != SNDRV_PCM_STATE_SETUP &&
 292	    stream->runtime->state != SNDRV_PCM_STATE_PREPARED &&
 293			stream->runtime->state != SNDRV_PCM_STATE_RUNNING) {
 
 
 
 294		mutex_unlock(&stream->device->lock);
 295		return -EBADFD;
 296	}
 297
 298	avail = snd_compr_get_avail(stream);
 299	pr_debug("avail returned %ld\n", (unsigned long)avail);
 300	/* calculate how much we can write to buffer */
 301	if (avail > count)
 302		avail = count;
 303
 304	if (stream->ops->copy) {
 305		char __user* cbuf = (char __user*)buf;
 306		retval = stream->ops->copy(stream, cbuf, avail);
 307	} else {
 308		retval = snd_compr_write_data(stream, buf, avail);
 309	}
 310	if (retval > 0)
 311		stream->runtime->total_bytes_available += retval;
 312
 313	/* while initiating the stream, write should be called before START
 314	 * call, so in setup move state */
 315	if (stream->runtime->state == SNDRV_PCM_STATE_SETUP) {
 316		stream->runtime->state = SNDRV_PCM_STATE_PREPARED;
 317		pr_debug("stream prepared, Houston we are good to go\n");
 318	}
 319
 320	mutex_unlock(&stream->device->lock);
 321	return retval;
 322}
 323
 324
 325static ssize_t snd_compr_read(struct file *f, char __user *buf,
 326		size_t count, loff_t *offset)
 327{
 328	struct snd_compr_file *data = f->private_data;
 329	struct snd_compr_stream *stream;
 330	size_t avail;
 331	int retval;
 332
 333	if (snd_BUG_ON(!data))
 334		return -EFAULT;
 335
 336	stream = &data->stream;
 337	mutex_lock(&stream->device->lock);
 338
 339	/* read is allowed when stream is running, paused, draining and setup
 340	 * (yes setup is state which we transition to after stop, so if user
 341	 * wants to read data after stop we allow that)
 342	 */
 343	switch (stream->runtime->state) {
 344	case SNDRV_PCM_STATE_OPEN:
 345	case SNDRV_PCM_STATE_PREPARED:
 346	case SNDRV_PCM_STATE_XRUN:
 347	case SNDRV_PCM_STATE_SUSPENDED:
 348	case SNDRV_PCM_STATE_DISCONNECTED:
 349		retval = -EBADFD;
 350		goto out;
 
 
 
 351	}
 352
 353	avail = snd_compr_get_avail(stream);
 354	pr_debug("avail returned %ld\n", (unsigned long)avail);
 355	/* calculate how much we can read from buffer */
 356	if (avail > count)
 357		avail = count;
 358
 359	if (stream->ops->copy) {
 360		retval = stream->ops->copy(stream, buf, avail);
 361	} else {
 362		retval = -ENXIO;
 363		goto out;
 364	}
 365	if (retval > 0)
 366		stream->runtime->total_bytes_transferred += retval;
 367
 368out:
 369	mutex_unlock(&stream->device->lock);
 370	return retval;
 371}
 372
 373static int snd_compr_mmap(struct file *f, struct vm_area_struct *vma)
 374{
 375	return -ENXIO;
 376}
 377
 378static inline int snd_compr_get_poll(struct snd_compr_stream *stream)
 379{
 380	if (stream->direction == SND_COMPRESS_PLAYBACK)
 381		return POLLOUT | POLLWRNORM;
 382	else
 383		return POLLIN | POLLRDNORM;
 384}
 385
 386static unsigned int snd_compr_poll(struct file *f, poll_table *wait)
 387{
 388	struct snd_compr_file *data = f->private_data;
 389	struct snd_compr_stream *stream;
 390	size_t avail;
 391	int retval = 0;
 392
 393	if (snd_BUG_ON(!data))
 394		return -EFAULT;
 
 395	stream = &data->stream;
 396	if (snd_BUG_ON(!stream))
 397		return -EFAULT;
 398
 399	mutex_lock(&stream->device->lock);
 400	if (stream->runtime->state == SNDRV_PCM_STATE_OPEN) {
 401		retval = -EBADFD;
 
 
 
 402		goto out;
 
 
 403	}
 
 404	poll_wait(f, &stream->runtime->sleep, wait);
 405
 406	avail = snd_compr_get_avail(stream);
 407	pr_debug("avail is %ld\n", (unsigned long)avail);
 408	/* check if we have at least one fragment to fill */
 409	switch (stream->runtime->state) {
 410	case SNDRV_PCM_STATE_DRAINING:
 411		/* stream has been woken up after drain is complete
 412		 * draining done so set stream state to stopped
 413		 */
 414		retval = snd_compr_get_poll(stream);
 415		stream->runtime->state = SNDRV_PCM_STATE_SETUP;
 416		break;
 417	case SNDRV_PCM_STATE_RUNNING:
 418	case SNDRV_PCM_STATE_PREPARED:
 419	case SNDRV_PCM_STATE_PAUSED:
 420		if (avail >= stream->runtime->fragment_size)
 421			retval = snd_compr_get_poll(stream);
 422		break;
 423	default:
 424		if (stream->direction == SND_COMPRESS_PLAYBACK)
 425			retval = POLLOUT | POLLWRNORM | POLLERR;
 426		else
 427			retval = POLLIN | POLLRDNORM | POLLERR;
 428		break;
 429	}
 430out:
 431	mutex_unlock(&stream->device->lock);
 432	return retval;
 433}
 434
 435static int
 436snd_compr_get_caps(struct snd_compr_stream *stream, unsigned long arg)
 437{
 438	int retval;
 439	struct snd_compr_caps caps;
 440
 441	if (!stream->ops->get_caps)
 442		return -ENXIO;
 443
 444	memset(&caps, 0, sizeof(caps));
 445	retval = stream->ops->get_caps(stream, &caps);
 446	if (retval)
 447		goto out;
 448	if (copy_to_user((void __user *)arg, &caps, sizeof(caps)))
 449		retval = -EFAULT;
 450out:
 451	return retval;
 452}
 453
 454#ifndef COMPR_CODEC_CAPS_OVERFLOW
 455static int
 456snd_compr_get_codec_caps(struct snd_compr_stream *stream, unsigned long arg)
 457{
 458	int retval;
 459	struct snd_compr_codec_caps *caps;
 460
 461	if (!stream->ops->get_codec_caps)
 462		return -ENXIO;
 463
 464	caps = kzalloc(sizeof(*caps), GFP_KERNEL);
 465	if (!caps)
 466		return -ENOMEM;
 467
 468	retval = stream->ops->get_codec_caps(stream, caps);
 469	if (retval)
 470		goto out;
 471	if (copy_to_user((void __user *)arg, caps, sizeof(*caps)))
 472		retval = -EFAULT;
 473
 474out:
 475	kfree(caps);
 476	return retval;
 477}
 478#endif /* !COMPR_CODEC_CAPS_OVERFLOW */
 479
 480/* revisit this with snd_pcm_preallocate_xxx */
 481static int snd_compr_allocate_buffer(struct snd_compr_stream *stream,
 482		struct snd_compr_params *params)
 483{
 484	unsigned int buffer_size;
 485	void *buffer;
 486
 487	buffer_size = params->buffer.fragment_size * params->buffer.fragments;
 488	if (stream->ops->copy) {
 489		buffer = NULL;
 490		/* if copy is defined the driver will be required to copy
 491		 * the data from core
 492		 */
 493	} else {
 494		buffer = kmalloc(buffer_size, GFP_KERNEL);
 
 
 
 
 
 
 
 
 
 
 
 495		if (!buffer)
 496			return -ENOMEM;
 497	}
 498	stream->runtime->fragment_size = params->buffer.fragment_size;
 499	stream->runtime->fragments = params->buffer.fragments;
 500	stream->runtime->buffer = buffer;
 501	stream->runtime->buffer_size = buffer_size;
 502	return 0;
 503}
 504
 505static int snd_compress_check_input(struct snd_compr_params *params)
 506{
 507	/* first let's check the buffer parameter's */
 508	if (params->buffer.fragment_size == 0 ||
 509	    params->buffer.fragments > INT_MAX / params->buffer.fragment_size)
 
 510		return -EINVAL;
 511
 512	/* now codec parameters */
 513	if (params->codec.id == 0 || params->codec.id > SND_AUDIOCODEC_MAX)
 514		return -EINVAL;
 515
 516	if (params->codec.ch_in == 0 || params->codec.ch_out == 0)
 517		return -EINVAL;
 518
 519	return 0;
 520}
 521
 522static int
 523snd_compr_set_params(struct snd_compr_stream *stream, unsigned long arg)
 524{
 525	struct snd_compr_params *params;
 526	int retval;
 527
 528	if (stream->runtime->state == SNDRV_PCM_STATE_OPEN) {
 529		/*
 530		 * we should allow parameter change only when stream has been
 531		 * opened not in other cases
 532		 */
 533		params = kmalloc(sizeof(*params), GFP_KERNEL);
 534		if (!params)
 535			return -ENOMEM;
 536		if (copy_from_user(params, (void __user *)arg, sizeof(*params))) {
 537			retval = -EFAULT;
 538			goto out;
 539		}
 540
 541		retval = snd_compress_check_input(params);
 542		if (retval)
 543			goto out;
 544
 545		retval = snd_compr_allocate_buffer(stream, params);
 546		if (retval) {
 547			retval = -ENOMEM;
 548			goto out;
 549		}
 550
 551		retval = stream->ops->set_params(stream, params);
 552		if (retval)
 553			goto out;
 554
 555		stream->metadata_set = false;
 556		stream->next_track = false;
 557
 558		if (stream->direction == SND_COMPRESS_PLAYBACK)
 559			stream->runtime->state = SNDRV_PCM_STATE_SETUP;
 560		else
 561			stream->runtime->state = SNDRV_PCM_STATE_PREPARED;
 562	} else {
 563		return -EPERM;
 564	}
 565out:
 566	kfree(params);
 567	return retval;
 568}
 569
 570static int
 571snd_compr_get_params(struct snd_compr_stream *stream, unsigned long arg)
 572{
 573	struct snd_codec *params;
 574	int retval;
 575
 576	if (!stream->ops->get_params)
 577		return -EBADFD;
 578
 579	params = kzalloc(sizeof(*params), GFP_KERNEL);
 580	if (!params)
 581		return -ENOMEM;
 582	retval = stream->ops->get_params(stream, params);
 583	if (retval)
 584		goto out;
 585	if (copy_to_user((char __user *)arg, params, sizeof(*params)))
 586		retval = -EFAULT;
 587
 588out:
 589	kfree(params);
 590	return retval;
 591}
 592
 593static int
 594snd_compr_get_metadata(struct snd_compr_stream *stream, unsigned long arg)
 595{
 596	struct snd_compr_metadata metadata;
 597	int retval;
 598
 599	if (!stream->ops->get_metadata)
 600		return -ENXIO;
 601
 602	if (copy_from_user(&metadata, (void __user *)arg, sizeof(metadata)))
 603		return -EFAULT;
 604
 605	retval = stream->ops->get_metadata(stream, &metadata);
 606	if (retval != 0)
 607		return retval;
 608
 609	if (copy_to_user((void __user *)arg, &metadata, sizeof(metadata)))
 610		return -EFAULT;
 611
 612	return 0;
 613}
 614
 615static int
 616snd_compr_set_metadata(struct snd_compr_stream *stream, unsigned long arg)
 617{
 618	struct snd_compr_metadata metadata;
 619	int retval;
 620
 621	if (!stream->ops->set_metadata)
 622		return -ENXIO;
 623	/*
 624	* we should allow parameter change only when stream has been
 625	* opened not in other cases
 626	*/
 627	if (copy_from_user(&metadata, (void __user *)arg, sizeof(metadata)))
 628		return -EFAULT;
 629
 630	retval = stream->ops->set_metadata(stream, &metadata);
 631	stream->metadata_set = true;
 632
 633	return retval;
 634}
 635
 636static inline int
 637snd_compr_tstamp(struct snd_compr_stream *stream, unsigned long arg)
 638{
 639	struct snd_compr_tstamp tstamp = {0};
 640	int ret;
 641
 642	ret = snd_compr_update_tstamp(stream, &tstamp);
 643	if (ret == 0)
 644		ret = copy_to_user((struct snd_compr_tstamp __user *)arg,
 645			&tstamp, sizeof(tstamp)) ? -EFAULT : 0;
 646	return ret;
 647}
 648
 649static int snd_compr_pause(struct snd_compr_stream *stream)
 650{
 651	int retval;
 652
 653	if (stream->runtime->state != SNDRV_PCM_STATE_RUNNING)
 654		return -EPERM;
 655	retval = stream->ops->trigger(stream, SNDRV_PCM_TRIGGER_PAUSE_PUSH);
 656	if (!retval)
 657		stream->runtime->state = SNDRV_PCM_STATE_PAUSED;
 658	return retval;
 659}
 660
 661static int snd_compr_resume(struct snd_compr_stream *stream)
 662{
 663	int retval;
 664
 665	if (stream->runtime->state != SNDRV_PCM_STATE_PAUSED)
 666		return -EPERM;
 667	retval = stream->ops->trigger(stream, SNDRV_PCM_TRIGGER_PAUSE_RELEASE);
 668	if (!retval)
 669		stream->runtime->state = SNDRV_PCM_STATE_RUNNING;
 670	return retval;
 671}
 672
 673static int snd_compr_start(struct snd_compr_stream *stream)
 674{
 675	int retval;
 676
 677	if (stream->runtime->state != SNDRV_PCM_STATE_PREPARED)
 
 
 
 
 
 
 
 678		return -EPERM;
 
 
 679	retval = stream->ops->trigger(stream, SNDRV_PCM_TRIGGER_START);
 680	if (!retval)
 681		stream->runtime->state = SNDRV_PCM_STATE_RUNNING;
 682	return retval;
 683}
 684
 685static int snd_compr_stop(struct snd_compr_stream *stream)
 686{
 687	int retval;
 688
 689	if (stream->runtime->state == SNDRV_PCM_STATE_PREPARED ||
 690			stream->runtime->state == SNDRV_PCM_STATE_SETUP)
 
 
 691		return -EPERM;
 
 
 
 
 692	retval = stream->ops->trigger(stream, SNDRV_PCM_TRIGGER_STOP);
 693	if (!retval) {
 694		snd_compr_drain_notify(stream);
 695		stream->runtime->total_bytes_available = 0;
 696		stream->runtime->total_bytes_transferred = 0;
 697	}
 698	return retval;
 699}
 700
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 701static int snd_compress_wait_for_drain(struct snd_compr_stream *stream)
 702{
 703	int ret;
 704
 705	/*
 706	 * We are called with lock held. So drop the lock while we wait for
 707	 * drain complete notification from the driver
 708	 *
 709	 * It is expected that driver will notify the drain completion and then
 710	 * stream will be moved to SETUP state, even if draining resulted in an
 711	 * error. We can trigger next track after this.
 712	 */
 713	stream->runtime->state = SNDRV_PCM_STATE_DRAINING;
 714	mutex_unlock(&stream->device->lock);
 715
 716	/* we wait for drain to complete here, drain can return when
 717	 * interruption occurred, wait returned error or success.
 718	 * For the first two cases we don't do anything different here and
 719	 * return after waking up
 720	 */
 721
 722	ret = wait_event_interruptible(stream->runtime->sleep,
 723			(stream->runtime->state != SNDRV_PCM_STATE_DRAINING));
 724	if (ret == -ERESTARTSYS)
 725		pr_debug("wait aborted by a signal");
 726	else if (ret)
 727		pr_debug("wait for drain failed with %d\n", ret);
 728
 729
 730	wake_up(&stream->runtime->sleep);
 731	mutex_lock(&stream->device->lock);
 732
 733	return ret;
 734}
 735
 736static int snd_compr_drain(struct snd_compr_stream *stream)
 737{
 738	int retval;
 739
 740	if (stream->runtime->state == SNDRV_PCM_STATE_PREPARED ||
 741			stream->runtime->state == SNDRV_PCM_STATE_SETUP)
 
 
 
 742		return -EPERM;
 
 
 
 
 
 743
 744	retval = stream->ops->trigger(stream, SND_COMPR_TRIGGER_DRAIN);
 745	if (retval) {
 746		pr_debug("SND_COMPR_TRIGGER_DRAIN failed %d\n", retval);
 747		wake_up(&stream->runtime->sleep);
 748		return retval;
 749	}
 750
 751	return snd_compress_wait_for_drain(stream);
 752}
 753
 754static int snd_compr_next_track(struct snd_compr_stream *stream)
 755{
 756	int retval;
 757
 758	/* only a running stream can transition to next track */
 759	if (stream->runtime->state != SNDRV_PCM_STATE_RUNNING)
 760		return -EPERM;
 761
 
 
 
 
 762	/* you can signal next track if this is intended to be a gapless stream
 763	 * and current track metadata is set
 764	 */
 765	if (stream->metadata_set == false)
 766		return -EPERM;
 767
 768	retval = stream->ops->trigger(stream, SND_COMPR_TRIGGER_NEXT_TRACK);
 769	if (retval != 0)
 770		return retval;
 771	stream->metadata_set = false;
 772	stream->next_track = true;
 773	return 0;
 774}
 775
 776static int snd_compr_partial_drain(struct snd_compr_stream *stream)
 777{
 778	int retval;
 779	if (stream->runtime->state == SNDRV_PCM_STATE_PREPARED ||
 780			stream->runtime->state == SNDRV_PCM_STATE_SETUP)
 
 
 
 
 781		return -EPERM;
 
 
 
 
 
 
 
 
 
 
 782	/* stream can be drained only when next track has been signalled */
 783	if (stream->next_track == false)
 784		return -EPERM;
 785
 786	retval = stream->ops->trigger(stream, SND_COMPR_TRIGGER_PARTIAL_DRAIN);
 787	if (retval) {
 788		pr_debug("Partial drain returned failure\n");
 789		wake_up(&stream->runtime->sleep);
 790		return retval;
 791	}
 792
 793	stream->next_track = false;
 794	return snd_compress_wait_for_drain(stream);
 795}
 796
 797static long snd_compr_ioctl(struct file *f, unsigned int cmd, unsigned long arg)
 798{
 799	struct snd_compr_file *data = f->private_data;
 800	struct snd_compr_stream *stream;
 801	int retval = -ENOTTY;
 802
 803	if (snd_BUG_ON(!data))
 804		return -EFAULT;
 
 805	stream = &data->stream;
 806	if (snd_BUG_ON(!stream))
 807		return -EFAULT;
 808	mutex_lock(&stream->device->lock);
 809	switch (_IOC_NR(cmd)) {
 810	case _IOC_NR(SNDRV_COMPRESS_IOCTL_VERSION):
 811		retval = put_user(SNDRV_COMPRESS_VERSION,
 812				(int __user *)arg) ? -EFAULT : 0;
 813		break;
 814	case _IOC_NR(SNDRV_COMPRESS_GET_CAPS):
 815		retval = snd_compr_get_caps(stream, arg);
 816		break;
 817#ifndef COMPR_CODEC_CAPS_OVERFLOW
 818	case _IOC_NR(SNDRV_COMPRESS_GET_CODEC_CAPS):
 819		retval = snd_compr_get_codec_caps(stream, arg);
 820		break;
 821#endif
 822	case _IOC_NR(SNDRV_COMPRESS_SET_PARAMS):
 823		retval = snd_compr_set_params(stream, arg);
 824		break;
 825	case _IOC_NR(SNDRV_COMPRESS_GET_PARAMS):
 826		retval = snd_compr_get_params(stream, arg);
 827		break;
 828	case _IOC_NR(SNDRV_COMPRESS_SET_METADATA):
 829		retval = snd_compr_set_metadata(stream, arg);
 830		break;
 831	case _IOC_NR(SNDRV_COMPRESS_GET_METADATA):
 832		retval = snd_compr_get_metadata(stream, arg);
 833		break;
 834	case _IOC_NR(SNDRV_COMPRESS_TSTAMP):
 835		retval = snd_compr_tstamp(stream, arg);
 836		break;
 837	case _IOC_NR(SNDRV_COMPRESS_AVAIL):
 838		retval = snd_compr_ioctl_avail(stream, arg);
 839		break;
 840	case _IOC_NR(SNDRV_COMPRESS_PAUSE):
 841		retval = snd_compr_pause(stream);
 842		break;
 843	case _IOC_NR(SNDRV_COMPRESS_RESUME):
 844		retval = snd_compr_resume(stream);
 845		break;
 846	case _IOC_NR(SNDRV_COMPRESS_START):
 847		retval = snd_compr_start(stream);
 848		break;
 849	case _IOC_NR(SNDRV_COMPRESS_STOP):
 850		retval = snd_compr_stop(stream);
 851		break;
 852	case _IOC_NR(SNDRV_COMPRESS_DRAIN):
 853		retval = snd_compr_drain(stream);
 854		break;
 855	case _IOC_NR(SNDRV_COMPRESS_PARTIAL_DRAIN):
 856		retval = snd_compr_partial_drain(stream);
 857		break;
 858	case _IOC_NR(SNDRV_COMPRESS_NEXT_TRACK):
 859		retval = snd_compr_next_track(stream);
 860		break;
 861
 862	}
 863	mutex_unlock(&stream->device->lock);
 864	return retval;
 865}
 866
 867/* support of 32bit userspace on 64bit platforms */
 868#ifdef CONFIG_COMPAT
 869static long snd_compr_ioctl_compat(struct file *file, unsigned int cmd,
 870						unsigned long arg)
 871{
 872	return snd_compr_ioctl(file, cmd, (unsigned long)compat_ptr(arg));
 873}
 874#endif
 875
 876static const struct file_operations snd_compr_file_ops = {
 877		.owner =	THIS_MODULE,
 878		.open =		snd_compr_open,
 879		.release =	snd_compr_free,
 880		.write =	snd_compr_write,
 881		.read =		snd_compr_read,
 882		.unlocked_ioctl = snd_compr_ioctl,
 883#ifdef CONFIG_COMPAT
 884		.compat_ioctl = snd_compr_ioctl_compat,
 885#endif
 886		.mmap =		snd_compr_mmap,
 887		.poll =		snd_compr_poll,
 888};
 889
 890static int snd_compress_dev_register(struct snd_device *device)
 891{
 892	int ret = -EINVAL;
 893	char str[16];
 894	struct snd_compr *compr;
 895
 896	if (snd_BUG_ON(!device || !device->device_data))
 897		return -EBADFD;
 898	compr = device->device_data;
 899
 900	pr_debug("reg %s for device %s, direction %d\n", str, compr->name,
 901			compr->direction);
 902	/* register compressed device */
 903	ret = snd_register_device(SNDRV_DEVICE_TYPE_COMPRESS,
 904				  compr->card, compr->device,
 905				  &snd_compr_file_ops, compr, &compr->dev);
 906	if (ret < 0) {
 907		pr_err("snd_register_device failed\n %d", ret);
 908		return ret;
 909	}
 910	return ret;
 911
 912}
 913
 914static int snd_compress_dev_disconnect(struct snd_device *device)
 915{
 916	struct snd_compr *compr;
 917
 918	compr = device->device_data;
 919	snd_unregister_device(&compr->dev);
 920	return 0;
 921}
 922
 923#ifdef CONFIG_SND_VERBOSE_PROCFS
 924static void snd_compress_proc_info_read(struct snd_info_entry *entry,
 925					struct snd_info_buffer *buffer)
 926{
 927	struct snd_compr *compr = (struct snd_compr *)entry->private_data;
 928
 929	snd_iprintf(buffer, "card: %d\n", compr->card->number);
 930	snd_iprintf(buffer, "device: %d\n", compr->device);
 931	snd_iprintf(buffer, "stream: %s\n",
 932			compr->direction == SND_COMPRESS_PLAYBACK
 933				? "PLAYBACK" : "CAPTURE");
 934	snd_iprintf(buffer, "id: %s\n", compr->id);
 935}
 936
 937static int snd_compress_proc_init(struct snd_compr *compr)
 938{
 939	struct snd_info_entry *entry;
 940	char name[16];
 941
 942	sprintf(name, "compr%i", compr->device);
 943	entry = snd_info_create_card_entry(compr->card, name,
 944					   compr->card->proc_root);
 945	if (!entry)
 946		return -ENOMEM;
 947	entry->mode = S_IFDIR | S_IRUGO | S_IXUGO;
 948	if (snd_info_register(entry) < 0) {
 949		snd_info_free_entry(entry);
 950		return -ENOMEM;
 951	}
 952	compr->proc_root = entry;
 953
 954	entry = snd_info_create_card_entry(compr->card, "info",
 955					   compr->proc_root);
 956	if (entry) {
 957		snd_info_set_text_ops(entry, compr,
 958				      snd_compress_proc_info_read);
 959		if (snd_info_register(entry) < 0) {
 960			snd_info_free_entry(entry);
 961			entry = NULL;
 962		}
 963	}
 964	compr->proc_info_entry = entry;
 965
 966	return 0;
 967}
 968
 969static void snd_compress_proc_done(struct snd_compr *compr)
 970{
 971	snd_info_free_entry(compr->proc_info_entry);
 972	compr->proc_info_entry = NULL;
 973	snd_info_free_entry(compr->proc_root);
 974	compr->proc_root = NULL;
 975}
 976
 977static inline void snd_compress_set_id(struct snd_compr *compr, const char *id)
 978{
 979	strlcpy(compr->id, id, sizeof(compr->id));
 980}
 981#else
 982static inline int snd_compress_proc_init(struct snd_compr *compr)
 983{
 984	return 0;
 985}
 986
 987static inline void snd_compress_proc_done(struct snd_compr *compr)
 988{
 989}
 990
 991static inline void snd_compress_set_id(struct snd_compr *compr, const char *id)
 992{
 993}
 994#endif
 995
 996static int snd_compress_dev_free(struct snd_device *device)
 997{
 998	struct snd_compr *compr;
 999
1000	compr = device->device_data;
1001	snd_compress_proc_done(compr);
1002	put_device(&compr->dev);
1003	return 0;
1004}
1005
1006/*
1007 * snd_compress_new: create new compress device
1008 * @card: sound card pointer
1009 * @device: device number
1010 * @dirn: device direction, should be of type enum snd_compr_direction
1011 * @compr: compress device pointer
1012 */
1013int snd_compress_new(struct snd_card *card, int device,
1014			int dirn, const char *id, struct snd_compr *compr)
1015{
1016	static struct snd_device_ops ops = {
1017		.dev_free = snd_compress_dev_free,
1018		.dev_register = snd_compress_dev_register,
1019		.dev_disconnect = snd_compress_dev_disconnect,
1020	};
1021	int ret;
1022
1023	compr->card = card;
1024	compr->device = device;
1025	compr->direction = dirn;
1026
1027	snd_compress_set_id(compr, id);
1028
1029	snd_device_initialize(&compr->dev, card);
1030	dev_set_name(&compr->dev, "comprC%iD%i", card->number, device);
1031
1032	ret = snd_device_new(card, SNDRV_DEV_COMPRESS, compr, &ops);
1033	if (ret == 0)
1034		snd_compress_proc_init(compr);
1035
1036	return ret;
1037}
1038EXPORT_SYMBOL_GPL(snd_compress_new);
1039
1040static int snd_compress_add_device(struct snd_compr *device)
1041{
1042	int ret;
1043
1044	if (!device->card)
1045		return -EINVAL;
1046
1047	/* register the card */
1048	ret = snd_card_register(device->card);
1049	if (ret)
1050		goto out;
1051	return 0;
1052
1053out:
1054	pr_err("failed with %d\n", ret);
1055	return ret;
1056
1057}
1058
1059static int snd_compress_remove_device(struct snd_compr *device)
1060{
1061	return snd_card_free(device->card);
1062}
1063
1064/**
1065 * snd_compress_register - register compressed device
1066 *
1067 * @device: compressed device to register
1068 */
1069int snd_compress_register(struct snd_compr *device)
1070{
1071	int retval;
1072
1073	if (device->name == NULL || device->ops == NULL)
1074		return -EINVAL;
1075
1076	pr_debug("Registering compressed device %s\n", device->name);
1077	if (snd_BUG_ON(!device->ops->open))
1078		return -EINVAL;
1079	if (snd_BUG_ON(!device->ops->free))
1080		return -EINVAL;
1081	if (snd_BUG_ON(!device->ops->set_params))
1082		return -EINVAL;
1083	if (snd_BUG_ON(!device->ops->trigger))
1084		return -EINVAL;
1085
1086	mutex_init(&device->lock);
1087
1088	/* register a compressed card */
1089	mutex_lock(&device_mutex);
1090	retval = snd_compress_add_device(device);
1091	mutex_unlock(&device_mutex);
1092	return retval;
1093}
1094EXPORT_SYMBOL_GPL(snd_compress_register);
1095
1096int snd_compress_deregister(struct snd_compr *device)
1097{
1098	pr_debug("Removing compressed device %s\n", device->name);
1099	mutex_lock(&device_mutex);
1100	snd_compress_remove_device(device);
1101	mutex_unlock(&device_mutex);
1102	return 0;
1103}
1104EXPORT_SYMBOL_GPL(snd_compress_deregister);
1105
1106static int __init snd_compress_init(void)
1107{
1108	return 0;
1109}
1110
1111static void __exit snd_compress_exit(void)
1112{
1113}
1114
1115module_init(snd_compress_init);
1116module_exit(snd_compress_exit);
1117
1118MODULE_DESCRIPTION("ALSA Compressed offload framework");
1119MODULE_AUTHOR("Vinod Koul <vinod.koul@linux.intel.com>");
1120MODULE_LICENSE("GPL v2");