sound/soc/soc-component.c

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