sound/soc/soc-core.c

   1 /*
   2  * soc-core.c  --  ALSA SoC Audio Layer
   3  *
   4  * Copyright 2005 Wolfson Microelectronics PLC.
   5  * Copyright 2005 Openedhand Ltd.
   6  * Copyright (C) 2010 Slimlogic Ltd.
   7  * Copyright (C) 2010 Texas Instruments Inc.
   8  *
   9  * Author: Liam Girdwood <lrg@slimlogic.co.uk>
  10  *         with code, comments and ideas from :-
  11  *         Richard Purdie <richard@openedhand.com>
  12  *
  13  *  This program is free software; you can redistribute  it and/or modify it
  14  *  under  the terms of  the GNU General  Public License as published by the
  15  *  Free Software Foundation;  either version 2 of the  License, or (at your
  16  *  option) any later version.
  17  *
  18  *  TODO:
  19  *   o Add hw rules to enforce rates, etc.
  20  *   o More testing with other codecs/machines.
  21  *   o Add more codecs and platforms to ensure good API coverage.
  22  *   o Support TDM on PCM and I2S
  23  */
  24
  25 #include <linux/module.h>
  26 #include <linux/moduleparam.h>
  27 #include <linux/init.h>
  28 #include <linux/delay.h>
  29 #include <linux/pm.h>
  30 #include <linux/bitops.h>
  31 #include <linux/debugfs.h>
  32 #include <linux/platform_device.h>
  33 #include <linux/pinctrl/consumer.h>
  34 #include <linux/ctype.h>
  35 #include <linux/slab.h>
  36 #include <linux/of.h>
  37 #include <linux/dmi.h>
  38 #include <sound/core.h>
  39 #include <sound/jack.h>
  40 #include <sound/pcm.h>
  41 #include <sound/pcm_params.h>
  42 #include <sound/soc.h>
  43 #include <sound/soc-dpcm.h>
  44 #include <sound/soc-topology.h>
  45 #include <sound/initval.h>
  46
  47 #define CREATE_TRACE_POINTS
  48 #include <trace/events/asoc.h>
  49
  50 #define NAME_SIZE       32
  51
  52 #ifdef CONFIG_DEBUG_FS
  53 struct dentry *snd_soc_debugfs_root;
  54 EXPORT_SYMBOL_GPL(snd_soc_debugfs_root);
  55 #endif
  56
  57 static DEFINE_MUTEX(client_mutex);
  58 static LIST_HEAD(platform_list);
  59 static LIST_HEAD(codec_list);
  60 static LIST_HEAD(component_list);
  61
  62 /*
  63  * This is a timeout to do a DAPM powerdown after a stream is closed().
  64  * It can be used to eliminate pops between different playback streams, e.g.
  65  * between two audio tracks.
  66  */
  67 static int pmdown_time = 5000;
  68 module_param(pmdown_time, int, 0);
  69 MODULE_PARM_DESC(pmdown_time, "DAPM stream powerdown time (msecs)");
  70
  71 /* If a DMI filed contain strings in this blacklist (e.g.
  72  * "Type2 - Board Manufacturer" or  "Type1 - TBD by OEM"), it will be taken
  73  * as invalid and dropped when setting the card long name from DMI info.
  74  */
  75 static const char * const dmi_blacklist[] = {
  76         "To be filled by OEM",
  77         "TBD by OEM",
  78         "Default String",
  79         "Board Manufacturer",
  80         "Board Vendor Name",
  81         "Board Product Name",
  82         NULL,   /* terminator */
  83 };
  84
  85 /* returns the minimum number of bytes needed to represent
  86  * a particular given value */
  87 static int min_bytes_needed(unsigned long val)
  88 {
  89         int c = 0;
  90         int i;
  91
  92         for (i = (sizeof val * 8) - 1; i >= 0; --i, ++c)
  93                 if (val & (1UL << i))
  94                         break;
  95         c = (sizeof val * 8) - c;
  96         if (!c || (c % 8))
  97                 c = (c + 8) / 8;
  98         else
  99                 c /= 8;
 100         return c;
 101 }
 102
 103 /* fill buf which is 'len' bytes with a formatted
 104  * string of the form 'reg: value\n' */
 105 static int format_register_str(struct snd_soc_codec *codec,
 106                                unsigned int reg, char *buf, size_t len)
 107 {
 108         int wordsize = min_bytes_needed(codec->driver->reg_cache_size) * 2;
 109         int regsize = codec->driver->reg_word_size * 2;
 110         int ret;
 111
 112         /* +2 for ': ' and + 1 for '\n' */
 113         if (wordsize + regsize + 2 + 1 != len)
 114                 return -EINVAL;
 115
 116         sprintf(buf, "%.*x: ", wordsize, reg);
 117         buf += wordsize + 2;
 118
 119         ret = snd_soc_read(codec, reg);
 120         if (ret < 0)
 121                 memset(buf, 'X', regsize);
 122         else
 123                 sprintf(buf, "%.*x", regsize, ret);
 124         buf[regsize] = '\n';
 125         /* no NUL-termination needed */
 126         return 0;
 127 }
 128
 129 /* codec register dump */
 130 static ssize_t soc_codec_reg_show(struct snd_soc_codec *codec, char *buf,
 131                                   size_t count, loff_t pos)
 132 {
 133         int i, step = 1;
 134         int wordsize, regsize;
 135         int len;
 136         size_t total = 0;
 137         loff_t p = 0;
 138
 139         wordsize = min_bytes_needed(codec->driver->reg_cache_size) * 2;
 140         regsize = codec->driver->reg_word_size * 2;
 141
 142         len = wordsize + regsize + 2 + 1;
 143
 144         if (!codec->driver->reg_cache_size)
 145                 return 0;
 146
 147         if (codec->driver->reg_cache_step)
 148                 step = codec->driver->reg_cache_step;
 149
 150         for (i = 0; i < codec->driver->reg_cache_size; i += step) {
 151                 /* only support larger than PAGE_SIZE bytes debugfs
 152                  * entries for the default case */
 153                 if (p >= pos) {
 154                         if (total + len >= count - 1)
 155                                 break;
 156                         format_register_str(codec, i, buf + total, len);
 157                         total += len;
 158                 }
 159                 p += len;
 160         }
 161
 162         total = min(total, count - 1);
 163
 164         return total;
 165 }
 166
 167 static ssize_t codec_reg_show(struct device *dev,
 168         struct device_attribute *attr, char *buf)
 169 {
 170         struct snd_soc_pcm_runtime *rtd = dev_get_drvdata(dev);
 171
 172         return soc_codec_reg_show(rtd->codec, buf, PAGE_SIZE, 0);
 173 }
 174
 175 static DEVICE_ATTR(codec_reg, 0444, codec_reg_show, NULL);
 176
 177 static ssize_t pmdown_time_show(struct device *dev,
 178                                 struct device_attribute *attr, char *buf)
 179 {
 180         struct snd_soc_pcm_runtime *rtd = dev_get_drvdata(dev);
 181
 182         return sprintf(buf, "%ld\n", rtd->pmdown_time);
 183 }
 184
 185 static ssize_t pmdown_time_set(struct device *dev,
 186                                struct device_attribute *attr,
 187                                const char *buf, size_t count)
 188 {
 189         struct snd_soc_pcm_runtime *rtd = dev_get_drvdata(dev);
 190         int ret;
 191
 192         ret = kstrtol(buf, 10, &rtd->pmdown_time);
 193         if (ret)
 194                 return ret;
 195
 196         return count;
 197 }
 198
 199 static DEVICE_ATTR(pmdown_time, 0644, pmdown_time_show, pmdown_time_set);
 200
 201 static struct attribute *soc_dev_attrs[] = {
 202         &dev_attr_codec_reg.attr,
 203         &dev_attr_pmdown_time.attr,
 204         NULL
 205 };
 206
 207 static umode_t soc_dev_attr_is_visible(struct kobject *kobj,
 208                                        struct attribute *attr, int idx)
 209 {
 210         struct device *dev = kobj_to_dev(kobj);
 211         struct snd_soc_pcm_runtime *rtd = dev_get_drvdata(dev);
 212
 213         if (attr == &dev_attr_pmdown_time.attr)
 214                 return attr->mode; /* always visible */
 215         return rtd->codec ? attr->mode : 0; /* enabled only with codec */
 216 }
 217
 218 static const struct attribute_group soc_dapm_dev_group = {
 219         .attrs = soc_dapm_dev_attrs,
 220         .is_visible = soc_dev_attr_is_visible,
 221 };
 222
 223 static const struct attribute_group soc_dev_roup = {
 224         .attrs = soc_dev_attrs,
 225         .is_visible = soc_dev_attr_is_visible,
 226 };
 227
 228 static const struct attribute_group *soc_dev_attr_groups[] = {
 229         &soc_dapm_dev_group,
 230         &soc_dev_roup,
 231         NULL
 232 };
 233
 234 #ifdef CONFIG_DEBUG_FS
 235 static ssize_t codec_reg_read_file(struct file *file, char __user *user_buf,
 236                                    size_t count, loff_t *ppos)
 237 {
 238         ssize_t ret;
 239         struct snd_soc_codec *codec = file->private_data;
 240         char *buf;
 241
 242         if (*ppos < 0 || !count)
 243                 return -EINVAL;
 244
 245         buf = kmalloc(count, GFP_KERNEL);
 246         if (!buf)
 247                 return -ENOMEM;
 248
 249         ret = soc_codec_reg_show(codec, buf, count, *ppos);
 250         if (ret >= 0) {
 251                 if (copy_to_user(user_buf, buf, ret)) {
 252                         kfree(buf);
 253                         return -EFAULT;
 254                 }
 255                 *ppos += ret;
 256         }
 257
 258         kfree(buf);
 259         return ret;
 260 }
 261
 262 static ssize_t codec_reg_write_file(struct file *file,
 263                 const char __user *user_buf, size_t count, loff_t *ppos)
 264 {
 265         char buf[32];
 266         size_t buf_size;
 267         char *start = buf;
 268         unsigned long reg, value;
 269         struct snd_soc_codec *codec = file->private_data;
 270         int ret;
 271
 272         buf_size = min(count, (sizeof(buf)-1));
 273         if (copy_from_user(buf, user_buf, buf_size))
 274                 return -EFAULT;
 275         buf[buf_size] = 0;
 276
 277         while (*start == ' ')
 278                 start++;
 279         reg = simple_strtoul(start, &start, 16);
 280         while (*start == ' ')
 281                 start++;
 282         ret = kstrtoul(start, 16, &value);
 283         if (ret)
 284                 return ret;
 285
 286         /* Userspace has been fiddling around behind the kernel's back */
 287         add_taint(TAINT_USER, LOCKDEP_NOW_UNRELIABLE);
 288
 289         snd_soc_write(codec, reg, value);
 290         return buf_size;
 291 }
 292
 293 static const struct file_operations codec_reg_fops = {
 294         .open = simple_open,
 295         .read = codec_reg_read_file,
 296         .write = codec_reg_write_file,
 297         .llseek = default_llseek,
 298 };
 299
 300 static void soc_init_component_debugfs(struct snd_soc_component *component)
 301 {
 302         if (!component->card->debugfs_card_root)
 303                 return;
 304
 305         if (component->debugfs_prefix) {
 306                 char *name;
 307
 308                 name = kasprintf(GFP_KERNEL, "%s:%s",
 309                         component->debugfs_prefix, component->name);
 310                 if (name) {
 311                         component->debugfs_root = debugfs_create_dir(name,
 312                                 component->card->debugfs_card_root);
 313                         kfree(name);
 314                 }
 315         } else {
 316                 component->debugfs_root = debugfs_create_dir(component->name,
 317                                 component->card->debugfs_card_root);
 318         }
 319
 320         if (!component->debugfs_root) {
 321                 dev_warn(component->dev,
 322                         "ASoC: Failed to create component debugfs directory\n");
 323                 return;
 324         }
 325
 326         snd_soc_dapm_debugfs_init(snd_soc_component_get_dapm(component),
 327                 component->debugfs_root);
 328
 329         if (component->init_debugfs)
 330                 component->init_debugfs(component);
 331 }
 332
 333 static void soc_cleanup_component_debugfs(struct snd_soc_component *component)
 334 {
 335         debugfs_remove_recursive(component->debugfs_root);
 336 }
 337
 338 static void soc_init_codec_debugfs(struct snd_soc_component *component)
 339 {
 340         struct snd_soc_codec *codec = snd_soc_component_to_codec(component);
 341
 342         codec->debugfs_reg = debugfs_create_file("codec_reg", 0644,
 343                                                  codec->component.debugfs_root,
 344                                                  codec, &codec_reg_fops);
 345         if (!codec->debugfs_reg)
 346                 dev_warn(codec->dev,
 347                         "ASoC: Failed to create codec register debugfs file\n");
 348 }
 349
 350 static ssize_t codec_list_read_file(struct file *file, char __user *user_buf,
 351                                     size_t count, loff_t *ppos)
 352 {
 353         char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
 354         ssize_t len, ret = 0;
 355         struct snd_soc_codec *codec;
 356
 357         if (!buf)
 358                 return -ENOMEM;
 359
 360         mutex_lock(&client_mutex);
 361
 362         list_for_each_entry(codec, &codec_list, list) {
 363                 len = snprintf(buf + ret, PAGE_SIZE - ret, "%s\n",
 364                                codec->component.name);
 365                 if (len >= 0)
 366                         ret += len;
 367                 if (ret > PAGE_SIZE) {
 368                         ret = PAGE_SIZE;
 369                         break;
 370                 }
 371         }
 372
 373         mutex_unlock(&client_mutex);
 374
 375         if (ret >= 0)
 376                 ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
 377
 378         kfree(buf);
 379
 380         return ret;
 381 }
 382
 383 static const struct file_operations codec_list_fops = {
 384         .read = codec_list_read_file,
 385         .llseek = default_llseek,/* read accesses f_pos */
 386 };
 387
 388 static ssize_t dai_list_read_file(struct file *file, char __user *user_buf,
 389                                   size_t count, loff_t *ppos)
 390 {
 391         char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
 392         ssize_t len, ret = 0;
 393         struct snd_soc_component *component;
 394         struct snd_soc_dai *dai;
 395
 396         if (!buf)
 397                 return -ENOMEM;
 398
 399         mutex_lock(&client_mutex);
 400
 401         list_for_each_entry(component, &component_list, list) {
 402                 list_for_each_entry(dai, &component->dai_list, list) {
 403                         len = snprintf(buf + ret, PAGE_SIZE - ret, "%s\n",
 404                                 dai->name);
 405                         if (len >= 0)
 406                                 ret += len;
 407                         if (ret > PAGE_SIZE) {
 408                                 ret = PAGE_SIZE;
 409                                 break;
 410                         }
 411                 }
 412         }
 413
 414         mutex_unlock(&client_mutex);
 415
 416         ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
 417
 418         kfree(buf);
 419
 420         return ret;
 421 }
 422
 423 static const struct file_operations dai_list_fops = {
 424         .read = dai_list_read_file,
 425         .llseek = default_llseek,/* read accesses f_pos */
 426 };
 427
 428 static ssize_t platform_list_read_file(struct file *file,
 429                                        char __user *user_buf,
 430                                        size_t count, loff_t *ppos)
 431 {
 432         char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
 433         ssize_t len, ret = 0;
 434         struct snd_soc_platform *platform;
 435
 436         if (!buf)
 437                 return -ENOMEM;
 438
 439         mutex_lock(&client_mutex);
 440
 441         list_for_each_entry(platform, &platform_list, list) {
 442                 len = snprintf(buf + ret, PAGE_SIZE - ret, "%s\n",
 443                                platform->component.name);
 444                 if (len >= 0)
 445                         ret += len;
 446                 if (ret > PAGE_SIZE) {
 447                         ret = PAGE_SIZE;
 448                         break;
 449                 }
 450         }
 451
 452         mutex_unlock(&client_mutex);
 453
 454         ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
 455
 456         kfree(buf);
 457
 458         return ret;
 459 }
 460
 461 static const struct file_operations platform_list_fops = {
 462         .read = platform_list_read_file,
 463         .llseek = default_llseek,/* read accesses f_pos */
 464 };
 465
 466 static void soc_init_card_debugfs(struct snd_soc_card *card)
 467 {
 468         if (!snd_soc_debugfs_root)
 469                 return;
 470
 471         card->debugfs_card_root = debugfs_create_dir(card->name,
 472                                                      snd_soc_debugfs_root);
 473         if (!card->debugfs_card_root) {
 474                 dev_warn(card->dev,
 475                          "ASoC: Failed to create card debugfs directory\n");
 476                 return;
 477         }
 478
 479         card->debugfs_pop_time = debugfs_create_u32("dapm_pop_time", 0644,
 480                                                     card->debugfs_card_root,
 481                                                     &card->pop_time);
 482         if (!card->debugfs_pop_time)
 483                 dev_warn(card->dev,
 484                        "ASoC: Failed to create pop time debugfs file\n");
 485 }
 486
 487 static void soc_cleanup_card_debugfs(struct snd_soc_card *card)
 488 {
 489         debugfs_remove_recursive(card->debugfs_card_root);
 490 }
 491
 492
 493 static void snd_soc_debugfs_init(void)
 494 {
 495         snd_soc_debugfs_root = debugfs_create_dir("asoc", NULL);
 496         if (IS_ERR(snd_soc_debugfs_root) || !snd_soc_debugfs_root) {
 497                 pr_warn("ASoC: Failed to create debugfs directory\n");
 498                 snd_soc_debugfs_root = NULL;
 499                 return;
 500         }
 501
 502         if (!debugfs_create_file("codecs", 0444, snd_soc_debugfs_root, NULL,
 503                                  &codec_list_fops))
 504                 pr_warn("ASoC: Failed to create CODEC list debugfs file\n");
 505
 506         if (!debugfs_create_file("dais", 0444, snd_soc_debugfs_root, NULL,
 507                                  &dai_list_fops))
 508                 pr_warn("ASoC: Failed to create DAI list debugfs file\n");
 509
 510         if (!debugfs_create_file("platforms", 0444, snd_soc_debugfs_root, NULL,
 511                                  &platform_list_fops))
 512                 pr_warn("ASoC: Failed to create platform list debugfs file\n");
 513 }
 514
 515 static void snd_soc_debugfs_exit(void)
 516 {
 517         debugfs_remove_recursive(snd_soc_debugfs_root);
 518 }
 519
 520 #else
 521
 522 #define soc_init_codec_debugfs NULL
 523
 524 static inline void soc_init_component_debugfs(
 525         struct snd_soc_component *component)
 526 {
 527 }
 528
 529 static inline void soc_cleanup_component_debugfs(
 530         struct snd_soc_component *component)
 531 {
 532 }
 533
 534 static inline void soc_init_card_debugfs(struct snd_soc_card *card)
 535 {
 536 }
 537
 538 static inline void soc_cleanup_card_debugfs(struct snd_soc_card *card)
 539 {
 540 }
 541
 542 static inline void snd_soc_debugfs_init(void)
 543 {
 544 }
 545
 546 static inline void snd_soc_debugfs_exit(void)
 547 {
 548 }
 549
 550 #endif
 551
 552 struct snd_pcm_substream *snd_soc_get_dai_substream(struct snd_soc_card *card,
 553                 const char *dai_link, int stream)
 554 {
 555         struct snd_soc_pcm_runtime *rtd;
 556
 557         list_for_each_entry(rtd, &card->rtd_list, list) {
 558                 if (rtd->dai_link->no_pcm &&
 559                         !strcmp(rtd->dai_link->name, dai_link))
 560                         return rtd->pcm->streams[stream].substream;
 561         }
 562         dev_dbg(card->dev, "ASoC: failed to find dai link %s\n", dai_link);
 563         return NULL;
 564 }
 565 EXPORT_SYMBOL_GPL(snd_soc_get_dai_substream);
 566
 567 static struct snd_soc_pcm_runtime *soc_new_pcm_runtime(
 568         struct snd_soc_card *card, struct snd_soc_dai_link *dai_link)
 569 {
 570         struct snd_soc_pcm_runtime *rtd;
 571
 572         rtd = kzalloc(sizeof(struct snd_soc_pcm_runtime), GFP_KERNEL);
 573         if (!rtd)
 574                 return NULL;
 575
 576         rtd->card = card;
 577         rtd->dai_link = dai_link;
 578         rtd->codec_dais = kzalloc(sizeof(struct snd_soc_dai *) *
 579                                         dai_link->num_codecs,
 580                                         GFP_KERNEL);
 581         if (!rtd->codec_dais) {
 582                 kfree(rtd);
 583                 return NULL;
 584         }
 585
 586         return rtd;
 587 }
 588
 589 static void soc_free_pcm_runtime(struct snd_soc_pcm_runtime *rtd)
 590 {
 591         if (rtd && rtd->codec_dais)
 592                 kfree(rtd->codec_dais);
 593         kfree(rtd);
 594 }
 595
 596 static void soc_add_pcm_runtime(struct snd_soc_card *card,
 597                 struct snd_soc_pcm_runtime *rtd)
 598 {
 599         list_add_tail(&rtd->list, &card->rtd_list);
 600         rtd->num = card->num_rtd;
 601         card->num_rtd++;
 602 }
 603
 604 static void soc_remove_pcm_runtimes(struct snd_soc_card *card)
 605 {
 606         struct snd_soc_pcm_runtime *rtd, *_rtd;
 607
 608         list_for_each_entry_safe(rtd, _rtd, &card->rtd_list, list) {
 609                 list_del(&rtd->list);
 610                 soc_free_pcm_runtime(rtd);
 611         }
 612
 613         card->num_rtd = 0;
 614 }
 615
 616 struct snd_soc_pcm_runtime *snd_soc_get_pcm_runtime(struct snd_soc_card *card,
 617                 const char *dai_link)
 618 {
 619         struct snd_soc_pcm_runtime *rtd;
 620
 621         list_for_each_entry(rtd, &card->rtd_list, list) {
 622                 if (!strcmp(rtd->dai_link->name, dai_link))
 623                         return rtd;
 624         }
 625         dev_dbg(card->dev, "ASoC: failed to find rtd %s\n", dai_link);
 626         return NULL;
 627 }
 628 EXPORT_SYMBOL_GPL(snd_soc_get_pcm_runtime);
 629
 630 static void codec2codec_close_delayed_work(struct work_struct *work)
 631 {
 632         /* Currently nothing to do for c2c links
 633          * Since c2c links are internal nodes in the DAPM graph and
 634          * don't interface with the outside world or application layer
 635          * we don't have to do any special handling on close.
 636          */
 637 }
 638
 639 #ifdef CONFIG_PM_SLEEP
 640 /* powers down audio subsystem for suspend */
 641 int snd_soc_suspend(struct device *dev)
 642 {
 643         struct snd_soc_card *card = dev_get_drvdata(dev);
 644         struct snd_soc_component *component;
 645         struct snd_soc_pcm_runtime *rtd;
 646         int i;
 647
 648         /* If the card is not initialized yet there is nothing to do */
 649         if (!card->instantiated)
 650                 return 0;
 651
 652         /* Due to the resume being scheduled into a workqueue we could
 653         * suspend before that's finished - wait for it to complete.
 654          */
 655         snd_power_lock(card->snd_card);
 656         snd_power_wait(card->snd_card, SNDRV_CTL_POWER_D0);
 657         snd_power_unlock(card->snd_card);
 658
 659         /* we're going to block userspace touching us until resume completes */
 660         snd_power_change_state(card->snd_card, SNDRV_CTL_POWER_D3hot);
 661
 662         /* mute any active DACs */
 663         list_for_each_entry(rtd, &card->rtd_list, list) {
 664
 665                 if (rtd->dai_link->ignore_suspend)
 666                         continue;
 667
 668                 for (i = 0; i < rtd->num_codecs; i++) {
 669                         struct snd_soc_dai *dai = rtd->codec_dais[i];
 670                         struct snd_soc_dai_driver *drv = dai->driver;
 671
 672                         if (drv->ops->digital_mute && dai->playback_active)
 673                                 drv->ops->digital_mute(dai, 1);
 674                 }
 675         }
 676
 677         /* suspend all pcms */
 678         list_for_each_entry(rtd, &card->rtd_list, list) {
 679                 if (rtd->dai_link->ignore_suspend)
 680                         continue;
 681
 682                 snd_pcm_suspend_all(rtd->pcm);
 683         }
 684
 685         if (card->suspend_pre)
 686                 card->suspend_pre(card);
 687
 688         list_for_each_entry(rtd, &card->rtd_list, list) {
 689                 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
 690
 691                 if (rtd->dai_link->ignore_suspend)
 692                         continue;
 693
 694                 if (cpu_dai->driver->suspend && !cpu_dai->driver->bus_control)
 695                         cpu_dai->driver->suspend(cpu_dai);
 696         }
 697
 698         /* close any waiting streams */
 699         list_for_each_entry(rtd, &card->rtd_list, list)
 700                 flush_delayed_work(&rtd->delayed_work);
 701
 702         list_for_each_entry(rtd, &card->rtd_list, list) {
 703
 704                 if (rtd->dai_link->ignore_suspend)
 705                         continue;
 706
 707                 snd_soc_dapm_stream_event(rtd,
 708                                           SNDRV_PCM_STREAM_PLAYBACK,
 709                                           SND_SOC_DAPM_STREAM_SUSPEND);
 710
 711                 snd_soc_dapm_stream_event(rtd,
 712                                           SNDRV_PCM_STREAM_CAPTURE,
 713                                           SND_SOC_DAPM_STREAM_SUSPEND);
 714         }
 715
 716         /* Recheck all endpoints too, their state is affected by suspend */
 717         dapm_mark_endpoints_dirty(card);
 718         snd_soc_dapm_sync(&card->dapm);
 719
 720         /* suspend all COMPONENTs */
 721         list_for_each_entry(component, &card->component_dev_list, card_list) {
 722                 struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(component);
 723
 724                 /* If there are paths active then the COMPONENT will be held with
 725                  * bias _ON and should not be suspended. */
 726                 if (!component->suspended) {
 727                         switch (snd_soc_dapm_get_bias_level(dapm)) {
 728                         case SND_SOC_BIAS_STANDBY:
 729                                 /*
 730                                  * If the COMPONENT is capable of idle
 731                                  * bias off then being in STANDBY
 732                                  * means it's doing something,
 733                                  * otherwise fall through.
 734                                  */
 735                                 if (dapm->idle_bias_off) {
 736                                         dev_dbg(component->dev,
 737                                                 "ASoC: idle_bias_off CODEC on over suspend\n");
 738                                         break;
 739                                 }
 740
 741                         case SND_SOC_BIAS_OFF:
 742                                 if (component->suspend)
 743                                         component->suspend(component);
 744                                 component->suspended = 1;
 745                                 if (component->regmap)
 746                                         regcache_mark_dirty(component->regmap);
 747                                 /* deactivate pins to sleep state */
 748                                 pinctrl_pm_select_sleep_state(component->dev);
 749                                 break;
 750                         default:
 751                                 dev_dbg(component->dev,
 752                                         "ASoC: COMPONENT is on over suspend\n");
 753                                 break;
 754                         }
 755                 }
 756         }
 757
 758         list_for_each_entry(rtd, &card->rtd_list, list) {
 759                 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
 760
 761                 if (rtd->dai_link->ignore_suspend)
 762                         continue;
 763
 764                 if (cpu_dai->driver->suspend && cpu_dai->driver->bus_control)
 765                         cpu_dai->driver->suspend(cpu_dai);
 766
 767                 /* deactivate pins to sleep state */
 768                 pinctrl_pm_select_sleep_state(cpu_dai->dev);
 769         }
 770
 771         if (card->suspend_post)
 772                 card->suspend_post(card);
 773
 774         return 0;
 775 }
 776 EXPORT_SYMBOL_GPL(snd_soc_suspend);
 777
 778 /* deferred resume work, so resume can complete before we finished
 779  * setting our codec back up, which can be very slow on I2C
 780  */
 781 static void soc_resume_deferred(struct work_struct *work)
 782 {
 783         struct snd_soc_card *card =
 784                         container_of(work, struct snd_soc_card, deferred_resume_work);
 785         struct snd_soc_pcm_runtime *rtd;
 786         struct snd_soc_component *component;
 787         int i;
 788
 789         /* our power state is still SNDRV_CTL_POWER_D3hot from suspend time,
 790          * so userspace apps are blocked from touching us
 791          */
 792
 793         dev_dbg(card->dev, "ASoC: starting resume work\n");
 794
 795         /* Bring us up into D2 so that DAPM starts enabling things */
 796         snd_power_change_state(card->snd_card, SNDRV_CTL_POWER_D2);
 797
 798         if (card->resume_pre)
 799                 card->resume_pre(card);
 800
 801         /* resume control bus DAIs */
 802         list_for_each_entry(rtd, &card->rtd_list, list) {
 803                 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
 804
 805                 if (rtd->dai_link->ignore_suspend)
 806                         continue;
 807
 808                 if (cpu_dai->driver->resume && cpu_dai->driver->bus_control)
 809                         cpu_dai->driver->resume(cpu_dai);
 810         }
 811
 812         list_for_each_entry(component, &card->component_dev_list, card_list) {
 813                 if (component->suspended) {
 814                         if (component->resume)
 815                                 component->resume(component);
 816                         component->suspended = 0;
 817                 }
 818         }
 819
 820         list_for_each_entry(rtd, &card->rtd_list, list) {
 821
 822                 if (rtd->dai_link->ignore_suspend)
 823                         continue;
 824
 825                 snd_soc_dapm_stream_event(rtd,
 826                                           SNDRV_PCM_STREAM_PLAYBACK,
 827                                           SND_SOC_DAPM_STREAM_RESUME);
 828
 829                 snd_soc_dapm_stream_event(rtd,
 830                                           SNDRV_PCM_STREAM_CAPTURE,
 831                                           SND_SOC_DAPM_STREAM_RESUME);
 832         }
 833
 834         /* unmute any active DACs */
 835         list_for_each_entry(rtd, &card->rtd_list, list) {
 836
 837                 if (rtd->dai_link->ignore_suspend)
 838                         continue;
 839
 840                 for (i = 0; i < rtd->num_codecs; i++) {
 841                         struct snd_soc_dai *dai = rtd->codec_dais[i];
 842                         struct snd_soc_dai_driver *drv = dai->driver;
 843
 844                         if (drv->ops->digital_mute && dai->playback_active)
 845                                 drv->ops->digital_mute(dai, 0);
 846                 }
 847         }
 848
 849         list_for_each_entry(rtd, &card->rtd_list, list) {
 850                 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
 851
 852                 if (rtd->dai_link->ignore_suspend)
 853                         continue;
 854
 855                 if (cpu_dai->driver->resume && !cpu_dai->driver->bus_control)
 856                         cpu_dai->driver->resume(cpu_dai);
 857         }
 858
 859         if (card->resume_post)
 860                 card->resume_post(card);
 861
 862         dev_dbg(card->dev, "ASoC: resume work completed\n");
 863
 864         /* Recheck all endpoints too, their state is affected by suspend */
 865         dapm_mark_endpoints_dirty(card);
 866         snd_soc_dapm_sync(&card->dapm);
 867
 868         /* userspace can access us now we are back as we were before */
 869         snd_power_change_state(card->snd_card, SNDRV_CTL_POWER_D0);
 870 }
 871
 872 /* powers up audio subsystem after a suspend */
 873 int snd_soc_resume(struct device *dev)
 874 {
 875         struct snd_soc_card *card = dev_get_drvdata(dev);
 876         bool bus_control = false;
 877         struct snd_soc_pcm_runtime *rtd;
 878
 879         /* If the card is not initialized yet there is nothing to do */
 880         if (!card->instantiated)
 881                 return 0;
 882
 883         /* activate pins from sleep state */
 884         list_for_each_entry(rtd, &card->rtd_list, list) {
 885                 struct snd_soc_dai **codec_dais = rtd->codec_dais;
 886                 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
 887                 int j;
 888
 889                 if (cpu_dai->active)
 890                         pinctrl_pm_select_default_state(cpu_dai->dev);
 891
 892                 for (j = 0; j < rtd->num_codecs; j++) {
 893                         struct snd_soc_dai *codec_dai = codec_dais[j];
 894                         if (codec_dai->active)
 895                                 pinctrl_pm_select_default_state(codec_dai->dev);
 896                 }
 897         }
 898
 899         /*
 900          * DAIs that also act as the control bus master might have other drivers
 901          * hanging off them so need to resume immediately. Other drivers don't
 902          * have that problem and may take a substantial amount of time to resume
 903          * due to I/O costs and anti-pop so handle them out of line.
 904          */
 905         list_for_each_entry(rtd, &card->rtd_list, list) {
 906                 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
 907                 bus_control |= cpu_dai->driver->bus_control;
 908         }
 909         if (bus_control) {
 910                 dev_dbg(dev, "ASoC: Resuming control bus master immediately\n");
 911                 soc_resume_deferred(&card->deferred_resume_work);
 912         } else {
 913                 dev_dbg(dev, "ASoC: Scheduling resume work\n");
 914                 if (!schedule_work(&card->deferred_resume_work))
 915                         dev_err(dev, "ASoC: resume work item may be lost\n");
 916         }
 917
 918         return 0;
 919 }
 920 EXPORT_SYMBOL_GPL(snd_soc_resume);
 921 #else
 922 #define snd_soc_suspend NULL
 923 #define snd_soc_resume NULL
 924 #endif
 925
 926 static const struct snd_soc_dai_ops null_dai_ops = {
 927 };
 928
 929 static struct snd_soc_component *soc_find_component(
 930         const struct device_node *of_node, const char *name)
 931 {
 932         struct snd_soc_component *component;
 933
 934         lockdep_assert_held(&client_mutex);
 935
 936         list_for_each_entry(component, &component_list, list) {
 937                 if (of_node) {
 938                         if (component->dev->of_node == of_node)
 939                                 return component;
 940                 } else if (strcmp(component->name, name) == 0) {
 941                         return component;
 942                 }
 943         }
 944
 945         return NULL;
 946 }
 947
 948 /**
 949  * snd_soc_find_dai - Find a registered DAI
 950  *
 951  * @dlc: name of the DAI and optional component info to match
 952  *
 953  * This function will search all registered components and their DAIs to
 954  * find the DAI of the same name. The component's of_node and name
 955  * should also match if being specified.
 956  *
 957  * Return: pointer of DAI, or NULL if not found.
 958  */
 959 struct snd_soc_dai *snd_soc_find_dai(
 960         const struct snd_soc_dai_link_component *dlc)
 961 {
 962         struct snd_soc_component *component;
 963         struct snd_soc_dai *dai;
 964         struct device_node *component_of_node;
 965
 966         lockdep_assert_held(&client_mutex);
 967
 968         /* Find CPU DAI from registered DAIs*/
 969         list_for_each_entry(component, &component_list, list) {
 970                 component_of_node = component->dev->of_node;
 971                 if (!component_of_node && component->dev->parent)
 972                         component_of_node = component->dev->parent->of_node;
 973
 974                 if (dlc->of_node && component_of_node != dlc->of_node)
 975                         continue;
 976                 if (dlc->name && strcmp(component->name, dlc->name))
 977                         continue;
 978                 list_for_each_entry(dai, &component->dai_list, list) {
 979                         if (dlc->dai_name && strcmp(dai->name, dlc->dai_name))
 980                                 continue;
 981
 982                         return dai;
 983                 }
 984         }
 985
 986         return NULL;
 987 }
 988 EXPORT_SYMBOL_GPL(snd_soc_find_dai);
 989
 990
 991 /**
 992  * snd_soc_find_dai_link - Find a DAI link
 993  *
 994  * @card: soc card
 995  * @id: DAI link ID to match
 996  * @name: DAI link name to match, optional
 997  * @stream_name: DAI link stream name to match, optional
 998  *
 999  * This function will search all existing DAI links of the soc card to
1000  * find the link of the same ID. Since DAI links may not have their
1001  * unique ID, so name and stream name should also match if being
1002  * specified.
1003  *
1004  * Return: pointer of DAI link, or NULL if not found.
1005  */
1006 struct snd_soc_dai_link *snd_soc_find_dai_link(struct snd_soc_card *card,
1007                                                int id, const char *name,
1008                                                const char *stream_name)
1009 {
1010         struct snd_soc_dai_link *link, *_link;
1011
1012         lockdep_assert_held(&client_mutex);
1013
1014         list_for_each_entry_safe(link, _link, &card->dai_link_list, list) {
1015                 if (link->id != id)
1016                         continue;
1017
1018                 if (name && (!link->name || strcmp(name, link->name)))
1019                         continue;
1020
1021                 if (stream_name && (!link->stream_name
1022                         || strcmp(stream_name, link->stream_name)))
1023                         continue;
1024
1025                 return link;
1026         }
1027
1028         return NULL;
1029 }
1030 EXPORT_SYMBOL_GPL(snd_soc_find_dai_link);
1031
1032 static bool soc_is_dai_link_bound(struct snd_soc_card *card,
1033                 struct snd_soc_dai_link *dai_link)
1034 {
1035         struct snd_soc_pcm_runtime *rtd;
1036
1037         list_for_each_entry(rtd, &card->rtd_list, list) {
1038                 if (rtd->dai_link == dai_link)
1039                         return true;
1040         }
1041
1042         return false;
1043 }
1044
1045 static int soc_bind_dai_link(struct snd_soc_card *card,
1046         struct snd_soc_dai_link *dai_link)
1047 {
1048         struct snd_soc_pcm_runtime *rtd;
1049         struct snd_soc_dai_link_component *codecs = dai_link->codecs;
1050         struct snd_soc_dai_link_component cpu_dai_component;
1051         struct snd_soc_dai **codec_dais;
1052         struct snd_soc_platform *platform;
1053         struct device_node *platform_of_node;
1054         const char *platform_name;
1055         int i;
1056
1057         dev_dbg(card->dev, "ASoC: binding %s\n", dai_link->name);
1058
1059         if (soc_is_dai_link_bound(card, dai_link)) {
1060                 dev_dbg(card->dev, "ASoC: dai link %s already bound\n",
1061                         dai_link->name);
1062                 return 0;
1063         }
1064
1065         rtd = soc_new_pcm_runtime(card, dai_link);
1066         if (!rtd)
1067                 return -ENOMEM;
1068
1069         cpu_dai_component.name = dai_link->cpu_name;
1070         cpu_dai_component.of_node = dai_link->cpu_of_node;
1071         cpu_dai_component.dai_name = dai_link->cpu_dai_name;
1072         rtd->cpu_dai = snd_soc_find_dai(&cpu_dai_component);
1073         if (!rtd->cpu_dai) {
1074                 dev_err(card->dev, "ASoC: CPU DAI %s not registered\n",
1075                         dai_link->cpu_dai_name);
1076                 goto _err_defer;
1077         }
1078
1079         rtd->num_codecs = dai_link->num_codecs;
1080
1081         /* Find CODEC from registered CODECs */
1082         codec_dais = rtd->codec_dais;
1083         for (i = 0; i < rtd->num_codecs; i++) {
1084                 codec_dais[i] = snd_soc_find_dai(&codecs[i]);
1085                 if (!codec_dais[i]) {
1086                         dev_err(card->dev, "ASoC: CODEC DAI %s not registered\n",
1087                                 codecs[i].dai_name);
1088                         goto _err_defer;
1089                 }
1090         }
1091
1092         /* Single codec links expect codec and codec_dai in runtime data */
1093         rtd->codec_dai = codec_dais[0];
1094         rtd->codec = rtd->codec_dai->codec;
1095
1096         /* if there's no platform we match on the empty platform */
1097         platform_name = dai_link->platform_name;
1098         if (!platform_name && !dai_link->platform_of_node)
1099                 platform_name = "snd-soc-dummy";
1100
1101         /* find one from the set of registered platforms */
1102         list_for_each_entry(platform, &platform_list, list) {
1103                 platform_of_node = platform->dev->of_node;
1104                 if (!platform_of_node && platform->dev->parent->of_node)
1105                         platform_of_node = platform->dev->parent->of_node;
1106
1107                 if (dai_link->platform_of_node) {
1108                         if (platform_of_node != dai_link->platform_of_node)
1109                                 continue;
1110                 } else {
1111                         if (strcmp(platform->component.name, platform_name))
1112                                 continue;
1113                 }
1114
1115                 rtd->platform = platform;
1116         }
1117         if (!rtd->platform) {
1118                 dev_err(card->dev, "ASoC: platform %s not registered\n",
1119                         dai_link->platform_name);
1120                 goto _err_defer;
1121         }
1122
1123         soc_add_pcm_runtime(card, rtd);
1124         return 0;
1125
1126 _err_defer:
1127         soc_free_pcm_runtime(rtd);
1128         return  -EPROBE_DEFER;
1129 }
1130
1131 static void soc_remove_component(struct snd_soc_component *component)
1132 {
1133         if (!component->card)
1134                 return;
1135
1136         list_del(&component->card_list);
1137
1138         if (component->remove)
1139                 component->remove(component);
1140
1141         snd_soc_dapm_free(snd_soc_component_get_dapm(component));
1142
1143         soc_cleanup_component_debugfs(component);
1144         component->card = NULL;
1145         module_put(component->dev->driver->owner);
1146 }
1147
1148 static void soc_remove_dai(struct snd_soc_dai *dai, int order)
1149 {
1150         int err;
1151
1152         if (dai && dai->probed &&
1153                         dai->driver->remove_order == order) {
1154                 if (dai->driver->remove) {
1155                         err = dai->driver->remove(dai);
1156                         if (err < 0)
1157                                 dev_err(dai->dev,
1158                                         "ASoC: failed to remove %s: %d\n",
1159                                         dai->name, err);
1160                 }
1161                 dai->probed = 0;
1162         }
1163 }
1164
1165 static void soc_remove_link_dais(struct snd_soc_card *card,
1166                 struct snd_soc_pcm_runtime *rtd, int order)
1167 {
1168         int i;
1169
1170         /* unregister the rtd device */
1171         if (rtd->dev_registered) {
1172                 device_unregister(rtd->dev);
1173                 rtd->dev_registered = 0;
1174         }
1175
1176         /* remove the CODEC DAI */
1177         for (i = 0; i < rtd->num_codecs; i++)
1178                 soc_remove_dai(rtd->codec_dais[i], order);
1179
1180         soc_remove_dai(rtd->cpu_dai, order);
1181 }
1182
1183 static void soc_remove_link_components(struct snd_soc_card *card,
1184         struct snd_soc_pcm_runtime *rtd, int order)
1185 {
1186         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
1187         struct snd_soc_platform *platform = rtd->platform;
1188         struct snd_soc_component *component;
1189         int i;
1190
1191         /* remove the platform */
1192         if (platform && platform->component.driver->remove_order == order)
1193                 soc_remove_component(&platform->component);
1194
1195         /* remove the CODEC-side CODEC */
1196         for (i = 0; i < rtd->num_codecs; i++) {
1197                 component = rtd->codec_dais[i]->component;
1198                 if (component->driver->remove_order == order)
1199                         soc_remove_component(component);
1200         }
1201
1202         /* remove any CPU-side CODEC */
1203         if (cpu_dai) {
1204                 if (cpu_dai->component->driver->remove_order == order)
1205                         soc_remove_component(cpu_dai->component);
1206         }
1207 }
1208
1209 static void soc_remove_dai_links(struct snd_soc_card *card)
1210 {
1211         int order;
1212         struct snd_soc_pcm_runtime *rtd;
1213         struct snd_soc_dai_link *link, *_link;
1214
1215         for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
1216                         order++) {
1217                 list_for_each_entry(rtd, &card->rtd_list, list)
1218                         soc_remove_link_dais(card, rtd, order);
1219         }
1220
1221         for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
1222                         order++) {
1223                 list_for_each_entry(rtd, &card->rtd_list, list)
1224                         soc_remove_link_components(card, rtd, order);
1225         }
1226
1227         list_for_each_entry_safe(link, _link, &card->dai_link_list, list) {
1228                 if (link->dobj.type == SND_SOC_DOBJ_DAI_LINK)
1229                         dev_warn(card->dev, "Topology forgot to remove link %s?\n",
1230                                 link->name);
1231
1232                 list_del(&link->list);
1233                 card->num_dai_links--;
1234         }
1235 }
1236
1237 static int snd_soc_init_multicodec(struct snd_soc_card *card,
1238                                    struct snd_soc_dai_link *dai_link)
1239 {
1240         /* Legacy codec/codec_dai link is a single entry in multicodec */
1241         if (dai_link->codec_name || dai_link->codec_of_node ||
1242             dai_link->codec_dai_name) {
1243                 dai_link->num_codecs = 1;
1244
1245                 dai_link->codecs = devm_kzalloc(card->dev,
1246                                 sizeof(struct snd_soc_dai_link_component),
1247                                 GFP_KERNEL);
1248                 if (!dai_link->codecs)
1249                         return -ENOMEM;
1250
1251                 dai_link->codecs[0].name = dai_link->codec_name;
1252                 dai_link->codecs[0].of_node = dai_link->codec_of_node;
1253                 dai_link->codecs[0].dai_name = dai_link->codec_dai_name;
1254         }
1255
1256         if (!dai_link->codecs) {
1257                 dev_err(card->dev, "ASoC: DAI link has no CODECs\n");
1258                 return -EINVAL;
1259         }
1260
1261         return 0;
1262 }
1263
1264 static int soc_init_dai_link(struct snd_soc_card *card,
1265                                    struct snd_soc_dai_link *link)
1266 {
1267         int i, ret;
1268
1269         ret = snd_soc_init_multicodec(card, link);
1270         if (ret) {
1271                 dev_err(card->dev, "ASoC: failed to init multicodec\n");
1272                 return ret;
1273         }
1274
1275         for (i = 0; i < link->num_codecs; i++) {
1276                 /*
1277                  * Codec must be specified by 1 of name or OF node,
1278                  * not both or neither.
1279                  */
1280                 if (!!link->codecs[i].name ==
1281                     !!link->codecs[i].of_node) {
1282                         dev_err(card->dev, "ASoC: Neither/both codec name/of_node are set for %s\n",
1283                                 link->name);
1284                         return -EINVAL;
1285                 }
1286                 /* Codec DAI name must be specified */
1287                 if (!link->codecs[i].dai_name) {
1288                         dev_err(card->dev, "ASoC: codec_dai_name not set for %s\n",
1289                                 link->name);
1290                         return -EINVAL;
1291                 }
1292         }
1293
1294         /*
1295          * Platform may be specified by either name or OF node, but
1296          * can be left unspecified, and a dummy platform will be used.
1297          */
1298         if (link->platform_name && link->platform_of_node) {
1299                 dev_err(card->dev,
1300                         "ASoC: Both platform name/of_node are set for %s\n",
1301                         link->name);
1302                 return -EINVAL;
1303         }
1304
1305         /*
1306          * CPU device may be specified by either name or OF node, but
1307          * can be left unspecified, and will be matched based on DAI
1308          * name alone..
1309          */
1310         if (link->cpu_name && link->cpu_of_node) {
1311                 dev_err(card->dev,
1312                         "ASoC: Neither/both cpu name/of_node are set for %s\n",
1313                         link->name);
1314                 return -EINVAL;
1315         }
1316         /*
1317          * At least one of CPU DAI name or CPU device name/node must be
1318          * specified
1319          */
1320         if (!link->cpu_dai_name &&
1321             !(link->cpu_name || link->cpu_of_node)) {
1322                 dev_err(card->dev,
1323                         "ASoC: Neither cpu_dai_name nor cpu_name/of_node are set for %s\n",
1324                         link->name);
1325                 return -EINVAL;
1326         }
1327
1328         return 0;
1329 }
1330
1331 /**
1332  * snd_soc_add_dai_link - Add a DAI link dynamically
1333  * @card: The ASoC card to which the DAI link is added
1334  * @dai_link: The new DAI link to add
1335  *
1336  * This function adds a DAI link to the ASoC card's link list.
1337  *
1338  * Note: Topology can use this API to add DAI links when probing the
1339  * topology component. And machine drivers can still define static
1340  * DAI links in dai_link array.
1341  */
1342 int snd_soc_add_dai_link(struct snd_soc_card *card,
1343                 struct snd_soc_dai_link *dai_link)
1344 {
1345         if (dai_link->dobj.type
1346             && dai_link->dobj.type != SND_SOC_DOBJ_DAI_LINK) {
1347                 dev_err(card->dev, "Invalid dai link type %d\n",
1348                         dai_link->dobj.type);
1349                 return -EINVAL;
1350         }
1351
1352         lockdep_assert_held(&client_mutex);
1353         /* Notify the machine driver for extra initialization
1354          * on the link created by topology.
1355          */
1356         if (dai_link->dobj.type && card->add_dai_link)
1357                 card->add_dai_link(card, dai_link);
1358
1359         list_add_tail(&dai_link->list, &card->dai_link_list);
1360         card->num_dai_links++;
1361
1362         return 0;
1363 }
1364 EXPORT_SYMBOL_GPL(snd_soc_add_dai_link);
1365
1366 /**
1367  * snd_soc_remove_dai_link - Remove a DAI link from the list
1368  * @card: The ASoC card that owns the link
1369  * @dai_link: The DAI link to remove
1370  *
1371  * This function removes a DAI link from the ASoC card's link list.
1372  *
1373  * For DAI links previously added by topology, topology should
1374  * remove them by using the dobj embedded in the link.
1375  */
1376 void snd_soc_remove_dai_link(struct snd_soc_card *card,
1377                              struct snd_soc_dai_link *dai_link)
1378 {
1379         struct snd_soc_dai_link *link, *_link;
1380
1381         if (dai_link->dobj.type
1382             && dai_link->dobj.type != SND_SOC_DOBJ_DAI_LINK) {
1383                 dev_err(card->dev, "Invalid dai link type %d\n",
1384                         dai_link->dobj.type);
1385                 return;
1386         }
1387
1388         lockdep_assert_held(&client_mutex);
1389         /* Notify the machine driver for extra destruction
1390          * on the link created by topology.
1391          */
1392         if (dai_link->dobj.type && card->remove_dai_link)
1393                 card->remove_dai_link(card, dai_link);
1394
1395         list_for_each_entry_safe(link, _link, &card->dai_link_list, list) {
1396                 if (link == dai_link) {
1397                         list_del(&link->list);
1398                         card->num_dai_links--;
1399                         return;
1400                 }
1401         }
1402 }
1403 EXPORT_SYMBOL_GPL(snd_soc_remove_dai_link);
1404
1405 static void soc_set_name_prefix(struct snd_soc_card *card,
1406                                 struct snd_soc_component *component)
1407 {
1408         int i;
1409
1410         if (card->codec_conf == NULL)
1411                 return;
1412
1413         for (i = 0; i < card->num_configs; i++) {
1414                 struct snd_soc_codec_conf *map = &card->codec_conf[i];
1415                 if (map->of_node && component->dev->of_node != map->of_node)
1416                         continue;
1417                 if (map->dev_name && strcmp(component->name, map->dev_name))
1418                         continue;
1419                 component->name_prefix = map->name_prefix;
1420                 break;
1421         }
1422 }
1423
1424 static int soc_probe_component(struct snd_soc_card *card,
1425         struct snd_soc_component *component)
1426 {
1427         struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(component);
1428         struct snd_soc_dai *dai;
1429         int ret;
1430
1431         if (!strcmp(component->name, "snd-soc-dummy"))
1432                 return 0;
1433
1434         if (component->card) {
1435                 if (component->card != card) {
1436                         dev_err(component->dev,
1437                                 "Trying to bind component to card \"%s\" but is already bound to card \"%s\"\n",
1438                                 card->name, component->card->name);
1439                         return -ENODEV;
1440                 }
1441                 return 0;
1442         }
1443
1444         if (!try_module_get(component->dev->driver->owner))
1445                 return -ENODEV;
1446
1447         component->card = card;
1448         dapm->card = card;
1449         soc_set_name_prefix(card, component);
1450
1451         soc_init_component_debugfs(component);
1452
1453         if (component->dapm_widgets) {
1454                 ret = snd_soc_dapm_new_controls(dapm, component->dapm_widgets,
1455                         component->num_dapm_widgets);
1456
1457                 if (ret != 0) {
1458                         dev_err(component->dev,
1459                                 "Failed to create new controls %d\n", ret);
1460                         goto err_probe;
1461                 }
1462         }
1463
1464         list_for_each_entry(dai, &component->dai_list, list) {
1465                 ret = snd_soc_dapm_new_dai_widgets(dapm, dai);
1466                 if (ret != 0) {
1467                         dev_err(component->dev,
1468                                 "Failed to create DAI widgets %d\n", ret);
1469                         goto err_probe;
1470                 }
1471         }
1472
1473         if (component->probe) {
1474                 ret = component->probe(component);
1475                 if (ret < 0) {
1476                         dev_err(component->dev,
1477                                 "ASoC: failed to probe component %d\n", ret);
1478                         goto err_probe;
1479                 }
1480
1481                 WARN(dapm->idle_bias_off &&
1482                         dapm->bias_level != SND_SOC_BIAS_OFF,
1483                         "codec %s can not start from non-off bias with idle_bias_off==1\n",
1484                         component->name);
1485         }
1486
1487         /* machine specific init */
1488         if (component->init) {
1489                 ret = component->init(component);
1490                 if (ret < 0) {
1491                         dev_err(component->dev,
1492                                 "Failed to do machine specific init %d\n", ret);
1493                         goto err_probe;
1494                 }
1495         }
1496
1497         if (component->controls)
1498                 snd_soc_add_component_controls(component, component->controls,
1499                                      component->num_controls);
1500         if (component->dapm_routes)
1501                 snd_soc_dapm_add_routes(dapm, component->dapm_routes,
1502                                         component->num_dapm_routes);
1503
1504         list_add(&dapm->list, &card->dapm_list);
1505         list_add(&component->card_list, &card->component_dev_list);
1506
1507         return 0;
1508
1509 err_probe:
1510         soc_cleanup_component_debugfs(component);
1511         component->card = NULL;
1512         module_put(component->dev->driver->owner);
1513
1514         return ret;
1515 }
1516
1517 static void rtd_release(struct device *dev)
1518 {
1519         kfree(dev);
1520 }
1521
1522 static int soc_post_component_init(struct snd_soc_pcm_runtime *rtd,
1523         const char *name)
1524 {
1525         int ret = 0;
1526
1527         /* register the rtd device */
1528         rtd->dev = kzalloc(sizeof(struct device), GFP_KERNEL);
1529         if (!rtd->dev)
1530                 return -ENOMEM;
1531         device_initialize(rtd->dev);
1532         rtd->dev->parent = rtd->card->dev;
1533         rtd->dev->release = rtd_release;
1534         rtd->dev->groups = soc_dev_attr_groups;
1535         dev_set_name(rtd->dev, "%s", name);
1536         dev_set_drvdata(rtd->dev, rtd);
1537         mutex_init(&rtd->pcm_mutex);
1538         INIT_LIST_HEAD(&rtd->dpcm[SNDRV_PCM_STREAM_PLAYBACK].be_clients);
1539         INIT_LIST_HEAD(&rtd->dpcm[SNDRV_PCM_STREAM_CAPTURE].be_clients);
1540         INIT_LIST_HEAD(&rtd->dpcm[SNDRV_PCM_STREAM_PLAYBACK].fe_clients);
1541         INIT_LIST_HEAD(&rtd->dpcm[SNDRV_PCM_STREAM_CAPTURE].fe_clients);
1542         ret = device_add(rtd->dev);
1543         if (ret < 0) {
1544                 /* calling put_device() here to free the rtd->dev */
1545                 put_device(rtd->dev);
1546                 dev_err(rtd->card->dev,
1547                         "ASoC: failed to register runtime device: %d\n", ret);
1548                 return ret;
1549         }
1550         rtd->dev_registered = 1;
1551         return 0;
1552 }
1553
1554 static int soc_probe_link_components(struct snd_soc_card *card,
1555                         struct snd_soc_pcm_runtime *rtd,
1556                                      int order)
1557 {
1558         struct snd_soc_platform *platform = rtd->platform;
1559         struct snd_soc_component *component;
1560         int i, ret;
1561
1562         /* probe the CPU-side component, if it is a CODEC */
1563         component = rtd->cpu_dai->component;
1564         if (component->driver->probe_order == order) {
1565                 ret = soc_probe_component(card, component);
1566                 if (ret < 0)
1567                         return ret;
1568         }
1569
1570         /* probe the CODEC-side components */
1571         for (i = 0; i < rtd->num_codecs; i++) {
1572                 component = rtd->codec_dais[i]->component;
1573                 if (component->driver->probe_order == order) {
1574                         ret = soc_probe_component(card, component);
1575                         if (ret < 0)
1576                                 return ret;
1577                 }
1578         }
1579
1580         /* probe the platform */
1581         if (platform->component.driver->probe_order == order) {
1582                 ret = soc_probe_component(card, &platform->component);
1583                 if (ret < 0)
1584                         return ret;
1585         }
1586
1587         return 0;
1588 }
1589
1590 static int soc_probe_dai(struct snd_soc_dai *dai, int order)
1591 {
1592         int ret;
1593
1594         if (!dai->probed && dai->driver->probe_order == order) {
1595                 if (dai->driver->probe) {
1596                         ret = dai->driver->probe(dai);
1597                         if (ret < 0) {
1598                                 dev_err(dai->dev,
1599                                         "ASoC: failed to probe DAI %s: %d\n",
1600                                         dai->name, ret);
1601                                 return ret;
1602                         }
1603                 }
1604
1605                 dai->probed = 1;
1606         }
1607
1608         return 0;
1609 }
1610
1611 static int soc_link_dai_pcm_new(struct snd_soc_dai **dais, int num_dais,
1612                                 struct snd_soc_pcm_runtime *rtd)
1613 {
1614         int i, ret = 0;
1615
1616         for (i = 0; i < num_dais; ++i) {
1617                 struct snd_soc_dai_driver *drv = dais[i]->driver;
1618
1619                 if (!rtd->dai_link->no_pcm && drv->pcm_new)
1620                         ret = drv->pcm_new(rtd, dais[i]);
1621                 if (ret < 0) {
1622                         dev_err(dais[i]->dev,
1623                                 "ASoC: Failed to bind %s with pcm device\n",
1624                                 dais[i]->name);
1625                         return ret;
1626                 }
1627         }
1628
1629         return 0;
1630 }
1631
1632 static int soc_link_dai_widgets(struct snd_soc_card *card,
1633                                 struct snd_soc_dai_link *dai_link,
1634                                 struct snd_soc_pcm_runtime *rtd)
1635 {
1636         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
1637         struct snd_soc_dai *codec_dai = rtd->codec_dai;
1638         struct snd_soc_dapm_widget *sink, *source;
1639         int ret;
1640
1641         if (rtd->num_codecs > 1)
1642                 dev_warn(card->dev, "ASoC: Multiple codecs not supported yet\n");
1643
1644         /* link the DAI widgets */
1645         sink = codec_dai->playback_widget;
1646         source = cpu_dai->capture_widget;
1647         if (sink && source) {
1648                 ret = snd_soc_dapm_new_pcm(card, dai_link->params,
1649                                            dai_link->num_params,
1650                                            source, sink);
1651                 if (ret != 0) {
1652                         dev_err(card->dev, "ASoC: Can't link %s to %s: %d\n",
1653                                 sink->name, source->name, ret);
1654                         return ret;
1655                 }
1656         }
1657
1658         sink = cpu_dai->playback_widget;
1659         source = codec_dai->capture_widget;
1660         if (sink && source) {
1661                 ret = snd_soc_dapm_new_pcm(card, dai_link->params,
1662                                            dai_link->num_params,
1663                                            source, sink);
1664                 if (ret != 0) {
1665                         dev_err(card->dev, "ASoC: Can't link %s to %s: %d\n",
1666                                 sink->name, source->name, ret);
1667                         return ret;
1668                 }
1669         }
1670
1671         return 0;
1672 }
1673
1674 static int soc_probe_link_dais(struct snd_soc_card *card,
1675                 struct snd_soc_pcm_runtime *rtd, int order)
1676 {
1677         struct snd_soc_dai_link *dai_link = rtd->dai_link;
1678         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
1679         int i, ret;
1680
1681         dev_dbg(card->dev, "ASoC: probe %s dai link %d late %d\n",
1682                         card->name, rtd->num, order);
1683
1684         /* set default power off timeout */
1685         rtd->pmdown_time = pmdown_time;
1686
1687         ret = soc_probe_dai(cpu_dai, order);
1688         if (ret)
1689                 return ret;
1690
1691         /* probe the CODEC DAI */
1692         for (i = 0; i < rtd->num_codecs; i++) {
1693                 ret = soc_probe_dai(rtd->codec_dais[i], order);
1694                 if (ret)
1695                         return ret;
1696         }
1697
1698         /* complete DAI probe during last probe */
1699         if (order != SND_SOC_COMP_ORDER_LAST)
1700                 return 0;
1701
1702         /* do machine specific initialization */
1703         if (dai_link->init) {
1704                 ret = dai_link->init(rtd);
1705                 if (ret < 0) {
1706                         dev_err(card->dev, "ASoC: failed to init %s: %d\n",
1707                                 dai_link->name, ret);
1708                         return ret;
1709                 }
1710         }
1711
1712         if (dai_link->dai_fmt)
1713                 snd_soc_runtime_set_dai_fmt(rtd, dai_link->dai_fmt);
1714
1715         ret = soc_post_component_init(rtd, dai_link->name);
1716         if (ret)
1717                 return ret;
1718
1719 #ifdef CONFIG_DEBUG_FS
1720         /* add DPCM sysfs entries */
1721         if (dai_link->dynamic)
1722                 soc_dpcm_debugfs_add(rtd);
1723 #endif
1724
1725         if (cpu_dai->driver->compress_new) {
1726                 /*create compress_device"*/
1727                 ret = cpu_dai->driver->compress_new(rtd, rtd->num);
1728                 if (ret < 0) {
1729                         dev_err(card->dev, "ASoC: can't create compress %s\n",
1730                                          dai_link->stream_name);
1731                         return ret;
1732                 }
1733         } else {
1734
1735                 if (!dai_link->params) {
1736                         /* create the pcm */
1737                         ret = soc_new_pcm(rtd, rtd->num);
1738                         if (ret < 0) {
1739                                 dev_err(card->dev, "ASoC: can't create pcm %s :%d\n",
1740                                        dai_link->stream_name, ret);
1741                                 return ret;
1742                         }
1743                         ret = soc_link_dai_pcm_new(&cpu_dai, 1, rtd);
1744                         if (ret < 0)
1745                                 return ret;
1746                         ret = soc_link_dai_pcm_new(rtd->codec_dais,
1747                                                    rtd->num_codecs, rtd);
1748                         if (ret < 0)
1749                                 return ret;
1750                 } else {
1751                         INIT_DELAYED_WORK(&rtd->delayed_work,
1752                                                 codec2codec_close_delayed_work);
1753
1754                         /* link the DAI widgets */
1755                         ret = soc_link_dai_widgets(card, dai_link, rtd);
1756                         if (ret)
1757                                 return ret;
1758                 }
1759         }
1760
1761         return 0;
1762 }
1763
1764 static int soc_bind_aux_dev(struct snd_soc_card *card, int num)
1765 {
1766         struct snd_soc_aux_dev *aux_dev = &card->aux_dev[num];
1767         struct snd_soc_component *component;
1768         const char *name;
1769         struct device_node *codec_of_node;
1770
1771         if (aux_dev->codec_of_node || aux_dev->codec_name) {
1772                 /* codecs, usually analog devices */
1773                 name = aux_dev->codec_name;
1774                 codec_of_node = aux_dev->codec_of_node;
1775                 component = soc_find_component(codec_of_node, name);
1776                 if (!component) {
1777                         if (codec_of_node)
1778                                 name = of_node_full_name(codec_of_node);
1779                         goto err_defer;
1780                 }
1781         } else if (aux_dev->name) {
1782                 /* generic components */
1783                 name = aux_dev->name;
1784                 component = soc_find_component(NULL, name);
1785                 if (!component)
1786                         goto err_defer;
1787         } else {
1788                 dev_err(card->dev, "ASoC: Invalid auxiliary device\n");
1789                 return -EINVAL;
1790         }
1791
1792         component->init = aux_dev->init;
1793         list_add(&component->card_aux_list, &card->aux_comp_list);
1794
1795         return 0;
1796
1797 err_defer:
1798         dev_err(card->dev, "ASoC: %s not registered\n", name);
1799         return -EPROBE_DEFER;
1800 }
1801
1802 static int soc_probe_aux_devices(struct snd_soc_card *card)
1803 {
1804         struct snd_soc_component *comp;
1805         int order;
1806         int ret;
1807
1808         for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
1809                 order++) {
1810                 list_for_each_entry(comp, &card->aux_comp_list, card_aux_list) {
1811                         if (comp->driver->probe_order == order) {
1812                                 ret = soc_probe_component(card, comp);
1813                                 if (ret < 0) {
1814                                         dev_err(card->dev,
1815                                                 "ASoC: failed to probe aux component %s %d\n",
1816                                                 comp->name, ret);
1817                                         return ret;
1818                                 }
1819                         }
1820                 }
1821         }
1822
1823         return 0;
1824 }
1825
1826 static void soc_remove_aux_devices(struct snd_soc_card *card)
1827 {
1828         struct snd_soc_component *comp, *_comp;
1829         int order;
1830
1831         for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
1832                 order++) {
1833                 list_for_each_entry_safe(comp, _comp,
1834                         &card->aux_comp_list, card_aux_list) {
1835
1836                         if (comp->driver->remove_order == order) {
1837                                 soc_remove_component(comp);
1838                                 /* remove it from the card's aux_comp_list */
1839                                 list_del(&comp->card_aux_list);
1840                         }
1841                 }
1842         }
1843 }
1844
1845 static int snd_soc_init_codec_cache(struct snd_soc_codec *codec)
1846 {
1847         int ret;
1848
1849         if (codec->cache_init)
1850                 return 0;
1851
1852         ret = snd_soc_cache_init(codec);
1853         if (ret < 0) {
1854                 dev_err(codec->dev,
1855                         "ASoC: Failed to set cache compression type: %d\n",
1856                         ret);
1857                 return ret;
1858         }
1859         codec->cache_init = 1;
1860         return 0;
1861 }
1862
1863 /**
1864  * snd_soc_runtime_set_dai_fmt() - Change DAI link format for a ASoC runtime
1865  * @rtd: The runtime for which the DAI link format should be changed
1866  * @dai_fmt: The new DAI link format
1867  *
1868  * This function updates the DAI link format for all DAIs connected to the DAI
1869  * link for the specified runtime.
1870  *
1871  * Note: For setups with a static format set the dai_fmt field in the
1872  * corresponding snd_dai_link struct instead of using this function.
1873  *
1874  * Returns 0 on success, otherwise a negative error code.
1875  */
1876 int snd_soc_runtime_set_dai_fmt(struct snd_soc_pcm_runtime *rtd,
1877         unsigned int dai_fmt)
1878 {
1879         struct snd_soc_dai **codec_dais = rtd->codec_dais;
1880         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
1881         unsigned int i;
1882         int ret;
1883
1884         for (i = 0; i < rtd->num_codecs; i++) {
1885                 struct snd_soc_dai *codec_dai = codec_dais[i];
1886
1887                 ret = snd_soc_dai_set_fmt(codec_dai, dai_fmt);
1888                 if (ret != 0 && ret != -ENOTSUPP) {
1889                         dev_warn(codec_dai->dev,
1890                                  "ASoC: Failed to set DAI format: %d\n", ret);
1891                         return ret;
1892                 }
1893         }
1894
1895         /* Flip the polarity for the "CPU" end of a CODEC<->CODEC link */
1896         if (cpu_dai->codec) {
1897                 unsigned int inv_dai_fmt;
1898
1899                 inv_dai_fmt = dai_fmt & ~SND_SOC_DAIFMT_MASTER_MASK;
1900                 switch (dai_fmt & SND_SOC_DAIFMT_MASTER_MASK) {
1901                 case SND_SOC_DAIFMT_CBM_CFM:
1902                         inv_dai_fmt |= SND_SOC_DAIFMT_CBS_CFS;
1903                         break;
1904                 case SND_SOC_DAIFMT_CBM_CFS:
1905                         inv_dai_fmt |= SND_SOC_DAIFMT_CBS_CFM;
1906                         break;
1907                 case SND_SOC_DAIFMT_CBS_CFM:
1908                         inv_dai_fmt |= SND_SOC_DAIFMT_CBM_CFS;
1909                         break;
1910                 case SND_SOC_DAIFMT_CBS_CFS:
1911                         inv_dai_fmt |= SND_SOC_DAIFMT_CBM_CFM;
1912                         break;
1913                 }
1914
1915                 dai_fmt = inv_dai_fmt;
1916         }
1917
1918         ret = snd_soc_dai_set_fmt(cpu_dai, dai_fmt);
1919         if (ret != 0 && ret != -ENOTSUPP) {
1920                 dev_warn(cpu_dai->dev,
1921                          "ASoC: Failed to set DAI format: %d\n", ret);
1922                 return ret;
1923         }
1924
1925         return 0;
1926 }
1927 EXPORT_SYMBOL_GPL(snd_soc_runtime_set_dai_fmt);
1928
1929
1930 #ifdef CONFIG_DMI
1931 /* Trim special characters, and replace '-' with '_' since '-' is used to
1932  * separate different DMI fields in the card long name. Only number and
1933  * alphabet characters and a few separator characters are kept.
1934  */
1935 static void cleanup_dmi_name(char *name)
1936 {
1937         int i, j = 0;
1938
1939         for (i = 0; name[i]; i++) {
1940                 if (isalnum(name[i]) || (name[i] == '.')
1941                     || (name[i] == '_'))
1942                         name[j++] = name[i];
1943                 else if (name[i] == '-')
1944                         name[j++] = '_';
1945         }
1946
1947         name[j] = '\0';
1948 }
1949
1950 /* Check if a DMI field is valid, i.e. not containing any string
1951  * in the black list.
1952  */
1953 static int is_dmi_valid(const char *field)
1954 {
1955         int i = 0;
1956
1957         while (dmi_blacklist[i]) {
1958                 if (strstr(field, dmi_blacklist[i]))
1959                         return 0;
1960                 i++;
1961         }
1962
1963         return 1;
1964 }
1965
1966 /**
1967  * snd_soc_set_dmi_name() - Register DMI names to card
1968  * @card: The card to register DMI names
1969  * @flavour: The flavour "differentiator" for the card amongst its peers.
1970  *
1971  * An Intel machine driver may be used by many different devices but are
1972  * difficult for userspace to differentiate, since machine drivers ususally
1973  * use their own name as the card short name and leave the card long name
1974  * blank. To differentiate such devices and fix bugs due to lack of
1975  * device-specific configurations, this function allows DMI info to be used
1976  * as the sound card long name, in the format of
1977  * "vendor-product-version-board"
1978  * (Character '-' is used to separate different DMI fields here).
1979  * This will help the user space to load the device-specific Use Case Manager
1980  * (UCM) configurations for the card.
1981  *
1982  * Possible card long names may be:
1983  * DellInc.-XPS139343-01-0310JH
1984  * ASUSTeKCOMPUTERINC.-T100TA-1.0-T100TA
1985  * Circuitco-MinnowboardMaxD0PLATFORM-D0-MinnowBoardMAX
1986  *
1987  * This function also supports flavoring the card longname to provide
1988  * the extra differentiation, like "vendor-product-version-board-flavor".
1989  *
1990  * We only keep number and alphabet characters and a few separator characters
1991  * in the card long name since UCM in the user space uses the card long names
1992  * as card configuration directory names and AudoConf cannot support special
1993  * charactors like SPACE.
1994  *
1995  * Returns 0 on success, otherwise a negative error code.
1996  */
1997 int snd_soc_set_dmi_name(struct snd_soc_card *card, const char *flavour)
1998 {
1999         const char *vendor, *product, *product_version, *board;
2000         size_t longname_buf_size = sizeof(card->snd_card->longname);
2001         size_t len;
2002
2003         if (card->long_name)
2004                 return 0; /* long name already set by driver or from DMI */
2005
2006         /* make up dmi long name as: vendor.product.version.board */
2007         vendor = dmi_get_system_info(DMI_BOARD_VENDOR);
2008         if (!vendor || !is_dmi_valid(vendor)) {
2009                 dev_warn(card->dev, "ASoC: no DMI vendor name!\n");
2010                 return 0;
2011         }
2012
2013
2014         snprintf(card->dmi_longname, sizeof(card->snd_card->longname),
2015                          "%s", vendor);
2016         cleanup_dmi_name(card->dmi_longname);
2017
2018         product = dmi_get_system_info(DMI_PRODUCT_NAME);
2019         if (product && is_dmi_valid(product)) {
2020                 len = strlen(card->dmi_longname);
2021                 snprintf(card->dmi_longname + len,
2022                          longname_buf_size - len,
2023                          "-%s", product);
2024
2025                 len++;  /* skip the separator "-" */
2026                 if (len < longname_buf_size)
2027                         cleanup_dmi_name(card->dmi_longname + len);
2028
2029                 /* some vendors like Lenovo may only put a self-explanatory
2030                  * name in the product version field
2031                  */
2032                 product_version = dmi_get_system_info(DMI_PRODUCT_VERSION);
2033                 if (product_version && is_dmi_valid(product_version)) {
2034                         len = strlen(card->dmi_longname);
2035                         snprintf(card->dmi_longname + len,
2036                                  longname_buf_size - len,
2037                                  "-%s", product_version);
2038
2039                         len++;
2040                         if (len < longname_buf_size)
2041                                 cleanup_dmi_name(card->dmi_longname + len);
2042                 }
2043         }
2044
2045         board = dmi_get_system_info(DMI_BOARD_NAME);
2046         if (board && is_dmi_valid(board)) {
2047                 len = strlen(card->dmi_longname);
2048                 snprintf(card->dmi_longname + len,
2049                          longname_buf_size - len,
2050                          "-%s", board);
2051
2052                 len++;
2053                 if (len < longname_buf_size)
2054                         cleanup_dmi_name(card->dmi_longname + len);
2055         } else if (!product) {
2056                 /* fall back to using legacy name */
2057                 dev_warn(card->dev, "ASoC: no DMI board/product name!\n");
2058                 return 0;
2059         }
2060
2061         /* Add flavour to dmi long name */
2062         if (flavour) {
2063                 len = strlen(card->dmi_longname);
2064                 snprintf(card->dmi_longname + len,
2065                          longname_buf_size - len,
2066                          "-%s", flavour);
2067
2068                 len++;
2069                 if (len < longname_buf_size)
2070                         cleanup_dmi_name(card->dmi_longname + len);
2071         }
2072
2073         /* set the card long name */
2074         card->long_name = card->dmi_longname;
2075
2076         return 0;
2077 }
2078 EXPORT_SYMBOL_GPL(snd_soc_set_dmi_name);
2079 #endif /* CONFIG_DMI */
2080
2081 static int snd_soc_instantiate_card(struct snd_soc_card *card)
2082 {
2083         struct snd_soc_codec *codec;
2084         struct snd_soc_pcm_runtime *rtd;
2085         struct snd_soc_dai_link *dai_link;
2086         int ret, i, order;
2087
2088         mutex_lock(&client_mutex);
2089         mutex_lock_nested(&card->mutex, SND_SOC_CARD_CLASS_INIT);
2090
2091         /* bind DAIs */
2092         for (i = 0; i < card->num_links; i++) {
2093                 ret = soc_bind_dai_link(card, &card->dai_link[i]);
2094                 if (ret != 0)
2095                         goto base_error;
2096         }
2097
2098         /* bind aux_devs too */
2099         for (i = 0; i < card->num_aux_devs; i++) {
2100                 ret = soc_bind_aux_dev(card, i);
2101                 if (ret != 0)
2102                         goto base_error;
2103         }
2104
2105         /* add predefined DAI links to the list */
2106         for (i = 0; i < card->num_links; i++)
2107                 snd_soc_add_dai_link(card, card->dai_link+i);
2108
2109         /* initialize the register cache for each available codec */
2110         list_for_each_entry(codec, &codec_list, list) {
2111                 if (codec->cache_init)
2112                         continue;
2113                 ret = snd_soc_init_codec_cache(codec);
2114                 if (ret < 0)
2115                         goto base_error;
2116         }
2117
2118         /* card bind complete so register a sound card */
2119         ret = snd_card_new(card->dev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1,
2120                         card->owner, 0, &card->snd_card);
2121         if (ret < 0) {
2122                 dev_err(card->dev,
2123                         "ASoC: can't create sound card for card %s: %d\n",
2124                         card->name, ret);
2125                 goto base_error;
2126         }
2127
2128         soc_init_card_debugfs(card);
2129
2130         card->dapm.bias_level = SND_SOC_BIAS_OFF;
2131         card->dapm.dev = card->dev;
2132         card->dapm.card = card;
2133         list_add(&card->dapm.list, &card->dapm_list);
2134
2135 #ifdef CONFIG_DEBUG_FS
2136         snd_soc_dapm_debugfs_init(&card->dapm, card->debugfs_card_root);
2137 #endif
2138
2139 #ifdef CONFIG_PM_SLEEP
2140         /* deferred resume work */
2141         INIT_WORK(&card->deferred_resume_work, soc_resume_deferred);
2142 #endif
2143
2144         if (card->dapm_widgets)
2145                 snd_soc_dapm_new_controls(&card->dapm, card->dapm_widgets,
2146                                           card->num_dapm_widgets);
2147
2148         if (card->of_dapm_widgets)
2149                 snd_soc_dapm_new_controls(&card->dapm, card->of_dapm_widgets,
2150                                           card->num_of_dapm_widgets);
2151
2152         /* initialise the sound card only once */
2153         if (card->probe) {
2154                 ret = card->probe(card);
2155                 if (ret < 0)
2156                         goto card_probe_error;
2157         }
2158
2159         /* probe all components used by DAI links on this card */
2160         for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
2161                         order++) {
2162                 list_for_each_entry(rtd, &card->rtd_list, list) {
2163                         ret = soc_probe_link_components(card, rtd, order);
2164                         if (ret < 0) {
2165                                 dev_err(card->dev,
2166                                         "ASoC: failed to instantiate card %d\n",
2167                                         ret);
2168                                 goto probe_dai_err;
2169                         }
2170                 }
2171         }
2172
2173         /* probe auxiliary components */
2174         ret = soc_probe_aux_devices(card);
2175         if (ret < 0)
2176                 goto probe_dai_err;
2177
2178         /* Find new DAI links added during probing components and bind them.
2179          * Components with topology may bring new DAIs and DAI links.
2180          */
2181         list_for_each_entry(dai_link, &card->dai_link_list, list) {
2182                 if (soc_is_dai_link_bound(card, dai_link))
2183                         continue;
2184
2185                 ret = soc_init_dai_link(card, dai_link);
2186                 if (ret)
2187                         goto probe_dai_err;
2188                 ret = soc_bind_dai_link(card, dai_link);
2189                 if (ret)
2190                         goto probe_dai_err;
2191         }
2192
2193         /* probe all DAI links on this card */
2194         for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
2195                         order++) {
2196                 list_for_each_entry(rtd, &card->rtd_list, list) {
2197                         ret = soc_probe_link_dais(card, rtd, order);
2198                         if (ret < 0) {
2199                                 dev_err(card->dev,
2200                                         "ASoC: failed to instantiate card %d\n",
2201                                         ret);
2202                                 goto probe_dai_err;
2203                         }
2204                 }
2205         }
2206
2207         snd_soc_dapm_link_dai_widgets(card);
2208         snd_soc_dapm_connect_dai_link_widgets(card);
2209
2210         if (card->controls)
2211                 snd_soc_add_card_controls(card, card->controls, card->num_controls);
2212
2213         if (card->dapm_routes)
2214                 snd_soc_dapm_add_routes(&card->dapm, card->dapm_routes,
2215                                         card->num_dapm_routes);
2216
2217         if (card->of_dapm_routes)
2218                 snd_soc_dapm_add_routes(&card->dapm, card->of_dapm_routes,
2219                                         card->num_of_dapm_routes);
2220
2221         /* try to set some sane longname if DMI is available */
2222         snd_soc_set_dmi_name(card, NULL);
2223
2224         snprintf(card->snd_card->shortname, sizeof(card->snd_card->shortname),
2225                  "%s", card->name);
2226         snprintf(card->snd_card->longname, sizeof(card->snd_card->longname),
2227                  "%s", card->long_name ? card->long_name : card->name);
2228         snprintf(card->snd_card->driver, sizeof(card->snd_card->driver),
2229                  "%s", card->driver_name ? card->driver_name : card->name);
2230         for (i = 0; i < ARRAY_SIZE(card->snd_card->driver); i++) {
2231                 switch (card->snd_card->driver[i]) {
2232                 case '_':
2233                 case '-':
2234                 case '\0':
2235                         break;
2236                 default:
2237                         if (!isalnum(card->snd_card->driver[i]))
2238                                 card->snd_card->driver[i] = '_';
2239                         break;
2240                 }
2241         }
2242
2243         if (card->late_probe) {
2244                 ret = card->late_probe(card);
2245                 if (ret < 0) {
2246                         dev_err(card->dev, "ASoC: %s late_probe() failed: %d\n",
2247                                 card->name, ret);
2248                         goto probe_aux_dev_err;
2249                 }
2250         }
2251
2252         snd_soc_dapm_new_widgets(card);
2253
2254         ret = snd_card_register(card->snd_card);
2255         if (ret < 0) {
2256                 dev_err(card->dev, "ASoC: failed to register soundcard %d\n",
2257                                 ret);
2258                 goto probe_aux_dev_err;
2259         }
2260
2261         card->instantiated = 1;
2262         snd_soc_dapm_sync(&card->dapm);
2263         mutex_unlock(&card->mutex);
2264         mutex_unlock(&client_mutex);
2265
2266         return 0;
2267
2268 probe_aux_dev_err:
2269         soc_remove_aux_devices(card);
2270
2271 probe_dai_err:
2272         soc_remove_dai_links(card);
2273
2274 card_probe_error:
2275         if (card->remove)
2276                 card->remove(card);
2277
2278         snd_soc_dapm_free(&card->dapm);
2279         soc_cleanup_card_debugfs(card);
2280         snd_card_free(card->snd_card);
2281
2282 base_error:
2283         soc_remove_pcm_runtimes(card);
2284         mutex_unlock(&card->mutex);
2285         mutex_unlock(&client_mutex);
2286
2287         return ret;
2288 }
2289
2290 /* probes a new socdev */
2291 static int soc_probe(struct platform_device *pdev)
2292 {
2293         struct snd_soc_card *card = platform_get_drvdata(pdev);
2294
2295         /*
2296          * no card, so machine driver should be registering card
2297          * we should not be here in that case so ret error
2298          */
2299         if (!card)
2300                 return -EINVAL;
2301
2302         dev_warn(&pdev->dev,
2303                  "ASoC: machine %s should use snd_soc_register_card()\n",
2304                  card->name);
2305
2306         /* Bodge while we unpick instantiation */
2307         card->dev = &pdev->dev;
2308
2309         return snd_soc_register_card(card);
2310 }
2311
2312 static int soc_cleanup_card_resources(struct snd_soc_card *card)
2313 {
2314         struct snd_soc_pcm_runtime *rtd;
2315
2316         /* make sure any delayed work runs */
2317         list_for_each_entry(rtd, &card->rtd_list, list)
2318                 flush_delayed_work(&rtd->delayed_work);
2319
2320         /* free the ALSA card at first; this syncs with pending operations */
2321         snd_card_free(card->snd_card);
2322
2323         /* remove and free each DAI */
2324         soc_remove_dai_links(card);
2325         soc_remove_pcm_runtimes(card);
2326
2327         /* remove auxiliary devices */
2328         soc_remove_aux_devices(card);
2329
2330         snd_soc_dapm_free(&card->dapm);
2331         soc_cleanup_card_debugfs(card);
2332
2333         /* remove the card */
2334         if (card->remove)
2335                 card->remove(card);
2336
2337         return 0;
2338 }
2339
2340 /* removes a socdev */
2341 static int soc_remove(struct platform_device *pdev)
2342 {
2343         struct snd_soc_card *card = platform_get_drvdata(pdev);
2344
2345         snd_soc_unregister_card(card);
2346         return 0;
2347 }
2348
2349 int snd_soc_poweroff(struct device *dev)
2350 {
2351         struct snd_soc_card *card = dev_get_drvdata(dev);
2352         struct snd_soc_pcm_runtime *rtd;
2353
2354         if (!card->instantiated)
2355                 return 0;
2356
2357         /* Flush out pmdown_time work - we actually do want to run it
2358          * now, we're shutting down so no imminent restart. */
2359         list_for_each_entry(rtd, &card->rtd_list, list)
2360                 flush_delayed_work(&rtd->delayed_work);
2361
2362         snd_soc_dapm_shutdown(card);
2363
2364         /* deactivate pins to sleep state */
2365         list_for_each_entry(rtd, &card->rtd_list, list) {
2366                 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
2367                 int i;
2368
2369                 pinctrl_pm_select_sleep_state(cpu_dai->dev);
2370                 for (i = 0; i < rtd->num_codecs; i++) {
2371                         struct snd_soc_dai *codec_dai = rtd->codec_dais[i];
2372                         pinctrl_pm_select_sleep_state(codec_dai->dev);
2373                 }
2374         }
2375
2376         return 0;
2377 }
2378 EXPORT_SYMBOL_GPL(snd_soc_poweroff);
2379
2380 const struct dev_pm_ops snd_soc_pm_ops = {
2381         .suspend = snd_soc_suspend,
2382         .resume = snd_soc_resume,
2383         .freeze = snd_soc_suspend,
2384         .thaw = snd_soc_resume,
2385         .poweroff = snd_soc_poweroff,
2386         .restore = snd_soc_resume,
2387 };
2388 EXPORT_SYMBOL_GPL(snd_soc_pm_ops);
2389
2390 /* ASoC platform driver */
2391 static struct platform_driver soc_driver = {
2392         .driver         = {
2393                 .name           = "soc-audio",
2394                 .pm             = &snd_soc_pm_ops,
2395         },
2396         .probe          = soc_probe,
2397         .remove         = soc_remove,
2398 };
2399
2400 /**
2401  * snd_soc_cnew - create new control
2402  * @_template: control template
2403  * @data: control private data
2404  * @long_name: control long name
2405  * @prefix: control name prefix
2406  *
2407  * Create a new mixer control from a template control.
2408  *
2409  * Returns 0 for success, else error.
2410  */
2411 struct snd_kcontrol *snd_soc_cnew(const struct snd_kcontrol_new *_template,
2412                                   void *data, const char *long_name,
2413                                   const char *prefix)
2414 {
2415         struct snd_kcontrol_new template;
2416         struct snd_kcontrol *kcontrol;
2417         char *name = NULL;
2418
2419         memcpy(&template, _template, sizeof(template));
2420         template.index = 0;
2421
2422         if (!long_name)
2423                 long_name = template.name;
2424
2425         if (prefix) {
2426                 name = kasprintf(GFP_KERNEL, "%s %s", prefix, long_name);
2427                 if (!name)
2428                         return NULL;
2429
2430                 template.name = name;
2431         } else {
2432                 template.name = long_name;
2433         }
2434
2435         kcontrol = snd_ctl_new1(&template, data);
2436
2437         kfree(name);
2438
2439         return kcontrol;
2440 }
2441 EXPORT_SYMBOL_GPL(snd_soc_cnew);
2442
2443 static int snd_soc_add_controls(struct snd_card *card, struct device *dev,
2444         const struct snd_kcontrol_new *controls, int num_controls,
2445         const char *prefix, void *data)
2446 {
2447         int err, i;
2448
2449         for (i = 0; i < num_controls; i++) {
2450                 const struct snd_kcontrol_new *control = &controls[i];
2451                 err = snd_ctl_add(card, snd_soc_cnew(control, data,
2452                                                      control->name, prefix));
2453                 if (err < 0) {
2454                         dev_err(dev, "ASoC: Failed to add %s: %d\n",
2455                                 control->name, err);
2456                         return err;
2457                 }
2458         }
2459
2460         return 0;
2461 }
2462
2463 struct snd_kcontrol *snd_soc_card_get_kcontrol(struct snd_soc_card *soc_card,
2464                                                const char *name)
2465 {
2466         struct snd_card *card = soc_card->snd_card;
2467         struct snd_kcontrol *kctl;
2468
2469         if (unlikely(!name))
2470                 return NULL;
2471
2472         list_for_each_entry(kctl, &card->controls, list)
2473                 if (!strncmp(kctl->id.name, name, sizeof(kctl->id.name)))
2474                         return kctl;
2475         return NULL;
2476 }
2477 EXPORT_SYMBOL_GPL(snd_soc_card_get_kcontrol);
2478
2479 /**
2480  * snd_soc_add_component_controls - Add an array of controls to a component.
2481  *
2482  * @component: Component to add controls to
2483  * @controls: Array of controls to add
2484  * @num_controls: Number of elements in the array
2485  *
2486  * Return: 0 for success, else error.
2487  */
2488 int snd_soc_add_component_controls(struct snd_soc_component *component,
2489         const struct snd_kcontrol_new *controls, unsigned int num_controls)
2490 {
2491         struct snd_card *card = component->card->snd_card;
2492
2493         return snd_soc_add_controls(card, component->dev, controls,
2494                         num_controls, component->name_prefix, component);
2495 }
2496 EXPORT_SYMBOL_GPL(snd_soc_add_component_controls);
2497
2498 /**
2499  * snd_soc_add_codec_controls - add an array of controls to a codec.
2500  * Convenience function to add a list of controls. Many codecs were
2501  * duplicating this code.
2502  *
2503  * @codec: codec to add controls to
2504  * @controls: array of controls to add
2505  * @num_controls: number of elements in the array
2506  *
2507  * Return 0 for success, else error.
2508  */
2509 int snd_soc_add_codec_controls(struct snd_soc_codec *codec,
2510         const struct snd_kcontrol_new *controls, unsigned int num_controls)
2511 {
2512         return snd_soc_add_component_controls(&codec->component, controls,
2513                 num_controls);
2514 }
2515 EXPORT_SYMBOL_GPL(snd_soc_add_codec_controls);
2516
2517 /**
2518  * snd_soc_add_platform_controls - add an array of controls to a platform.
2519  * Convenience function to add a list of controls.
2520  *
2521  * @platform: platform to add controls to
2522  * @controls: array of controls to add
2523  * @num_controls: number of elements in the array
2524  *
2525  * Return 0 for success, else error.
2526  */
2527 int snd_soc_add_platform_controls(struct snd_soc_platform *platform,
2528         const struct snd_kcontrol_new *controls, unsigned int num_controls)
2529 {
2530         return snd_soc_add_component_controls(&platform->component, controls,
2531                 num_controls);
2532 }
2533 EXPORT_SYMBOL_GPL(snd_soc_add_platform_controls);
2534
2535 /**
2536  * snd_soc_add_card_controls - add an array of controls to a SoC card.
2537  * Convenience function to add a list of controls.
2538  *
2539  * @soc_card: SoC card to add controls to
2540  * @controls: array of controls to add
2541  * @num_controls: number of elements in the array
2542  *
2543  * Return 0 for success, else error.
2544  */
2545 int snd_soc_add_card_controls(struct snd_soc_card *soc_card,
2546         const struct snd_kcontrol_new *controls, int num_controls)
2547 {
2548         struct snd_card *card = soc_card->snd_card;
2549
2550         return snd_soc_add_controls(card, soc_card->dev, controls, num_controls,
2551                         NULL, soc_card);
2552 }
2553 EXPORT_SYMBOL_GPL(snd_soc_add_card_controls);
2554
2555 /**
2556  * snd_soc_add_dai_controls - add an array of controls to a DAI.
2557  * Convienience function to add a list of controls.
2558  *
2559  * @dai: DAI to add controls to
2560  * @controls: array of controls to add
2561  * @num_controls: number of elements in the array
2562  *
2563  * Return 0 for success, else error.
2564  */
2565 int snd_soc_add_dai_controls(struct snd_soc_dai *dai,
2566         const struct snd_kcontrol_new *controls, int num_controls)
2567 {
2568         struct snd_card *card = dai->component->card->snd_card;
2569
2570         return snd_soc_add_controls(card, dai->dev, controls, num_controls,
2571                         NULL, dai);
2572 }
2573 EXPORT_SYMBOL_GPL(snd_soc_add_dai_controls);
2574
2575 /**
2576  * snd_soc_dai_set_sysclk - configure DAI system or master clock.
2577  * @dai: DAI
2578  * @clk_id: DAI specific clock ID
2579  * @freq: new clock frequency in Hz
2580  * @dir: new clock direction - input/output.
2581  *
2582  * Configures the DAI master (MCLK) or system (SYSCLK) clocking.
2583  */
2584 int snd_soc_dai_set_sysclk(struct snd_soc_dai *dai, int clk_id,
2585         unsigned int freq, int dir)
2586 {
2587         if (dai->driver && dai->driver->ops->set_sysclk)
2588                 return dai->driver->ops->set_sysclk(dai, clk_id, freq, dir);
2589         else if (dai->codec && dai->codec->driver->set_sysclk)
2590                 return dai->codec->driver->set_sysclk(dai->codec, clk_id, 0,
2591                                                       freq, dir);
2592         else
2593                 return -ENOTSUPP;
2594 }
2595 EXPORT_SYMBOL_GPL(snd_soc_dai_set_sysclk);
2596
2597 /**
2598  * snd_soc_codec_set_sysclk - configure CODEC system or master clock.
2599  * @codec: CODEC
2600  * @clk_id: DAI specific clock ID
2601  * @source: Source for the clock
2602  * @freq: new clock frequency in Hz
2603  * @dir: new clock direction - input/output.
2604  *
2605  * Configures the CODEC master (MCLK) or system (SYSCLK) clocking.
2606  */
2607 int snd_soc_codec_set_sysclk(struct snd_soc_codec *codec, int clk_id,
2608                              int source, unsigned int freq, int dir)
2609 {
2610         if (codec->driver->set_sysclk)
2611                 return codec->driver->set_sysclk(codec, clk_id, source,
2612                                                  freq, dir);
2613         else
2614                 return -ENOTSUPP;
2615 }
2616 EXPORT_SYMBOL_GPL(snd_soc_codec_set_sysclk);
2617
2618 /**
2619  * snd_soc_dai_set_clkdiv - configure DAI clock dividers.
2620  * @dai: DAI
2621  * @div_id: DAI specific clock divider ID
2622  * @div: new clock divisor.
2623  *
2624  * Configures the clock dividers. This is used to derive the best DAI bit and
2625  * frame clocks from the system or master clock. It's best to set the DAI bit
2626  * and frame clocks as low as possible to save system power.
2627  */
2628 int snd_soc_dai_set_clkdiv(struct snd_soc_dai *dai,
2629         int div_id, int div)
2630 {
2631         if (dai->driver && dai->driver->ops->set_clkdiv)
2632                 return dai->driver->ops->set_clkdiv(dai, div_id, div);
2633         else
2634                 return -EINVAL;
2635 }
2636 EXPORT_SYMBOL_GPL(snd_soc_dai_set_clkdiv);
2637
2638 /**
2639  * snd_soc_dai_set_pll - configure DAI PLL.
2640  * @dai: DAI
2641  * @pll_id: DAI specific PLL ID
2642  * @source: DAI specific source for the PLL
2643  * @freq_in: PLL input clock frequency in Hz
2644  * @freq_out: requested PLL output clock frequency in Hz
2645  *
2646  * Configures and enables PLL to generate output clock based on input clock.
2647  */
2648 int snd_soc_dai_set_pll(struct snd_soc_dai *dai, int pll_id, int source,
2649         unsigned int freq_in, unsigned int freq_out)
2650 {
2651         if (dai->driver && dai->driver->ops->set_pll)
2652                 return dai->driver->ops->set_pll(dai, pll_id, source,
2653                                          freq_in, freq_out);
2654         else if (dai->codec && dai->codec->driver->set_pll)
2655                 return dai->codec->driver->set_pll(dai->codec, pll_id, source,
2656                                                    freq_in, freq_out);
2657         else
2658                 return -EINVAL;
2659 }
2660 EXPORT_SYMBOL_GPL(snd_soc_dai_set_pll);
2661
2662 /*
2663  * snd_soc_codec_set_pll - configure codec PLL.
2664  * @codec: CODEC
2665  * @pll_id: DAI specific PLL ID
2666  * @source: DAI specific source for the PLL
2667  * @freq_in: PLL input clock frequency in Hz
2668  * @freq_out: requested PLL output clock frequency in Hz
2669  *
2670  * Configures and enables PLL to generate output clock based on input clock.
2671  */
2672 int snd_soc_codec_set_pll(struct snd_soc_codec *codec, int pll_id, int source,
2673                           unsigned int freq_in, unsigned int freq_out)
2674 {
2675         if (codec->driver->set_pll)
2676                 return codec->driver->set_pll(codec, pll_id, source,
2677                                               freq_in, freq_out);
2678         else
2679                 return -EINVAL;
2680 }
2681 EXPORT_SYMBOL_GPL(snd_soc_codec_set_pll);
2682
2683 /**
2684  * snd_soc_dai_set_bclk_ratio - configure BCLK to sample rate ratio.
2685  * @dai: DAI
2686  * @ratio: Ratio of BCLK to Sample rate.
2687  *
2688  * Configures the DAI for a preset BCLK to sample rate ratio.
2689  */
2690 int snd_soc_dai_set_bclk_ratio(struct snd_soc_dai *dai, unsigned int ratio)
2691 {
2692         if (dai->driver && dai->driver->ops->set_bclk_ratio)
2693                 return dai->driver->ops->set_bclk_ratio(dai, ratio);
2694         else
2695                 return -EINVAL;
2696 }
2697 EXPORT_SYMBOL_GPL(snd_soc_dai_set_bclk_ratio);
2698
2699 /**
2700  * snd_soc_dai_set_fmt - configure DAI hardware audio format.
2701  * @dai: DAI
2702  * @fmt: SND_SOC_DAIFMT_ format value.
2703  *
2704  * Configures the DAI hardware format and clocking.
2705  */
2706 int snd_soc_dai_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)
2707 {
2708         if (dai->driver == NULL)
2709                 return -EINVAL;
2710         if (dai->driver->ops->set_fmt == NULL)
2711                 return -ENOTSUPP;
2712         return dai->driver->ops->set_fmt(dai, fmt);
2713 }
2714 EXPORT_SYMBOL_GPL(snd_soc_dai_set_fmt);
2715
2716 /**
2717  * snd_soc_xlate_tdm_slot - generate tx/rx slot mask.
2718  * @slots: Number of slots in use.
2719  * @tx_mask: bitmask representing active TX slots.
2720  * @rx_mask: bitmask representing active RX slots.
2721  *
2722  * Generates the TDM tx and rx slot default masks for DAI.
2723  */
2724 static int snd_soc_xlate_tdm_slot_mask(unsigned int slots,
2725                                           unsigned int *tx_mask,
2726                                           unsigned int *rx_mask)
2727 {
2728         if (*tx_mask || *rx_mask)
2729                 return 0;
2730
2731         if (!slots)
2732                 return -EINVAL;
2733
2734         *tx_mask = (1 << slots) - 1;
2735         *rx_mask = (1 << slots) - 1;
2736
2737         return 0;
2738 }
2739
2740 /**
2741  * snd_soc_dai_set_tdm_slot() - Configures a DAI for TDM operation
2742  * @dai: The DAI to configure
2743  * @tx_mask: bitmask representing active TX slots.
2744  * @rx_mask: bitmask representing active RX slots.
2745  * @slots: Number of slots in use.
2746  * @slot_width: Width in bits for each slot.
2747  *
2748  * This function configures the specified DAI for TDM operation. @slot contains
2749  * the total number of slots of the TDM stream and @slot_with the width of each
2750  * slot in bit clock cycles. @tx_mask and @rx_mask are bitmasks specifying the
2751  * active slots of the TDM stream for the specified DAI, i.e. which slots the
2752  * DAI should write to or read from. If a bit is set the corresponding slot is
2753  * active, if a bit is cleared the corresponding slot is inactive. Bit 0 maps to
2754  * the first slot, bit 1 to the second slot and so on. The first active slot
2755  * maps to the first channel of the DAI, the second active slot to the second
2756  * channel and so on.
2757  *
2758  * TDM mode can be disabled by passing 0 for @slots. In this case @tx_mask,
2759  * @rx_mask and @slot_width will be ignored.
2760  *
2761  * Returns 0 on success, a negative error code otherwise.
2762  */
2763 int snd_soc_dai_set_tdm_slot(struct snd_soc_dai *dai,
2764         unsigned int tx_mask, unsigned int rx_mask, int slots, int slot_width)
2765 {
2766         if (dai->driver && dai->driver->ops->xlate_tdm_slot_mask)
2767                 dai->driver->ops->xlate_tdm_slot_mask(slots,
2768                                                 &tx_mask, &rx_mask);
2769         else
2770                 snd_soc_xlate_tdm_slot_mask(slots, &tx_mask, &rx_mask);
2771
2772         dai->tx_mask = tx_mask;
2773         dai->rx_mask = rx_mask;
2774
2775         if (dai->driver && dai->driver->ops->set_tdm_slot)
2776                 return dai->driver->ops->set_tdm_slot(dai, tx_mask, rx_mask,
2777                                 slots, slot_width);
2778         else
2779                 return -ENOTSUPP;
2780 }
2781 EXPORT_SYMBOL_GPL(snd_soc_dai_set_tdm_slot);
2782
2783 /**
2784  * snd_soc_dai_set_channel_map - configure DAI audio channel map
2785  * @dai: DAI
2786  * @tx_num: how many TX channels
2787  * @tx_slot: pointer to an array which imply the TX slot number channel
2788  *           0~num-1 uses
2789  * @rx_num: how many RX channels
2790  * @rx_slot: pointer to an array which imply the RX slot number channel
2791  *           0~num-1 uses
2792  *
2793  * configure the relationship between channel number and TDM slot number.
2794  */
2795 int snd_soc_dai_set_channel_map(struct snd_soc_dai *dai,
2796         unsigned int tx_num, unsigned int *tx_slot,
2797         unsigned int rx_num, unsigned int *rx_slot)
2798 {
2799         if (dai->driver && dai->driver->ops->set_channel_map)
2800                 return dai->driver->ops->set_channel_map(dai, tx_num, tx_slot,
2801                         rx_num, rx_slot);
2802         else
2803                 return -EINVAL;
2804 }
2805 EXPORT_SYMBOL_GPL(snd_soc_dai_set_channel_map);
2806
2807 /**
2808  * snd_soc_dai_set_tristate - configure DAI system or master clock.
2809  * @dai: DAI
2810  * @tristate: tristate enable
2811  *
2812  * Tristates the DAI so that others can use it.
2813  */
2814 int snd_soc_dai_set_tristate(struct snd_soc_dai *dai, int tristate)
2815 {
2816         if (dai->driver && dai->driver->ops->set_tristate)
2817                 return dai->driver->ops->set_tristate(dai, tristate);
2818         else
2819                 return -EINVAL;
2820 }
2821 EXPORT_SYMBOL_GPL(snd_soc_dai_set_tristate);
2822
2823 /**
2824  * snd_soc_dai_digital_mute - configure DAI system or master clock.
2825  * @dai: DAI
2826  * @mute: mute enable
2827  * @direction: stream to mute
2828  *
2829  * Mutes the DAI DAC.
2830  */
2831 int snd_soc_dai_digital_mute(struct snd_soc_dai *dai, int mute,
2832                              int direction)
2833 {
2834         if (!dai->driver)
2835                 return -ENOTSUPP;
2836
2837         if (dai->driver->ops->mute_stream)
2838                 return dai->driver->ops->mute_stream(dai, mute, direction);
2839         else if (direction == SNDRV_PCM_STREAM_PLAYBACK &&
2840                  dai->driver->ops->digital_mute)
2841                 return dai->driver->ops->digital_mute(dai, mute);
2842         else
2843                 return -ENOTSUPP;
2844 }
2845 EXPORT_SYMBOL_GPL(snd_soc_dai_digital_mute);
2846
2847 /**
2848  * snd_soc_register_card - Register a card with the ASoC core
2849  *
2850  * @card: Card to register
2851  *
2852  */
2853 int snd_soc_register_card(struct snd_soc_card *card)
2854 {
2855         int i, ret;
2856         struct snd_soc_pcm_runtime *rtd;
2857
2858         if (!card->name || !card->dev)
2859                 return -EINVAL;
2860
2861         for (i = 0; i < card->num_links; i++) {
2862                 struct snd_soc_dai_link *link = &card->dai_link[i];
2863
2864                 ret = soc_init_dai_link(card, link);
2865                 if (ret) {
2866                         dev_err(card->dev, "ASoC: failed to init link %s\n",
2867                                 link->name);
2868                         return ret;
2869                 }
2870         }
2871
2872         dev_set_drvdata(card->dev, card);
2873
2874         snd_soc_initialize_card_lists(card);
2875
2876         INIT_LIST_HEAD(&card->dai_link_list);
2877         card->num_dai_links = 0;
2878
2879         INIT_LIST_HEAD(&card->rtd_list);
2880         card->num_rtd = 0;
2881
2882         INIT_LIST_HEAD(&card->dapm_dirty);
2883         INIT_LIST_HEAD(&card->dobj_list);
2884         card->instantiated = 0;
2885         mutex_init(&card->mutex);
2886         mutex_init(&card->dapm_mutex);
2887
2888         ret = snd_soc_instantiate_card(card);
2889         if (ret != 0)
2890                 return ret;
2891
2892         /* deactivate pins to sleep state */
2893         list_for_each_entry(rtd, &card->rtd_list, list)  {
2894                 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
2895                 int j;
2896
2897                 for (j = 0; j < rtd->num_codecs; j++) {
2898                         struct snd_soc_dai *codec_dai = rtd->codec_dais[j];
2899                         if (!codec_dai->active)
2900                                 pinctrl_pm_select_sleep_state(codec_dai->dev);
2901                 }
2902
2903                 if (!cpu_dai->active)
2904                         pinctrl_pm_select_sleep_state(cpu_dai->dev);
2905         }
2906
2907         return ret;
2908 }
2909 EXPORT_SYMBOL_GPL(snd_soc_register_card);
2910
2911 /**
2912  * snd_soc_unregister_card - Unregister a card with the ASoC core
2913  *
2914  * @card: Card to unregister
2915  *
2916  */
2917 int snd_soc_unregister_card(struct snd_soc_card *card)
2918 {
2919         if (card->instantiated) {
2920                 card->instantiated = false;
2921                 snd_soc_dapm_shutdown(card);
2922                 soc_cleanup_card_resources(card);
2923                 dev_dbg(card->dev, "ASoC: Unregistered card '%s'\n", card->name);
2924         }
2925
2926         return 0;
2927 }
2928 EXPORT_SYMBOL_GPL(snd_soc_unregister_card);
2929
2930 /*
2931  * Simplify DAI link configuration by removing ".-1" from device names
2932  * and sanitizing names.
2933  */
2934 static char *fmt_single_name(struct device *dev, int *id)
2935 {
2936         char *found, name[NAME_SIZE];
2937         int id1, id2;
2938
2939         if (dev_name(dev) == NULL)
2940                 return NULL;
2941
2942         strlcpy(name, dev_name(dev), NAME_SIZE);
2943
2944         /* are we a "%s.%d" name (platform and SPI components) */
2945         found = strstr(name, dev->driver->name);
2946         if (found) {
2947                 /* get ID */
2948                 if (sscanf(&found[strlen(dev->driver->name)], ".%d", id) == 1) {
2949
2950                         /* discard ID from name if ID == -1 */
2951                         if (*id == -1)
2952                                 found[strlen(dev->driver->name)] = '\0';
2953                 }
2954
2955         } else {
2956                 /* I2C component devices are named "bus-addr"  */
2957                 if (sscanf(name, "%x-%x", &id1, &id2) == 2) {
2958                         char tmp[NAME_SIZE];
2959
2960                         /* create unique ID number from I2C addr and bus */
2961                         *id = ((id1 & 0xffff) << 16) + id2;
2962
2963                         /* sanitize component name for DAI link creation */
2964                         snprintf(tmp, NAME_SIZE, "%s.%s", dev->driver->name, name);
2965                         strlcpy(name, tmp, NAME_SIZE);
2966                 } else
2967                         *id = 0;
2968         }
2969
2970         return kstrdup(name, GFP_KERNEL);
2971 }
2972
2973 /*
2974  * Simplify DAI link naming for single devices with multiple DAIs by removing
2975  * any ".-1" and using the DAI name (instead of device name).
2976  */
2977 static inline char *fmt_multiple_name(struct device *dev,
2978                 struct snd_soc_dai_driver *dai_drv)
2979 {
2980         if (dai_drv->name == NULL) {
2981                 dev_err(dev,
2982                         "ASoC: error - multiple DAI %s registered with no name\n",
2983                         dev_name(dev));
2984                 return NULL;
2985         }
2986
2987         return kstrdup(dai_drv->name, GFP_KERNEL);
2988 }
2989
2990 /**
2991  * snd_soc_unregister_dai - Unregister DAIs from the ASoC core
2992  *
2993  * @component: The component for which the DAIs should be unregistered
2994  */
2995 static void snd_soc_unregister_dais(struct snd_soc_component *component)
2996 {
2997         struct snd_soc_dai *dai, *_dai;
2998
2999         list_for_each_entry_safe(dai, _dai, &component->dai_list, list) {
3000                 dev_dbg(component->dev, "ASoC: Unregistered DAI '%s'\n",
3001                         dai->name);
3002                 list_del(&dai->list);
3003                 kfree(dai->name);
3004                 kfree(dai);
3005         }
3006 }
3007
3008 /* Create a DAI and add it to the component's DAI list */
3009 static struct snd_soc_dai *soc_add_dai(struct snd_soc_component *component,
3010         struct snd_soc_dai_driver *dai_drv,
3011         bool legacy_dai_naming)
3012 {
3013         struct device *dev = component->dev;
3014         struct snd_soc_dai *dai;
3015
3016         dev_dbg(dev, "ASoC: dynamically register DAI %s\n", dev_name(dev));
3017
3018         dai = kzalloc(sizeof(struct snd_soc_dai), GFP_KERNEL);
3019         if (dai == NULL)
3020                 return NULL;
3021
3022         /*
3023          * Back in the old days when we still had component-less DAIs,
3024          * instead of having a static name, component-less DAIs would
3025          * inherit the name of the parent device so it is possible to
3026          * register multiple instances of the DAI. We still need to keep
3027          * the same naming style even though those DAIs are not
3028          * component-less anymore.
3029          */
3030         if (legacy_dai_naming &&
3031            (dai_drv->id == 0 || dai_drv->name == NULL)) {
3032                 dai->name = fmt_single_name(dev, &dai->id);
3033         } else {
3034                 dai->name = fmt_multiple_name(dev, dai_drv);
3035                 if (dai_drv->id)
3036                         dai->id = dai_drv->id;
3037                 else
3038                         dai->id = component->num_dai;
3039         }
3040         if (dai->name == NULL) {
3041                 kfree(dai);
3042                 return NULL;
3043         }
3044
3045         dai->component = component;
3046         dai->dev = dev;
3047         dai->driver = dai_drv;
3048         if (!dai->driver->ops)
3049                 dai->driver->ops = &null_dai_ops;
3050
3051         list_add(&dai->list, &component->dai_list);
3052         component->num_dai++;
3053
3054         dev_dbg(dev, "ASoC: Registered DAI '%s'\n", dai->name);
3055         return dai;
3056 }
3057
3058 /**
3059  * snd_soc_register_dais - Register a DAI with the ASoC core
3060  *
3061  * @component: The component the DAIs are registered for
3062  * @dai_drv: DAI driver to use for the DAIs
3063  * @count: Number of DAIs
3064  * @legacy_dai_naming: Use the legacy naming scheme and let the DAI inherit the
3065  *                     parent's name.
3066  */
3067 static int snd_soc_register_dais(struct snd_soc_component *component,
3068         struct snd_soc_dai_driver *dai_drv, size_t count,
3069         bool legacy_dai_naming)
3070 {
3071         struct device *dev = component->dev;
3072         struct snd_soc_dai *dai;
3073         unsigned int i;
3074         int ret;
3075
3076         dev_dbg(dev, "ASoC: dai register %s #%zu\n", dev_name(dev), count);
3077
3078         component->dai_drv = dai_drv;
3079
3080         for (i = 0; i < count; i++) {
3081
3082                 dai = soc_add_dai(component, dai_drv + i,
3083                                 count == 1 && legacy_dai_naming);
3084                 if (dai == NULL) {
3085                         ret = -ENOMEM;
3086                         goto err;
3087                 }
3088         }
3089
3090         return 0;
3091
3092 err:
3093         snd_soc_unregister_dais(component);
3094
3095         return ret;
3096 }
3097
3098 /**
3099  * snd_soc_register_dai - Register a DAI dynamically & create its widgets
3100  *
3101  * @component: The component the DAIs are registered for
3102  * @dai_drv: DAI driver to use for the DAI
3103  *
3104  * Topology can use this API to register DAIs when probing a component.
3105  * These DAIs's widgets will be freed in the card cleanup and the DAIs
3106  * will be freed in the component cleanup.
3107  */
3108 int snd_soc_register_dai(struct snd_soc_component *component,
3109         struct snd_soc_dai_driver *dai_drv)
3110 {
3111         struct snd_soc_dapm_context *dapm =
3112                 snd_soc_component_get_dapm(component);
3113         struct snd_soc_dai *dai;
3114         int ret;
3115
3116         if (dai_drv->dobj.type != SND_SOC_DOBJ_PCM) {
3117                 dev_err(component->dev, "Invalid dai type %d\n",
3118                         dai_drv->dobj.type);
3119                 return -EINVAL;
3120         }
3121
3122         lockdep_assert_held(&client_mutex);
3123         dai = soc_add_dai(component, dai_drv, false);
3124         if (!dai)
3125                 return -ENOMEM;
3126
3127         /* Create the DAI widgets here. After adding DAIs, topology may
3128          * also add routes that need these widgets as source or sink.
3129          */
3130         ret = snd_soc_dapm_new_dai_widgets(dapm, dai);
3131         if (ret != 0) {
3132                 dev_err(component->dev,
3133                         "Failed to create DAI widgets %d\n", ret);
3134         }
3135
3136         return ret;
3137 }
3138 EXPORT_SYMBOL_GPL(snd_soc_register_dai);
3139
3140 static void snd_soc_component_seq_notifier(struct snd_soc_dapm_context *dapm,
3141         enum snd_soc_dapm_type type, int subseq)
3142 {
3143         struct snd_soc_component *component = dapm->component;
3144
3145         component->driver->seq_notifier(component, type, subseq);
3146 }
3147
3148 static int snd_soc_component_stream_event(struct snd_soc_dapm_context *dapm,
3149         int event)
3150 {
3151         struct snd_soc_component *component = dapm->component;
3152
3153         return component->driver->stream_event(component, event);
3154 }
3155
3156 static int snd_soc_component_initialize(struct snd_soc_component *component,
3157         const struct snd_soc_component_driver *driver, struct device *dev)
3158 {
3159         struct snd_soc_dapm_context *dapm;
3160
3161         component->name = fmt_single_name(dev, &component->id);
3162         if (!component->name) {
3163                 dev_err(dev, "ASoC: Failed to allocate name\n");
3164                 return -ENOMEM;
3165         }
3166
3167         component->dev = dev;
3168         component->driver = driver;
3169         component->probe = component->driver->probe;
3170         component->remove = component->driver->remove;
3171         component->suspend = component->driver->suspend;
3172         component->resume = component->driver->resume;
3173         component->pcm_new = component->driver->pcm_new;
3174         component->pcm_free = component->driver->pcm_free;
3175
3176         dapm = &component->dapm;
3177         dapm->dev = dev;
3178         dapm->component = component;
3179         dapm->bias_level = SND_SOC_BIAS_OFF;
3180         dapm->idle_bias_off = true;
3181         if (driver->seq_notifier)
3182                 dapm->seq_notifier = snd_soc_component_seq_notifier;
3183         if (driver->stream_event)
3184                 dapm->stream_event = snd_soc_component_stream_event;
3185
3186         component->controls = driver->controls;
3187         component->num_controls = driver->num_controls;
3188         component->dapm_widgets = driver->dapm_widgets;
3189         component->num_dapm_widgets = driver->num_dapm_widgets;
3190         component->dapm_routes = driver->dapm_routes;
3191         component->num_dapm_routes = driver->num_dapm_routes;
3192
3193         INIT_LIST_HEAD(&component->dai_list);
3194         mutex_init(&component->io_mutex);
3195
3196         return 0;
3197 }
3198
3199 static void snd_soc_component_setup_regmap(struct snd_soc_component *component)
3200 {
3201         int val_bytes = regmap_get_val_bytes(component->regmap);
3202
3203         /* Errors are legitimate for non-integer byte multiples */
3204         if (val_bytes > 0)
3205                 component->val_bytes = val_bytes;
3206 }
3207
3208 #ifdef CONFIG_REGMAP
3209
3210 /**
3211  * snd_soc_component_init_regmap() - Initialize regmap instance for the component
3212  * @component: The component for which to initialize the regmap instance
3213  * @regmap: The regmap instance that should be used by the component
3214  *
3215  * This function allows deferred assignment of the regmap instance that is
3216  * associated with the component. Only use this if the regmap instance is not
3217  * yet ready when the component is registered. The function must also be called
3218  * before the first IO attempt of the component.
3219  */
3220 void snd_soc_component_init_regmap(struct snd_soc_component *component,
3221         struct regmap *regmap)
3222 {
3223         component->regmap = regmap;
3224         snd_soc_component_setup_regmap(component);
3225 }
3226 EXPORT_SYMBOL_GPL(snd_soc_component_init_regmap);
3227
3228 /**
3229  * snd_soc_component_exit_regmap() - De-initialize regmap instance for the component
3230  * @component: The component for which to de-initialize the regmap instance
3231  *
3232  * Calls regmap_exit() on the regmap instance associated to the component and
3233  * removes the regmap instance from the component.
3234  *
3235  * This function should only be used if snd_soc_component_init_regmap() was used
3236  * to initialize the regmap instance.
3237  */
3238 void snd_soc_component_exit_regmap(struct snd_soc_component *component)
3239 {
3240         regmap_exit(component->regmap);
3241         component->regmap = NULL;
3242 }
3243 EXPORT_SYMBOL_GPL(snd_soc_component_exit_regmap);
3244
3245 #endif
3246
3247 static void snd_soc_component_add_unlocked(struct snd_soc_component *component)
3248 {
3249         if (!component->write && !component->read) {
3250                 if (!component->regmap)
3251                         component->regmap = dev_get_regmap(component->dev, NULL);
3252                 if (component->regmap)
3253                         snd_soc_component_setup_regmap(component);
3254         }
3255
3256         list_add(&component->list, &component_list);
3257         INIT_LIST_HEAD(&component->dobj_list);
3258 }
3259
3260 static void snd_soc_component_add(struct snd_soc_component *component)
3261 {
3262         mutex_lock(&client_mutex);
3263         snd_soc_component_add_unlocked(component);
3264         mutex_unlock(&client_mutex);
3265 }
3266
3267 static void snd_soc_component_cleanup(struct snd_soc_component *component)
3268 {
3269         snd_soc_unregister_dais(component);
3270         kfree(component->name);
3271 }
3272
3273 static void snd_soc_component_del_unlocked(struct snd_soc_component *component)
3274 {
3275         struct snd_soc_card *card = component->card;
3276
3277         if (card)
3278                 snd_soc_unregister_card(card);
3279
3280         list_del(&component->list);
3281 }
3282
3283 int snd_soc_register_component(struct device *dev,
3284                                const struct snd_soc_component_driver *cmpnt_drv,
3285                                struct snd_soc_dai_driver *dai_drv,
3286                                int num_dai)
3287 {
3288         struct snd_soc_component *cmpnt;
3289         int ret;
3290
3291         cmpnt = kzalloc(sizeof(*cmpnt), GFP_KERNEL);
3292         if (!cmpnt) {
3293                 dev_err(dev, "ASoC: Failed to allocate memory\n");
3294                 return -ENOMEM;
3295         }
3296
3297         ret = snd_soc_component_initialize(cmpnt, cmpnt_drv, dev);
3298         if (ret)
3299                 goto err_free;
3300
3301         cmpnt->ignore_pmdown_time = true;
3302         cmpnt->registered_as_component = true;
3303
3304         ret = snd_soc_register_dais(cmpnt, dai_drv, num_dai, true);
3305         if (ret < 0) {
3306                 dev_err(dev, "ASoC: Failed to register DAIs: %d\n", ret);
3307                 goto err_cleanup;
3308         }
3309
3310         snd_soc_component_add(cmpnt);
3311
3312         return 0;
3313
3314 err_cleanup:
3315         snd_soc_component_cleanup(cmpnt);
3316 err_free:
3317         kfree(cmpnt);
3318         return ret;
3319 }
3320 EXPORT_SYMBOL_GPL(snd_soc_register_component);
3321
3322 /**
3323  * snd_soc_unregister_component - Unregister a component from the ASoC core
3324  *
3325  * @dev: The device to unregister
3326  */
3327 void snd_soc_unregister_component(struct device *dev)
3328 {
3329         struct snd_soc_component *cmpnt;
3330
3331         mutex_lock(&client_mutex);
3332         list_for_each_entry(cmpnt, &component_list, list) {
3333                 if (dev == cmpnt->dev && cmpnt->registered_as_component)
3334                         goto found;
3335         }
3336         mutex_unlock(&client_mutex);
3337         return;
3338
3339 found:
3340         snd_soc_tplg_component_remove(cmpnt, SND_SOC_TPLG_INDEX_ALL);
3341         snd_soc_component_del_unlocked(cmpnt);
3342         mutex_unlock(&client_mutex);
3343         snd_soc_component_cleanup(cmpnt);
3344         kfree(cmpnt);
3345 }
3346 EXPORT_SYMBOL_GPL(snd_soc_unregister_component);
3347
3348 static int snd_soc_platform_drv_probe(struct snd_soc_component *component)
3349 {
3350         struct snd_soc_platform *platform = snd_soc_component_to_platform(component);
3351
3352         return platform->driver->probe(platform);
3353 }
3354
3355 static void snd_soc_platform_drv_remove(struct snd_soc_component *component)
3356 {
3357         struct snd_soc_platform *platform = snd_soc_component_to_platform(component);
3358
3359         platform->driver->remove(platform);
3360 }
3361
3362 static int snd_soc_platform_drv_pcm_new(struct snd_soc_pcm_runtime *rtd)
3363 {
3364         struct snd_soc_platform *platform = rtd->platform;
3365
3366         if (platform->driver->pcm_new)
3367                 return platform->driver->pcm_new(rtd);
3368         else
3369                 return 0;
3370 }
3371
3372 static void snd_soc_platform_drv_pcm_free(struct snd_pcm *pcm)
3373 {
3374         struct snd_soc_pcm_runtime *rtd = pcm->private_data;
3375         struct snd_soc_platform *platform = rtd->platform;
3376
3377         if (platform->driver->pcm_free)
3378                 platform->driver->pcm_free(pcm);
3379 }
3380
3381 /**
3382  * snd_soc_add_platform - Add a platform to the ASoC core
3383  * @dev: The parent device for the platform
3384  * @platform: The platform to add
3385  * @platform_drv: The driver for the platform
3386  */
3387 int snd_soc_add_platform(struct device *dev, struct snd_soc_platform *platform,
3388                 const struct snd_soc_platform_driver *platform_drv)
3389 {
3390         int ret;
3391
3392         ret = snd_soc_component_initialize(&platform->component,
3393                         &platform_drv->component_driver, dev);
3394         if (ret)
3395                 return ret;
3396
3397         platform->dev = dev;
3398         platform->driver = platform_drv;
3399
3400         if (platform_drv->probe)
3401                 platform->component.probe = snd_soc_platform_drv_probe;
3402         if (platform_drv->remove)
3403                 platform->component.remove = snd_soc_platform_drv_remove;
3404         if (platform_drv->pcm_new)
3405                 platform->component.pcm_new = snd_soc_platform_drv_pcm_new;
3406         if (platform_drv->pcm_free)
3407                 platform->component.pcm_free = snd_soc_platform_drv_pcm_free;
3408
3409 #ifdef CONFIG_DEBUG_FS
3410         platform->component.debugfs_prefix = "platform";
3411 #endif
3412
3413         mutex_lock(&client_mutex);
3414         snd_soc_component_add_unlocked(&platform->component);
3415         list_add(&platform->list, &platform_list);
3416         mutex_unlock(&client_mutex);
3417
3418         dev_dbg(dev, "ASoC: Registered platform '%s'\n",
3419                 platform->component.name);
3420
3421         return 0;
3422 }
3423 EXPORT_SYMBOL_GPL(snd_soc_add_platform);
3424
3425 /**
3426  * snd_soc_register_platform - Register a platform with the ASoC core
3427  *
3428  * @dev: The device for the platform
3429  * @platform_drv: The driver for the platform
3430  */
3431 int snd_soc_register_platform(struct device *dev,
3432                 const struct snd_soc_platform_driver *platform_drv)
3433 {
3434         struct snd_soc_platform *platform;
3435         int ret;
3436
3437         dev_dbg(dev, "ASoC: platform register %s\n", dev_name(dev));
3438
3439         platform = kzalloc(sizeof(struct snd_soc_platform), GFP_KERNEL);
3440         if (platform == NULL)
3441                 return -ENOMEM;
3442
3443         ret = snd_soc_add_platform(dev, platform, platform_drv);
3444         if (ret)
3445                 kfree(platform);
3446
3447         return ret;
3448 }
3449 EXPORT_SYMBOL_GPL(snd_soc_register_platform);
3450
3451 /**
3452  * snd_soc_remove_platform - Remove a platform from the ASoC core
3453  * @platform: the platform to remove
3454  */
3455 void snd_soc_remove_platform(struct snd_soc_platform *platform)
3456 {
3457
3458         mutex_lock(&client_mutex);
3459         list_del(&platform->list);
3460         snd_soc_component_del_unlocked(&platform->component);
3461         mutex_unlock(&client_mutex);
3462
3463         dev_dbg(platform->dev, "ASoC: Unregistered platform '%s'\n",
3464                 platform->component.name);
3465
3466         snd_soc_component_cleanup(&platform->component);
3467 }
3468 EXPORT_SYMBOL_GPL(snd_soc_remove_platform);
3469
3470 struct snd_soc_platform *snd_soc_lookup_platform(struct device *dev)
3471 {
3472         struct snd_soc_platform *platform;
3473
3474         mutex_lock(&client_mutex);
3475         list_for_each_entry(platform, &platform_list, list) {
3476                 if (dev == platform->dev) {
3477                         mutex_unlock(&client_mutex);
3478                         return platform;
3479                 }
3480         }
3481         mutex_unlock(&client_mutex);
3482
3483         return NULL;
3484 }
3485 EXPORT_SYMBOL_GPL(snd_soc_lookup_platform);
3486
3487 /**
3488  * snd_soc_unregister_platform - Unregister a platform from the ASoC core
3489  *
3490  * @dev: platform to unregister
3491  */
3492 void snd_soc_unregister_platform(struct device *dev)
3493 {
3494         struct snd_soc_platform *platform;
3495
3496         platform = snd_soc_lookup_platform(dev);
3497         if (!platform)
3498                 return;
3499
3500         snd_soc_remove_platform(platform);
3501         kfree(platform);
3502 }
3503 EXPORT_SYMBOL_GPL(snd_soc_unregister_platform);
3504
3505 static u64 codec_format_map[] = {
3506         SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S16_BE,
3507         SNDRV_PCM_FMTBIT_U16_LE | SNDRV_PCM_FMTBIT_U16_BE,
3508         SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S24_BE,
3509         SNDRV_PCM_FMTBIT_U24_LE | SNDRV_PCM_FMTBIT_U24_BE,
3510         SNDRV_PCM_FMTBIT_S32_LE | SNDRV_PCM_FMTBIT_S32_BE,
3511         SNDRV_PCM_FMTBIT_U32_LE | SNDRV_PCM_FMTBIT_U32_BE,
3512         SNDRV_PCM_FMTBIT_S24_3LE | SNDRV_PCM_FMTBIT_U24_3BE,
3513         SNDRV_PCM_FMTBIT_