2 * compress_core.c - compress offload core
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 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
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.
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.
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.
22 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
25 #define FORMAT(fmt) "%s: %d: " fmt, __func__, __LINE__
26 #define pr_fmt(fmt) KBUILD_MODNAME ": " FORMAT(fmt)
28 #include <linux/file.h>
30 #include <linux/list.h>
31 #include <linux/math64.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>
49 /* struct snd_compr_codec_caps overflows the ioctl bit size for some
50 * architectures, so we need to disable the relevant ioctls.
52 #if _IOC_SIZEBITS < 14
53 #define COMPR_CODEC_CAPS_OVERFLOW
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
63 static DEFINE_MUTEX(device_mutex);
65 struct snd_compr_file {
67 struct snd_compr_stream stream;
71 * a note on stream states used:
72 * we use follwing 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_RUNNING: When stream has been started and is
78 * decoding/encoding and rendering/capturing data.
79 * SNDRV_PCM_STATE_DRAINING: When stream is draining current data. This is done
80 * by calling SNDRV_COMPRESS_DRAIN.
81 * SNDRV_PCM_STATE_PAUSED: When stream is paused. This is done by calling
82 * SNDRV_COMPRESS_PAUSE. It can be stopped or resumed by calling
83 * SNDRV_COMPRESS_STOP or SNDRV_COMPRESS_RESUME respectively.
85 static int snd_compr_open(struct inode *inode, struct file *f)
87 struct snd_compr *compr;
88 struct snd_compr_file *data;
89 struct snd_compr_runtime *runtime;
90 enum snd_compr_direction dirn;
91 int maj = imajor(inode);
94 if ((f->f_flags & O_ACCMODE) == O_WRONLY)
95 dirn = SND_COMPRESS_PLAYBACK;
96 else if ((f->f_flags & O_ACCMODE) == O_RDONLY)
97 dirn = SND_COMPRESS_CAPTURE;
101 if (maj == snd_major)
102 compr = snd_lookup_minor_data(iminor(inode),
103 SNDRV_DEVICE_TYPE_COMPRESS);
108 pr_err("no device data!!!\n");
112 if (dirn != compr->direction) {
113 pr_err("this device doesn't support this direction\n");
114 snd_card_unref(compr->card);
118 data = kzalloc(sizeof(*data), GFP_KERNEL);
120 snd_card_unref(compr->card);
123 data->stream.ops = compr->ops;
124 data->stream.direction = dirn;
125 data->stream.private_data = compr->private_data;
126 data->stream.device = compr;
127 runtime = kzalloc(sizeof(*runtime), GFP_KERNEL);
130 snd_card_unref(compr->card);
133 runtime->state = SNDRV_PCM_STATE_OPEN;
134 init_waitqueue_head(&runtime->sleep);
135 data->stream.runtime = runtime;
136 f->private_data = (void *)data;
137 mutex_lock(&compr->lock);
138 ret = compr->ops->open(&data->stream);
139 mutex_unlock(&compr->lock);
144 snd_card_unref(compr->card);
148 static int snd_compr_free(struct inode *inode, struct file *f)
150 struct snd_compr_file *data = f->private_data;
151 struct snd_compr_runtime *runtime = data->stream.runtime;
153 switch (runtime->state) {
154 case SNDRV_PCM_STATE_RUNNING:
155 case SNDRV_PCM_STATE_DRAINING:
156 case SNDRV_PCM_STATE_PAUSED:
157 data->stream.ops->trigger(&data->stream, SNDRV_PCM_TRIGGER_STOP);
163 data->stream.ops->free(&data->stream);
164 kfree(data->stream.runtime->buffer);
165 kfree(data->stream.runtime);
170 static int snd_compr_update_tstamp(struct snd_compr_stream *stream,
171 struct snd_compr_tstamp *tstamp)
173 if (!stream->ops->pointer)
175 stream->ops->pointer(stream, tstamp);
176 pr_debug("dsp consumed till %d total %d bytes\n",
177 tstamp->byte_offset, tstamp->copied_total);
178 if (stream->direction == SND_COMPRESS_PLAYBACK)
179 stream->runtime->total_bytes_transferred = tstamp->copied_total;
181 stream->runtime->total_bytes_available = tstamp->copied_total;
185 static size_t snd_compr_calc_avail(struct snd_compr_stream *stream,
186 struct snd_compr_avail *avail)
188 memset(avail, 0, sizeof(*avail));
189 snd_compr_update_tstamp(stream, &avail->tstamp);
190 /* Still need to return avail even if tstamp can't be filled in */
192 if (stream->runtime->total_bytes_available == 0 &&
193 stream->runtime->state == SNDRV_PCM_STATE_SETUP &&
194 stream->direction == SND_COMPRESS_PLAYBACK) {
195 pr_debug("detected init and someone forgot to do a write\n");
196 return stream->runtime->buffer_size;
198 pr_debug("app wrote %lld, DSP consumed %lld\n",
199 stream->runtime->total_bytes_available,
200 stream->runtime->total_bytes_transferred);
201 if (stream->runtime->total_bytes_available ==
202 stream->runtime->total_bytes_transferred) {
203 if (stream->direction == SND_COMPRESS_PLAYBACK) {
204 pr_debug("both pointers are same, returning full avail\n");
205 return stream->runtime->buffer_size;
207 pr_debug("both pointers are same, returning no avail\n");
212 avail->avail = stream->runtime->total_bytes_available -
213 stream->runtime->total_bytes_transferred;
214 if (stream->direction == SND_COMPRESS_PLAYBACK)
215 avail->avail = stream->runtime->buffer_size - avail->avail;
217 pr_debug("ret avail as %lld\n", avail->avail);
221 static inline size_t snd_compr_get_avail(struct snd_compr_stream *stream)
223 struct snd_compr_avail avail;
225 return snd_compr_calc_avail(stream, &avail);
229 snd_compr_ioctl_avail(struct snd_compr_stream *stream, unsigned long arg)
231 struct snd_compr_avail ioctl_avail;
234 avail = snd_compr_calc_avail(stream, &ioctl_avail);
235 ioctl_avail.avail = avail;
237 if (copy_to_user((__u64 __user *)arg,
238 &ioctl_avail, sizeof(ioctl_avail)))
243 static int snd_compr_write_data(struct snd_compr_stream *stream,
244 const char __user *buf, size_t count)
248 struct snd_compr_runtime *runtime = stream->runtime;
250 u64 app_pointer = div64_u64(runtime->total_bytes_available,
251 runtime->buffer_size);
252 app_pointer = runtime->total_bytes_available -
253 (app_pointer * runtime->buffer_size);
255 dstn = runtime->buffer + app_pointer;
256 pr_debug("copying %ld at %lld\n",
257 (unsigned long)count, app_pointer);
258 if (count < runtime->buffer_size - app_pointer) {
259 if (copy_from_user(dstn, buf, count))
262 copy = runtime->buffer_size - app_pointer;
263 if (copy_from_user(dstn, buf, copy))
265 if (copy_from_user(runtime->buffer, buf + copy, count - copy))
268 /* if DSP cares, let it know data has been written */
269 if (stream->ops->ack)
270 stream->ops->ack(stream, count);
274 static ssize_t snd_compr_write(struct file *f, const char __user *buf,
275 size_t count, loff_t *offset)
277 struct snd_compr_file *data = f->private_data;
278 struct snd_compr_stream *stream;
282 if (snd_BUG_ON(!data))
285 stream = &data->stream;
286 mutex_lock(&stream->device->lock);
287 /* write is allowed when stream is running or has been steup */
288 if (stream->runtime->state != SNDRV_PCM_STATE_SETUP &&
289 stream->runtime->state != SNDRV_PCM_STATE_RUNNING) {
290 mutex_unlock(&stream->device->lock);
294 avail = snd_compr_get_avail(stream);
295 pr_debug("avail returned %ld\n", (unsigned long)avail);
296 /* calculate how much we can write to buffer */
300 if (stream->ops->copy) {
301 char __user* cbuf = (char __user*)buf;
302 retval = stream->ops->copy(stream, cbuf, avail);
304 retval = snd_compr_write_data(stream, buf, avail);
307 stream->runtime->total_bytes_available += retval;
309 /* while initiating the stream, write should be called before START
310 * call, so in setup move state */
311 if (stream->runtime->state == SNDRV_PCM_STATE_SETUP) {
312 stream->runtime->state = SNDRV_PCM_STATE_PREPARED;
313 pr_debug("stream prepared, Houston we are good to go\n");
316 mutex_unlock(&stream->device->lock);
321 static ssize_t snd_compr_read(struct file *f, char __user *buf,
322 size_t count, loff_t *offset)
324 struct snd_compr_file *data = f->private_data;
325 struct snd_compr_stream *stream;
329 if (snd_BUG_ON(!data))
332 stream = &data->stream;
333 mutex_lock(&stream->device->lock);
335 /* read is allowed when stream is running, paused, draining and setup
336 * (yes setup is state which we transition to after stop, so if user
337 * wants to read data after stop we allow that)
339 switch (stream->runtime->state) {
340 case SNDRV_PCM_STATE_OPEN:
341 case SNDRV_PCM_STATE_PREPARED:
342 case SNDRV_PCM_STATE_XRUN:
343 case SNDRV_PCM_STATE_SUSPENDED:
344 case SNDRV_PCM_STATE_DISCONNECTED:
349 avail = snd_compr_get_avail(stream);
350 pr_debug("avail returned %ld\n", (unsigned long)avail);
351 /* calculate how much we can read from buffer */
355 if (stream->ops->copy) {
356 retval = stream->ops->copy(stream, buf, avail);
362 stream->runtime->total_bytes_transferred += retval;
365 mutex_unlock(&stream->device->lock);
369 static int snd_compr_mmap(struct file *f, struct vm_area_struct *vma)
374 static inline int snd_compr_get_poll(struct snd_compr_stream *stream)
376 if (stream->direction == SND_COMPRESS_PLAYBACK)
377 return POLLOUT | POLLWRNORM;
379 return POLLIN | POLLRDNORM;
382 static unsigned int snd_compr_poll(struct file *f, poll_table *wait)
384 struct snd_compr_file *data = f->private_data;
385 struct snd_compr_stream *stream;
389 if (snd_BUG_ON(!data))
391 stream = &data->stream;
392 if (snd_BUG_ON(!stream))
395 mutex_lock(&stream->device->lock);
396 if (stream->runtime->state == SNDRV_PCM_STATE_OPEN) {
400 poll_wait(f, &stream->runtime->sleep, wait);
402 avail = snd_compr_get_avail(stream);
403 pr_debug("avail is %ld\n", (unsigned long)avail);
404 /* check if we have at least one fragment to fill */
405 switch (stream->runtime->state) {
406 case SNDRV_PCM_STATE_DRAINING:
407 /* stream has been woken up after drain is complete
408 * draining done so set stream state to stopped
410 retval = snd_compr_get_poll(stream);
411 stream->runtime->state = SNDRV_PCM_STATE_SETUP;
413 case SNDRV_PCM_STATE_RUNNING:
414 case SNDRV_PCM_STATE_PREPARED:
415 case SNDRV_PCM_STATE_PAUSED:
416 if (avail >= stream->runtime->fragment_size)
417 retval = snd_compr_get_poll(stream);
420 if (stream->direction == SND_COMPRESS_PLAYBACK)
421 retval = POLLOUT | POLLWRNORM | POLLERR;
423 retval = POLLIN | POLLRDNORM | POLLERR;
427 mutex_unlock(&stream->device->lock);
432 snd_compr_get_caps(struct snd_compr_stream *stream, unsigned long arg)
435 struct snd_compr_caps caps;
437 if (!stream->ops->get_caps)
440 memset(&caps, 0, sizeof(caps));
441 retval = stream->ops->get_caps(stream, &caps);
444 if (copy_to_user((void __user *)arg, &caps, sizeof(caps)))
450 #ifndef COMPR_CODEC_CAPS_OVERFLOW
452 snd_compr_get_codec_caps(struct snd_compr_stream *stream, unsigned long arg)
455 struct snd_compr_codec_caps *caps;
457 if (!stream->ops->get_codec_caps)
460 caps = kzalloc(sizeof(*caps), GFP_KERNEL);
464 retval = stream->ops->get_codec_caps(stream, caps);
467 if (copy_to_user((void __user *)arg, caps, sizeof(*caps)))
474 #endif /* !COMPR_CODEC_CAPS_OVERFLOW */
476 /* revisit this with snd_pcm_preallocate_xxx */
477 static int snd_compr_allocate_buffer(struct snd_compr_stream *stream,
478 struct snd_compr_params *params)
480 unsigned int buffer_size;
483 buffer_size = params->buffer.fragment_size * params->buffer.fragments;
484 if (stream->ops->copy) {
486 /* if copy is defined the driver will be required to copy
490 buffer = kmalloc(buffer_size, GFP_KERNEL);
494 stream->runtime->fragment_size = params->buffer.fragment_size;
495 stream->runtime->fragments = params->buffer.fragments;
496 stream->runtime->buffer = buffer;
497 stream->runtime->buffer_size = buffer_size;
501 static int snd_compress_check_input(struct snd_compr_params *params)
503 /* first let's check the buffer parameter's */
504 if (params->buffer.fragment_size == 0 ||
505 params->buffer.fragments > INT_MAX / params->buffer.fragment_size)
508 /* now codec parameters */
509 if (params->codec.id == 0 || params->codec.id > SND_AUDIOCODEC_MAX)
512 if (params->codec.ch_in == 0 || params->codec.ch_out == 0)
519 snd_compr_set_params(struct snd_compr_stream *stream, unsigned long arg)
521 struct snd_compr_params *params;
524 if (stream->runtime->state == SNDRV_PCM_STATE_OPEN) {
526 * we should allow parameter change only when stream has been
527 * opened not in other cases
529 params = kmalloc(sizeof(*params), GFP_KERNEL);
532 if (copy_from_user(params, (void __user *)arg, sizeof(*params))) {
537 retval = snd_compress_check_input(params);
541 retval = snd_compr_allocate_buffer(stream, params);
547 retval = stream->ops->set_params(stream, params);
551 stream->metadata_set = false;
552 stream->next_track = false;
554 if (stream->direction == SND_COMPRESS_PLAYBACK)
555 stream->runtime->state = SNDRV_PCM_STATE_SETUP;
557 stream->runtime->state = SNDRV_PCM_STATE_PREPARED;
567 snd_compr_get_params(struct snd_compr_stream *stream, unsigned long arg)
569 struct snd_codec *params;
572 if (!stream->ops->get_params)
575 params = kzalloc(sizeof(*params), GFP_KERNEL);
578 retval = stream->ops->get_params(stream, params);
581 if (copy_to_user((char __user *)arg, params, sizeof(*params)))
590 snd_compr_get_metadata(struct snd_compr_stream *stream, unsigned long arg)
592 struct snd_compr_metadata metadata;
595 if (!stream->ops->get_metadata)
598 if (copy_from_user(&metadata, (void __user *)arg, sizeof(metadata)))
601 retval = stream->ops->get_metadata(stream, &metadata);
605 if (copy_to_user((void __user *)arg, &metadata, sizeof(metadata)))
612 snd_compr_set_metadata(struct snd_compr_stream *stream, unsigned long arg)
614 struct snd_compr_metadata metadata;
617 if (!stream->ops->set_metadata)
620 * we should allow parameter change only when stream has been
621 * opened not in other cases
623 if (copy_from_user(&metadata, (void __user *)arg, sizeof(metadata)))
626 retval = stream->ops->set_metadata(stream, &metadata);
627 stream->metadata_set = true;
633 snd_compr_tstamp(struct snd_compr_stream *stream, unsigned long arg)
635 struct snd_compr_tstamp tstamp = {0};
638 ret = snd_compr_update_tstamp(stream, &tstamp);
640 ret = copy_to_user((struct snd_compr_tstamp __user *)arg,
641 &tstamp, sizeof(tstamp)) ? -EFAULT : 0;
645 static int snd_compr_pause(struct snd_compr_stream *stream)
649 if (stream->runtime->state != SNDRV_PCM_STATE_RUNNING)
651 retval = stream->ops->trigger(stream, SNDRV_PCM_TRIGGER_PAUSE_PUSH);
653 stream->runtime->state = SNDRV_PCM_STATE_PAUSED;
657 static int snd_compr_resume(struct snd_compr_stream *stream)
661 if (stream->runtime->state != SNDRV_PCM_STATE_PAUSED)
663 retval = stream->ops->trigger(stream, SNDRV_PCM_TRIGGER_PAUSE_RELEASE);
665 stream->runtime->state = SNDRV_PCM_STATE_RUNNING;
669 static int snd_compr_start(struct snd_compr_stream *stream)
673 if (stream->runtime->state != SNDRV_PCM_STATE_PREPARED)
675 retval = stream->ops->trigger(stream, SNDRV_PCM_TRIGGER_START);
677 stream->runtime->state = SNDRV_PCM_STATE_RUNNING;
681 static int snd_compr_stop(struct snd_compr_stream *stream)
685 if (stream->runtime->state == SNDRV_PCM_STATE_PREPARED ||
686 stream->runtime->state == SNDRV_PCM_STATE_SETUP)
688 retval = stream->ops->trigger(stream, SNDRV_PCM_TRIGGER_STOP);
690 snd_compr_drain_notify(stream);
691 stream->runtime->total_bytes_available = 0;
692 stream->runtime->total_bytes_transferred = 0;
697 static int snd_compress_wait_for_drain(struct snd_compr_stream *stream)
702 * We are called with lock held. So drop the lock while we wait for
703 * drain complete notfication from the driver
705 * It is expected that driver will notify the drain completion and then
706 * stream will be moved to SETUP state, even if draining resulted in an
707 * error. We can trigger next track after this.
709 stream->runtime->state = SNDRV_PCM_STATE_DRAINING;
710 mutex_unlock(&stream->device->lock);
712 /* we wait for drain to complete here, drain can return when
713 * interruption occurred, wait returned error or success.
714 * For the first two cases we don't do anything different here and
715 * return after waking up
718 ret = wait_event_interruptible(stream->runtime->sleep,
719 (stream->runtime->state != SNDRV_PCM_STATE_DRAINING));
720 if (ret == -ERESTARTSYS)
721 pr_debug("wait aborted by a signal");
723 pr_debug("wait for drain failed with %d\n", ret);
726 wake_up(&stream->runtime->sleep);
727 mutex_lock(&stream->device->lock);
732 static int snd_compr_drain(struct snd_compr_stream *stream)
736 if (stream->runtime->state == SNDRV_PCM_STATE_PREPARED ||
737 stream->runtime->state == SNDRV_PCM_STATE_SETUP)
740 retval = stream->ops->trigger(stream, SND_COMPR_TRIGGER_DRAIN);
742 pr_debug("SND_COMPR_TRIGGER_DRAIN failed %d\n", retval);
743 wake_up(&stream->runtime->sleep);
747 return snd_compress_wait_for_drain(stream);
750 static int snd_compr_next_track(struct snd_compr_stream *stream)
754 /* only a running stream can transition to next track */
755 if (stream->runtime->state != SNDRV_PCM_STATE_RUNNING)
758 /* you can signal next track isf this is intended to be a gapless stream
759 * and current track metadata is set
761 if (stream->metadata_set == false)
764 retval = stream->ops->trigger(stream, SND_COMPR_TRIGGER_NEXT_TRACK);
767 stream->metadata_set = false;
768 stream->next_track = true;
772 static int snd_compr_partial_drain(struct snd_compr_stream *stream)
775 if (stream->runtime->state == SNDRV_PCM_STATE_PREPARED ||
776 stream->runtime->state == SNDRV_PCM_STATE_SETUP)
778 /* stream can be drained only when next track has been signalled */
779 if (stream->next_track == false)
782 retval = stream->ops->trigger(stream, SND_COMPR_TRIGGER_PARTIAL_DRAIN);
784 pr_debug("Partial drain returned failure\n");
785 wake_up(&stream->runtime->sleep);
789 stream->next_track = false;
790 return snd_compress_wait_for_drain(stream);
793 static long snd_compr_ioctl(struct file *f, unsigned int cmd, unsigned long arg)
795 struct snd_compr_file *data = f->private_data;
796 struct snd_compr_stream *stream;
797 int retval = -ENOTTY;
799 if (snd_BUG_ON(!data))
801 stream = &data->stream;
802 if (snd_BUG_ON(!stream))
804 mutex_lock(&stream->device->lock);
805 switch (_IOC_NR(cmd)) {
806 case _IOC_NR(SNDRV_COMPRESS_IOCTL_VERSION):
807 retval = put_user(SNDRV_COMPRESS_VERSION,
808 (int __user *)arg) ? -EFAULT : 0;
810 case _IOC_NR(SNDRV_COMPRESS_GET_CAPS):
811 retval = snd_compr_get_caps(stream, arg);
813 #ifndef COMPR_CODEC_CAPS_OVERFLOW
814 case _IOC_NR(SNDRV_COMPRESS_GET_CODEC_CAPS):
815 retval = snd_compr_get_codec_caps(stream, arg);
818 case _IOC_NR(SNDRV_COMPRESS_SET_PARAMS):
819 retval = snd_compr_set_params(stream, arg);
821 case _IOC_NR(SNDRV_COMPRESS_GET_PARAMS):
822 retval = snd_compr_get_params(stream, arg);
824 case _IOC_NR(SNDRV_COMPRESS_SET_METADATA):
825 retval = snd_compr_set_metadata(stream, arg);
827 case _IOC_NR(SNDRV_COMPRESS_GET_METADATA):
828 retval = snd_compr_get_metadata(stream, arg);
830 case _IOC_NR(SNDRV_COMPRESS_TSTAMP):
831 retval = snd_compr_tstamp(stream, arg);
833 case _IOC_NR(SNDRV_COMPRESS_AVAIL):
834 retval = snd_compr_ioctl_avail(stream, arg);
836 case _IOC_NR(SNDRV_COMPRESS_PAUSE):
837 retval = snd_compr_pause(stream);
839 case _IOC_NR(SNDRV_COMPRESS_RESUME):
840 retval = snd_compr_resume(stream);
842 case _IOC_NR(SNDRV_COMPRESS_START):
843 retval = snd_compr_start(stream);
845 case _IOC_NR(SNDRV_COMPRESS_STOP):
846 retval = snd_compr_stop(stream);
848 case _IOC_NR(SNDRV_COMPRESS_DRAIN):
849 retval = snd_compr_drain(stream);
851 case _IOC_NR(SNDRV_COMPRESS_PARTIAL_DRAIN):
852 retval = snd_compr_partial_drain(stream);
854 case _IOC_NR(SNDRV_COMPRESS_NEXT_TRACK):
855 retval = snd_compr_next_track(stream);
859 mutex_unlock(&stream->device->lock);
863 /* support of 32bit userspace on 64bit platforms */
865 static long snd_compr_ioctl_compat(struct file *file, unsigned int cmd,
868 return snd_compr_ioctl(file, cmd, (unsigned long)compat_ptr(arg));
872 static const struct file_operations snd_compr_file_ops = {
873 .owner = THIS_MODULE,
874 .open = snd_compr_open,
875 .release = snd_compr_free,
876 .write = snd_compr_write,
877 .read = snd_compr_read,
878 .unlocked_ioctl = snd_compr_ioctl,
880 .compat_ioctl = snd_compr_ioctl_compat,
882 .mmap = snd_compr_mmap,
883 .poll = snd_compr_poll,
886 static int snd_compress_dev_register(struct snd_device *device)
890 struct snd_compr *compr;
892 if (snd_BUG_ON(!device || !device->device_data))
894 compr = device->device_data;
896 pr_debug("reg %s for device %s, direction %d\n", str, compr->name,
898 /* register compressed device */
899 ret = snd_register_device(SNDRV_DEVICE_TYPE_COMPRESS,
900 compr->card, compr->device,
901 &snd_compr_file_ops, compr, &compr->dev);
903 pr_err("snd_register_device failed\n %d", ret);
910 static int snd_compress_dev_disconnect(struct snd_device *device)
912 struct snd_compr *compr;
914 compr = device->device_data;
915 snd_unregister_device(&compr->dev);
919 #ifdef CONFIG_SND_VERBOSE_PROCFS
920 static void snd_compress_proc_info_read(struct snd_info_entry *entry,
921 struct snd_info_buffer *buffer)
923 struct snd_compr *compr = (struct snd_compr *)entry->private_data;
925 snd_iprintf(buffer, "card: %d\n", compr->card->number);
926 snd_iprintf(buffer, "device: %d\n", compr->device);
927 snd_iprintf(buffer, "stream: %s\n",
928 compr->direction == SND_COMPRESS_PLAYBACK
929 ? "PLAYBACK" : "CAPTURE");
930 snd_iprintf(buffer, "id: %s\n", compr->id);
933 static int snd_compress_proc_init(struct snd_compr *compr)
935 struct snd_info_entry *entry;
938 sprintf(name, "compr%i", compr->device);
939 entry = snd_info_create_card_entry(compr->card, name,
940 compr->card->proc_root);
943 entry->mode = S_IFDIR | S_IRUGO | S_IXUGO;
944 if (snd_info_register(entry) < 0) {
945 snd_info_free_entry(entry);
948 compr->proc_root = entry;
950 entry = snd_info_create_card_entry(compr->card, "info",
953 snd_info_set_text_ops(entry, compr,
954 snd_compress_proc_info_read);
955 if (snd_info_register(entry) < 0) {
956 snd_info_free_entry(entry);
960 compr->proc_info_entry = entry;
965 static void snd_compress_proc_done(struct snd_compr *compr)
967 snd_info_free_entry(compr->proc_info_entry);
968 compr->proc_info_entry = NULL;
969 snd_info_free_entry(compr->proc_root);
970 compr->proc_root = NULL;
973 static inline void snd_compress_set_id(struct snd_compr *compr, const char *id)
975 strlcpy(compr->id, id, sizeof(compr->id));
978 static inline int snd_compress_proc_init(struct snd_compr *compr)
983 static inline void snd_compress_proc_done(struct snd_compr *compr)
987 static inline void snd_compress_set_id(struct snd_compr *compr, const char *id)
992 static int snd_compress_dev_free(struct snd_device *device)
994 struct snd_compr *compr;
996 compr = device->device_data;
997 snd_compress_proc_done(compr);
998 put_device(&compr->dev);
1003 * snd_compress_new: create new compress device
1004 * @card: sound card pointer
1005 * @device: device number
1006 * @dirn: device direction, should be of type enum snd_compr_direction
1007 * @compr: compress device pointer
1009 int snd_compress_new(struct snd_card *card, int device,
1010 int dirn, const char *id, struct snd_compr *compr)
1012 static struct snd_device_ops ops = {
1013 .dev_free = snd_compress_dev_free,
1014 .dev_register = snd_compress_dev_register,
1015 .dev_disconnect = snd_compress_dev_disconnect,
1020 compr->device = device;
1021 compr->direction = dirn;
1023 snd_compress_set_id(compr, id);
1025 snd_device_initialize(&compr->dev, card);
1026 dev_set_name(&compr->dev, "comprC%iD%i", card->number, device);
1028 ret = snd_device_new(card, SNDRV_DEV_COMPRESS, compr, &ops);
1030 snd_compress_proc_init(compr);
1034 EXPORT_SYMBOL_GPL(snd_compress_new);
1036 static int snd_compress_add_device(struct snd_compr *device)
1043 /* register the card */
1044 ret = snd_card_register(device->card);
1050 pr_err("failed with %d\n", ret);
1055 static int snd_compress_remove_device(struct snd_compr *device)
1057 return snd_card_free(device->card);
1061 * snd_compress_register - register compressed device
1063 * @device: compressed device to register
1065 int snd_compress_register(struct snd_compr *device)
1069 if (device->name == NULL || device->ops == NULL)
1072 pr_debug("Registering compressed device %s\n", device->name);
1073 if (snd_BUG_ON(!device->ops->open))
1075 if (snd_BUG_ON(!device->ops->free))
1077 if (snd_BUG_ON(!device->ops->set_params))
1079 if (snd_BUG_ON(!device->ops->trigger))
1082 mutex_init(&device->lock);
1084 /* register a compressed card */
1085 mutex_lock(&device_mutex);
1086 retval = snd_compress_add_device(device);
1087 mutex_unlock(&device_mutex);
1090 EXPORT_SYMBOL_GPL(snd_compress_register);
1092 int snd_compress_deregister(struct snd_compr *device)
1094 pr_debug("Removing compressed device %s\n", device->name);
1095 mutex_lock(&device_mutex);
1096 snd_compress_remove_device(device);
1097 mutex_unlock(&device_mutex);
1100 EXPORT_SYMBOL_GPL(snd_compress_deregister);
1102 static int __init snd_compress_init(void)
1107 static void __exit snd_compress_exit(void)
1111 module_init(snd_compress_init);
1112 module_exit(snd_compress_exit);
1114 MODULE_DESCRIPTION("ALSA Compressed offload framework");
1115 MODULE_AUTHOR("Vinod Koul <vinod.koul@linux.intel.com>");
1116 MODULE_LICENSE("GPL v2");