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