Merge remote-tracking branches 'asoc/fix/compress', 'asoc/fix/core', 'asoc/fix/dapm...
[sfrench/cifs-2.6.git] / sound / soc / soc-compress.c
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_platform *platform = rtd->platform;
1100         struct snd_soc_component *component;
1101         struct snd_soc_rtdcom_list *rtdcom;
1102         struct snd_soc_dai *codec_dai = rtd->codec_dai;
1103         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
1104         struct snd_compr *compr;
1105         struct snd_pcm *be_pcm;
1106         char new_name[64];
1107         int ret = 0, direction = 0;
1108         int playback = 0, capture = 0;
1109
1110         if (rtd->num_codecs > 1) {
1111                 dev_err(rtd->card->dev, "Multicodec not supported for compressed stream\n");
1112                 return -EINVAL;
1113         }
1114
1115         /* check client and interface hw capabilities */
1116         if (codec_dai->driver->playback.channels_min)
1117                 playback = 1;
1118         if (codec_dai->driver->capture.channels_min)
1119                 capture = 1;
1120
1121         capture = capture && cpu_dai->driver->capture.channels_min;
1122         playback = playback && cpu_dai->driver->playback.channels_min;
1123
1124         /*
1125          * Compress devices are unidirectional so only one of the directions
1126          * should be set, check for that (xor)
1127          */
1128         if (playback + capture != 1) {
1129                 dev_err(rtd->card->dev, "Invalid direction for compress P %d, C %d\n",
1130                                 playback, capture);
1131                 return -EINVAL;
1132         }
1133
1134         if (playback)
1135                 direction = SND_COMPRESS_PLAYBACK;
1136         else
1137                 direction = SND_COMPRESS_CAPTURE;
1138
1139         compr = kzalloc(sizeof(*compr), GFP_KERNEL);
1140         if (!compr)
1141                 return -ENOMEM;
1142
1143         compr->ops = devm_kzalloc(rtd->card->dev, sizeof(soc_compr_ops),
1144                                   GFP_KERNEL);
1145         if (!compr->ops) {
1146                 ret = -ENOMEM;
1147                 goto compr_err;
1148         }
1149
1150         if (rtd->dai_link->dynamic) {
1151                 snprintf(new_name, sizeof(new_name), "(%s)",
1152                         rtd->dai_link->stream_name);
1153
1154                 ret = snd_pcm_new_internal(rtd->card->snd_card, new_name, num,
1155                                 rtd->dai_link->dpcm_playback,
1156                                 rtd->dai_link->dpcm_capture, &be_pcm);
1157                 if (ret < 0) {
1158                         dev_err(rtd->card->dev, "ASoC: can't create compressed for %s\n",
1159                                 rtd->dai_link->name);
1160                         goto compr_err;
1161                 }
1162
1163                 rtd->pcm = be_pcm;
1164                 rtd->fe_compr = 1;
1165                 if (rtd->dai_link->dpcm_playback)
1166                         be_pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream->private_data = rtd;
1167                 else if (rtd->dai_link->dpcm_capture)
1168                         be_pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream->private_data = rtd;
1169                 memcpy(compr->ops, &soc_compr_dyn_ops, sizeof(soc_compr_dyn_ops));
1170         } else {
1171                 snprintf(new_name, sizeof(new_name), "%s %s-%d",
1172                         rtd->dai_link->stream_name, codec_dai->name, num);
1173
1174                 memcpy(compr->ops, &soc_compr_ops, sizeof(soc_compr_ops));
1175         }
1176
1177
1178         /* Add copy callback for not memory mapped DSPs */
1179         if (platform && platform->driver->compr_ops && platform->driver->compr_ops->copy)
1180                 compr->ops->copy = soc_compr_copy;
1181
1182         for_each_rtdcom(rtd, rtdcom) {
1183                 component = rtdcom->component;
1184
1185                 /* ignore duplication for now */
1186                 if (platform && (component == &platform->component))
1187                         continue;
1188
1189                 if (!component->driver->compr_ops ||
1190                     !component->driver->compr_ops->copy)
1191                         continue;
1192
1193                 compr->ops->copy = soc_compr_copy;
1194         }
1195
1196
1197         mutex_init(&compr->lock);
1198         ret = snd_compress_new(rtd->card->snd_card, num, direction,
1199                                 new_name, compr);
1200         if (ret < 0) {
1201                 component = rtd->codec_dai->component;
1202                 pr_err("compress asoc: can't create compress for codec %s\n",
1203                         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);