1 // SPDX-License-Identifier: GPL-2.0+ 2 // 3 // soc-compress.c -- ALSA SoC Compress 4 // 5 // Copyright (C) 2012 Intel Corp. 6 // 7 // Authors: Namarta Kohli <namartax.kohli@intel.com> 8 // Ramesh Babu K V <ramesh.babu@linux.intel.com> 9 // Vinod Koul <vinod.koul@linux.intel.com> 10 11 #include <linux/kernel.h> 12 #include <linux/init.h> 13 #include <linux/delay.h> 14 #include <linux/slab.h> 15 #include <linux/workqueue.h> 16 #include <sound/core.h> 17 #include <sound/compress_params.h> 18 #include <sound/compress_driver.h> 19 #include <sound/soc.h> 20 #include <sound/initval.h> 21 #include <sound/soc-dpcm.h> 22 #include <sound/soc-link.h> 23 #include <linux/pm_runtime.h> 24 25 static int soc_compr_clean(struct snd_compr_stream *cstream, int rollback) 26 { 27 struct snd_soc_pcm_runtime *rtd = cstream->private_data; 28 struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(rtd, 0); 29 struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtd, 0); 30 int stream = cstream->direction; /* SND_COMPRESS_xxx is same as SNDRV_PCM_STREAM_xxx */ 31 32 mutex_lock_nested(&rtd->card->pcm_mutex, rtd->card->pcm_subclass); 33 34 if (!rollback) 35 snd_soc_runtime_deactivate(rtd, stream); 36 37 snd_soc_dai_digital_mute(codec_dai, 1, stream); 38 39 if (!snd_soc_dai_active(cpu_dai)) 40 cpu_dai->rate = 0; 41 42 if (!snd_soc_dai_active(codec_dai)) 43 codec_dai->rate = 0; 44 45 snd_soc_link_compr_shutdown(cstream, rollback); 46 47 snd_soc_component_compr_free(cstream, rollback); 48 49 snd_soc_dai_compr_shutdown(cpu_dai, cstream, rollback); 50 51 if (!rollback) 52 snd_soc_dapm_stream_stop(rtd, stream); 53 54 mutex_unlock(&rtd->card->pcm_mutex); 55 56 snd_soc_pcm_component_pm_runtime_put(rtd, cstream, rollback); 57 58 return 0; 59 } 60 61 static int soc_compr_free(struct snd_compr_stream *cstream) 62 { 63 return soc_compr_clean(cstream, 0); 64 } 65 66 static int soc_compr_open(struct snd_compr_stream *cstream) 67 { 68 struct snd_soc_pcm_runtime *rtd = cstream->private_data; 69 struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(rtd, 0); 70 int stream = cstream->direction; /* SND_COMPRESS_xxx is same as SNDRV_PCM_STREAM_xxx */ 71 int ret; 72 73 ret = snd_soc_pcm_component_pm_runtime_get(rtd, cstream); 74 if (ret < 0) 75 goto err_no_lock; 76 77 mutex_lock_nested(&rtd->card->pcm_mutex, rtd->card->pcm_subclass); 78 79 ret = snd_soc_dai_compr_startup(cpu_dai, cstream); 80 if (ret < 0) 81 goto err; 82 83 ret = snd_soc_component_compr_open(cstream); 84 if (ret < 0) 85 goto err; 86 87 ret = snd_soc_link_compr_startup(cstream); 88 if (ret < 0) 89 goto err; 90 91 snd_soc_runtime_activate(rtd, stream); 92 err: 93 mutex_unlock(&rtd->card->pcm_mutex); 94 err_no_lock: 95 if (ret < 0) 96 soc_compr_clean(cstream, 1); 97 98 return ret; 99 } 100 101 static int soc_compr_open_fe(struct snd_compr_stream *cstream) 102 { 103 struct snd_soc_pcm_runtime *fe = cstream->private_data; 104 struct snd_pcm_substream *fe_substream = 105 fe->pcm->streams[cstream->direction].substream; 106 struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(fe, 0); 107 struct snd_soc_dpcm *dpcm; 108 struct snd_soc_dapm_widget_list *list; 109 int stream = cstream->direction; /* SND_COMPRESS_xxx is same as SNDRV_PCM_STREAM_xxx */ 110 int ret; 111 112 mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME); 113 fe->dpcm[stream].runtime = fe_substream->runtime; 114 115 ret = dpcm_path_get(fe, stream, &list); 116 if (ret < 0) 117 goto be_err; 118 119 /* calculate valid and active FE <-> BE dpcms */ 120 dpcm_process_paths(fe, stream, &list, 1); 121 fe->dpcm[stream].runtime = fe_substream->runtime; 122 123 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE; 124 125 ret = dpcm_be_dai_startup(fe, stream); 126 if (ret < 0) { 127 /* clean up all links */ 128 for_each_dpcm_be(fe, stream, dpcm) 129 dpcm->state = SND_SOC_DPCM_LINK_STATE_FREE; 130 131 dpcm_be_disconnect(fe, stream); 132 fe->dpcm[stream].runtime = NULL; 133 goto out; 134 } 135 136 ret = snd_soc_dai_compr_startup(cpu_dai, cstream); 137 if (ret < 0) 138 goto out; 139 140 ret = snd_soc_component_compr_open(cstream); 141 if (ret < 0) 142 goto open_err; 143 144 ret = snd_soc_link_compr_startup(cstream); 145 if (ret < 0) 146 goto machine_err; 147 148 dpcm_clear_pending_state(fe, stream); 149 dpcm_path_put(&list); 150 151 fe->dpcm[stream].state = SND_SOC_DPCM_STATE_OPEN; 152 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO; 153 154 mutex_lock_nested(&fe->card->pcm_mutex, fe->card->pcm_subclass); 155 snd_soc_runtime_activate(fe, stream); 156 mutex_unlock(&fe->card->pcm_mutex); 157 158 mutex_unlock(&fe->card->mutex); 159 160 return 0; 161 162 machine_err: 163 snd_soc_component_compr_free(cstream, 1); 164 open_err: 165 snd_soc_dai_compr_shutdown(cpu_dai, cstream, 1); 166 out: 167 dpcm_path_put(&list); 168 be_err: 169 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO; 170 mutex_unlock(&fe->card->mutex); 171 return ret; 172 } 173 174 static int soc_compr_free_fe(struct snd_compr_stream *cstream) 175 { 176 struct snd_soc_pcm_runtime *fe = cstream->private_data; 177 struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(fe, 0); 178 struct snd_soc_dpcm *dpcm; 179 int stream = cstream->direction; /* SND_COMPRESS_xxx is same as SNDRV_PCM_STREAM_xxx */ 180 181 mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME); 182 183 mutex_lock_nested(&fe->card->pcm_mutex, fe->card->pcm_subclass); 184 snd_soc_runtime_deactivate(fe, stream); 185 mutex_unlock(&fe->card->pcm_mutex); 186 187 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE; 188 189 dpcm_be_dai_hw_free(fe, stream); 190 191 dpcm_be_dai_shutdown(fe, stream); 192 193 /* mark FE's links ready to prune */ 194 for_each_dpcm_be(fe, stream, dpcm) 195 dpcm->state = SND_SOC_DPCM_LINK_STATE_FREE; 196 197 dpcm_dapm_stream_event(fe, stream, SND_SOC_DAPM_STREAM_STOP); 198 199 fe->dpcm[stream].state = SND_SOC_DPCM_STATE_CLOSE; 200 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO; 201 202 dpcm_be_disconnect(fe, stream); 203 204 fe->dpcm[stream].runtime = NULL; 205 206 snd_soc_link_compr_shutdown(cstream, 0); 207 208 snd_soc_component_compr_free(cstream, 0); 209 210 snd_soc_dai_compr_shutdown(cpu_dai, cstream, 0); 211 212 mutex_unlock(&fe->card->mutex); 213 return 0; 214 } 215 216 static int soc_compr_trigger(struct snd_compr_stream *cstream, int cmd) 217 { 218 struct snd_soc_pcm_runtime *rtd = cstream->private_data; 219 struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtd, 0); 220 struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(rtd, 0); 221 int stream = cstream->direction; /* SND_COMPRESS_xxx is same as SNDRV_PCM_STREAM_xxx */ 222 int ret; 223 224 mutex_lock_nested(&rtd->card->pcm_mutex, rtd->card->pcm_subclass); 225 226 ret = snd_soc_component_compr_trigger(cstream, cmd); 227 if (ret < 0) 228 goto out; 229 230 ret = snd_soc_dai_compr_trigger(cpu_dai, cstream, cmd); 231 if (ret < 0) 232 goto out; 233 234 switch (cmd) { 235 case SNDRV_PCM_TRIGGER_START: 236 snd_soc_dai_digital_mute(codec_dai, 0, stream); 237 break; 238 case SNDRV_PCM_TRIGGER_STOP: 239 snd_soc_dai_digital_mute(codec_dai, 1, stream); 240 break; 241 } 242 243 out: 244 mutex_unlock(&rtd->card->pcm_mutex); 245 return ret; 246 } 247 248 static int soc_compr_trigger_fe(struct snd_compr_stream *cstream, int cmd) 249 { 250 struct snd_soc_pcm_runtime *fe = cstream->private_data; 251 struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(fe, 0); 252 int stream = cstream->direction; /* SND_COMPRESS_xxx is same as SNDRV_PCM_STREAM_xxx */ 253 int ret; 254 255 if (cmd == SND_COMPR_TRIGGER_PARTIAL_DRAIN || 256 cmd == SND_COMPR_TRIGGER_DRAIN) 257 return snd_soc_component_compr_trigger(cstream, cmd); 258 259 mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME); 260 261 ret = snd_soc_dai_compr_trigger(cpu_dai, cstream, cmd); 262 if (ret < 0) 263 goto out; 264 265 ret = snd_soc_component_compr_trigger(cstream, cmd); 266 if (ret < 0) 267 goto out; 268 269 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE; 270 271 ret = dpcm_be_dai_trigger(fe, stream, cmd); 272 273 switch (cmd) { 274 case SNDRV_PCM_TRIGGER_START: 275 case SNDRV_PCM_TRIGGER_RESUME: 276 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: 277 fe->dpcm[stream].state = SND_SOC_DPCM_STATE_START; 278 break; 279 case SNDRV_PCM_TRIGGER_STOP: 280 case SNDRV_PCM_TRIGGER_SUSPEND: 281 fe->dpcm[stream].state = SND_SOC_DPCM_STATE_STOP; 282 break; 283 case SNDRV_PCM_TRIGGER_PAUSE_PUSH: 284 fe->dpcm[stream].state = SND_SOC_DPCM_STATE_PAUSED; 285 break; 286 } 287 288 out: 289 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO; 290 mutex_unlock(&fe->card->mutex); 291 return ret; 292 } 293 294 static int soc_compr_set_params(struct snd_compr_stream *cstream, 295 struct snd_compr_params *params) 296 { 297 struct snd_soc_pcm_runtime *rtd = cstream->private_data; 298 struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(rtd, 0); 299 int stream = cstream->direction; /* SND_COMPRESS_xxx is same as SNDRV_PCM_STREAM_xxx */ 300 int ret; 301 302 mutex_lock_nested(&rtd->card->pcm_mutex, rtd->card->pcm_subclass); 303 304 /* 305 * First we call set_params for the CPU DAI, then the component 306 * driver this should configure the SoC side. If the machine has 307 * compressed ops then we call that as well. The expectation is 308 * that these callbacks will configure everything for this compress 309 * path, like configuring a PCM port for a CODEC. 310 */ 311 ret = snd_soc_dai_compr_set_params(cpu_dai, cstream, params); 312 if (ret < 0) 313 goto err; 314 315 ret = snd_soc_component_compr_set_params(cstream, params); 316 if (ret < 0) 317 goto err; 318 319 ret = snd_soc_link_compr_set_params(cstream); 320 if (ret < 0) 321 goto err; 322 323 snd_soc_dapm_stream_event(rtd, stream, SND_SOC_DAPM_STREAM_START); 324 325 /* cancel any delayed stream shutdown that is pending */ 326 rtd->pop_wait = 0; 327 mutex_unlock(&rtd->card->pcm_mutex); 328 329 cancel_delayed_work_sync(&rtd->delayed_work); 330 331 return 0; 332 333 err: 334 mutex_unlock(&rtd->card->pcm_mutex); 335 return ret; 336 } 337 338 static int soc_compr_set_params_fe(struct snd_compr_stream *cstream, 339 struct snd_compr_params *params) 340 { 341 struct snd_soc_pcm_runtime *fe = cstream->private_data; 342 struct snd_pcm_substream *fe_substream = 343 fe->pcm->streams[cstream->direction].substream; 344 struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(fe, 0); 345 int stream = cstream->direction; /* SND_COMPRESS_xxx is same as SNDRV_PCM_STREAM_xxx */ 346 int ret; 347 348 mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME); 349 350 /* 351 * Create an empty hw_params for the BE as the machine driver must 352 * fix this up to match DSP decoder and ASRC configuration. 353 * I.e. machine driver fixup for compressed BE is mandatory. 354 */ 355 memset(&fe->dpcm[fe_substream->stream].hw_params, 0, 356 sizeof(struct snd_pcm_hw_params)); 357 358 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE; 359 360 ret = dpcm_be_dai_hw_params(fe, stream); 361 if (ret < 0) 362 goto out; 363 364 ret = dpcm_be_dai_prepare(fe, stream); 365 if (ret < 0) 366 goto out; 367 368 ret = snd_soc_dai_compr_set_params(cpu_dai, cstream, params); 369 if (ret < 0) 370 goto out; 371 372 ret = snd_soc_component_compr_set_params(cstream, params); 373 if (ret < 0) 374 goto out; 375 376 ret = snd_soc_link_compr_set_params(cstream); 377 if (ret < 0) 378 goto out; 379 380 dpcm_dapm_stream_event(fe, stream, SND_SOC_DAPM_STREAM_START); 381 fe->dpcm[stream].state = SND_SOC_DPCM_STATE_PREPARE; 382 383 out: 384 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO; 385 mutex_unlock(&fe->card->mutex); 386 return ret; 387 } 388 389 static int soc_compr_get_params(struct snd_compr_stream *cstream, 390 struct snd_codec *params) 391 { 392 struct snd_soc_pcm_runtime *rtd = cstream->private_data; 393 struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(rtd, 0); 394 int ret = 0; 395 396 mutex_lock_nested(&rtd->card->pcm_mutex, rtd->card->pcm_subclass); 397 398 ret = snd_soc_dai_compr_get_params(cpu_dai, cstream, params); 399 if (ret < 0) 400 goto err; 401 402 ret = snd_soc_component_compr_get_params(cstream, params); 403 err: 404 mutex_unlock(&rtd->card->pcm_mutex); 405 return ret; 406 } 407 408 static int soc_compr_ack(struct snd_compr_stream *cstream, size_t bytes) 409 { 410 struct snd_soc_pcm_runtime *rtd = cstream->private_data; 411 struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(rtd, 0); 412 int ret; 413 414 mutex_lock_nested(&rtd->card->pcm_mutex, rtd->card->pcm_subclass); 415 416 ret = snd_soc_dai_compr_ack(cpu_dai, cstream, bytes); 417 if (ret < 0) 418 goto err; 419 420 ret = snd_soc_component_compr_ack(cstream, bytes); 421 err: 422 mutex_unlock(&rtd->card->pcm_mutex); 423 return ret; 424 } 425 426 static int soc_compr_pointer(struct snd_compr_stream *cstream, 427 struct snd_compr_tstamp *tstamp) 428 { 429 struct snd_soc_pcm_runtime *rtd = cstream->private_data; 430 int ret; 431 struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(rtd, 0); 432 433 mutex_lock_nested(&rtd->card->pcm_mutex, rtd->card->pcm_subclass); 434 435 ret = snd_soc_dai_compr_pointer(cpu_dai, cstream, tstamp); 436 if (ret < 0) 437 goto out; 438 439 ret = snd_soc_component_compr_pointer(cstream, tstamp); 440 out: 441 mutex_unlock(&rtd->card->pcm_mutex); 442 return ret; 443 } 444 445 static int soc_compr_set_metadata(struct snd_compr_stream *cstream, 446 struct snd_compr_metadata *metadata) 447 { 448 struct snd_soc_pcm_runtime *rtd = cstream->private_data; 449 struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(rtd, 0); 450 int ret; 451 452 ret = snd_soc_dai_compr_set_metadata(cpu_dai, cstream, metadata); 453 if (ret < 0) 454 return ret; 455 456 return snd_soc_component_compr_set_metadata(cstream, metadata); 457 } 458 459 static int soc_compr_get_metadata(struct snd_compr_stream *cstream, 460 struct snd_compr_metadata *metadata) 461 { 462 struct snd_soc_pcm_runtime *rtd = cstream->private_data; 463 struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(rtd, 0); 464 int ret; 465 466 ret = snd_soc_dai_compr_get_metadata(cpu_dai, cstream, metadata); 467 if (ret < 0) 468 return ret; 469 470 return snd_soc_component_compr_get_metadata(cstream, metadata); 471 } 472 473 /* ASoC Compress operations */ 474 static struct snd_compr_ops soc_compr_ops = { 475 .open = soc_compr_open, 476 .free = soc_compr_free, 477 .set_params = soc_compr_set_params, 478 .set_metadata = soc_compr_set_metadata, 479 .get_metadata = soc_compr_get_metadata, 480 .get_params = soc_compr_get_params, 481 .trigger = soc_compr_trigger, 482 .pointer = soc_compr_pointer, 483 .ack = soc_compr_ack, 484 .get_caps = snd_soc_component_compr_get_caps, 485 .get_codec_caps = snd_soc_component_compr_get_codec_caps, 486 }; 487 488 /* ASoC Dynamic Compress operations */ 489 static struct snd_compr_ops soc_compr_dyn_ops = { 490 .open = soc_compr_open_fe, 491 .free = soc_compr_free_fe, 492 .set_params = soc_compr_set_params_fe, 493 .get_params = soc_compr_get_params, 494 .set_metadata = soc_compr_set_metadata, 495 .get_metadata = soc_compr_get_metadata, 496 .trigger = soc_compr_trigger_fe, 497 .pointer = soc_compr_pointer, 498 .ack = soc_compr_ack, 499 .get_caps = snd_soc_component_compr_get_caps, 500 .get_codec_caps = snd_soc_component_compr_get_codec_caps, 501 }; 502 503 /** 504 * snd_soc_new_compress - create a new compress. 505 * 506 * @rtd: The runtime for which we will create compress 507 * @num: the device index number (zero based - shared with normal PCMs) 508 * 509 * Return: 0 for success, else error. 510 */ 511 int snd_soc_new_compress(struct snd_soc_pcm_runtime *rtd, int num) 512 { 513 struct snd_soc_component *component; 514 struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtd, 0); 515 struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(rtd, 0); 516 struct snd_compr *compr; 517 struct snd_pcm *be_pcm; 518 char new_name[64]; 519 int ret = 0, direction = 0; 520 int playback = 0, capture = 0; 521 int i; 522 523 /* 524 * make sure these are same value, 525 * and then use these as equally 526 */ 527 BUILD_BUG_ON((int)SNDRV_PCM_STREAM_PLAYBACK != (int)SND_COMPRESS_PLAYBACK); 528 BUILD_BUG_ON((int)SNDRV_PCM_STREAM_CAPTURE != (int)SND_COMPRESS_CAPTURE); 529 530 if (rtd->num_cpus > 1 || 531 rtd->num_codecs > 1) { 532 dev_err(rtd->card->dev, 533 "Compress ASoC: Multi CPU/Codec not supported\n"); 534 return -EINVAL; 535 } 536 537 /* check client and interface hw capabilities */ 538 if (snd_soc_dai_stream_valid(codec_dai, SNDRV_PCM_STREAM_PLAYBACK) && 539 snd_soc_dai_stream_valid(cpu_dai, SNDRV_PCM_STREAM_PLAYBACK)) 540 playback = 1; 541 if (snd_soc_dai_stream_valid(codec_dai, SNDRV_PCM_STREAM_CAPTURE) && 542 snd_soc_dai_stream_valid(cpu_dai, SNDRV_PCM_STREAM_CAPTURE)) 543 capture = 1; 544 545 /* 546 * Compress devices are unidirectional so only one of the directions 547 * should be set, check for that (xor) 548 */ 549 if (playback + capture != 1) { 550 dev_err(rtd->card->dev, 551 "Compress ASoC: Invalid direction for P %d, C %d\n", 552 playback, capture); 553 return -EINVAL; 554 } 555 556 if (playback) 557 direction = SND_COMPRESS_PLAYBACK; 558 else 559 direction = SND_COMPRESS_CAPTURE; 560 561 compr = devm_kzalloc(rtd->card->dev, sizeof(*compr), GFP_KERNEL); 562 if (!compr) 563 return -ENOMEM; 564 565 compr->ops = devm_kzalloc(rtd->card->dev, sizeof(soc_compr_ops), 566 GFP_KERNEL); 567 if (!compr->ops) 568 return -ENOMEM; 569 570 if (rtd->dai_link->dynamic) { 571 snprintf(new_name, sizeof(new_name), "(%s)", 572 rtd->dai_link->stream_name); 573 574 ret = snd_pcm_new_internal(rtd->card->snd_card, new_name, num, 575 rtd->dai_link->dpcm_playback, 576 rtd->dai_link->dpcm_capture, &be_pcm); 577 if (ret < 0) { 578 dev_err(rtd->card->dev, 579 "Compress ASoC: can't create compressed for %s: %d\n", 580 rtd->dai_link->name, ret); 581 return ret; 582 } 583 584 rtd->pcm = be_pcm; 585 rtd->fe_compr = 1; 586 if (rtd->dai_link->dpcm_playback) 587 be_pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream->private_data = rtd; 588 else if (rtd->dai_link->dpcm_capture) 589 be_pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream->private_data = rtd; 590 memcpy(compr->ops, &soc_compr_dyn_ops, sizeof(soc_compr_dyn_ops)); 591 } else { 592 snprintf(new_name, sizeof(new_name), "%s %s-%d", 593 rtd->dai_link->stream_name, codec_dai->name, num); 594 595 memcpy(compr->ops, &soc_compr_ops, sizeof(soc_compr_ops)); 596 } 597 598 for_each_rtd_components(rtd, i, component) { 599 if (!component->driver->compress_ops || 600 !component->driver->compress_ops->copy) 601 continue; 602 603 compr->ops->copy = snd_soc_component_compr_copy; 604 break; 605 } 606 607 mutex_init(&compr->lock); 608 ret = snd_compress_new(rtd->card->snd_card, num, direction, 609 new_name, compr); 610 if (ret < 0) { 611 component = asoc_rtd_to_codec(rtd, 0)->component; 612 dev_err(component->dev, 613 "Compress ASoC: can't create compress for codec %s: %d\n", 614 component->name, ret); 615 return ret; 616 } 617 618 /* DAPM dai link stream work */ 619 rtd->close_delayed_work_func = snd_soc_close_delayed_work; 620 621 rtd->compr = compr; 622 compr->private_data = rtd; 623 624 dev_dbg(rtd->card->dev, "Compress ASoC: %s <-> %s mapping ok\n", 625 codec_dai->name, cpu_dai->name); 626 627 return 0; 628 } 629 EXPORT_SYMBOL_GPL(snd_soc_new_compress); 630