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