sound/soc/soc-component.c

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