?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 4.15.6
[linux/fpc-iii.git] / sound / soc / soc-compress.c
blob1507117d1185156425d6a2d4fa176c5e3f7ea7ed
1 /*
2 * soc-compress.c -- ALSA SoC Compress
3 *
4 * Copyright (C) 2012 Intel Corp.
5 *
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>
9 *
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.
14 *
15 */
16
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>
28
29 static int soc_compr_open(struct snd_compr_stream *cstream)
30 {
31 struct snd_soc_pcm_runtime *rtd = cstream->private_data;
32 struct snd_soc_platform *platform = rtd->platform;
33 struct snd_soc_component *component;
34 struct snd_soc_rtdcom_list *rtdcom;
35 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
36 int ret = 0, __ret;
37
38 mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
39
40 if (cpu_dai->driver->cops && cpu_dai->driver->cops->startup) {
41 ret = cpu_dai->driver->cops->startup(cstream, cpu_dai);
42 if (ret < 0) {
43 dev_err(cpu_dai->dev, "Compress ASoC: can't open interface %s: %d\n",
44 cpu_dai->name, ret);
45 goto out;
46 }
47 }
48
49 if (platform && platform->driver->compr_ops && platform->driver->compr_ops->open) {
50 ret = platform->driver->compr_ops->open(cstream);
51 if (ret < 0) {
52 pr_err("compress asoc: can't open platform %s\n",
53 platform->component.name);
54 goto plat_err;
55 }
56 }
57
58 for_each_rtdcom(rtd, rtdcom) {
59 component = rtdcom->component;
60
61 /* ignore duplication for now */
62 if (platform && (component == &platform->component))
63 continue;
64
65 if (!component->driver->compr_ops ||
66 !component->driver->compr_ops->open)
67 continue;
68
69 __ret = component->driver->compr_ops->open(cstream);
70 if (__ret < 0) {
71 pr_err("compress asoc: can't open platform %s\n",
72 component->name);
73 ret = __ret;
74 }
75 }
76 if (ret < 0)
77 goto machine_err;
78
79 if (rtd->dai_link->compr_ops && rtd->dai_link->compr_ops->startup) {
80 ret = rtd->dai_link->compr_ops->startup(cstream);
81 if (ret < 0) {
82 pr_err("compress asoc: %s startup failed\n", rtd->dai_link->name);
83 goto machine_err;
84 }
85 }
86
87 snd_soc_runtime_activate(rtd, cstream->direction);
88
89 mutex_unlock(&rtd->pcm_mutex);
90
91 return 0;
92
93 machine_err:
94 for_each_rtdcom(rtd, rtdcom) {
95 component = rtdcom->component;
96
97 /* ignore duplication for now */
98 if (platform && (component == &platform->component))
99 continue;
100
101 if (!component->driver->compr_ops ||
102 !component->driver->compr_ops->free)
103 continue;
104
105 component->driver->compr_ops->free(cstream);
106 }
107
108 if (platform && platform->driver->compr_ops && platform->driver->compr_ops->free)
109 platform->driver->compr_ops->free(cstream);
110 plat_err:
111 if (cpu_dai->driver->cops && cpu_dai->driver->cops->shutdown)
112 cpu_dai->driver->cops->shutdown(cstream, cpu_dai);
113 out:
114 mutex_unlock(&rtd->pcm_mutex);
115 return ret;
116 }
117
118 static int soc_compr_open_fe(struct snd_compr_stream *cstream)
119 {
120 struct snd_soc_pcm_runtime *fe = cstream->private_data;
121 struct snd_pcm_substream *fe_substream =
122 fe->pcm->streams[cstream->direction].substream;
123 struct snd_soc_platform *platform = fe->platform;
124 struct snd_soc_component *component;
125 struct snd_soc_rtdcom_list *rtdcom;
126 struct snd_soc_dai *cpu_dai = fe->cpu_dai;
127 struct snd_soc_dpcm *dpcm;
128 struct snd_soc_dapm_widget_list *list;
129 int stream;
130 int ret = 0, __ret;
131
132 if (cstream->direction == SND_COMPRESS_PLAYBACK)
133 stream = SNDRV_PCM_STREAM_PLAYBACK;
134 else
135 stream = SNDRV_PCM_STREAM_CAPTURE;
136
137 mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME);
138
139 if (cpu_dai->driver->cops && cpu_dai->driver->cops->startup) {
140 ret = cpu_dai->driver->cops->startup(cstream, cpu_dai);
141 if (ret < 0) {
142 dev_err(cpu_dai->dev, "Compress ASoC: can't open interface %s: %d\n",
143 cpu_dai->name, ret);
144 goto out;
145 }
146 }
147
148
149 if (platform && platform->driver->compr_ops && platform->driver->compr_ops->open) {
150 ret = platform->driver->compr_ops->open(cstream);
151 if (ret < 0) {
152 pr_err("compress asoc: can't open platform %s\n",
153 platform->component.name);
154 goto plat_err;
155 }
156 }
157
158 for_each_rtdcom(fe, rtdcom) {
159 component = rtdcom->component;
160
161 /* ignore duplication for now */
162 if (platform && (component == &platform->component))
163 continue;
164
165 if (!component->driver->compr_ops ||
166 !component->driver->compr_ops->open)
167 continue;
168
169 __ret = component->driver->compr_ops->open(cstream);
170 if (__ret < 0) {
171 pr_err("compress asoc: can't open platform %s\n",
172 component->name);
173 ret = __ret;
174 }
175 }
176 if (ret < 0)
177 goto machine_err;
178
179 if (fe->dai_link->compr_ops && fe->dai_link->compr_ops->startup) {
180 ret = fe->dai_link->compr_ops->startup(cstream);
181 if (ret < 0) {
182 pr_err("compress asoc: %s startup failed\n", fe->dai_link->name);
183 goto machine_err;
184 }
185 }
186
187 fe->dpcm[stream].runtime = fe_substream->runtime;
188
189 ret = dpcm_path_get(fe, stream, &list);
190 if (ret < 0)
191 goto fe_err;
192 else if (ret == 0)
193 dev_dbg(fe->dev, "ASoC: %s no valid %s route\n",
194 fe->dai_link->name, stream ? "capture" : "playback");
195
196 /* calculate valid and active FE <-> BE dpcms */
197 dpcm_process_paths(fe, stream, &list, 1);
198
199 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE;
200
201 ret = dpcm_be_dai_startup(fe, stream);
202 if (ret < 0) {
203 /* clean up all links */
204 list_for_each_entry(dpcm, &fe->dpcm[stream].be_clients, list_be)
205 dpcm->state = SND_SOC_DPCM_LINK_STATE_FREE;
206
207 dpcm_be_disconnect(fe, stream);
208 fe->dpcm[stream].runtime = NULL;
209 goto path_err;
210 }
211
212 dpcm_clear_pending_state(fe, stream);
213 dpcm_path_put(&list);
214
215 fe->dpcm[stream].state = SND_SOC_DPCM_STATE_OPEN;
216 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO;
217
218 snd_soc_runtime_activate(fe, stream);
219
220 mutex_unlock(&fe->card->mutex);
221
222 return 0;
223
224 path_err:
225 dpcm_path_put(&list);
226 fe_err:
227 if (fe->dai_link->compr_ops && fe->dai_link->compr_ops->shutdown)
228 fe->dai_link->compr_ops->shutdown(cstream);
229 machine_err:
230 for_each_rtdcom(fe, rtdcom) {
231 component = rtdcom->component;
232
233 /* ignore duplication for now */
234 if (platform && (component == &platform->component))
235 continue;
236
237 if (!component->driver->compr_ops ||
238 !component->driver->compr_ops->free)
239 continue;
240
241 component->driver->compr_ops->free(cstream);
242 }
243
244 if (platform && platform->driver->compr_ops && platform->driver->compr_ops->free)
245 platform->driver->compr_ops->free(cstream);
246 plat_err:
247 if (cpu_dai->driver->cops && cpu_dai->driver->cops->shutdown)
248 cpu_dai->driver->cops->shutdown(cstream, cpu_dai);
249 out:
250 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO;
251 mutex_unlock(&fe->card->mutex);
252 return ret;
253 }
254
255 /*
256 * Power down the audio subsystem pmdown_time msecs after close is called.
257 * This is to ensure there are no pops or clicks in between any music tracks
258 * due to DAPM power cycling.
259 */
260 static void close_delayed_work(struct work_struct *work)
261 {
262 struct snd_soc_pcm_runtime *rtd =
263 container_of(work, struct snd_soc_pcm_runtime, delayed_work.work);
264 struct snd_soc_dai *codec_dai = rtd->codec_dai;
265
266 mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
267
268 dev_dbg(rtd->dev, "ASoC: pop wq checking: %s status: %s waiting: %s\n",
269 codec_dai->driver->playback.stream_name,
270 codec_dai->playback_active ? "active" : "inactive",
271 rtd->pop_wait ? "yes" : "no");
272
273 /* are we waiting on this codec DAI stream */
274 if (rtd->pop_wait == 1) {
275 rtd->pop_wait = 0;
276 snd_soc_dapm_stream_event(rtd, SNDRV_PCM_STREAM_PLAYBACK,
277 SND_SOC_DAPM_STREAM_STOP);
278 }
279
280 mutex_unlock(&rtd->pcm_mutex);
281 }
282
283 static int soc_compr_free(struct snd_compr_stream *cstream)
284 {
285 struct snd_soc_pcm_runtime *rtd = cstream->private_data;
286 struct snd_soc_platform *platform = rtd->platform;
287 struct snd_soc_component *component;
288 struct snd_soc_rtdcom_list *rtdcom;
289 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
290 struct snd_soc_dai *codec_dai = rtd->codec_dai;
291 int stream;
292
293 mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
294
295 if (cstream->direction == SND_COMPRESS_PLAYBACK)
296 stream = SNDRV_PCM_STREAM_PLAYBACK;
297 else
298 stream = SNDRV_PCM_STREAM_CAPTURE;
299
300 snd_soc_runtime_deactivate(rtd, stream);
301
302 snd_soc_dai_digital_mute(codec_dai, 1, cstream->direction);
303
304 if (!cpu_dai->active)
305 cpu_dai->rate = 0;
306
307 if (!codec_dai->active)
308 codec_dai->rate = 0;
309
310
311 if (rtd->dai_link->compr_ops && rtd->dai_link->compr_ops->shutdown)
312 rtd->dai_link->compr_ops->shutdown(cstream);
313
314 for_each_rtdcom(rtd, rtdcom) {
315 component = rtdcom->component;
316
317 /* ignore duplication for now */
318 if (platform && (component == &platform->component))
319 continue;
320
321 if (!component->driver->compr_ops ||
322 !component->driver->compr_ops->free)
323 continue;
324
325 component->driver->compr_ops->free(cstream);
326 }
327
328 if (platform && platform->driver->compr_ops && platform->driver->compr_ops->free)
329 platform->driver->compr_ops->free(cstream);
330
331 if (cpu_dai->driver->cops && cpu_dai->driver->cops->shutdown)
332 cpu_dai->driver->cops->shutdown(cstream, cpu_dai);
333
334 if (cstream->direction == SND_COMPRESS_PLAYBACK) {
335 if (snd_soc_runtime_ignore_pmdown_time(rtd)) {
336 snd_soc_dapm_stream_event(rtd,
337 SNDRV_PCM_STREAM_PLAYBACK,
338 SND_SOC_DAPM_STREAM_STOP);
339 } else {
340 rtd->pop_wait = 1;
341 queue_delayed_work(system_power_efficient_wq,
342 &rtd->delayed_work,
343 msecs_to_jiffies(rtd->pmdown_time));
344 }
345 } else {
346 /* capture streams can be powered down now */
347 snd_soc_dapm_stream_event(rtd,
348 SNDRV_PCM_STREAM_CAPTURE,
349 SND_SOC_DAPM_STREAM_STOP);
350 }
351
352 mutex_unlock(&rtd->pcm_mutex);
353 return 0;
354 }
355
356 static int soc_compr_free_fe(struct snd_compr_stream *cstream)
357 {
358 struct snd_soc_pcm_runtime *fe = cstream->private_data;
359 struct snd_soc_platform *platform = fe->platform;
360 struct snd_soc_component *component;
361 struct snd_soc_rtdcom_list *rtdcom;
362 struct snd_soc_dai *cpu_dai = fe->cpu_dai;
363 struct snd_soc_dpcm *dpcm;
364 int stream, ret;
365
366 mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME);
367
368 if (cstream->direction == SND_COMPRESS_PLAYBACK)
369 stream = SNDRV_PCM_STREAM_PLAYBACK;
370 else
371 stream = SNDRV_PCM_STREAM_CAPTURE;
372
373 snd_soc_runtime_deactivate(fe, stream);
374
375 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE;
376
377 ret = dpcm_be_dai_hw_free(fe, stream);
378 if (ret < 0)
379 dev_err(fe->dev, "compressed hw_free failed %d\n", ret);
380
381 ret = dpcm_be_dai_shutdown(fe, stream);
382
383 /* mark FE's links ready to prune */
384 list_for_each_entry(dpcm, &fe->dpcm[stream].be_clients, list_be)
385 dpcm->state = SND_SOC_DPCM_LINK_STATE_FREE;
386
387 dpcm_dapm_stream_event(fe, stream, SND_SOC_DAPM_STREAM_STOP);
388
389 fe->dpcm[stream].state = SND_SOC_DPCM_STATE_CLOSE;
390 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO;
391
392 dpcm_be_disconnect(fe, stream);
393
394 fe->dpcm[stream].runtime = NULL;
395
396 if (fe->dai_link->compr_ops && fe->dai_link->compr_ops->shutdown)
397 fe->dai_link->compr_ops->shutdown(cstream);
398
399 if (platform && platform->driver->compr_ops && platform->driver->compr_ops->free)
400 platform->driver->compr_ops->free(cstream);
401
402 for_each_rtdcom(fe, rtdcom) {
403 component = rtdcom->component;
404
405 /* ignore duplication for now */
406 if (platform && (component == &platform->component))
407 continue;
408
409 if (!component->driver->compr_ops ||
410 !component->driver->compr_ops->free)
411 continue;
412
413 component->driver->compr_ops->free(cstream);
414 }
415
416 if (cpu_dai->driver->cops && cpu_dai->driver->cops->shutdown)
417 cpu_dai->driver->cops->shutdown(cstream, cpu_dai);
418
419 mutex_unlock(&fe->card->mutex);
420 return 0;
421 }
422
423 static int soc_compr_trigger(struct snd_compr_stream *cstream, int cmd)
424 {
425
426 struct snd_soc_pcm_runtime *rtd = cstream->private_data;
427 struct snd_soc_platform *platform = rtd->platform;
428 struct snd_soc_component *component;
429 struct snd_soc_rtdcom_list *rtdcom;
430 struct snd_soc_dai *codec_dai = rtd->codec_dai;
431 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
432 int ret = 0, __ret;
433
434 mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
435
436 if (platform && platform->driver->compr_ops && platform->driver->compr_ops->trigger) {
437 ret = platform->driver->compr_ops->trigger(cstream, cmd);
438 if (ret < 0)
439 goto out;
440 }
441
442 for_each_rtdcom(rtd, rtdcom) {
443 component = rtdcom->component;
444
445 /* ignore duplication for now */
446 if (platform && (component == &platform->component))
447 continue;
448
449 if (!component->driver->compr_ops ||
450 !component->driver->compr_ops->trigger)
451 continue;
452
453 __ret = component->driver->compr_ops->trigger(cstream, cmd);
454 if (__ret < 0)
455 ret = __ret;
456 }
457 if (ret < 0)
458 goto out;
459
460 if (cpu_dai->driver->cops && cpu_dai->driver->cops->trigger)
461 cpu_dai->driver->cops->trigger(cstream, cmd, cpu_dai);
462
463
464 switch (cmd) {
465 case SNDRV_PCM_TRIGGER_START:
466 snd_soc_dai_digital_mute(codec_dai, 0, cstream->direction);
467 break;
468 case SNDRV_PCM_TRIGGER_STOP:
469 snd_soc_dai_digital_mute(codec_dai, 1, cstream->direction);
470 break;
471 }
472
473 out:
474 mutex_unlock(&rtd->pcm_mutex);
475 return ret;
476 }
477
478 static int soc_compr_trigger_fe(struct snd_compr_stream *cstream, int cmd)
479 {
480 struct snd_soc_pcm_runtime *fe = cstream->private_data;
481 struct snd_soc_platform *platform = fe->platform;
482 struct snd_soc_component *component;
483 struct snd_soc_rtdcom_list *rtdcom;
484 struct snd_soc_dai *cpu_dai = fe->cpu_dai;
485 int ret = 0, __ret, stream;
486
487 if (cmd == SND_COMPR_TRIGGER_PARTIAL_DRAIN ||
488 cmd == SND_COMPR_TRIGGER_DRAIN) {
489
490 if (platform &&
491 platform->driver->compr_ops &&
492 platform->driver->compr_ops->trigger)
493 return platform->driver->compr_ops->trigger(cstream,
494 cmd);
495
496 for_each_rtdcom(fe, rtdcom) {
497 component = rtdcom->component;
498
499 /* ignore duplication for now */
500 if (platform && (component == &platform->component))
501 continue;
502
503 if (!component->driver->compr_ops ||
504 !component->driver->compr_ops->trigger)
505 continue;
506
507 __ret = component->driver->compr_ops->trigger(cstream, cmd);
508 if (__ret < 0)
509 ret = __ret;
510 }
511 return ret;
512 }
513
514 if (cstream->direction == SND_COMPRESS_PLAYBACK)
515 stream = SNDRV_PCM_STREAM_PLAYBACK;
516 else
517 stream = SNDRV_PCM_STREAM_CAPTURE;
518
519
520 mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME);
521
522 if (cpu_dai->driver->cops && cpu_dai->driver->cops->trigger) {
523 ret = cpu_dai->driver->cops->trigger(cstream, cmd, cpu_dai);
524 if (ret < 0)
525 goto out;
526 }
527
528 if (platform && platform->driver->compr_ops && platform->driver->compr_ops->trigger) {
529 ret = platform->driver->compr_ops->trigger(cstream, cmd);
530 if (ret < 0)
531 goto out;
532 }
533
534 for_each_rtdcom(fe, rtdcom) {
535 component = rtdcom->component;
536
537 /* ignore duplication for now */
538 if (platform && (component == &platform->component))
539 continue;
540
541 if (!component->driver->compr_ops ||
542 !component->driver->compr_ops->trigger)
543 continue;
544
545 __ret = component->driver->compr_ops->trigger(cstream, cmd);
546 if (__ret < 0)
547 ret = __ret;
548 }
549 if (ret < 0)
550 goto out;
551
552 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE;
553
554 ret = dpcm_be_dai_trigger(fe, stream, cmd);
555
556 switch (cmd) {
557 case SNDRV_PCM_TRIGGER_START:
558 case SNDRV_PCM_TRIGGER_RESUME:
559 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
560 fe->dpcm[stream].state = SND_SOC_DPCM_STATE_START;
561 break;
562 case SNDRV_PCM_TRIGGER_STOP:
563 case SNDRV_PCM_TRIGGER_SUSPEND:
564 fe->dpcm[stream].state = SND_SOC_DPCM_STATE_STOP;
565 break;
566 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
567 fe->dpcm[stream].state = SND_SOC_DPCM_STATE_PAUSED;
568 break;
569 }
570
571 out:
572 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO;
573 mutex_unlock(&fe->card->mutex);
574 return ret;
575 }
576
577 static int soc_compr_set_params(struct snd_compr_stream *cstream,
578 struct snd_compr_params *params)
579 {
580 struct snd_soc_pcm_runtime *rtd = cstream->private_data;
581 struct snd_soc_platform *platform = rtd->platform;
582 struct snd_soc_component *component;
583 struct snd_soc_rtdcom_list *rtdcom;
584 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
585 int ret = 0, __ret;
586
587 mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
588
589 /* first we call set_params for the platform driver
590 * this should configure the soc side
591 * if the machine has compressed ops then we call that as well
592 * expectation is that platform and machine will configure everything
593 * for this compress path, like configuring pcm port for codec
594 */
595 if (cpu_dai->driver->cops && cpu_dai->driver->cops->set_params) {
596 ret = cpu_dai->driver->cops->set_params(cstream, params, cpu_dai);
597 if (ret < 0)
598 goto err;
599 }
600
601 if (platform && platform->driver->compr_ops && platform->driver->compr_ops->set_params) {
602 ret = platform->driver->compr_ops->set_params(cstream, params);
603 if (ret < 0)
604 goto err;
605 }
606
607 for_each_rtdcom(rtd, rtdcom) {
608 component = rtdcom->component;
609
610 /* ignore duplication for now */
611 if (platform && (component == &platform->component))
612 continue;
613
614 if (!component->driver->compr_ops ||
615 !component->driver->compr_ops->set_params)
616 continue;
617
618 __ret = component->driver->compr_ops->set_params(cstream, params);
619 if (__ret < 0)
620 ret = __ret;
621 }
622 if (ret < 0)
623 goto err;
624
625 if (rtd->dai_link->compr_ops && rtd->dai_link->compr_ops->set_params) {
626 ret = rtd->dai_link->compr_ops->set_params(cstream);
627 if (ret < 0)
628 goto err;
629 }
630
631 if (cstream->direction == SND_COMPRESS_PLAYBACK)
632 snd_soc_dapm_stream_event(rtd, SNDRV_PCM_STREAM_PLAYBACK,
633 SND_SOC_DAPM_STREAM_START);
634 else
635 snd_soc_dapm_stream_event(rtd, SNDRV_PCM_STREAM_CAPTURE,
636 SND_SOC_DAPM_STREAM_START);
637
638 /* cancel any delayed stream shutdown that is pending */
639 rtd->pop_wait = 0;
640 mutex_unlock(&rtd->pcm_mutex);
641
642 cancel_delayed_work_sync(&rtd->delayed_work);
643
644 return ret;
645
646 err:
647 mutex_unlock(&rtd->pcm_mutex);
648 return ret;
649 }
650
651 static int soc_compr_set_params_fe(struct snd_compr_stream *cstream,
652 struct snd_compr_params *params)
653 {
654 struct snd_soc_pcm_runtime *fe = cstream->private_data;
655 struct snd_pcm_substream *fe_substream =
656 fe->pcm->streams[cstream->direction].substream;
657 struct snd_soc_platform *platform = fe->platform;
658 struct snd_soc_component *component;
659 struct snd_soc_rtdcom_list *rtdcom;
660 struct snd_soc_dai *cpu_dai = fe->cpu_dai;
661 int ret = 0, __ret, stream;
662
663 if (cstream->direction == SND_COMPRESS_PLAYBACK)
664 stream = SNDRV_PCM_STREAM_PLAYBACK;
665 else
666 stream = SNDRV_PCM_STREAM_CAPTURE;
667
668 mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME);
669
670 if (cpu_dai->driver->cops && cpu_dai->driver->cops->set_params) {
671 ret = cpu_dai->driver->cops->set_params(cstream, params, cpu_dai);
672 if (ret < 0)
673 goto out;
674 }
675
676 if (platform && platform->driver->compr_ops && platform->driver->compr_ops->set_params) {
677 ret = platform->driver->compr_ops->set_params(cstream, params);
678 if (ret < 0)
679 goto out;
680 }
681
682 for_each_rtdcom(fe, rtdcom) {
683 component = rtdcom->component;
684
685 /* ignore duplication for now */
686 if (platform && (component == &platform->component))
687 continue;
688
689 if (!component->driver->compr_ops ||
690 !component->driver->compr_ops->set_params)
691 continue;
692
693 __ret = component->driver->compr_ops->set_params(cstream, params);
694 if (__ret < 0)
695 ret = __ret;
696 }
697 if (ret < 0)
698 goto out;
699
700 if (fe->dai_link->compr_ops && fe->dai_link->compr_ops->set_params) {
701 ret = fe->dai_link->compr_ops->set_params(cstream);
702 if (ret < 0)
703 goto out;
704 }
705
706 /*
707 * Create an empty hw_params for the BE as the machine driver must
708 * fix this up to match DSP decoder and ASRC configuration.
709 * I.e. machine driver fixup for compressed BE is mandatory.
710 */
711 memset(&fe->dpcm[fe_substream->stream].hw_params, 0,
712 sizeof(struct snd_pcm_hw_params));
713
714 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE;
715
716 ret = dpcm_be_dai_hw_params(fe, stream);
717 if (ret < 0)
718 goto out;
719
720 ret = dpcm_be_dai_prepare(fe, stream);
721 if (ret < 0)
722 goto out;
723
724 dpcm_dapm_stream_event(fe, stream, SND_SOC_DAPM_STREAM_START);
725 fe->dpcm[stream].state = SND_SOC_DPCM_STATE_PREPARE;
726
727 out:
728 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO;
729 mutex_unlock(&fe->card->mutex);
730 return ret;
731 }
732
733 static int soc_compr_get_params(struct snd_compr_stream *cstream,
734 struct snd_codec *params)
735 {
736 struct snd_soc_pcm_runtime *rtd = cstream->private_data;
737 struct snd_soc_platform *platform = rtd->platform;
738 struct snd_soc_component *component;
739 struct snd_soc_rtdcom_list *rtdcom;
740 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
741 int ret = 0, __ret;
742
743 mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
744
745 if (cpu_dai->driver->cops && cpu_dai->driver->cops->get_params) {
746 ret = cpu_dai->driver->cops->get_params(cstream, params, cpu_dai);
747 if (ret < 0)
748 goto err;
749 }
750
751 if (platform && platform->driver->compr_ops && platform->driver->compr_ops->get_params) {
752 ret = platform->driver->compr_ops->get_params(cstream, params);
753 if (ret < 0)
754 goto err;
755 }
756
757 for_each_rtdcom(rtd, rtdcom) {
758 component = rtdcom->component;
759
760 /* ignore duplication for now */
761 if (platform && (component == &platform->component))
762 continue;
763
764 if (!component->driver->compr_ops ||
765 !component->driver->compr_ops->get_params)
766 continue;
767
768 __ret = component->driver->compr_ops->get_params(cstream, params);
769 if (__ret < 0)
770 ret = __ret;
771 }
772
773 err:
774 mutex_unlock(&rtd->pcm_mutex);
775 return ret;
776 }
777
778 static int soc_compr_get_caps(struct snd_compr_stream *cstream,
779 struct snd_compr_caps *caps)
780 {
781 struct snd_soc_pcm_runtime *rtd = cstream->private_data;
782 struct snd_soc_platform *platform = rtd->platform;
783 struct snd_soc_component *component;
784 struct snd_soc_rtdcom_list *rtdcom;
785 int ret = 0, __ret;
786
787 mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
788
789 if (platform && platform->driver->compr_ops && platform->driver->compr_ops->get_caps) {
790 ret = platform->driver->compr_ops->get_caps(cstream, caps);
791 if (ret < 0)
792 goto err;
793 }
794
795 for_each_rtdcom(rtd, rtdcom) {
796 component = rtdcom->component;
797
798 /* ignore duplication for now */
799 if (platform && (component == &platform->component))
800 continue;
801
802 if (!component->driver->compr_ops ||
803 !component->driver->compr_ops->get_caps)
804 continue;
805
806 __ret = component->driver->compr_ops->get_caps(cstream, caps);
807 if (__ret < 0)
808 ret = __ret;
809 }
810
811 err:
812 mutex_unlock(&rtd->pcm_mutex);
813 return ret;
814 }
815
816 static int soc_compr_get_codec_caps(struct snd_compr_stream *cstream,
817 struct snd_compr_codec_caps *codec)
818 {
819 struct snd_soc_pcm_runtime *rtd = cstream->private_data;
820 struct snd_soc_platform *platform = rtd->platform;
821 struct snd_soc_component *component;
822 struct snd_soc_rtdcom_list *rtdcom;
823 int ret = 0, __ret;
824
825 mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
826
827 if (platform && platform->driver->compr_ops && platform->driver->compr_ops->get_codec_caps) {
828 ret = platform->driver->compr_ops->get_codec_caps(cstream, codec);
829 if (ret < 0)
830 goto err;
831 }
832
833 for_each_rtdcom(rtd, rtdcom) {
834 component = rtdcom->component;
835
836 /* ignore duplication for now */
837 if (platform && (component == &platform->component))
838 continue;
839
840 if (!component->driver->compr_ops ||
841 !component->driver->compr_ops->get_codec_caps)
842 continue;
843
844 __ret = component->driver->compr_ops->get_codec_caps(cstream, codec);
845 if (__ret < 0)
846 ret = __ret;
847 }
848
849 err:
850 mutex_unlock(&rtd->pcm_mutex);
851 return ret;
852 }
853
854 static int soc_compr_ack(struct snd_compr_stream *cstream, size_t bytes)
855 {
856 struct snd_soc_pcm_runtime *rtd = cstream->private_data;
857 struct snd_soc_platform *platform = rtd->platform;
858 struct snd_soc_component *component;
859 struct snd_soc_rtdcom_list *rtdcom;
860 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
861 int ret = 0, __ret;
862
863 mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
864
865 if (cpu_dai->driver->cops && cpu_dai->driver->cops->ack) {
866 ret = cpu_dai->driver->cops->ack(cstream, bytes, cpu_dai);
867 if (ret < 0)
868 goto err;
869 }
870
871 if (platform && platform->driver->compr_ops && platform->driver->compr_ops->ack) {
872 ret = platform->driver->compr_ops->ack(cstream, bytes);
873 if (ret < 0)
874 goto err;
875 }
876
877 for_each_rtdcom(rtd, rtdcom) {
878 component = rtdcom->component;
879
880 /* ignore duplication for now */
881 if (platform && (component == &platform->component))
882 continue;
883
884 if (!component->driver->compr_ops ||
885 !component->driver->compr_ops->ack)
886 continue;
887
888 __ret = component->driver->compr_ops->ack(cstream, bytes);
889 if (__ret < 0)
890 ret = __ret;
891 }
892
893 err:
894 mutex_unlock(&rtd->pcm_mutex);
895 return ret;
896 }
897
898 static int soc_compr_pointer(struct snd_compr_stream *cstream,
899 struct snd_compr_tstamp *tstamp)
900 {
901 struct snd_soc_pcm_runtime *rtd = cstream->private_data;
902 struct snd_soc_platform *platform = rtd->platform;
903 struct snd_soc_component *component;
904 struct snd_soc_rtdcom_list *rtdcom;
905 int ret = 0, __ret;
906 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
907
908 mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
909
910 if (cpu_dai->driver->cops && cpu_dai->driver->cops->pointer)
911 cpu_dai->driver->cops->pointer(cstream, tstamp, cpu_dai);
912
913 if (platform && platform->driver->compr_ops && platform->driver->compr_ops->pointer) {
914 ret = platform->driver->compr_ops->pointer(cstream, tstamp);
915 if (ret < 0)
916 goto err;
917 }
918
919 for_each_rtdcom(rtd, rtdcom) {
920 component = rtdcom->component;
921
922 /* ignore duplication for now */
923 if (platform && (component == &platform->component))
924 continue;
925
926 if (!component->driver->compr_ops ||
927 !component->driver->compr_ops->pointer)
928 continue;
929
930 __ret = component->driver->compr_ops->pointer(cstream, tstamp);
931 if (__ret < 0)
932 ret = __ret;
933 }
934
935 err:
936 mutex_unlock(&rtd->pcm_mutex);
937 return ret;
938 }
939
940 static int soc_compr_copy(struct snd_compr_stream *cstream,
941 char __user *buf, size_t count)
942 {
943 struct snd_soc_pcm_runtime *rtd = cstream->private_data;
944 struct snd_soc_platform *platform = rtd->platform;
945 struct snd_soc_component *component;
946 struct snd_soc_rtdcom_list *rtdcom;
947 int ret = 0;
948
949 mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
950
951 if (platform && platform->driver->compr_ops && platform->driver->compr_ops->copy) {
952 ret = platform->driver->compr_ops->copy(cstream, buf, count);
953 if (ret < 0)
954 goto err;
955 }
956
957 for_each_rtdcom(rtd, rtdcom) {
958 component = rtdcom->component;
959
960 /* ignore duplication for now */
961 if (platform && (component == &platform->component))
962 continue;
963
964 if (!component->driver->compr_ops ||
965 !component->driver->compr_ops->copy)
966 continue;
967
968 ret = component->driver->compr_ops->copy(cstream, buf, count);
969 break;
970 }
971
972 err:
973 mutex_unlock(&rtd->pcm_mutex);
974 return ret;
975 }
976
977 static int soc_compr_set_metadata(struct snd_compr_stream *cstream,
978 struct snd_compr_metadata *metadata)
979 {
980 struct snd_soc_pcm_runtime *rtd = cstream->private_data;
981 struct snd_soc_platform *platform = rtd->platform;
982 struct snd_soc_component *component;
983 struct snd_soc_rtdcom_list *rtdcom;
984 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
985 int ret = 0, __ret;
986
987 if (cpu_dai->driver->cops && cpu_dai->driver->cops->set_metadata) {
988 ret = cpu_dai->driver->cops->set_metadata(cstream, metadata, cpu_dai);
989 if (ret < 0)
990 return ret;
991 }
992
993 if (platform && platform->driver->compr_ops && platform->driver->compr_ops->set_metadata) {
994 ret = platform->driver->compr_ops->set_metadata(cstream, metadata);
995 if (ret < 0)
996 return ret;
997 }
998
999 for_each_rtdcom(rtd, rtdcom) {
1000 component = rtdcom->component;
1001
1002 /* ignore duplication for now */
1003 if (platform && (component == &platform->component))
1004 continue;
1005
1006 if (!component->driver->compr_ops ||
1007 !component->driver->compr_ops->set_metadata)
1008 continue;
1009
1010 __ret = component->driver->compr_ops->set_metadata(cstream, metadata);
1011 if (__ret < 0)
1012 ret = __ret;
1013 }
1014
1015 return ret;
1016 }
1017
1018 static int soc_compr_get_metadata(struct snd_compr_stream *cstream,
1019 struct snd_compr_metadata *metadata)
1020 {
1021 struct snd_soc_pcm_runtime *rtd = cstream->private_data;
1022 struct snd_soc_platform *platform = rtd->platform;
1023 struct snd_soc_component *component;
1024 struct snd_soc_rtdcom_list *rtdcom;
1025 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
1026 int ret = 0, __ret;
1027
1028 if (cpu_dai->driver->cops && cpu_dai->driver->cops->get_metadata) {
1029 ret = cpu_dai->driver->cops->get_metadata(cstream, metadata, cpu_dai);
1030 if (ret < 0)
1031 return ret;
1032 }
1033
1034 if (platform && platform->driver->compr_ops && platform->driver->compr_ops->get_metadata) {
1035 ret = platform->driver->compr_ops->get_metadata(cstream, metadata);
1036 if (ret < 0)
1037 return ret;
1038 }
1039
1040 for_each_rtdcom(rtd, rtdcom) {
1041 component = rtdcom->component;
1042
1043 /* ignore duplication for now */
1044 if (platform && (component == &platform->component))
1045 continue;
1046
1047 if (!component->driver->compr_ops ||
1048 !component->driver->compr_ops->get_metadata)
1049 continue;
1050
1051 __ret = component->driver->compr_ops->get_metadata(cstream, metadata);
1052 if (__ret < 0)
1053 ret = __ret;
1054 }
1055
1056 return ret;
1057 }
1058
1059 /* ASoC Compress operations */
1060 static struct snd_compr_ops soc_compr_ops = {
1061 .open = soc_compr_open,
1062 .free = soc_compr_free,
1063 .set_params = soc_compr_set_params,
1064 .set_metadata = soc_compr_set_metadata,
1065 .get_metadata = soc_compr_get_metadata,
1066 .get_params = soc_compr_get_params,
1067 .trigger = soc_compr_trigger,
1068 .pointer = soc_compr_pointer,
1069 .ack = soc_compr_ack,
1070 .get_caps = soc_compr_get_caps,
1071 .get_codec_caps = soc_compr_get_codec_caps
1072 };
1073
1074 /* ASoC Dynamic Compress operations */
1075 static struct snd_compr_ops soc_compr_dyn_ops = {
1076 .open = soc_compr_open_fe,
1077 .free = soc_compr_free_fe,
1078 .set_params = soc_compr_set_params_fe,
1079 .get_params = soc_compr_get_params,
1080 .set_metadata = soc_compr_set_metadata,
1081 .get_metadata = soc_compr_get_metadata,
1082 .trigger = soc_compr_trigger_fe,
1083 .pointer = soc_compr_pointer,
1084 .ack = soc_compr_ack,
1085 .get_caps = soc_compr_get_caps,
1086 .get_codec_caps = soc_compr_get_codec_caps
1087 };
1088
1089 /**
1090 * snd_soc_new_compress - create a new compress.
1091 *
1092 * @rtd: The runtime for which we will create compress
1093 * @num: the device index number (zero based - shared with normal PCMs)
1094 *
1095 * Return: 0 for success, else error.
1096 */
1097 int snd_soc_new_compress(struct snd_soc_pcm_runtime *rtd, int num)
1098 {
1099 struct snd_soc_codec *codec = rtd->codec;
1100 struct snd_soc_platform *platform = rtd->platform;
1101 struct snd_soc_component *component;
1102 struct snd_soc_rtdcom_list *rtdcom;
1103 struct snd_soc_dai *codec_dai = rtd->codec_dai;
1104 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
1105 struct snd_compr *compr;
1106 struct snd_pcm *be_pcm;
1107 char new_name[64];
1108 int ret = 0, direction = 0;
1109 int playback = 0, capture = 0;
1110
1111 if (rtd->num_codecs > 1) {
1112 dev_err(rtd->card->dev, "Multicodec not supported for compressed stream\n");
1113 return -EINVAL;
1114 }
1115
1116 /* check client and interface hw capabilities */
1117 if (codec_dai->driver->playback.channels_min)
1118 playback = 1;
1119 if (codec_dai->driver->capture.channels_min)
1120 capture = 1;
1121
1122 capture = capture && cpu_dai->driver->capture.channels_min;
1123 playback = playback && cpu_dai->driver->playback.channels_min;
1124
1125 /*
1126 * Compress devices are unidirectional so only one of the directions
1127 * should be set, check for that (xor)
1128 */
1129 if (playback + capture != 1) {
1130 dev_err(rtd->card->dev, "Invalid direction for compress P %d, C %d\n",
1131 playback, capture);
1132 return -EINVAL;
1133 }
1134
1135 if (playback)
1136 direction = SND_COMPRESS_PLAYBACK;
1137 else
1138 direction = SND_COMPRESS_CAPTURE;
1139
1140 compr = kzalloc(sizeof(*compr), GFP_KERNEL);
1141 if (!compr)
1142 return -ENOMEM;
1143
1144 compr->ops = devm_kzalloc(rtd->card->dev, sizeof(soc_compr_ops),
1145 GFP_KERNEL);
1146 if (!compr->ops) {
1147 ret = -ENOMEM;
1148 goto compr_err;
1149 }
1150
1151 if (rtd->dai_link->dynamic) {
1152 snprintf(new_name, sizeof(new_name), "(%s)",
1153 rtd->dai_link->stream_name);
1154
1155 ret = snd_pcm_new_internal(rtd->card->snd_card, new_name, num,
1156 rtd->dai_link->dpcm_playback,
1157 rtd->dai_link->dpcm_capture, &be_pcm);
1158 if (ret < 0) {
1159 dev_err(rtd->card->dev, "ASoC: can't create compressed for %s\n",
1160 rtd->dai_link->name);
1161 goto compr_err;
1162 }
1163
1164 rtd->pcm = be_pcm;
1165 rtd->fe_compr = 1;
1166 if (rtd->dai_link->dpcm_playback)
1167 be_pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream->private_data = rtd;
1168 else if (rtd->dai_link->dpcm_capture)
1169 be_pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream->private_data = rtd;
1170 memcpy(compr->ops, &soc_compr_dyn_ops, sizeof(soc_compr_dyn_ops));
1171 } else {
1172 snprintf(new_name, sizeof(new_name), "%s %s-%d",
1173 rtd->dai_link->stream_name, codec_dai->name, num);
1174
1175 memcpy(compr->ops, &soc_compr_ops, sizeof(soc_compr_ops));
1176 }
1177
1178
1179 /* Add copy callback for not memory mapped DSPs */
1180 if (platform && platform->driver->compr_ops && platform->driver->compr_ops->copy)
1181 compr->ops->copy = soc_compr_copy;
1182
1183 for_each_rtdcom(rtd, rtdcom) {
1184 component = rtdcom->component;
1185
1186 /* ignore duplication for now */
1187 if (platform && (component == &platform->component))
1188 continue;
1189
1190 if (!component->driver->compr_ops ||
1191 !component->driver->compr_ops->copy)
1192 continue;
1193
1194 compr->ops->copy = soc_compr_copy;
1195 }
1196
1197
1198 mutex_init(&compr->lock);
1199 ret = snd_compress_new(rtd->card->snd_card, num, direction,
1200 new_name, compr);
1201 if (ret < 0) {
1202 pr_err("compress asoc: can't create compress for codec %s\n",
1203 codec->component.name);
1204 goto compr_err;
1205 }
1206
1207 /* DAPM dai link stream work */
1208 INIT_DELAYED_WORK(&rtd->delayed_work, close_delayed_work);
1209
1210 rtd->compr = compr;
1211 compr->private_data = rtd;
1212
1213 printk(KERN_INFO "compress asoc: %s <-> %s mapping ok\n", codec_dai->name,
1214 cpu_dai->name);
1215 return ret;
1216
1217 compr_err:
1218 kfree(compr);
1219 return ret;
1220 }
1221 EXPORT_SYMBOL_GPL(snd_soc_new_compress);
Linux with added FPC-III support