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 /** 260 * snd_soc_component_get_jack_type 261 * @component: COMPONENTs 262 * 263 * Returns the jack type of the component 264 * This can either be the supported type or one read from 265 * devicetree with the property: jack-type. 266 */ 267 int snd_soc_component_get_jack_type( 268 struct snd_soc_component *component) 269 { 270 int ret = -ENOTSUPP; 271 272 if (component->driver->get_jack_type) 273 ret = component->driver->get_jack_type(component); 274 275 return soc_component_ret(component, ret); 276 } 277 EXPORT_SYMBOL_GPL(snd_soc_component_get_jack_type); 278 279 int snd_soc_component_module_get(struct snd_soc_component *component, 280 void *mark, int upon_open) 281 { 282 int ret = 0; 283 284 if (component->driver->module_get_upon_open == !!upon_open && 285 !try_module_get(component->dev->driver->owner)) 286 ret = -ENODEV; 287 288 /* mark module if succeeded */ 289 if (ret == 0) 290 soc_component_mark_push(component, mark, module); 291 292 return soc_component_ret(component, ret); 293 } 294 295 void snd_soc_component_module_put(struct snd_soc_component *component, 296 void *mark, int upon_open, int rollback) 297 { 298 if (rollback && !soc_component_mark_match(component, mark, module)) 299 return; 300 301 if (component->driver->module_get_upon_open == !!upon_open) 302 module_put(component->dev->driver->owner); 303 304 /* remove the mark from module */ 305 soc_component_mark_pop(component, mark, module); 306 } 307 308 int snd_soc_component_open(struct snd_soc_component *component, 309 struct snd_pcm_substream *substream) 310 { 311 int ret = 0; 312 313 if (component->driver->open) 314 ret = component->driver->open(component, substream); 315 316 /* mark substream if succeeded */ 317 if (ret == 0) 318 soc_component_mark_push(component, substream, open); 319 320 return soc_component_ret(component, ret); 321 } 322 323 int snd_soc_component_close(struct snd_soc_component *component, 324 struct snd_pcm_substream *substream, 325 int rollback) 326 { 327 int ret = 0; 328 329 if (rollback && !soc_component_mark_match(component, substream, open)) 330 return 0; 331 332 if (component->driver->close) 333 ret = component->driver->close(component, substream); 334 335 /* remove marked substream */ 336 soc_component_mark_pop(component, substream, open); 337 338 return soc_component_ret(component, ret); 339 } 340 341 void snd_soc_component_suspend(struct snd_soc_component *component) 342 { 343 if (component->driver->suspend) 344 component->driver->suspend(component); 345 component->suspended = 1; 346 } 347 348 void snd_soc_component_resume(struct snd_soc_component *component) 349 { 350 if (component->driver->resume) 351 component->driver->resume(component); 352 component->suspended = 0; 353 } 354 355 int snd_soc_component_is_suspended(struct snd_soc_component *component) 356 { 357 return component->suspended; 358 } 359 360 int snd_soc_component_probe(struct snd_soc_component *component) 361 { 362 int ret = 0; 363 364 if (component->driver->probe) 365 ret = component->driver->probe(component); 366 367 return soc_component_ret(component, ret); 368 } 369 370 void snd_soc_component_remove(struct snd_soc_component *component) 371 { 372 if (component->driver->remove) 373 component->driver->remove(component); 374 } 375 376 int snd_soc_component_of_xlate_dai_id(struct snd_soc_component *component, 377 struct device_node *ep) 378 { 379 int ret = -ENOTSUPP; 380 381 if (component->driver->of_xlate_dai_id) 382 ret = component->driver->of_xlate_dai_id(component, ep); 383 384 return soc_component_ret(component, ret); 385 } 386 387 int snd_soc_component_of_xlate_dai_name(struct snd_soc_component *component, 388 const struct of_phandle_args *args, 389 const char **dai_name) 390 { 391 if (component->driver->of_xlate_dai_name) 392 return component->driver->of_xlate_dai_name(component, 393 args, dai_name); 394 /* 395 * Don't use soc_component_ret here because we may not want to report 396 * the error just yet. If a device has more than one component, the 397 * first may not match and we don't want spam the log with this. 398 */ 399 return -ENOTSUPP; 400 } 401 402 void snd_soc_component_setup_regmap(struct snd_soc_component *component) 403 { 404 int val_bytes = regmap_get_val_bytes(component->regmap); 405 406 /* Errors are legitimate for non-integer byte multiples */ 407 if (val_bytes > 0) 408 component->val_bytes = val_bytes; 409 } 410 411 #ifdef CONFIG_REGMAP 412 413 /** 414 * snd_soc_component_init_regmap() - Initialize regmap instance for the 415 * component 416 * @component: The component for which to initialize the regmap instance 417 * @regmap: The regmap instance that should be used by the component 418 * 419 * This function allows deferred assignment of the regmap instance that is 420 * associated with the component. Only use this if the regmap instance is not 421 * yet ready when the component is registered. The function must also be called 422 * before the first IO attempt of the component. 423 */ 424 void snd_soc_component_init_regmap(struct snd_soc_component *component, 425 struct regmap *regmap) 426 { 427 component->regmap = regmap; 428 snd_soc_component_setup_regmap(component); 429 } 430 EXPORT_SYMBOL_GPL(snd_soc_component_init_regmap); 431 432 /** 433 * snd_soc_component_exit_regmap() - De-initialize regmap instance for the 434 * component 435 * @component: The component for which to de-initialize the regmap instance 436 * 437 * Calls regmap_exit() on the regmap instance associated to the component and 438 * removes the regmap instance from the component. 439 * 440 * This function should only be used if snd_soc_component_init_regmap() was used 441 * to initialize the regmap instance. 442 */ 443 void snd_soc_component_exit_regmap(struct snd_soc_component *component) 444 { 445 regmap_exit(component->regmap); 446 component->regmap = NULL; 447 } 448 EXPORT_SYMBOL_GPL(snd_soc_component_exit_regmap); 449 450 #endif 451 452 int snd_soc_component_compr_open(struct snd_soc_component *component, 453 struct snd_compr_stream *cstream) 454 { 455 int ret = 0; 456 457 if (component->driver->compress_ops && 458 component->driver->compress_ops->open) 459 ret = component->driver->compress_ops->open(component, cstream); 460 461 /* mark substream if succeeded */ 462 if (ret == 0) 463 soc_component_mark_push(component, cstream, compr_open); 464 465 return soc_component_ret(component, ret); 466 } 467 EXPORT_SYMBOL_GPL(snd_soc_component_compr_open); 468 469 void snd_soc_component_compr_free(struct snd_soc_component *component, 470 struct snd_compr_stream *cstream, 471 int rollback) 472 { 473 if (rollback && !soc_component_mark_match(component, cstream, compr_open)) 474 return; 475 476 if (component->driver->compress_ops && 477 component->driver->compress_ops->free) 478 component->driver->compress_ops->free(component, cstream); 479 480 /* remove marked substream */ 481 soc_component_mark_pop(component, cstream, compr_open); 482 } 483 EXPORT_SYMBOL_GPL(snd_soc_component_compr_free); 484 485 int snd_soc_component_compr_trigger(struct snd_compr_stream *cstream, int cmd) 486 { 487 struct snd_soc_pcm_runtime *rtd = cstream->private_data; 488 struct snd_soc_component *component; 489 int i, ret; 490 491 for_each_rtd_components(rtd, i, component) { 492 if (component->driver->compress_ops && 493 component->driver->compress_ops->trigger) { 494 ret = component->driver->compress_ops->trigger( 495 component, cstream, cmd); 496 if (ret < 0) 497 return soc_component_ret(component, ret); 498 } 499 } 500 501 return 0; 502 } 503 EXPORT_SYMBOL_GPL(snd_soc_component_compr_trigger); 504 505 int snd_soc_component_compr_set_params(struct snd_compr_stream *cstream, 506 struct snd_compr_params *params) 507 { 508 struct snd_soc_pcm_runtime *rtd = cstream->private_data; 509 struct snd_soc_component *component; 510 int i, ret; 511 512 for_each_rtd_components(rtd, i, component) { 513 if (component->driver->compress_ops && 514 component->driver->compress_ops->set_params) { 515 ret = component->driver->compress_ops->set_params( 516 component, cstream, params); 517 if (ret < 0) 518 return soc_component_ret(component, ret); 519 } 520 } 521 522 return 0; 523 } 524 EXPORT_SYMBOL_GPL(snd_soc_component_compr_set_params); 525 526 int snd_soc_component_compr_get_params(struct snd_compr_stream *cstream, 527 struct snd_codec *params) 528 { 529 struct snd_soc_pcm_runtime *rtd = cstream->private_data; 530 struct snd_soc_component *component; 531 int i, ret; 532 533 for_each_rtd_components(rtd, i, component) { 534 if (component->driver->compress_ops && 535 component->driver->compress_ops->get_params) { 536 ret = component->driver->compress_ops->get_params( 537 component, cstream, params); 538 return soc_component_ret(component, ret); 539 } 540 } 541 542 return 0; 543 } 544 EXPORT_SYMBOL_GPL(snd_soc_component_compr_get_params); 545 546 int snd_soc_component_compr_get_caps(struct snd_compr_stream *cstream, 547 struct snd_compr_caps *caps) 548 { 549 struct snd_soc_pcm_runtime *rtd = cstream->private_data; 550 struct snd_soc_component *component; 551 int i, ret = 0; 552 553 snd_soc_dpcm_mutex_lock(rtd); 554 555 for_each_rtd_components(rtd, i, component) { 556 if (component->driver->compress_ops && 557 component->driver->compress_ops->get_caps) { 558 ret = component->driver->compress_ops->get_caps( 559 component, cstream, caps); 560 break; 561 } 562 } 563 564 snd_soc_dpcm_mutex_unlock(rtd); 565 566 return soc_component_ret(component, ret); 567 } 568 EXPORT_SYMBOL_GPL(snd_soc_component_compr_get_caps); 569 570 int snd_soc_component_compr_get_codec_caps(struct snd_compr_stream *cstream, 571 struct snd_compr_codec_caps *codec) 572 { 573 struct snd_soc_pcm_runtime *rtd = cstream->private_data; 574 struct snd_soc_component *component; 575 int i, ret = 0; 576 577 snd_soc_dpcm_mutex_lock(rtd); 578 579 for_each_rtd_components(rtd, i, component) { 580 if (component->driver->compress_ops && 581 component->driver->compress_ops->get_codec_caps) { 582 ret = component->driver->compress_ops->get_codec_caps( 583 component, cstream, codec); 584 break; 585 } 586 } 587 588 snd_soc_dpcm_mutex_unlock(rtd); 589 590 return soc_component_ret(component, ret); 591 } 592 EXPORT_SYMBOL_GPL(snd_soc_component_compr_get_codec_caps); 593 594 int snd_soc_component_compr_ack(struct snd_compr_stream *cstream, size_t bytes) 595 { 596 struct snd_soc_pcm_runtime *rtd = cstream->private_data; 597 struct snd_soc_component *component; 598 int i, ret; 599 600 for_each_rtd_components(rtd, i, component) { 601 if (component->driver->compress_ops && 602 component->driver->compress_ops->ack) { 603 ret = component->driver->compress_ops->ack( 604 component, cstream, bytes); 605 if (ret < 0) 606 return soc_component_ret(component, ret); 607 } 608 } 609 610 return 0; 611 } 612 EXPORT_SYMBOL_GPL(snd_soc_component_compr_ack); 613 614 int snd_soc_component_compr_pointer(struct snd_compr_stream *cstream, 615 struct snd_compr_tstamp *tstamp) 616 { 617 struct snd_soc_pcm_runtime *rtd = cstream->private_data; 618 struct snd_soc_component *component; 619 int i, ret; 620 621 for_each_rtd_components(rtd, i, component) { 622 if (component->driver->compress_ops && 623 component->driver->compress_ops->pointer) { 624 ret = component->driver->compress_ops->pointer( 625 component, cstream, tstamp); 626 return soc_component_ret(component, ret); 627 } 628 } 629 630 return 0; 631 } 632 EXPORT_SYMBOL_GPL(snd_soc_component_compr_pointer); 633 634 int snd_soc_component_compr_copy(struct snd_compr_stream *cstream, 635 char __user *buf, size_t count) 636 { 637 struct snd_soc_pcm_runtime *rtd = cstream->private_data; 638 struct snd_soc_component *component; 639 int i, ret = 0; 640 641 snd_soc_dpcm_mutex_lock(rtd); 642 643 for_each_rtd_components(rtd, i, component) { 644 if (component->driver->compress_ops && 645 component->driver->compress_ops->copy) { 646 ret = component->driver->compress_ops->copy( 647 component, cstream, buf, count); 648 break; 649 } 650 } 651 652 snd_soc_dpcm_mutex_unlock(rtd); 653 654 return soc_component_ret(component, ret); 655 } 656 EXPORT_SYMBOL_GPL(snd_soc_component_compr_copy); 657 658 int snd_soc_component_compr_set_metadata(struct snd_compr_stream *cstream, 659 struct snd_compr_metadata *metadata) 660 { 661 struct snd_soc_pcm_runtime *rtd = cstream->private_data; 662 struct snd_soc_component *component; 663 int i, ret; 664 665 for_each_rtd_components(rtd, i, component) { 666 if (component->driver->compress_ops && 667 component->driver->compress_ops->set_metadata) { 668 ret = component->driver->compress_ops->set_metadata( 669 component, cstream, metadata); 670 if (ret < 0) 671 return soc_component_ret(component, ret); 672 } 673 } 674 675 return 0; 676 } 677 EXPORT_SYMBOL_GPL(snd_soc_component_compr_set_metadata); 678 679 int snd_soc_component_compr_get_metadata(struct snd_compr_stream *cstream, 680 struct snd_compr_metadata *metadata) 681 { 682 struct snd_soc_pcm_runtime *rtd = cstream->private_data; 683 struct snd_soc_component *component; 684 int i, ret; 685 686 for_each_rtd_components(rtd, i, component) { 687 if (component->driver->compress_ops && 688 component->driver->compress_ops->get_metadata) { 689 ret = component->driver->compress_ops->get_metadata( 690 component, cstream, metadata); 691 return soc_component_ret(component, ret); 692 } 693 } 694 695 return 0; 696 } 697 EXPORT_SYMBOL_GPL(snd_soc_component_compr_get_metadata); 698 699 static unsigned int soc_component_read_no_lock( 700 struct snd_soc_component *component, 701 unsigned int reg) 702 { 703 int ret; 704 unsigned int val = 0; 705 706 if (component->regmap) 707 ret = regmap_read(component->regmap, reg, &val); 708 else if (component->driver->read) { 709 ret = 0; 710 val = component->driver->read(component, reg); 711 } 712 else 713 ret = -EIO; 714 715 if (ret < 0) 716 return soc_component_ret_reg_rw(component, ret, reg); 717 718 return val; 719 } 720 721 /** 722 * snd_soc_component_read() - Read register value 723 * @component: Component to read from 724 * @reg: Register to read 725 * 726 * Return: read value 727 */ 728 unsigned int snd_soc_component_read(struct snd_soc_component *component, 729 unsigned int reg) 730 { 731 unsigned int val; 732 733 mutex_lock(&component->io_mutex); 734 val = soc_component_read_no_lock(component, reg); 735 mutex_unlock(&component->io_mutex); 736 737 return val; 738 } 739 EXPORT_SYMBOL_GPL(snd_soc_component_read); 740 741 static int soc_component_write_no_lock( 742 struct snd_soc_component *component, 743 unsigned int reg, unsigned int val) 744 { 745 int ret = -EIO; 746 747 if (component->regmap) 748 ret = regmap_write(component->regmap, reg, val); 749 else if (component->driver->write) 750 ret = component->driver->write(component, reg, val); 751 752 return soc_component_ret_reg_rw(component, ret, reg); 753 } 754 755 /** 756 * snd_soc_component_write() - Write register value 757 * @component: Component to write to 758 * @reg: Register to write 759 * @val: Value to write to the register 760 * 761 * Return: 0 on success, a negative error code otherwise. 762 */ 763 int snd_soc_component_write(struct snd_soc_component *component, 764 unsigned int reg, unsigned int val) 765 { 766 int ret; 767 768 mutex_lock(&component->io_mutex); 769 ret = soc_component_write_no_lock(component, reg, val); 770 mutex_unlock(&component->io_mutex); 771 772 return ret; 773 } 774 EXPORT_SYMBOL_GPL(snd_soc_component_write); 775 776 static int snd_soc_component_update_bits_legacy( 777 struct snd_soc_component *component, unsigned int reg, 778 unsigned int mask, unsigned int val, bool *change) 779 { 780 unsigned int old, new; 781 int ret = 0; 782 783 mutex_lock(&component->io_mutex); 784 785 old = soc_component_read_no_lock(component, reg); 786 787 new = (old & ~mask) | (val & mask); 788 *change = old != new; 789 if (*change) 790 ret = soc_component_write_no_lock(component, reg, new); 791 792 mutex_unlock(&component->io_mutex); 793 794 return soc_component_ret_reg_rw(component, ret, reg); 795 } 796 797 /** 798 * snd_soc_component_update_bits() - Perform read/modify/write cycle 799 * @component: Component to update 800 * @reg: Register to update 801 * @mask: Mask that specifies which bits to update 802 * @val: New value for the bits specified by mask 803 * 804 * Return: 1 if the operation was successful and the value of the register 805 * changed, 0 if the operation was successful, but the value did not change. 806 * Returns a negative error code otherwise. 807 */ 808 int snd_soc_component_update_bits(struct snd_soc_component *component, 809 unsigned int reg, unsigned int mask, unsigned int val) 810 { 811 bool change; 812 int ret; 813 814 if (component->regmap) 815 ret = regmap_update_bits_check(component->regmap, reg, mask, 816 val, &change); 817 else 818 ret = snd_soc_component_update_bits_legacy(component, reg, 819 mask, val, &change); 820 821 if (ret < 0) 822 return soc_component_ret_reg_rw(component, ret, reg); 823 return change; 824 } 825 EXPORT_SYMBOL_GPL(snd_soc_component_update_bits); 826 827 /** 828 * snd_soc_component_update_bits_async() - Perform asynchronous 829 * read/modify/write cycle 830 * @component: Component to update 831 * @reg: Register to update 832 * @mask: Mask that specifies which bits to update 833 * @val: New value for the bits specified by mask 834 * 835 * This function is similar to snd_soc_component_update_bits(), but the update 836 * operation is scheduled asynchronously. This means it may not be completed 837 * when the function returns. To make sure that all scheduled updates have been 838 * completed snd_soc_component_async_complete() must be called. 839 * 840 * Return: 1 if the operation was successful and the value of the register 841 * changed, 0 if the operation was successful, but the value did not change. 842 * Returns a negative error code otherwise. 843 */ 844 int snd_soc_component_update_bits_async(struct snd_soc_component *component, 845 unsigned int reg, unsigned int mask, unsigned int val) 846 { 847 bool change; 848 int ret; 849 850 if (component->regmap) 851 ret = regmap_update_bits_check_async(component->regmap, reg, 852 mask, val, &change); 853 else 854 ret = snd_soc_component_update_bits_legacy(component, reg, 855 mask, val, &change); 856 857 if (ret < 0) 858 return soc_component_ret_reg_rw(component, ret, reg); 859 return change; 860 } 861 EXPORT_SYMBOL_GPL(snd_soc_component_update_bits_async); 862 863 /** 864 * snd_soc_component_read_field() - Read register field value 865 * @component: Component to read from 866 * @reg: Register to read 867 * @mask: mask of the register field 868 * 869 * Return: read value of register field. 870 */ 871 unsigned int snd_soc_component_read_field(struct snd_soc_component *component, 872 unsigned int reg, unsigned int mask) 873 { 874 unsigned int val; 875 876 val = snd_soc_component_read(component, reg); 877 878 val = (val & mask) >> soc_component_field_shift(component, mask); 879 880 return val; 881 } 882 EXPORT_SYMBOL_GPL(snd_soc_component_read_field); 883 884 /** 885 * snd_soc_component_write_field() - write to register field 886 * @component: Component to write to 887 * @reg: Register to write 888 * @mask: mask of the register field to update 889 * @val: value of the field to write 890 * 891 * Return: 1 for change, otherwise 0. 892 */ 893 int snd_soc_component_write_field(struct snd_soc_component *component, 894 unsigned int reg, unsigned int mask, 895 unsigned int val) 896 { 897 898 val = (val << soc_component_field_shift(component, mask)) & mask; 899 900 return snd_soc_component_update_bits(component, reg, mask, val); 901 } 902 EXPORT_SYMBOL_GPL(snd_soc_component_write_field); 903 904 /** 905 * snd_soc_component_async_complete() - Ensure asynchronous I/O has completed 906 * @component: Component for which to wait 907 * 908 * This function blocks until all asynchronous I/O which has previously been 909 * scheduled using snd_soc_component_update_bits_async() has completed. 910 */ 911 void snd_soc_component_async_complete(struct snd_soc_component *component) 912 { 913 if (component->regmap) 914 regmap_async_complete(component->regmap); 915 } 916 EXPORT_SYMBOL_GPL(snd_soc_component_async_complete); 917 918 /** 919 * snd_soc_component_test_bits - Test register for change 920 * @component: component 921 * @reg: Register to test 922 * @mask: Mask that specifies which bits to test 923 * @value: Value to test against 924 * 925 * Tests a register with a new value and checks if the new value is 926 * different from the old value. 927 * 928 * Return: 1 for change, otherwise 0. 929 */ 930 int snd_soc_component_test_bits(struct snd_soc_component *component, 931 unsigned int reg, unsigned int mask, unsigned int value) 932 { 933 unsigned int old, new; 934 935 old = snd_soc_component_read(component, reg); 936 new = (old & ~mask) | value; 937 return old != new; 938 } 939 EXPORT_SYMBOL_GPL(snd_soc_component_test_bits); 940 941 int snd_soc_pcm_component_pointer(struct snd_pcm_substream *substream) 942 { 943 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream); 944 struct snd_soc_component *component; 945 int i; 946 947 /* FIXME: use 1st pointer */ 948 for_each_rtd_components(rtd, i, component) 949 if (component->driver->pointer) 950 return component->driver->pointer(component, substream); 951 952 return 0; 953 } 954 955 static bool snd_soc_component_is_codec_on_rtd(struct snd_soc_pcm_runtime *rtd, 956 struct snd_soc_component *component) 957 { 958 struct snd_soc_dai *dai; 959 int i; 960 961 for_each_rtd_codec_dais(rtd, i, dai) { 962 if (dai->component == component) 963 return true; 964 } 965 966 return false; 967 } 968 969 void snd_soc_pcm_component_delay(struct snd_pcm_substream *substream, 970 snd_pcm_sframes_t *cpu_delay, 971 snd_pcm_sframes_t *codec_delay) 972 { 973 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream); 974 struct snd_soc_component *component; 975 snd_pcm_sframes_t delay; 976 int i; 977 978 /* 979 * We're looking for the delay through the full audio path so it needs to 980 * be the maximum of the Components doing transmit and the maximum of the 981 * Components doing receive (ie, all CPUs and all CODECs) rather than 982 * just the maximum of all Components. 983 */ 984 for_each_rtd_components(rtd, i, component) { 985 if (!component->driver->delay) 986 continue; 987 988 delay = component->driver->delay(component, substream); 989 990 if (snd_soc_component_is_codec_on_rtd(rtd, component)) 991 *codec_delay = max(*codec_delay, delay); 992 else 993 *cpu_delay = max(*cpu_delay, delay); 994 } 995 } 996 997 int snd_soc_pcm_component_ioctl(struct snd_pcm_substream *substream, 998 unsigned int cmd, void *arg) 999 { 1000 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream); 1001 struct snd_soc_component *component; 1002 int i; 1003 1004 /* FIXME: use 1st ioctl */ 1005 for_each_rtd_components(rtd, i, component) 1006 if (component->driver->ioctl) 1007 return soc_component_ret( 1008 component, 1009 component->driver->ioctl(component, 1010 substream, cmd, arg)); 1011 1012 return snd_pcm_lib_ioctl(substream, cmd, arg); 1013 } 1014 1015 int snd_soc_pcm_component_sync_stop(struct snd_pcm_substream *substream) 1016 { 1017 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream); 1018 struct snd_soc_component *component; 1019 int i, ret; 1020 1021 for_each_rtd_components(rtd, i, component) { 1022 if (component->driver->sync_stop) { 1023 ret = component->driver->sync_stop(component, 1024 substream); 1025 if (ret < 0) 1026 return soc_component_ret(component, ret); 1027 } 1028 } 1029 1030 return 0; 1031 } 1032 1033 int snd_soc_pcm_component_copy_user(struct snd_pcm_substream *substream, 1034 int channel, unsigned long pos, 1035 void __user *buf, unsigned long bytes) 1036 { 1037 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream); 1038 struct snd_soc_component *component; 1039 int i; 1040 1041 /* FIXME. it returns 1st copy now */ 1042 for_each_rtd_components(rtd, i, component) 1043 if (component->driver->copy_user) 1044 return soc_component_ret( 1045 component, 1046 component->driver->copy_user( 1047 component, substream, channel, 1048 pos, buf, bytes)); 1049 1050 return -EINVAL; 1051 } 1052 1053 struct page *snd_soc_pcm_component_page(struct snd_pcm_substream *substream, 1054 unsigned long offset) 1055 { 1056 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream); 1057 struct snd_soc_component *component; 1058 struct page *page; 1059 int i; 1060 1061 /* FIXME. it returns 1st page now */ 1062 for_each_rtd_components(rtd, i, component) { 1063 if (component->driver->page) { 1064 page = component->driver->page(component, 1065 substream, offset); 1066 if (page) 1067 return page; 1068 } 1069 } 1070 1071 return NULL; 1072 } 1073 1074 int snd_soc_pcm_component_mmap(struct snd_pcm_substream *substream, 1075 struct vm_area_struct *vma) 1076 { 1077 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream); 1078 struct snd_soc_component *component; 1079 int i; 1080 1081 /* FIXME. it returns 1st mmap now */ 1082 for_each_rtd_components(rtd, i, component) 1083 if (component->driver->mmap) 1084 return soc_component_ret( 1085 component, 1086 component->driver->mmap(component, 1087 substream, vma)); 1088 1089 return -EINVAL; 1090 } 1091 1092 int snd_soc_pcm_component_new(struct snd_soc_pcm_runtime *rtd) 1093 { 1094 struct snd_soc_component *component; 1095 int ret; 1096 int i; 1097 1098 for_each_rtd_components(rtd, i, component) { 1099 if (component->driver->pcm_construct) { 1100 ret = component->driver->pcm_construct(component, rtd); 1101 if (ret < 0) 1102 return soc_component_ret(component, ret); 1103 } 1104 } 1105 1106 return 0; 1107 } 1108 1109 void snd_soc_pcm_component_free(struct snd_soc_pcm_runtime *rtd) 1110 { 1111 struct snd_soc_component *component; 1112 int i; 1113 1114 if (!rtd->pcm) 1115 return; 1116 1117 for_each_rtd_components(rtd, i, component) 1118 if (component->driver->pcm_destruct) 1119 component->driver->pcm_destruct(component, rtd->pcm); 1120 } 1121 1122 int snd_soc_pcm_component_prepare(struct snd_pcm_substream *substream) 1123 { 1124 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream); 1125 struct snd_soc_component *component; 1126 int i, ret; 1127 1128 for_each_rtd_components(rtd, i, component) { 1129 if (component->driver->prepare) { 1130 ret = component->driver->prepare(component, substream); 1131 if (ret < 0) 1132 return soc_component_ret(component, ret); 1133 } 1134 } 1135 1136 return 0; 1137 } 1138 1139 int snd_soc_pcm_component_hw_params(struct snd_pcm_substream *substream, 1140 struct snd_pcm_hw_params *params) 1141 { 1142 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream); 1143 struct snd_soc_component *component; 1144 int i, ret; 1145 1146 for_each_rtd_components(rtd, i, component) { 1147 if (component->driver->hw_params) { 1148 ret = component->driver->hw_params(component, 1149 substream, params); 1150 if (ret < 0) 1151 return soc_component_ret(component, ret); 1152 } 1153 /* mark substream if succeeded */ 1154 soc_component_mark_push(component, substream, hw_params); 1155 } 1156 1157 return 0; 1158 } 1159 1160 void snd_soc_pcm_component_hw_free(struct snd_pcm_substream *substream, 1161 int rollback) 1162 { 1163 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream); 1164 struct snd_soc_component *component; 1165 int i, ret; 1166 1167 for_each_rtd_components(rtd, i, component) { 1168 if (rollback && !soc_component_mark_match(component, substream, hw_params)) 1169 continue; 1170 1171 if (component->driver->hw_free) { 1172 ret = component->driver->hw_free(component, substream); 1173 if (ret < 0) 1174 soc_component_ret(component, ret); 1175 } 1176 1177 /* remove marked substream */ 1178 soc_component_mark_pop(component, substream, hw_params); 1179 } 1180 } 1181 1182 static int soc_component_trigger(struct snd_soc_component *component, 1183 struct snd_pcm_substream *substream, 1184 int cmd) 1185 { 1186 int ret = 0; 1187 1188 if (component->driver->trigger) 1189 ret = component->driver->trigger(component, substream, cmd); 1190 1191 return soc_component_ret(component, ret); 1192 } 1193 1194 int snd_soc_pcm_component_trigger(struct snd_pcm_substream *substream, 1195 int cmd, int rollback) 1196 { 1197 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream); 1198 struct snd_soc_component *component; 1199 int i, r, ret = 0; 1200 1201 switch (cmd) { 1202 case SNDRV_PCM_TRIGGER_START: 1203 case SNDRV_PCM_TRIGGER_RESUME: 1204 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: 1205 for_each_rtd_components(rtd, i, component) { 1206 ret = soc_component_trigger(component, substream, cmd); 1207 if (ret < 0) 1208 break; 1209 soc_component_mark_push(component, substream, trigger); 1210 } 1211 break; 1212 case SNDRV_PCM_TRIGGER_STOP: 1213 case SNDRV_PCM_TRIGGER_SUSPEND: 1214 case SNDRV_PCM_TRIGGER_PAUSE_PUSH: 1215 for_each_rtd_components(rtd, i, component) { 1216 if (rollback && !soc_component_mark_match(component, substream, trigger)) 1217 continue; 1218 1219 r = soc_component_trigger(component, substream, cmd); 1220 if (r < 0) 1221 ret = r; /* use last ret */ 1222 soc_component_mark_pop(component, substream, trigger); 1223 } 1224 } 1225 1226 return ret; 1227 } 1228 1229 int snd_soc_pcm_component_pm_runtime_get(struct snd_soc_pcm_runtime *rtd, 1230 void *stream) 1231 { 1232 struct snd_soc_component *component; 1233 int i; 1234 1235 for_each_rtd_components(rtd, i, component) { 1236 int ret = pm_runtime_get_sync(component->dev); 1237 if (ret < 0 && ret != -EACCES) { 1238 pm_runtime_put_noidle(component->dev); 1239 return soc_component_ret(component, ret); 1240 } 1241 /* mark stream if succeeded */ 1242 soc_component_mark_push(component, stream, pm); 1243 } 1244 1245 return 0; 1246 } 1247 1248 void snd_soc_pcm_component_pm_runtime_put(struct snd_soc_pcm_runtime *rtd, 1249 void *stream, int rollback) 1250 { 1251 struct snd_soc_component *component; 1252 int i; 1253 1254 for_each_rtd_components(rtd, i, component) { 1255 if (rollback && !soc_component_mark_match(component, stream, pm)) 1256 continue; 1257 1258 pm_runtime_mark_last_busy(component->dev); 1259 pm_runtime_put_autosuspend(component->dev); 1260 1261 /* remove marked stream */ 1262 soc_component_mark_pop(component, stream, pm); 1263 } 1264 } 1265 1266 int snd_soc_pcm_component_ack(struct snd_pcm_substream *substream) 1267 { 1268 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream); 1269 struct snd_soc_component *component; 1270 int i; 1271 1272 /* FIXME: use 1st pointer */ 1273 for_each_rtd_components(rtd, i, component) 1274 if (component->driver->ack) 1275 return component->driver->ack(component, substream); 1276 1277 return 0; 1278 } 1279