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 int snd_soc_component_compr_open(struct snd_compr_stream *cstream, 425 struct snd_soc_component **last) 426 { 427 struct snd_soc_pcm_runtime *rtd = cstream->private_data; 428 struct snd_soc_component *component; 429 int i, ret; 430 431 for_each_rtd_components(rtd, i, component) { 432 if (component->driver->compress_ops && 433 component->driver->compress_ops->open) { 434 ret = component->driver->compress_ops->open(component, cstream); 435 if (ret < 0) { 436 *last = component; 437 return soc_component_ret(component, ret); 438 } 439 } 440 } 441 442 *last = NULL; 443 return 0; 444 } 445 EXPORT_SYMBOL_GPL(snd_soc_component_compr_open); 446 447 void snd_soc_component_compr_free(struct snd_compr_stream *cstream, 448 struct snd_soc_component *last) 449 { 450 struct snd_soc_pcm_runtime *rtd = cstream->private_data; 451 struct snd_soc_component *component; 452 int i; 453 454 for_each_rtd_components(rtd, i, component) { 455 if (component == last) 456 break; 457 458 if (component->driver->compress_ops && 459 component->driver->compress_ops->free) 460 component->driver->compress_ops->free(component, cstream); 461 } 462 } 463 EXPORT_SYMBOL_GPL(snd_soc_component_compr_free); 464 465 int snd_soc_component_compr_trigger(struct snd_compr_stream *cstream, int cmd) 466 { 467 struct snd_soc_pcm_runtime *rtd = cstream->private_data; 468 struct snd_soc_component *component; 469 int i, ret; 470 471 for_each_rtd_components(rtd, i, component) { 472 if (component->driver->compress_ops && 473 component->driver->compress_ops->trigger) { 474 ret = component->driver->compress_ops->trigger( 475 component, cstream, cmd); 476 if (ret < 0) 477 return soc_component_ret(component, ret); 478 } 479 } 480 481 return 0; 482 } 483 EXPORT_SYMBOL_GPL(snd_soc_component_compr_trigger); 484 485 int snd_soc_component_compr_set_params(struct snd_compr_stream *cstream, 486 struct snd_compr_params *params) 487 { 488 struct snd_soc_pcm_runtime *rtd = cstream->private_data; 489 struct snd_soc_component *component; 490 int i, ret; 491 492 for_each_rtd_components(rtd, i, component) { 493 if (component->driver->compress_ops && 494 component->driver->compress_ops->set_params) { 495 ret = component->driver->compress_ops->set_params( 496 component, cstream, params); 497 if (ret < 0) 498 return soc_component_ret(component, ret); 499 } 500 } 501 502 return 0; 503 } 504 EXPORT_SYMBOL_GPL(snd_soc_component_compr_set_params); 505 506 int snd_soc_component_compr_get_params(struct snd_compr_stream *cstream, 507 struct snd_codec *params) 508 { 509 struct snd_soc_pcm_runtime *rtd = cstream->private_data; 510 struct snd_soc_component *component; 511 int i, ret; 512 513 for_each_rtd_components(rtd, i, component) { 514 if (component->driver->compress_ops && 515 component->driver->compress_ops->get_params) { 516 ret = component->driver->compress_ops->get_params( 517 component, cstream, params); 518 return soc_component_ret(component, ret); 519 } 520 } 521 522 return 0; 523 } 524 EXPORT_SYMBOL_GPL(snd_soc_component_compr_get_params); 525 526 int snd_soc_component_compr_get_caps(struct snd_compr_stream *cstream, 527 struct snd_compr_caps *caps) 528 { 529 struct snd_soc_pcm_runtime *rtd = cstream->private_data; 530 struct snd_soc_component *component; 531 int i, ret = 0; 532 533 mutex_lock_nested(&rtd->card->pcm_mutex, rtd->card->pcm_subclass); 534 535 for_each_rtd_components(rtd, i, component) { 536 if (component->driver->compress_ops && 537 component->driver->compress_ops->get_caps) { 538 ret = component->driver->compress_ops->get_caps( 539 component, cstream, caps); 540 break; 541 } 542 } 543 544 mutex_unlock(&rtd->card->pcm_mutex); 545 546 return soc_component_ret(component, ret); 547 } 548 EXPORT_SYMBOL_GPL(snd_soc_component_compr_get_caps); 549 550 int snd_soc_component_compr_get_codec_caps(struct snd_compr_stream *cstream, 551 struct snd_compr_codec_caps *codec) 552 { 553 struct snd_soc_pcm_runtime *rtd = cstream->private_data; 554 struct snd_soc_component *component; 555 int i, ret = 0; 556 557 mutex_lock_nested(&rtd->card->pcm_mutex, rtd->card->pcm_subclass); 558 559 for_each_rtd_components(rtd, i, component) { 560 if (component->driver->compress_ops && 561 component->driver->compress_ops->get_codec_caps) { 562 ret = component->driver->compress_ops->get_codec_caps( 563 component, cstream, codec); 564 break; 565 } 566 } 567 568 mutex_unlock(&rtd->card->pcm_mutex); 569 570 return soc_component_ret(component, ret); 571 } 572 EXPORT_SYMBOL_GPL(snd_soc_component_compr_get_codec_caps); 573 574 int snd_soc_component_compr_ack(struct snd_compr_stream *cstream, size_t bytes) 575 { 576 struct snd_soc_pcm_runtime *rtd = cstream->private_data; 577 struct snd_soc_component *component; 578 int i, ret; 579 580 for_each_rtd_components(rtd, i, component) { 581 if (component->driver->compress_ops && 582 component->driver->compress_ops->ack) { 583 ret = component->driver->compress_ops->ack( 584 component, cstream, bytes); 585 if (ret < 0) 586 return soc_component_ret(component, ret); 587 } 588 } 589 590 return 0; 591 } 592 EXPORT_SYMBOL_GPL(snd_soc_component_compr_ack); 593 594 int snd_soc_component_compr_pointer(struct snd_compr_stream *cstream, 595 struct snd_compr_tstamp *tstamp) 596 { 597 struct snd_soc_pcm_runtime *rtd = cstream->private_data; 598 struct snd_soc_component *component; 599 int i, ret; 600 601 for_each_rtd_components(rtd, i, component) { 602 if (component->driver->compress_ops && 603 component->driver->compress_ops->pointer) { 604 ret = component->driver->compress_ops->pointer( 605 component, cstream, tstamp); 606 return soc_component_ret(component, ret); 607 } 608 } 609 610 return 0; 611 } 612 EXPORT_SYMBOL_GPL(snd_soc_component_compr_pointer); 613 614 int snd_soc_component_compr_copy(struct snd_compr_stream *cstream, 615 char __user *buf, size_t count) 616 { 617 struct snd_soc_pcm_runtime *rtd = cstream->private_data; 618 struct snd_soc_component *component; 619 int i, ret = 0; 620 621 mutex_lock_nested(&rtd->card->pcm_mutex, rtd->card->pcm_subclass); 622 623 for_each_rtd_components(rtd, i, component) { 624 if (component->driver->compress_ops && 625 component->driver->compress_ops->copy) { 626 ret = component->driver->compress_ops->copy( 627 component, cstream, buf, count); 628 break; 629 } 630 } 631 632 mutex_unlock(&rtd->card->pcm_mutex); 633 634 return soc_component_ret(component, ret); 635 } 636 EXPORT_SYMBOL_GPL(snd_soc_component_compr_copy); 637 638 static unsigned int soc_component_read_no_lock( 639 struct snd_soc_component *component, 640 unsigned int reg) 641 { 642 int ret; 643 unsigned int val = 0; 644 645 if (component->regmap) 646 ret = regmap_read(component->regmap, reg, &val); 647 else if (component->driver->read) { 648 ret = 0; 649 val = component->driver->read(component, reg); 650 } 651 else 652 ret = -EIO; 653 654 if (ret < 0) 655 return soc_component_ret(component, ret); 656 657 return val; 658 } 659 660 /** 661 * snd_soc_component_read() - Read register value 662 * @component: Component to read from 663 * @reg: Register to read 664 * 665 * Return: read value 666 */ 667 unsigned int snd_soc_component_read(struct snd_soc_component *component, 668 unsigned int reg) 669 { 670 unsigned int val; 671 672 mutex_lock(&component->io_mutex); 673 val = soc_component_read_no_lock(component, reg); 674 mutex_unlock(&component->io_mutex); 675 676 return val; 677 } 678 EXPORT_SYMBOL_GPL(snd_soc_component_read); 679 680 static int soc_component_write_no_lock( 681 struct snd_soc_component *component, 682 unsigned int reg, unsigned int val) 683 { 684 int ret = -EIO; 685 686 if (component->regmap) 687 ret = regmap_write(component->regmap, reg, val); 688 else if (component->driver->write) 689 ret = component->driver->write(component, reg, val); 690 691 return soc_component_ret(component, ret); 692 } 693 694 /** 695 * snd_soc_component_write() - Write register value 696 * @component: Component to write to 697 * @reg: Register to write 698 * @val: Value to write to the register 699 * 700 * Return: 0 on success, a negative error code otherwise. 701 */ 702 int snd_soc_component_write(struct snd_soc_component *component, 703 unsigned int reg, unsigned int val) 704 { 705 int ret; 706 707 mutex_lock(&component->io_mutex); 708 ret = soc_component_write_no_lock(component, reg, val); 709 mutex_unlock(&component->io_mutex); 710 711 return ret; 712 } 713 EXPORT_SYMBOL_GPL(snd_soc_component_write); 714 715 static int snd_soc_component_update_bits_legacy( 716 struct snd_soc_component *component, unsigned int reg, 717 unsigned int mask, unsigned int val, bool *change) 718 { 719 unsigned int old, new; 720 int ret = 0; 721 722 mutex_lock(&component->io_mutex); 723 724 old = soc_component_read_no_lock(component, reg); 725 726 new = (old & ~mask) | (val & mask); 727 *change = old != new; 728 if (*change) 729 ret = soc_component_write_no_lock(component, reg, new); 730 731 mutex_unlock(&component->io_mutex); 732 733 return soc_component_ret(component, ret); 734 } 735 736 /** 737 * snd_soc_component_update_bits() - Perform read/modify/write cycle 738 * @component: Component to update 739 * @reg: Register to update 740 * @mask: Mask that specifies which bits to update 741 * @val: New value for the bits specified by mask 742 * 743 * Return: 1 if the operation was successful and the value of the register 744 * changed, 0 if the operation was successful, but the value did not change. 745 * Returns a negative error code otherwise. 746 */ 747 int snd_soc_component_update_bits(struct snd_soc_component *component, 748 unsigned int reg, unsigned int mask, unsigned int val) 749 { 750 bool change; 751 int ret; 752 753 if (component->regmap) 754 ret = regmap_update_bits_check(component->regmap, reg, mask, 755 val, &change); 756 else 757 ret = snd_soc_component_update_bits_legacy(component, reg, 758 mask, val, &change); 759 760 if (ret < 0) 761 return soc_component_ret(component, ret); 762 return change; 763 } 764 EXPORT_SYMBOL_GPL(snd_soc_component_update_bits); 765 766 /** 767 * snd_soc_component_update_bits_async() - Perform asynchronous 768 * read/modify/write cycle 769 * @component: Component to update 770 * @reg: Register to update 771 * @mask: Mask that specifies which bits to update 772 * @val: New value for the bits specified by mask 773 * 774 * This function is similar to snd_soc_component_update_bits(), but the update 775 * operation is scheduled asynchronously. This means it may not be completed 776 * when the function returns. To make sure that all scheduled updates have been 777 * completed snd_soc_component_async_complete() must be called. 778 * 779 * Return: 1 if the operation was successful and the value of the register 780 * changed, 0 if the operation was successful, but the value did not change. 781 * Returns a negative error code otherwise. 782 */ 783 int snd_soc_component_update_bits_async(struct snd_soc_component *component, 784 unsigned int reg, unsigned int mask, unsigned int val) 785 { 786 bool change; 787 int ret; 788 789 if (component->regmap) 790 ret = regmap_update_bits_check_async(component->regmap, reg, 791 mask, val, &change); 792 else 793 ret = snd_soc_component_update_bits_legacy(component, reg, 794 mask, val, &change); 795 796 if (ret < 0) 797 return soc_component_ret(component, ret); 798 return change; 799 } 800 EXPORT_SYMBOL_GPL(snd_soc_component_update_bits_async); 801 802 /** 803 * snd_soc_component_async_complete() - Ensure asynchronous I/O has completed 804 * @component: Component for which to wait 805 * 806 * This function blocks until all asynchronous I/O which has previously been 807 * scheduled using snd_soc_component_update_bits_async() has completed. 808 */ 809 void snd_soc_component_async_complete(struct snd_soc_component *component) 810 { 811 if (component->regmap) 812 regmap_async_complete(component->regmap); 813 } 814 EXPORT_SYMBOL_GPL(snd_soc_component_async_complete); 815 816 /** 817 * snd_soc_component_test_bits - Test register for change 818 * @component: component 819 * @reg: Register to test 820 * @mask: Mask that specifies which bits to test 821 * @value: Value to test against 822 * 823 * Tests a register with a new value and checks if the new value is 824 * different from the old value. 825 * 826 * Return: 1 for change, otherwise 0. 827 */ 828 int snd_soc_component_test_bits(struct snd_soc_component *component, 829 unsigned int reg, unsigned int mask, unsigned int value) 830 { 831 unsigned int old, new; 832 833 old = snd_soc_component_read(component, reg); 834 new = (old & ~mask) | value; 835 return old != new; 836 } 837 EXPORT_SYMBOL_GPL(snd_soc_component_test_bits); 838 839 int snd_soc_pcm_component_pointer(struct snd_pcm_substream *substream) 840 { 841 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream); 842 struct snd_soc_component *component; 843 int i; 844 845 /* FIXME: use 1st pointer */ 846 for_each_rtd_components(rtd, i, component) 847 if (component->driver->pointer) 848 return component->driver->pointer(component, substream); 849 850 return 0; 851 } 852 853 int snd_soc_pcm_component_ioctl(struct snd_pcm_substream *substream, 854 unsigned int cmd, void *arg) 855 { 856 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream); 857 struct snd_soc_component *component; 858 int i; 859 860 /* FIXME: use 1st ioctl */ 861 for_each_rtd_components(rtd, i, component) 862 if (component->driver->ioctl) 863 return soc_component_ret( 864 component, 865 component->driver->ioctl(component, 866 substream, cmd, arg)); 867 868 return snd_pcm_lib_ioctl(substream, cmd, arg); 869 } 870 871 int snd_soc_pcm_component_sync_stop(struct snd_pcm_substream *substream) 872 { 873 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream); 874 struct snd_soc_component *component; 875 int i, ret; 876 877 for_each_rtd_components(rtd, i, component) { 878 if (component->driver->sync_stop) { 879 ret = component->driver->sync_stop(component, 880 substream); 881 if (ret < 0) 882 return soc_component_ret(component, ret); 883 } 884 } 885 886 return 0; 887 } 888 889 int snd_soc_pcm_component_copy_user(struct snd_pcm_substream *substream, 890 int channel, unsigned long pos, 891 void __user *buf, unsigned long bytes) 892 { 893 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream); 894 struct snd_soc_component *component; 895 int i; 896 897 /* FIXME. it returns 1st copy now */ 898 for_each_rtd_components(rtd, i, component) 899 if (component->driver->copy_user) 900 return soc_component_ret( 901 component, 902 component->driver->copy_user( 903 component, substream, channel, 904 pos, buf, bytes)); 905 906 return -EINVAL; 907 } 908 909 struct page *snd_soc_pcm_component_page(struct snd_pcm_substream *substream, 910 unsigned long offset) 911 { 912 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream); 913 struct snd_soc_component *component; 914 struct page *page; 915 int i; 916 917 /* FIXME. it returns 1st page now */ 918 for_each_rtd_components(rtd, i, component) { 919 if (component->driver->page) { 920 page = component->driver->page(component, 921 substream, offset); 922 if (page) 923 return page; 924 } 925 } 926 927 return NULL; 928 } 929 930 int snd_soc_pcm_component_mmap(struct snd_pcm_substream *substream, 931 struct vm_area_struct *vma) 932 { 933 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream); 934 struct snd_soc_component *component; 935 int i; 936 937 /* FIXME. it returns 1st mmap now */ 938 for_each_rtd_components(rtd, i, component) 939 if (component->driver->mmap) 940 return soc_component_ret( 941 component, 942 component->driver->mmap(component, 943 substream, vma)); 944 945 return -EINVAL; 946 } 947 948 int snd_soc_pcm_component_new(struct snd_soc_pcm_runtime *rtd) 949 { 950 struct snd_soc_component *component; 951 int ret; 952 int i; 953 954 for_each_rtd_components(rtd, i, component) { 955 if (component->driver->pcm_construct) { 956 ret = component->driver->pcm_construct(component, rtd); 957 if (ret < 0) 958 return soc_component_ret(component, ret); 959 } 960 } 961 962 return 0; 963 } 964 965 void snd_soc_pcm_component_free(struct snd_soc_pcm_runtime *rtd) 966 { 967 struct snd_soc_component *component; 968 int i; 969 970 if (!rtd->pcm) 971 return; 972 973 for_each_rtd_components(rtd, i, component) 974 if (component->driver->pcm_destruct) 975 component->driver->pcm_destruct(component, rtd->pcm); 976 } 977 978 int snd_soc_pcm_component_prepare(struct snd_pcm_substream *substream) 979 { 980 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream); 981 struct snd_soc_component *component; 982 int i, ret; 983 984 for_each_rtd_components(rtd, i, component) { 985 if (component->driver->prepare) { 986 ret = component->driver->prepare(component, substream); 987 if (ret < 0) 988 return soc_component_ret(component, ret); 989 } 990 } 991 992 return 0; 993 } 994 995 int snd_soc_pcm_component_hw_params(struct snd_pcm_substream *substream, 996 struct snd_pcm_hw_params *params) 997 { 998 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream); 999 struct snd_soc_component *component; 1000 int i, ret; 1001 1002 for_each_rtd_components(rtd, i, component) { 1003 if (component->driver->hw_params) { 1004 ret = component->driver->hw_params(component, 1005 substream, params); 1006 if (ret < 0) 1007 return soc_component_ret(component, ret); 1008 } 1009 /* mark substream if succeeded */ 1010 soc_component_mark_push(component, substream, hw_params); 1011 } 1012 1013 return 0; 1014 } 1015 1016 void snd_soc_pcm_component_hw_free(struct snd_pcm_substream *substream, 1017 int rollback) 1018 { 1019 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream); 1020 struct snd_soc_component *component; 1021 int i, ret; 1022 1023 for_each_rtd_components(rtd, i, component) { 1024 if (rollback && !soc_component_mark_match(component, substream, hw_params)) 1025 continue; 1026 1027 if (component->driver->hw_free) { 1028 ret = component->driver->hw_free(component, substream); 1029 if (ret < 0) 1030 soc_component_ret(component, ret); 1031 } 1032 1033 /* remove marked substream */ 1034 soc_component_mark_pop(component, substream, hw_params); 1035 } 1036 } 1037 1038 int snd_soc_pcm_component_trigger(struct snd_pcm_substream *substream, 1039 int cmd) 1040 { 1041 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream); 1042 struct snd_soc_component *component; 1043 int i, ret; 1044 1045 for_each_rtd_components(rtd, i, component) { 1046 if (component->driver->trigger) { 1047 ret = component->driver->trigger(component, substream, cmd); 1048 if (ret < 0) 1049 return soc_component_ret(component, ret); 1050 } 1051 } 1052 1053 return 0; 1054 } 1055 1056 int snd_soc_pcm_component_pm_runtime_get(struct snd_soc_pcm_runtime *rtd, 1057 void *stream) 1058 { 1059 struct snd_soc_component *component; 1060 int i, ret; 1061 1062 for_each_rtd_components(rtd, i, component) { 1063 ret = pm_runtime_get_sync(component->dev); 1064 if (ret < 0 && ret != -EACCES) { 1065 pm_runtime_put_noidle(component->dev); 1066 return soc_component_ret(component, ret); 1067 } 1068 /* mark stream if succeeded */ 1069 soc_component_mark_push(component, stream, pm); 1070 } 1071 1072 return 0; 1073 } 1074 1075 void snd_soc_pcm_component_pm_runtime_put(struct snd_soc_pcm_runtime *rtd, 1076 void *stream, int rollback) 1077 { 1078 struct snd_soc_component *component; 1079 int i; 1080 1081 for_each_rtd_components(rtd, i, component) { 1082 if (rollback && !soc_component_mark_match(component, stream, pm)) 1083 continue; 1084 1085 pm_runtime_mark_last_busy(component->dev); 1086 pm_runtime_put_autosuspend(component->dev); 1087 1088 /* remove marked stream */ 1089 soc_component_mark_pop(component, stream, pm); 1090 } 1091 } 1092