Version:  2.0.40 2.2.26 2.4.37 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 3.15 3.16 3.17 3.18

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

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