Commit | Line | Data |
---|---|---|
1245b700 NK |
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> | |
2a99ef0f | 27 | #include <sound/soc-dpcm.h> |
1245b700 NK |
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; | |
9e7e3738 KM |
33 | struct snd_soc_component *component; |
34 | struct snd_soc_rtdcom_list *rtdcom; | |
2e622ae4 | 35 | struct snd_soc_dai *cpu_dai = rtd->cpu_dai; |
9e7e3738 | 36 | int ret = 0, __ret; |
1245b700 | 37 | |
15e2e619 CK |
38 | mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass); |
39 | ||
2e622ae4 VK |
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 | ||
9e7e3738 | 49 | if (platform && platform->driver->compr_ops && platform->driver->compr_ops->open) { |
1245b700 NK |
50 | ret = platform->driver->compr_ops->open(cstream); |
51 | if (ret < 0) { | |
f4333203 LPC |
52 | pr_err("compress asoc: can't open platform %s\n", |
53 | platform->component.name); | |
2e622ae4 | 54 | goto plat_err; |
1245b700 NK |
55 | } |
56 | } | |
57 | ||
9e7e3738 KM |
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 | ||
1245b700 NK |
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 | ||
24894b76 | 87 | snd_soc_runtime_activate(rtd, cstream->direction); |
1245b700 | 88 | |
15e2e619 CK |
89 | mutex_unlock(&rtd->pcm_mutex); |
90 | ||
1245b700 NK |
91 | return 0; |
92 | ||
93 | machine_err: | |
9e7e3738 KM |
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) | |
1245b700 | 109 | platform->driver->compr_ops->free(cstream); |
2e622ae4 VK |
110 | plat_err: |
111 | if (cpu_dai->driver->cops && cpu_dai->driver->cops->shutdown) | |
112 | cpu_dai->driver->cops->shutdown(cstream, cpu_dai); | |
1245b700 | 113 | out: |
15e2e619 | 114 | mutex_unlock(&rtd->pcm_mutex); |
1245b700 NK |
115 | return ret; |
116 | } | |
117 | ||
2a99ef0f LG |
118 | static int soc_compr_open_fe(struct snd_compr_stream *cstream) |
119 | { | |
120 | struct snd_soc_pcm_runtime *fe = cstream->private_data; | |
01b8cedf SBP |
121 | struct snd_pcm_substream *fe_substream = |
122 | fe->pcm->streams[cstream->direction].substream; | |
2a99ef0f | 123 | struct snd_soc_platform *platform = fe->platform; |
9e7e3738 KM |
124 | struct snd_soc_component *component; |
125 | struct snd_soc_rtdcom_list *rtdcom; | |
2e622ae4 | 126 | struct snd_soc_dai *cpu_dai = fe->cpu_dai; |
2a99ef0f LG |
127 | struct snd_soc_dpcm *dpcm; |
128 | struct snd_soc_dapm_widget_list *list; | |
129 | int stream; | |
9e7e3738 | 130 | int ret = 0, __ret; |
2a99ef0f LG |
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 | ||
2e622ae4 VK |
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 | ||
9e7e3738 | 149 | if (platform && platform->driver->compr_ops && platform->driver->compr_ops->open) { |
2a99ef0f LG |
150 | ret = platform->driver->compr_ops->open(cstream); |
151 | if (ret < 0) { | |
f4333203 LPC |
152 | pr_err("compress asoc: can't open platform %s\n", |
153 | platform->component.name); | |
2e622ae4 | 154 | goto plat_err; |
2a99ef0f LG |
155 | } |
156 | } | |
157 | ||
9e7e3738 KM |
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 | ||
2a99ef0f LG |
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 | ||
8f70e515 | 189 | ret = dpcm_path_get(fe, stream, &list); |
2e4ec1c0 | 190 | if (ret < 0) |
8f70e515 | 191 | goto fe_err; |
2e4ec1c0 | 192 | else if (ret == 0) |
2a99ef0f LG |
193 | dev_dbg(fe->dev, "ASoC: %s no valid %s route\n", |
194 | fe->dai_link->name, stream ? "capture" : "playback"); | |
2a99ef0f LG |
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; | |
b0f12c61 | 209 | goto path_err; |
2a99ef0f LG |
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 | ||
24894b76 | 218 | snd_soc_runtime_activate(fe, stream); |
2a99ef0f LG |
219 | |
220 | mutex_unlock(&fe->card->mutex); | |
221 | ||
222 | return 0; | |
223 | ||
b0f12c61 CK |
224 | path_err: |
225 | dpcm_path_put(&list); | |
2a99ef0f LG |
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: | |
9e7e3738 KM |
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) | |
2a99ef0f | 245 | platform->driver->compr_ops->free(cstream); |
2e622ae4 VK |
246 | plat_err: |
247 | if (cpu_dai->driver->cops && cpu_dai->driver->cops->shutdown) | |
248 | cpu_dai->driver->cops->shutdown(cstream, cpu_dai); | |
2a99ef0f LG |
249 | out: |
250 | fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO; | |
251 | mutex_unlock(&fe->card->mutex); | |
252 | return ret; | |
253 | } | |
254 | ||
202c8f70 CK |
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 | ||
1245b700 NK |
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; | |
9e7e3738 KM |
287 | struct snd_soc_component *component; |
288 | struct snd_soc_rtdcom_list *rtdcom; | |
1245b700 NK |
289 | struct snd_soc_dai *cpu_dai = rtd->cpu_dai; |
290 | struct snd_soc_dai *codec_dai = rtd->codec_dai; | |
24894b76 | 291 | int stream; |
1245b700 | 292 | |
15e2e619 CK |
293 | mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass); |
294 | ||
24894b76 LPC |
295 | if (cstream->direction == SND_COMPRESS_PLAYBACK) |
296 | stream = SNDRV_PCM_STREAM_PLAYBACK; | |
297 | else | |
298 | stream = SNDRV_PCM_STREAM_CAPTURE; | |
1245b700 | 299 | |
24894b76 | 300 | snd_soc_runtime_deactivate(rtd, stream); |
da18396f | 301 | |
24894b76 | 302 | snd_soc_dai_digital_mute(codec_dai, 1, cstream->direction); |
1245b700 NK |
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 | ||
9e7e3738 KM |
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) | |
1245b700 | 329 | platform->driver->compr_ops->free(cstream); |
1245b700 | 330 | |
2e622ae4 VK |
331 | if (cpu_dai->driver->cops && cpu_dai->driver->cops->shutdown) |
332 | cpu_dai->driver->cops->shutdown(cstream, cpu_dai); | |
333 | ||
1245b700 | 334 | if (cstream->direction == SND_COMPRESS_PLAYBACK) { |
208a1589 | 335 | if (snd_soc_runtime_ignore_pmdown_time(rtd)) { |
1245b700 NK |
336 | snd_soc_dapm_stream_event(rtd, |
337 | SNDRV_PCM_STREAM_PLAYBACK, | |
338 | SND_SOC_DAPM_STREAM_STOP); | |
8c3d2aa4 | 339 | } else { |
9bffb1fb | 340 | rtd->pop_wait = 1; |
3d24cfe4 MB |
341 | queue_delayed_work(system_power_efficient_wq, |
342 | &rtd->delayed_work, | |
343 | msecs_to_jiffies(rtd->pmdown_time)); | |
8c3d2aa4 | 344 | } |
1245b700 NK |
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 | ||
15e2e619 | 352 | mutex_unlock(&rtd->pcm_mutex); |
1245b700 NK |
353 | return 0; |
354 | } | |
355 | ||
2a99ef0f LG |
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; | |
9e7e3738 KM |
360 | struct snd_soc_component *component; |
361 | struct snd_soc_rtdcom_list *rtdcom; | |
2e622ae4 | 362 | struct snd_soc_dai *cpu_dai = fe->cpu_dai; |
2a99ef0f LG |
363 | struct snd_soc_dpcm *dpcm; |
364 | int stream, ret; | |
365 | ||
366 | mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME); | |
367 | ||
24894b76 | 368 | if (cstream->direction == SND_COMPRESS_PLAYBACK) |
2a99ef0f | 369 | stream = SNDRV_PCM_STREAM_PLAYBACK; |
24894b76 | 370 | else |
2a99ef0f | 371 | stream = SNDRV_PCM_STREAM_CAPTURE; |
2a99ef0f | 372 | |
24894b76 | 373 | snd_soc_runtime_deactivate(fe, stream); |
2a99ef0f LG |
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 | ||
15f6b09a | 387 | dpcm_dapm_stream_event(fe, stream, SND_SOC_DAPM_STREAM_STOP); |
2a99ef0f LG |
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 | ||
9e7e3738 | 399 | if (platform && platform->driver->compr_ops && platform->driver->compr_ops->free) |
2a99ef0f LG |
400 | platform->driver->compr_ops->free(cstream); |
401 | ||
9e7e3738 KM |
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 | ||
2e622ae4 VK |
416 | if (cpu_dai->driver->cops && cpu_dai->driver->cops->shutdown) |
417 | cpu_dai->driver->cops->shutdown(cstream, cpu_dai); | |
418 | ||
2a99ef0f LG |
419 | mutex_unlock(&fe->card->mutex); |
420 | return 0; | |
421 | } | |
422 | ||
1245b700 NK |
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; | |
9e7e3738 KM |
428 | struct snd_soc_component *component; |
429 | struct snd_soc_rtdcom_list *rtdcom; | |
1245b700 | 430 | struct snd_soc_dai *codec_dai = rtd->codec_dai; |
2e622ae4 | 431 | struct snd_soc_dai *cpu_dai = rtd->cpu_dai; |
9e7e3738 | 432 | int ret = 0, __ret; |
1245b700 | 433 | |
15e2e619 CK |
434 | mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass); |
435 | ||
9e7e3738 | 436 | if (platform && platform->driver->compr_ops && platform->driver->compr_ops->trigger) { |
1245b700 NK |
437 | ret = platform->driver->compr_ops->trigger(cstream, cmd); |
438 | if (ret < 0) | |
15e2e619 | 439 | goto out; |
1245b700 NK |
440 | } |
441 | ||
9e7e3738 KM |
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 | ||
2e622ae4 VK |
460 | if (cpu_dai->driver->cops && cpu_dai->driver->cops->trigger) |
461 | cpu_dai->driver->cops->trigger(cstream, cmd, cpu_dai); | |
462 | ||
463 | ||
da18396f MB |
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; | |
e38b9b74 | 471 | } |
1245b700 | 472 | |
15e2e619 CK |
473 | out: |
474 | mutex_unlock(&rtd->pcm_mutex); | |
1245b700 NK |
475 | return ret; |
476 | } | |
477 | ||
2a99ef0f LG |
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; | |
9e7e3738 KM |
482 | struct snd_soc_component *component; |
483 | struct snd_soc_rtdcom_list *rtdcom; | |
2e622ae4 | 484 | struct snd_soc_dai *cpu_dai = fe->cpu_dai; |
9e7e3738 | 485 | int ret = 0, __ret, stream; |
2a99ef0f LG |
486 | |
487 | if (cmd == SND_COMPR_TRIGGER_PARTIAL_DRAIN || | |
488 | cmd == SND_COMPR_TRIGGER_DRAIN) { | |
489 | ||
9e7e3738 KM |
490 | if (platform && |
491 | platform->driver->compr_ops && | |
15b8e94f DC |
492 | platform->driver->compr_ops->trigger) |
493 | return platform->driver->compr_ops->trigger(cstream, | |
494 | cmd); | |
9e7e3738 KM |
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; | |
2a99ef0f LG |
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 | ||
2e622ae4 VK |
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 | ||
9e7e3738 | 528 | if (platform && platform->driver->compr_ops && platform->driver->compr_ops->trigger) { |
2a99ef0f LG |
529 | ret = platform->driver->compr_ops->trigger(cstream, cmd); |
530 | if (ret < 0) | |
531 | goto out; | |
532 | } | |
533 | ||
9e7e3738 KM |
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 | ||
2a99ef0f LG |
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 | ||
1245b700 NK |
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; | |
9e7e3738 KM |
582 | struct snd_soc_component *component; |
583 | struct snd_soc_rtdcom_list *rtdcom; | |
2e622ae4 | 584 | struct snd_soc_dai *cpu_dai = rtd->cpu_dai; |
9e7e3738 | 585 | int ret = 0, __ret; |
1245b700 | 586 | |
15e2e619 CK |
587 | mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass); |
588 | ||
1245b700 NK |
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 | */ | |
2e622ae4 VK |
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 | ||
9e7e3738 | 601 | if (platform && platform->driver->compr_ops && platform->driver->compr_ops->set_params) { |
1245b700 NK |
602 | ret = platform->driver->compr_ops->set_params(cstream, params); |
603 | if (ret < 0) | |
fa40ef20 | 604 | goto err; |
1245b700 NK |
605 | } |
606 | ||
9e7e3738 KM |
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 | ||
1245b700 NK |
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) | |
fa40ef20 | 628 | goto err; |
1245b700 NK |
629 | } |
630 | ||
2c071ed7 CK |
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); | |
1245b700 | 637 | |
fa40ef20 CK |
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: | |
15e2e619 | 647 | mutex_unlock(&rtd->pcm_mutex); |
1245b700 NK |
648 | return ret; |
649 | } | |
650 | ||
2a99ef0f LG |
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; | |
01b8cedf SBP |
655 | struct snd_pcm_substream *fe_substream = |
656 | fe->pcm->streams[cstream->direction].substream; | |
2a99ef0f | 657 | struct snd_soc_platform *platform = fe->platform; |
9e7e3738 KM |
658 | struct snd_soc_component *component; |
659 | struct snd_soc_rtdcom_list *rtdcom; | |
2e622ae4 | 660 | struct snd_soc_dai *cpu_dai = fe->cpu_dai; |
9e7e3738 | 661 | int ret = 0, __ret, stream; |
2a99ef0f LG |
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 | ||
2e622ae4 VK |
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 | ||
9e7e3738 | 676 | if (platform && platform->driver->compr_ops && platform->driver->compr_ops->set_params) { |
2a99ef0f LG |
677 | ret = platform->driver->compr_ops->set_params(cstream, params); |
678 | if (ret < 0) | |
679 | goto out; | |
680 | } | |
681 | ||
9e7e3738 KM |
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 | ||
2a99ef0f LG |
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 | ||
15f6b09a | 724 | dpcm_dapm_stream_event(fe, stream, SND_SOC_DAPM_STREAM_START); |
2a99ef0f LG |
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 | ||
1245b700 NK |
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; | |
9e7e3738 KM |
738 | struct snd_soc_component *component; |
739 | struct snd_soc_rtdcom_list *rtdcom; | |
2e622ae4 | 740 | struct snd_soc_dai *cpu_dai = rtd->cpu_dai; |
9e7e3738 | 741 | int ret = 0, __ret; |
1245b700 | 742 | |
15e2e619 CK |
743 | mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass); |
744 | ||
2e622ae4 VK |
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 | ||
9e7e3738 | 751 | if (platform && platform->driver->compr_ops && platform->driver->compr_ops->get_params) { |
1245b700 | 752 | ret = platform->driver->compr_ops->get_params(cstream, params); |
9e7e3738 KM |
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 | } | |
1245b700 | 772 | |
2e622ae4 | 773 | err: |
15e2e619 | 774 | mutex_unlock(&rtd->pcm_mutex); |
1245b700 NK |
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; | |
9e7e3738 KM |
783 | struct snd_soc_component *component; |
784 | struct snd_soc_rtdcom_list *rtdcom; | |
785 | int ret = 0, __ret; | |
1245b700 | 786 | |
15e2e619 CK |
787 | mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass); |
788 | ||
9e7e3738 | 789 | if (platform && platform->driver->compr_ops && platform->driver->compr_ops->get_caps) { |
1245b700 | 790 | ret = platform->driver->compr_ops->get_caps(cstream, caps); |
9e7e3738 KM |
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; | |
1245b700 | 801 | |
9e7e3738 KM |
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: | |
15e2e619 | 812 | mutex_unlock(&rtd->pcm_mutex); |
1245b700 NK |
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; | |
9e7e3738 KM |
821 | struct snd_soc_component *component; |
822 | struct snd_soc_rtdcom_list *rtdcom; | |
823 | int ret = 0, __ret; | |
1245b700 | 824 | |
15e2e619 CK |
825 | mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass); |
826 | ||
9e7e3738 | 827 | if (platform && platform->driver->compr_ops && platform->driver->compr_ops->get_codec_caps) { |
1245b700 | 828 | ret = platform->driver->compr_ops->get_codec_caps(cstream, codec); |
9e7e3738 KM |
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; | |
1245b700 | 839 | |
9e7e3738 KM |
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: | |
15e2e619 | 850 | mutex_unlock(&rtd->pcm_mutex); |
1245b700 NK |
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; | |
9e7e3738 KM |
858 | struct snd_soc_component *component; |
859 | struct snd_soc_rtdcom_list *rtdcom; | |
2e622ae4 | 860 | struct snd_soc_dai *cpu_dai = rtd->cpu_dai; |
9e7e3738 | 861 | int ret = 0, __ret; |
1245b700 | 862 | |
15e2e619 CK |
863 | mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass); |
864 | ||
2e622ae4 VK |
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 | ||
9e7e3738 | 871 | if (platform && platform->driver->compr_ops && platform->driver->compr_ops->ack) { |
1245b700 | 872 | ret = platform->driver->compr_ops->ack(cstream, bytes); |
9e7e3738 KM |
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 | } | |
1245b700 | 892 | |
2e622ae4 | 893 | err: |
15e2e619 | 894 | mutex_unlock(&rtd->pcm_mutex); |
1245b700 NK |
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; | |
9e7e3738 KM |
903 | struct snd_soc_component *component; |
904 | struct snd_soc_rtdcom_list *rtdcom; | |
905 | int ret = 0, __ret; | |
2e622ae4 | 906 | struct snd_soc_dai *cpu_dai = rtd->cpu_dai; |
1245b700 | 907 | |
15e2e619 CK |
908 | mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass); |
909 | ||
2e622ae4 VK |
910 | if (cpu_dai->driver->cops && cpu_dai->driver->cops->pointer) |
911 | cpu_dai->driver->cops->pointer(cstream, tstamp, cpu_dai); | |
912 | ||
9e7e3738 | 913 | if (platform && platform->driver->compr_ops && platform->driver->compr_ops->pointer) { |
7c9190f7 | 914 | ret = platform->driver->compr_ops->pointer(cstream, tstamp); |
9e7e3738 KM |
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; | |
1245b700 | 929 | |
9e7e3738 KM |
930 | __ret = component->driver->compr_ops->pointer(cstream, tstamp); |
931 | if (__ret < 0) | |
932 | ret = __ret; | |
933 | } | |
934 | ||
935 | err: | |
15e2e619 | 936 | mutex_unlock(&rtd->pcm_mutex); |
7c9190f7 | 937 | return ret; |
1245b700 NK |
938 | } |
939 | ||
1f88eb0f | 940 | static int soc_compr_copy(struct snd_compr_stream *cstream, |
4daf891c | 941 | char __user *buf, size_t count) |
1f88eb0f CK |
942 | { |
943 | struct snd_soc_pcm_runtime *rtd = cstream->private_data; | |
944 | struct snd_soc_platform *platform = rtd->platform; | |
9e7e3738 KM |
945 | struct snd_soc_component *component; |
946 | struct snd_soc_rtdcom_list *rtdcom; | |
947 | int ret = 0, __ret; | |
1f88eb0f CK |
948 | |
949 | mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass); | |
950 | ||
9e7e3738 | 951 | if (platform && platform->driver->compr_ops && platform->driver->compr_ops->copy) { |
1f88eb0f | 952 | ret = platform->driver->compr_ops->copy(cstream, buf, count); |
9e7e3738 KM |
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; | |
1f88eb0f | 967 | |
9e7e3738 KM |
968 | __ret = component->driver->compr_ops->copy(cstream, buf, count); |
969 | if (__ret < 0) | |
970 | ret = __ret; | |
971 | } | |
972 | err: | |
1f88eb0f CK |
973 | mutex_unlock(&rtd->pcm_mutex); |
974 | return ret; | |
975 | } | |
976 | ||
02bd90e8 | 977 | static int soc_compr_set_metadata(struct snd_compr_stream *cstream, |
36953d98 JK |
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; | |
9e7e3738 KM |
982 | struct snd_soc_component *component; |
983 | struct snd_soc_rtdcom_list *rtdcom; | |
2e622ae4 | 984 | struct snd_soc_dai *cpu_dai = rtd->cpu_dai; |
9e7e3738 | 985 | int ret = 0, __ret; |
36953d98 | 986 | |
2e622ae4 VK |
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 | ||
9e7e3738 | 993 | if (platform && platform->driver->compr_ops && platform->driver->compr_ops->set_metadata) { |
36953d98 | 994 | ret = platform->driver->compr_ops->set_metadata(cstream, metadata); |
9e7e3738 KM |
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 | } | |
36953d98 JK |
1014 | |
1015 | return ret; | |
1016 | } | |
1017 | ||
02bd90e8 | 1018 | static int soc_compr_get_metadata(struct snd_compr_stream *cstream, |
36953d98 JK |
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; | |
9e7e3738 KM |
1023 | struct snd_soc_component *component; |
1024 | struct snd_soc_rtdcom_list *rtdcom; | |
2e622ae4 | 1025 | struct snd_soc_dai *cpu_dai = rtd->cpu_dai; |
9e7e3738 | 1026 | int ret = 0, __ret; |
36953d98 | 1027 | |
2e622ae4 VK |
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 | ||
9e7e3738 | 1034 | if (platform && platform->driver->compr_ops && platform->driver->compr_ops->get_metadata) { |
36953d98 | 1035 | ret = platform->driver->compr_ops->get_metadata(cstream, metadata); |
9e7e3738 KM |
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 | } | |
36953d98 JK |
1055 | |
1056 | return ret; | |
1057 | } | |
2a99ef0f | 1058 | |
1245b700 NK |
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, | |
02bd90e8 VK |
1064 | .set_metadata = soc_compr_set_metadata, |
1065 | .get_metadata = soc_compr_get_metadata, | |
1245b700 NK |
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 | ||
2a99ef0f LG |
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 | ||
6f0c4226 JY |
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) | |
1245b700 NK |
1098 | { |
1099 | struct snd_soc_codec *codec = rtd->codec; | |
1f88eb0f | 1100 | struct snd_soc_platform *platform = rtd->platform; |
9e7e3738 KM |
1101 | struct snd_soc_component *component; |
1102 | struct snd_soc_rtdcom_list *rtdcom; | |
1245b700 NK |
1103 | struct snd_soc_dai *codec_dai = rtd->codec_dai; |
1104 | struct snd_soc_dai *cpu_dai = rtd->cpu_dai; | |
1105 | struct snd_compr *compr; | |
2a99ef0f | 1106 | struct snd_pcm *be_pcm; |
1245b700 NK |
1107 | char new_name[64]; |
1108 | int ret = 0, direction = 0; | |
a1068045 | 1109 | int playback = 0, capture = 0; |
1245b700 | 1110 | |
8151d5e6 BC |
1111 | if (rtd->num_codecs > 1) { |
1112 | dev_err(rtd->card->dev, "Multicodec not supported for compressed stream\n"); | |
1113 | return -EINVAL; | |
1114 | } | |
1115 | ||
1245b700 | 1116 | /* check client and interface hw capabilities */ |
daa2db59 | 1117 | if (codec_dai->driver->playback.channels_min) |
a1068045 VK |
1118 | playback = 1; |
1119 | if (codec_dai->driver->capture.channels_min) | |
1120 | capture = 1; | |
1121 | ||
1122 | capture = capture && cpu_dai->driver->capture.channels_min; | |
1123 | playback = playback && cpu_dai->driver->playback.channels_min; | |
1124 | ||
1125 | /* | |
1126 | * Compress devices are unidirectional so only one of the directions | |
1127 | * should be set, check for that (xor) | |
1128 | */ | |
1129 | if (playback + capture != 1) { | |
1130 | dev_err(rtd->card->dev, "Invalid direction for compress P %d, C %d\n", | |
1131 | playback, capture); | |
1132 | return -EINVAL; | |
1133 | } | |
1134 | ||
aeb6fa0f | 1135 | if (playback) |
daa2db59 | 1136 | direction = SND_COMPRESS_PLAYBACK; |
daa2db59 | 1137 | else |
a1068045 | 1138 | direction = SND_COMPRESS_CAPTURE; |
daa2db59 | 1139 | |
1245b700 | 1140 | compr = kzalloc(sizeof(*compr), GFP_KERNEL); |
7a0cf42e | 1141 | if (!compr) |
1245b700 | 1142 | return -ENOMEM; |
1245b700 | 1143 | |
1f88eb0f CK |
1144 | compr->ops = devm_kzalloc(rtd->card->dev, sizeof(soc_compr_ops), |
1145 | GFP_KERNEL); | |
7a0cf42e | 1146 | if (!compr->ops) { |
1f88eb0f CK |
1147 | ret = -ENOMEM; |
1148 | goto compr_err; | |
1149 | } | |
2a99ef0f LG |
1150 | |
1151 | if (rtd->dai_link->dynamic) { | |
1152 | snprintf(new_name, sizeof(new_name), "(%s)", | |
1153 | rtd->dai_link->stream_name); | |
1154 | ||
1155 | ret = snd_pcm_new_internal(rtd->card->snd_card, new_name, num, | |
d3268a40 QY |
1156 | rtd->dai_link->dpcm_playback, |
1157 | rtd->dai_link->dpcm_capture, &be_pcm); | |
2a99ef0f LG |
1158 | if (ret < 0) { |
1159 | dev_err(rtd->card->dev, "ASoC: can't create compressed for %s\n", | |
1160 | rtd->dai_link->name); | |
1161 | goto compr_err; | |
1162 | } | |
1163 | ||
1164 | rtd->pcm = be_pcm; | |
1165 | rtd->fe_compr = 1; | |
d3268a40 QY |
1166 | if (rtd->dai_link->dpcm_playback) |
1167 | be_pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream->private_data = rtd; | |
1168 | else if (rtd->dai_link->dpcm_capture) | |
1169 | be_pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream->private_data = rtd; | |
2a99ef0f | 1170 | memcpy(compr->ops, &soc_compr_dyn_ops, sizeof(soc_compr_dyn_ops)); |
aeb6fa0f PD |
1171 | } else { |
1172 | snprintf(new_name, sizeof(new_name), "%s %s-%d", | |
1173 | rtd->dai_link->stream_name, codec_dai->name, num); | |
1174 | ||
2a99ef0f | 1175 | memcpy(compr->ops, &soc_compr_ops, sizeof(soc_compr_ops)); |
aeb6fa0f | 1176 | } |
1f88eb0f | 1177 | |
9e7e3738 | 1178 | |
1f88eb0f | 1179 | /* Add copy callback for not memory mapped DSPs */ |
9e7e3738 KM |
1180 | if (platform && platform->driver->compr_ops && platform->driver->compr_ops->copy) |
1181 | compr->ops->copy = soc_compr_copy; | |
1182 | ||
1183 | for_each_rtdcom(rtd, rtdcom) { | |
1184 | component = rtdcom->component; | |
1185 | ||
1186 | /* ignore duplication for now */ | |
1187 | if (platform && (component == &platform->component)) | |
1188 | continue; | |
1189 | ||
1190 | if (!component->driver->compr_ops || | |
1191 | !component->driver->compr_ops->copy) | |
1192 | continue; | |
1193 | ||
1f88eb0f | 1194 | compr->ops->copy = soc_compr_copy; |
9e7e3738 KM |
1195 | } |
1196 | ||
1f88eb0f | 1197 | |
1245b700 | 1198 | mutex_init(&compr->lock); |
e5241a8c RF |
1199 | ret = snd_compress_new(rtd->card->snd_card, num, direction, |
1200 | new_name, compr); | |
1245b700 NK |
1201 | if (ret < 0) { |
1202 | pr_err("compress asoc: can't create compress for codec %s\n", | |
f4333203 | 1203 | codec->component.name); |
1f88eb0f | 1204 | goto compr_err; |
1245b700 NK |
1205 | } |
1206 | ||
202c8f70 CK |
1207 | /* DAPM dai link stream work */ |
1208 | INIT_DELAYED_WORK(&rtd->delayed_work, close_delayed_work); | |
1209 | ||
1245b700 NK |
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; | |
1f88eb0f CK |
1216 | |
1217 | compr_err: | |
1218 | kfree(compr); | |
1219 | return ret; | |
1245b700 | 1220 | } |
6f0c4226 | 1221 | EXPORT_SYMBOL_GPL(snd_soc_new_compress); |