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