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 <linux/pm_runtime.h> 23 24 static int soc_compr_components_open(struct snd_compr_stream *cstream, 25 struct snd_soc_component **last) 26 { 27 struct snd_soc_pcm_runtime *rtd = cstream->private_data; 28 struct snd_soc_component *component; 29 struct snd_soc_rtdcom_list *rtdcom; 30 int ret; 31 32 for_each_rtd_components(rtd, rtdcom, component) { 33 if (!component->driver->compr_ops || 34 !component->driver->compr_ops->open) 35 continue; 36 37 ret = component->driver->compr_ops->open(cstream); 38 if (ret < 0) { 39 dev_err(component->dev, 40 "Compress ASoC: can't open platform %s: %d\n", 41 component->name, ret); 42 43 *last = component; 44 return ret; 45 } 46 } 47 48 *last = NULL; 49 return 0; 50 } 51 52 static int soc_compr_components_free(struct snd_compr_stream *cstream, 53 struct snd_soc_component *last) 54 { 55 struct snd_soc_pcm_runtime *rtd = cstream->private_data; 56 struct snd_soc_component *component; 57 struct snd_soc_rtdcom_list *rtdcom; 58 59 for_each_rtd_components(rtd, rtdcom, component) { 60 if (component == last) 61 break; 62 63 if (!component->driver->compr_ops || 64 !component->driver->compr_ops->free) 65 continue; 66 67 component->driver->compr_ops->free(cstream); 68 } 69 70 return 0; 71 } 72 73 static int soc_compr_open(struct snd_compr_stream *cstream) 74 { 75 struct snd_soc_pcm_runtime *rtd = cstream->private_data; 76 struct snd_soc_component *component, *save = NULL; 77 struct snd_soc_rtdcom_list *rtdcom; 78 struct snd_soc_dai *cpu_dai = rtd->cpu_dai; 79 int ret; 80 81 for_each_rtd_components(rtd, rtdcom, component) { 82 ret = pm_runtime_get_sync(component->dev); 83 if (ret < 0 && ret != -EACCES) { 84 pm_runtime_put_noidle(component->dev); 85 save = component; 86 goto pm_err; 87 } 88 } 89 90 mutex_lock_nested(&rtd->card->pcm_mutex, rtd->card->pcm_subclass); 91 92 if (cpu_dai->driver->cops && cpu_dai->driver->cops->startup) { 93 ret = cpu_dai->driver->cops->startup(cstream, cpu_dai); 94 if (ret < 0) { 95 dev_err(cpu_dai->dev, 96 "Compress ASoC: can't open interface %s: %d\n", 97 cpu_dai->name, ret); 98 goto out; 99 } 100 } 101 102 ret = soc_compr_components_open(cstream, &component); 103 if (ret < 0) 104 goto machine_err; 105 106 if (rtd->dai_link->compr_ops && rtd->dai_link->compr_ops->startup) { 107 ret = rtd->dai_link->compr_ops->startup(cstream); 108 if (ret < 0) { 109 dev_err(rtd->dev, 110 "Compress ASoC: %s startup failed: %d\n", 111 rtd->dai_link->name, ret); 112 goto machine_err; 113 } 114 } 115 116 snd_soc_runtime_activate(rtd, cstream->direction); 117 118 mutex_unlock(&rtd->card->pcm_mutex); 119 120 return 0; 121 122 machine_err: 123 soc_compr_components_free(cstream, component); 124 125 if (cpu_dai->driver->cops && cpu_dai->driver->cops->shutdown) 126 cpu_dai->driver->cops->shutdown(cstream, cpu_dai); 127 out: 128 mutex_unlock(&rtd->card->pcm_mutex); 129 pm_err: 130 for_each_rtd_components(rtd, rtdcom, component) { 131 if (component == save) 132 break; 133 pm_runtime_mark_last_busy(component->dev); 134 pm_runtime_put_autosuspend(component->dev); 135 } 136 137 return ret; 138 } 139 140 static int soc_compr_open_fe(struct snd_compr_stream *cstream) 141 { 142 struct snd_soc_pcm_runtime *fe = cstream->private_data; 143 struct snd_pcm_substream *fe_substream = 144 fe->pcm->streams[cstream->direction].substream; 145 struct snd_soc_component *component; 146 struct snd_soc_dai *cpu_dai = fe->cpu_dai; 147 struct snd_soc_dpcm *dpcm; 148 struct snd_soc_dapm_widget_list *list; 149 int stream; 150 int ret; 151 152 if (cstream->direction == SND_COMPRESS_PLAYBACK) 153 stream = SNDRV_PCM_STREAM_PLAYBACK; 154 else 155 stream = SNDRV_PCM_STREAM_CAPTURE; 156 157 mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME); 158 fe->dpcm[stream].runtime = fe_substream->runtime; 159 160 ret = dpcm_path_get(fe, stream, &list); 161 if (ret < 0) 162 goto be_err; 163 else if (ret == 0) 164 dev_dbg(fe->dev, "Compress ASoC: %s no valid %s route\n", 165 fe->dai_link->name, stream ? "capture" : "playback"); 166 /* calculate valid and active FE <-> BE dpcms */ 167 dpcm_process_paths(fe, stream, &list, 1); 168 fe->dpcm[stream].runtime = fe_substream->runtime; 169 170 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE; 171 172 ret = dpcm_be_dai_startup(fe, stream); 173 if (ret < 0) { 174 /* clean up all links */ 175 for_each_dpcm_be(fe, stream, dpcm) 176 dpcm->state = SND_SOC_DPCM_LINK_STATE_FREE; 177 178 dpcm_be_disconnect(fe, stream); 179 fe->dpcm[stream].runtime = NULL; 180 goto out; 181 } 182 183 if (cpu_dai->driver->cops && cpu_dai->driver->cops->startup) { 184 ret = cpu_dai->driver->cops->startup(cstream, cpu_dai); 185 if (ret < 0) { 186 dev_err(cpu_dai->dev, 187 "Compress ASoC: can't open interface %s: %d\n", 188 cpu_dai->name, ret); 189 goto out; 190 } 191 } 192 193 ret = soc_compr_components_open(cstream, &component); 194 if (ret < 0) 195 goto open_err; 196 197 if (fe->dai_link->compr_ops && fe->dai_link->compr_ops->startup) { 198 ret = fe->dai_link->compr_ops->startup(cstream); 199 if (ret < 0) { 200 pr_err("Compress ASoC: %s startup failed: %d\n", 201 fe->dai_link->name, ret); 202 goto machine_err; 203 } 204 } 205 206 dpcm_clear_pending_state(fe, stream); 207 dpcm_path_put(&list); 208 209 fe->dpcm[stream].state = SND_SOC_DPCM_STATE_OPEN; 210 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO; 211 212 snd_soc_runtime_activate(fe, stream); 213 214 mutex_unlock(&fe->card->mutex); 215 216 return 0; 217 218 machine_err: 219 soc_compr_components_free(cstream, component); 220 open_err: 221 if (cpu_dai->driver->cops && cpu_dai->driver->cops->shutdown) 222 cpu_dai->driver->cops->shutdown(cstream, cpu_dai); 223 out: 224 dpcm_path_put(&list); 225 be_err: 226 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO; 227 mutex_unlock(&fe->card->mutex); 228 return ret; 229 } 230 231 /* 232 * Power down the audio subsystem pmdown_time msecs after close is called. 233 * This is to ensure there are no pops or clicks in between any music tracks 234 * due to DAPM power cycling. 235 */ 236 static void close_delayed_work(struct snd_soc_pcm_runtime *rtd) 237 { 238 struct snd_soc_dai *codec_dai = rtd->codec_dai; 239 240 mutex_lock_nested(&rtd->card->pcm_mutex, rtd->card->pcm_subclass); 241 242 dev_dbg(rtd->dev, 243 "Compress ASoC: pop wq checking: %s status: %s waiting: %s\n", 244 codec_dai->driver->playback.stream_name, 245 codec_dai->playback_active ? "active" : "inactive", 246 rtd->pop_wait ? "yes" : "no"); 247 248 /* are we waiting on this codec DAI stream */ 249 if (rtd->pop_wait == 1) { 250 rtd->pop_wait = 0; 251 snd_soc_dapm_stream_event(rtd, SNDRV_PCM_STREAM_PLAYBACK, 252 SND_SOC_DAPM_STREAM_STOP); 253 } 254 255 mutex_unlock(&rtd->card->pcm_mutex); 256 } 257 258 static int soc_compr_free(struct snd_compr_stream *cstream) 259 { 260 struct snd_soc_pcm_runtime *rtd = cstream->private_data; 261 struct snd_soc_component *component; 262 struct snd_soc_rtdcom_list *rtdcom; 263 struct snd_soc_dai *cpu_dai = rtd->cpu_dai; 264 struct snd_soc_dai *codec_dai = rtd->codec_dai; 265 int stream; 266 267 mutex_lock_nested(&rtd->card->pcm_mutex, rtd->card->pcm_subclass); 268 269 if (cstream->direction == SND_COMPRESS_PLAYBACK) 270 stream = SNDRV_PCM_STREAM_PLAYBACK; 271 else 272 stream = SNDRV_PCM_STREAM_CAPTURE; 273 274 snd_soc_runtime_deactivate(rtd, stream); 275 276 snd_soc_dai_digital_mute(codec_dai, 1, cstream->direction); 277 278 if (!cpu_dai->active) 279 cpu_dai->rate = 0; 280 281 if (!codec_dai->active) 282 codec_dai->rate = 0; 283 284 if (rtd->dai_link->compr_ops && rtd->dai_link->compr_ops->shutdown) 285 rtd->dai_link->compr_ops->shutdown(cstream); 286 287 soc_compr_components_free(cstream, NULL); 288 289 if (cpu_dai->driver->cops && cpu_dai->driver->cops->shutdown) 290 cpu_dai->driver->cops->shutdown(cstream, cpu_dai); 291 292 if (cstream->direction == SND_COMPRESS_PLAYBACK) { 293 if (snd_soc_runtime_ignore_pmdown_time(rtd)) { 294 snd_soc_dapm_stream_event(rtd, 295 SNDRV_PCM_STREAM_PLAYBACK, 296 SND_SOC_DAPM_STREAM_STOP); 297 } else { 298 rtd->pop_wait = 1; 299 queue_delayed_work(system_power_efficient_wq, 300 &rtd->delayed_work, 301 msecs_to_jiffies(rtd->pmdown_time)); 302 } 303 } else { 304 /* capture streams can be powered down now */ 305 snd_soc_dapm_stream_event(rtd, 306 SNDRV_PCM_STREAM_CAPTURE, 307 SND_SOC_DAPM_STREAM_STOP); 308 } 309 310 mutex_unlock(&rtd->card->pcm_mutex); 311 312 for_each_rtd_components(rtd, rtdcom, component) { 313 pm_runtime_mark_last_busy(component->dev); 314 pm_runtime_put_autosuspend(component->dev); 315 } 316 317 return 0; 318 } 319 320 static int soc_compr_free_fe(struct snd_compr_stream *cstream) 321 { 322 struct snd_soc_pcm_runtime *fe = cstream->private_data; 323 struct snd_soc_dai *cpu_dai = fe->cpu_dai; 324 struct snd_soc_dpcm *dpcm; 325 int stream, ret; 326 327 mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME); 328 329 if (cstream->direction == SND_COMPRESS_PLAYBACK) 330 stream = SNDRV_PCM_STREAM_PLAYBACK; 331 else 332 stream = SNDRV_PCM_STREAM_CAPTURE; 333 334 snd_soc_runtime_deactivate(fe, stream); 335 336 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE; 337 338 ret = dpcm_be_dai_hw_free(fe, stream); 339 if (ret < 0) 340 dev_err(fe->dev, "Compressed ASoC: hw_free failed: %d\n", ret); 341 342 ret = dpcm_be_dai_shutdown(fe, stream); 343 344 /* mark FE's links ready to prune */ 345 for_each_dpcm_be(fe, stream, dpcm) 346 dpcm->state = SND_SOC_DPCM_LINK_STATE_FREE; 347 348 dpcm_dapm_stream_event(fe, stream, SND_SOC_DAPM_STREAM_STOP); 349 350 fe->dpcm[stream].state = SND_SOC_DPCM_STATE_CLOSE; 351 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO; 352 353 dpcm_be_disconnect(fe, stream); 354 355 fe->dpcm[stream].runtime = NULL; 356 357 if (fe->dai_link->compr_ops && fe->dai_link->compr_ops->shutdown) 358 fe->dai_link->compr_ops->shutdown(cstream); 359 360 soc_compr_components_free(cstream, NULL); 361 362 if (cpu_dai->driver->cops && cpu_dai->driver->cops->shutdown) 363 cpu_dai->driver->cops->shutdown(cstream, cpu_dai); 364 365 mutex_unlock(&fe->card->mutex); 366 return 0; 367 } 368 369 static int soc_compr_components_trigger(struct snd_compr_stream *cstream, 370 int cmd) 371 { 372 struct snd_soc_pcm_runtime *rtd = cstream->private_data; 373 struct snd_soc_component *component; 374 struct snd_soc_rtdcom_list *rtdcom; 375 int ret; 376 377 for_each_rtd_components(rtd, rtdcom, component) { 378 if (!component->driver->compr_ops || 379 !component->driver->compr_ops->trigger) 380 continue; 381 382 ret = component->driver->compr_ops->trigger(cstream, cmd); 383 if (ret < 0) 384 return ret; 385 } 386 387 return 0; 388 } 389 390 static int soc_compr_trigger(struct snd_compr_stream *cstream, int cmd) 391 { 392 struct snd_soc_pcm_runtime *rtd = cstream->private_data; 393 struct snd_soc_dai *codec_dai = rtd->codec_dai; 394 struct snd_soc_dai *cpu_dai = rtd->cpu_dai; 395 int ret; 396 397 mutex_lock_nested(&rtd->card->pcm_mutex, rtd->card->pcm_subclass); 398 399 ret = soc_compr_components_trigger(cstream, cmd); 400 if (ret < 0) 401 goto out; 402 403 if (cpu_dai->driver->cops && cpu_dai->driver->cops->trigger) 404 cpu_dai->driver->cops->trigger(cstream, cmd, cpu_dai); 405 406 switch (cmd) { 407 case SNDRV_PCM_TRIGGER_START: 408 snd_soc_dai_digital_mute(codec_dai, 0, cstream->direction); 409 break; 410 case SNDRV_PCM_TRIGGER_STOP: 411 snd_soc_dai_digital_mute(codec_dai, 1, cstream->direction); 412 break; 413 } 414 415 out: 416 mutex_unlock(&rtd->card->pcm_mutex); 417 return ret; 418 } 419 420 static int soc_compr_trigger_fe(struct snd_compr_stream *cstream, int cmd) 421 { 422 struct snd_soc_pcm_runtime *fe = cstream->private_data; 423 struct snd_soc_dai *cpu_dai = fe->cpu_dai; 424 int ret, stream; 425 426 if (cmd == SND_COMPR_TRIGGER_PARTIAL_DRAIN || 427 cmd == SND_COMPR_TRIGGER_DRAIN) 428 return soc_compr_components_trigger(cstream, cmd); 429 430 if (cstream->direction == SND_COMPRESS_PLAYBACK) 431 stream = SNDRV_PCM_STREAM_PLAYBACK; 432 else 433 stream = SNDRV_PCM_STREAM_CAPTURE; 434 435 mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME); 436 437 if (cpu_dai->driver->cops && cpu_dai->driver->cops->trigger) { 438 ret = cpu_dai->driver->cops->trigger(cstream, cmd, cpu_dai); 439 if (ret < 0) 440 goto out; 441 } 442 443 ret = soc_compr_components_trigger(cstream, cmd); 444 if (ret < 0) 445 goto out; 446 447 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE; 448 449 ret = dpcm_be_dai_trigger(fe, stream, cmd); 450 451 switch (cmd) { 452 case SNDRV_PCM_TRIGGER_START: 453 case SNDRV_PCM_TRIGGER_RESUME: 454 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: 455 fe->dpcm[stream].state = SND_SOC_DPCM_STATE_START; 456 break; 457 case SNDRV_PCM_TRIGGER_STOP: 458 case SNDRV_PCM_TRIGGER_SUSPEND: 459 fe->dpcm[stream].state = SND_SOC_DPCM_STATE_STOP; 460 break; 461 case SNDRV_PCM_TRIGGER_PAUSE_PUSH: 462 fe->dpcm[stream].state = SND_SOC_DPCM_STATE_PAUSED; 463 break; 464 } 465 466 out: 467 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO; 468 mutex_unlock(&fe->card->mutex); 469 return ret; 470 } 471 472 static int soc_compr_components_set_params(struct snd_compr_stream *cstream, 473 struct snd_compr_params *params) 474 { 475 struct snd_soc_pcm_runtime *rtd = cstream->private_data; 476 struct snd_soc_component *component; 477 struct snd_soc_rtdcom_list *rtdcom; 478 int ret; 479 480 for_each_rtd_components(rtd, rtdcom, component) { 481 if (!component->driver->compr_ops || 482 !component->driver->compr_ops->set_params) 483 continue; 484 485 ret = component->driver->compr_ops->set_params(cstream, params); 486 if (ret < 0) 487 return ret; 488 } 489 490 return 0; 491 } 492 493 static int soc_compr_set_params(struct snd_compr_stream *cstream, 494 struct snd_compr_params *params) 495 { 496 struct snd_soc_pcm_runtime *rtd = cstream->private_data; 497 struct snd_soc_dai *cpu_dai = rtd->cpu_dai; 498 int ret; 499 500 mutex_lock_nested(&rtd->card->pcm_mutex, rtd->card->pcm_subclass); 501 502 /* 503 * First we call set_params for the CPU DAI, then the component 504 * driver this should configure the SoC side. If the machine has 505 * compressed ops then we call that as well. The expectation is 506 * that these callbacks will configure everything for this compress 507 * path, like configuring a PCM port for a CODEC. 508 */ 509 if (cpu_dai->driver->cops && cpu_dai->driver->cops->set_params) { 510 ret = cpu_dai->driver->cops->set_params(cstream, params, cpu_dai); 511 if (ret < 0) 512 goto err; 513 } 514 515 ret = soc_compr_components_set_params(cstream, params); 516 if (ret < 0) 517 goto err; 518 519 if (rtd->dai_link->compr_ops && rtd->dai_link->compr_ops->set_params) { 520 ret = rtd->dai_link->compr_ops->set_params(cstream); 521 if (ret < 0) 522 goto err; 523 } 524 525 if (cstream->direction == SND_COMPRESS_PLAYBACK) 526 snd_soc_dapm_stream_event(rtd, SNDRV_PCM_STREAM_PLAYBACK, 527 SND_SOC_DAPM_STREAM_START); 528 else 529 snd_soc_dapm_stream_event(rtd, SNDRV_PCM_STREAM_CAPTURE, 530 SND_SOC_DAPM_STREAM_START); 531 532 /* cancel any delayed stream shutdown that is pending */ 533 rtd->pop_wait = 0; 534 mutex_unlock(&rtd->card->pcm_mutex); 535 536 cancel_delayed_work_sync(&rtd->delayed_work); 537 538 return 0; 539 540 err: 541 mutex_unlock(&rtd->card->pcm_mutex); 542 return ret; 543 } 544 545 static int soc_compr_set_params_fe(struct snd_compr_stream *cstream, 546 struct snd_compr_params *params) 547 { 548 struct snd_soc_pcm_runtime *fe = cstream->private_data; 549 struct snd_pcm_substream *fe_substream = 550 fe->pcm->streams[cstream->direction].substream; 551 struct snd_soc_dai *cpu_dai = fe->cpu_dai; 552 int ret, stream; 553 554 if (cstream->direction == SND_COMPRESS_PLAYBACK) 555 stream = SNDRV_PCM_STREAM_PLAYBACK; 556 else 557 stream = SNDRV_PCM_STREAM_CAPTURE; 558 559 mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME); 560 561 /* 562 * Create an empty hw_params for the BE as the machine driver must 563 * fix this up to match DSP decoder and ASRC configuration. 564 * I.e. machine driver fixup for compressed BE is mandatory. 565 */ 566 memset(&fe->dpcm[fe_substream->stream].hw_params, 0, 567 sizeof(struct snd_pcm_hw_params)); 568 569 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE; 570 571 ret = dpcm_be_dai_hw_params(fe, stream); 572 if (ret < 0) 573 goto out; 574 575 ret = dpcm_be_dai_prepare(fe, stream); 576 if (ret < 0) 577 goto out; 578 579 if (cpu_dai->driver->cops && cpu_dai->driver->cops->set_params) { 580 ret = cpu_dai->driver->cops->set_params(cstream, params, cpu_dai); 581 if (ret < 0) 582 goto out; 583 } 584 585 ret = soc_compr_components_set_params(cstream, params); 586 if (ret < 0) 587 goto out; 588 589 if (fe->dai_link->compr_ops && fe->dai_link->compr_ops->set_params) { 590 ret = fe->dai_link->compr_ops->set_params(cstream); 591 if (ret < 0) 592 goto out; 593 } 594 595 dpcm_dapm_stream_event(fe, stream, SND_SOC_DAPM_STREAM_START); 596 fe->dpcm[stream].state = SND_SOC_DPCM_STATE_PREPARE; 597 598 out: 599 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO; 600 mutex_unlock(&fe->card->mutex); 601 return ret; 602 } 603 604 static int soc_compr_get_params(struct snd_compr_stream *cstream, 605 struct snd_codec *params) 606 { 607 struct snd_soc_pcm_runtime *rtd = cstream->private_data; 608 struct snd_soc_component *component; 609 struct snd_soc_rtdcom_list *rtdcom; 610 struct snd_soc_dai *cpu_dai = rtd->cpu_dai; 611 int ret = 0; 612 613 mutex_lock_nested(&rtd->card->pcm_mutex, rtd->card->pcm_subclass); 614 615 if (cpu_dai->driver->cops && cpu_dai->driver->cops->get_params) { 616 ret = cpu_dai->driver->cops->get_params(cstream, params, cpu_dai); 617 if (ret < 0) 618 goto err; 619 } 620 621 for_each_rtd_components(rtd, rtdcom, component) { 622 if (!component->driver->compr_ops || 623 !component->driver->compr_ops->get_params) 624 continue; 625 626 ret = component->driver->compr_ops->get_params(cstream, params); 627 break; 628 } 629 630 err: 631 mutex_unlock(&rtd->card->pcm_mutex); 632 return ret; 633 } 634 635 static int soc_compr_get_caps(struct snd_compr_stream *cstream, 636 struct snd_compr_caps *caps) 637 { 638 struct snd_soc_pcm_runtime *rtd = cstream->private_data; 639 struct snd_soc_component *component; 640 struct snd_soc_rtdcom_list *rtdcom; 641 int ret = 0; 642 643 mutex_lock_nested(&rtd->card->pcm_mutex, rtd->card->pcm_subclass); 644 645 for_each_rtd_components(rtd, rtdcom, component) { 646 if (!component->driver->compr_ops || 647 !component->driver->compr_ops->get_caps) 648 continue; 649 650 ret = component->driver->compr_ops->get_caps(cstream, caps); 651 break; 652 } 653 654 mutex_unlock(&rtd->card->pcm_mutex); 655 return ret; 656 } 657 658 static int soc_compr_get_codec_caps(struct snd_compr_stream *cstream, 659 struct snd_compr_codec_caps *codec) 660 { 661 struct snd_soc_pcm_runtime *rtd = cstream->private_data; 662 struct snd_soc_component *component; 663 struct snd_soc_rtdcom_list *rtdcom; 664 int ret = 0; 665 666 mutex_lock_nested(&rtd->card->pcm_mutex, rtd->card->pcm_subclass); 667 668 for_each_rtd_components(rtd, rtdcom, component) { 669 if (!component->driver->compr_ops || 670 !component->driver->compr_ops->get_codec_caps) 671 continue; 672 673 ret = component->driver->compr_ops->get_codec_caps(cstream, 674 codec); 675 break; 676 } 677 678 mutex_unlock(&rtd->card->pcm_mutex); 679 return ret; 680 } 681 682 static int soc_compr_ack(struct snd_compr_stream *cstream, size_t bytes) 683 { 684 struct snd_soc_pcm_runtime *rtd = cstream->private_data; 685 struct snd_soc_component *component; 686 struct snd_soc_rtdcom_list *rtdcom; 687 struct snd_soc_dai *cpu_dai = rtd->cpu_dai; 688 int ret = 0; 689 690 mutex_lock_nested(&rtd->card->pcm_mutex, rtd->card->pcm_subclass); 691 692 if (cpu_dai->driver->cops && cpu_dai->driver->cops->ack) { 693 ret = cpu_dai->driver->cops->ack(cstream, bytes, cpu_dai); 694 if (ret < 0) 695 goto err; 696 } 697 698 for_each_rtd_components(rtd, rtdcom, component) { 699 if (!component->driver->compr_ops || 700 !component->driver->compr_ops->ack) 701 continue; 702 703 ret = component->driver->compr_ops->ack(cstream, bytes); 704 if (ret < 0) 705 goto err; 706 } 707 708 err: 709 mutex_unlock(&rtd->card->pcm_mutex); 710 return ret; 711 } 712 713 static int soc_compr_pointer(struct snd_compr_stream *cstream, 714 struct snd_compr_tstamp *tstamp) 715 { 716 struct snd_soc_pcm_runtime *rtd = cstream->private_data; 717 struct snd_soc_component *component; 718 struct snd_soc_rtdcom_list *rtdcom; 719 int ret = 0; 720 struct snd_soc_dai *cpu_dai = rtd->cpu_dai; 721 722 mutex_lock_nested(&rtd->card->pcm_mutex, rtd->card->pcm_subclass); 723 724 if (cpu_dai->driver->cops && cpu_dai->driver->cops->pointer) 725 cpu_dai->driver->cops->pointer(cstream, tstamp, cpu_dai); 726 727 for_each_rtd_components(rtd, rtdcom, component) { 728 if (!component->driver->compr_ops || 729 !component->driver->compr_ops->pointer) 730 continue; 731 732 ret = component->driver->compr_ops->pointer(cstream, tstamp); 733 break; 734 } 735 736 mutex_unlock(&rtd->card->pcm_mutex); 737 return ret; 738 } 739 740 static int soc_compr_copy(struct snd_compr_stream *cstream, 741 char __user *buf, size_t count) 742 { 743 struct snd_soc_pcm_runtime *rtd = cstream->private_data; 744 struct snd_soc_component *component; 745 struct snd_soc_rtdcom_list *rtdcom; 746 int ret = 0; 747 748 mutex_lock_nested(&rtd->card->pcm_mutex, rtd->card->pcm_subclass); 749 750 for_each_rtd_components(rtd, rtdcom, component) { 751 if (!component->driver->compr_ops || 752 !component->driver->compr_ops->copy) 753 continue; 754 755 ret = component->driver->compr_ops->copy(cstream, buf, count); 756 break; 757 } 758 759 mutex_unlock(&rtd->card->pcm_mutex); 760 return ret; 761 } 762 763 static int soc_compr_set_metadata(struct snd_compr_stream *cstream, 764 struct snd_compr_metadata *metadata) 765 { 766 struct snd_soc_pcm_runtime *rtd = cstream->private_data; 767 struct snd_soc_component *component; 768 struct snd_soc_rtdcom_list *rtdcom; 769 struct snd_soc_dai *cpu_dai = rtd->cpu_dai; 770 int ret; 771 772 if (cpu_dai->driver->cops && cpu_dai->driver->cops->set_metadata) { 773 ret = cpu_dai->driver->cops->set_metadata(cstream, metadata, cpu_dai); 774 if (ret < 0) 775 return ret; 776 } 777 778 for_each_rtd_components(rtd, rtdcom, component) { 779 if (!component->driver->compr_ops || 780 !component->driver->compr_ops->set_metadata) 781 continue; 782 783 ret = component->driver->compr_ops->set_metadata(cstream, 784 metadata); 785 if (ret < 0) 786 return ret; 787 } 788 789 return 0; 790 } 791 792 static int soc_compr_get_metadata(struct snd_compr_stream *cstream, 793 struct snd_compr_metadata *metadata) 794 { 795 struct snd_soc_pcm_runtime *rtd = cstream->private_data; 796 struct snd_soc_component *component; 797 struct snd_soc_rtdcom_list *rtdcom; 798 struct snd_soc_dai *cpu_dai = rtd->cpu_dai; 799 int ret; 800 801 if (cpu_dai->driver->cops && cpu_dai->driver->cops->get_metadata) { 802 ret = cpu_dai->driver->cops->get_metadata(cstream, metadata, cpu_dai); 803 if (ret < 0) 804 return ret; 805 } 806 807 for_each_rtd_components(rtd, rtdcom, component) { 808 if (!component->driver->compr_ops || 809 !component->driver->compr_ops->get_metadata) 810 continue; 811 812 return component->driver->compr_ops->get_metadata(cstream, 813 metadata); 814 } 815 816 return 0; 817 } 818 819 /* ASoC Compress operations */ 820 static struct snd_compr_ops soc_compr_ops = { 821 .open = soc_compr_open, 822 .free = soc_compr_free, 823 .set_params = soc_compr_set_params, 824 .set_metadata = soc_compr_set_metadata, 825 .get_metadata = soc_compr_get_metadata, 826 .get_params = soc_compr_get_params, 827 .trigger = soc_compr_trigger, 828 .pointer = soc_compr_pointer, 829 .ack = soc_compr_ack, 830 .get_caps = soc_compr_get_caps, 831 .get_codec_caps = soc_compr_get_codec_caps 832 }; 833 834 /* ASoC Dynamic Compress operations */ 835 static struct snd_compr_ops soc_compr_dyn_ops = { 836 .open = soc_compr_open_fe, 837 .free = soc_compr_free_fe, 838 .set_params = soc_compr_set_params_fe, 839 .get_params = soc_compr_get_params, 840 .set_metadata = soc_compr_set_metadata, 841 .get_metadata = soc_compr_get_metadata, 842 .trigger = soc_compr_trigger_fe, 843 .pointer = soc_compr_pointer, 844 .ack = soc_compr_ack, 845 .get_caps = soc_compr_get_caps, 846 .get_codec_caps = soc_compr_get_codec_caps 847 }; 848 849 /** 850 * snd_soc_new_compress - create a new compress. 851 * 852 * @rtd: The runtime for which we will create compress 853 * @num: the device index number (zero based - shared with normal PCMs) 854 * 855 * Return: 0 for success, else error. 856 */ 857 int snd_soc_new_compress(struct snd_soc_pcm_runtime *rtd, int num) 858 { 859 struct snd_soc_component *component; 860 struct snd_soc_rtdcom_list *rtdcom; 861 struct snd_soc_dai *codec_dai = rtd->codec_dai; 862 struct snd_soc_dai *cpu_dai = rtd->cpu_dai; 863 struct snd_compr *compr; 864 struct snd_pcm *be_pcm; 865 char new_name[64]; 866 int ret = 0, direction = 0; 867 int playback = 0, capture = 0; 868 869 if (rtd->num_codecs > 1) { 870 dev_err(rtd->card->dev, 871 "Compress ASoC: Multicodec not supported\n"); 872 return -EINVAL; 873 } 874 875 /* check client and interface hw capabilities */ 876 if (snd_soc_dai_stream_valid(codec_dai, SNDRV_PCM_STREAM_PLAYBACK) && 877 snd_soc_dai_stream_valid(cpu_dai, SNDRV_PCM_STREAM_PLAYBACK)) 878 playback = 1; 879 if (snd_soc_dai_stream_valid(codec_dai, SNDRV_PCM_STREAM_CAPTURE) && 880 snd_soc_dai_stream_valid(cpu_dai, SNDRV_PCM_STREAM_CAPTURE)) 881 capture = 1; 882 883 /* 884 * Compress devices are unidirectional so only one of the directions 885 * should be set, check for that (xor) 886 */ 887 if (playback + capture != 1) { 888 dev_err(rtd->card->dev, 889 "Compress ASoC: Invalid direction for P %d, C %d\n", 890 playback, capture); 891 return -EINVAL; 892 } 893 894 if (playback) 895 direction = SND_COMPRESS_PLAYBACK; 896 else 897 direction = SND_COMPRESS_CAPTURE; 898 899 compr = devm_kzalloc(rtd->card->dev, sizeof(*compr), GFP_KERNEL); 900 if (!compr) 901 return -ENOMEM; 902 903 compr->ops = devm_kzalloc(rtd->card->dev, sizeof(soc_compr_ops), 904 GFP_KERNEL); 905 if (!compr->ops) 906 return -ENOMEM; 907 908 if (rtd->dai_link->dynamic) { 909 snprintf(new_name, sizeof(new_name), "(%s)", 910 rtd->dai_link->stream_name); 911 912 ret = snd_pcm_new_internal(rtd->card->snd_card, new_name, num, 913 rtd->dai_link->dpcm_playback, 914 rtd->dai_link->dpcm_capture, &be_pcm); 915 if (ret < 0) { 916 dev_err(rtd->card->dev, 917 "Compress ASoC: can't create compressed for %s: %d\n", 918 rtd->dai_link->name, ret); 919 return ret; 920 } 921 922 rtd->pcm = be_pcm; 923 rtd->fe_compr = 1; 924 if (rtd->dai_link->dpcm_playback) 925 be_pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream->private_data = rtd; 926 else if (rtd->dai_link->dpcm_capture) 927 be_pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream->private_data = rtd; 928 memcpy(compr->ops, &soc_compr_dyn_ops, sizeof(soc_compr_dyn_ops)); 929 } else { 930 snprintf(new_name, sizeof(new_name), "%s %s-%d", 931 rtd->dai_link->stream_name, codec_dai->name, num); 932 933 memcpy(compr->ops, &soc_compr_ops, sizeof(soc_compr_ops)); 934 } 935 936 for_each_rtd_components(rtd, rtdcom, component) { 937 if (!component->driver->compr_ops || 938 !component->driver->compr_ops->copy) 939 continue; 940 941 compr->ops->copy = soc_compr_copy; 942 break; 943 } 944 945 mutex_init(&compr->lock); 946 ret = snd_compress_new(rtd->card->snd_card, num, direction, 947 new_name, compr); 948 if (ret < 0) { 949 component = rtd->codec_dai->component; 950 dev_err(component->dev, 951 "Compress ASoC: can't create compress for codec %s: %d\n", 952 component->name, ret); 953 return ret; 954 } 955 956 /* DAPM dai link stream work */ 957 rtd->close_delayed_work_func = close_delayed_work; 958 959 rtd->compr = compr; 960 compr->private_data = rtd; 961 962 dev_info(rtd->card->dev, "Compress ASoC: %s <-> %s mapping ok\n", 963 codec_dai->name, cpu_dai->name); 964 965 return 0; 966 } 967 EXPORT_SYMBOL_GPL(snd_soc_new_compress); 968