1 // SPDX-License-Identifier: GPL-2.0 2 // 3 // soc-component.c 4 // 5 // Copyright 2009-2011 Wolfson Microelectronics PLC. 6 // Copyright (C) 2019 Renesas Electronics Corp. 7 // 8 // Mark Brown <broonie@opensource.wolfsonmicro.com> 9 // Kuninori Morimoto <kuninori.morimoto.gx@renesas.com> 10 // 11 #include <linux/module.h> 12 #include <linux/pm_runtime.h> 13 #include <sound/soc.h> 14 15 #define soc_component_ret(dai, ret) _soc_component_ret(dai, __func__, ret) 16 static inline int _soc_component_ret(struct snd_soc_component *component, 17 const char *func, int ret) 18 { 19 /* Positive/Zero values are not errors */ 20 if (ret >= 0) 21 return ret; 22 23 /* Negative values might be errors */ 24 switch (ret) { 25 case -EPROBE_DEFER: 26 case -ENOTSUPP: 27 break; 28 default: 29 dev_err(component->dev, 30 "ASoC: error at %s on %s: %d\n", 31 func, component->name, ret); 32 } 33 34 return ret; 35 } 36 37 /* 38 * We might want to check substream by using list. 39 * In such case, we can update these macros. 40 */ 41 #define soc_component_mark_push(component, substream, tgt) ((component)->mark_##tgt = substream) 42 #define soc_component_mark_pop(component, substream, tgt) ((component)->mark_##tgt = NULL) 43 #define soc_component_mark_match(component, substream, tgt) ((component)->mark_##tgt == substream) 44 45 void snd_soc_component_set_aux(struct snd_soc_component *component, 46 struct snd_soc_aux_dev *aux) 47 { 48 component->init = (aux) ? aux->init : NULL; 49 } 50 51 int snd_soc_component_init(struct snd_soc_component *component) 52 { 53 int ret = 0; 54 55 if (component->init) 56 ret = component->init(component); 57 58 return soc_component_ret(component, ret); 59 } 60 61 /** 62 * snd_soc_component_set_sysclk - configure COMPONENT system or master clock. 63 * @component: COMPONENT 64 * @clk_id: DAI specific clock ID 65 * @source: Source for the clock 66 * @freq: new clock frequency in Hz 67 * @dir: new clock direction - input/output. 68 * 69 * Configures the CODEC master (MCLK) or system (SYSCLK) clocking. 70 */ 71 int snd_soc_component_set_sysclk(struct snd_soc_component *component, 72 int clk_id, int source, unsigned int freq, 73 int dir) 74 { 75 int ret = -ENOTSUPP; 76 77 if (component->driver->set_sysclk) 78 ret = component->driver->set_sysclk(component, clk_id, source, 79 freq, dir); 80 81 return soc_component_ret(component, ret); 82 } 83 EXPORT_SYMBOL_GPL(snd_soc_component_set_sysclk); 84 85 /* 86 * snd_soc_component_set_pll - configure component PLL. 87 * @component: COMPONENT 88 * @pll_id: DAI specific PLL ID 89 * @source: DAI specific source for the PLL 90 * @freq_in: PLL input clock frequency in Hz 91 * @freq_out: requested PLL output clock frequency in Hz 92 * 93 * Configures and enables PLL to generate output clock based on input clock. 94 */ 95 int snd_soc_component_set_pll(struct snd_soc_component *component, int pll_id, 96 int source, unsigned int freq_in, 97 unsigned int freq_out) 98 { 99 int ret = -EINVAL; 100 101 if (component->driver->set_pll) 102 ret = component->driver->set_pll(component, pll_id, source, 103 freq_in, freq_out); 104 105 return soc_component_ret(component, ret); 106 } 107 EXPORT_SYMBOL_GPL(snd_soc_component_set_pll); 108 109 void snd_soc_component_seq_notifier(struct snd_soc_component *component, 110 enum snd_soc_dapm_type type, int subseq) 111 { 112 if (component->driver->seq_notifier) 113 component->driver->seq_notifier(component, type, subseq); 114 } 115 116 int snd_soc_component_stream_event(struct snd_soc_component *component, 117 int event) 118 { 119 int ret = 0; 120 121 if (component->driver->stream_event) 122 ret = component->driver->stream_event(component, event); 123 124 return soc_component_ret(component, ret); 125 } 126 127 int snd_soc_component_set_bias_level(struct snd_soc_component *component, 128 enum snd_soc_bias_level level) 129 { 130 int ret = 0; 131 132 if (component->driver->set_bias_level) 133 ret = component->driver->set_bias_level(component, level); 134 135 return soc_component_ret(component, ret); 136 } 137 138 static int soc_component_pin(struct snd_soc_component *component, 139 const char *pin, 140 int (*pin_func)(struct snd_soc_dapm_context *dapm, 141 const char *pin)) 142 { 143 struct snd_soc_dapm_context *dapm = 144 snd_soc_component_get_dapm(component); 145 char *full_name; 146 int ret; 147 148 if (!component->name_prefix) { 149 ret = pin_func(dapm, pin); 150 goto end; 151 } 152 153 full_name = kasprintf(GFP_KERNEL, "%s %s", component->name_prefix, pin); 154 if (!full_name) { 155 ret = -ENOMEM; 156 goto end; 157 } 158 159 ret = pin_func(dapm, full_name); 160 kfree(full_name); 161 end: 162 return soc_component_ret(component, ret); 163 } 164 165 int snd_soc_component_enable_pin(struct snd_soc_component *component, 166 const char *pin) 167 { 168 return soc_component_pin(component, pin, snd_soc_dapm_enable_pin); 169 } 170 EXPORT_SYMBOL_GPL(snd_soc_component_enable_pin); 171 172 int snd_soc_component_enable_pin_unlocked(struct snd_soc_component *component, 173 const char *pin) 174 { 175 return soc_component_pin(component, pin, snd_soc_dapm_enable_pin_unlocked); 176 } 177 EXPORT_SYMBOL_GPL(snd_soc_component_enable_pin_unlocked); 178 179 int snd_soc_component_disable_pin(struct snd_soc_component *component, 180 const char *pin) 181 { 182 return soc_component_pin(component, pin, snd_soc_dapm_disable_pin); 183 } 184 EXPORT_SYMBOL_GPL(snd_soc_component_disable_pin); 185 186 int snd_soc_component_disable_pin_unlocked(struct snd_soc_component *component, 187 const char *pin) 188 { 189 return soc_component_pin(component, pin, snd_soc_dapm_disable_pin_unlocked); 190 } 191 EXPORT_SYMBOL_GPL(snd_soc_component_disable_pin_unlocked); 192 193 int snd_soc_component_nc_pin(struct snd_soc_component *component, 194 const char *pin) 195 { 196 return soc_component_pin(component, pin, snd_soc_dapm_nc_pin); 197 } 198 EXPORT_SYMBOL_GPL(snd_soc_component_nc_pin); 199 200 int snd_soc_component_nc_pin_unlocked(struct snd_soc_component *component, 201 const char *pin) 202 { 203 return soc_component_pin(component, pin, snd_soc_dapm_nc_pin_unlocked); 204 } 205 EXPORT_SYMBOL_GPL(snd_soc_component_nc_pin_unlocked); 206 207 int snd_soc_component_get_pin_status(struct snd_soc_component *component, 208 const char *pin) 209 { 210 return soc_component_pin(component, pin, snd_soc_dapm_get_pin_status); 211 } 212 EXPORT_SYMBOL_GPL(snd_soc_component_get_pin_status); 213 214 int snd_soc_component_force_enable_pin(struct snd_soc_component *component, 215 const char *pin) 216 { 217 return soc_component_pin(component, pin, snd_soc_dapm_force_enable_pin); 218 } 219 EXPORT_SYMBOL_GPL(snd_soc_component_force_enable_pin); 220 221 int snd_soc_component_force_enable_pin_unlocked( 222 struct snd_soc_component *component, 223 const char *pin) 224 { 225 return soc_component_pin(component, pin, snd_soc_dapm_force_enable_pin_unlocked); 226 } 227 EXPORT_SYMBOL_GPL(snd_soc_component_force_enable_pin_unlocked); 228 229 /** 230 * snd_soc_component_set_jack - configure component jack. 231 * @component: COMPONENTs 232 * @jack: structure to use for the jack 233 * @data: can be used if codec driver need extra data for configuring jack 234 * 235 * Configures and enables jack detection function. 236 */ 237 int snd_soc_component_set_jack(struct snd_soc_component *component, 238 struct snd_soc_jack *jack, void *data) 239 { 240 int ret = -ENOTSUPP; 241 242 if (component->driver->set_jack) 243 ret = component->driver->set_jack(component, jack, data); 244 245 return soc_component_ret(component, ret); 246 } 247 EXPORT_SYMBOL_GPL(snd_soc_component_set_jack); 248 249 int snd_soc_component_module_get(struct snd_soc_component *component, 250 struct snd_pcm_substream *substream, 251 int upon_open) 252 { 253 int ret = 0; 254 255 if (component->driver->module_get_upon_open == !!upon_open && 256 !try_module_get(component->dev->driver->owner)) 257 ret = -ENODEV; 258 259 /* mark substream if succeeded */ 260 if (ret == 0) 261 soc_component_mark_push(component, substream, module); 262 263 return soc_component_ret(component, ret); 264 } 265 266 void snd_soc_component_module_put(struct snd_soc_component *component, 267 struct snd_pcm_substream *substream, 268 int upon_open, int rollback) 269 { 270 if (rollback && !soc_component_mark_match(component, substream, module)) 271 return; 272 273 if (component->driver->module_get_upon_open == !!upon_open) 274 module_put(component->dev->driver->owner); 275 276 /* remove marked substream */ 277 soc_component_mark_pop(component, substream, module); 278 } 279 280 int snd_soc_component_open(struct snd_soc_component *component, 281 struct snd_pcm_substream *substream) 282 { 283 int ret = 0; 284 285 if (component->driver->open) 286 ret = component->driver->open(component, substream); 287 288 /* mark substream if succeeded */ 289 if (ret == 0) 290 soc_component_mark_push(component, substream, open); 291 292 return soc_component_ret(component, ret); 293 } 294 295 int snd_soc_component_close(struct snd_soc_component *component, 296 struct snd_pcm_substream *substream, 297 int rollback) 298 { 299 int ret = 0; 300 301 if (rollback && !soc_component_mark_match(component, substream, open)) 302 return 0; 303 304 if (component->driver->close) 305 ret = component->driver->close(component, substream); 306 307 /* remove marked substream */ 308 soc_component_mark_pop(component, substream, open); 309 310 return soc_component_ret(component, ret); 311 } 312 313 void snd_soc_component_suspend(struct snd_soc_component *component) 314 { 315 if (component->driver->suspend) 316 component->driver->suspend(component); 317 component->suspended = 1; 318 } 319 320 void snd_soc_component_resume(struct snd_soc_component *component) 321 { 322 if (component->driver->resume) 323 component->driver->resume(component); 324 component->suspended = 0; 325 } 326 327 int snd_soc_component_is_suspended(struct snd_soc_component *component) 328 { 329 return component->suspended; 330 } 331 332 int snd_soc_component_probe(struct snd_soc_component *component) 333 { 334 int ret = 0; 335 336 if (component->driver->probe) 337 ret = component->driver->probe(component); 338 339 return soc_component_ret(component, ret); 340 } 341 342 void snd_soc_component_remove(struct snd_soc_component *component) 343 { 344 if (component->driver->remove) 345 component->driver->remove(component); 346 } 347 348 int snd_soc_component_of_xlate_dai_id(struct snd_soc_component *component, 349 struct device_node *ep) 350 { 351 int ret = -ENOTSUPP; 352 353 if (component->driver->of_xlate_dai_id) 354 ret = component->driver->of_xlate_dai_id(component, ep); 355 356 return soc_component_ret(component, ret); 357 } 358 359 int snd_soc_component_of_xlate_dai_name(struct snd_soc_component *component, 360 struct of_phandle_args *args, 361 const char **dai_name) 362 { 363 if (component->driver->of_xlate_dai_name) 364 return component->driver->of_xlate_dai_name(component, 365 args, dai_name); 366 /* 367 * Don't use soc_component_ret here because we may not want to report 368 * the error just yet. If a device has more than one component, the 369 * first may not match and we don't want spam the log with this. 370 */ 371 return -ENOTSUPP; 372 } 373 374 void snd_soc_component_setup_regmap(struct snd_soc_component *component) 375 { 376 int val_bytes = regmap_get_val_bytes(component->regmap); 377 378 /* Errors are legitimate for non-integer byte multiples */ 379 if (val_bytes > 0) 380 component->val_bytes = val_bytes; 381 } 382 383 #ifdef CONFIG_REGMAP 384 385 /** 386 * snd_soc_component_init_regmap() - Initialize regmap instance for the 387 * component 388 * @component: The component for which to initialize the regmap instance 389 * @regmap: The regmap instance that should be used by the component 390 * 391 * This function allows deferred assignment of the regmap instance that is 392 * associated with the component. Only use this if the regmap instance is not 393 * yet ready when the component is registered. The function must also be called 394 * before the first IO attempt of the component. 395 */ 396 void snd_soc_component_init_regmap(struct snd_soc_component *component, 397 struct regmap *regmap) 398 { 399 component->regmap = regmap; 400 snd_soc_component_setup_regmap(component); 401 } 402 EXPORT_SYMBOL_GPL(snd_soc_component_init_regmap); 403 404 /** 405 * snd_soc_component_exit_regmap() - De-initialize regmap instance for the 406 * component 407 * @component: The component for which to de-initialize the regmap instance 408 * 409 * Calls regmap_exit() on the regmap instance associated to the component and 410 * removes the regmap instance from the component. 411 * 412 * This function should only be used if snd_soc_component_init_regmap() was used 413 * to initialize the regmap instance. 414 */ 415 void snd_soc_component_exit_regmap(struct snd_soc_component *component) 416 { 417 regmap_exit(component->regmap); 418 component->regmap = NULL; 419 } 420 EXPORT_SYMBOL_GPL(snd_soc_component_exit_regmap); 421 422 #endif 423 424 static unsigned int soc_component_read_no_lock( 425 struct snd_soc_component *component, 426 unsigned int reg) 427 { 428 int ret; 429 unsigned int val = 0; 430 431 if (component->regmap) 432 ret = regmap_read(component->regmap, reg, &val); 433 else if (component->driver->read) { 434 ret = 0; 435 val = component->driver->read(component, reg); 436 } 437 else 438 ret = -EIO; 439 440 if (ret < 0) 441 return soc_component_ret(component, ret); 442 443 return val; 444 } 445 446 /** 447 * snd_soc_component_read() - Read register value 448 * @component: Component to read from 449 * @reg: Register to read 450 * 451 * Return: read value 452 */ 453 unsigned int snd_soc_component_read(struct snd_soc_component *component, 454 unsigned int reg) 455 { 456 unsigned int val; 457 458 mutex_lock(&component->io_mutex); 459 val = soc_component_read_no_lock(component, reg); 460 mutex_unlock(&component->io_mutex); 461 462 return val; 463 } 464 EXPORT_SYMBOL_GPL(snd_soc_component_read); 465 466 static int soc_component_write_no_lock( 467 struct snd_soc_component *component, 468 unsigned int reg, unsigned int val) 469 { 470 int ret = -EIO; 471 472 if (component->regmap) 473 ret = regmap_write(component->regmap, reg, val); 474 else if (component->driver->write) 475 ret = component->driver->write(component, reg, val); 476 477 return soc_component_ret(component, ret); 478 } 479 480 /** 481 * snd_soc_component_write() - Write register value 482 * @component: Component to write to 483 * @reg: Register to write 484 * @val: Value to write to the register 485 * 486 * Return: 0 on success, a negative error code otherwise. 487 */ 488 int snd_soc_component_write(struct snd_soc_component *component, 489 unsigned int reg, unsigned int val) 490 { 491 int ret; 492 493 mutex_lock(&component->io_mutex); 494 ret = soc_component_write_no_lock(component, reg, val); 495 mutex_unlock(&component->io_mutex); 496 497 return ret; 498 } 499 EXPORT_SYMBOL_GPL(snd_soc_component_write); 500 501 static int snd_soc_component_update_bits_legacy( 502 struct snd_soc_component *component, unsigned int reg, 503 unsigned int mask, unsigned int val, bool *change) 504 { 505 unsigned int old, new; 506 int ret = 0; 507 508 mutex_lock(&component->io_mutex); 509 510 old = soc_component_read_no_lock(component, reg); 511 512 new = (old & ~mask) | (val & mask); 513 *change = old != new; 514 if (*change) 515 ret = soc_component_write_no_lock(component, reg, new); 516 517 mutex_unlock(&component->io_mutex); 518 519 return soc_component_ret(component, ret); 520 } 521 522 /** 523 * snd_soc_component_update_bits() - Perform read/modify/write cycle 524 * @component: Component to update 525 * @reg: Register to update 526 * @mask: Mask that specifies which bits to update 527 * @val: New value for the bits specified by mask 528 * 529 * Return: 1 if the operation was successful and the value of the register 530 * changed, 0 if the operation was successful, but the value did not change. 531 * Returns a negative error code otherwise. 532 */ 533 int snd_soc_component_update_bits(struct snd_soc_component *component, 534 unsigned int reg, unsigned int mask, unsigned int val) 535 { 536 bool change; 537 int ret; 538 539 if (component->regmap) 540 ret = regmap_update_bits_check(component->regmap, reg, mask, 541 val, &change); 542 else 543 ret = snd_soc_component_update_bits_legacy(component, reg, 544 mask, val, &change); 545 546 if (ret < 0) 547 return soc_component_ret(component, ret); 548 return change; 549 } 550 EXPORT_SYMBOL_GPL(snd_soc_component_update_bits); 551 552 /** 553 * snd_soc_component_update_bits_async() - Perform asynchronous 554 * read/modify/write cycle 555 * @component: Component to update 556 * @reg: Register to update 557 * @mask: Mask that specifies which bits to update 558 * @val: New value for the bits specified by mask 559 * 560 * This function is similar to snd_soc_component_update_bits(), but the update 561 * operation is scheduled asynchronously. This means it may not be completed 562 * when the function returns. To make sure that all scheduled updates have been 563 * completed snd_soc_component_async_complete() must be called. 564 * 565 * Return: 1 if the operation was successful and the value of the register 566 * changed, 0 if the operation was successful, but the value did not change. 567 * Returns a negative error code otherwise. 568 */ 569 int snd_soc_component_update_bits_async(struct snd_soc_component *component, 570 unsigned int reg, unsigned int mask, unsigned int val) 571 { 572 bool change; 573 int ret; 574 575 if (component->regmap) 576 ret = regmap_update_bits_check_async(component->regmap, reg, 577 mask, val, &change); 578 else 579 ret = snd_soc_component_update_bits_legacy(component, reg, 580 mask, val, &change); 581 582 if (ret < 0) 583 return soc_component_ret(component, ret); 584 return change; 585 } 586 EXPORT_SYMBOL_GPL(snd_soc_component_update_bits_async); 587 588 /** 589 * snd_soc_component_async_complete() - Ensure asynchronous I/O has completed 590 * @component: Component for which to wait 591 * 592 * This function blocks until all asynchronous I/O which has previously been 593 * scheduled using snd_soc_component_update_bits_async() has completed. 594 */ 595 void snd_soc_component_async_complete(struct snd_soc_component *component) 596 { 597 if (component->regmap) 598 regmap_async_complete(component->regmap); 599 } 600 EXPORT_SYMBOL_GPL(snd_soc_component_async_complete); 601 602 /** 603 * snd_soc_component_test_bits - Test register for change 604 * @component: component 605 * @reg: Register to test 606 * @mask: Mask that specifies which bits to test 607 * @value: Value to test against 608 * 609 * Tests a register with a new value and checks if the new value is 610 * different from the old value. 611 * 612 * Return: 1 for change, otherwise 0. 613 */ 614 int snd_soc_component_test_bits(struct snd_soc_component *component, 615 unsigned int reg, unsigned int mask, unsigned int value) 616 { 617 unsigned int old, new; 618 619 old = snd_soc_component_read(component, reg); 620 new = (old & ~mask) | value; 621 return old != new; 622 } 623 EXPORT_SYMBOL_GPL(snd_soc_component_test_bits); 624 625 int snd_soc_pcm_component_pointer(struct snd_pcm_substream *substream) 626 { 627 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream); 628 struct snd_soc_component *component; 629 int i; 630 631 /* FIXME: use 1st pointer */ 632 for_each_rtd_components(rtd, i, component) 633 if (component->driver->pointer) 634 return component->driver->pointer(component, substream); 635 636 return 0; 637 } 638 639 int snd_soc_pcm_component_ioctl(struct snd_pcm_substream *substream, 640 unsigned int cmd, void *arg) 641 { 642 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream); 643 struct snd_soc_component *component; 644 int i; 645 646 /* FIXME: use 1st ioctl */ 647 for_each_rtd_components(rtd, i, component) 648 if (component->driver->ioctl) 649 return soc_component_ret( 650 component, 651 component->driver->ioctl(component, 652 substream, cmd, arg)); 653 654 return snd_pcm_lib_ioctl(substream, cmd, arg); 655 } 656 657 int snd_soc_pcm_component_sync_stop(struct snd_pcm_substream *substream) 658 { 659 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream); 660 struct snd_soc_component *component; 661 int i, ret; 662 663 for_each_rtd_components(rtd, i, component) { 664 if (component->driver->sync_stop) { 665 ret = component->driver->sync_stop(component, 666 substream); 667 if (ret < 0) 668 return soc_component_ret(component, ret); 669 } 670 } 671 672 return 0; 673 } 674 675 int snd_soc_pcm_component_copy_user(struct snd_pcm_substream *substream, 676 int channel, unsigned long pos, 677 void __user *buf, unsigned long bytes) 678 { 679 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream); 680 struct snd_soc_component *component; 681 int i; 682 683 /* FIXME. it returns 1st copy now */ 684 for_each_rtd_components(rtd, i, component) 685 if (component->driver->copy_user) 686 return soc_component_ret( 687 component, 688 component->driver->copy_user( 689 component, substream, channel, 690 pos, buf, bytes)); 691 692 return -EINVAL; 693 } 694 695 struct page *snd_soc_pcm_component_page(struct snd_pcm_substream *substream, 696 unsigned long offset) 697 { 698 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream); 699 struct snd_soc_component *component; 700 struct page *page; 701 int i; 702 703 /* FIXME. it returns 1st page now */ 704 for_each_rtd_components(rtd, i, component) { 705 if (component->driver->page) { 706 page = component->driver->page(component, 707 substream, offset); 708 if (page) 709 return page; 710 } 711 } 712 713 return NULL; 714 } 715 716 int snd_soc_pcm_component_mmap(struct snd_pcm_substream *substream, 717 struct vm_area_struct *vma) 718 { 719 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream); 720 struct snd_soc_component *component; 721 int i; 722 723 /* FIXME. it returns 1st mmap now */ 724 for_each_rtd_components(rtd, i, component) 725 if (component->driver->mmap) 726 return soc_component_ret( 727 component, 728 component->driver->mmap(component, 729 substream, vma)); 730 731 return -EINVAL; 732 } 733 734 int snd_soc_pcm_component_new(struct snd_soc_pcm_runtime *rtd) 735 { 736 struct snd_soc_component *component; 737 int ret; 738 int i; 739 740 for_each_rtd_components(rtd, i, component) { 741 if (component->driver->pcm_construct) { 742 ret = component->driver->pcm_construct(component, rtd); 743 if (ret < 0) 744 return soc_component_ret(component, ret); 745 } 746 } 747 748 return 0; 749 } 750 751 void snd_soc_pcm_component_free(struct snd_soc_pcm_runtime *rtd) 752 { 753 struct snd_soc_component *component; 754 int i; 755 756 if (!rtd->pcm) 757 return; 758 759 for_each_rtd_components(rtd, i, component) 760 if (component->driver->pcm_destruct) 761 component->driver->pcm_destruct(component, rtd->pcm); 762 } 763 764 int snd_soc_pcm_component_prepare(struct snd_pcm_substream *substream) 765 { 766 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream); 767 struct snd_soc_component *component; 768 int i, ret; 769 770 for_each_rtd_components(rtd, i, component) { 771 if (component->driver->prepare) { 772 ret = component->driver->prepare(component, substream); 773 if (ret < 0) 774 return soc_component_ret(component, ret); 775 } 776 } 777 778 return 0; 779 } 780 781 int snd_soc_pcm_component_hw_params(struct snd_pcm_substream *substream, 782 struct snd_pcm_hw_params *params, 783 struct snd_soc_component **last) 784 { 785 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream); 786 struct snd_soc_component *component; 787 int i, ret; 788 789 for_each_rtd_components(rtd, i, component) { 790 if (component->driver->hw_params) { 791 ret = component->driver->hw_params(component, 792 substream, params); 793 if (ret < 0) { 794 *last = component; 795 return soc_component_ret(component, ret); 796 } 797 } 798 } 799 800 *last = NULL; 801 return 0; 802 } 803 804 void snd_soc_pcm_component_hw_free(struct snd_pcm_substream *substream, 805 struct snd_soc_component *last) 806 { 807 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream); 808 struct snd_soc_component *component; 809 int i, ret; 810 811 for_each_rtd_components(rtd, i, component) { 812 if (component == last) 813 break; 814 815 if (component->driver->hw_free) { 816 ret = component->driver->hw_free(component, substream); 817 if (ret < 0) 818 soc_component_ret(component, ret); 819 } 820 } 821 } 822 823 int snd_soc_pcm_component_trigger(struct snd_pcm_substream *substream, 824 int cmd) 825 { 826 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream); 827 struct snd_soc_component *component; 828 int i, ret; 829 830 for_each_rtd_components(rtd, i, component) { 831 if (component->driver->trigger) { 832 ret = component->driver->trigger(component, substream, cmd); 833 if (ret < 0) 834 return soc_component_ret(component, ret); 835 } 836 } 837 838 return 0; 839 } 840 841 int snd_soc_pcm_component_pm_runtime_get(struct snd_soc_pcm_runtime *rtd, 842 void *stream) 843 { 844 struct snd_soc_component *component; 845 int i, ret; 846 847 for_each_rtd_components(rtd, i, component) { 848 ret = pm_runtime_get_sync(component->dev); 849 if (ret < 0 && ret != -EACCES) { 850 pm_runtime_put_noidle(component->dev); 851 return soc_component_ret(component, ret); 852 } 853 /* mark stream if succeeded */ 854 soc_component_mark_push(component, stream, pm); 855 } 856 857 return 0; 858 } 859 860 void snd_soc_pcm_component_pm_runtime_put(struct snd_soc_pcm_runtime *rtd, 861 void *stream, int rollback) 862 { 863 struct snd_soc_component *component; 864 int i; 865 866 for_each_rtd_components(rtd, i, component) { 867 if (rollback && !soc_component_mark_match(component, stream, pm)) 868 continue; 869 870 pm_runtime_mark_last_busy(component->dev); 871 pm_runtime_put_autosuspend(component->dev); 872 873 /* remove marked stream */ 874 soc_component_mark_pop(component, stream, pm); 875 } 876 } 877