xref: /openbmc/linux/sound/core/compress_offload.c (revision b34e08d5)
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 <sound/core.h>
42 #include <sound/initval.h>
43 #include <sound/compress_params.h>
44 #include <sound/compress_offload.h>
45 #include <sound/compress_driver.h>
46 
47 /* TODO:
48  * - add substream support for multiple devices in case of
49  *	SND_DYNAMIC_MINORS is not used
50  * - Multiple node representation
51  *	driver should be able to register multiple nodes
52  */
53 
54 static DEFINE_MUTEX(device_mutex);
55 
56 struct snd_compr_file {
57 	unsigned long caps;
58 	struct snd_compr_stream stream;
59 };
60 
61 /*
62  * a note on stream states used:
63  * we use follwing states in the compressed core
64  * SNDRV_PCM_STATE_OPEN: When stream has been opened.
65  * SNDRV_PCM_STATE_SETUP: When stream has been initialized. This is done by
66  *	calling SNDRV_COMPRESS_SET_PARAMS. running streams will come to this
67  *	state at stop by calling SNDRV_COMPRESS_STOP, or at end of drain.
68  * SNDRV_PCM_STATE_RUNNING: When stream has been started and is
69  *	decoding/encoding and rendering/capturing data.
70  * SNDRV_PCM_STATE_DRAINING: When stream is draining current data. This is done
71  *	by calling SNDRV_COMPRESS_DRAIN.
72  * SNDRV_PCM_STATE_PAUSED: When stream is paused. This is done by calling
73  *	SNDRV_COMPRESS_PAUSE. It can be stopped or resumed by calling
74  *	SNDRV_COMPRESS_STOP or SNDRV_COMPRESS_RESUME respectively.
75  */
76 static int snd_compr_open(struct inode *inode, struct file *f)
77 {
78 	struct snd_compr *compr;
79 	struct snd_compr_file *data;
80 	struct snd_compr_runtime *runtime;
81 	enum snd_compr_direction dirn;
82 	int maj = imajor(inode);
83 	int ret;
84 
85 	if ((f->f_flags & O_ACCMODE) == O_WRONLY)
86 		dirn = SND_COMPRESS_PLAYBACK;
87 	else if ((f->f_flags & O_ACCMODE) == O_RDONLY)
88 		dirn = SND_COMPRESS_CAPTURE;
89 	else
90 		return -EINVAL;
91 
92 	if (maj == snd_major)
93 		compr = snd_lookup_minor_data(iminor(inode),
94 					SNDRV_DEVICE_TYPE_COMPRESS);
95 	else
96 		return -EBADFD;
97 
98 	if (compr == NULL) {
99 		pr_err("no device data!!!\n");
100 		return -ENODEV;
101 	}
102 
103 	if (dirn != compr->direction) {
104 		pr_err("this device doesn't support this direction\n");
105 		snd_card_unref(compr->card);
106 		return -EINVAL;
107 	}
108 
109 	data = kzalloc(sizeof(*data), GFP_KERNEL);
110 	if (!data) {
111 		snd_card_unref(compr->card);
112 		return -ENOMEM;
113 	}
114 	data->stream.ops = compr->ops;
115 	data->stream.direction = dirn;
116 	data->stream.private_data = compr->private_data;
117 	data->stream.device = compr;
118 	runtime = kzalloc(sizeof(*runtime), GFP_KERNEL);
119 	if (!runtime) {
120 		kfree(data);
121 		snd_card_unref(compr->card);
122 		return -ENOMEM;
123 	}
124 	runtime->state = SNDRV_PCM_STATE_OPEN;
125 	init_waitqueue_head(&runtime->sleep);
126 	data->stream.runtime = runtime;
127 	f->private_data = (void *)data;
128 	mutex_lock(&compr->lock);
129 	ret = compr->ops->open(&data->stream);
130 	mutex_unlock(&compr->lock);
131 	if (ret) {
132 		kfree(runtime);
133 		kfree(data);
134 	}
135 	snd_card_unref(compr->card);
136 	return ret;
137 }
138 
139 static int snd_compr_free(struct inode *inode, struct file *f)
140 {
141 	struct snd_compr_file *data = f->private_data;
142 	struct snd_compr_runtime *runtime = data->stream.runtime;
143 
144 	switch (runtime->state) {
145 	case SNDRV_PCM_STATE_RUNNING:
146 	case SNDRV_PCM_STATE_DRAINING:
147 	case SNDRV_PCM_STATE_PAUSED:
148 		data->stream.ops->trigger(&data->stream, SNDRV_PCM_TRIGGER_STOP);
149 		break;
150 	default:
151 		break;
152 	}
153 
154 	data->stream.ops->free(&data->stream);
155 	kfree(data->stream.runtime->buffer);
156 	kfree(data->stream.runtime);
157 	kfree(data);
158 	return 0;
159 }
160 
161 static int snd_compr_update_tstamp(struct snd_compr_stream *stream,
162 		struct snd_compr_tstamp *tstamp)
163 {
164 	if (!stream->ops->pointer)
165 		return -ENOTSUPP;
166 	stream->ops->pointer(stream, tstamp);
167 	pr_debug("dsp consumed till %d total %d bytes\n",
168 		tstamp->byte_offset, tstamp->copied_total);
169 	if (stream->direction == SND_COMPRESS_PLAYBACK)
170 		stream->runtime->total_bytes_transferred = tstamp->copied_total;
171 	else
172 		stream->runtime->total_bytes_available = tstamp->copied_total;
173 	return 0;
174 }
175 
176 static size_t snd_compr_calc_avail(struct snd_compr_stream *stream,
177 		struct snd_compr_avail *avail)
178 {
179 	memset(avail, 0, sizeof(*avail));
180 	snd_compr_update_tstamp(stream, &avail->tstamp);
181 	/* Still need to return avail even if tstamp can't be filled in */
182 
183 	if (stream->runtime->total_bytes_available == 0 &&
184 			stream->runtime->state == SNDRV_PCM_STATE_SETUP &&
185 			stream->direction == SND_COMPRESS_PLAYBACK) {
186 		pr_debug("detected init and someone forgot to do a write\n");
187 		return stream->runtime->buffer_size;
188 	}
189 	pr_debug("app wrote %lld, DSP consumed %lld\n",
190 			stream->runtime->total_bytes_available,
191 			stream->runtime->total_bytes_transferred);
192 	if (stream->runtime->total_bytes_available ==
193 				stream->runtime->total_bytes_transferred) {
194 		if (stream->direction == SND_COMPRESS_PLAYBACK) {
195 			pr_debug("both pointers are same, returning full avail\n");
196 			return stream->runtime->buffer_size;
197 		} else {
198 			pr_debug("both pointers are same, returning no avail\n");
199 			return 0;
200 		}
201 	}
202 
203 	avail->avail = stream->runtime->total_bytes_available -
204 			stream->runtime->total_bytes_transferred;
205 	if (stream->direction == SND_COMPRESS_PLAYBACK)
206 		avail->avail = stream->runtime->buffer_size - avail->avail;
207 
208 	pr_debug("ret avail as %lld\n", avail->avail);
209 	return avail->avail;
210 }
211 
212 static inline size_t snd_compr_get_avail(struct snd_compr_stream *stream)
213 {
214 	struct snd_compr_avail avail;
215 
216 	return snd_compr_calc_avail(stream, &avail);
217 }
218 
219 static int
220 snd_compr_ioctl_avail(struct snd_compr_stream *stream, unsigned long arg)
221 {
222 	struct snd_compr_avail ioctl_avail;
223 	size_t avail;
224 
225 	avail = snd_compr_calc_avail(stream, &ioctl_avail);
226 	ioctl_avail.avail = avail;
227 
228 	if (copy_to_user((__u64 __user *)arg,
229 				&ioctl_avail, sizeof(ioctl_avail)))
230 		return -EFAULT;
231 	return 0;
232 }
233 
234 static int snd_compr_write_data(struct snd_compr_stream *stream,
235 	       const char __user *buf, size_t count)
236 {
237 	void *dstn;
238 	size_t copy;
239 	struct snd_compr_runtime *runtime = stream->runtime;
240 	/* 64-bit Modulus */
241 	u64 app_pointer = div64_u64(runtime->total_bytes_available,
242 				    runtime->buffer_size);
243 	app_pointer = runtime->total_bytes_available -
244 		      (app_pointer * runtime->buffer_size);
245 
246 	dstn = runtime->buffer + app_pointer;
247 	pr_debug("copying %ld at %lld\n",
248 			(unsigned long)count, app_pointer);
249 	if (count < runtime->buffer_size - app_pointer) {
250 		if (copy_from_user(dstn, buf, count))
251 			return -EFAULT;
252 	} else {
253 		copy = runtime->buffer_size - app_pointer;
254 		if (copy_from_user(dstn, buf, copy))
255 			return -EFAULT;
256 		if (copy_from_user(runtime->buffer, buf + copy, count - copy))
257 			return -EFAULT;
258 	}
259 	/* if DSP cares, let it know data has been written */
260 	if (stream->ops->ack)
261 		stream->ops->ack(stream, count);
262 	return count;
263 }
264 
265 static ssize_t snd_compr_write(struct file *f, const char __user *buf,
266 		size_t count, loff_t *offset)
267 {
268 	struct snd_compr_file *data = f->private_data;
269 	struct snd_compr_stream *stream;
270 	size_t avail;
271 	int retval;
272 
273 	if (snd_BUG_ON(!data))
274 		return -EFAULT;
275 
276 	stream = &data->stream;
277 	mutex_lock(&stream->device->lock);
278 	/* write is allowed when stream is running or has been steup */
279 	if (stream->runtime->state != SNDRV_PCM_STATE_SETUP &&
280 			stream->runtime->state != SNDRV_PCM_STATE_RUNNING) {
281 		mutex_unlock(&stream->device->lock);
282 		return -EBADFD;
283 	}
284 
285 	avail = snd_compr_get_avail(stream);
286 	pr_debug("avail returned %ld\n", (unsigned long)avail);
287 	/* calculate how much we can write to buffer */
288 	if (avail > count)
289 		avail = count;
290 
291 	if (stream->ops->copy) {
292 		char __user* cbuf = (char __user*)buf;
293 		retval = stream->ops->copy(stream, cbuf, avail);
294 	} else {
295 		retval = snd_compr_write_data(stream, buf, avail);
296 	}
297 	if (retval > 0)
298 		stream->runtime->total_bytes_available += retval;
299 
300 	/* while initiating the stream, write should be called before START
301 	 * call, so in setup move state */
302 	if (stream->runtime->state == SNDRV_PCM_STATE_SETUP) {
303 		stream->runtime->state = SNDRV_PCM_STATE_PREPARED;
304 		pr_debug("stream prepared, Houston we are good to go\n");
305 	}
306 
307 	mutex_unlock(&stream->device->lock);
308 	return retval;
309 }
310 
311 
312 static ssize_t snd_compr_read(struct file *f, char __user *buf,
313 		size_t count, loff_t *offset)
314 {
315 	struct snd_compr_file *data = f->private_data;
316 	struct snd_compr_stream *stream;
317 	size_t avail;
318 	int retval;
319 
320 	if (snd_BUG_ON(!data))
321 		return -EFAULT;
322 
323 	stream = &data->stream;
324 	mutex_lock(&stream->device->lock);
325 
326 	/* read is allowed when stream is running, paused, draining and setup
327 	 * (yes setup is state which we transition to after stop, so if user
328 	 * wants to read data after stop we allow that)
329 	 */
330 	switch (stream->runtime->state) {
331 	case SNDRV_PCM_STATE_OPEN:
332 	case SNDRV_PCM_STATE_PREPARED:
333 	case SNDRV_PCM_STATE_XRUN:
334 	case SNDRV_PCM_STATE_SUSPENDED:
335 	case SNDRV_PCM_STATE_DISCONNECTED:
336 		retval = -EBADFD;
337 		goto out;
338 	}
339 
340 	avail = snd_compr_get_avail(stream);
341 	pr_debug("avail returned %ld\n", (unsigned long)avail);
342 	/* calculate how much we can read from buffer */
343 	if (avail > count)
344 		avail = count;
345 
346 	if (stream->ops->copy) {
347 		retval = stream->ops->copy(stream, buf, avail);
348 	} else {
349 		retval = -ENXIO;
350 		goto out;
351 	}
352 	if (retval > 0)
353 		stream->runtime->total_bytes_transferred += retval;
354 
355 out:
356 	mutex_unlock(&stream->device->lock);
357 	return retval;
358 }
359 
360 static int snd_compr_mmap(struct file *f, struct vm_area_struct *vma)
361 {
362 	return -ENXIO;
363 }
364 
365 static inline int snd_compr_get_poll(struct snd_compr_stream *stream)
366 {
367 	if (stream->direction == SND_COMPRESS_PLAYBACK)
368 		return POLLOUT | POLLWRNORM;
369 	else
370 		return POLLIN | POLLRDNORM;
371 }
372 
373 static unsigned int snd_compr_poll(struct file *f, poll_table *wait)
374 {
375 	struct snd_compr_file *data = f->private_data;
376 	struct snd_compr_stream *stream;
377 	size_t avail;
378 	int retval = 0;
379 
380 	if (snd_BUG_ON(!data))
381 		return -EFAULT;
382 	stream = &data->stream;
383 	if (snd_BUG_ON(!stream))
384 		return -EFAULT;
385 
386 	mutex_lock(&stream->device->lock);
387 	if (stream->runtime->state == SNDRV_PCM_STATE_OPEN) {
388 		retval = -EBADFD;
389 		goto out;
390 	}
391 	poll_wait(f, &stream->runtime->sleep, wait);
392 
393 	avail = snd_compr_get_avail(stream);
394 	pr_debug("avail is %ld\n", (unsigned long)avail);
395 	/* check if we have at least one fragment to fill */
396 	switch (stream->runtime->state) {
397 	case SNDRV_PCM_STATE_DRAINING:
398 		/* stream has been woken up after drain is complete
399 		 * draining done so set stream state to stopped
400 		 */
401 		retval = snd_compr_get_poll(stream);
402 		stream->runtime->state = SNDRV_PCM_STATE_SETUP;
403 		break;
404 	case SNDRV_PCM_STATE_RUNNING:
405 	case SNDRV_PCM_STATE_PREPARED:
406 	case SNDRV_PCM_STATE_PAUSED:
407 		if (avail >= stream->runtime->fragment_size)
408 			retval = snd_compr_get_poll(stream);
409 		break;
410 	default:
411 		if (stream->direction == SND_COMPRESS_PLAYBACK)
412 			retval = POLLOUT | POLLWRNORM | POLLERR;
413 		else
414 			retval = POLLIN | POLLRDNORM | POLLERR;
415 		break;
416 	}
417 out:
418 	mutex_unlock(&stream->device->lock);
419 	return retval;
420 }
421 
422 static int
423 snd_compr_get_caps(struct snd_compr_stream *stream, unsigned long arg)
424 {
425 	int retval;
426 	struct snd_compr_caps caps;
427 
428 	if (!stream->ops->get_caps)
429 		return -ENXIO;
430 
431 	memset(&caps, 0, sizeof(caps));
432 	retval = stream->ops->get_caps(stream, &caps);
433 	if (retval)
434 		goto out;
435 	if (copy_to_user((void __user *)arg, &caps, sizeof(caps)))
436 		retval = -EFAULT;
437 out:
438 	return retval;
439 }
440 
441 static int
442 snd_compr_get_codec_caps(struct snd_compr_stream *stream, unsigned long arg)
443 {
444 	int retval;
445 	struct snd_compr_codec_caps *caps;
446 
447 	if (!stream->ops->get_codec_caps)
448 		return -ENXIO;
449 
450 	caps = kzalloc(sizeof(*caps), GFP_KERNEL);
451 	if (!caps)
452 		return -ENOMEM;
453 
454 	retval = stream->ops->get_codec_caps(stream, caps);
455 	if (retval)
456 		goto out;
457 	if (copy_to_user((void __user *)arg, caps, sizeof(*caps)))
458 		retval = -EFAULT;
459 
460 out:
461 	kfree(caps);
462 	return retval;
463 }
464 
465 /* revisit this with snd_pcm_preallocate_xxx */
466 static int snd_compr_allocate_buffer(struct snd_compr_stream *stream,
467 		struct snd_compr_params *params)
468 {
469 	unsigned int buffer_size;
470 	void *buffer;
471 
472 	buffer_size = params->buffer.fragment_size * params->buffer.fragments;
473 	if (stream->ops->copy) {
474 		buffer = NULL;
475 		/* if copy is defined the driver will be required to copy
476 		 * the data from core
477 		 */
478 	} else {
479 		buffer = kmalloc(buffer_size, GFP_KERNEL);
480 		if (!buffer)
481 			return -ENOMEM;
482 	}
483 	stream->runtime->fragment_size = params->buffer.fragment_size;
484 	stream->runtime->fragments = params->buffer.fragments;
485 	stream->runtime->buffer = buffer;
486 	stream->runtime->buffer_size = buffer_size;
487 	return 0;
488 }
489 
490 static int snd_compress_check_input(struct snd_compr_params *params)
491 {
492 	/* first let's check the buffer parameter's */
493 	if (params->buffer.fragment_size == 0 ||
494 			params->buffer.fragments > SIZE_MAX / params->buffer.fragment_size)
495 		return -EINVAL;
496 
497 	/* now codec parameters */
498 	if (params->codec.id == 0 || params->codec.id > SND_AUDIOCODEC_MAX)
499 		return -EINVAL;
500 
501 	if (params->codec.ch_in == 0 || params->codec.ch_out == 0)
502 		return -EINVAL;
503 
504 	return 0;
505 }
506 
507 static int
508 snd_compr_set_params(struct snd_compr_stream *stream, unsigned long arg)
509 {
510 	struct snd_compr_params *params;
511 	int retval;
512 
513 	if (stream->runtime->state == SNDRV_PCM_STATE_OPEN) {
514 		/*
515 		 * we should allow parameter change only when stream has been
516 		 * opened not in other cases
517 		 */
518 		params = kmalloc(sizeof(*params), GFP_KERNEL);
519 		if (!params)
520 			return -ENOMEM;
521 		if (copy_from_user(params, (void __user *)arg, sizeof(*params))) {
522 			retval = -EFAULT;
523 			goto out;
524 		}
525 
526 		retval = snd_compress_check_input(params);
527 		if (retval)
528 			goto out;
529 
530 		retval = snd_compr_allocate_buffer(stream, params);
531 		if (retval) {
532 			retval = -ENOMEM;
533 			goto out;
534 		}
535 
536 		retval = stream->ops->set_params(stream, params);
537 		if (retval)
538 			goto out;
539 
540 		stream->metadata_set = false;
541 		stream->next_track = false;
542 
543 		if (stream->direction == SND_COMPRESS_PLAYBACK)
544 			stream->runtime->state = SNDRV_PCM_STATE_SETUP;
545 		else
546 			stream->runtime->state = SNDRV_PCM_STATE_PREPARED;
547 	} else {
548 		return -EPERM;
549 	}
550 out:
551 	kfree(params);
552 	return retval;
553 }
554 
555 static int
556 snd_compr_get_params(struct snd_compr_stream *stream, unsigned long arg)
557 {
558 	struct snd_codec *params;
559 	int retval;
560 
561 	if (!stream->ops->get_params)
562 		return -EBADFD;
563 
564 	params = kzalloc(sizeof(*params), GFP_KERNEL);
565 	if (!params)
566 		return -ENOMEM;
567 	retval = stream->ops->get_params(stream, params);
568 	if (retval)
569 		goto out;
570 	if (copy_to_user((char __user *)arg, params, sizeof(*params)))
571 		retval = -EFAULT;
572 
573 out:
574 	kfree(params);
575 	return retval;
576 }
577 
578 static int
579 snd_compr_get_metadata(struct snd_compr_stream *stream, unsigned long arg)
580 {
581 	struct snd_compr_metadata metadata;
582 	int retval;
583 
584 	if (!stream->ops->get_metadata)
585 		return -ENXIO;
586 
587 	if (copy_from_user(&metadata, (void __user *)arg, sizeof(metadata)))
588 		return -EFAULT;
589 
590 	retval = stream->ops->get_metadata(stream, &metadata);
591 	if (retval != 0)
592 		return retval;
593 
594 	if (copy_to_user((void __user *)arg, &metadata, sizeof(metadata)))
595 		return -EFAULT;
596 
597 	return 0;
598 }
599 
600 static int
601 snd_compr_set_metadata(struct snd_compr_stream *stream, unsigned long arg)
602 {
603 	struct snd_compr_metadata metadata;
604 	int retval;
605 
606 	if (!stream->ops->set_metadata)
607 		return -ENXIO;
608 	/*
609 	* we should allow parameter change only when stream has been
610 	* opened not in other cases
611 	*/
612 	if (copy_from_user(&metadata, (void __user *)arg, sizeof(metadata)))
613 		return -EFAULT;
614 
615 	retval = stream->ops->set_metadata(stream, &metadata);
616 	stream->metadata_set = true;
617 
618 	return retval;
619 }
620 
621 static inline int
622 snd_compr_tstamp(struct snd_compr_stream *stream, unsigned long arg)
623 {
624 	struct snd_compr_tstamp tstamp = {0};
625 	int ret;
626 
627 	ret = snd_compr_update_tstamp(stream, &tstamp);
628 	if (ret == 0)
629 		ret = copy_to_user((struct snd_compr_tstamp __user *)arg,
630 			&tstamp, sizeof(tstamp)) ? -EFAULT : 0;
631 	return ret;
632 }
633 
634 static int snd_compr_pause(struct snd_compr_stream *stream)
635 {
636 	int retval;
637 
638 	if (stream->runtime->state != SNDRV_PCM_STATE_RUNNING)
639 		return -EPERM;
640 	retval = stream->ops->trigger(stream, SNDRV_PCM_TRIGGER_PAUSE_PUSH);
641 	if (!retval)
642 		stream->runtime->state = SNDRV_PCM_STATE_PAUSED;
643 	return retval;
644 }
645 
646 static int snd_compr_resume(struct snd_compr_stream *stream)
647 {
648 	int retval;
649 
650 	if (stream->runtime->state != SNDRV_PCM_STATE_PAUSED)
651 		return -EPERM;
652 	retval = stream->ops->trigger(stream, SNDRV_PCM_TRIGGER_PAUSE_RELEASE);
653 	if (!retval)
654 		stream->runtime->state = SNDRV_PCM_STATE_RUNNING;
655 	return retval;
656 }
657 
658 static int snd_compr_start(struct snd_compr_stream *stream)
659 {
660 	int retval;
661 
662 	if (stream->runtime->state != SNDRV_PCM_STATE_PREPARED)
663 		return -EPERM;
664 	retval = stream->ops->trigger(stream, SNDRV_PCM_TRIGGER_START);
665 	if (!retval)
666 		stream->runtime->state = SNDRV_PCM_STATE_RUNNING;
667 	return retval;
668 }
669 
670 static int snd_compr_stop(struct snd_compr_stream *stream)
671 {
672 	int retval;
673 
674 	if (stream->runtime->state == SNDRV_PCM_STATE_PREPARED ||
675 			stream->runtime->state == SNDRV_PCM_STATE_SETUP)
676 		return -EPERM;
677 	retval = stream->ops->trigger(stream, SNDRV_PCM_TRIGGER_STOP);
678 	if (!retval) {
679 		snd_compr_drain_notify(stream);
680 		stream->runtime->total_bytes_available = 0;
681 		stream->runtime->total_bytes_transferred = 0;
682 	}
683 	return retval;
684 }
685 
686 static int snd_compress_wait_for_drain(struct snd_compr_stream *stream)
687 {
688 	int ret;
689 
690 	/*
691 	 * We are called with lock held. So drop the lock while we wait for
692 	 * drain complete notfication from the driver
693 	 *
694 	 * It is expected that driver will notify the drain completion and then
695 	 * stream will be moved to SETUP state, even if draining resulted in an
696 	 * error. We can trigger next track after this.
697 	 */
698 	stream->runtime->state = SNDRV_PCM_STATE_DRAINING;
699 	mutex_unlock(&stream->device->lock);
700 
701 	/* we wait for drain to complete here, drain can return when
702 	 * interruption occurred, wait returned error or success.
703 	 * For the first two cases we don't do anything different here and
704 	 * return after waking up
705 	 */
706 
707 	ret = wait_event_interruptible(stream->runtime->sleep,
708 			(stream->runtime->state != SNDRV_PCM_STATE_DRAINING));
709 	if (ret == -ERESTARTSYS)
710 		pr_debug("wait aborted by a signal");
711 	else if (ret)
712 		pr_debug("wait for drain failed with %d\n", ret);
713 
714 
715 	wake_up(&stream->runtime->sleep);
716 	mutex_lock(&stream->device->lock);
717 
718 	return ret;
719 }
720 
721 static int snd_compr_drain(struct snd_compr_stream *stream)
722 {
723 	int retval;
724 
725 	if (stream->runtime->state == SNDRV_PCM_STATE_PREPARED ||
726 			stream->runtime->state == SNDRV_PCM_STATE_SETUP)
727 		return -EPERM;
728 
729 	retval = stream->ops->trigger(stream, SND_COMPR_TRIGGER_DRAIN);
730 	if (retval) {
731 		pr_debug("SND_COMPR_TRIGGER_DRAIN failed %d\n", retval);
732 		wake_up(&stream->runtime->sleep);
733 		return retval;
734 	}
735 
736 	return snd_compress_wait_for_drain(stream);
737 }
738 
739 static int snd_compr_next_track(struct snd_compr_stream *stream)
740 {
741 	int retval;
742 
743 	/* only a running stream can transition to next track */
744 	if (stream->runtime->state != SNDRV_PCM_STATE_RUNNING)
745 		return -EPERM;
746 
747 	/* you can signal next track isf this is intended to be a gapless stream
748 	 * and current track metadata is set
749 	 */
750 	if (stream->metadata_set == false)
751 		return -EPERM;
752 
753 	retval = stream->ops->trigger(stream, SND_COMPR_TRIGGER_NEXT_TRACK);
754 	if (retval != 0)
755 		return retval;
756 	stream->metadata_set = false;
757 	stream->next_track = true;
758 	return 0;
759 }
760 
761 static int snd_compr_partial_drain(struct snd_compr_stream *stream)
762 {
763 	int retval;
764 	if (stream->runtime->state == SNDRV_PCM_STATE_PREPARED ||
765 			stream->runtime->state == SNDRV_PCM_STATE_SETUP)
766 		return -EPERM;
767 	/* stream can be drained only when next track has been signalled */
768 	if (stream->next_track == false)
769 		return -EPERM;
770 
771 	retval = stream->ops->trigger(stream, SND_COMPR_TRIGGER_PARTIAL_DRAIN);
772 	if (retval) {
773 		pr_debug("Partial drain returned failure\n");
774 		wake_up(&stream->runtime->sleep);
775 		return retval;
776 	}
777 
778 	stream->next_track = false;
779 	return snd_compress_wait_for_drain(stream);
780 }
781 
782 static long snd_compr_ioctl(struct file *f, unsigned int cmd, unsigned long arg)
783 {
784 	struct snd_compr_file *data = f->private_data;
785 	struct snd_compr_stream *stream;
786 	int retval = -ENOTTY;
787 
788 	if (snd_BUG_ON(!data))
789 		return -EFAULT;
790 	stream = &data->stream;
791 	if (snd_BUG_ON(!stream))
792 		return -EFAULT;
793 	mutex_lock(&stream->device->lock);
794 	switch (_IOC_NR(cmd)) {
795 	case _IOC_NR(SNDRV_COMPRESS_IOCTL_VERSION):
796 		retval = put_user(SNDRV_COMPRESS_VERSION,
797 				(int __user *)arg) ? -EFAULT : 0;
798 		break;
799 	case _IOC_NR(SNDRV_COMPRESS_GET_CAPS):
800 		retval = snd_compr_get_caps(stream, arg);
801 		break;
802 	case _IOC_NR(SNDRV_COMPRESS_GET_CODEC_CAPS):
803 		retval = snd_compr_get_codec_caps(stream, arg);
804 		break;
805 	case _IOC_NR(SNDRV_COMPRESS_SET_PARAMS):
806 		retval = snd_compr_set_params(stream, arg);
807 		break;
808 	case _IOC_NR(SNDRV_COMPRESS_GET_PARAMS):
809 		retval = snd_compr_get_params(stream, arg);
810 		break;
811 	case _IOC_NR(SNDRV_COMPRESS_SET_METADATA):
812 		retval = snd_compr_set_metadata(stream, arg);
813 		break;
814 	case _IOC_NR(SNDRV_COMPRESS_GET_METADATA):
815 		retval = snd_compr_get_metadata(stream, arg);
816 		break;
817 	case _IOC_NR(SNDRV_COMPRESS_TSTAMP):
818 		retval = snd_compr_tstamp(stream, arg);
819 		break;
820 	case _IOC_NR(SNDRV_COMPRESS_AVAIL):
821 		retval = snd_compr_ioctl_avail(stream, arg);
822 		break;
823 	case _IOC_NR(SNDRV_COMPRESS_PAUSE):
824 		retval = snd_compr_pause(stream);
825 		break;
826 	case _IOC_NR(SNDRV_COMPRESS_RESUME):
827 		retval = snd_compr_resume(stream);
828 		break;
829 	case _IOC_NR(SNDRV_COMPRESS_START):
830 		retval = snd_compr_start(stream);
831 		break;
832 	case _IOC_NR(SNDRV_COMPRESS_STOP):
833 		retval = snd_compr_stop(stream);
834 		break;
835 	case _IOC_NR(SNDRV_COMPRESS_DRAIN):
836 		retval = snd_compr_drain(stream);
837 		break;
838 	case _IOC_NR(SNDRV_COMPRESS_PARTIAL_DRAIN):
839 		retval = snd_compr_partial_drain(stream);
840 		break;
841 	case _IOC_NR(SNDRV_COMPRESS_NEXT_TRACK):
842 		retval = snd_compr_next_track(stream);
843 		break;
844 
845 	}
846 	mutex_unlock(&stream->device->lock);
847 	return retval;
848 }
849 
850 static const struct file_operations snd_compr_file_ops = {
851 		.owner =	THIS_MODULE,
852 		.open =		snd_compr_open,
853 		.release =	snd_compr_free,
854 		.write =	snd_compr_write,
855 		.read =		snd_compr_read,
856 		.unlocked_ioctl = snd_compr_ioctl,
857 		.mmap =		snd_compr_mmap,
858 		.poll =		snd_compr_poll,
859 };
860 
861 static int snd_compress_dev_register(struct snd_device *device)
862 {
863 	int ret = -EINVAL;
864 	char str[16];
865 	struct snd_compr *compr;
866 
867 	if (snd_BUG_ON(!device || !device->device_data))
868 		return -EBADFD;
869 	compr = device->device_data;
870 
871 	sprintf(str, "comprC%iD%i", compr->card->number, compr->device);
872 	pr_debug("reg %s for device %s, direction %d\n", str, compr->name,
873 			compr->direction);
874 	/* register compressed device */
875 	ret = snd_register_device(SNDRV_DEVICE_TYPE_COMPRESS, compr->card,
876 			compr->device, &snd_compr_file_ops, compr, str);
877 	if (ret < 0) {
878 		pr_err("snd_register_device failed\n %d", ret);
879 		return ret;
880 	}
881 	return ret;
882 
883 }
884 
885 static int snd_compress_dev_disconnect(struct snd_device *device)
886 {
887 	struct snd_compr *compr;
888 
889 	compr = device->device_data;
890 	snd_unregister_device(SNDRV_DEVICE_TYPE_COMPRESS, compr->card,
891 		compr->device);
892 	return 0;
893 }
894 
895 /*
896  * snd_compress_new: create new compress device
897  * @card: sound card pointer
898  * @device: device number
899  * @dirn: device direction, should be of type enum snd_compr_direction
900  * @compr: compress device pointer
901  */
902 int snd_compress_new(struct snd_card *card, int device,
903 			int dirn, struct snd_compr *compr)
904 {
905 	static struct snd_device_ops ops = {
906 		.dev_free = NULL,
907 		.dev_register = snd_compress_dev_register,
908 		.dev_disconnect = snd_compress_dev_disconnect,
909 	};
910 
911 	compr->card = card;
912 	compr->device = device;
913 	compr->direction = dirn;
914 	return snd_device_new(card, SNDRV_DEV_COMPRESS, compr, &ops);
915 }
916 EXPORT_SYMBOL_GPL(snd_compress_new);
917 
918 static int snd_compress_add_device(struct snd_compr *device)
919 {
920 	int ret;
921 
922 	if (!device->card)
923 		return -EINVAL;
924 
925 	/* register the card */
926 	ret = snd_card_register(device->card);
927 	if (ret)
928 		goto out;
929 	return 0;
930 
931 out:
932 	pr_err("failed with %d\n", ret);
933 	return ret;
934 
935 }
936 
937 static int snd_compress_remove_device(struct snd_compr *device)
938 {
939 	return snd_card_free(device->card);
940 }
941 
942 /**
943  * snd_compress_register - register compressed device
944  *
945  * @device: compressed device to register
946  */
947 int snd_compress_register(struct snd_compr *device)
948 {
949 	int retval;
950 
951 	if (device->name == NULL || device->dev == NULL || device->ops == NULL)
952 		return -EINVAL;
953 
954 	pr_debug("Registering compressed device %s\n", device->name);
955 	if (snd_BUG_ON(!device->ops->open))
956 		return -EINVAL;
957 	if (snd_BUG_ON(!device->ops->free))
958 		return -EINVAL;
959 	if (snd_BUG_ON(!device->ops->set_params))
960 		return -EINVAL;
961 	if (snd_BUG_ON(!device->ops->trigger))
962 		return -EINVAL;
963 
964 	mutex_init(&device->lock);
965 
966 	/* register a compressed card */
967 	mutex_lock(&device_mutex);
968 	retval = snd_compress_add_device(device);
969 	mutex_unlock(&device_mutex);
970 	return retval;
971 }
972 EXPORT_SYMBOL_GPL(snd_compress_register);
973 
974 int snd_compress_deregister(struct snd_compr *device)
975 {
976 	pr_debug("Removing compressed device %s\n", device->name);
977 	mutex_lock(&device_mutex);
978 	snd_compress_remove_device(device);
979 	mutex_unlock(&device_mutex);
980 	return 0;
981 }
982 EXPORT_SYMBOL_GPL(snd_compress_deregister);
983 
984 static int __init snd_compress_init(void)
985 {
986 	return 0;
987 }
988 
989 static void __exit snd_compress_exit(void)
990 {
991 }
992 
993 module_init(snd_compress_init);
994 module_exit(snd_compress_exit);
995 
996 MODULE_DESCRIPTION("ALSA Compressed offload framework");
997 MODULE_AUTHOR("Vinod Koul <vinod.koul@linux.intel.com>");
998 MODULE_LICENSE("GPL v2");
999