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 #include <linux/bitops.h> 15 16 #define soc_component_ret(dai, ret) _soc_component_ret(dai, __func__, ret, -1) 17 #define soc_component_ret_reg_rw(dai, ret, reg) _soc_component_ret(dai, __func__, ret, reg) 18 static inline int _soc_component_ret(struct snd_soc_component *component, 19 const char *func, int ret, int reg) 20 { 21 /* Positive/Zero values are not errors */ 22 if (ret >= 0) 23 return ret; 24 25 /* Negative values might be errors */ 26 switch (ret) { 27 case -EPROBE_DEFER: 28 case -ENOTSUPP: 29 break; 30 default: 31 if (reg == -1) 32 dev_err(component->dev, 33 "ASoC: error at %s on %s: %d\n", 34 func, component->name, ret); 35 else 36 dev_err(component->dev, 37 "ASoC: error at %s on %s for register: [0x%08x] %d\n", 38 func, component->name, reg, ret); 39 } 40 41 return ret; 42 } 43 44 static inline int soc_component_field_shift(struct snd_soc_component *component, 45 unsigned int mask) 46 { 47 if (!mask) { 48 dev_err(component->dev, "ASoC: error field mask is zero for %s\n", 49 component->name); 50 return 0; 51 } 52 53 return (ffs(mask) - 1); 54 } 55 56 /* 57 * We might want to check substream by using list. 58 * In such case, we can update these macros. 59 */ 60 #define soc_component_mark_push(component, substream, tgt) ((component)->mark_##tgt = substream) 61 #define soc_component_mark_pop(component, substream, tgt) ((component)->mark_##tgt = NULL) 62 #define soc_component_mark_match(component, substream, tgt) ((component)->mark_##tgt == substream) 63 64 void snd_soc_component_set_aux(struct snd_soc_component *component, 65 struct snd_soc_aux_dev *aux) 66 { 67 component->init = (aux) ? aux->init : NULL; 68 } 69 70 int snd_soc_component_init(struct snd_soc_component *component) 71 { 72 int ret = 0; 73 74 if (component->init) 75 ret = component->init(component); 76 77 return soc_component_ret(component, ret); 78 } 79 80 /** 81 * snd_soc_component_set_sysclk - configure COMPONENT system or master clock. 82 * @component: COMPONENT 83 * @clk_id: DAI specific clock ID 84 * @source: Source for the clock 85 * @freq: new clock frequency in Hz 86 * @dir: new clock direction - input/output. 87 * 88 * Configures the CODEC master (MCLK) or system (SYSCLK) clocking. 89 */ 90 int snd_soc_component_set_sysclk(struct snd_soc_component *component, 91 int clk_id, int source, unsigned int freq, 92 int dir) 93 { 94 int ret = -ENOTSUPP; 95 96 if (component->driver->set_sysclk) 97 ret = component->driver->set_sysclk(component, clk_id, source, 98 freq, dir); 99 100 return soc_component_ret(component, ret); 101 } 102 EXPORT_SYMBOL_GPL(snd_soc_component_set_sysclk); 103 104 /* 105 * snd_soc_component_set_pll - configure component PLL. 106 * @component: COMPONENT 107 * @pll_id: DAI specific PLL ID 108 * @source: DAI specific source for the PLL 109 * @freq_in: PLL input clock frequency in Hz 110 * @freq_out: requested PLL output clock frequency in Hz 111 * 112 * Configures and enables PLL to generate output clock based on input clock. 113 */ 114 int snd_soc_component_set_pll(struct snd_soc_component *component, int pll_id, 115 int source, unsigned int freq_in, 116 unsigned int freq_out) 117 { 118 int ret = -EINVAL; 119 120 if (component->driver->set_pll) 121 ret = component->driver->set_pll(component, pll_id, source, 122 freq_in, freq_out); 123 124 return soc_component_ret(component, ret); 125 } 126 EXPORT_SYMBOL_GPL(snd_soc_component_set_pll); 127 128 void snd_soc_component_seq_notifier(struct snd_soc_component *component, 129 enum snd_soc_dapm_type type, int subseq) 130 { 131 if (component->driver->seq_notifier) 132 component->driver->seq_notifier(component, type, subseq); 133 } 134 135 int snd_soc_component_stream_event(struct snd_soc_component *component, 136 int event) 137 { 138 int ret = 0; 139 140 if (component->driver->stream_event) 141 ret = component->driver->stream_event(component, event); 142 143 return soc_component_ret(component, ret); 144 } 145 146 int snd_soc_component_set_bias_level(struct snd_soc_component *component, 147 enum snd_soc_bias_level level) 148 { 149 int ret = 0; 150 151 if (component->driver->set_bias_level) 152 ret = component->driver->set_bias_level(component, level); 153 154 return soc_component_ret(component, ret); 155 } 156 157 int snd_soc_component_enable_pin(struct snd_soc_component *component, 158 const char *pin) 159 { 160 struct snd_soc_dapm_context *dapm = 161 snd_soc_component_get_dapm(component); 162 return snd_soc_dapm_enable_pin(dapm, pin); 163 } 164 EXPORT_SYMBOL_GPL(snd_soc_component_enable_pin); 165 166 int snd_soc_component_enable_pin_unlocked(struct snd_soc_component *component, 167 const char *pin) 168 { 169 struct snd_soc_dapm_context *dapm = 170 snd_soc_component_get_dapm(component); 171 return snd_soc_dapm_enable_pin_unlocked(dapm, pin); 172 } 173 EXPORT_SYMBOL_GPL(snd_soc_component_enable_pin_unlocked); 174 175 int snd_soc_component_disable_pin(struct snd_soc_component *component, 176 const char *pin) 177 { 178 struct snd_soc_dapm_context *dapm = 179 snd_soc_component_get_dapm(component); 180 return snd_soc_dapm_disable_pin(dapm, pin); 181 } 182 EXPORT_SYMBOL_GPL(snd_soc_component_disable_pin); 183 184 int snd_soc_component_disable_pin_unlocked(struct snd_soc_component *component, 185 const char *pin) 186 { 187 struct snd_soc_dapm_context *dapm = 188 snd_soc_component_get_dapm(component); 189 return snd_soc_dapm_disable_pin_unlocked(dapm, pin); 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 struct snd_soc_dapm_context *dapm = 197 snd_soc_component_get_dapm(component); 198 return snd_soc_dapm_nc_pin(dapm, pin); 199 } 200 EXPORT_SYMBOL_GPL(snd_soc_component_nc_pin); 201 202 int snd_soc_component_nc_pin_unlocked(struct snd_soc_component *component, 203 const char *pin) 204 { 205 struct snd_soc_dapm_context *dapm = 206 snd_soc_component_get_dapm(component); 207 return snd_soc_dapm_nc_pin_unlocked(dapm, pin); 208 } 209 EXPORT_SYMBOL_GPL(snd_soc_component_nc_pin_unlocked); 210 211 int snd_soc_component_get_pin_status(struct snd_soc_component *component, 212 const char *pin) 213 { 214 struct snd_soc_dapm_context *dapm = 215 snd_soc_component_get_dapm(component); 216 return snd_soc_dapm_get_pin_status(dapm, pin); 217 } 218 EXPORT_SYMBOL_GPL(snd_soc_component_get_pin_status); 219 220 int snd_soc_component_force_enable_pin(struct snd_soc_component *component, 221 const char *pin) 222 { 223 struct snd_soc_dapm_context *dapm = 224 snd_soc_component_get_dapm(component); 225 return snd_soc_dapm_force_enable_pin(dapm, pin); 226 } 227 EXPORT_SYMBOL_GPL(snd_soc_component_force_enable_pin); 228 229 int snd_soc_component_force_enable_pin_unlocked( 230 struct snd_soc_component *component, 231 const char *pin) 232 { 233 struct snd_soc_dapm_context *dapm = 234 snd_soc_component_get_dapm(component); 235 return snd_soc_dapm_force_enable_pin_unlocked(dapm, pin); 236 } 237 EXPORT_SYMBOL_GPL(snd_soc_component_force_enable_pin_unlocked); 238 239 /** 240 * snd_soc_component_set_jack - configure component jack. 241 * @component: COMPONENTs 242 * @jack: structure to use for the jack 243 * @data: can be used if codec driver need extra data for configuring jack 244 * 245 * Configures and enables jack detection function. 246 */ 247 int snd_soc_component_set_jack(struct snd_soc_component *component, 248 struct snd_soc_jack *jack, void *data) 249 { 250 int ret = -ENOTSUPP; 251 252 if (component->driver->set_jack) 253 ret = component->driver->set_jack(component, jack, data); 254 255 return soc_component_ret(component, ret); 256 } 257 EXPORT_SYMBOL_GPL(snd_soc_component_set_jack); 258 259 int snd_soc_component_module_get(struct snd_soc_component *component, 260 void *mark, int upon_open) 261 { 262 int ret = 0; 263 264 if (component->driver->module_get_upon_open == !!upon_open && 265 !try_module_get(component->dev->driver->owner)) 266 ret = -ENODEV; 267 268 /* mark module if succeeded */ 269 if (ret == 0) 270 soc_component_mark_push(component, mark, module); 271 272 return soc_component_ret(component, ret); 273 } 274 275 void snd_soc_component_module_put(struct snd_soc_component *component, 276 void *mark, int upon_open, int rollback) 277 { 278 if (rollback && !soc_component_mark_match(component, mark, module)) 279 return; 280 281 if (component->driver->module_get_upon_open == !!upon_open) 282 module_put(component->dev->driver->owner); 283 284 /* remove the mark from module */ 285 soc_component_mark_pop(component, mark, module); 286 } 287 288 int snd_soc_component_open(struct snd_soc_component *component, 289 struct snd_pcm_substream *substream) 290 { 291 int ret = 0; 292 293 if (component->driver->open) 294 ret = component->driver->open(component, substream); 295 296 /* mark substream if succeeded */ 297 if (ret == 0) 298 soc_component_mark_push(component, substream, open); 299 300 return soc_component_ret(component, ret); 301 } 302 303 int snd_soc_component_close(struct snd_soc_component *component, 304 struct snd_pcm_substream *substream, 305 int rollback) 306 { 307 int ret = 0; 308 309 if (rollback && !soc_component_mark_match(component, substream, open)) 310 return 0; 311 312 if (component->driver->close) 313 ret = component->driver->close(component, substream); 314 315 /* remove marked substream */ 316 soc_component_mark_pop(component, substream, open); 317 318 return soc_component_ret(component, ret); 319 } 320 321 void snd_soc_component_suspend(struct snd_soc_component *component) 322 { 323 if (component->driver->suspend) 324 component->driver->suspend(component); 325 component->suspended = 1; 326 } 327 328 void snd_soc_component_resume(struct snd_soc_component *component) 329 { 330 if (component->driver->resume) 331 component->driver->resume(component); 332 component->suspended = 0; 333 } 334 335 int snd_soc_component_is_suspended(struct snd_soc_component *component) 336 { 337 return component->suspended; 338 } 339 340 int snd_soc_component_probe(struct snd_soc_component *component) 341 { 342 int ret = 0; 343 344 if (component->driver->probe) 345 ret = component->driver->probe(component); 346 347 return soc_component_ret(component, ret); 348 } 349 350 void snd_soc_component_remove(struct snd_soc_component *component) 351 { 352 if (component->driver->remove) 353 component->driver->remove(component); 354 } 355 356 int snd_soc_component_of_xlate_dai_id(struct snd_soc_component *component, 357 struct device_node *ep) 358 { 359 int ret = -ENOTSUPP; 360 361 if (component->driver->of_xlate_dai_id) 362 ret = component->driver->of_xlate_dai_id(component, ep); 363 364 return soc_component_ret(component, ret); 365 } 366 367 int snd_soc_component_of_xlate_dai_name(struct snd_soc_component *component, 368 const struct of_phandle_args *args, 369 const char **dai_name) 370 { 371 if (component->driver->of_xlate_dai_name) 372 return component->driver->of_xlate_dai_name(component, 373 args, dai_name); 374 /* 375 * Don't use soc_component_ret here because we may not want to report 376 * the error just yet. If a device has more than one component, the 377 * first may not match and we don't want spam the log with this. 378 */ 379 return -ENOTSUPP; 380 } 381 382 void snd_soc_component_setup_regmap(struct snd_soc_component *component) 383 { 384 int val_bytes = regmap_get_val_bytes(component->regmap); 385 386 /* Errors are legitimate for non-integer byte multiples */ 387 if (val_bytes > 0) 388 component->val_bytes = val_bytes; 389 } 390 391 #ifdef CONFIG_REGMAP 392 393 /** 394 * snd_soc_component_init_regmap() - Initialize regmap instance for the 395 * component 396 * @component: The component for which to initialize the regmap instance 397 * @regmap: The regmap instance that should be used by the component 398 * 399 * This function allows deferred assignment of the regmap instance that is 400 * associated with the component. Only use this if the regmap instance is not 401 * yet ready when the component is registered. The function must also be called 402 * before the first IO attempt of the component. 403 */ 404 void snd_soc_component_init_regmap(struct snd_soc_component *component, 405 struct regmap *regmap) 406 { 407 component->regmap = regmap; 408 snd_soc_component_setup_regmap(component); 409 } 410 EXPORT_SYMBOL_GPL(snd_soc_component_init_regmap); 411 412 /** 413 * snd_soc_component_exit_regmap() - De-initialize regmap instance for the 414 * component 415 * @component: The component for which to de-initialize the regmap instance 416 * 417 * Calls regmap_exit() on the regmap instance associated to the component and 418 * removes the regmap instance from the component. 419 * 420 * This function should only be used if snd_soc_component_init_regmap() was used 421 * to initialize the regmap instance. 422 */ 423 void snd_soc_component_exit_regmap(struct snd_soc_component *component) 424 { 425 regmap_exit(component->regmap); 426 component->regmap = NULL; 427 } 428 EXPORT_SYMBOL_GPL(snd_soc_component_exit_regmap); 429 430 #endif 431 432 int snd_soc_component_compr_open(struct snd_soc_component *component, 433 struct snd_compr_stream *cstream) 434 { 435 int ret = 0; 436 437 if (component->driver->compress_ops && 438 component->driver->compress_ops->open) 439 ret = component->driver->compress_ops->open(component, cstream); 440 441 /* mark substream if succeeded */ 442 if (ret == 0) 443 soc_component_mark_push(component, cstream, compr_open); 444 445 return soc_component_ret(component, ret); 446 } 447 EXPORT_SYMBOL_GPL(snd_soc_component_compr_open); 448 449 void snd_soc_component_compr_free(struct snd_soc_component *component, 450 struct snd_compr_stream *cstream, 451 int rollback) 452 { 453 if (rollback && !soc_component_mark_match(component, cstream, compr_open)) 454 return; 455 456 if (component->driver->compress_ops && 457 component->driver->compress_ops->free) 458 component->driver->compress_ops->free(component, cstream); 459 460 /* remove marked substream */ 461 soc_component_mark_pop(component, cstream, compr_open); 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 int snd_soc_component_compr_set_metadata(struct snd_compr_stream *cstream, 639 struct snd_compr_metadata *metadata) 640 { 641 struct snd_soc_pcm_runtime *rtd = cstream->private_data; 642 struct snd_soc_component *component; 643 int i, ret; 644 645 for_each_rtd_components(rtd, i, component) { 646 if (component->driver->compress_ops && 647 component->driver->compress_ops->set_metadata) { 648 ret = component->driver->compress_ops->set_metadata( 649 component, cstream, metadata); 650 if (ret < 0) 651 return soc_component_ret(component, ret); 652 } 653 } 654 655 return 0; 656 } 657 EXPORT_SYMBOL_GPL(snd_soc_component_compr_set_metadata); 658 659 int snd_soc_component_compr_get_metadata(struct snd_compr_stream *cstream, 660 struct snd_compr_metadata *metadata) 661 { 662 struct snd_soc_pcm_runtime *rtd = cstream->private_data; 663 struct snd_soc_component *component; 664 int i, ret; 665 666 for_each_rtd_components(rtd, i, component) { 667 if (component->driver->compress_ops && 668 component->driver->compress_ops->get_metadata) { 669 ret = component->driver->compress_ops->get_metadata( 670 component, cstream, metadata); 671 return soc_component_ret(component, ret); 672 } 673 } 674 675 return 0; 676 } 677 EXPORT_SYMBOL_GPL(snd_soc_component_compr_get_metadata); 678 679 static unsigned int soc_component_read_no_lock( 680 struct snd_soc_component *component, 681 unsigned int reg) 682 { 683 int ret; 684 unsigned int val = 0; 685 686 if (component->regmap) 687 ret = regmap_read(component->regmap, reg, &val); 688 else if (component->driver->read) { 689 ret = 0; 690 val = component->driver->read(component, reg); 691 } 692 else 693 ret = -EIO; 694 695 if (ret < 0) 696 return soc_component_ret_reg_rw(component, ret, reg); 697 698 return val; 699 } 700 701 /** 702 * snd_soc_component_read() - Read register value 703 * @component: Component to read from 704 * @reg: Register to read 705 * 706 * Return: read value 707 */ 708 unsigned int snd_soc_component_read(struct snd_soc_component *component, 709 unsigned int reg) 710 { 711 unsigned int val; 712 713 mutex_lock(&component->io_mutex); 714 val = soc_component_read_no_lock(component, reg); 715 mutex_unlock(&component->io_mutex); 716 717 return val; 718 } 719 EXPORT_SYMBOL_GPL(snd_soc_component_read); 720 721 static int soc_component_write_no_lock( 722 struct snd_soc_component *component, 723 unsigned int reg, unsigned int val) 724 { 725 int ret = -EIO; 726 727 if (component->regmap) 728 ret = regmap_write(component->regmap, reg, val); 729 else if (component->driver->write) 730 ret = component->driver->write(component, reg, val); 731 732 return soc_component_ret_reg_rw(component, ret, reg); 733 } 734 735 /** 736 * snd_soc_component_write() - Write register value 737 * @component: Component to write to 738 * @reg: Register to write 739 * @val: Value to write to the register 740 * 741 * Return: 0 on success, a negative error code otherwise. 742 */ 743 int snd_soc_component_write(struct snd_soc_component *component, 744 unsigned int reg, unsigned int val) 745 { 746 int ret; 747 748 mutex_lock(&component->io_mutex); 749 ret = soc_component_write_no_lock(component, reg, val); 750 mutex_unlock(&component->io_mutex); 751 752 return ret; 753 } 754 EXPORT_SYMBOL_GPL(snd_soc_component_write); 755 756 static int snd_soc_component_update_bits_legacy( 757 struct snd_soc_component *component, unsigned int reg, 758 unsigned int mask, unsigned int val, bool *change) 759 { 760 unsigned int old, new; 761 int ret = 0; 762 763 mutex_lock(&component->io_mutex); 764 765 old = soc_component_read_no_lock(component, reg); 766 767 new = (old & ~mask) | (val & mask); 768 *change = old != new; 769 if (*change) 770 ret = soc_component_write_no_lock(component, reg, new); 771 772 mutex_unlock(&component->io_mutex); 773 774 return soc_component_ret_reg_rw(component, ret, reg); 775 } 776 777 /** 778 * snd_soc_component_update_bits() - Perform read/modify/write cycle 779 * @component: Component to update 780 * @reg: Register to update 781 * @mask: Mask that specifies which bits to update 782 * @val: New value for the bits specified by mask 783 * 784 * Return: 1 if the operation was successful and the value of the register 785 * changed, 0 if the operation was successful, but the value did not change. 786 * Returns a negative error code otherwise. 787 */ 788 int snd_soc_component_update_bits(struct snd_soc_component *component, 789 unsigned int reg, unsigned int mask, unsigned int val) 790 { 791 bool change; 792 int ret; 793 794 if (component->regmap) 795 ret = regmap_update_bits_check(component->regmap, reg, mask, 796 val, &change); 797 else 798 ret = snd_soc_component_update_bits_legacy(component, reg, 799 mask, val, &change); 800 801 if (ret < 0) 802 return soc_component_ret_reg_rw(component, ret, reg); 803 return change; 804 } 805 EXPORT_SYMBOL_GPL(snd_soc_component_update_bits); 806 807 /** 808 * snd_soc_component_update_bits_async() - Perform asynchronous 809 * read/modify/write cycle 810 * @component: Component to update 811 * @reg: Register to update 812 * @mask: Mask that specifies which bits to update 813 * @val: New value for the bits specified by mask 814 * 815 * This function is similar to snd_soc_component_update_bits(), but the update 816 * operation is scheduled asynchronously. This means it may not be completed 817 * when the function returns. To make sure that all scheduled updates have been 818 * completed snd_soc_component_async_complete() must be called. 819 * 820 * Return: 1 if the operation was successful and the value of the register 821 * changed, 0 if the operation was successful, but the value did not change. 822 * Returns a negative error code otherwise. 823 */ 824 int snd_soc_component_update_bits_async(struct snd_soc_component *component, 825 unsigned int reg, unsigned int mask, unsigned int val) 826 { 827 bool change; 828 int ret; 829 830 if (component->regmap) 831 ret = regmap_update_bits_check_async(component->regmap, reg, 832 mask, val, &change); 833 else 834 ret = snd_soc_component_update_bits_legacy(component, reg, 835 mask, val, &change); 836 837 if (ret < 0) 838 return soc_component_ret_reg_rw(component, ret, reg); 839 return change; 840 } 841 EXPORT_SYMBOL_GPL(snd_soc_component_update_bits_async); 842 843 /** 844 * snd_soc_component_read_field() - Read register field value 845 * @component: Component to read from 846 * @reg: Register to read 847 * @mask: mask of the register field 848 * 849 * Return: read value of register field. 850 */ 851 unsigned int snd_soc_component_read_field(struct snd_soc_component *component, 852 unsigned int reg, unsigned int mask) 853 { 854 unsigned int val; 855 856 val = snd_soc_component_read(component, reg); 857 858 val = (val & mask) >> soc_component_field_shift(component, mask); 859 860 return val; 861 } 862 EXPORT_SYMBOL_GPL(snd_soc_component_read_field); 863 864 /** 865 * snd_soc_component_write_field() - write to register field 866 * @component: Component to write to 867 * @reg: Register to write 868 * @mask: mask of the register field to update 869 * @val: value of the field to write 870 * 871 * Return: 1 for change, otherwise 0. 872 */ 873 int snd_soc_component_write_field(struct snd_soc_component *component, 874 unsigned int reg, unsigned int mask, 875 unsigned int val) 876 { 877 878 val = (val << soc_component_field_shift(component, mask)) & mask; 879 880 return snd_soc_component_update_bits(component, reg, mask, val); 881 } 882 EXPORT_SYMBOL_GPL(snd_soc_component_write_field); 883 884 /** 885 * snd_soc_component_async_complete() - Ensure asynchronous I/O has completed 886 * @component: Component for which to wait 887 * 888 * This function blocks until all asynchronous I/O which has previously been 889 * scheduled using snd_soc_component_update_bits_async() has completed. 890 */ 891 void snd_soc_component_async_complete(struct snd_soc_component *component) 892 { 893 if (component->regmap) 894 regmap_async_complete(component->regmap); 895 } 896 EXPORT_SYMBOL_GPL(snd_soc_component_async_complete); 897 898 /** 899 * snd_soc_component_test_bits - Test register for change 900 * @component: component 901 * @reg: Register to test 902 * @mask: Mask that specifies which bits to test 903 * @value: Value to test against 904 * 905 * Tests a register with a new value and checks if the new value is 906 * different from the old value. 907 * 908 * Return: 1 for change, otherwise 0. 909 */ 910 int snd_soc_component_test_bits(struct snd_soc_component *component, 911 unsigned int reg, unsigned int mask, unsigned int value) 912 { 913 unsigned int old, new; 914 915 old = snd_soc_component_read(component, reg); 916 new = (old & ~mask) | value; 917 return old != new; 918 } 919 EXPORT_SYMBOL_GPL(snd_soc_component_test_bits); 920 921 int snd_soc_pcm_component_pointer(struct snd_pcm_substream *substream) 922 { 923 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream); 924 struct snd_soc_component *component; 925 int i; 926 927 /* FIXME: use 1st pointer */ 928 for_each_rtd_components(rtd, i, component) 929 if (component->driver->pointer) 930 return component->driver->pointer(component, substream); 931 932 return 0; 933 } 934 935 void snd_soc_pcm_component_delay(struct snd_pcm_substream *substream, 936 snd_pcm_sframes_t *cpu_delay, 937 snd_pcm_sframes_t *codec_delay) 938 { 939 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream); 940 struct snd_soc_component *component; 941 snd_pcm_sframes_t delay; 942 int i; 943 944 /* 945 * We're looking for the delay through the full audio path so it needs to 946 * be the maximum of the Components doing transmit and the maximum of the 947 * Components doing receive (ie, all CPUs and all CODECs) rather than 948 * just the maximum of all Components. 949 */ 950 for_each_rtd_components(rtd, i, component) { 951 if (!component->driver->delay) 952 continue; 953 954 delay = component->driver->delay(component, substream); 955 956 if (snd_soc_component_is_codec(component)) 957 *codec_delay = max(*codec_delay, delay); 958 else 959 *cpu_delay = max(*cpu_delay, delay); 960 } 961 } 962 963 int snd_soc_pcm_component_ioctl(struct snd_pcm_substream *substream, 964 unsigned int cmd, void *arg) 965 { 966 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream); 967 struct snd_soc_component *component; 968 int i; 969 970 /* FIXME: use 1st ioctl */ 971 for_each_rtd_components(rtd, i, component) 972 if (component->driver->ioctl) 973 return soc_component_ret( 974 component, 975 component->driver->ioctl(component, 976 substream, cmd, arg)); 977 978 return snd_pcm_lib_ioctl(substream, cmd, arg); 979 } 980 981 int snd_soc_pcm_component_sync_stop(struct snd_pcm_substream *substream) 982 { 983 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream); 984 struct snd_soc_component *component; 985 int i, ret; 986 987 for_each_rtd_components(rtd, i, component) { 988 if (component->driver->sync_stop) { 989 ret = component->driver->sync_stop(component, 990 substream); 991 if (ret < 0) 992 return soc_component_ret(component, ret); 993 } 994 } 995 996 return 0; 997 } 998 999 int snd_soc_pcm_component_copy_user(struct snd_pcm_substream *substream, 1000 int channel, unsigned long pos, 1001 void __user *buf, unsigned long bytes) 1002 { 1003 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream); 1004 struct snd_soc_component *component; 1005 int i; 1006 1007 /* FIXME. it returns 1st copy now */ 1008 for_each_rtd_components(rtd, i, component) 1009 if (component->driver->copy_user) 1010 return soc_component_ret( 1011 component, 1012 component->driver->copy_user( 1013 component, substream, channel, 1014 pos, buf, bytes)); 1015 1016 return -EINVAL; 1017 } 1018 1019 struct page *snd_soc_pcm_component_page(struct snd_pcm_substream *substream, 1020 unsigned long offset) 1021 { 1022 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream); 1023 struct snd_soc_component *component; 1024 struct page *page; 1025 int i; 1026 1027 /* FIXME. it returns 1st page now */ 1028 for_each_rtd_components(rtd, i, component) { 1029 if (component->driver->page) { 1030 page = component->driver->page(component, 1031 substream, offset); 1032 if (page) 1033 return page; 1034 } 1035 } 1036 1037 return NULL; 1038 } 1039 1040 int snd_soc_pcm_component_mmap(struct snd_pcm_substream *substream, 1041 struct vm_area_struct *vma) 1042 { 1043 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream); 1044 struct snd_soc_component *component; 1045 int i; 1046 1047 /* FIXME. it returns 1st mmap now */ 1048 for_each_rtd_components(rtd, i, component) 1049 if (component->driver->mmap) 1050 return soc_component_ret( 1051 component, 1052 component->driver->mmap(component, 1053 substream, vma)); 1054 1055 return -EINVAL; 1056 } 1057 1058 int snd_soc_pcm_component_new(struct snd_soc_pcm_runtime *rtd) 1059 { 1060 struct snd_soc_component *component; 1061 int ret; 1062 int i; 1063 1064 for_each_rtd_components(rtd, i, component) { 1065 if (component->driver->pcm_construct) { 1066 ret = component->driver->pcm_construct(component, rtd); 1067 if (ret < 0) 1068 return soc_component_ret(component, ret); 1069 } 1070 } 1071 1072 return 0; 1073 } 1074 1075 void snd_soc_pcm_component_free(struct snd_soc_pcm_runtime *rtd) 1076 { 1077 struct snd_soc_component *component; 1078 int i; 1079 1080 if (!rtd->pcm) 1081 return; 1082 1083 for_each_rtd_components(rtd, i, component) 1084 if (component->driver->pcm_destruct) 1085 component->driver->pcm_destruct(component, rtd->pcm); 1086 } 1087 1088 int snd_soc_pcm_component_prepare(struct snd_pcm_substream *substream) 1089 { 1090 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream); 1091 struct snd_soc_component *component; 1092 int i, ret; 1093 1094 for_each_rtd_components(rtd, i, component) { 1095 if (component->driver->prepare) { 1096 ret = component->driver->prepare(component, substream); 1097 if (ret < 0) 1098 return soc_component_ret(component, ret); 1099 } 1100 } 1101 1102 return 0; 1103 } 1104 1105 int snd_soc_pcm_component_hw_params(struct snd_pcm_substream *substream, 1106 struct snd_pcm_hw_params *params) 1107 { 1108 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream); 1109 struct snd_soc_component *component; 1110 int i, ret; 1111 1112 for_each_rtd_components(rtd, i, component) { 1113 if (component->driver->hw_params) { 1114 ret = component->driver->hw_params(component, 1115 substream, params); 1116 if (ret < 0) 1117 return soc_component_ret(component, ret); 1118 } 1119 /* mark substream if succeeded */ 1120 soc_component_mark_push(component, substream, hw_params); 1121 } 1122 1123 return 0; 1124 } 1125 1126 void snd_soc_pcm_component_hw_free(struct snd_pcm_substream *substream, 1127 int rollback) 1128 { 1129 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream); 1130 struct snd_soc_component *component; 1131 int i, ret; 1132 1133 for_each_rtd_components(rtd, i, component) { 1134 if (rollback && !soc_component_mark_match(component, substream, hw_params)) 1135 continue; 1136 1137 if (component->driver->hw_free) { 1138 ret = component->driver->hw_free(component, substream); 1139 if (ret < 0) 1140 soc_component_ret(component, ret); 1141 } 1142 1143 /* remove marked substream */ 1144 soc_component_mark_pop(component, substream, hw_params); 1145 } 1146 } 1147 1148 static int soc_component_trigger(struct snd_soc_component *component, 1149 struct snd_pcm_substream *substream, 1150 int cmd) 1151 { 1152 int ret = 0; 1153 1154 if (component->driver->trigger) 1155 ret = component->driver->trigger(component, substream, cmd); 1156 1157 return soc_component_ret(component, ret); 1158 } 1159 1160 int snd_soc_pcm_component_trigger(struct snd_pcm_substream *substream, 1161 int cmd, int rollback) 1162 { 1163 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream); 1164 struct snd_soc_component *component; 1165 int i, r, ret = 0; 1166 1167 switch (cmd) { 1168 case SNDRV_PCM_TRIGGER_START: 1169 case SNDRV_PCM_TRIGGER_RESUME: 1170 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: 1171 for_each_rtd_components(rtd, i, component) { 1172 ret = soc_component_trigger(component, substream, cmd); 1173 if (ret < 0) 1174 break; 1175 soc_component_mark_push(component, substream, trigger); 1176 } 1177 break; 1178 case SNDRV_PCM_TRIGGER_STOP: 1179 case SNDRV_PCM_TRIGGER_SUSPEND: 1180 case SNDRV_PCM_TRIGGER_PAUSE_PUSH: 1181 for_each_rtd_components(rtd, i, component) { 1182 if (rollback && !soc_component_mark_match(component, substream, trigger)) 1183 continue; 1184 1185 r = soc_component_trigger(component, substream, cmd); 1186 if (r < 0) 1187 ret = r; /* use last ret */ 1188 soc_component_mark_pop(component, substream, trigger); 1189 } 1190 } 1191 1192 return ret; 1193 } 1194 1195 int snd_soc_pcm_component_pm_runtime_get(struct snd_soc_pcm_runtime *rtd, 1196 void *stream) 1197 { 1198 struct snd_soc_component *component; 1199 int i; 1200 1201 for_each_rtd_components(rtd, i, component) { 1202 int ret = pm_runtime_get_sync(component->dev); 1203 if (ret < 0 && ret != -EACCES) { 1204 pm_runtime_put_noidle(component->dev); 1205 return soc_component_ret(component, ret); 1206 } 1207 /* mark stream if succeeded */ 1208 soc_component_mark_push(component, stream, pm); 1209 } 1210 1211 return 0; 1212 } 1213 1214 void snd_soc_pcm_component_pm_runtime_put(struct snd_soc_pcm_runtime *rtd, 1215 void *stream, int rollback) 1216 { 1217 struct snd_soc_component *component; 1218 int i; 1219 1220 for_each_rtd_components(rtd, i, component) { 1221 if (rollback && !soc_component_mark_match(component, stream, pm)) 1222 continue; 1223 1224 pm_runtime_mark_last_busy(component->dev); 1225 pm_runtime_put_autosuspend(component->dev); 1226 1227 /* remove marked stream */ 1228 soc_component_mark_pop(component, stream, pm); 1229 } 1230 } 1231 1232 int snd_soc_pcm_component_ack(struct snd_pcm_substream *substream) 1233 { 1234 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream); 1235 struct snd_soc_component *component; 1236 int i; 1237 1238 /* FIXME: use 1st pointer */ 1239 for_each_rtd_components(rtd, i, component) 1240 if (component->driver->ack) 1241 return component->driver->ack(component, substream); 1242 1243 return 0; 1244 } 1245