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