projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Linux 3.17-rc6
[linux-2.6-block.git] / sound / soc / soc-compress.c
CommitLineData
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
29static 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;
1245b700
NK		 33 int ret = 0;
34
15e2e619
CK		 35 mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
36
1245b700
NK		 37 if (platform->driver->compr_ops && platform->driver->compr_ops->open) {
38 ret = platform->driver->compr_ops->open(cstream);
39 if (ret < 0) {
f4333203
LPC		 40 pr_err("compress asoc: can't open platform %s\n",
41 platform->component.name);
1245b700
NK		 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
24894b76 54 snd_soc_runtime_activate(rtd, cstream->direction);
1245b700 55
15e2e619
CK		 56 mutex_unlock(&rtd->pcm_mutex);
57
1245b700
NK		 58 return 0;
59
60machine_err:
61 if (platform->driver->compr_ops && platform->driver->compr_ops->free)
62 platform->driver->compr_ops->free(cstream);
63out:
15e2e619 64 mutex_unlock(&rtd->pcm_mutex);
1245b700
NK		 65 return ret;
66}
67
2a99ef0f
LG		 68static 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;
2a99ef0f
LG		 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) {
f4333203
LPC		 88 pr_err("compress asoc: can't open platform %s\n",
89 platform->component.name);
2a99ef0f
LG		 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
8f70e515
QZ		 104 ret = dpcm_path_get(fe, stream, &list);
105 if (ret < 0) {
106 mutex_unlock(&fe->card->mutex);
107 goto fe_err;
108 } else if (ret == 0) {
2a99ef0f
LG		 109 dev_dbg(fe->dev, "ASoC: %s no valid %s route\n",
110 fe->dai_link->name, stream ? "capture" : "playback");
111 }
112
113 /* calculate valid and active FE <-> BE dpcms */
114 dpcm_process_paths(fe, stream, &list, 1);
115
116 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE;
117
118 ret = dpcm_be_dai_startup(fe, stream);
119 if (ret < 0) {
120 /* clean up all links */
121 list_for_each_entry(dpcm, &fe->dpcm[stream].be_clients, list_be)
122 dpcm->state = SND_SOC_DPCM_LINK_STATE_FREE;
123
124 dpcm_be_disconnect(fe, stream);
125 fe->dpcm[stream].runtime = NULL;
126 goto fe_err;
127 }
128
129 dpcm_clear_pending_state(fe, stream);
130 dpcm_path_put(&list);
131
132 fe->dpcm[stream].state = SND_SOC_DPCM_STATE_OPEN;
133 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO;
134
24894b76 135 snd_soc_runtime_activate(fe, stream);
2a99ef0f
LG		 136
137 mutex_unlock(&fe->card->mutex);
138
139 return 0;
140
141fe_err:
142 if (fe->dai_link->compr_ops && fe->dai_link->compr_ops->shutdown)
143 fe->dai_link->compr_ops->shutdown(cstream);
144machine_err:
145 if (platform->driver->compr_ops && platform->driver->compr_ops->free)
146 platform->driver->compr_ops->free(cstream);
147out:
148 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO;
149 mutex_unlock(&fe->card->mutex);
150 return ret;
151}
152
202c8f70
CK		 153/*
154 * Power down the audio subsystem pmdown_time msecs after close is called.
155 * This is to ensure there are no pops or clicks in between any music tracks
156 * due to DAPM power cycling.
157 */
158static void close_delayed_work(struct work_struct *work)
159{
160 struct snd_soc_pcm_runtime *rtd =
161 container_of(work, struct snd_soc_pcm_runtime, delayed_work.work);
162 struct snd_soc_dai *codec_dai = rtd->codec_dai;
163
164 mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
165
166 dev_dbg(rtd->dev, "ASoC: pop wq checking: %s status: %s waiting: %s\n",
167 codec_dai->driver->playback.stream_name,
168 codec_dai->playback_active ? "active" : "inactive",
169 rtd->pop_wait ? "yes" : "no");
170
171 /* are we waiting on this codec DAI stream */
172 if (rtd->pop_wait == 1) {
173 rtd->pop_wait = 0;
174 snd_soc_dapm_stream_event(rtd, SNDRV_PCM_STREAM_PLAYBACK,
175 SND_SOC_DAPM_STREAM_STOP);
176 }
177
178 mutex_unlock(&rtd->pcm_mutex);
179}
180
1245b700
NK		 181static int soc_compr_free(struct snd_compr_stream *cstream)
182{
183 struct snd_soc_pcm_runtime *rtd = cstream->private_data;
184 struct snd_soc_platform *platform = rtd->platform;
185 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
186 struct snd_soc_dai *codec_dai = rtd->codec_dai;
24894b76 187 int stream;
1245b700 188
15e2e619
CK		 189 mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
190
24894b76
LPC		 191 if (cstream->direction == SND_COMPRESS_PLAYBACK)
192 stream = SNDRV_PCM_STREAM_PLAYBACK;
193 else
194 stream = SNDRV_PCM_STREAM_CAPTURE;
1245b700 195
24894b76 196 snd_soc_runtime_deactivate(rtd, stream);
da18396f 197
24894b76 198 snd_soc_dai_digital_mute(codec_dai, 1, cstream->direction);
1245b700
NK		 199
200 if (!cpu_dai->active)
201 cpu_dai->rate = 0;
202
203 if (!codec_dai->active)
204 codec_dai->rate = 0;
205
206
207 if (rtd->dai_link->compr_ops && rtd->dai_link->compr_ops->shutdown)
208 rtd->dai_link->compr_ops->shutdown(cstream);
209
210 if (platform->driver->compr_ops && platform->driver->compr_ops->free)
211 platform->driver->compr_ops->free(cstream);
1245b700
NK		 212
213 if (cstream->direction == SND_COMPRESS_PLAYBACK) {
208a1589 214 if (snd_soc_runtime_ignore_pmdown_time(rtd)) {
1245b700
NK		 215 snd_soc_dapm_stream_event(rtd,
216 SNDRV_PCM_STREAM_PLAYBACK,
217 SND_SOC_DAPM_STREAM_STOP);
8c3d2aa4 218 } else {
9bffb1fb 219 rtd->pop_wait = 1;
3d24cfe4
MB		 220 queue_delayed_work(system_power_efficient_wq,
221 &rtd->delayed_work,
222 msecs_to_jiffies(rtd->pmdown_time));
8c3d2aa4 223 }
1245b700
NK		 224 } else {
225 /* capture streams can be powered down now */
226 snd_soc_dapm_stream_event(rtd,
227 SNDRV_PCM_STREAM_CAPTURE,
228 SND_SOC_DAPM_STREAM_STOP);
229 }
230
15e2e619 231 mutex_unlock(&rtd->pcm_mutex);
1245b700
NK		 232 return 0;
233}
234
2a99ef0f
LG		 235static int soc_compr_free_fe(struct snd_compr_stream *cstream)
236{
237 struct snd_soc_pcm_runtime *fe = cstream->private_data;
238 struct snd_soc_platform *platform = fe->platform;
2a99ef0f
LG		 239 struct snd_soc_dpcm *dpcm;
240 int stream, ret;
241
242 mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME);
243
24894b76 244 if (cstream->direction == SND_COMPRESS_PLAYBACK)
2a99ef0f 245 stream = SNDRV_PCM_STREAM_PLAYBACK;
24894b76 246 else
2a99ef0f 247 stream = SNDRV_PCM_STREAM_CAPTURE;
2a99ef0f 248
24894b76 249 snd_soc_runtime_deactivate(fe, stream);
2a99ef0f
LG		 250
251 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE;
252
253 ret = dpcm_be_dai_hw_free(fe, stream);
254 if (ret < 0)
255 dev_err(fe->dev, "compressed hw_free failed %d\n", ret);
256
257 ret = dpcm_be_dai_shutdown(fe, stream);
258
259 /* mark FE's links ready to prune */
260 list_for_each_entry(dpcm, &fe->dpcm[stream].be_clients, list_be)
261 dpcm->state = SND_SOC_DPCM_LINK_STATE_FREE;
262
263 if (stream == SNDRV_PCM_STREAM_PLAYBACK)
264 dpcm_dapm_stream_event(fe, stream, SND_SOC_DAPM_STREAM_STOP);
265 else
266 dpcm_dapm_stream_event(fe, stream, SND_SOC_DAPM_STREAM_STOP);
267
268 fe->dpcm[stream].state = SND_SOC_DPCM_STATE_CLOSE;
269 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO;
270
271 dpcm_be_disconnect(fe, stream);
272
273 fe->dpcm[stream].runtime = NULL;
274
275 if (fe->dai_link->compr_ops && fe->dai_link->compr_ops->shutdown)
276 fe->dai_link->compr_ops->shutdown(cstream);
277
278 if (platform->driver->compr_ops && platform->driver->compr_ops->free)
279 platform->driver->compr_ops->free(cstream);
280
281 mutex_unlock(&fe->card->mutex);
282 return 0;
283}
284
1245b700
NK		 285static int soc_compr_trigger(struct snd_compr_stream *cstream, int cmd)
286{
287
288 struct snd_soc_pcm_runtime *rtd = cstream->private_data;
289 struct snd_soc_platform *platform = rtd->platform;
290 struct snd_soc_dai *codec_dai = rtd->codec_dai;
291 int ret = 0;
292
15e2e619
CK		 293 mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
294
1245b700
NK		 295 if (platform->driver->compr_ops && platform->driver->compr_ops->trigger) {
296 ret = platform->driver->compr_ops->trigger(cstream, cmd);
297 if (ret < 0)
15e2e619 298 goto out;
1245b700
NK		 299 }
300
da18396f
MB		 301 switch (cmd) {
302 case SNDRV_PCM_TRIGGER_START:
303 snd_soc_dai_digital_mute(codec_dai, 0, cstream->direction);
304 break;
305 case SNDRV_PCM_TRIGGER_STOP:
306 snd_soc_dai_digital_mute(codec_dai, 1, cstream->direction);
307 break;
e38b9b74 308 }
1245b700 309
15e2e619
CK		 310out:
311 mutex_unlock(&rtd->pcm_mutex);
1245b700
NK		 312 return ret;
313}
314
2a99ef0f
LG		 315static int soc_compr_trigger_fe(struct snd_compr_stream *cstream, int cmd)
316{
317 struct snd_soc_pcm_runtime *fe = cstream->private_data;
318 struct snd_soc_platform *platform = fe->platform;
319 int ret = 0, stream;
320
321 if (cmd == SND_COMPR_TRIGGER_PARTIAL_DRAIN ||
322 cmd == SND_COMPR_TRIGGER_DRAIN) {
323
324 if (platform->driver->compr_ops &&
15b8e94f
DC		 325 platform->driver->compr_ops->trigger)
326 return platform->driver->compr_ops->trigger(cstream,
327 cmd);
2a99ef0f
LG		 328 }
329
330 if (cstream->direction == SND_COMPRESS_PLAYBACK)
331 stream = SNDRV_PCM_STREAM_PLAYBACK;
332 else
333 stream = SNDRV_PCM_STREAM_CAPTURE;
334
335
336 mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME);
337
338 if (platform->driver->compr_ops && platform->driver->compr_ops->trigger) {
339 ret = platform->driver->compr_ops->trigger(cstream, cmd);
340 if (ret < 0)
341 goto out;
342 }
343
344 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE;
345
346 ret = dpcm_be_dai_trigger(fe, stream, cmd);
347
348 switch (cmd) {
349 case SNDRV_PCM_TRIGGER_START:
350 case SNDRV_PCM_TRIGGER_RESUME:
351 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
352 fe->dpcm[stream].state = SND_SOC_DPCM_STATE_START;
353 break;
354 case SNDRV_PCM_TRIGGER_STOP:
355 case SNDRV_PCM_TRIGGER_SUSPEND:
356 fe->dpcm[stream].state = SND_SOC_DPCM_STATE_STOP;
357 break;
358 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
359 fe->dpcm[stream].state = SND_SOC_DPCM_STATE_PAUSED;
360 break;
361 }
362
363out:
364 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO;
365 mutex_unlock(&fe->card->mutex);
366 return ret;
367}
368
1245b700
NK		 369static int soc_compr_set_params(struct snd_compr_stream *cstream,
370 struct snd_compr_params *params)
371{
372 struct snd_soc_pcm_runtime *rtd = cstream->private_data;
373 struct snd_soc_platform *platform = rtd->platform;
1245b700
NK		 374 int ret = 0;
375
15e2e619
CK		 376 mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
377
1245b700
NK		 378 /* first we call set_params for the platform driver
379 * this should configure the soc side
380 * if the machine has compressed ops then we call that as well
381 * expectation is that platform and machine will configure everything
382 * for this compress path, like configuring pcm port for codec
383 */
384 if (platform->driver->compr_ops && platform->driver->compr_ops->set_params) {
385 ret = platform->driver->compr_ops->set_params(cstream, params);
386 if (ret < 0)
fa40ef20 387 goto err;
1245b700
NK		 388 }
389
390 if (rtd->dai_link->compr_ops && rtd->dai_link->compr_ops->set_params) {
391 ret = rtd->dai_link->compr_ops->set_params(cstream);
392 if (ret < 0)
fa40ef20 393 goto err;
1245b700
NK		 394 }
395
2c071ed7
CK		 396 if (cstream->direction == SND_COMPRESS_PLAYBACK)
397 snd_soc_dapm_stream_event(rtd, SNDRV_PCM_STREAM_PLAYBACK,
398 SND_SOC_DAPM_STREAM_START);
399 else
400 snd_soc_dapm_stream_event(rtd, SNDRV_PCM_STREAM_CAPTURE,
401 SND_SOC_DAPM_STREAM_START);
1245b700 402
fa40ef20
CK		 403 /* cancel any delayed stream shutdown that is pending */
404 rtd->pop_wait = 0;
405 mutex_unlock(&rtd->pcm_mutex);
406
407 cancel_delayed_work_sync(&rtd->delayed_work);
408
409 return ret;
410
411err:
15e2e619 412 mutex_unlock(&rtd->pcm_mutex);
1245b700
NK		 413 return ret;
414}
415
2a99ef0f
LG		 416static int soc_compr_set_params_fe(struct snd_compr_stream *cstream,
417 struct snd_compr_params *params)
418{
419 struct snd_soc_pcm_runtime *fe = cstream->private_data;
420 struct snd_pcm_substream *fe_substream = fe->pcm->streams[0].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
468out:
469 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO;
470 mutex_unlock(&fe->card->mutex);
471 return ret;
472}
473
1245b700
NK		 474static 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
15e2e619
CK		 481 mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
482
1245b700
NK		 483 if (platform->driver->compr_ops && platform->driver->compr_ops->get_params)
484 ret = platform->driver->compr_ops->get_params(cstream, params);
485
15e2e619 486 mutex_unlock(&rtd->pcm_mutex);
1245b700
NK		 487 return ret;
488}
489
490static 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
15e2e619
CK		 497 mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
498
1245b700
NK		 499 if (platform->driver->compr_ops && platform->driver->compr_ops->get_caps)
500 ret = platform->driver->compr_ops->get_caps(cstream, caps);
501
15e2e619 502 mutex_unlock(&rtd->pcm_mutex);
1245b700
NK		 503 return ret;
504}
505
506static 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
15e2e619
CK		 513 mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
514
1245b700
NK		 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
15e2e619 518 mutex_unlock(&rtd->pcm_mutex);
1245b700
NK		 519 return ret;
520}
521
522static 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
15e2e619
CK		 528 mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
529
1245b700
NK		 530 if (platform->driver->compr_ops && platform->driver->compr_ops->ack)
531 ret = platform->driver->compr_ops->ack(cstream, bytes);
532
15e2e619 533 mutex_unlock(&rtd->pcm_mutex);
1245b700
NK		 534 return ret;
535}
536
537static 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
15e2e619
CK		 543 mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
544
1245b700
NK		 545 if (platform->driver->compr_ops && platform->driver->compr_ops->pointer)
546 platform->driver->compr_ops->pointer(cstream, tstamp);
547
15e2e619 548 mutex_unlock(&rtd->pcm_mutex);
1245b700
NK		 549 return 0;
550}
551
1f88eb0f 552static int soc_compr_copy(struct snd_compr_stream *cstream,
4daf891c 553 char __user *buf, size_t count)
1f88eb0f
CK		 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
02bd90e8 568static int soc_compr_set_metadata(struct snd_compr_stream *cstream,
36953d98
JK		 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
02bd90e8 581static int soc_compr_get_metadata(struct snd_compr_stream *cstream,
36953d98
JK		 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}
2a99ef0f 593
1245b700
NK		 594/* ASoC Compress operations */
595static struct snd_compr_ops soc_compr_ops = {
596 .open = soc_compr_open,
597 .free = soc_compr_free,
598 .set_params = soc_compr_set_params,
02bd90e8
VK		 599 .set_metadata = soc_compr_set_metadata,
600 .get_metadata = soc_compr_get_metadata,
1245b700
NK		 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
2a99ef0f
LG		 609/* ASoC Dynamic Compress operations */
610static 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
1245b700
NK		 624/* create a new compress */
625int soc_new_compress(struct snd_soc_pcm_runtime *rtd, int num)
626{
627 struct snd_soc_codec *codec = rtd->codec;
1f88eb0f 628 struct snd_soc_platform *platform = rtd->platform;
1245b700
NK		 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;
2a99ef0f 632 struct snd_pcm *be_pcm;
1245b700
NK		 633 char new_name[64];
634 int ret = 0, direction = 0;
635
8151d5e6
BC		 636 if (rtd->num_codecs > 1) {
637 dev_err(rtd->card->dev, "Multicodec not supported for compressed stream\n");
638 return -EINVAL;
639 }
640
1245b700
NK		 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);
daa2db59
CK		 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
1245b700
NK		 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
1f88eb0f
CK		 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 }
2a99ef0f
LG		 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 1, 0, &be_pcm);
672 if (ret < 0) {
673 dev_err(rtd->card->dev, "ASoC: can't create compressed for %s\n",
674 rtd->dai_link->name);
675 goto compr_err;
676 }
677
678 rtd->pcm = be_pcm;
679 rtd->fe_compr = 1;
680 be_pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream->private_data = rtd;
681 be_pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream->private_data = rtd;
682 memcpy(compr->ops, &soc_compr_dyn_ops, sizeof(soc_compr_dyn_ops));
683 } else
684 memcpy(compr->ops, &soc_compr_ops, sizeof(soc_compr_ops));
1f88eb0f
CK		 685
686 /* Add copy callback for not memory mapped DSPs */
687 if (platform->driver->compr_ops && platform->driver->compr_ops->copy)
688 compr->ops->copy = soc_compr_copy;
689
1245b700
NK		 690 mutex_init(&compr->lock);
691 ret = snd_compress_new(rtd->card->snd_card, num, direction, compr);
692 if (ret < 0) {
693 pr_err("compress asoc: can't create compress for codec %s\n",
f4333203 694 codec->component.name);
1f88eb0f 695 goto compr_err;
1245b700
NK		 696 }
697
202c8f70
CK		 698 /* DAPM dai link stream work */
699 INIT_DELAYED_WORK(&rtd->delayed_work, close_delayed_work);
700
1245b700
NK		 701 rtd->compr = compr;
702 compr->private_data = rtd;
703
704 printk(KERN_INFO "compress asoc: %s <-> %s mapping ok\n", codec_dai->name,
705 cpu_dai->name);
706 return ret;
1f88eb0f
CK		 707
708compr_err:
709 kfree(compr);
710 return ret;
1245b700 711}
Linux 6.x block layer and io_uring tree(s)