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