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