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 #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 }