2 * soc-compress.c -- ALSA SoC Compress
4 * Copyright (C) 2012 Intel Corp.
6 * Authors: Namarta Kohli <namartax.kohli@intel.com>
7 * Ramesh Babu K V <ramesh.babu@linux.intel.com>
8 * Vinod Koul <vinod.koul@linux.intel.com>
10 * This program is free software; you can redistribute it and/or modify it
11 * under the terms of the GNU General Public License as published by the
12 * Free Software Foundation; either version 2 of the License, or (at your
13 * option) any later version.
17 #include <linux/kernel.h>
18 #include <linux/init.h>
19 #include <linux/delay.h>
20 #include <linux/slab.h>
21 #include <linux/workqueue.h>
22 #include <sound/core.h>
23 #include <sound/compress_params.h>
24 #include <sound/compress_driver.h>
25 #include <sound/soc.h>
26 #include <sound/initval.h>
27 #include <sound/soc-dpcm.h>
29 static int soc_compr_open(struct snd_compr_stream *cstream)
31 struct snd_soc_pcm_runtime *rtd = cstream->private_data;
32 struct snd_soc_platform *platform = rtd->platform;
35 mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
37 if (platform->driver->compr_ops && platform->driver->compr_ops->open) {
38 ret = platform->driver->compr_ops->open(cstream);
40 pr_err("compress asoc: can't open platform %s\n",
41 platform->component.name);
46 if (rtd->dai_link->compr_ops && rtd->dai_link->compr_ops->startup) {
47 ret = rtd->dai_link->compr_ops->startup(cstream);
49 pr_err("compress asoc: %s startup failed\n", rtd->dai_link->name);
54 snd_soc_runtime_activate(rtd, cstream->direction);
56 mutex_unlock(&rtd->pcm_mutex);
61 if (platform->driver->compr_ops && platform->driver->compr_ops->free)
62 platform->driver->compr_ops->free(cstream);
64 mutex_unlock(&rtd->pcm_mutex);
68 static int soc_compr_open_fe(struct snd_compr_stream *cstream)
70 struct snd_soc_pcm_runtime *fe = cstream->private_data;
71 struct snd_pcm_substream *fe_substream = fe->pcm->streams[0].substream;
72 struct snd_soc_platform *platform = fe->platform;
73 struct snd_soc_dpcm *dpcm;
74 struct snd_soc_dapm_widget_list *list;
78 if (cstream->direction == SND_COMPRESS_PLAYBACK)
79 stream = SNDRV_PCM_STREAM_PLAYBACK;
81 stream = SNDRV_PCM_STREAM_CAPTURE;
83 mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME);
85 if (platform->driver->compr_ops && platform->driver->compr_ops->open) {
86 ret = platform->driver->compr_ops->open(cstream);
88 pr_err("compress asoc: can't open platform %s\n",
89 platform->component.name);
94 if (fe->dai_link->compr_ops && fe->dai_link->compr_ops->startup) {
95 ret = fe->dai_link->compr_ops->startup(cstream);
97 pr_err("compress asoc: %s startup failed\n", fe->dai_link->name);
102 fe->dpcm[stream].runtime = fe_substream->runtime;
104 ret = dpcm_path_get(fe, stream, &list);
106 mutex_unlock(&fe->card->mutex);
108 } else if (ret == 0) {
109 dev_dbg(fe->dev, "ASoC: %s no valid %s route\n",
110 fe->dai_link->name, stream ? "capture" : "playback");
113 /* calculate valid and active FE <-> BE dpcms */
114 dpcm_process_paths(fe, stream, &list, 1);
116 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE;
118 ret = dpcm_be_dai_startup(fe, stream);
120 /* clean up all links */
121 list_for_each_entry(dpcm, &fe->dpcm[stream].be_clients, list_be)
122 dpcm->state = SND_SOC_DPCM_LINK_STATE_FREE;
124 dpcm_be_disconnect(fe, stream);
125 fe->dpcm[stream].runtime = NULL;
129 dpcm_clear_pending_state(fe, stream);
130 dpcm_path_put(&list);
132 fe->dpcm[stream].state = SND_SOC_DPCM_STATE_OPEN;
133 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO;
135 snd_soc_runtime_activate(fe, stream);
137 mutex_unlock(&fe->card->mutex);
142 if (fe->dai_link->compr_ops && fe->dai_link->compr_ops->shutdown)
143 fe->dai_link->compr_ops->shutdown(cstream);
145 if (platform->driver->compr_ops && platform->driver->compr_ops->free)
146 platform->driver->compr_ops->free(cstream);
148 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO;
149 mutex_unlock(&fe->card->mutex);
154 * Power down the audio subsystem pmdown_time msecs after close is called.
155 * This is to ensure there are no pops or clicks in between any music tracks
156 * due to DAPM power cycling.
158 static void close_delayed_work(struct work_struct *work)
160 struct snd_soc_pcm_runtime *rtd =
161 container_of(work, struct snd_soc_pcm_runtime, delayed_work.work);
162 struct snd_soc_dai *codec_dai = rtd->codec_dai;
164 mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
166 dev_dbg(rtd->dev, "ASoC: pop wq checking: %s status: %s waiting: %s\n",
167 codec_dai->driver->playback.stream_name,
168 codec_dai->playback_active ? "active" : "inactive",
169 rtd->pop_wait ? "yes" : "no");
171 /* are we waiting on this codec DAI stream */
172 if (rtd->pop_wait == 1) {
174 snd_soc_dapm_stream_event(rtd, SNDRV_PCM_STREAM_PLAYBACK,
175 SND_SOC_DAPM_STREAM_STOP);
178 mutex_unlock(&rtd->pcm_mutex);
181 static int soc_compr_free(struct snd_compr_stream *cstream)
183 struct snd_soc_pcm_runtime *rtd = cstream->private_data;
184 struct snd_soc_platform *platform = rtd->platform;
185 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
186 struct snd_soc_dai *codec_dai = rtd->codec_dai;
189 mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
191 if (cstream->direction == SND_COMPRESS_PLAYBACK)
192 stream = SNDRV_PCM_STREAM_PLAYBACK;
194 stream = SNDRV_PCM_STREAM_CAPTURE;
196 snd_soc_runtime_deactivate(rtd, stream);
198 snd_soc_dai_digital_mute(codec_dai, 1, cstream->direction);
200 if (!cpu_dai->active)
203 if (!codec_dai->active)
207 if (rtd->dai_link->compr_ops && rtd->dai_link->compr_ops->shutdown)
208 rtd->dai_link->compr_ops->shutdown(cstream);
210 if (platform->driver->compr_ops && platform->driver->compr_ops->free)
211 platform->driver->compr_ops->free(cstream);
213 if (cstream->direction == SND_COMPRESS_PLAYBACK) {
214 if (snd_soc_runtime_ignore_pmdown_time(rtd)) {
215 snd_soc_dapm_stream_event(rtd,
216 SNDRV_PCM_STREAM_PLAYBACK,
217 SND_SOC_DAPM_STREAM_STOP);
220 queue_delayed_work(system_power_efficient_wq,
222 msecs_to_jiffies(rtd->pmdown_time));
225 /* capture streams can be powered down now */
226 snd_soc_dapm_stream_event(rtd,
227 SNDRV_PCM_STREAM_CAPTURE,
228 SND_SOC_DAPM_STREAM_STOP);
231 mutex_unlock(&rtd->pcm_mutex);
235 static int soc_compr_free_fe(struct snd_compr_stream *cstream)
237 struct snd_soc_pcm_runtime *fe = cstream->private_data;
238 struct snd_soc_platform *platform = fe->platform;
239 struct snd_soc_dpcm *dpcm;
242 mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME);
244 if (cstream->direction == SND_COMPRESS_PLAYBACK)
245 stream = SNDRV_PCM_STREAM_PLAYBACK;
247 stream = SNDRV_PCM_STREAM_CAPTURE;
249 snd_soc_runtime_deactivate(fe, stream);
251 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE;
253 ret = dpcm_be_dai_hw_free(fe, stream);
255 dev_err(fe->dev, "compressed hw_free failed %d\n", ret);
257 ret = dpcm_be_dai_shutdown(fe, stream);
259 /* mark FE's links ready to prune */
260 list_for_each_entry(dpcm, &fe->dpcm[stream].be_clients, list_be)
261 dpcm->state = SND_SOC_DPCM_LINK_STATE_FREE;
263 if (stream == SNDRV_PCM_STREAM_PLAYBACK)
264 dpcm_dapm_stream_event(fe, stream, SND_SOC_DAPM_STREAM_STOP);
266 dpcm_dapm_stream_event(fe, stream, SND_SOC_DAPM_STREAM_STOP);
268 fe->dpcm[stream].state = SND_SOC_DPCM_STATE_CLOSE;
269 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO;
271 dpcm_be_disconnect(fe, stream);
273 fe->dpcm[stream].runtime = NULL;
275 if (fe->dai_link->compr_ops && fe->dai_link->compr_ops->shutdown)
276 fe->dai_link->compr_ops->shutdown(cstream);
278 if (platform->driver->compr_ops && platform->driver->compr_ops->free)
279 platform->driver->compr_ops->free(cstream);
281 mutex_unlock(&fe->card->mutex);
285 static int soc_compr_trigger(struct snd_compr_stream *cstream, int cmd)
288 struct snd_soc_pcm_runtime *rtd = cstream->private_data;
289 struct snd_soc_platform *platform = rtd->platform;
290 struct snd_soc_dai *codec_dai = rtd->codec_dai;
293 mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
295 if (platform->driver->compr_ops && platform->driver->compr_ops->trigger) {
296 ret = platform->driver->compr_ops->trigger(cstream, cmd);
302 case SNDRV_PCM_TRIGGER_START:
303 snd_soc_dai_digital_mute(codec_dai, 0, cstream->direction);
305 case SNDRV_PCM_TRIGGER_STOP:
306 snd_soc_dai_digital_mute(codec_dai, 1, cstream->direction);
311 mutex_unlock(&rtd->pcm_mutex);
315 static int soc_compr_trigger_fe(struct snd_compr_stream *cstream, int cmd)
317 struct snd_soc_pcm_runtime *fe = cstream->private_data;
318 struct snd_soc_platform *platform = fe->platform;
321 if (cmd == SND_COMPR_TRIGGER_PARTIAL_DRAIN ||
322 cmd == SND_COMPR_TRIGGER_DRAIN) {
324 if (platform->driver->compr_ops &&
325 platform->driver->compr_ops->trigger)
326 return platform->driver->compr_ops->trigger(cstream,
330 if (cstream->direction == SND_COMPRESS_PLAYBACK)
331 stream = SNDRV_PCM_STREAM_PLAYBACK;
333 stream = SNDRV_PCM_STREAM_CAPTURE;
336 mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME);
338 if (platform->driver->compr_ops && platform->driver->compr_ops->trigger) {
339 ret = platform->driver->compr_ops->trigger(cstream, cmd);
344 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE;
346 ret = dpcm_be_dai_trigger(fe, stream, cmd);
349 case SNDRV_PCM_TRIGGER_START:
350 case SNDRV_PCM_TRIGGER_RESUME:
351 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
352 fe->dpcm[stream].state = SND_SOC_DPCM_STATE_START;
354 case SNDRV_PCM_TRIGGER_STOP:
355 case SNDRV_PCM_TRIGGER_SUSPEND:
356 fe->dpcm[stream].state = SND_SOC_DPCM_STATE_STOP;
358 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
359 fe->dpcm[stream].state = SND_SOC_DPCM_STATE_PAUSED;
364 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO;
365 mutex_unlock(&fe->card->mutex);
369 static int soc_compr_set_params(struct snd_compr_stream *cstream,
370 struct snd_compr_params *params)
372 struct snd_soc_pcm_runtime *rtd = cstream->private_data;
373 struct snd_soc_platform *platform = rtd->platform;
376 mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
378 /* first we call set_params for the platform driver
379 * this should configure the soc side
380 * if the machine has compressed ops then we call that as well
381 * expectation is that platform and machine will configure everything
382 * for this compress path, like configuring pcm port for codec
384 if (platform->driver->compr_ops && platform->driver->compr_ops->set_params) {
385 ret = platform->driver->compr_ops->set_params(cstream, params);
390 if (rtd->dai_link->compr_ops && rtd->dai_link->compr_ops->set_params) {
391 ret = rtd->dai_link->compr_ops->set_params(cstream);
396 if (cstream->direction == SND_COMPRESS_PLAYBACK)
397 snd_soc_dapm_stream_event(rtd, SNDRV_PCM_STREAM_PLAYBACK,
398 SND_SOC_DAPM_STREAM_START);
400 snd_soc_dapm_stream_event(rtd, SNDRV_PCM_STREAM_CAPTURE,
401 SND_SOC_DAPM_STREAM_START);
403 /* cancel any delayed stream shutdown that is pending */
405 mutex_unlock(&rtd->pcm_mutex);
407 cancel_delayed_work_sync(&rtd->delayed_work);
412 mutex_unlock(&rtd->pcm_mutex);
416 static int soc_compr_set_params_fe(struct snd_compr_stream *cstream,
417 struct snd_compr_params *params)
419 struct snd_soc_pcm_runtime *fe = cstream->private_data;
420 struct snd_pcm_substream *fe_substream = fe->pcm->streams[0].substream;
421 struct snd_soc_platform *platform = fe->platform;
424 if (cstream->direction == SND_COMPRESS_PLAYBACK)
425 stream = SNDRV_PCM_STREAM_PLAYBACK;
427 stream = SNDRV_PCM_STREAM_CAPTURE;
429 mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME);
431 if (platform->driver->compr_ops && platform->driver->compr_ops->set_params) {
432 ret = platform->driver->compr_ops->set_params(cstream, params);
437 if (fe->dai_link->compr_ops && fe->dai_link->compr_ops->set_params) {
438 ret = fe->dai_link->compr_ops->set_params(cstream);
444 * Create an empty hw_params for the BE as the machine driver must
445 * fix this up to match DSP decoder and ASRC configuration.
446 * I.e. machine driver fixup for compressed BE is mandatory.
448 memset(&fe->dpcm[fe_substream->stream].hw_params, 0,
449 sizeof(struct snd_pcm_hw_params));
451 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE;
453 ret = dpcm_be_dai_hw_params(fe, stream);
457 ret = dpcm_be_dai_prepare(fe, stream);
461 if (stream == SNDRV_PCM_STREAM_PLAYBACK)
462 dpcm_dapm_stream_event(fe, stream, SND_SOC_DAPM_STREAM_START);
464 dpcm_dapm_stream_event(fe, stream, SND_SOC_DAPM_STREAM_START);
466 fe->dpcm[stream].state = SND_SOC_DPCM_STATE_PREPARE;
469 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO;
470 mutex_unlock(&fe->card->mutex);
474 static int soc_compr_get_params(struct snd_compr_stream *cstream,
475 struct snd_codec *params)
477 struct snd_soc_pcm_runtime *rtd = cstream->private_data;
478 struct snd_soc_platform *platform = rtd->platform;
481 mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
483 if (platform->driver->compr_ops && platform->driver->compr_ops->get_params)
484 ret = platform->driver->compr_ops->get_params(cstream, params);
486 mutex_unlock(&rtd->pcm_mutex);
490 static int soc_compr_get_caps(struct snd_compr_stream *cstream,
491 struct snd_compr_caps *caps)
493 struct snd_soc_pcm_runtime *rtd = cstream->private_data;
494 struct snd_soc_platform *platform = rtd->platform;
497 mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
499 if (platform->driver->compr_ops && platform->driver->compr_ops->get_caps)
500 ret = platform->driver->compr_ops->get_caps(cstream, caps);
502 mutex_unlock(&rtd->pcm_mutex);
506 static int soc_compr_get_codec_caps(struct snd_compr_stream *cstream,
507 struct snd_compr_codec_caps *codec)
509 struct snd_soc_pcm_runtime *rtd = cstream->private_data;
510 struct snd_soc_platform *platform = rtd->platform;
513 mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
515 if (platform->driver->compr_ops && platform->driver->compr_ops->get_codec_caps)
516 ret = platform->driver->compr_ops->get_codec_caps(cstream, codec);
518 mutex_unlock(&rtd->pcm_mutex);
522 static int soc_compr_ack(struct snd_compr_stream *cstream, size_t bytes)
524 struct snd_soc_pcm_runtime *rtd = cstream->private_data;
525 struct snd_soc_platform *platform = rtd->platform;
528 mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
530 if (platform->driver->compr_ops && platform->driver->compr_ops->ack)
531 ret = platform->driver->compr_ops->ack(cstream, bytes);
533 mutex_unlock(&rtd->pcm_mutex);
537 static int soc_compr_pointer(struct snd_compr_stream *cstream,
538 struct snd_compr_tstamp *tstamp)
540 struct snd_soc_pcm_runtime *rtd = cstream->private_data;
541 struct snd_soc_platform *platform = rtd->platform;
543 mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
545 if (platform->driver->compr_ops && platform->driver->compr_ops->pointer)
546 platform->driver->compr_ops->pointer(cstream, tstamp);
548 mutex_unlock(&rtd->pcm_mutex);
552 static int soc_compr_copy(struct snd_compr_stream *cstream,
553 char __user *buf, size_t count)
555 struct snd_soc_pcm_runtime *rtd = cstream->private_data;
556 struct snd_soc_platform *platform = rtd->platform;
559 mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
561 if (platform->driver->compr_ops && platform->driver->compr_ops->copy)
562 ret = platform->driver->compr_ops->copy(cstream, buf, count);
564 mutex_unlock(&rtd->pcm_mutex);
568 static int soc_compr_set_metadata(struct snd_compr_stream *cstream,
569 struct snd_compr_metadata *metadata)
571 struct snd_soc_pcm_runtime *rtd = cstream->private_data;
572 struct snd_soc_platform *platform = rtd->platform;
575 if (platform->driver->compr_ops && platform->driver->compr_ops->set_metadata)
576 ret = platform->driver->compr_ops->set_metadata(cstream, metadata);
581 static int soc_compr_get_metadata(struct snd_compr_stream *cstream,
582 struct snd_compr_metadata *metadata)
584 struct snd_soc_pcm_runtime *rtd = cstream->private_data;
585 struct snd_soc_platform *platform = rtd->platform;
588 if (platform->driver->compr_ops && platform->driver->compr_ops->get_metadata)
589 ret = platform->driver->compr_ops->get_metadata(cstream, metadata);
594 /* ASoC Compress operations */
595 static struct snd_compr_ops soc_compr_ops = {
596 .open = soc_compr_open,
597 .free = soc_compr_free,
598 .set_params = soc_compr_set_params,
599 .set_metadata = soc_compr_set_metadata,
600 .get_metadata = soc_compr_get_metadata,
601 .get_params = soc_compr_get_params,
602 .trigger = soc_compr_trigger,
603 .pointer = soc_compr_pointer,
604 .ack = soc_compr_ack,
605 .get_caps = soc_compr_get_caps,
606 .get_codec_caps = soc_compr_get_codec_caps
609 /* ASoC Dynamic Compress operations */
610 static struct snd_compr_ops soc_compr_dyn_ops = {
611 .open = soc_compr_open_fe,
612 .free = soc_compr_free_fe,
613 .set_params = soc_compr_set_params_fe,
614 .get_params = soc_compr_get_params,
615 .set_metadata = soc_compr_set_metadata,
616 .get_metadata = soc_compr_get_metadata,
617 .trigger = soc_compr_trigger_fe,
618 .pointer = soc_compr_pointer,
619 .ack = soc_compr_ack,
620 .get_caps = soc_compr_get_caps,
621 .get_codec_caps = soc_compr_get_codec_caps
624 /* create a new compress */
625 int soc_new_compress(struct snd_soc_pcm_runtime *rtd, int num)
627 struct snd_soc_codec *codec = rtd->codec;
628 struct snd_soc_platform *platform = rtd->platform;
629 struct snd_soc_dai *codec_dai = rtd->codec_dai;
630 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
631 struct snd_compr *compr;
632 struct snd_pcm *be_pcm;
634 int ret = 0, direction = 0;
636 if (rtd->num_codecs > 1) {
637 dev_err(rtd->card->dev, "Multicodec not supported for compressed stream\n");
641 /* check client and interface hw capabilities */
642 snprintf(new_name, sizeof(new_name), "%s %s-%d",
643 rtd->dai_link->stream_name, codec_dai->name, num);
645 if (codec_dai->driver->playback.channels_min)
646 direction = SND_COMPRESS_PLAYBACK;
647 else if (codec_dai->driver->capture.channels_min)
648 direction = SND_COMPRESS_CAPTURE;
652 compr = kzalloc(sizeof(*compr), GFP_KERNEL);
654 snd_printk(KERN_ERR "Cannot allocate compr\n");
658 compr->ops = devm_kzalloc(rtd->card->dev, sizeof(soc_compr_ops),
660 if (compr->ops == NULL) {
661 dev_err(rtd->card->dev, "Cannot allocate compressed ops\n");
666 if (rtd->dai_link->dynamic) {
667 snprintf(new_name, sizeof(new_name), "(%s)",
668 rtd->dai_link->stream_name);
670 ret = snd_pcm_new_internal(rtd->card->snd_card, new_name, num,
673 dev_err(rtd->card->dev, "ASoC: can't create compressed for %s\n",
674 rtd->dai_link->name);
680 be_pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream->private_data = rtd;
681 be_pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream->private_data = rtd;
682 memcpy(compr->ops, &soc_compr_dyn_ops, sizeof(soc_compr_dyn_ops));
684 memcpy(compr->ops, &soc_compr_ops, sizeof(soc_compr_ops));
686 /* Add copy callback for not memory mapped DSPs */
687 if (platform->driver->compr_ops && platform->driver->compr_ops->copy)
688 compr->ops->copy = soc_compr_copy;
690 mutex_init(&compr->lock);
691 ret = snd_compress_new(rtd->card->snd_card, num, direction, compr);
693 pr_err("compress asoc: can't create compress for codec %s\n",
694 codec->component.name);
698 /* DAPM dai link stream work */
699 INIT_DELAYED_WORK(&rtd->delayed_work, close_delayed_work);
702 compr->private_data = rtd;
704 printk(KERN_INFO "compress asoc: %s <-> %s mapping ok\n", codec_dai->name,