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