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 struct snd_soc_component *component; 34 struct snd_soc_rtdcom_list *rtdcom; 35 struct snd_soc_dai *cpu_dai = rtd->cpu_dai; 36 int ret = 0, __ret; 37 38 mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass); 39 40 if (cpu_dai->driver->cops && cpu_dai->driver->cops->startup) { 41 ret = cpu_dai->driver->cops->startup(cstream, cpu_dai); 42 if (ret < 0) { 43 dev_err(cpu_dai->dev, 44 "Compress ASoC: can't open interface %s: %d\n", 45 cpu_dai->name, ret); 46 goto out; 47 } 48 } 49 50 if (platform && platform->driver->compr_ops && platform->driver->compr_ops->open) { 51 ret = platform->driver->compr_ops->open(cstream); 52 if (ret < 0) { 53 dev_err(platform->dev, 54 "Compress ASoC: can't open platform %s: %d\n", 55 platform->component.name, ret); 56 goto plat_err; 57 } 58 } 59 60 for_each_rtdcom(rtd, rtdcom) { 61 component = rtdcom->component; 62 63 /* ignore duplication for now */ 64 if (platform && (component == &platform->component)) 65 continue; 66 67 if (!component->driver->compr_ops || 68 !component->driver->compr_ops->open) 69 continue; 70 71 __ret = component->driver->compr_ops->open(cstream); 72 if (__ret < 0) { 73 dev_err(component->dev, 74 "Compress ASoC: can't open platform %s: %d\n", 75 component->name, __ret); 76 ret = __ret; 77 } 78 } 79 if (ret < 0) 80 goto machine_err; 81 82 if (rtd->dai_link->compr_ops && rtd->dai_link->compr_ops->startup) { 83 ret = rtd->dai_link->compr_ops->startup(cstream); 84 if (ret < 0) { 85 dev_err(rtd->dev, 86 "Compress ASoC: %s startup failed: %d\n", 87 rtd->dai_link->name, ret); 88 goto machine_err; 89 } 90 } 91 92 snd_soc_runtime_activate(rtd, cstream->direction); 93 94 mutex_unlock(&rtd->pcm_mutex); 95 96 return 0; 97 98 machine_err: 99 for_each_rtdcom(rtd, rtdcom) { 100 component = rtdcom->component; 101 102 /* ignore duplication for now */ 103 if (platform && (component == &platform->component)) 104 continue; 105 106 if (!component->driver->compr_ops || 107 !component->driver->compr_ops->free) 108 continue; 109 110 component->driver->compr_ops->free(cstream); 111 } 112 113 if (platform && platform->driver->compr_ops && platform->driver->compr_ops->free) 114 platform->driver->compr_ops->free(cstream); 115 plat_err: 116 if (cpu_dai->driver->cops && cpu_dai->driver->cops->shutdown) 117 cpu_dai->driver->cops->shutdown(cstream, cpu_dai); 118 out: 119 mutex_unlock(&rtd->pcm_mutex); 120 return ret; 121 } 122 123 static int soc_compr_open_fe(struct snd_compr_stream *cstream) 124 { 125 struct snd_soc_pcm_runtime *fe = cstream->private_data; 126 struct snd_pcm_substream *fe_substream = 127 fe->pcm->streams[cstream->direction].substream; 128 struct snd_soc_platform *platform = fe->platform; 129 struct snd_soc_component *component; 130 struct snd_soc_rtdcom_list *rtdcom; 131 struct snd_soc_dai *cpu_dai = fe->cpu_dai; 132 struct snd_soc_dpcm *dpcm; 133 struct snd_soc_dapm_widget_list *list; 134 int stream; 135 int ret = 0, __ret; 136 137 if (cstream->direction == SND_COMPRESS_PLAYBACK) 138 stream = SNDRV_PCM_STREAM_PLAYBACK; 139 else 140 stream = SNDRV_PCM_STREAM_CAPTURE; 141 142 mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME); 143 144 if (cpu_dai->driver->cops && cpu_dai->driver->cops->startup) { 145 ret = cpu_dai->driver->cops->startup(cstream, cpu_dai); 146 if (ret < 0) { 147 dev_err(cpu_dai->dev, 148 "Compress ASoC: can't open interface %s: %d\n", 149 cpu_dai->name, ret); 150 goto out; 151 } 152 } 153 154 if (platform && platform->driver->compr_ops && platform->driver->compr_ops->open) { 155 ret = platform->driver->compr_ops->open(cstream); 156 if (ret < 0) { 157 dev_err(platform->dev, 158 "Compress ASoC: can't open platform %s: %d\n", 159 platform->component.name, ret); 160 goto plat_err; 161 } 162 } 163 164 for_each_rtdcom(fe, rtdcom) { 165 component = rtdcom->component; 166 167 /* ignore duplication for now */ 168 if (platform && (component == &platform->component)) 169 continue; 170 171 if (!component->driver->compr_ops || 172 !component->driver->compr_ops->open) 173 continue; 174 175 __ret = component->driver->compr_ops->open(cstream); 176 if (__ret < 0) { 177 dev_err(component->dev, 178 "Compress ASoC: can't open platform %s: %d\n", 179 component->name, __ret); 180 ret = __ret; 181 } 182 } 183 if (ret < 0) 184 goto machine_err; 185 186 if (fe->dai_link->compr_ops && fe->dai_link->compr_ops->startup) { 187 ret = fe->dai_link->compr_ops->startup(cstream); 188 if (ret < 0) { 189 pr_err("Compress ASoC: %s startup failed: %d\n", 190 fe->dai_link->name, ret); 191 goto machine_err; 192 } 193 } 194 195 fe->dpcm[stream].runtime = fe_substream->runtime; 196 197 ret = dpcm_path_get(fe, stream, &list); 198 if (ret < 0) 199 goto fe_err; 200 else if (ret == 0) 201 dev_dbg(fe->dev, "Compress ASoC: %s no valid %s route\n", 202 fe->dai_link->name, stream ? "capture" : "playback"); 203 204 /* calculate valid and active FE <-> BE dpcms */ 205 dpcm_process_paths(fe, stream, &list, 1); 206 207 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE; 208 209 ret = dpcm_be_dai_startup(fe, stream); 210 if (ret < 0) { 211 /* clean up all links */ 212 list_for_each_entry(dpcm, &fe->dpcm[stream].be_clients, list_be) 213 dpcm->state = SND_SOC_DPCM_LINK_STATE_FREE; 214 215 dpcm_be_disconnect(fe, stream); 216 fe->dpcm[stream].runtime = NULL; 217 goto path_err; 218 } 219 220 dpcm_clear_pending_state(fe, stream); 221 dpcm_path_put(&list); 222 223 fe->dpcm[stream].state = SND_SOC_DPCM_STATE_OPEN; 224 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO; 225 226 snd_soc_runtime_activate(fe, stream); 227 228 mutex_unlock(&fe->card->mutex); 229 230 return 0; 231 232 path_err: 233 dpcm_path_put(&list); 234 fe_err: 235 if (fe->dai_link->compr_ops && fe->dai_link->compr_ops->shutdown) 236 fe->dai_link->compr_ops->shutdown(cstream); 237 machine_err: 238 for_each_rtdcom(fe, rtdcom) { 239 component = rtdcom->component; 240 241 /* ignore duplication for now */ 242 if (platform && (component == &platform->component)) 243 continue; 244 245 if (!component->driver->compr_ops || 246 !component->driver->compr_ops->free) 247 continue; 248 249 component->driver->compr_ops->free(cstream); 250 } 251 252 if (platform && platform->driver->compr_ops && platform->driver->compr_ops->free) 253 platform->driver->compr_ops->free(cstream); 254 plat_err: 255 if (cpu_dai->driver->cops && cpu_dai->driver->cops->shutdown) 256 cpu_dai->driver->cops->shutdown(cstream, cpu_dai); 257 out: 258 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO; 259 mutex_unlock(&fe->card->mutex); 260 return ret; 261 } 262 263 /* 264 * Power down the audio subsystem pmdown_time msecs after close is called. 265 * This is to ensure there are no pops or clicks in between any music tracks 266 * due to DAPM power cycling. 267 */ 268 static void close_delayed_work(struct work_struct *work) 269 { 270 struct snd_soc_pcm_runtime *rtd = 271 container_of(work, struct snd_soc_pcm_runtime, delayed_work.work); 272 struct snd_soc_dai *codec_dai = rtd->codec_dai; 273 274 mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass); 275 276 dev_dbg(rtd->dev, 277 "Compress ASoC: pop wq checking: %s status: %s waiting: %s\n", 278 codec_dai->driver->playback.stream_name, 279 codec_dai->playback_active ? "active" : "inactive", 280 rtd->pop_wait ? "yes" : "no"); 281 282 /* are we waiting on this codec DAI stream */ 283 if (rtd->pop_wait == 1) { 284 rtd->pop_wait = 0; 285 snd_soc_dapm_stream_event(rtd, SNDRV_PCM_STREAM_PLAYBACK, 286 SND_SOC_DAPM_STREAM_STOP); 287 } 288 289 mutex_unlock(&rtd->pcm_mutex); 290 } 291 292 static int soc_compr_free(struct snd_compr_stream *cstream) 293 { 294 struct snd_soc_pcm_runtime *rtd = cstream->private_data; 295 struct snd_soc_platform *platform = rtd->platform; 296 struct snd_soc_component *component; 297 struct snd_soc_rtdcom_list *rtdcom; 298 struct snd_soc_dai *cpu_dai = rtd->cpu_dai; 299 struct snd_soc_dai *codec_dai = rtd->codec_dai; 300 int stream; 301 302 mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass); 303 304 if (cstream->direction == SND_COMPRESS_PLAYBACK) 305 stream = SNDRV_PCM_STREAM_PLAYBACK; 306 else 307 stream = SNDRV_PCM_STREAM_CAPTURE; 308 309 snd_soc_runtime_deactivate(rtd, stream); 310 311 snd_soc_dai_digital_mute(codec_dai, 1, cstream->direction); 312 313 if (!cpu_dai->active) 314 cpu_dai->rate = 0; 315 316 if (!codec_dai->active) 317 codec_dai->rate = 0; 318 319 if (rtd->dai_link->compr_ops && rtd->dai_link->compr_ops->shutdown) 320 rtd->dai_link->compr_ops->shutdown(cstream); 321 322 for_each_rtdcom(rtd, rtdcom) { 323 component = rtdcom->component; 324 325 /* ignore duplication for now */ 326 if (platform && (component == &platform->component)) 327 continue; 328 329 if (!component->driver->compr_ops || 330 !component->driver->compr_ops->free) 331 continue; 332 333 component->driver->compr_ops->free(cstream); 334 } 335 336 if (platform && platform->driver->compr_ops && platform->driver->compr_ops->free) 337 platform->driver->compr_ops->free(cstream); 338 339 if (cpu_dai->driver->cops && cpu_dai->driver->cops->shutdown) 340 cpu_dai->driver->cops->shutdown(cstream, cpu_dai); 341 342 if (cstream->direction == SND_COMPRESS_PLAYBACK) { 343 if (snd_soc_runtime_ignore_pmdown_time(rtd)) { 344 snd_soc_dapm_stream_event(rtd, 345 SNDRV_PCM_STREAM_PLAYBACK, 346 SND_SOC_DAPM_STREAM_STOP); 347 } else { 348 rtd->pop_wait = 1; 349 queue_delayed_work(system_power_efficient_wq, 350 &rtd->delayed_work, 351 msecs_to_jiffies(rtd->pmdown_time)); 352 } 353 } else { 354 /* capture streams can be powered down now */ 355 snd_soc_dapm_stream_event(rtd, 356 SNDRV_PCM_STREAM_CAPTURE, 357 SND_SOC_DAPM_STREAM_STOP); 358 } 359 360 mutex_unlock(&rtd->pcm_mutex); 361 return 0; 362 } 363 364 static int soc_compr_free_fe(struct snd_compr_stream *cstream) 365 { 366 struct snd_soc_pcm_runtime *fe = cstream->private_data; 367 struct snd_soc_platform *platform = fe->platform; 368 struct snd_soc_component *component; 369 struct snd_soc_rtdcom_list *rtdcom; 370 struct snd_soc_dai *cpu_dai = fe->cpu_dai; 371 struct snd_soc_dpcm *dpcm; 372 int stream, ret; 373 374 mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME); 375 376 if (cstream->direction == SND_COMPRESS_PLAYBACK) 377 stream = SNDRV_PCM_STREAM_PLAYBACK; 378 else 379 stream = SNDRV_PCM_STREAM_CAPTURE; 380 381 snd_soc_runtime_deactivate(fe, stream); 382 383 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE; 384 385 ret = dpcm_be_dai_hw_free(fe, stream); 386 if (ret < 0) 387 dev_err(fe->dev, "Compressed ASoC: hw_free failed: %d\n", ret); 388 389 ret = dpcm_be_dai_shutdown(fe, stream); 390 391 /* mark FE's links ready to prune */ 392 list_for_each_entry(dpcm, &fe->dpcm[stream].be_clients, list_be) 393 dpcm->state = SND_SOC_DPCM_LINK_STATE_FREE; 394 395 dpcm_dapm_stream_event(fe, stream, SND_SOC_DAPM_STREAM_STOP); 396 397 fe->dpcm[stream].state = SND_SOC_DPCM_STATE_CLOSE; 398 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO; 399 400 dpcm_be_disconnect(fe, stream); 401 402 fe->dpcm[stream].runtime = NULL; 403 404 if (fe->dai_link->compr_ops && fe->dai_link->compr_ops->shutdown) 405 fe->dai_link->compr_ops->shutdown(cstream); 406 407 if (platform && platform->driver->compr_ops && platform->driver->compr_ops->free) 408 platform->driver->compr_ops->free(cstream); 409 410 for_each_rtdcom(fe, rtdcom) { 411 component = rtdcom->component; 412 413 /* ignore duplication for now */ 414 if (platform && (component == &platform->component)) 415 continue; 416 417 if (!component->driver->compr_ops || 418 !component->driver->compr_ops->free) 419 continue; 420 421 component->driver->compr_ops->free(cstream); 422 } 423 424 if (cpu_dai->driver->cops && cpu_dai->driver->cops->shutdown) 425 cpu_dai->driver->cops->shutdown(cstream, cpu_dai); 426 427 mutex_unlock(&fe->card->mutex); 428 return 0; 429 } 430 431 static int soc_compr_trigger(struct snd_compr_stream *cstream, int cmd) 432 { 433 434 struct snd_soc_pcm_runtime *rtd = cstream->private_data; 435 struct snd_soc_platform *platform = rtd->platform; 436 struct snd_soc_component *component; 437 struct snd_soc_rtdcom_list *rtdcom; 438 struct snd_soc_dai *codec_dai = rtd->codec_dai; 439 struct snd_soc_dai *cpu_dai = rtd->cpu_dai; 440 int ret = 0, __ret; 441 442 mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass); 443 444 if (platform && platform->driver->compr_ops && platform->driver->compr_ops->trigger) { 445 ret = platform->driver->compr_ops->trigger(cstream, cmd); 446 if (ret < 0) 447 goto out; 448 } 449 450 for_each_rtdcom(rtd, rtdcom) { 451 component = rtdcom->component; 452 453 /* ignore duplication for now */ 454 if (platform && (component == &platform->component)) 455 continue; 456 457 if (!component->driver->compr_ops || 458 !component->driver->compr_ops->trigger) 459 continue; 460 461 __ret = component->driver->compr_ops->trigger(cstream, cmd); 462 if (__ret < 0) 463 ret = __ret; 464 } 465 if (ret < 0) 466 goto out; 467 468 if (cpu_dai->driver->cops && cpu_dai->driver->cops->trigger) 469 cpu_dai->driver->cops->trigger(cstream, cmd, cpu_dai); 470 471 switch (cmd) { 472 case SNDRV_PCM_TRIGGER_START: 473 snd_soc_dai_digital_mute(codec_dai, 0, cstream->direction); 474 break; 475 case SNDRV_PCM_TRIGGER_STOP: 476 snd_soc_dai_digital_mute(codec_dai, 1, cstream->direction); 477 break; 478 } 479 480 out: 481 mutex_unlock(&rtd->pcm_mutex); 482 return ret; 483 } 484 485 static int soc_compr_trigger_fe(struct snd_compr_stream *cstream, int cmd) 486 { 487 struct snd_soc_pcm_runtime *fe = cstream->private_data; 488 struct snd_soc_platform *platform = fe->platform; 489 struct snd_soc_component *component; 490 struct snd_soc_rtdcom_list *rtdcom; 491 struct snd_soc_dai *cpu_dai = fe->cpu_dai; 492 int ret = 0, __ret, stream; 493 494 if (cmd == SND_COMPR_TRIGGER_PARTIAL_DRAIN || 495 cmd == SND_COMPR_TRIGGER_DRAIN) { 496 497 if (platform && 498 platform->driver->compr_ops && 499 platform->driver->compr_ops->trigger) 500 return platform->driver->compr_ops->trigger(cstream, 501 cmd); 502 503 for_each_rtdcom(fe, rtdcom) { 504 component = rtdcom->component; 505 506 /* ignore duplication for now */ 507 if (platform && (component == &platform->component)) 508 continue; 509 510 if (!component->driver->compr_ops || 511 !component->driver->compr_ops->trigger) 512 continue; 513 514 __ret = component->driver->compr_ops->trigger(cstream, cmd); 515 if (__ret < 0) 516 ret = __ret; 517 } 518 return ret; 519 } 520 521 if (cstream->direction == SND_COMPRESS_PLAYBACK) 522 stream = SNDRV_PCM_STREAM_PLAYBACK; 523 else 524 stream = SNDRV_PCM_STREAM_CAPTURE; 525 526 527 mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME); 528 529 if (cpu_dai->driver->cops && cpu_dai->driver->cops->trigger) { 530 ret = cpu_dai->driver->cops->trigger(cstream, cmd, cpu_dai); 531 if (ret < 0) 532 goto out; 533 } 534 535 if (platform && platform->driver->compr_ops && platform->driver->compr_ops->trigger) { 536 ret = platform->driver->compr_ops->trigger(cstream, cmd); 537 if (ret < 0) 538 goto out; 539 } 540 541 for_each_rtdcom(fe, rtdcom) { 542 component = rtdcom->component; 543 544 /* ignore duplication for now */ 545 if (platform && (component == &platform->component)) 546 continue; 547 548 if (!component->driver->compr_ops || 549 !component->driver->compr_ops->trigger) 550 continue; 551 552 __ret = component->driver->compr_ops->trigger(cstream, cmd); 553 if (__ret < 0) 554 ret = __ret; 555 } 556 if (ret < 0) 557 goto out; 558 559 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE; 560 561 ret = dpcm_be_dai_trigger(fe, stream, cmd); 562 563 switch (cmd) { 564 case SNDRV_PCM_TRIGGER_START: 565 case SNDRV_PCM_TRIGGER_RESUME: 566 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: 567 fe->dpcm[stream].state = SND_SOC_DPCM_STATE_START; 568 break; 569 case SNDRV_PCM_TRIGGER_STOP: 570 case SNDRV_PCM_TRIGGER_SUSPEND: 571 fe->dpcm[stream].state = SND_SOC_DPCM_STATE_STOP; 572 break; 573 case SNDRV_PCM_TRIGGER_PAUSE_PUSH: 574 fe->dpcm[stream].state = SND_SOC_DPCM_STATE_PAUSED; 575 break; 576 } 577 578 out: 579 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO; 580 mutex_unlock(&fe->card->mutex); 581 return ret; 582 } 583 584 static int soc_compr_set_params(struct snd_compr_stream *cstream, 585 struct snd_compr_params *params) 586 { 587 struct snd_soc_pcm_runtime *rtd = cstream->private_data; 588 struct snd_soc_platform *platform = rtd->platform; 589 struct snd_soc_component *component; 590 struct snd_soc_rtdcom_list *rtdcom; 591 struct snd_soc_dai *cpu_dai = rtd->cpu_dai; 592 int ret = 0, __ret; 593 594 mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass); 595 596 /* first we call set_params for the platform driver 597 * this should configure the soc side 598 * if the machine has compressed ops then we call that as well 599 * expectation is that platform and machine will configure everything 600 * for this compress path, like configuring pcm port for codec 601 */ 602 if (cpu_dai->driver->cops && cpu_dai->driver->cops->set_params) { 603 ret = cpu_dai->driver->cops->set_params(cstream, params, cpu_dai); 604 if (ret < 0) 605 goto err; 606 } 607 608 if (platform && platform->driver->compr_ops && platform->driver->compr_ops->set_params) { 609 ret = platform->driver->compr_ops->set_params(cstream, params); 610 if (ret < 0) 611 goto err; 612 } 613 614 for_each_rtdcom(rtd, rtdcom) { 615 component = rtdcom->component; 616 617 /* ignore duplication for now */ 618 if (platform && (component == &platform->component)) 619 continue; 620 621 if (!component->driver->compr_ops || 622 !component->driver->compr_ops->set_params) 623 continue; 624 625 __ret = component->driver->compr_ops->set_params(cstream, params); 626 if (__ret < 0) 627 ret = __ret; 628 } 629 if (ret < 0) 630 goto err; 631 632 if (rtd->dai_link->compr_ops && rtd->dai_link->compr_ops->set_params) { 633 ret = rtd->dai_link->compr_ops->set_params(cstream); 634 if (ret < 0) 635 goto err; 636 } 637 638 if (cstream->direction == SND_COMPRESS_PLAYBACK) 639 snd_soc_dapm_stream_event(rtd, SNDRV_PCM_STREAM_PLAYBACK, 640 SND_SOC_DAPM_STREAM_START); 641 else 642 snd_soc_dapm_stream_event(rtd, SNDRV_PCM_STREAM_CAPTURE, 643 SND_SOC_DAPM_STREAM_START); 644 645 /* cancel any delayed stream shutdown that is pending */ 646 rtd->pop_wait = 0; 647 mutex_unlock(&rtd->pcm_mutex); 648 649 cancel_delayed_work_sync(&rtd->delayed_work); 650 651 return ret; 652 653 err: 654 mutex_unlock(&rtd->pcm_mutex); 655 return ret; 656 } 657 658 static int soc_compr_set_params_fe(struct snd_compr_stream *cstream, 659 struct snd_compr_params *params) 660 { 661 struct snd_soc_pcm_runtime *fe = cstream->private_data; 662 struct snd_pcm_substream *fe_substream = 663 fe->pcm->streams[cstream->direction].substream; 664 struct snd_soc_platform *platform = fe->platform; 665 struct snd_soc_component *component; 666 struct snd_soc_rtdcom_list *rtdcom; 667 struct snd_soc_dai *cpu_dai = fe->cpu_dai; 668 int ret = 0, __ret, stream; 669 670 if (cstream->direction == SND_COMPRESS_PLAYBACK) 671 stream = SNDRV_PCM_STREAM_PLAYBACK; 672 else 673 stream = SNDRV_PCM_STREAM_CAPTURE; 674 675 mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME); 676 677 if (cpu_dai->driver->cops && cpu_dai->driver->cops->set_params) { 678 ret = cpu_dai->driver->cops->set_params(cstream, params, cpu_dai); 679 if (ret < 0) 680 goto out; 681 } 682 683 if (platform && platform->driver->compr_ops && platform->driver->compr_ops->set_params) { 684 ret = platform->driver->compr_ops->set_params(cstream, params); 685 if (ret < 0) 686 goto out; 687 } 688 689 for_each_rtdcom(fe, rtdcom) { 690 component = rtdcom->component; 691 692 /* ignore duplication for now */ 693 if (platform && (component == &platform->component)) 694 continue; 695 696 if (!component->driver->compr_ops || 697 !component->driver->compr_ops->set_params) 698 continue; 699 700 __ret = component->driver->compr_ops->set_params(cstream, params); 701 if (__ret < 0) 702 ret = __ret; 703 } 704 if (ret < 0) 705 goto out; 706 707 if (fe->dai_link->compr_ops && fe->dai_link->compr_ops->set_params) { 708 ret = fe->dai_link->compr_ops->set_params(cstream); 709 if (ret < 0) 710 goto out; 711 } 712 713 /* 714 * Create an empty hw_params for the BE as the machine driver must 715 * fix this up to match DSP decoder and ASRC configuration. 716 * I.e. machine driver fixup for compressed BE is mandatory. 717 */ 718 memset(&fe->dpcm[fe_substream->stream].hw_params, 0, 719 sizeof(struct snd_pcm_hw_params)); 720 721 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE; 722 723 ret = dpcm_be_dai_hw_params(fe, stream); 724 if (ret < 0) 725 goto out; 726 727 ret = dpcm_be_dai_prepare(fe, stream); 728 if (ret < 0) 729 goto out; 730 731 dpcm_dapm_stream_event(fe, stream, SND_SOC_DAPM_STREAM_START); 732 fe->dpcm[stream].state = SND_SOC_DPCM_STATE_PREPARE; 733 734 out: 735 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO; 736 mutex_unlock(&fe->card->mutex); 737 return ret; 738 } 739 740 static int soc_compr_get_params(struct snd_compr_stream *cstream, 741 struct snd_codec *params) 742 { 743 struct snd_soc_pcm_runtime *rtd = cstream->private_data; 744 struct snd_soc_platform *platform = rtd->platform; 745 struct snd_soc_component *component; 746 struct snd_soc_rtdcom_list *rtdcom; 747 struct snd_soc_dai *cpu_dai = rtd->cpu_dai; 748 int ret = 0, __ret; 749 750 mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass); 751 752 if (cpu_dai->driver->cops && cpu_dai->driver->cops->get_params) { 753 ret = cpu_dai->driver->cops->get_params(cstream, params, cpu_dai); 754 if (ret < 0) 755 goto err; 756 } 757 758 if (platform && platform->driver->compr_ops && platform->driver->compr_ops->get_params) { 759 ret = platform->driver->compr_ops->get_params(cstream, params); 760 if (ret < 0) 761 goto err; 762 } 763 764 for_each_rtdcom(rtd, rtdcom) { 765 component = rtdcom->component; 766 767 /* ignore duplication for now */ 768 if (platform && (component == &platform->component)) 769 continue; 770 771 if (!component->driver->compr_ops || 772 !component->driver->compr_ops->get_params) 773 continue; 774 775 __ret = component->driver->compr_ops->get_params(cstream, params); 776 if (__ret < 0) 777 ret = __ret; 778 } 779 780 err: 781 mutex_unlock(&rtd->pcm_mutex); 782 return ret; 783 } 784 785 static int soc_compr_get_caps(struct snd_compr_stream *cstream, 786 struct snd_compr_caps *caps) 787 { 788 struct snd_soc_pcm_runtime *rtd = cstream->private_data; 789 struct snd_soc_platform *platform = rtd->platform; 790 struct snd_soc_component *component; 791 struct snd_soc_rtdcom_list *rtdcom; 792 int ret = 0, __ret; 793 794 mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass); 795 796 if (platform && platform->driver->compr_ops && platform->driver->compr_ops->get_caps) { 797 ret = platform->driver->compr_ops->get_caps(cstream, caps); 798 if (ret < 0) 799 goto err; 800 } 801 802 for_each_rtdcom(rtd, rtdcom) { 803 component = rtdcom->component; 804 805 /* ignore duplication for now */ 806 if (platform && (component == &platform->component)) 807 continue; 808 809 if (!component->driver->compr_ops || 810 !component->driver->compr_ops->get_caps) 811 continue; 812 813 __ret = component->driver->compr_ops->get_caps(cstream, caps); 814 if (__ret < 0) 815 ret = __ret; 816 } 817 818 err: 819 mutex_unlock(&rtd->pcm_mutex); 820 return ret; 821 } 822 823 static int soc_compr_get_codec_caps(struct snd_compr_stream *cstream, 824 struct snd_compr_codec_caps *codec) 825 { 826 struct snd_soc_pcm_runtime *rtd = cstream->private_data; 827 struct snd_soc_platform *platform = rtd->platform; 828 struct snd_soc_component *component; 829 struct snd_soc_rtdcom_list *rtdcom; 830 int ret = 0, __ret; 831 832 mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass); 833 834 if (platform && platform->driver->compr_ops && platform->driver->compr_ops->get_codec_caps) { 835 ret = platform->driver->compr_ops->get_codec_caps(cstream, codec); 836 if (ret < 0) 837 goto err; 838 } 839 840 for_each_rtdcom(rtd, rtdcom) { 841 component = rtdcom->component; 842 843 /* ignore duplication for now */ 844 if (platform && (component == &platform->component)) 845 continue; 846 847 if (!component->driver->compr_ops || 848 !component->driver->compr_ops->get_codec_caps) 849 continue; 850 851 __ret = component->driver->compr_ops->get_codec_caps(cstream, codec); 852 if (__ret < 0) 853 ret = __ret; 854 } 855 856 err: 857 mutex_unlock(&rtd->pcm_mutex); 858 return ret; 859 } 860 861 static int soc_compr_ack(struct snd_compr_stream *cstream, size_t bytes) 862 { 863 struct snd_soc_pcm_runtime *rtd = cstream->private_data; 864 struct snd_soc_platform *platform = rtd->platform; 865 struct snd_soc_component *component; 866 struct snd_soc_rtdcom_list *rtdcom; 867 struct snd_soc_dai *cpu_dai = rtd->cpu_dai; 868 int ret = 0, __ret; 869 870 mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass); 871 872 if (cpu_dai->driver->cops && cpu_dai->driver->cops->ack) { 873 ret = cpu_dai->driver->cops->ack(cstream, bytes, cpu_dai); 874 if (ret < 0) 875 goto err; 876 } 877 878 if (platform && platform->driver->compr_ops && platform->driver->compr_ops->ack) { 879 ret = platform->driver->compr_ops->ack(cstream, bytes); 880 if (ret < 0) 881 goto err; 882 } 883 884 for_each_rtdcom(rtd, rtdcom) { 885 component = rtdcom->component; 886 887 /* ignore duplication for now */ 888 if (platform && (component == &platform->component)) 889 continue; 890 891 if (!component->driver->compr_ops || 892 !component->driver->compr_ops->ack) 893 continue; 894 895 __ret = component->driver->compr_ops->ack(cstream, bytes); 896 if (__ret < 0) 897 ret = __ret; 898 } 899 900 err: 901 mutex_unlock(&rtd->pcm_mutex); 902 return ret; 903 } 904 905 static int soc_compr_pointer(struct snd_compr_stream *cstream, 906 struct snd_compr_tstamp *tstamp) 907 { 908 struct snd_soc_pcm_runtime *rtd = cstream->private_data; 909 struct snd_soc_platform *platform = rtd->platform; 910 struct snd_soc_component *component; 911 struct snd_soc_rtdcom_list *rtdcom; 912 int ret = 0, __ret; 913 struct snd_soc_dai *cpu_dai = rtd->cpu_dai; 914 915 mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass); 916 917 if (cpu_dai->driver->cops && cpu_dai->driver->cops->pointer) 918 cpu_dai->driver->cops->pointer(cstream, tstamp, cpu_dai); 919 920 if (platform && platform->driver->compr_ops && platform->driver->compr_ops->pointer) { 921 ret = platform->driver->compr_ops->pointer(cstream, tstamp); 922 if (ret < 0) 923 goto err; 924 } 925 926 for_each_rtdcom(rtd, rtdcom) { 927 component = rtdcom->component; 928 929 /* ignore duplication for now */ 930 if (platform && (component == &platform->component)) 931 continue; 932 933 if (!component->driver->compr_ops || 934 !component->driver->compr_ops->pointer) 935 continue; 936 937 __ret = component->driver->compr_ops->pointer(cstream, tstamp); 938 if (__ret < 0) 939 ret = __ret; 940 } 941 942 err: 943 mutex_unlock(&rtd->pcm_mutex); 944 return ret; 945 } 946 947 static int soc_compr_copy(struct snd_compr_stream *cstream, 948 char __user *buf, size_t count) 949 { 950 struct snd_soc_pcm_runtime *rtd = cstream->private_data; 951 struct snd_soc_platform *platform = rtd->platform; 952 struct snd_soc_component *component; 953 struct snd_soc_rtdcom_list *rtdcom; 954 int ret = 0; 955 956 mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass); 957 958 if (platform && platform->driver->compr_ops && platform->driver->compr_ops->copy) { 959 ret = platform->driver->compr_ops->copy(cstream, buf, count); 960 if (ret < 0) 961 goto err; 962 } 963 964 for_each_rtdcom(rtd, rtdcom) { 965 component = rtdcom->component; 966 967 /* ignore duplication for now */ 968 if (platform && (component == &platform->component)) 969 continue; 970 971 if (!component->driver->compr_ops || 972 !component->driver->compr_ops->copy) 973 continue; 974 975 ret = component->driver->compr_ops->copy(cstream, buf, count); 976 break; 977 } 978 979 err: 980 mutex_unlock(&rtd->pcm_mutex); 981 return ret; 982 } 983 984 static int soc_compr_set_metadata(struct snd_compr_stream *cstream, 985 struct snd_compr_metadata *metadata) 986 { 987 struct snd_soc_pcm_runtime *rtd = cstream->private_data; 988 struct snd_soc_platform *platform = rtd->platform; 989 struct snd_soc_component *component; 990 struct snd_soc_rtdcom_list *rtdcom; 991 struct snd_soc_dai *cpu_dai = rtd->cpu_dai; 992 int ret = 0, __ret; 993 994 if (cpu_dai->driver->cops && cpu_dai->driver->cops->set_metadata) { 995 ret = cpu_dai->driver->cops->set_metadata(cstream, metadata, cpu_dai); 996 if (ret < 0) 997 return ret; 998 } 999 1000 if (platform && platform->driver->compr_ops && platform->driver->compr_ops->set_metadata) { 1001 ret = platform->driver->compr_ops->set_metadata(cstream, metadata); 1002 if (ret < 0) 1003 return ret; 1004 } 1005 1006 for_each_rtdcom(rtd, rtdcom) { 1007 component = rtdcom->component; 1008 1009 /* ignore duplication for now */ 1010 if (platform && (component == &platform->component)) 1011 continue; 1012 1013 if (!component->driver->compr_ops || 1014 !component->driver->compr_ops->set_metadata) 1015 continue; 1016 1017 __ret = component->driver->compr_ops->set_metadata(cstream, metadata); 1018 if (__ret < 0) 1019 ret = __ret; 1020 } 1021 1022 return ret; 1023 } 1024 1025 static int soc_compr_get_metadata(struct snd_compr_stream *cstream, 1026 struct snd_compr_metadata *metadata) 1027 { 1028 struct snd_soc_pcm_runtime *rtd = cstream->private_data; 1029 struct snd_soc_platform *platform = rtd->platform; 1030 struct snd_soc_component *component; 1031 struct snd_soc_rtdcom_list *rtdcom; 1032 struct snd_soc_dai *cpu_dai = rtd->cpu_dai; 1033 int ret = 0, __ret; 1034 1035 if (cpu_dai->driver->cops && cpu_dai->driver->cops->get_metadata) { 1036 ret = cpu_dai->driver->cops->get_metadata(cstream, metadata, cpu_dai); 1037 if (ret < 0) 1038 return ret; 1039 } 1040 1041 if (platform && platform->driver->compr_ops && platform->driver->compr_ops->get_metadata) { 1042 ret = platform->driver->compr_ops->get_metadata(cstream, metadata); 1043 if (ret < 0) 1044 return ret; 1045 } 1046 1047 for_each_rtdcom(rtd, rtdcom) { 1048 component = rtdcom->component; 1049 1050 /* ignore duplication for now */ 1051 if (platform && (component == &platform->component)) 1052 continue; 1053 1054 if (!component->driver->compr_ops || 1055 !component->driver->compr_ops->get_metadata) 1056 continue; 1057 1058 __ret = component->driver->compr_ops->get_metadata(cstream, metadata); 1059 if (__ret < 0) 1060 ret = __ret; 1061 } 1062 1063 return ret; 1064 } 1065 1066 /* ASoC Compress operations */ 1067 static struct snd_compr_ops soc_compr_ops = { 1068 .open = soc_compr_open, 1069 .free = soc_compr_free, 1070 .set_params = soc_compr_set_params, 1071 .set_metadata = soc_compr_set_metadata, 1072 .get_metadata = soc_compr_get_metadata, 1073 .get_params = soc_compr_get_params, 1074 .trigger = soc_compr_trigger, 1075 .pointer = soc_compr_pointer, 1076 .ack = soc_compr_ack, 1077 .get_caps = soc_compr_get_caps, 1078 .get_codec_caps = soc_compr_get_codec_caps 1079 }; 1080 1081 /* ASoC Dynamic Compress operations */ 1082 static struct snd_compr_ops soc_compr_dyn_ops = { 1083 .open = soc_compr_open_fe, 1084 .free = soc_compr_free_fe, 1085 .set_params = soc_compr_set_params_fe, 1086 .get_params = soc_compr_get_params, 1087 .set_metadata = soc_compr_set_metadata, 1088 .get_metadata = soc_compr_get_metadata, 1089 .trigger = soc_compr_trigger_fe, 1090 .pointer = soc_compr_pointer, 1091 .ack = soc_compr_ack, 1092 .get_caps = soc_compr_get_caps, 1093 .get_codec_caps = soc_compr_get_codec_caps 1094 }; 1095 1096 /** 1097 * snd_soc_new_compress - create a new compress. 1098 * 1099 * @rtd: The runtime for which we will create compress 1100 * @num: the device index number (zero based - shared with normal PCMs) 1101 * 1102 * Return: 0 for success, else error. 1103 */ 1104 int snd_soc_new_compress(struct snd_soc_pcm_runtime *rtd, int num) 1105 { 1106 struct snd_soc_platform *platform = rtd->platform; 1107 struct snd_soc_component *component; 1108 struct snd_soc_rtdcom_list *rtdcom; 1109 struct snd_soc_dai *codec_dai = rtd->codec_dai; 1110 struct snd_soc_dai *cpu_dai = rtd->cpu_dai; 1111 struct snd_compr *compr; 1112 struct snd_pcm *be_pcm; 1113 char new_name[64]; 1114 int ret = 0, direction = 0; 1115 int playback = 0, capture = 0; 1116 1117 if (rtd->num_codecs > 1) { 1118 dev_err(rtd->card->dev, 1119 "Compress ASoC: Multicodec not supported\n"); 1120 return -EINVAL; 1121 } 1122 1123 /* check client and interface hw capabilities */ 1124 if (codec_dai->driver->playback.channels_min) 1125 playback = 1; 1126 if (codec_dai->driver->capture.channels_min) 1127 capture = 1; 1128 1129 capture = capture && cpu_dai->driver->capture.channels_min; 1130 playback = playback && cpu_dai->driver->playback.channels_min; 1131 1132 /* 1133 * Compress devices are unidirectional so only one of the directions 1134 * should be set, check for that (xor) 1135 */ 1136 if (playback + capture != 1) { 1137 dev_err(rtd->card->dev, 1138 "Compress ASoC: Invalid direction for P %d, C %d\n", 1139 playback, capture); 1140 return -EINVAL; 1141 } 1142 1143 if (playback) 1144 direction = SND_COMPRESS_PLAYBACK; 1145 else 1146 direction = SND_COMPRESS_CAPTURE; 1147 1148 compr = kzalloc(sizeof(*compr), GFP_KERNEL); 1149 if (!compr) 1150 return -ENOMEM; 1151 1152 compr->ops = devm_kzalloc(rtd->card->dev, sizeof(soc_compr_ops), 1153 GFP_KERNEL); 1154 if (!compr->ops) { 1155 ret = -ENOMEM; 1156 goto compr_err; 1157 } 1158 1159 if (rtd->dai_link->dynamic) { 1160 snprintf(new_name, sizeof(new_name), "(%s)", 1161 rtd->dai_link->stream_name); 1162 1163 ret = snd_pcm_new_internal(rtd->card->snd_card, new_name, num, 1164 rtd->dai_link->dpcm_playback, 1165 rtd->dai_link->dpcm_capture, &be_pcm); 1166 if (ret < 0) { 1167 dev_err(rtd->card->dev, 1168 "Compress ASoC: can't create compressed for %s: %d\n", 1169 rtd->dai_link->name, ret); 1170 goto compr_err; 1171 } 1172 1173 rtd->pcm = be_pcm; 1174 rtd->fe_compr = 1; 1175 if (rtd->dai_link->dpcm_playback) 1176 be_pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream->private_data = rtd; 1177 else if (rtd->dai_link->dpcm_capture) 1178 be_pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream->private_data = rtd; 1179 memcpy(compr->ops, &soc_compr_dyn_ops, sizeof(soc_compr_dyn_ops)); 1180 } else { 1181 snprintf(new_name, sizeof(new_name), "%s %s-%d", 1182 rtd->dai_link->stream_name, codec_dai->name, num); 1183 1184 memcpy(compr->ops, &soc_compr_ops, sizeof(soc_compr_ops)); 1185 } 1186 1187 1188 /* Add copy callback for not memory mapped DSPs */ 1189 if (platform && platform->driver->compr_ops && platform->driver->compr_ops->copy) 1190 compr->ops->copy = soc_compr_copy; 1191 1192 for_each_rtdcom(rtd, rtdcom) { 1193 component = rtdcom->component; 1194 1195 /* ignore duplication for now */ 1196 if (platform && (component == &platform->component)) 1197 continue; 1198 1199 if (!component->driver->compr_ops || 1200 !component->driver->compr_ops->copy) 1201 continue; 1202 1203 compr->ops->copy = soc_compr_copy; 1204 } 1205 1206 1207 mutex_init(&compr->lock); 1208 ret = snd_compress_new(rtd->card->snd_card, num, direction, 1209 new_name, compr); 1210 if (ret < 0) { 1211 component = rtd->codec_dai->component; 1212 dev_err(component->dev, 1213 "Compress ASoC: can't create compress for codec %s: %d\n", 1214 component->name, ret); 1215 goto compr_err; 1216 } 1217 1218 /* DAPM dai link stream work */ 1219 INIT_DELAYED_WORK(&rtd->delayed_work, close_delayed_work); 1220 1221 rtd->compr = compr; 1222 compr->private_data = rtd; 1223 1224 dev_info(rtd->card->dev, "Compress ASoC: %s <-> %s mapping ok\n", 1225 codec_dai->name, cpu_dai->name); 1226 return ret; 1227 1228 compr_err: 1229 kfree(compr); 1230 return ret; 1231 } 1232 EXPORT_SYMBOL_GPL(snd_soc_new_compress); 1233