Version:  2.6.34 2.6.35 2.6.36 2.6.37 2.6.38 2.6.39 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14

Linux/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_dai *cpu_dai = rtd->cpu_dai;
 34         struct snd_soc_dai *codec_dai = rtd->codec_dai;
 35         int ret = 0;
 36 
 37         mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
 38 
 39         if (platform->driver->compr_ops && platform->driver->compr_ops->open) {
 40                 ret = platform->driver->compr_ops->open(cstream);
 41                 if (ret < 0) {
 42                         pr_err("compress asoc: can't open platform %s\n", platform->name);
 43                         goto out;
 44                 }
 45         }
 46 
 47         if (rtd->dai_link->compr_ops && rtd->dai_link->compr_ops->startup) {
 48                 ret = rtd->dai_link->compr_ops->startup(cstream);
 49                 if (ret < 0) {
 50                         pr_err("compress asoc: %s startup failed\n", rtd->dai_link->name);
 51                         goto machine_err;
 52                 }
 53         }
 54 
 55         if (cstream->direction == SND_COMPRESS_PLAYBACK) {
 56                 cpu_dai->playback_active++;
 57                 codec_dai->playback_active++;
 58         } else {
 59                 cpu_dai->capture_active++;
 60                 codec_dai->capture_active++;
 61         }
 62 
 63         cpu_dai->active++;
 64         codec_dai->active++;
 65         rtd->codec->active++;
 66 
 67         mutex_unlock(&rtd->pcm_mutex);
 68 
 69         return 0;
 70 
 71 machine_err:
 72         if (platform->driver->compr_ops && platform->driver->compr_ops->free)
 73                 platform->driver->compr_ops->free(cstream);
 74 out:
 75         mutex_unlock(&rtd->pcm_mutex);
 76         return ret;
 77 }
 78 
 79 static int soc_compr_open_fe(struct snd_compr_stream *cstream)
 80 {
 81         struct snd_soc_pcm_runtime *fe = cstream->private_data;
 82         struct snd_pcm_substream *fe_substream = fe->pcm->streams[0].substream;
 83         struct snd_soc_platform *platform = fe->platform;
 84         struct snd_soc_dai *cpu_dai = fe->cpu_dai;
 85         struct snd_soc_dai *codec_dai = fe->codec_dai;
 86         struct snd_soc_dpcm *dpcm;
 87         struct snd_soc_dapm_widget_list *list;
 88         int stream;
 89         int ret = 0;
 90 
 91         if (cstream->direction == SND_COMPRESS_PLAYBACK)
 92                 stream = SNDRV_PCM_STREAM_PLAYBACK;
 93         else
 94                 stream = SNDRV_PCM_STREAM_CAPTURE;
 95 
 96         mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME);
 97 
 98         if (platform->driver->compr_ops && platform->driver->compr_ops->open) {
 99                 ret = platform->driver->compr_ops->open(cstream);
100                 if (ret < 0) {
101                         pr_err("compress asoc: can't open platform %s\n", platform->name);
102                         goto out;
103                 }
104         }
105 
106         if (fe->dai_link->compr_ops && fe->dai_link->compr_ops->startup) {
107                 ret = fe->dai_link->compr_ops->startup(cstream);
108                 if (ret < 0) {
109                         pr_err("compress asoc: %s startup failed\n", fe->dai_link->name);
110                         goto machine_err;
111                 }
112         }
113 
114         fe->dpcm[stream].runtime = fe_substream->runtime;
115 
116         if (dpcm_path_get(fe, stream, &list) <= 0) {
117                 dev_dbg(fe->dev, "ASoC: %s no valid %s route\n",
118                         fe->dai_link->name, stream ? "capture" : "playback");
119         }
120 
121         /* calculate valid and active FE <-> BE dpcms */
122         dpcm_process_paths(fe, stream, &list, 1);
123 
124         fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE;
125 
126         ret = dpcm_be_dai_startup(fe, stream);
127         if (ret < 0) {
128                 /* clean up all links */
129                 list_for_each_entry(dpcm, &fe->dpcm[stream].be_clients, list_be)
130                         dpcm->state = SND_SOC_DPCM_LINK_STATE_FREE;
131 
132                 dpcm_be_disconnect(fe, stream);
133                 fe->dpcm[stream].runtime = NULL;
134                 goto fe_err;
135         }
136 
137         dpcm_clear_pending_state(fe, stream);
138         dpcm_path_put(&list);
139 
140         fe->dpcm[stream].state = SND_SOC_DPCM_STATE_OPEN;
141         fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO;
142 
143         if (cstream->direction == SND_COMPRESS_PLAYBACK) {
144                 cpu_dai->playback_active++;
145                 codec_dai->playback_active++;
146         } else {
147                 cpu_dai->capture_active++;
148                 codec_dai->capture_active++;
149         }
150 
151         cpu_dai->active++;
152         codec_dai->active++;
153         fe->codec->active++;
154 
155         mutex_unlock(&fe->card->mutex);
156 
157         return 0;
158 
159 fe_err:
160         if (fe->dai_link->compr_ops && fe->dai_link->compr_ops->shutdown)
161                 fe->dai_link->compr_ops->shutdown(cstream);
162 machine_err:
163         if (platform->driver->compr_ops && platform->driver->compr_ops->free)
164                 platform->driver->compr_ops->free(cstream);
165 out:
166         fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO;
167         mutex_unlock(&fe->card->mutex);
168         return ret;
169 }
170 
171 /*
172  * Power down the audio subsystem pmdown_time msecs after close is called.
173  * This is to ensure there are no pops or clicks in between any music tracks
174  * due to DAPM power cycling.
175  */
176 static void close_delayed_work(struct work_struct *work)
177 {
178         struct snd_soc_pcm_runtime *rtd =
179                         container_of(work, struct snd_soc_pcm_runtime, delayed_work.work);
180         struct snd_soc_dai *codec_dai = rtd->codec_dai;
181 
182         mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
183 
184         dev_dbg(rtd->dev, "ASoC: pop wq checking: %s status: %s waiting: %s\n",
185                  codec_dai->driver->playback.stream_name,
186                  codec_dai->playback_active ? "active" : "inactive",
187                  rtd->pop_wait ? "yes" : "no");
188 
189         /* are we waiting on this codec DAI stream */
190         if (rtd->pop_wait == 1) {
191                 rtd->pop_wait = 0;
192                 snd_soc_dapm_stream_event(rtd, SNDRV_PCM_STREAM_PLAYBACK,
193                                           SND_SOC_DAPM_STREAM_STOP);
194         }
195 
196         mutex_unlock(&rtd->pcm_mutex);
197 }
198 
199 static int soc_compr_free(struct snd_compr_stream *cstream)
200 {
201         struct snd_soc_pcm_runtime *rtd = cstream->private_data;
202         struct snd_soc_platform *platform = rtd->platform;
203         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
204         struct snd_soc_dai *codec_dai = rtd->codec_dai;
205         struct snd_soc_codec *codec = rtd->codec;
206 
207         mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
208 
209         if (cstream->direction == SND_COMPRESS_PLAYBACK) {
210                 cpu_dai->playback_active--;
211                 codec_dai->playback_active--;
212         } else {
213                 cpu_dai->capture_active--;
214                 codec_dai->capture_active--;
215         }
216 
217         snd_soc_dai_digital_mute(codec_dai, 1, cstream->direction);
218 
219         cpu_dai->active--;
220         codec_dai->active--;
221         codec->active--;
222 
223         if (!cpu_dai->active)
224                 cpu_dai->rate = 0;
225 
226         if (!codec_dai->active)
227                 codec_dai->rate = 0;
228 
229 
230         if (rtd->dai_link->compr_ops && rtd->dai_link->compr_ops->shutdown)
231                 rtd->dai_link->compr_ops->shutdown(cstream);
232 
233         if (platform->driver->compr_ops && platform->driver->compr_ops->free)
234                 platform->driver->compr_ops->free(cstream);
235         cpu_dai->runtime = NULL;
236 
237         if (cstream->direction == SND_COMPRESS_PLAYBACK) {
238                 if (!rtd->pmdown_time || codec->ignore_pmdown_time ||
239                     rtd->dai_link->ignore_pmdown_time) {
240                         snd_soc_dapm_stream_event(rtd,
241                                         SNDRV_PCM_STREAM_PLAYBACK,
242                                         SND_SOC_DAPM_STREAM_STOP);
243                 } else {
244                         rtd->pop_wait = 1;
245                         queue_delayed_work(system_power_efficient_wq,
246                                            &rtd->delayed_work,
247                                            msecs_to_jiffies(rtd->pmdown_time));
248                 }
249         } else {
250                 /* capture streams can be powered down now */
251                 snd_soc_dapm_stream_event(rtd,
252                         SNDRV_PCM_STREAM_CAPTURE,
253                         SND_SOC_DAPM_STREAM_STOP);
254         }
255 
256         mutex_unlock(&rtd->pcm_mutex);
257         return 0;
258 }
259 
260 static int soc_compr_free_fe(struct snd_compr_stream *cstream)
261 {
262         struct snd_soc_pcm_runtime *fe = cstream->private_data;
263         struct snd_soc_platform *platform = fe->platform;
264         struct snd_soc_dai *cpu_dai = fe->cpu_dai;
265         struct snd_soc_dai *codec_dai = fe->codec_dai;
266         struct snd_soc_dpcm *dpcm;
267         int stream, ret;
268 
269         mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME);
270 
271         if (cstream->direction == SND_COMPRESS_PLAYBACK) {
272                 stream = SNDRV_PCM_STREAM_PLAYBACK;
273                 cpu_dai->playback_active--;
274                 codec_dai->playback_active--;
275         } else {
276                 stream = SNDRV_PCM_STREAM_CAPTURE;
277                 cpu_dai->capture_active--;
278                 codec_dai->capture_active--;
279         }
280 
281         cpu_dai->active--;
282         codec_dai->active--;
283         fe->codec->active--;
284 
285         fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE;
286 
287         ret = dpcm_be_dai_hw_free(fe, stream);
288         if (ret < 0)
289                 dev_err(fe->dev, "compressed hw_free failed %d\n", ret);
290 
291         ret = dpcm_be_dai_shutdown(fe, stream);
292 
293         /* mark FE's links ready to prune */
294         list_for_each_entry(dpcm, &fe->dpcm[stream].be_clients, list_be)
295                 dpcm->state = SND_SOC_DPCM_LINK_STATE_FREE;
296 
297         if (stream == SNDRV_PCM_STREAM_PLAYBACK)
298                 dpcm_dapm_stream_event(fe, stream, SND_SOC_DAPM_STREAM_STOP);
299         else
300                 dpcm_dapm_stream_event(fe, stream, SND_SOC_DAPM_STREAM_STOP);
301 
302         fe->dpcm[stream].state = SND_SOC_DPCM_STATE_CLOSE;
303         fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO;
304 
305         dpcm_be_disconnect(fe, stream);
306 
307         fe->dpcm[stream].runtime = NULL;
308 
309         if (fe->dai_link->compr_ops && fe->dai_link->compr_ops->shutdown)
310                 fe->dai_link->compr_ops->shutdown(cstream);
311 
312         if (platform->driver->compr_ops && platform->driver->compr_ops->free)
313                 platform->driver->compr_ops->free(cstream);
314 
315         mutex_unlock(&fe->card->mutex);
316         return 0;
317 }
318 
319 static int soc_compr_trigger(struct snd_compr_stream *cstream, int cmd)
320 {
321 
322         struct snd_soc_pcm_runtime *rtd = cstream->private_data;
323         struct snd_soc_platform *platform = rtd->platform;
324         struct snd_soc_dai *codec_dai = rtd->codec_dai;
325         int ret = 0;
326 
327         mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
328 
329         if (platform->driver->compr_ops && platform->driver->compr_ops->trigger) {
330                 ret = platform->driver->compr_ops->trigger(cstream, cmd);
331                 if (ret < 0)
332                         goto out;
333         }
334 
335         switch (cmd) {
336         case SNDRV_PCM_TRIGGER_START:
337                 snd_soc_dai_digital_mute(codec_dai, 0, cstream->direction);
338                 break;
339         case SNDRV_PCM_TRIGGER_STOP:
340                 snd_soc_dai_digital_mute(codec_dai, 1, cstream->direction);
341                 break;
342         }
343 
344 out:
345         mutex_unlock(&rtd->pcm_mutex);
346         return ret;
347 }
348 
349 static int soc_compr_trigger_fe(struct snd_compr_stream *cstream, int cmd)
350 {
351         struct snd_soc_pcm_runtime *fe = cstream->private_data;
352         struct snd_soc_platform *platform = fe->platform;
353         int ret = 0, stream;
354 
355         if (cmd == SND_COMPR_TRIGGER_PARTIAL_DRAIN ||
356                 cmd == SND_COMPR_TRIGGER_DRAIN) {
357 
358                 if (platform->driver->compr_ops &&
359                         platform->driver->compr_ops->trigger)
360                 return platform->driver->compr_ops->trigger(cstream, cmd);
361         }
362 
363         if (cstream->direction == SND_COMPRESS_PLAYBACK)
364                 stream = SNDRV_PCM_STREAM_PLAYBACK;
365         else
366                 stream = SNDRV_PCM_STREAM_CAPTURE;
367 
368 
369         mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME);
370 
371         if (platform->driver->compr_ops && platform->driver->compr_ops->trigger) {
372                 ret = platform->driver->compr_ops->trigger(cstream, cmd);
373                 if (ret < 0)
374                         goto out;
375         }
376 
377         fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE;
378 
379         ret = dpcm_be_dai_trigger(fe, stream, cmd);
380 
381         switch (cmd) {
382         case SNDRV_PCM_TRIGGER_START:
383         case SNDRV_PCM_TRIGGER_RESUME:
384         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
385                 fe->dpcm[stream].state = SND_SOC_DPCM_STATE_START;
386                 break;
387         case SNDRV_PCM_TRIGGER_STOP:
388         case SNDRV_PCM_TRIGGER_SUSPEND:
389                 fe->dpcm[stream].state = SND_SOC_DPCM_STATE_STOP;
390                 break;
391         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
392                 fe->dpcm[stream].state = SND_SOC_DPCM_STATE_PAUSED;
393                 break;
394         }
395 
396 out:
397         fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO;
398         mutex_unlock(&fe->card->mutex);
399         return ret;
400 }
401 
402 static int soc_compr_set_params(struct snd_compr_stream *cstream,
403                                         struct snd_compr_params *params)
404 {
405         struct snd_soc_pcm_runtime *rtd = cstream->private_data;
406         struct snd_soc_platform *platform = rtd->platform;
407         int ret = 0;
408 
409         mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
410 
411         /* first we call set_params for the platform driver
412          * this should configure the soc side
413          * if the machine has compressed ops then we call that as well
414          * expectation is that platform and machine will configure everything
415          * for this compress path, like configuring pcm port for codec
416          */
417         if (platform->driver->compr_ops && platform->driver->compr_ops->set_params) {
418                 ret = platform->driver->compr_ops->set_params(cstream, params);
419                 if (ret < 0)
420                         goto err;
421         }
422 
423         if (rtd->dai_link->compr_ops && rtd->dai_link->compr_ops->set_params) {
424                 ret = rtd->dai_link->compr_ops->set_params(cstream);
425                 if (ret < 0)
426                         goto err;
427         }
428 
429         if (cstream->direction == SND_COMPRESS_PLAYBACK)
430                 snd_soc_dapm_stream_event(rtd, SNDRV_PCM_STREAM_PLAYBACK,
431                                         SND_SOC_DAPM_STREAM_START);
432         else
433                 snd_soc_dapm_stream_event(rtd, SNDRV_PCM_STREAM_CAPTURE,
434                                         SND_SOC_DAPM_STREAM_START);
435 
436         /* cancel any delayed stream shutdown that is pending */
437         rtd->pop_wait = 0;
438         mutex_unlock(&rtd->pcm_mutex);
439 
440         cancel_delayed_work_sync(&rtd->delayed_work);
441 
442         return ret;
443 
444 err:
445         mutex_unlock(&rtd->pcm_mutex);
446         return ret;
447 }
448 
449 static int soc_compr_set_params_fe(struct snd_compr_stream *cstream,
450                                         struct snd_compr_params *params)
451 {
452         struct snd_soc_pcm_runtime *fe = cstream->private_data;
453         struct snd_pcm_substream *fe_substream = fe->pcm->streams[0].substream;
454         struct snd_soc_platform *platform = fe->platform;
455         int ret = 0, stream;
456 
457         if (cstream->direction == SND_COMPRESS_PLAYBACK)
458                 stream = SNDRV_PCM_STREAM_PLAYBACK;
459         else
460                 stream = SNDRV_PCM_STREAM_CAPTURE;
461 
462         mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME);
463 
464         if (platform->driver->compr_ops && platform->driver->compr_ops->set_params) {
465                 ret = platform->driver->compr_ops->set_params(cstream, params);
466                 if (ret < 0)
467                         goto out;
468         }
469 
470         if (fe->dai_link->compr_ops && fe->dai_link->compr_ops->set_params) {
471                 ret = fe->dai_link->compr_ops->set_params(cstream);
472                 if (ret < 0)
473                         goto out;
474         }
475 
476         /*
477          * Create an empty hw_params for the BE as the machine driver must
478          * fix this up to match DSP decoder and ASRC configuration.
479          * I.e. machine driver fixup for compressed BE is mandatory.
480          */
481         memset(&fe->dpcm[fe_substream->stream].hw_params, 0,
482                 sizeof(struct snd_pcm_hw_params));
483 
484         fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE;
485 
486         ret = dpcm_be_dai_hw_params(fe, stream);
487         if (ret < 0)
488                 goto out;
489 
490         ret = dpcm_be_dai_prepare(fe, stream);
491         if (ret < 0)
492                 goto out;
493 
494         if (stream == SNDRV_PCM_STREAM_PLAYBACK)
495                 dpcm_dapm_stream_event(fe, stream, SND_SOC_DAPM_STREAM_START);
496         else
497                 dpcm_dapm_stream_event(fe, stream, SND_SOC_DAPM_STREAM_START);
498 
499         fe->dpcm[stream].state = SND_SOC_DPCM_STATE_PREPARE;
500 
501 out:
502         fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO;
503         mutex_unlock(&fe->card->mutex);
504         return ret;
505 }
506 
507 static int soc_compr_get_params(struct snd_compr_stream *cstream,
508                                         struct snd_codec *params)
509 {
510         struct snd_soc_pcm_runtime *rtd = cstream->private_data;
511         struct snd_soc_platform *platform = rtd->platform;
512         int ret = 0;
513 
514         mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
515 
516         if (platform->driver->compr_ops && platform->driver->compr_ops->get_params)
517                 ret = platform->driver->compr_ops->get_params(cstream, params);
518 
519         mutex_unlock(&rtd->pcm_mutex);
520         return ret;
521 }
522 
523 static int soc_compr_get_caps(struct snd_compr_stream *cstream,
524                                 struct snd_compr_caps *caps)
525 {
526         struct snd_soc_pcm_runtime *rtd = cstream->private_data;
527         struct snd_soc_platform *platform = rtd->platform;
528         int ret = 0;
529 
530         mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
531 
532         if (platform->driver->compr_ops && platform->driver->compr_ops->get_caps)
533                 ret = platform->driver->compr_ops->get_caps(cstream, caps);
534 
535         mutex_unlock(&rtd->pcm_mutex);
536         return ret;
537 }
538 
539 static int soc_compr_get_codec_caps(struct snd_compr_stream *cstream,
540                                 struct snd_compr_codec_caps *codec)
541 {
542         struct snd_soc_pcm_runtime *rtd = cstream->private_data;
543         struct snd_soc_platform *platform = rtd->platform;
544         int ret = 0;
545 
546         mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
547 
548         if (platform->driver->compr_ops && platform->driver->compr_ops->get_codec_caps)
549                 ret = platform->driver->compr_ops->get_codec_caps(cstream, codec);
550 
551         mutex_unlock(&rtd->pcm_mutex);
552         return ret;
553 }
554 
555 static int soc_compr_ack(struct snd_compr_stream *cstream, size_t bytes)
556 {
557         struct snd_soc_pcm_runtime *rtd = cstream->private_data;
558         struct snd_soc_platform *platform = rtd->platform;
559         int ret = 0;
560 
561         mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
562 
563         if (platform->driver->compr_ops && platform->driver->compr_ops->ack)
564                 ret = platform->driver->compr_ops->ack(cstream, bytes);
565 
566         mutex_unlock(&rtd->pcm_mutex);
567         return ret;
568 }
569 
570 static int soc_compr_pointer(struct snd_compr_stream *cstream,
571                         struct snd_compr_tstamp *tstamp)
572 {
573         struct snd_soc_pcm_runtime *rtd = cstream->private_data;
574         struct snd_soc_platform *platform = rtd->platform;
575 
576         mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
577 
578         if (platform->driver->compr_ops && platform->driver->compr_ops->pointer)
579                  platform->driver->compr_ops->pointer(cstream, tstamp);
580 
581         mutex_unlock(&rtd->pcm_mutex);
582         return 0;
583 }
584 
585 static int soc_compr_copy(struct snd_compr_stream *cstream,
586                           char __user *buf, size_t count)
587 {
588         struct snd_soc_pcm_runtime *rtd = cstream->private_data;
589         struct snd_soc_platform *platform = rtd->platform;
590         int ret = 0;
591 
592         mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
593 
594         if (platform->driver->compr_ops && platform->driver->compr_ops->copy)
595                 ret = platform->driver->compr_ops->copy(cstream, buf, count);
596 
597         mutex_unlock(&rtd->pcm_mutex);
598         return ret;
599 }
600 
601 static int soc_compr_set_metadata(struct snd_compr_stream *cstream,
602                                 struct snd_compr_metadata *metadata)
603 {
604         struct snd_soc_pcm_runtime *rtd = cstream->private_data;
605         struct snd_soc_platform *platform = rtd->platform;
606         int ret = 0;
607 
608         if (platform->driver->compr_ops && platform->driver->compr_ops->set_metadata)
609                 ret = platform->driver->compr_ops->set_metadata(cstream, metadata);
610 
611         return ret;
612 }
613 
614 static int soc_compr_get_metadata(struct snd_compr_stream *cstream,
615                                 struct snd_compr_metadata *metadata)
616 {
617         struct snd_soc_pcm_runtime *rtd = cstream->private_data;
618         struct snd_soc_platform *platform = rtd->platform;
619         int ret = 0;
620 
621         if (platform->driver->compr_ops && platform->driver->compr_ops->get_metadata)
622                 ret = platform->driver->compr_ops->get_metadata(cstream, metadata);
623 
624         return ret;
625 }
626 
627 /* ASoC Compress operations */
628 static struct snd_compr_ops soc_compr_ops = {
629         .open           = soc_compr_open,
630         .free           = soc_compr_free,
631         .set_params     = soc_compr_set_params,
632         .set_metadata   = soc_compr_set_metadata,
633         .get_metadata   = soc_compr_get_metadata,
634         .get_params     = soc_compr_get_params,
635         .trigger        = soc_compr_trigger,
636         .pointer        = soc_compr_pointer,
637         .ack            = soc_compr_ack,
638         .get_caps       = soc_compr_get_caps,
639         .get_codec_caps = soc_compr_get_codec_caps
640 };
641 
642 /* ASoC Dynamic Compress operations */
643 static struct snd_compr_ops soc_compr_dyn_ops = {
644         .open           = soc_compr_open_fe,
645         .free           = soc_compr_free_fe,
646         .set_params     = soc_compr_set_params_fe,
647         .get_params     = soc_compr_get_params,
648         .set_metadata   = soc_compr_set_metadata,
649         .get_metadata   = soc_compr_get_metadata,
650         .trigger        = soc_compr_trigger_fe,
651         .pointer        = soc_compr_pointer,
652         .ack            = soc_compr_ack,
653         .get_caps       = soc_compr_get_caps,
654         .get_codec_caps = soc_compr_get_codec_caps
655 };
656 
657 /* create a new compress */
658 int soc_new_compress(struct snd_soc_pcm_runtime *rtd, int num)
659 {
660         struct snd_soc_codec *codec = rtd->codec;
661         struct snd_soc_platform *platform = rtd->platform;
662         struct snd_soc_dai *codec_dai = rtd->codec_dai;
663         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
664         struct snd_compr *compr;
665         struct snd_pcm *be_pcm;
666         char new_name[64];
667         int ret = 0, direction = 0;
668 
669         /* check client and interface hw capabilities */
670         snprintf(new_name, sizeof(new_name), "%s %s-%d",
671                         rtd->dai_link->stream_name, codec_dai->name, num);
672 
673         if (codec_dai->driver->playback.channels_min)
674                 direction = SND_COMPRESS_PLAYBACK;
675         else if (codec_dai->driver->capture.channels_min)
676                 direction = SND_COMPRESS_CAPTURE;
677         else
678                 return -EINVAL;
679 
680         compr = kzalloc(sizeof(*compr), GFP_KERNEL);
681         if (compr == NULL) {
682                 snd_printk(KERN_ERR "Cannot allocate compr\n");
683                 return -ENOMEM;
684         }
685 
686         compr->ops = devm_kzalloc(rtd->card->dev, sizeof(soc_compr_ops),
687                                   GFP_KERNEL);
688         if (compr->ops == NULL) {
689                 dev_err(rtd->card->dev, "Cannot allocate compressed ops\n");
690                 ret = -ENOMEM;
691                 goto compr_err;
692         }
693 
694         if (rtd->dai_link->dynamic) {
695                 snprintf(new_name, sizeof(new_name), "(%s)",
696                         rtd->dai_link->stream_name);
697 
698                 ret = snd_pcm_new_internal(rtd->card->snd_card, new_name, num,
699                                 1, 0, &be_pcm);
700                 if (ret < 0) {
701                         dev_err(rtd->card->dev, "ASoC: can't create compressed for %s\n",
702                                 rtd->dai_link->name);
703                         goto compr_err;
704                 }
705 
706                 rtd->pcm = be_pcm;
707                 rtd->fe_compr = 1;
708                 be_pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream->private_data = rtd;
709                 be_pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream->private_data = rtd;
710                 memcpy(compr->ops, &soc_compr_dyn_ops, sizeof(soc_compr_dyn_ops));
711         } else
712                 memcpy(compr->ops, &soc_compr_ops, sizeof(soc_compr_ops));
713 
714         /* Add copy callback for not memory mapped DSPs */
715         if (platform->driver->compr_ops && platform->driver->compr_ops->copy)
716                 compr->ops->copy = soc_compr_copy;
717 
718         mutex_init(&compr->lock);
719         ret = snd_compress_new(rtd->card->snd_card, num, direction, compr);
720         if (ret < 0) {
721                 pr_err("compress asoc: can't create compress for codec %s\n",
722                         codec->name);
723                 goto compr_err;
724         }
725 
726         /* DAPM dai link stream work */
727         INIT_DELAYED_WORK(&rtd->delayed_work, close_delayed_work);
728 
729         rtd->compr = compr;
730         compr->private_data = rtd;
731 
732         printk(KERN_INFO "compress asoc: %s <-> %s mapping ok\n", codec_dai->name,
733                 cpu_dai->name);
734         return ret;
735 
736 compr_err:
737         kfree(compr);
738         return ret;
739 }
740 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us