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