linux/sound/soc/soc-core.c
<<
>>
Prefs
   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/slab.h>
  34#include <sound/ac97_codec.h>
  35#include <sound/core.h>
  36#include <sound/jack.h>
  37#include <sound/pcm.h>
  38#include <sound/pcm_params.h>
  39#include <sound/soc.h>
  40#include <sound/initval.h>
  41
  42#define CREATE_TRACE_POINTS
  43#include <trace/events/asoc.h>
  44
  45#define NAME_SIZE       32
  46
  47static DEFINE_MUTEX(pcm_mutex);
  48static DECLARE_WAIT_QUEUE_HEAD(soc_pm_waitq);
  49
  50#ifdef CONFIG_DEBUG_FS
  51static struct dentry *debugfs_root;
  52#endif
  53
  54static DEFINE_MUTEX(client_mutex);
  55static LIST_HEAD(card_list);
  56static LIST_HEAD(dai_list);
  57static LIST_HEAD(platform_list);
  58static LIST_HEAD(codec_list);
  59
  60static int snd_soc_register_card(struct snd_soc_card *card);
  61static int snd_soc_unregister_card(struct snd_soc_card *card);
  62static int soc_new_pcm(struct snd_soc_pcm_runtime *rtd, int num);
  63
  64/*
  65 * This is a timeout to do a DAPM powerdown after a stream is closed().
  66 * It can be used to eliminate pops between different playback streams, e.g.
  67 * between two audio tracks.
  68 */
  69static int pmdown_time = 5000;
  70module_param(pmdown_time, int, 0);
  71MODULE_PARM_DESC(pmdown_time, "DAPM stream powerdown time (msecs)");
  72
  73/* codec register dump */
  74static ssize_t soc_codec_reg_show(struct snd_soc_codec *codec, char *buf)
  75{
  76        int ret, i, step = 1, count = 0;
  77
  78        if (!codec->driver->reg_cache_size)
  79                return 0;
  80
  81        if (codec->driver->reg_cache_step)
  82                step = codec->driver->reg_cache_step;
  83
  84        count += sprintf(buf, "%s registers\n", codec->name);
  85        for (i = 0; i < codec->driver->reg_cache_size; i += step) {
  86                if (codec->driver->readable_register && !codec->driver->readable_register(i))
  87                        continue;
  88
  89                count += sprintf(buf + count, "%2x: ", i);
  90                if (count >= PAGE_SIZE - 1)
  91                        break;
  92
  93                if (codec->driver->display_register) {
  94                        count += codec->driver->display_register(codec, buf + count,
  95                                                         PAGE_SIZE - count, i);
  96                } else {
  97                        /* If the read fails it's almost certainly due to
  98                         * the register being volatile and the device being
  99                         * powered off.
 100                         */
 101                        ret = snd_soc_read(codec, i);
 102                        if (ret >= 0)
 103                                count += snprintf(buf + count,
 104                                                  PAGE_SIZE - count,
 105                                                  "%4x", ret);
 106                        else
 107                                count += snprintf(buf + count,
 108                                                  PAGE_SIZE - count,
 109                                                  "<no data: %d>", ret);
 110                }
 111
 112                if (count >= PAGE_SIZE - 1)
 113                        break;
 114
 115                count += snprintf(buf + count, PAGE_SIZE - count, "\n");
 116                if (count >= PAGE_SIZE - 1)
 117                        break;
 118        }
 119
 120        /* Truncate count; min() would cause a warning */
 121        if (count >= PAGE_SIZE)
 122                count = PAGE_SIZE - 1;
 123
 124        return count;
 125}
 126static ssize_t codec_reg_show(struct device *dev,
 127        struct device_attribute *attr, char *buf)
 128{
 129        struct snd_soc_pcm_runtime *rtd =
 130                        container_of(dev, struct snd_soc_pcm_runtime, dev);
 131
 132        return soc_codec_reg_show(rtd->codec, buf);
 133}
 134
 135static DEVICE_ATTR(codec_reg, 0444, codec_reg_show, NULL);
 136
 137static ssize_t pmdown_time_show(struct device *dev,
 138                                struct device_attribute *attr, char *buf)
 139{
 140        struct snd_soc_pcm_runtime *rtd =
 141                        container_of(dev, struct snd_soc_pcm_runtime, dev);
 142
 143        return sprintf(buf, "%ld\n", rtd->pmdown_time);
 144}
 145
 146static ssize_t pmdown_time_set(struct device *dev,
 147                               struct device_attribute *attr,
 148                               const char *buf, size_t count)
 149{
 150        struct snd_soc_pcm_runtime *rtd =
 151                        container_of(dev, struct snd_soc_pcm_runtime, dev);
 152        int ret;
 153
 154        ret = strict_strtol(buf, 10, &rtd->pmdown_time);
 155        if (ret)
 156                return ret;
 157
 158        return count;
 159}
 160
 161static DEVICE_ATTR(pmdown_time, 0644, pmdown_time_show, pmdown_time_set);
 162
 163#ifdef CONFIG_DEBUG_FS
 164static int codec_reg_open_file(struct inode *inode, struct file *file)
 165{
 166        file->private_data = inode->i_private;
 167        return 0;
 168}
 169
 170static ssize_t codec_reg_read_file(struct file *file, char __user *user_buf,
 171                               size_t count, loff_t *ppos)
 172{
 173        ssize_t ret;
 174        struct snd_soc_codec *codec = file->private_data;
 175        char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
 176        if (!buf)
 177                return -ENOMEM;
 178        ret = soc_codec_reg_show(codec, buf);
 179        if (ret >= 0)
 180                ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
 181        kfree(buf);
 182        return ret;
 183}
 184
 185static ssize_t codec_reg_write_file(struct file *file,
 186                const char __user *user_buf, size_t count, loff_t *ppos)
 187{
 188        char buf[32];
 189        int buf_size;
 190        char *start = buf;
 191        unsigned long reg, value;
 192        int step = 1;
 193        struct snd_soc_codec *codec = file->private_data;
 194
 195        buf_size = min(count, (sizeof(buf)-1));
 196        if (copy_from_user(buf, user_buf, buf_size))
 197                return -EFAULT;
 198        buf[buf_size] = 0;
 199
 200        if (codec->driver->reg_cache_step)
 201                step = codec->driver->reg_cache_step;
 202
 203        while (*start == ' ')
 204                start++;
 205        reg = simple_strtoul(start, &start, 16);
 206        if ((reg >= codec->driver->reg_cache_size) || (reg % step))
 207                return -EINVAL;
 208        while (*start == ' ')
 209                start++;
 210        if (strict_strtoul(start, 16, &value))
 211                return -EINVAL;
 212        snd_soc_write(codec, reg, value);
 213        return buf_size;
 214}
 215
 216static const struct file_operations codec_reg_fops = {
 217        .open = codec_reg_open_file,
 218        .read = codec_reg_read_file,
 219        .write = codec_reg_write_file,
 220        .llseek = default_llseek,
 221};
 222
 223static void soc_init_codec_debugfs(struct snd_soc_codec *codec)
 224{
 225        struct dentry *debugfs_card_root = codec->card->debugfs_card_root;
 226
 227        codec->debugfs_codec_root = debugfs_create_dir(codec->name,
 228                                                       debugfs_card_root);
 229        if (!codec->debugfs_codec_root) {
 230                printk(KERN_WARNING
 231                       "ASoC: Failed to create codec debugfs directory\n");
 232                return;
 233        }
 234
 235        codec->debugfs_reg = debugfs_create_file("codec_reg", 0644,
 236                                                 codec->debugfs_codec_root,
 237                                                 codec, &codec_reg_fops);
 238        if (!codec->debugfs_reg)
 239                printk(KERN_WARNING
 240                       "ASoC: Failed to create codec register debugfs file\n");
 241
 242        codec->dapm.debugfs_dapm = debugfs_create_dir("dapm",
 243                                                 codec->debugfs_codec_root);
 244        if (!codec->dapm.debugfs_dapm)
 245                printk(KERN_WARNING
 246                       "Failed to create DAPM debugfs directory\n");
 247
 248        snd_soc_dapm_debugfs_init(&codec->dapm);
 249}
 250
 251static void soc_cleanup_codec_debugfs(struct snd_soc_codec *codec)
 252{
 253        debugfs_remove_recursive(codec->debugfs_codec_root);
 254}
 255
 256static ssize_t codec_list_read_file(struct file *file, char __user *user_buf,
 257                                    size_t count, loff_t *ppos)
 258{
 259        char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
 260        ssize_t len, ret = 0;
 261        struct snd_soc_codec *codec;
 262
 263        if (!buf)
 264                return -ENOMEM;
 265
 266        list_for_each_entry(codec, &codec_list, list) {
 267                len = snprintf(buf + ret, PAGE_SIZE - ret, "%s\n",
 268                               codec->name);
 269                if (len >= 0)
 270                        ret += len;
 271                if (ret > PAGE_SIZE) {
 272                        ret = PAGE_SIZE;
 273                        break;
 274                }
 275        }
 276
 277        if (ret >= 0)
 278                ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
 279
 280        kfree(buf);
 281
 282        return ret;
 283}
 284
 285static const struct file_operations codec_list_fops = {
 286        .read = codec_list_read_file,
 287        .llseek = default_llseek,/* read accesses f_pos */
 288};
 289
 290static ssize_t dai_list_read_file(struct file *file, char __user *user_buf,
 291                                  size_t count, loff_t *ppos)
 292{
 293        char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
 294        ssize_t len, ret = 0;
 295        struct snd_soc_dai *dai;
 296
 297        if (!buf)
 298                return -ENOMEM;
 299
 300        list_for_each_entry(dai, &dai_list, list) {
 301                len = snprintf(buf + ret, PAGE_SIZE - ret, "%s\n", dai->name);
 302                if (len >= 0)
 303                        ret += len;
 304                if (ret > PAGE_SIZE) {
 305                        ret = PAGE_SIZE;
 306                        break;
 307                }
 308        }
 309
 310        ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
 311
 312        kfree(buf);
 313
 314        return ret;
 315}
 316
 317static const struct file_operations dai_list_fops = {
 318        .read = dai_list_read_file,
 319        .llseek = default_llseek,/* read accesses f_pos */
 320};
 321
 322static ssize_t platform_list_read_file(struct file *file,
 323                                       char __user *user_buf,
 324                                       size_t count, loff_t *ppos)
 325{
 326        char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
 327        ssize_t len, ret = 0;
 328        struct snd_soc_platform *platform;
 329
 330        if (!buf)
 331                return -ENOMEM;
 332
 333        list_for_each_entry(platform, &platform_list, list) {
 334                len = snprintf(buf + ret, PAGE_SIZE - ret, "%s\n",
 335                               platform->name);
 336                if (len >= 0)
 337                        ret += len;
 338                if (ret > PAGE_SIZE) {
 339                        ret = PAGE_SIZE;
 340                        break;
 341                }
 342        }
 343
 344        ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
 345
 346        kfree(buf);
 347
 348        return ret;
 349}
 350
 351static const struct file_operations platform_list_fops = {
 352        .read = platform_list_read_file,
 353        .llseek = default_llseek,/* read accesses f_pos */
 354};
 355
 356static void soc_init_card_debugfs(struct snd_soc_card *card)
 357{
 358        card->debugfs_card_root = debugfs_create_dir(card->name,
 359                                                     debugfs_root);
 360        if (!card->debugfs_card_root) {
 361                dev_warn(card->dev,
 362                         "ASoC: Failed to create codec debugfs directory\n");
 363                return;
 364        }
 365
 366        card->debugfs_pop_time = debugfs_create_u32("dapm_pop_time", 0644,
 367                                                    card->debugfs_card_root,
 368                                                    &card->pop_time);
 369        if (!card->debugfs_pop_time)
 370                dev_warn(card->dev,
 371                       "Failed to create pop time debugfs file\n");
 372}
 373
 374static void soc_cleanup_card_debugfs(struct snd_soc_card *card)
 375{
 376        debugfs_remove_recursive(card->debugfs_card_root);
 377}
 378
 379#else
 380
 381static inline void soc_init_codec_debugfs(struct snd_soc_codec *codec)
 382{
 383}
 384
 385static inline void soc_cleanup_codec_debugfs(struct snd_soc_codec *codec)
 386{
 387}
 388
 389static inline void soc_init_card_debugfs(struct snd_soc_card *card)
 390{
 391}
 392
 393static inline void soc_cleanup_card_debugfs(struct snd_soc_card *card)
 394{
 395}
 396#endif
 397
 398#ifdef CONFIG_SND_SOC_AC97_BUS
 399/* unregister ac97 codec */
 400static int soc_ac97_dev_unregister(struct snd_soc_codec *codec)
 401{
 402        if (codec->ac97->dev.bus)
 403                device_unregister(&codec->ac97->dev);
 404        return 0;
 405}
 406
 407/* stop no dev release warning */
 408static void soc_ac97_device_release(struct device *dev){}
 409
 410/* register ac97 codec to bus */
 411static int soc_ac97_dev_register(struct snd_soc_codec *codec)
 412{
 413        int err;
 414
 415        codec->ac97->dev.bus = &ac97_bus_type;
 416        codec->ac97->dev.parent = codec->card->dev;
 417        codec->ac97->dev.release = soc_ac97_device_release;
 418
 419        dev_set_name(&codec->ac97->dev, "%d-%d:%s",
 420                     codec->card->snd_card->number, 0, codec->name);
 421        err = device_register(&codec->ac97->dev);
 422        if (err < 0) {
 423                snd_printk(KERN_ERR "Can't register ac97 bus\n");
 424                codec->ac97->dev.bus = NULL;
 425                return err;
 426        }
 427        return 0;
 428}
 429#endif
 430
 431static int soc_pcm_apply_symmetry(struct snd_pcm_substream *substream)
 432{
 433        struct snd_soc_pcm_runtime *rtd = substream->private_data;
 434        struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
 435        struct snd_soc_dai *codec_dai = rtd->codec_dai;
 436        int ret;
 437
 438        if (codec_dai->driver->symmetric_rates || cpu_dai->driver->symmetric_rates ||
 439                        rtd->dai_link->symmetric_rates) {
 440                dev_dbg(&rtd->dev, "Symmetry forces %dHz rate\n",
 441                                rtd->rate);
 442
 443                ret = snd_pcm_hw_constraint_minmax(substream->runtime,
 444                                                   SNDRV_PCM_HW_PARAM_RATE,
 445                                                   rtd->rate,
 446                                                   rtd->rate);
 447                if (ret < 0) {
 448                        dev_err(&rtd->dev,
 449                                "Unable to apply rate symmetry constraint: %d\n", ret);
 450                        return ret;
 451                }
 452        }
 453
 454        return 0;
 455}
 456
 457/*
 458 * Called by ALSA when a PCM substream is opened, the runtime->hw record is
 459 * then initialized and any private data can be allocated. This also calls
 460 * startup for the cpu DAI, platform, machine and codec DAI.
 461 */
 462static int soc_pcm_open(struct snd_pcm_substream *substream)
 463{
 464        struct snd_soc_pcm_runtime *rtd = substream->private_data;
 465        struct snd_pcm_runtime *runtime = substream->runtime;
 466        struct snd_soc_platform *platform = rtd->platform;
 467        struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
 468        struct snd_soc_dai *codec_dai = rtd->codec_dai;
 469        struct snd_soc_dai_driver *cpu_dai_drv = cpu_dai->driver;
 470        struct snd_soc_dai_driver *codec_dai_drv = codec_dai->driver;
 471        int ret = 0;
 472
 473        mutex_lock(&pcm_mutex);
 474
 475        /* startup the audio subsystem */
 476        if (cpu_dai->driver->ops->startup) {
 477                ret = cpu_dai->driver->ops->startup(substream, cpu_dai);
 478                if (ret < 0) {
 479                        printk(KERN_ERR "asoc: can't open interface %s\n",
 480                                cpu_dai->name);
 481                        goto out;
 482                }
 483        }
 484
 485        if (platform->driver->ops->open) {
 486                ret = platform->driver->ops->open(substream);
 487                if (ret < 0) {
 488                        printk(KERN_ERR "asoc: can't open platform %s\n", platform->name);
 489                        goto platform_err;
 490                }
 491        }
 492
 493        if (codec_dai->driver->ops->startup) {
 494                ret = codec_dai->driver->ops->startup(substream, codec_dai);
 495                if (ret < 0) {
 496                        printk(KERN_ERR "asoc: can't open codec %s\n",
 497                                codec_dai->name);
 498                        goto codec_dai_err;
 499                }
 500        }
 501
 502        if (rtd->dai_link->ops && rtd->dai_link->ops->startup) {
 503                ret = rtd->dai_link->ops->startup(substream);
 504                if (ret < 0) {
 505                        printk(KERN_ERR "asoc: %s startup failed\n", rtd->dai_link->name);
 506                        goto machine_err;
 507                }
 508        }
 509
 510        /* Check that the codec and cpu DAIs are compatible */
 511        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
 512                runtime->hw.rate_min =
 513                        max(codec_dai_drv->playback.rate_min,
 514                            cpu_dai_drv->playback.rate_min);
 515                runtime->hw.rate_max =
 516                        min(codec_dai_drv->playback.rate_max,
 517                            cpu_dai_drv->playback.rate_max);
 518                runtime->hw.channels_min =
 519                        max(codec_dai_drv->playback.channels_min,
 520                                cpu_dai_drv->playback.channels_min);
 521                runtime->hw.channels_max =
 522                        min(codec_dai_drv->playback.channels_max,
 523                                cpu_dai_drv->playback.channels_max);
 524                runtime->hw.formats =
 525                        codec_dai_drv->playback.formats & cpu_dai_drv->playback.formats;
 526                runtime->hw.rates =
 527                        codec_dai_drv->playback.rates & cpu_dai_drv->playback.rates;
 528                if (codec_dai_drv->playback.rates
 529                           & (SNDRV_PCM_RATE_KNOT | SNDRV_PCM_RATE_CONTINUOUS))
 530                        runtime->hw.rates |= cpu_dai_drv->playback.rates;
 531                if (cpu_dai_drv->playback.rates
 532                           & (SNDRV_PCM_RATE_KNOT | SNDRV_PCM_RATE_CONTINUOUS))
 533                        runtime->hw.rates |= codec_dai_drv->playback.rates;
 534        } else {
 535                runtime->hw.rate_min =
 536                        max(codec_dai_drv->capture.rate_min,
 537                            cpu_dai_drv->capture.rate_min);
 538                runtime->hw.rate_max =
 539                        min(codec_dai_drv->capture.rate_max,
 540                            cpu_dai_drv->capture.rate_max);
 541                runtime->hw.channels_min =
 542                        max(codec_dai_drv->capture.channels_min,
 543                                cpu_dai_drv->capture.channels_min);
 544                runtime->hw.channels_max =
 545                        min(codec_dai_drv->capture.channels_max,
 546                                cpu_dai_drv->capture.channels_max);
 547                runtime->hw.formats =
 548                        codec_dai_drv->capture.formats & cpu_dai_drv->capture.formats;
 549                runtime->hw.rates =
 550                        codec_dai_drv->capture.rates & cpu_dai_drv->capture.rates;
 551                if (codec_dai_drv->capture.rates
 552                           & (SNDRV_PCM_RATE_KNOT | SNDRV_PCM_RATE_CONTINUOUS))
 553                        runtime->hw.rates |= cpu_dai_drv->capture.rates;
 554                if (cpu_dai_drv->capture.rates
 555                           & (SNDRV_PCM_RATE_KNOT | SNDRV_PCM_RATE_CONTINUOUS))
 556                        runtime->hw.rates |= codec_dai_drv->capture.rates;
 557        }
 558
 559        snd_pcm_limit_hw_rates(runtime);
 560        if (!runtime->hw.rates) {
 561                printk(KERN_ERR "asoc: %s <-> %s No matching rates\n",
 562                        codec_dai->name, cpu_dai->name);
 563                goto config_err;
 564        }
 565        if (!runtime->hw.formats) {
 566                printk(KERN_ERR "asoc: %s <-> %s No matching formats\n",
 567                        codec_dai->name, cpu_dai->name);
 568                goto config_err;
 569        }
 570        if (!runtime->hw.channels_min || !runtime->hw.channels_max) {
 571                printk(KERN_ERR "asoc: %s <-> %s No matching channels\n",
 572                                codec_dai->name, cpu_dai->name);
 573                goto config_err;
 574        }
 575
 576        /* Symmetry only applies if we've already got an active stream. */
 577        if (cpu_dai->active || codec_dai->active) {
 578                ret = soc_pcm_apply_symmetry(substream);
 579                if (ret != 0)
 580                        goto config_err;
 581        }
 582
 583        pr_debug("asoc: %s <-> %s info:\n",
 584                        codec_dai->name, cpu_dai->name);
 585        pr_debug("asoc: rate mask 0x%x\n", runtime->hw.rates);
 586        pr_debug("asoc: min ch %d max ch %d\n", runtime->hw.channels_min,
 587                 runtime->hw.channels_max);
 588        pr_debug("asoc: min rate %d max rate %d\n", runtime->hw.rate_min,
 589                 runtime->hw.rate_max);
 590
 591        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
 592                cpu_dai->playback_active++;
 593                codec_dai->playback_active++;
 594        } else {
 595                cpu_dai->capture_active++;
 596                codec_dai->capture_active++;
 597        }
 598        cpu_dai->active++;
 599        codec_dai->active++;
 600        rtd->codec->active++;
 601        mutex_unlock(&pcm_mutex);
 602        return 0;
 603
 604config_err:
 605        if (rtd->dai_link->ops && rtd->dai_link->ops->shutdown)
 606                rtd->dai_link->ops->shutdown(substream);
 607
 608machine_err:
 609        if (codec_dai->driver->ops->shutdown)
 610                codec_dai->driver->ops->shutdown(substream, codec_dai);
 611
 612codec_dai_err:
 613        if (platform->driver->ops->close)
 614                platform->driver->ops->close(substream);
 615
 616platform_err:
 617        if (cpu_dai->driver->ops->shutdown)
 618                cpu_dai->driver->ops->shutdown(substream, cpu_dai);
 619out:
 620        mutex_unlock(&pcm_mutex);
 621        return ret;
 622}
 623
 624/*
 625 * Power down the audio subsystem pmdown_time msecs after close is called.
 626 * This is to ensure there are no pops or clicks in between any music tracks
 627 * due to DAPM power cycling.
 628 */
 629static void close_delayed_work(struct work_struct *work)
 630{
 631        struct snd_soc_pcm_runtime *rtd =
 632                        container_of(work, struct snd_soc_pcm_runtime, delayed_work.work);
 633        struct snd_soc_dai *codec_dai = rtd->codec_dai;
 634
 635        mutex_lock(&pcm_mutex);
 636
 637        pr_debug("pop wq checking: %s status: %s waiting: %s\n",
 638                 codec_dai->driver->playback.stream_name,
 639                 codec_dai->playback_active ? "active" : "inactive",
 640                 codec_dai->pop_wait ? "yes" : "no");
 641
 642        /* are we waiting on this codec DAI stream */
 643        if (codec_dai->pop_wait == 1) {
 644                codec_dai->pop_wait = 0;
 645                snd_soc_dapm_stream_event(rtd,
 646                        codec_dai->driver->playback.stream_name,
 647                        SND_SOC_DAPM_STREAM_STOP);
 648        }
 649
 650        mutex_unlock(&pcm_mutex);
 651}
 652
 653/*
 654 * Called by ALSA when a PCM substream is closed. Private data can be
 655 * freed here. The cpu DAI, codec DAI, machine and platform are also
 656 * shutdown.
 657 */
 658static int soc_codec_close(struct snd_pcm_substream *substream)
 659{
 660        struct snd_soc_pcm_runtime *rtd = substream->private_data;
 661        struct snd_soc_platform *platform = rtd->platform;
 662        struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
 663        struct snd_soc_dai *codec_dai = rtd->codec_dai;
 664        struct snd_soc_codec *codec = rtd->codec;
 665
 666        mutex_lock(&pcm_mutex);
 667
 668        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
 669                cpu_dai->playback_active--;
 670                codec_dai->playback_active--;
 671        } else {
 672                cpu_dai->capture_active--;
 673                codec_dai->capture_active--;
 674        }
 675
 676        cpu_dai->active--;
 677        codec_dai->active--;
 678        codec->active--;
 679
 680        /* Muting the DAC suppresses artifacts caused during digital
 681         * shutdown, for example from stopping clocks.
 682         */
 683        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
 684                snd_soc_dai_digital_mute(codec_dai, 1);
 685
 686        if (cpu_dai->driver->ops->shutdown)
 687                cpu_dai->driver->ops->shutdown(substream, cpu_dai);
 688
 689        if (codec_dai->driver->ops->shutdown)
 690                codec_dai->driver->ops->shutdown(substream, codec_dai);
 691
 692        if (rtd->dai_link->ops && rtd->dai_link->ops->shutdown)
 693                rtd->dai_link->ops->shutdown(substream);
 694
 695        if (platform->driver->ops->close)
 696                platform->driver->ops->close(substream);
 697        cpu_dai->runtime = NULL;
 698
 699        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
 700                /* start delayed pop wq here for playback streams */
 701                codec_dai->pop_wait = 1;
 702                schedule_delayed_work(&rtd->delayed_work,
 703                        msecs_to_jiffies(rtd->pmdown_time));
 704        } else {
 705                /* capture streams can be powered down now */
 706                snd_soc_dapm_stream_event(rtd,
 707                        codec_dai->driver->capture.stream_name,
 708                        SND_SOC_DAPM_STREAM_STOP);
 709        }
 710
 711        mutex_unlock(&pcm_mutex);
 712        return 0;
 713}
 714
 715/*
 716 * Called by ALSA when the PCM substream is prepared, can set format, sample
 717 * rate, etc.  This function is non atomic and can be called multiple times,
 718 * it can refer to the runtime info.
 719 */
 720static int soc_pcm_prepare(struct snd_pcm_substream *substream)
 721{
 722        struct snd_soc_pcm_runtime *rtd = substream->private_data;
 723        struct snd_soc_platform *platform = rtd->platform;
 724        struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
 725        struct snd_soc_dai *codec_dai = rtd->codec_dai;
 726        int ret = 0;
 727
 728        mutex_lock(&pcm_mutex);
 729
 730        if (rtd->dai_link->ops && rtd->dai_link->ops->prepare) {
 731                ret = rtd->dai_link->ops->prepare(substream);
 732                if (ret < 0) {
 733                        printk(KERN_ERR "asoc: machine prepare error\n");
 734                        goto out;
 735                }
 736        }
 737
 738        if (platform->driver->ops->prepare) {
 739                ret = platform->driver->ops->prepare(substream);
 740                if (ret < 0) {
 741                        printk(KERN_ERR "asoc: platform prepare error\n");
 742                        goto out;
 743                }
 744        }
 745
 746        if (codec_dai->driver->ops->prepare) {
 747                ret = codec_dai->driver->ops->prepare(substream, codec_dai);
 748                if (ret < 0) {
 749                        printk(KERN_ERR "asoc: codec DAI prepare error\n");
 750                        goto out;
 751                }
 752        }
 753
 754        if (cpu_dai->driver->ops->prepare) {
 755                ret = cpu_dai->driver->ops->prepare(substream, cpu_dai);
 756                if (ret < 0) {
 757                        printk(KERN_ERR "asoc: cpu DAI prepare error\n");
 758                        goto out;
 759                }
 760        }
 761
 762        /* cancel any delayed stream shutdown that is pending */
 763        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
 764            codec_dai->pop_wait) {
 765                codec_dai->pop_wait = 0;
 766                cancel_delayed_work(&rtd->delayed_work);
 767        }
 768
 769        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
 770                snd_soc_dapm_stream_event(rtd,
 771                                          codec_dai->driver->playback.stream_name,
 772                                          SND_SOC_DAPM_STREAM_START);
 773        else
 774                snd_soc_dapm_stream_event(rtd,
 775                                          codec_dai->driver->capture.stream_name,
 776                                          SND_SOC_DAPM_STREAM_START);
 777
 778        snd_soc_dai_digital_mute(codec_dai, 0);
 779
 780out:
 781        mutex_unlock(&pcm_mutex);
 782        return ret;
 783}
 784
 785/*
 786 * Called by ALSA when the hardware params are set by application. This
 787 * function can also be called multiple times and can allocate buffers
 788 * (using snd_pcm_lib_* ). It's non-atomic.
 789 */
 790static int soc_pcm_hw_params(struct snd_pcm_substream *substream,
 791                                struct snd_pcm_hw_params *params)
 792{
 793        struct snd_soc_pcm_runtime *rtd = substream->private_data;
 794        struct snd_soc_platform *platform = rtd->platform;
 795        struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
 796        struct snd_soc_dai *codec_dai = rtd->codec_dai;
 797        int ret = 0;
 798
 799        mutex_lock(&pcm_mutex);
 800
 801        if (rtd->dai_link->ops && rtd->dai_link->ops->hw_params) {
 802                ret = rtd->dai_link->ops->hw_params(substream, params);
 803                if (ret < 0) {
 804                        printk(KERN_ERR "asoc: machine hw_params failed\n");
 805                        goto out;
 806                }
 807        }
 808
 809        if (codec_dai->driver->ops->hw_params) {
 810                ret = codec_dai->driver->ops->hw_params(substream, params, codec_dai);
 811                if (ret < 0) {
 812                        printk(KERN_ERR "asoc: can't set codec %s hw params\n",
 813                                codec_dai->name);
 814                        goto codec_err;
 815                }
 816        }
 817
 818        if (cpu_dai->driver->ops->hw_params) {
 819                ret = cpu_dai->driver->ops->hw_params(substream, params, cpu_dai);
 820                if (ret < 0) {
 821                        printk(KERN_ERR "asoc: interface %s hw params failed\n",
 822                                cpu_dai->name);
 823                        goto interface_err;
 824                }
 825        }
 826
 827        if (platform->driver->ops->hw_params) {
 828                ret = platform->driver->ops->hw_params(substream, params);
 829                if (ret < 0) {
 830                        printk(KERN_ERR "asoc: platform %s hw params failed\n",
 831                                platform->name);
 832                        goto platform_err;
 833                }
 834        }
 835
 836        rtd->rate = params_rate(params);
 837
 838out:
 839        mutex_unlock(&pcm_mutex);
 840        return ret;
 841
 842platform_err:
 843        if (cpu_dai->driver->ops->hw_free)
 844                cpu_dai->driver->ops->hw_free(substream, cpu_dai);
 845
 846interface_err:
 847        if (codec_dai->driver->ops->hw_free)
 848                codec_dai->driver->ops->hw_free(substream, codec_dai);
 849
 850codec_err:
 851        if (rtd->dai_link->ops && rtd->dai_link->ops->hw_free)
 852                rtd->dai_link->ops->hw_free(substream);
 853
 854        mutex_unlock(&pcm_mutex);
 855        return ret;
 856}
 857
 858/*
 859 * Frees resources allocated by hw_params, can be called multiple times
 860 */
 861static int soc_pcm_hw_free(struct snd_pcm_substream *substream)
 862{
 863        struct snd_soc_pcm_runtime *rtd = substream->private_data;
 864        struct snd_soc_platform *platform = rtd->platform;
 865        struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
 866        struct snd_soc_dai *codec_dai = rtd->codec_dai;
 867        struct snd_soc_codec *codec = rtd->codec;
 868
 869        mutex_lock(&pcm_mutex);
 870
 871        /* apply codec digital mute */
 872        if (!codec->active)
 873                snd_soc_dai_digital_mute(codec_dai, 1);
 874
 875        /* free any machine hw params */
 876        if (rtd->dai_link->ops && rtd->dai_link->ops->hw_free)
 877                rtd->dai_link->ops->hw_free(substream);
 878
 879        /* free any DMA resources */
 880        if (platform->driver->ops->hw_free)
 881                platform->driver->ops->hw_free(substream);
 882
 883        /* now free hw params for the DAIs  */
 884        if (codec_dai->driver->ops->hw_free)
 885                codec_dai->driver->ops->hw_free(substream, codec_dai);
 886
 887        if (cpu_dai->driver->ops->hw_free)
 888                cpu_dai->driver->ops->hw_free(substream, cpu_dai);
 889
 890        mutex_unlock(&pcm_mutex);
 891        return 0;
 892}
 893
 894static int soc_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
 895{
 896        struct snd_soc_pcm_runtime *rtd = substream->private_data;
 897        struct snd_soc_platform *platform = rtd->platform;
 898        struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
 899        struct snd_soc_dai *codec_dai = rtd->codec_dai;
 900        int ret;
 901
 902        if (codec_dai->driver->ops->trigger) {
 903                ret = codec_dai->driver->ops->trigger(substream, cmd, codec_dai);
 904                if (ret < 0)
 905                        return ret;
 906        }
 907
 908        if (platform->driver->ops->trigger) {
 909                ret = platform->driver->ops->trigger(substream, cmd);
 910                if (ret < 0)
 911                        return ret;
 912        }
 913
 914        if (cpu_dai->driver->ops->trigger) {
 915                ret = cpu_dai->driver->ops->trigger(substream, cmd, cpu_dai);
 916                if (ret < 0)
 917                        return ret;
 918        }
 919        return 0;
 920}
 921
 922/*
 923 * soc level wrapper for pointer callback
 924 * If cpu_dai, codec_dai, platform driver has the delay callback, than
 925 * the runtime->delay will be updated accordingly.
 926 */
 927static snd_pcm_uframes_t soc_pcm_pointer(struct snd_pcm_substream *substream)
 928{
 929        struct snd_soc_pcm_runtime *rtd = substream->private_data;
 930        struct snd_soc_platform *platform = rtd->platform;
 931        struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
 932        struct snd_soc_dai *codec_dai = rtd->codec_dai;
 933        struct snd_pcm_runtime *runtime = substream->runtime;
 934        snd_pcm_uframes_t offset = 0;
 935        snd_pcm_sframes_t delay = 0;
 936
 937        if (platform->driver->ops->pointer)
 938                offset = platform->driver->ops->pointer(substream);
 939
 940        if (cpu_dai->driver->ops->delay)
 941                delay += cpu_dai->driver->ops->delay(substream, cpu_dai);
 942
 943        if (codec_dai->driver->ops->delay)
 944                delay += codec_dai->driver->ops->delay(substream, codec_dai);
 945
 946        if (platform->driver->delay)
 947                delay += platform->driver->delay(substream, codec_dai);
 948
 949        runtime->delay = delay;
 950
 951        return offset;
 952}
 953
 954/* ASoC PCM operations */
 955static struct snd_pcm_ops soc_pcm_ops = {
 956        .open           = soc_pcm_open,
 957        .close          = soc_codec_close,
 958        .hw_params      = soc_pcm_hw_params,
 959        .hw_free        = soc_pcm_hw_free,
 960        .prepare        = soc_pcm_prepare,
 961        .trigger        = soc_pcm_trigger,
 962        .pointer        = soc_pcm_pointer,
 963};
 964
 965#ifdef CONFIG_PM
 966/* powers down audio subsystem for suspend */
 967static int soc_suspend(struct device *dev)
 968{
 969        struct platform_device *pdev = to_platform_device(dev);
 970        struct snd_soc_card *card = platform_get_drvdata(pdev);
 971        struct snd_soc_codec *codec;
 972        int i;
 973
 974        /* If the initialization of this soc device failed, there is no codec
 975         * associated with it. Just bail out in this case.
 976         */
 977        if (list_empty(&card->codec_dev_list))
 978                return 0;
 979
 980        /* Due to the resume being scheduled into a workqueue we could
 981        * suspend before that's finished - wait for it to complete.
 982         */
 983        snd_power_lock(card->snd_card);
 984        snd_power_wait(card->snd_card, SNDRV_CTL_POWER_D0);
 985        snd_power_unlock(card->snd_card);
 986
 987        /* we're going to block userspace touching us until resume completes */
 988        snd_power_change_state(card->snd_card, SNDRV_CTL_POWER_D3hot);
 989
 990        /* mute any active DACs */
 991        for (i = 0; i < card->num_rtd; i++) {
 992                struct snd_soc_dai *dai = card->rtd[i].codec_dai;
 993                struct snd_soc_dai_driver *drv = dai->driver;
 994
 995                if (card->rtd[i].dai_link->ignore_suspend)
 996                        continue;
 997
 998                if (drv->ops->digital_mute && dai->playback_active)
 999                        drv->ops->digital_mute(dai, 1);
1000        }
1001
1002        /* suspend all pcms */
1003        for (i = 0; i < card->num_rtd; i++) {
1004                if (card->rtd[i].dai_link->ignore_suspend)
1005                        continue;
1006
1007                snd_pcm_suspend_all(card->rtd[i].pcm);
1008        }
1009
1010        if (card->suspend_pre)
1011                card->suspend_pre(pdev, PMSG_SUSPEND);
1012
1013        for (i = 0; i < card->num_rtd; i++) {
1014                struct snd_soc_dai *cpu_dai = card->rtd[i].cpu_dai;
1015                struct snd_soc_platform *platform = card->rtd[i].platform;
1016
1017                if (card->rtd[i].dai_link->ignore_suspend)
1018                        continue;
1019
1020                if (cpu_dai->driver->suspend && !cpu_dai->driver->ac97_control)
1021                        cpu_dai->driver->suspend(cpu_dai);
1022                if (platform->driver->suspend && !platform->suspended) {
1023                        platform->driver->suspend(cpu_dai);
1024                        platform->suspended = 1;
1025                }
1026        }
1027
1028        /* close any waiting streams and save state */
1029        for (i = 0; i < card->num_rtd; i++) {
1030                flush_delayed_work_sync(&card->rtd[i].delayed_work);
1031                card->rtd[i].codec->dapm.suspend_bias_level = card->rtd[i].codec->dapm.bias_level;
1032        }
1033
1034        for (i = 0; i < card->num_rtd; i++) {
1035                struct snd_soc_dai_driver *driver = card->rtd[i].codec_dai->driver;
1036
1037                if (card->rtd[i].dai_link->ignore_suspend)
1038                        continue;
1039
1040                if (driver->playback.stream_name != NULL)
1041                        snd_soc_dapm_stream_event(&card->rtd[i], driver->playback.stream_name,
1042                                SND_SOC_DAPM_STREAM_SUSPEND);
1043
1044                if (driver->capture.stream_name != NULL)
1045                        snd_soc_dapm_stream_event(&card->rtd[i], driver->capture.stream_name,
1046                                SND_SOC_DAPM_STREAM_SUSPEND);
1047        }
1048
1049        /* suspend all CODECs */
1050        list_for_each_entry(codec, &card->codec_dev_list, card_list) {
1051                /* If there are paths active then the CODEC will be held with
1052                 * bias _ON and should not be suspended. */
1053                if (!codec->suspended && codec->driver->suspend) {
1054                        switch (codec->dapm.bias_level) {
1055                        case SND_SOC_BIAS_STANDBY:
1056                        case SND_SOC_BIAS_OFF:
1057                                codec->driver->suspend(codec, PMSG_SUSPEND);
1058                                codec->suspended = 1;
1059                                break;
1060                        default:
1061                                dev_dbg(codec->dev, "CODEC is on over suspend\n");
1062                                break;
1063                        }
1064                }
1065        }
1066
1067        for (i = 0; i < card->num_rtd; i++) {
1068                struct snd_soc_dai *cpu_dai = card->rtd[i].cpu_dai;
1069
1070                if (card->rtd[i].dai_link->ignore_suspend)
1071                        continue;
1072
1073                if (cpu_dai->driver->suspend && cpu_dai->driver->ac97_control)
1074                        cpu_dai->driver->suspend(cpu_dai);
1075        }
1076
1077        if (card->suspend_post)
1078                card->suspend_post(pdev, PMSG_SUSPEND);
1079
1080        return 0;
1081}
1082
1083/* deferred resume work, so resume can complete before we finished
1084 * setting our codec back up, which can be very slow on I2C
1085 */
1086static void soc_resume_deferred(struct work_struct *work)
1087{
1088        struct snd_soc_card *card =
1089                        container_of(work, struct snd_soc_card, deferred_resume_work);
1090        struct platform_device *pdev = to_platform_device(card->dev);
1091        struct snd_soc_codec *codec;
1092        int i;
1093
1094        /* our power state is still SNDRV_CTL_POWER_D3hot from suspend time,
1095         * so userspace apps are blocked from touching us
1096         */
1097
1098        dev_dbg(card->dev, "starting resume work\n");
1099
1100        /* Bring us up into D2 so that DAPM starts enabling things */
1101        snd_power_change_state(card->snd_card, SNDRV_CTL_POWER_D2);
1102
1103        if (card->resume_pre)
1104                card->resume_pre(pdev);
1105
1106        /* resume AC97 DAIs */
1107        for (i = 0; i < card->num_rtd; i++) {
1108                struct snd_soc_dai *cpu_dai = card->rtd[i].cpu_dai;
1109
1110                if (card->rtd[i].dai_link->ignore_suspend)
1111                        continue;
1112
1113                if (cpu_dai->driver->resume && cpu_dai->driver->ac97_control)
1114                        cpu_dai->driver->resume(cpu_dai);
1115        }
1116
1117        list_for_each_entry(codec, &card->codec_dev_list, card_list) {
1118                /* If the CODEC was idle over suspend then it will have been
1119                 * left with bias OFF or STANDBY and suspended so we must now
1120                 * resume.  Otherwise the suspend was suppressed.
1121                 */
1122                if (codec->driver->resume && codec->suspended) {
1123                        switch (codec->dapm.bias_level) {
1124                        case SND_SOC_BIAS_STANDBY:
1125                        case SND_SOC_BIAS_OFF:
1126                                codec->driver->resume(codec);
1127                                codec->suspended = 0;
1128                                break;
1129                        default:
1130                                dev_dbg(codec->dev, "CODEC was on over suspend\n");
1131                                break;
1132                        }
1133                }
1134        }
1135
1136        for (i = 0; i < card->num_rtd; i++) {
1137                struct snd_soc_dai_driver *driver = card->rtd[i].codec_dai->driver;
1138
1139                if (card->rtd[i].dai_link->ignore_suspend)
1140                        continue;
1141
1142                if (driver->playback.stream_name != NULL)
1143                        snd_soc_dapm_stream_event(&card->rtd[i], driver->playback.stream_name,
1144                                SND_SOC_DAPM_STREAM_RESUME);
1145
1146                if (driver->capture.stream_name != NULL)
1147                        snd_soc_dapm_stream_event(&card->rtd[i], driver->capture.stream_name,
1148                                SND_SOC_DAPM_STREAM_RESUME);
1149        }
1150
1151        /* unmute any active DACs */
1152        for (i = 0; i < card->num_rtd; i++) {
1153                struct snd_soc_dai *dai = card->rtd[i].codec_dai;
1154                struct snd_soc_dai_driver *drv = dai->driver;
1155
1156                if (card->rtd[i].dai_link->ignore_suspend)
1157                        continue;
1158
1159                if (drv->ops->digital_mute && dai->playback_active)
1160                        drv->ops->digital_mute(dai, 0);
1161        }
1162
1163        for (i = 0; i < card->num_rtd; i++) {
1164                struct snd_soc_dai *cpu_dai = card->rtd[i].cpu_dai;
1165                struct snd_soc_platform *platform = card->rtd[i].platform;
1166
1167                if (card->rtd[i].dai_link->ignore_suspend)
1168                        continue;
1169
1170                if (cpu_dai->driver->resume && !cpu_dai->driver->ac97_control)
1171                        cpu_dai->driver->resume(cpu_dai);
1172                if (platform->driver->resume && platform->suspended) {
1173                        platform->driver->resume(cpu_dai);
1174                        platform->suspended = 0;
1175                }
1176        }
1177
1178        if (card->resume_post)
1179                card->resume_post(pdev);
1180
1181        dev_dbg(card->dev, "resume work completed\n");
1182
1183        /* userspace can access us now we are back as we were before */
1184        snd_power_change_state(card->snd_card, SNDRV_CTL_POWER_D0);
1185}
1186
1187/* powers up audio subsystem after a suspend */
1188static int soc_resume(struct device *dev)
1189{
1190        struct platform_device *pdev = to_platform_device(dev);
1191        struct snd_soc_card *card = platform_get_drvdata(pdev);
1192        int i;
1193
1194        /* AC97 devices might have other drivers hanging off them so
1195         * need to resume immediately.  Other drivers don't have that
1196         * problem and may take a substantial amount of time to resume
1197         * due to I/O costs and anti-pop so handle them out of line.
1198         */
1199        for (i = 0; i < card->num_rtd; i++) {
1200                struct snd_soc_dai *cpu_dai = card->rtd[i].cpu_dai;
1201                if (cpu_dai->driver->ac97_control) {
1202                        dev_dbg(dev, "Resuming AC97 immediately\n");
1203                        soc_resume_deferred(&card->deferred_resume_work);
1204                } else {
1205                        dev_dbg(dev, "Scheduling resume work\n");
1206                        if (!schedule_work(&card->deferred_resume_work))
1207                                dev_err(dev, "resume work item may be lost\n");
1208                }
1209        }
1210
1211        return 0;
1212}
1213#else
1214#define soc_suspend     NULL
1215#define soc_resume      NULL
1216#endif
1217
1218static struct snd_soc_dai_ops null_dai_ops = {
1219};
1220
1221static int soc_bind_dai_link(struct snd_soc_card *card, int num)
1222{
1223        struct snd_soc_dai_link *dai_link = &card->dai_link[num];
1224        struct snd_soc_pcm_runtime *rtd = &card->rtd[num];
1225        struct snd_soc_codec *codec;
1226        struct snd_soc_platform *platform;
1227        struct snd_soc_dai *codec_dai, *cpu_dai;
1228
1229        if (rtd->complete)
1230                return 1;
1231        dev_dbg(card->dev, "binding %s at idx %d\n", dai_link->name, num);
1232
1233        /* do we already have the CPU DAI for this link ? */
1234        if (rtd->cpu_dai) {
1235                goto find_codec;
1236        }
1237        /* no, then find CPU DAI from registered DAIs*/
1238        list_for_each_entry(cpu_dai, &dai_list, list) {
1239                if (!strcmp(cpu_dai->name, dai_link->cpu_dai_name)) {
1240
1241                        if (!try_module_get(cpu_dai->dev->driver->owner))
1242                                return -ENODEV;
1243
1244                        rtd->cpu_dai = cpu_dai;
1245                        goto find_codec;
1246                }
1247        }
1248        dev_dbg(card->dev, "CPU DAI %s not registered\n",
1249                        dai_link->cpu_dai_name);
1250
1251find_codec:
1252        /* do we already have the CODEC for this link ? */
1253        if (rtd->codec) {
1254                goto find_platform;
1255        }
1256
1257        /* no, then find CODEC from registered CODECs*/
1258        list_for_each_entry(codec, &codec_list, list) {
1259                if (!strcmp(codec->name, dai_link->codec_name)) {
1260                        rtd->codec = codec;
1261
1262                        /* CODEC found, so find CODEC DAI from registered DAIs from this CODEC*/
1263                        list_for_each_entry(codec_dai, &dai_list, list) {
1264                                if (codec->dev == codec_dai->dev &&
1265                                                !strcmp(codec_dai->name, dai_link->codec_dai_name)) {
1266                                        rtd->codec_dai = codec_dai;
1267                                        goto find_platform;
1268                                }
1269                        }
1270                        dev_dbg(card->dev, "CODEC DAI %s not registered\n",
1271                                        dai_link->codec_dai_name);
1272
1273                        goto find_platform;
1274                }
1275        }
1276        dev_dbg(card->dev, "CODEC %s not registered\n",
1277                        dai_link->codec_name);
1278
1279find_platform:
1280        /* do we already have the CODEC DAI for this link ? */
1281        if (rtd->platform) {
1282                goto out;
1283        }
1284        /* no, then find CPU DAI from registered DAIs*/
1285        list_for_each_entry(platform, &platform_list, list) {
1286                if (!strcmp(platform->name, dai_link->platform_name)) {
1287                        rtd->platform = platform;
1288                        goto out;
1289                }
1290        }
1291
1292        dev_dbg(card->dev, "platform %s not registered\n",
1293                        dai_link->platform_name);
1294        return 0;
1295
1296out:
1297        /* mark rtd as complete if we found all 4 of our client devices */
1298        if (rtd->codec && rtd->codec_dai && rtd->platform && rtd->cpu_dai) {
1299                rtd->complete = 1;
1300                card->num_rtd++;
1301        }
1302        return 1;
1303}
1304
1305static void soc_remove_codec(struct snd_soc_codec *codec)
1306{
1307        int err;
1308
1309        if (codec->driver->remove) {
1310                err = codec->driver->remove(codec);
1311                if (err < 0)
1312                        dev_err(codec->dev,
1313                                "asoc: failed to remove %s: %d\n",
1314                                codec->name, err);
1315        }
1316
1317        /* Make sure all DAPM widgets are freed */
1318        snd_soc_dapm_free(&codec->dapm);
1319
1320        soc_cleanup_codec_debugfs(codec);
1321        codec->probed = 0;
1322        list_del(&codec->card_list);
1323        module_put(codec->dev->driver->owner);
1324}
1325
1326static void soc_remove_dai_link(struct snd_soc_card *card, int num)
1327{
1328        struct snd_soc_pcm_runtime *rtd = &card->rtd[num];
1329        struct snd_soc_codec *codec = rtd->codec;
1330        struct snd_soc_platform *platform = rtd->platform;
1331        struct snd_soc_dai *codec_dai = rtd->codec_dai, *cpu_dai = rtd->cpu_dai;
1332        int err;
1333
1334        /* unregister the rtd device */
1335        if (rtd->dev_registered) {
1336                device_remove_file(&rtd->dev, &dev_attr_pmdown_time);
1337                device_remove_file(&rtd->dev, &dev_attr_codec_reg);
1338                device_unregister(&rtd->dev);
1339                rtd->dev_registered = 0;
1340        }
1341
1342        /* remove the CODEC DAI */
1343        if (codec_dai && codec_dai->probed) {
1344                if (codec_dai->driver->remove) {
1345                        err = codec_dai->driver->remove(codec_dai);
1346                        if (err < 0)
1347                                printk(KERN_ERR "asoc: failed to remove %s\n", codec_dai->name);
1348                }
1349                codec_dai->probed = 0;
1350                list_del(&codec_dai->card_list);
1351        }
1352
1353        /* remove the platform */
1354        if (platform && platform->probed) {
1355                if (platform->driver->remove) {
1356                        err = platform->driver->remove(platform);
1357                        if (err < 0)
1358                                printk(KERN_ERR "asoc: failed to remove %s\n", platform->name);
1359                }
1360                platform->probed = 0;
1361                list_del(&platform->card_list);
1362                module_put(platform->dev->driver->owner);
1363        }
1364
1365        /* remove the CODEC */
1366        if (codec && codec->probed)
1367                soc_remove_codec(codec);
1368
1369        /* remove the cpu_dai */
1370        if (cpu_dai && cpu_dai->probed) {
1371                if (cpu_dai->driver->remove) {
1372                        err = cpu_dai->driver->remove(cpu_dai);
1373                        if (err < 0)
1374                                printk(KERN_ERR "asoc: failed to remove %s\n", cpu_dai->name);
1375                }
1376                cpu_dai->probed = 0;
1377                list_del(&cpu_dai->card_list);
1378                module_put(cpu_dai->dev->driver->owner);
1379        }
1380}
1381
1382static void soc_set_name_prefix(struct snd_soc_card *card,
1383                                struct snd_soc_codec *codec)
1384{
1385        int i;
1386
1387        if (card->codec_conf == NULL)
1388                return;
1389
1390        for (i = 0; i < card->num_configs; i++) {
1391                struct snd_soc_codec_conf *map = &card->codec_conf[i];
1392                if (map->dev_name && !strcmp(codec->name, map->dev_name)) {
1393                        codec->name_prefix = map->name_prefix;
1394                        break;
1395                }
1396        }
1397}
1398
1399static int soc_probe_codec(struct snd_soc_card *card,
1400                           struct snd_soc_codec *codec)
1401{
1402        int ret = 0;
1403
1404        codec->card = card;
1405        codec->dapm.card = card;
1406        soc_set_name_prefix(card, codec);
1407
1408        if (codec->driver->probe) {
1409                ret = codec->driver->probe(codec);
1410                if (ret < 0) {
1411                        dev_err(codec->dev,
1412                                "asoc: failed to probe CODEC %s: %d\n",
1413                                codec->name, ret);
1414                        return ret;
1415                }
1416        }
1417
1418        soc_init_codec_debugfs(codec);
1419
1420        /* mark codec as probed and add to card codec list */
1421        if (!try_module_get(codec->dev->driver->owner))
1422                return -ENODEV;
1423
1424        codec->probed = 1;
1425        list_add(&codec->card_list, &card->codec_dev_list);
1426        list_add(&codec->dapm.list, &card->dapm_list);
1427
1428        return ret;
1429}
1430
1431static void rtd_release(struct device *dev) {}
1432
1433static int soc_post_component_init(struct snd_soc_card *card,
1434                                   struct snd_soc_codec *codec,
1435                                   int num, int dailess)
1436{
1437        struct snd_soc_dai_link *dai_link = NULL;
1438        struct snd_soc_aux_dev *aux_dev = NULL;
1439        struct snd_soc_pcm_runtime *rtd;
1440        const char *temp, *name;
1441        int ret = 0;
1442
1443        if (!dailess) {
1444                dai_link = &card->dai_link[num];
1445                rtd = &card->rtd[num];
1446                name = dai_link->name;
1447        } else {
1448                aux_dev = &card->aux_dev[num];
1449                rtd = &card->rtd_aux[num];
1450                name = aux_dev->name;
1451        }
1452        rtd->card = card;
1453
1454        /* machine controls, routes and widgets are not prefixed */
1455        temp = codec->name_prefix;
1456        codec->name_prefix = NULL;
1457
1458        /* do machine specific initialization */
1459        if (!dailess && dai_link->init)
1460                ret = dai_link->init(rtd);
1461        else if (dailess && aux_dev->init)
1462                ret = aux_dev->init(&codec->dapm);
1463        if (ret < 0) {
1464                dev_err(card->dev, "asoc: failed to init %s: %d\n", name, ret);
1465                return ret;
1466        }
1467        codec->name_prefix = temp;
1468
1469        /* Make sure all DAPM widgets are instantiated */
1470        snd_soc_dapm_new_widgets(&codec->dapm);
1471        snd_soc_dapm_sync(&codec->dapm);
1472
1473        /* register the rtd device */
1474        rtd->codec = codec;
1475        rtd->dev.parent = card->dev;
1476        rtd->dev.release = rtd_release;
1477        rtd->dev.init_name = name;
1478        ret = device_register(&rtd->dev);
1479        if (ret < 0) {
1480                dev_err(card->dev,
1481                        "asoc: failed to register runtime device: %d\n", ret);
1482                return ret;
1483        }
1484        rtd->dev_registered = 1;
1485
1486        /* add DAPM sysfs entries for this codec */
1487        ret = snd_soc_dapm_sys_add(&rtd->dev);
1488        if (ret < 0)
1489                dev_err(codec->dev,
1490                        "asoc: failed to add codec dapm sysfs entries: %d\n",
1491                        ret);
1492
1493        /* add codec sysfs entries */
1494        ret = device_create_file(&rtd->dev, &dev_attr_codec_reg);
1495        if (ret < 0)
1496                dev_err(codec->dev,
1497                        "asoc: failed to add codec sysfs files: %d\n", ret);
1498
1499        return 0;
1500}
1501
1502static int soc_probe_dai_link(struct snd_soc_card *card, int num)
1503{
1504        struct snd_soc_dai_link *dai_link = &card->dai_link[num];
1505        struct snd_soc_pcm_runtime *rtd = &card->rtd[num];
1506        struct snd_soc_codec *codec = rtd->codec;
1507        struct snd_soc_platform *platform = rtd->platform;
1508        struct snd_soc_dai *codec_dai = rtd->codec_dai, *cpu_dai = rtd->cpu_dai;
1509        int ret;
1510
1511        dev_dbg(card->dev, "probe %s dai link %d\n", card->name, num);
1512
1513        /* config components */
1514        codec_dai->codec = codec;
1515        cpu_dai->platform = platform;
1516        codec_dai->card = card;
1517        cpu_dai->card = card;
1518
1519        /* set default power off timeout */
1520        rtd->pmdown_time = pmdown_time;
1521
1522        /* probe the cpu_dai */
1523        if (!cpu_dai->probed) {
1524                if (cpu_dai->driver->probe) {
1525                        ret = cpu_dai->driver->probe(cpu_dai);
1526                        if (ret < 0) {
1527                                printk(KERN_ERR "asoc: failed to probe CPU DAI %s\n",
1528                                                cpu_dai->name);
1529                                return ret;
1530                        }
1531                }
1532                cpu_dai->probed = 1;
1533                /* mark cpu_dai as probed and add to card cpu_dai list */
1534                list_add(&cpu_dai->card_list, &card->dai_dev_list);
1535        }
1536
1537        /* probe the CODEC */
1538        if (!codec->probed) {
1539                ret = soc_probe_codec(card, codec);
1540                if (ret < 0)
1541                        return ret;
1542        }
1543
1544        /* probe the platform */
1545        if (!platform->probed) {
1546                if (platform->driver->probe) {
1547                        ret = platform->driver->probe(platform);
1548                        if (ret < 0) {
1549                                printk(KERN_ERR "asoc: failed to probe platform %s\n",
1550                                                platform->name);
1551                                return ret;
1552                        }
1553                }
1554                /* mark platform as probed and add to card platform list */
1555
1556                if (!try_module_get(platform->dev->driver->owner))
1557                        return -ENODEV;
1558
1559                platform->probed = 1;
1560                list_add(&platform->card_list, &card->platform_dev_list);
1561        }
1562
1563        /* probe the CODEC DAI */
1564        if (!codec_dai->probed) {
1565                if (codec_dai->driver->probe) {
1566                        ret = codec_dai->driver->probe(codec_dai);
1567                        if (ret < 0) {
1568                                printk(KERN_ERR "asoc: failed to probe CODEC DAI %s\n",
1569                                                codec_dai->name);
1570                                return ret;
1571                        }
1572                }
1573
1574                /* mark cpu_dai as probed and add to card cpu_dai list */
1575                codec_dai->probed = 1;
1576                list_add(&codec_dai->card_list, &card->dai_dev_list);
1577        }
1578
1579        /* DAPM dai link stream work */
1580        INIT_DELAYED_WORK(&rtd->delayed_work, close_delayed_work);
1581
1582        ret = soc_post_component_init(card, codec, num, 0);
1583        if (ret)
1584                return ret;
1585
1586        ret = device_create_file(&rtd->dev, &dev_attr_pmdown_time);
1587        if (ret < 0)
1588                printk(KERN_WARNING "asoc: failed to add pmdown_time sysfs\n");
1589
1590        /* create the pcm */
1591        ret = soc_new_pcm(rtd, num);
1592        if (ret < 0) {
1593                printk(KERN_ERR "asoc: can't create pcm %s\n", dai_link->stream_name);
1594                return ret;
1595        }
1596
1597        /* add platform data for AC97 devices */
1598        if (rtd->codec_dai->driver->ac97_control)
1599                snd_ac97_dev_add_pdata(codec->ac97, rtd->cpu_dai->ac97_pdata);
1600
1601        return 0;
1602}
1603
1604#ifdef CONFIG_SND_SOC_AC97_BUS
1605static int soc_register_ac97_dai_link(struct snd_soc_pcm_runtime *rtd)
1606{
1607        int ret;
1608
1609        /* Only instantiate AC97 if not already done by the adaptor
1610         * for the generic AC97 subsystem.
1611         */
1612        if (rtd->codec_dai->driver->ac97_control && !rtd->codec->ac97_registered) {
1613                /*
1614                 * It is possible that the AC97 device is already registered to
1615                 * the device subsystem. This happens when the device is created
1616                 * via snd_ac97_mixer(). Currently only SoC codec that does so
1617                 * is the generic AC97 glue but others migh emerge.
1618                 *
1619                 * In those cases we don't try to register the device again.
1620                 */
1621                if (!rtd->codec->ac97_created)
1622                        return 0;
1623
1624                ret = soc_ac97_dev_register(rtd->codec);
1625                if (ret < 0) {
1626                        printk(KERN_ERR "asoc: AC97 device register failed\n");
1627                        return ret;
1628                }
1629
1630                rtd->codec->ac97_registered = 1;
1631        }
1632        return 0;
1633}
1634
1635static void soc_unregister_ac97_dai_link(struct snd_soc_codec *codec)
1636{
1637        if (codec->ac97_registered) {
1638                soc_ac97_dev_unregister(codec);
1639                codec->ac97_registered = 0;
1640        }
1641}
1642#endif
1643
1644static int soc_probe_aux_dev(struct snd_soc_card *card, int num)
1645{
1646        struct snd_soc_aux_dev *aux_dev = &card->aux_dev[num];
1647        struct snd_soc_codec *codec;
1648        int ret = -ENODEV;
1649
1650        /* find CODEC from registered CODECs*/
1651        list_for_each_entry(codec, &codec_list, list) {
1652                if (!strcmp(codec->name, aux_dev->codec_name)) {
1653                        if (codec->probed) {
1654                                dev_err(codec->dev,
1655                                        "asoc: codec already probed");
1656                                ret = -EBUSY;
1657                                goto out;
1658                        }
1659                        goto found;
1660                }
1661        }
1662        /* codec not found */
1663        dev_err(card->dev, "asoc: codec %s not found", aux_dev->codec_name);
1664        goto out;
1665
1666found:
1667        ret = soc_probe_codec(card, codec);
1668        if (ret < 0)
1669                return ret;
1670
1671        ret = soc_post_component_init(card, codec, num, 1);
1672
1673out:
1674        return ret;
1675}
1676
1677static void soc_remove_aux_dev(struct snd_soc_card *card, int num)
1678{
1679        struct snd_soc_pcm_runtime *rtd = &card->rtd_aux[num];
1680        struct snd_soc_codec *codec = rtd->codec;
1681
1682        /* unregister the rtd device */
1683        if (rtd->dev_registered) {
1684                device_remove_file(&rtd->dev, &dev_attr_codec_reg);
1685                device_unregister(&rtd->dev);
1686                rtd->dev_registered = 0;
1687        }
1688
1689        if (codec && codec->probed)
1690                soc_remove_codec(codec);
1691}
1692
1693static int snd_soc_init_codec_cache(struct snd_soc_codec *codec,
1694                                    enum snd_soc_compress_type compress_type)
1695{
1696        int ret;
1697
1698        if (codec->cache_init)
1699                return 0;
1700
1701        /* override the compress_type if necessary */
1702        if (compress_type && codec->compress_type != compress_type)
1703                codec->compress_type = compress_type;
1704        ret = snd_soc_cache_init(codec);
1705        if (ret < 0) {
1706                dev_err(codec->dev, "Failed to set cache compression type: %d\n",
1707                        ret);
1708                return ret;
1709        }
1710        codec->cache_init = 1;
1711        return 0;
1712}
1713
1714static void snd_soc_instantiate_card(struct snd_soc_card *card)
1715{
1716        struct platform_device *pdev = to_platform_device(card->dev);
1717        struct snd_soc_codec *codec;
1718        struct snd_soc_codec_conf *codec_conf;
1719        enum snd_soc_compress_type compress_type;
1720        int ret, i;
1721
1722        mutex_lock(&card->mutex);
1723
1724        if (card->instantiated) {
1725                mutex_unlock(&card->mutex);
1726                return;
1727        }
1728
1729        /* bind DAIs */
1730        for (i = 0; i < card->num_links; i++)
1731                soc_bind_dai_link(card, i);
1732
1733        /* bind completed ? */
1734        if (card->num_rtd != card->num_links) {
1735                mutex_unlock(&card->mutex);
1736                return;
1737        }
1738
1739        /* initialize the register cache for each available codec */
1740        list_for_each_entry(codec, &codec_list, list) {
1741                if (codec->cache_init)
1742                        continue;
1743                /* check to see if we need to override the compress_type */
1744                for (i = 0; i < card->num_configs; ++i) {
1745                        codec_conf = &card->codec_conf[i];
1746                        if (!strcmp(codec->name, codec_conf->dev_name)) {
1747                                compress_type = codec_conf->compress_type;
1748                                if (compress_type && compress_type
1749                                    != codec->compress_type)
1750                                        break;
1751                        }
1752                }
1753                if (i == card->num_configs) {
1754                        /* no need to override the compress_type so
1755                         * go ahead and do the standard thing */
1756                        ret = snd_soc_init_codec_cache(codec, 0);
1757                        if (ret < 0) {
1758                                mutex_unlock(&card->mutex);
1759                                return;
1760                        }
1761                        continue;
1762                }
1763                /* override the compress_type with the one supplied in
1764                 * the machine driver */
1765                ret = snd_soc_init_codec_cache(codec, compress_type);
1766                if (ret < 0) {
1767                        mutex_unlock(&card->mutex);
1768                        return;
1769                }
1770        }
1771
1772        /* card bind complete so register a sound card */
1773        ret = snd_card_create(SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1,
1774                        card->owner, 0, &card->snd_card);
1775        if (ret < 0) {
1776                printk(KERN_ERR "asoc: can't create sound card for card %s\n",
1777                        card->name);
1778                mutex_unlock(&card->mutex);
1779                return;
1780        }
1781        card->snd_card->dev = card->dev;
1782
1783#ifdef CONFIG_PM
1784        /* deferred resume work */
1785        INIT_WORK(&card->deferred_resume_work, soc_resume_deferred);
1786#endif
1787
1788        /* initialise the sound card only once */
1789        if (card->probe) {
1790                ret = card->probe(pdev);
1791                if (ret < 0)
1792                        goto card_probe_error;
1793        }
1794
1795        for (i = 0; i < card->num_links; i++) {
1796                ret = soc_probe_dai_link(card, i);
1797                if (ret < 0) {
1798                        pr_err("asoc: failed to instantiate card %s: %d\n",
1799                               card->name, ret);
1800                        goto probe_dai_err;
1801                }
1802        }
1803
1804        for (i = 0; i < card->num_aux_devs; i++) {
1805                ret = soc_probe_aux_dev(card, i);
1806                if (ret < 0) {
1807                        pr_err("asoc: failed to add auxiliary devices %s: %d\n",
1808                               card->name, ret);
1809                        goto probe_aux_dev_err;
1810                }
1811        }
1812
1813        snprintf(card->snd_card->shortname, sizeof(card->snd_card->shortname),
1814                 "%s",  card->name);
1815        snprintf(card->snd_card->longname, sizeof(card->snd_card->longname),
1816                 "%s", card->name);
1817
1818        ret = snd_card_register(card->snd_card);
1819        if (ret < 0) {
1820                printk(KERN_ERR "asoc: failed to register soundcard for %s\n", card->name);
1821                goto probe_aux_dev_err;
1822        }
1823
1824#ifdef CONFIG_SND_SOC_AC97_BUS
1825        /* register any AC97 codecs */
1826        for (i = 0; i < card->num_rtd; i++) {
1827                ret = soc_register_ac97_dai_link(&card->rtd[i]);
1828                if (ret < 0) {
1829                        printk(KERN_ERR "asoc: failed to register AC97 %s\n", card->name);
1830                        while (--i >= 0)
1831                                soc_unregister_ac97_dai_link(card->rtd[i].codec);
1832                        goto probe_aux_dev_err;
1833                }
1834        }
1835#endif
1836
1837        card->instantiated = 1;
1838        mutex_unlock(&card->mutex);
1839        return;
1840
1841probe_aux_dev_err:
1842        for (i = 0; i < card->num_aux_devs; i++)
1843                soc_remove_aux_dev(card, i);
1844
1845probe_dai_err:
1846        for (i = 0; i < card->num_links; i++)
1847                soc_remove_dai_link(card, i);
1848
1849card_probe_error:
1850        if (card->remove)
1851                card->remove(pdev);
1852
1853        snd_card_free(card->snd_card);
1854
1855        mutex_unlock(&card->mutex);
1856}
1857
1858/*
1859 * Attempt to initialise any uninitialised cards.  Must be called with
1860 * client_mutex.
1861 */
1862static void snd_soc_instantiate_cards(void)
1863{
1864        struct snd_soc_card *card;
1865        list_for_each_entry(card, &card_list, list)
1866                snd_soc_instantiate_card(card);
1867}
1868
1869/* probes a new socdev */
1870static int soc_probe(struct platform_device *pdev)
1871{
1872        struct snd_soc_card *card = platform_get_drvdata(pdev);
1873        int ret = 0;
1874
1875        /* Bodge while we unpick instantiation */
1876        card->dev = &pdev->dev;
1877        INIT_LIST_HEAD(&card->dai_dev_list);
1878        INIT_LIST_HEAD(&card->codec_dev_list);
1879        INIT_LIST_HEAD(&card->platform_dev_list);
1880        INIT_LIST_HEAD(&card->widgets);
1881        INIT_LIST_HEAD(&card->paths);
1882        INIT_LIST_HEAD(&card->dapm_list);
1883
1884        soc_init_card_debugfs(card);
1885
1886        ret = snd_soc_register_card(card);
1887        if (ret != 0) {
1888                dev_err(&pdev->dev, "Failed to register card\n");
1889                return ret;
1890        }
1891
1892        return 0;
1893}
1894
1895/* removes a socdev */
1896static int soc_remove(struct platform_device *pdev)
1897{
1898        struct snd_soc_card *card = platform_get_drvdata(pdev);
1899        int i;
1900
1901                if (card->instantiated) {
1902
1903                /* make sure any delayed work runs */
1904                for (i = 0; i < card->num_rtd; i++) {
1905                        struct snd_soc_pcm_runtime *rtd = &card->rtd[i];
1906                        flush_delayed_work_sync(&rtd->delayed_work);
1907                }
1908
1909                /* remove auxiliary devices */
1910                for (i = 0; i < card->num_aux_devs; i++)
1911                        soc_remove_aux_dev(card, i);
1912
1913                /* remove and free each DAI */
1914                for (i = 0; i < card->num_rtd; i++)
1915                        soc_remove_dai_link(card, i);
1916
1917                soc_cleanup_card_debugfs(card);
1918
1919                /* remove the card */
1920                if (card->remove)
1921                        card->remove(pdev);
1922
1923                kfree(card->rtd);
1924                snd_card_free(card->snd_card);
1925        }
1926        snd_soc_unregister_card(card);
1927        return 0;
1928}
1929
1930static int soc_poweroff(struct device *dev)
1931{
1932        struct platform_device *pdev = to_platform_device(dev);
1933        struct snd_soc_card *card = platform_get_drvdata(pdev);
1934        int i;
1935
1936        if (!card->instantiated)
1937                return 0;
1938
1939        /* Flush out pmdown_time work - we actually do want to run it
1940         * now, we're shutting down so no imminent restart. */
1941        for (i = 0; i < card->num_rtd; i++) {
1942                struct snd_soc_pcm_runtime *rtd = &card->rtd[i];
1943                flush_delayed_work_sync(&rtd->delayed_work);
1944        }
1945
1946        snd_soc_dapm_shutdown(card);
1947
1948        return 0;
1949}
1950
1951static const struct dev_pm_ops soc_pm_ops = {
1952        .suspend = soc_suspend,
1953        .resume = soc_resume,
1954        .poweroff = soc_poweroff,
1955};
1956
1957/* ASoC platform driver */
1958static struct platform_driver soc_driver = {
1959        .driver         = {
1960                .name           = "soc-audio",
1961                .owner          = THIS_MODULE,
1962                .pm             = &soc_pm_ops,
1963        },
1964        .probe          = soc_probe,
1965        .remove         = soc_remove,
1966};
1967
1968/* create a new pcm */
1969static int soc_new_pcm(struct snd_soc_pcm_runtime *rtd, int num)
1970{
1971        struct snd_soc_codec *codec = rtd->codec;
1972        struct snd_soc_platform *platform = rtd->platform;
1973        struct snd_soc_dai *codec_dai = rtd->codec_dai;
1974        struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
1975        struct snd_pcm *pcm;
1976        char new_name[64];
1977        int ret = 0, playback = 0, capture = 0;
1978
1979        /* check client and interface hw capabilities */
1980        snprintf(new_name, sizeof(new_name), "%s %s-%d",
1981                        rtd->dai_link->stream_name, codec_dai->name, num);
1982
1983        if (codec_dai->driver->playback.channels_min)
1984                playback = 1;
1985        if (codec_dai->driver->capture.channels_min)
1986                capture = 1;
1987
1988        dev_dbg(rtd->card->dev, "registered pcm #%d %s\n",num,new_name);
1989        ret = snd_pcm_new(rtd->card->snd_card, new_name,
1990                        num, playback, capture, &pcm);
1991        if (ret < 0) {
1992                printk(KERN_ERR "asoc: can't create pcm for codec %s\n", codec->name);
1993                return ret;
1994        }
1995
1996        rtd->pcm = pcm;
1997        pcm->private_data = rtd;
1998        soc_pcm_ops.mmap = platform->driver->ops->mmap;
1999        soc_pcm_ops.pointer = platform->driver->ops->pointer;
2000        soc_pcm_ops.ioctl = platform->driver->ops->ioctl;
2001        soc_pcm_ops.copy = platform->driver->ops->copy;
2002        soc_pcm_ops.silence = platform->driver->ops->silence;
2003        soc_pcm_ops.ack = platform->driver->ops->ack;
2004        soc_pcm_ops.page = platform->driver->ops->page;
2005
2006        if (playback)
2007                snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &soc_pcm_ops);
2008
2009        if (capture)
2010                snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &soc_pcm_ops);
2011
2012        ret = platform->driver->pcm_new(rtd->card->snd_card, codec_dai, pcm);
2013        if (ret < 0) {
2014                printk(KERN_ERR "asoc: platform pcm constructor failed\n");
2015                return ret;
2016        }
2017
2018        pcm->private_free = platform->driver->pcm_free;
2019        printk(KERN_INFO "asoc: %s <-> %s mapping ok\n", codec_dai->name,
2020                cpu_dai->name);
2021        return ret;
2022}
2023
2024/**
2025 * snd_soc_codec_volatile_register: Report if a register is volatile.
2026 *
2027 * @codec: CODEC to query.
2028 * @reg: Register to query.
2029 *
2030 * Boolean function indiciating if a CODEC register is volatile.
2031 */
2032int snd_soc_codec_volatile_register(struct snd_soc_codec *codec, int reg)
2033{
2034        if (codec->driver->volatile_register)
2035                return codec->driver->volatile_register(reg);
2036        else
2037                return 0;
2038}
2039EXPORT_SYMBOL_GPL(snd_soc_codec_volatile_register);
2040
2041/**
2042 * snd_soc_new_ac97_codec - initailise AC97 device
2043 * @codec: audio codec
2044 * @ops: AC97 bus operations
2045 * @num: AC97 codec number
2046 *
2047 * Initialises AC97 codec resources for use by ad-hoc devices only.
2048 */
2049int snd_soc_new_ac97_codec(struct snd_soc_codec *codec,
2050        struct snd_ac97_bus_ops *ops, int num)
2051{
2052        mutex_lock(&codec->mutex);
2053
2054        codec->ac97 = kzalloc(sizeof(struct snd_ac97), GFP_KERNEL);
2055        if (codec->ac97 == NULL) {
2056                mutex_unlock(&codec->mutex);
2057                return -ENOMEM;
2058        }
2059
2060        codec->ac97->bus = kzalloc(sizeof(struct snd_ac97_bus), GFP_KERNEL);
2061        if (codec->ac97->bus == NULL) {
2062                kfree(codec->ac97);
2063                codec->ac97 = NULL;
2064                mutex_unlock(&codec->mutex);
2065                return -ENOMEM;
2066        }
2067
2068        codec->ac97->bus->ops = ops;
2069        codec->ac97->num = num;
2070
2071        /*
2072         * Mark the AC97 device to be created by us. This way we ensure that the
2073         * device will be registered with the device subsystem later on.
2074         */
2075        codec->ac97_created = 1;
2076
2077        mutex_unlock(&codec->mutex);
2078        return 0;
2079}
2080EXPORT_SYMBOL_GPL(snd_soc_new_ac97_codec);
2081
2082/**
2083 * snd_soc_free_ac97_codec - free AC97 codec device
2084 * @codec: audio codec
2085 *
2086 * Frees AC97 codec device resources.
2087 */
2088void snd_soc_free_ac97_codec(struct snd_soc_codec *codec)
2089{
2090        mutex_lock(&codec->mutex);
2091#ifdef CONFIG_SND_SOC_AC97_BUS
2092        soc_unregister_ac97_dai_link(codec);
2093#endif
2094        kfree(codec->ac97->bus);
2095        kfree(codec->ac97);
2096        codec->ac97 = NULL;
2097        codec->ac97_created = 0;
2098        mutex_unlock(&codec->mutex);
2099}
2100EXPORT_SYMBOL_GPL(snd_soc_free_ac97_codec);
2101
2102unsigned int snd_soc_read(struct snd_soc_codec *codec, unsigned int reg)
2103{
2104        unsigned int ret;
2105
2106        ret = codec->read(codec, reg);
2107        dev_dbg(codec->dev, "read %x => %x\n", reg, ret);
2108        trace_snd_soc_reg_read(codec, reg, ret);
2109
2110        return ret;
2111}
2112EXPORT_SYMBOL_GPL(snd_soc_read);
2113
2114unsigned int snd_soc_write(struct snd_soc_codec *codec,
2115                           unsigned int reg, unsigned int val)
2116{
2117        dev_dbg(codec->dev, "write %x = %x\n", reg, val);
2118        trace_snd_soc_reg_write(codec, reg, val);
2119        return codec->write(codec, reg, val);
2120}
2121EXPORT_SYMBOL_GPL(snd_soc_write);
2122
2123/**
2124 * snd_soc_update_bits - update codec register bits
2125 * @codec: audio codec
2126 * @reg: codec register
2127 * @mask: register mask
2128 * @value: new value
2129 *
2130 * Writes new register value.
2131 *
2132 * Returns 1 for change else 0.
2133 */
2134int snd_soc_update_bits(struct snd_soc_codec *codec, unsigned short reg,
2135                                unsigned int mask, unsigned int value)
2136{
2137        int change;
2138        unsigned int old, new;
2139
2140        old = snd_soc_read(codec, reg);
2141        new = (old & ~mask) | value;
2142        change = old != new;
2143        if (change)
2144                snd_soc_write(codec, reg, new);
2145
2146        return change;
2147}
2148EXPORT_SYMBOL_GPL(snd_soc_update_bits);
2149
2150/**
2151 * snd_soc_update_bits_locked - update codec register bits
2152 * @codec: audio codec
2153 * @reg: codec register
2154 * @mask: register mask
2155 * @value: new value
2156 *
2157 * Writes new register value, and takes the codec mutex.
2158 *
2159 * Returns 1 for change else 0.
2160 */
2161int snd_soc_update_bits_locked(struct snd_soc_codec *codec,
2162                               unsigned short reg, unsigned int mask,
2163                               unsigned int value)
2164{
2165        int change;
2166
2167        mutex_lock(&codec->mutex);
2168        change = snd_soc_update_bits(codec, reg, mask, value);
2169        mutex_unlock(&codec->mutex);
2170
2171        return change;
2172}
2173EXPORT_SYMBOL_GPL(snd_soc_update_bits_locked);
2174
2175/**
2176 * snd_soc_test_bits - test register for change
2177 * @codec: audio codec
2178 * @reg: codec register
2179 * @mask: register mask
2180 * @value: new value
2181 *
2182 * Tests a register with a new value and checks if the new value is
2183 * different from the old value.
2184 *
2185 * Returns 1 for change else 0.
2186 */
2187int snd_soc_test_bits(struct snd_soc_codec *codec, unsigned short reg,
2188                                unsigned int mask, unsigned int value)
2189{
2190        int change;
2191        unsigned int old, new;
2192
2193        old = snd_soc_read(codec, reg);
2194        new = (old & ~mask) | value;
2195        change = old != new;
2196
2197        return change;
2198}
2199EXPORT_SYMBOL_GPL(snd_soc_test_bits);
2200
2201/**
2202 * snd_soc_set_runtime_hwparams - set the runtime hardware parameters
2203 * @substream: the pcm substream
2204 * @hw: the hardware parameters
2205 *
2206 * Sets the substream runtime hardware parameters.
2207 */
2208int snd_soc_set_runtime_hwparams(struct snd_pcm_substream *substream,
2209        const struct snd_pcm_hardware *hw)
2210{
2211        struct snd_pcm_runtime *runtime = substream->runtime;
2212        runtime->hw.info = hw->info;
2213        runtime->hw.formats = hw->formats;
2214        runtime->hw.period_bytes_min = hw->period_bytes_min;
2215        runtime->hw.period_bytes_max = hw->period_bytes_max;
2216        runtime->hw.periods_min = hw->periods_min;
2217        runtime->hw.periods_max = hw->periods_max;
2218        runtime->hw.buffer_bytes_max = hw->buffer_bytes_max;
2219        runtime->hw.fifo_size = hw->fifo_size;
2220        return 0;
2221}
2222EXPORT_SYMBOL_GPL(snd_soc_set_runtime_hwparams);
2223
2224/**
2225 * snd_soc_cnew - create new control
2226 * @_template: control template
2227 * @data: control private data
2228 * @long_name: control long name
2229 *
2230 * Create a new mixer control from a template control.
2231 *
2232 * Returns 0 for success, else error.
2233 */
2234struct snd_kcontrol *snd_soc_cnew(const struct snd_kcontrol_new *_template,
2235        void *data, char *long_name)
2236{
2237        struct snd_kcontrol_new template;
2238
2239        memcpy(&template, _template, sizeof(template));
2240        if (long_name)
2241                template.name = long_name;
2242        template.index = 0;
2243
2244        return snd_ctl_new1(&template, data);
2245}
2246EXPORT_SYMBOL_GPL(snd_soc_cnew);
2247
2248/**
2249 * snd_soc_add_controls - add an array of controls to a codec.
2250 * Convienience function to add a list of controls. Many codecs were
2251 * duplicating this code.
2252 *
2253 * @codec: codec to add controls to
2254 * @controls: array of controls to add
2255 * @num_controls: number of elements in the array
2256 *
2257 * Return 0 for success, else error.
2258 */
2259int snd_soc_add_controls(struct snd_soc_codec *codec,
2260        const struct snd_kcontrol_new *controls, int num_controls)
2261{
2262        struct snd_card *card = codec->card->snd_card;
2263        char prefixed_name[44], *name;
2264        int err, i;
2265
2266        for (i = 0; i < num_controls; i++) {
2267                const struct snd_kcontrol_new *control = &controls[i];
2268                if (codec->name_prefix) {
2269                        snprintf(prefixed_name, sizeof(prefixed_name), "%s %s",
2270                                 codec->name_prefix, control->name);
2271                        name = prefixed_name;
2272                } else {
2273                        name = control->name;
2274                }
2275                err = snd_ctl_add(card, snd_soc_cnew(control, codec, name));
2276                if (err < 0) {
2277                        dev_err(codec->dev, "%s: Failed to add %s: %d\n",
2278                                codec->name, name, err);
2279                        return err;
2280                }
2281        }
2282
2283        return 0;
2284}
2285EXPORT_SYMBOL_GPL(snd_soc_add_controls);
2286
2287/**
2288 * snd_soc_info_enum_double - enumerated double mixer info callback
2289 * @kcontrol: mixer control
2290 * @uinfo: control element information
2291 *
2292 * Callback to provide information about a double enumerated
2293 * mixer control.
2294 *
2295 * Returns 0 for success.
2296 */
2297int snd_soc_info_enum_double(struct snd_kcontrol *kcontrol,
2298        struct snd_ctl_elem_info *uinfo)
2299{
2300        struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
2301
2302        uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2303        uinfo->count = e->shift_l == e->shift_r ? 1 : 2;
2304        uinfo->value.enumerated.items = e->max;
2305
2306        if (uinfo->value.enumerated.item > e->max - 1)
2307                uinfo->value.enumerated.item = e->max - 1;
2308        strcpy(uinfo->value.enumerated.name,
2309                e->texts[uinfo->value.enumerated.item]);
2310        return 0;
2311}
2312EXPORT_SYMBOL_GPL(snd_soc_info_enum_double);
2313
2314/**
2315 * snd_soc_get_enum_double - enumerated double mixer get callback
2316 * @kcontrol: mixer control
2317 * @ucontrol: control element information
2318 *
2319 * Callback to get the value of a double enumerated mixer.
2320 *
2321 * Returns 0 for success.
2322 */
2323int snd_soc_get_enum_double(struct snd_kcontrol *kcontrol,
2324        struct snd_ctl_elem_value *ucontrol)
2325{
2326        struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
2327        struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
2328        unsigned int val, bitmask;
2329
2330        for (bitmask = 1; bitmask < e->max; bitmask <<= 1)
2331                ;
2332        val = snd_soc_read(codec, e->reg);
2333        ucontrol->value.enumerated.item[0]
2334                = (val >> e->shift_l) & (bitmask - 1);
2335        if (e->shift_l != e->shift_r)
2336                ucontrol->value.enumerated.item[1] =
2337                        (val >> e->shift_r) & (bitmask - 1);
2338
2339        return 0;
2340}
2341EXPORT_SYMBOL_GPL(snd_soc_get_enum_double);
2342
2343/**
2344 * snd_soc_put_enum_double - enumerated double mixer put callback
2345 * @kcontrol: mixer control
2346 * @ucontrol: control element information
2347 *
2348 * Callback to set the value of a double enumerated mixer.
2349 *
2350 * Returns 0 for success.
2351 */
2352int snd_soc_put_enum_double(struct snd_kcontrol *kcontrol,
2353        struct snd_ctl_elem_value *ucontrol)
2354{
2355        struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
2356        struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
2357        unsigned int val;
2358        unsigned int mask, bitmask;
2359
2360        for (bitmask = 1; bitmask < e->max; bitmask <<= 1)
2361                ;
2362        if (ucontrol->value.enumerated.item[0] > e->max - 1)
2363                return -EINVAL;
2364        val = ucontrol->value.enumerated.item[0] << e->shift_l;
2365        mask = (bitmask - 1) << e->shift_l;
2366        if (e->shift_l != e->shift_r) {
2367                if (ucontrol->value.enumerated.item[1] > e->max - 1)
2368                        return -EINVAL;
2369                val |= ucontrol->value.enumerated.item[1] << e->shift_r;
2370                mask |= (bitmask - 1) << e->shift_r;
2371        }
2372
2373        return snd_soc_update_bits_locked(codec, e->reg, mask, val);
2374}
2375EXPORT_SYMBOL_GPL(snd_soc_put_enum_double);
2376
2377/**
2378 * snd_soc_get_value_enum_double - semi enumerated double mixer get callback
2379 * @kcontrol: mixer control
2380 * @ucontrol: control element information
2381 *
2382 * Callback to get the value of a double semi enumerated mixer.
2383 *
2384 * Semi enumerated mixer: the enumerated items are referred as values. Can be
2385 * used for handling bitfield coded enumeration for example.
2386 *
2387 * Returns 0 for success.
2388 */
2389int snd_soc_get_value_enum_double(struct snd_kcontrol *kcontrol,
2390        struct snd_ctl_elem_value *ucontrol)
2391{
2392        struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
2393        struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
2394        unsigned int reg_val, val, mux;
2395
2396        reg_val = snd_soc_read(codec, e->reg);
2397        val = (reg_val >> e->shift_l) & e->mask;
2398        for (mux = 0; mux < e->max; mux++) {
2399                if (val == e->values[mux])
2400                        break;
2401        }
2402        ucontrol->value.enumerated.item[0] = mux;
2403        if (e->shift_l != e->shift_r) {
2404                val = (reg_val >> e->shift_r) & e->mask;
2405                for (mux = 0; mux < e->max; mux++) {
2406                        if (val == e->values[mux])
2407                                break;
2408                }
2409                ucontrol->value.enumerated.item[1] = mux;
2410        }
2411
2412        return 0;
2413}
2414EXPORT_SYMBOL_GPL(snd_soc_get_value_enum_double);
2415
2416/**
2417 * snd_soc_put_value_enum_double - semi enumerated double mixer put callback
2418 * @kcontrol: mixer control
2419 * @ucontrol: control element information
2420 *
2421 * Callback to set the value of a double semi enumerated mixer.
2422 *
2423 * Semi enumerated mixer: the enumerated items are referred as values. Can be
2424 * used for handling bitfield coded enumeration for example.
2425 *
2426 * Returns 0 for success.
2427 */
2428int snd_soc_put_value_enum_double(struct snd_kcontrol *kcontrol,
2429        struct snd_ctl_elem_value *ucontrol)
2430{
2431        struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
2432        struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
2433        unsigned int val;
2434        unsigned int mask;
2435
2436        if (ucontrol->value.enumerated.item[0] > e->max - 1)
2437                return -EINVAL;
2438        val = e->values[ucontrol->value.enumerated.item[0]] << e->shift_l;
2439        mask = e->mask << e->shift_l;
2440        if (e->shift_l != e->shift_r) {
2441                if (ucontrol->value.enumerated.item[1] > e->max - 1)
2442                        return -EINVAL;
2443                val |= e->values[ucontrol->value.enumerated.item[1]] << e->shift_r;
2444                mask |= e->mask << e->shift_r;
2445        }
2446
2447        return snd_soc_update_bits_locked(codec, e->reg, mask, val);
2448}
2449EXPORT_SYMBOL_GPL(snd_soc_put_value_enum_double);
2450
2451/**
2452 * snd_soc_info_enum_ext - external enumerated single mixer info callback
2453 * @kcontrol: mixer control
2454 * @uinfo: control element information
2455 *
2456 * Callback to provide information about an external enumerated
2457 * single mixer.
2458 *
2459 * Returns 0 for success.
2460 */
2461int snd_soc_info_enum_ext(struct snd_kcontrol *kcontrol,
2462        struct snd_ctl_elem_info *uinfo)
2463{
2464        struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
2465
2466        uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2467        uinfo->count = 1;
2468        uinfo->value.enumerated.items = e->max;
2469
2470        if (uinfo->value.enumerated.item > e->max - 1)
2471                uinfo->value.enumerated.item = e->max - 1;
2472        strcpy(uinfo->value.enumerated.name,
2473                e->texts[uinfo->value.enumerated.item]);
2474        return 0;
2475}
2476EXPORT_SYMBOL_GPL(snd_soc_info_enum_ext);
2477
2478/**
2479 * snd_soc_info_volsw_ext - external single mixer info callback
2480 * @kcontrol: mixer control
2481 * @uinfo: control element information
2482 *
2483 * Callback to provide information about a single external mixer control.
2484 *
2485 * Returns 0 for success.
2486 */
2487int snd_soc_info_volsw_ext(struct snd_kcontrol *kcontrol,
2488        struct snd_ctl_elem_info *uinfo)
2489{
2490        int max = kcontrol->private_value;
2491
2492        if (max == 1 && !strstr(kcontrol->id.name, " Volume"))
2493                uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2494        else
2495                uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2496
2497        uinfo->count = 1;
2498        uinfo->value.integer.min = 0;
2499        uinfo->value.integer.max = max;
2500        return 0;
2501}
2502EXPORT_SYMBOL_GPL(snd_soc_info_volsw_ext);
2503
2504/**
2505 * snd_soc_info_volsw - single mixer info callback
2506 * @kcontrol: mixer control
2507 * @uinfo: control element information
2508 *
2509 * Callback to provide information about a single mixer control.
2510 *
2511 * Returns 0 for success.
2512 */
2513int snd_soc_info_volsw(struct snd_kcontrol *kcontrol,
2514        struct snd_ctl_elem_info *uinfo)
2515{
2516        struct soc_mixer_control *mc =
2517                (struct soc_mixer_control *)kcontrol->private_value;
2518        int platform_max;
2519        unsigned int shift = mc->shift;
2520        unsigned int rshift = mc->rshift;
2521
2522        if (!mc->platform_max)
2523                mc->platform_max = mc->max;
2524        platform_max = mc->platform_max;
2525
2526        if (platform_max == 1 && !strstr(kcontrol->id.name, " Volume"))
2527                uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2528        else
2529                uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2530
2531        uinfo->count = shift == rshift ? 1 : 2;
2532        uinfo->value.integer.min = 0;
2533        uinfo->value.integer.max = platform_max;
2534        return 0;
2535}
2536EXPORT_SYMBOL_GPL(snd_soc_info_volsw);
2537
2538/**
2539 * snd_soc_get_volsw - single mixer get callback
2540 * @kcontrol: mixer control
2541 * @ucontrol: control element information
2542 *
2543 * Callback to get the value of a single mixer control.
2544 *
2545 * Returns 0 for success.
2546 */
2547int snd_soc_get_volsw(struct snd_kcontrol *kcontrol,
2548        struct snd_ctl_elem_value *ucontrol)
2549{
2550        struct soc_mixer_control *mc =
2551                (struct soc_mixer_control *)kcontrol->private_value;
2552        struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
2553        unsigned int reg = mc->reg;
2554        unsigned int shift = mc->shift;
2555        unsigned int rshift = mc->rshift;
2556        int max = mc->max;
2557        unsigned int mask = (1 << fls(max)) - 1;
2558        unsigned int invert = mc->invert;
2559
2560        ucontrol->value.integer.value[0] =
2561                (snd_soc_read(codec, reg) >> shift) & mask;
2562        if (shift != rshift)
2563                ucontrol->value.integer.value[1] =
2564                        (snd_soc_read(codec, reg) >> rshift) & mask;
2565        if (invert) {
2566                ucontrol->value.integer.value[0] =
2567                        max - ucontrol->value.integer.value[0];
2568                if (shift != rshift)
2569                        ucontrol->value.integer.value[1] =
2570                                max - ucontrol->value.integer.value[1];
2571        }
2572
2573        return 0;
2574}
2575EXPORT_SYMBOL_GPL(snd_soc_get_volsw);
2576
2577/**
2578 * snd_soc_put_volsw - single mixer put callback
2579 * @kcontrol: mixer control
2580 * @ucontrol: control element information
2581 *
2582 * Callback to set the value of a single mixer control.
2583 *
2584 * Returns 0 for success.
2585 */
2586int snd_soc_put_volsw(struct snd_kcontrol *kcontrol,
2587        struct snd_ctl_elem_value *ucontrol)
2588{
2589        struct soc_mixer_control *mc =
2590                (struct soc_mixer_control *)kcontrol->private_value;
2591        struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
2592        unsigned int reg = mc->reg;
2593        unsigned int shift = mc->shift;
2594        unsigned int rshift = mc->rshift;
2595        int max = mc->max;
2596        unsigned int mask = (1 << fls(max)) - 1;
2597        unsigned int invert = mc->invert;
2598        unsigned int val, val2, val_mask;
2599
2600        val = (ucontrol->value.integer.value[0] & mask);
2601        if (invert)
2602                val = max - val;
2603        val_mask = mask << shift;
2604        val = val << shift;
2605        if (shift != rshift) {
2606                val2 = (ucontrol->value.integer.value[1] & mask);
2607                if (invert)
2608                        val2 = max - val2;
2609                val_mask |= mask << rshift;
2610                val |= val2 << rshift;
2611        }
2612        return snd_soc_update_bits_locked(codec, reg, val_mask, val);
2613}
2614EXPORT_SYMBOL_GPL(snd_soc_put_volsw);
2615
2616/**
2617 * snd_soc_info_volsw_2r - double mixer info callback
2618 * @kcontrol: mixer control
2619 * @uinfo: control element information
2620 *
2621 * Callback to provide information about a double mixer control that
2622 * spans 2 codec registers.
2623 *
2624 * Returns 0 for success.
2625 */
2626int snd_soc_info_volsw_2r(struct snd_kcontrol *kcontrol,
2627        struct snd_ctl_elem_info *uinfo)
2628{
2629        struct soc_mixer_control *mc =
2630                (struct soc_mixer_control *)kcontrol->private_value;
2631        int platform_max;
2632
2633        if (!mc->platform_max)
2634                mc->platform_max = mc->max;
2635        platform_max = mc->platform_max;
2636
2637        if (platform_max == 1 && !strstr(kcontrol->id.name, " Volume"))
2638                uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2639        else
2640                uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2641
2642        uinfo->count = 2;
2643        uinfo->value.integer.min = 0;
2644        uinfo->value.integer.max = platform_max;
2645        return 0;
2646}
2647EXPORT_SYMBOL_GPL(snd_soc_info_volsw_2r);
2648
2649/**
2650 * snd_soc_get_volsw_2r - double mixer get callback
2651 * @kcontrol: mixer control
2652 * @ucontrol: control element information
2653 *
2654 * Callback to get the value of a double mixer control that spans 2 registers.
2655 *
2656 * Returns 0 for success.
2657 */
2658int snd_soc_get_volsw_2r(struct snd_kcontrol *kcontrol,
2659        struct snd_ctl_elem_value *ucontrol)
2660{
2661        struct soc_mixer_control *mc =
2662                (struct soc_mixer_control *)kcontrol->private_value;
2663        struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
2664        unsigned int reg = mc->reg;
2665        unsigned int reg2 = mc->rreg;
2666        unsigned int shift = mc->shift;
2667        int max = mc->max;
2668        unsigned int mask = (1 << fls(max)) - 1;
2669        unsigned int invert = mc->invert;
2670
2671        ucontrol->value.integer.value[0] =
2672                (snd_soc_read(codec, reg) >> shift) & mask;
2673        ucontrol->value.integer.value[1] =
2674                (snd_soc_read(codec, reg2) >> shift) & mask;
2675        if (invert) {
2676                ucontrol->value.integer.value[0] =
2677                        max - ucontrol->value.integer.value[0];
2678                ucontrol->value.integer.value[1] =
2679                        max - ucontrol->value.integer.value[1];
2680        }
2681
2682        return 0;
2683}
2684EXPORT_SYMBOL_GPL(snd_soc_get_volsw_2r);
2685
2686/**
2687 * snd_soc_put_volsw_2r - double mixer set callback
2688 * @kcontrol: mixer control
2689 * @ucontrol: control element information
2690 *
2691 * Callback to set the value of a double mixer control that spans 2 registers.
2692 *
2693 * Returns 0 for success.
2694 */
2695int snd_soc_put_volsw_2r(struct snd_kcontrol *kcontrol,
2696        struct snd_ctl_elem_value *ucontrol)
2697{
2698        struct soc_mixer_control *mc =
2699                (struct soc_mixer_control *)kcontrol->private_value;
2700        struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
2701        unsigned int reg = mc->reg;
2702        unsigned int reg2 = mc->rreg;
2703        unsigned int shift = mc->shift;
2704        int max = mc->max;
2705        unsigned int mask = (1 << fls(max)) - 1;
2706        unsigned int invert = mc->invert;
2707        int err;
2708        unsigned int val, val2, val_mask;
2709
2710        val_mask = mask << shift;
2711        val = (ucontrol->value.integer.value[0] & mask);
2712        val2 = (ucontrol->value.integer.value[1] & mask);
2713
2714        if (invert) {
2715                val = max - val;
2716                val2 = max - val2;
2717        }
2718
2719        val = val << shift;
2720        val2 = val2 << shift;
2721
2722        err = snd_soc_update_bits_locked(codec, reg, val_mask, val);
2723        if (err < 0)
2724                return err;
2725
2726        err = snd_soc_update_bits_locked(codec, reg2, val_mask, val2);
2727        return err;
2728}
2729EXPORT_SYMBOL_GPL(snd_soc_put_volsw_2r);
2730
2731/**
2732 * snd_soc_info_volsw_s8 - signed mixer info callback
2733 * @kcontrol: mixer control
2734 * @uinfo: control element information
2735 *
2736 * Callback to provide information about a signed mixer control.
2737 *
2738 * Returns 0 for success.
2739 */
2740int snd_soc_info_volsw_s8(struct snd_kcontrol *kcontrol,
2741        struct snd_ctl_elem_info *uinfo)
2742{
2743        struct soc_mixer_control *mc =
2744                (struct soc_mixer_control *)kcontrol->private_value;
2745        int platform_max;
2746        int min = mc->min;
2747
2748        if (!mc->platform_max)
2749                mc->platform_max = mc->max;
2750        platform_max = mc->platform_max;
2751
2752        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2753        uinfo->count = 2;
2754        uinfo->value.integer.min = 0;
2755        uinfo->value.integer.max = platform_max - min;
2756        return 0;
2757}
2758EXPORT_SYMBOL_GPL(snd_soc_info_volsw_s8);
2759
2760/**
2761 * snd_soc_get_volsw_s8 - signed mixer get callback
2762 * @kcontrol: mixer control
2763 * @ucontrol: control element information
2764 *
2765 * Callback to get the value of a signed mixer control.
2766 *
2767 * Returns 0 for success.
2768 */
2769int snd_soc_get_volsw_s8(struct snd_kcontrol *kcontrol,
2770        struct snd_ctl_elem_value *ucontrol)
2771{
2772        struct soc_mixer_control *mc =
2773                (struct soc_mixer_control *)kcontrol->private_value;
2774        struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
2775        unsigned int reg = mc->reg;
2776        int min = mc->min;
2777        int val = snd_soc_read(codec, reg);
2778
2779        ucontrol->value.integer.value[0] =
2780                ((signed char)(val & 0xff))-min;
2781        ucontrol->value.integer.value[1] =
2782                ((signed char)((val >> 8) & 0xff))-min;
2783        return 0;
2784}
2785EXPORT_SYMBOL_GPL(snd_soc_get_volsw_s8);
2786
2787/**
2788 * snd_soc_put_volsw_sgn - signed mixer put callback
2789 * @kcontrol: mixer control
2790 * @ucontrol: control element information
2791 *
2792 * Callback to set the value of a signed mixer control.
2793 *
2794 * Returns 0 for success.
2795 */
2796int snd_soc_put_volsw_s8(struct snd_kcontrol *kcontrol,
2797        struct snd_ctl_elem_value *ucontrol)
2798{
2799        struct soc_mixer_control *mc =
2800                (struct soc_mixer_control *)kcontrol->private_value;
2801        struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
2802        unsigned int reg = mc->reg;
2803        int min = mc->min;
2804        unsigned int val;
2805
2806        val = (ucontrol->value.integer.value[0]+min) & 0xff;
2807        val |= ((ucontrol->value.integer.value[1]+min) & 0xff) << 8;
2808
2809        return snd_soc_update_bits_locked(codec, reg, 0xffff, val);
2810}
2811EXPORT_SYMBOL_GPL(snd_soc_put_volsw_s8);
2812
2813/**
2814 * snd_soc_limit_volume - Set new limit to an existing volume control.
2815 *
2816 * @codec: where to look for the control
2817 * @name: Name of the control
2818 * @max: new maximum limit
2819 *
2820 * Return 0 for success, else error.
2821 */
2822int snd_soc_limit_volume(struct snd_soc_codec *codec,
2823        const char *name, int max)
2824{
2825        struct snd_card *card = codec->card->snd_card;
2826        struct snd_kcontrol *kctl;
2827        struct soc_mixer_control *mc;
2828        int found = 0;
2829        int ret = -EINVAL;
2830
2831        /* Sanity check for name and max */
2832        if (unlikely(!name || max <= 0))
2833                return -EINVAL;
2834
2835        list_for_each_entry(kctl, &card->controls, list) {
2836                if (!strncmp(kctl->id.name, name, sizeof(kctl->id.name))) {
2837                        found = 1;
2838                        break;
2839                }
2840        }
2841        if (found) {
2842                mc = (struct soc_mixer_control *)kctl->private_value;
2843                if (max <= mc->max) {
2844                        mc->platform_max = max;
2845                        ret = 0;
2846                }
2847        }
2848        return ret;
2849}
2850EXPORT_SYMBOL_GPL(snd_soc_limit_volume);
2851
2852/**
2853 * snd_soc_info_volsw_2r_sx - double with tlv and variable data size
2854 *  mixer info callback
2855 * @kcontrol: mixer control
2856 * @uinfo: control element information
2857 *
2858 * Returns 0 for success.
2859 */
2860int snd_soc_info_volsw_2r_sx(struct snd_kcontrol *kcontrol,
2861                        struct snd_ctl_elem_info *uinfo)
2862{
2863        struct soc_mixer_control *mc =
2864                (struct soc_mixer_control *)kcontrol->private_value;
2865        int max = mc->max;
2866        int min = mc->min;
2867
2868        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2869        uinfo->count = 2;
2870        uinfo->value.integer.min = 0;
2871        uinfo->value.integer.max = max-min;
2872
2873        return 0;
2874}
2875EXPORT_SYMBOL_GPL(snd_soc_info_volsw_2r_sx);
2876
2877/**
2878 * snd_soc_get_volsw_2r_sx - double with tlv and variable data size
2879 *  mixer get callback
2880 * @kcontrol: mixer control
2881 * @uinfo: control element information
2882 *
2883 * Returns 0 for success.
2884 */
2885int snd_soc_get_volsw_2r_sx(struct snd_kcontrol *kcontrol,
2886                        struct snd_ctl_elem_value *ucontrol)
2887{
2888        struct soc_mixer_control *mc =
2889                (struct soc_mixer_control *)kcontrol->private_value;
2890        struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
2891        unsigned int mask = (1<<mc->shift)-1;
2892        int min = mc->min;
2893        int val = snd_soc_read(codec, mc->reg) & mask;
2894        int valr = snd_soc_read(codec, mc->rreg) & mask;
2895
2896        ucontrol->value.integer.value[0] = ((val & 0xff)-min) & mask;
2897        ucontrol->value.integer.value[1] = ((valr & 0xff)-min) & mask;
2898        return 0;
2899}
2900EXPORT_SYMBOL_GPL(snd_soc_get_volsw_2r_sx);
2901
2902/**
2903 * snd_soc_put_volsw_2r_sx - double with tlv and variable data size
2904 *  mixer put callback
2905 * @kcontrol: mixer control
2906 * @uinfo: control element information
2907 *
2908 * Returns 0 for success.
2909 */
2910int snd_soc_put_volsw_2r_sx(struct snd_kcontrol *kcontrol,
2911                        struct snd_ctl_elem_value *ucontrol)
2912{
2913        struct soc_mixer_control *mc =
2914                (struct soc_mixer_control *)kcontrol->private_value;
2915        struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
2916        unsigned int mask = (1<<mc->shift)-1;
2917        int min = mc->min;
2918        int ret;
2919        unsigned int val, valr, oval, ovalr;
2920
2921        val = ((ucontrol->value.integer.value[0]+min) & 0xff);
2922        val &= mask;
2923        valr = ((ucontrol->value.integer.value[1]+min) & 0xff);
2924        valr &= mask;
2925
2926        oval = snd_soc_read(codec, mc->reg) & mask;
2927        ovalr = snd_soc_read(codec, mc->rreg) & mask;
2928
2929        ret = 0;
2930        if (oval != val) {
2931                ret = snd_soc_write(codec, mc->reg, val);
2932                if (ret < 0)
2933                        return ret;
2934        }
2935        if (ovalr != valr) {
2936                ret = snd_soc_write(codec, mc->rreg, valr);
2937                if (ret < 0)
2938                        return ret;
2939        }
2940
2941        return 0;
2942}
2943EXPORT_SYMBOL_GPL(snd_soc_put_volsw_2r_sx);
2944
2945/**
2946 * snd_soc_dai_set_sysclk - configure DAI system or master clock.
2947 * @dai: DAI
2948 * @clk_id: DAI specific clock ID
2949 * @freq: new clock frequency in Hz
2950 * @dir: new clock direction - input/output.
2951 *
2952 * Configures the DAI master (MCLK) or system (SYSCLK) clocking.
2953 */
2954int snd_soc_dai_set_sysclk(struct snd_soc_dai *dai, int clk_id,
2955        unsigned int freq, int dir)
2956{
2957        if (dai->driver && dai->driver->ops->set_sysclk)
2958                return dai->driver->ops->set_sysclk(dai, clk_id, freq, dir);
2959        else
2960                return -EINVAL;
2961}
2962EXPORT_SYMBOL_GPL(snd_soc_dai_set_sysclk);
2963
2964/**
2965 * snd_soc_dai_set_clkdiv - configure DAI clock dividers.
2966 * @dai: DAI
2967 * @div_id: DAI specific clock divider ID
2968 * @div: new clock divisor.
2969 *
2970 * Configures the clock dividers. This is used to derive the best DAI bit and
2971 * frame clocks from the system or master clock. It's best to set the DAI bit
2972 * and frame clocks as low as possible to save system power.
2973 */
2974int snd_soc_dai_set_clkdiv(struct snd_soc_dai *dai,
2975        int div_id, int div)
2976{
2977        if (dai->driver && dai->driver->ops->set_clkdiv)
2978                return dai->driver->ops->set_clkdiv(dai, div_id, div);
2979        else
2980                return -EINVAL;
2981}
2982EXPORT_SYMBOL_GPL(snd_soc_dai_set_clkdiv);
2983
2984/**
2985 * snd_soc_dai_set_pll - configure DAI PLL.
2986 * @dai: DAI
2987 * @pll_id: DAI specific PLL ID
2988 * @source: DAI specific source for the PLL
2989 * @freq_in: PLL input clock frequency in Hz
2990 * @freq_out: requested PLL output clock frequency in Hz
2991 *
2992 * Configures and enables PLL to generate output clock based on input clock.
2993 */
2994int snd_soc_dai_set_pll(struct snd_soc_dai *dai, int pll_id, int source,
2995        unsigned int freq_in, unsigned int freq_out)
2996{
2997        if (dai->driver && dai->driver->ops->set_pll)
2998                return dai->driver->ops->set_pll(dai, pll_id, source,
2999                                         freq_in, freq_out);
3000        else
3001                return -EINVAL;
3002}
3003EXPORT_SYMBOL_GPL(snd_soc_dai_set_pll);
3004
3005/**
3006 * snd_soc_dai_set_fmt - configure DAI hardware audio format.
3007 * @dai: DAI
3008 * @fmt: SND_SOC_DAIFMT_ format value.
3009 *
3010 * Configures the DAI hardware format and clocking.
3011 */
3012int snd_soc_dai_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)
3013{
3014        if (dai->driver && dai->driver->ops->set_fmt)
3015                return dai->driver->ops->set_fmt(dai, fmt);
3016        else
3017                return -EINVAL;
3018}
3019EXPORT_SYMBOL_GPL(snd_soc_dai_set_fmt);
3020
3021/**
3022 * snd_soc_dai_set_tdm_slot - configure DAI TDM.
3023 * @dai: DAI
3024 * @tx_mask: bitmask representing active TX slots.
3025 * @rx_mask: bitmask representing active RX slots.
3026 * @slots: Number of slots in use.
3027 * @slot_width: Width in bits for each slot.
3028 *
3029 * Configures a DAI for TDM operation. Both mask and slots are codec and DAI
3030 * specific.
3031 */
3032int snd_soc_dai_set_tdm_slot(struct snd_soc_dai *dai,
3033        unsigned int tx_mask, unsigned int rx_mask, int slots, int slot_width)
3034{
3035        if (dai->driver && dai->driver->ops->set_tdm_slot)
3036                return dai->driver->ops->set_tdm_slot(dai, tx_mask, rx_mask,
3037                                slots, slot_width);
3038        else
3039                return -EINVAL;
3040}
3041EXPORT_SYMBOL_GPL(snd_soc_dai_set_tdm_slot);
3042
3043/**
3044 * snd_soc_dai_set_channel_map - configure DAI audio channel map
3045 * @dai: DAI
3046 * @tx_num: how many TX channels
3047 * @tx_slot: pointer to an array which imply the TX slot number channel
3048 *           0~num-1 uses
3049 * @rx_num: how many RX channels
3050 * @rx_slot: pointer to an array which imply the RX slot number channel
3051 *           0~num-1 uses
3052 *
3053 * configure the relationship between channel number and TDM slot number.
3054 */
3055int snd_soc_dai_set_channel_map(struct snd_soc_dai *dai,
3056        unsigned int tx_num, unsigned int *tx_slot,
3057        unsigned int rx_num, unsigned int *rx_slot)
3058{
3059        if (dai->driver && dai->driver->ops->set_channel_map)
3060                return dai->driver->ops->set_channel_map(dai, tx_num, tx_slot,
3061                        rx_num, rx_slot);
3062        else
3063                return -EINVAL;
3064}
3065EXPORT_SYMBOL_GPL(snd_soc_dai_set_channel_map);
3066
3067/**
3068 * snd_soc_dai_set_tristate - configure DAI system or master clock.
3069 * @dai: DAI
3070 * @tristate: tristate enable
3071 *
3072 * Tristates the DAI so that others can use it.
3073 */
3074int snd_soc_dai_set_tristate(struct snd_soc_dai *dai, int tristate)
3075{
3076        if (dai->driver && dai->driver->ops->set_tristate)
3077                return dai->driver->ops->set_tristate(dai, tristate);
3078        else
3079                return -EINVAL;
3080}
3081EXPORT_SYMBOL_GPL(snd_soc_dai_set_tristate);
3082
3083/**
3084 * snd_soc_dai_digital_mute - configure DAI system or master clock.
3085 * @dai: DAI
3086 * @mute: mute enable
3087 *
3088 * Mutes the DAI DAC.
3089 */
3090int snd_soc_dai_digital_mute(struct snd_soc_dai *dai, int mute)
3091{
3092        if (dai->driver && dai->driver->ops->digital_mute)
3093                return dai->driver->ops->digital_mute(dai, mute);
3094        else
3095                return -EINVAL;
3096}
3097EXPORT_SYMBOL_GPL(snd_soc_dai_digital_mute);
3098
3099/**
3100 * snd_soc_register_card - Register a card with the ASoC core
3101 *
3102 * @card: Card to register
3103 *
3104 * Note that currently this is an internal only function: it will be
3105 * exposed to machine drivers after further backporting of ASoC v2
3106 * registration APIs.
3107 */
3108static int snd_soc_register_card(struct snd_soc_card *card)
3109{
3110        int i;
3111
3112        if (!card->name || !card->dev)
3113                return -EINVAL;
3114
3115        card->rtd = kzalloc(sizeof(struct snd_soc_pcm_runtime) *
3116                            (card->num_links + card->num_aux_devs),
3117                            GFP_KERNEL);
3118        if (card->rtd == NULL)
3119                return -ENOMEM;
3120        card->rtd_aux = &card->rtd[card->num_links];
3121
3122        for (i = 0; i < card->num_links; i++)
3123                card->rtd[i].dai_link = &card->dai_link[i];
3124
3125        INIT_LIST_HEAD(&card->list);
3126        card->instantiated = 0;
3127        mutex_init(&card->mutex);
3128
3129        mutex_lock(&client_mutex);
3130        list_add(&card->list, &card_list);
3131        snd_soc_instantiate_cards();
3132        mutex_unlock(&client_mutex);
3133
3134        dev_dbg(card->dev, "Registered card '%s'\n", card->name);
3135
3136        return 0;
3137}
3138
3139/**
3140 * snd_soc_unregister_card - Unregister a card with the ASoC core
3141 *
3142 * @card: Card to unregister
3143 *
3144 * Note that currently this is an internal only function: it will be
3145 * exposed to machine drivers after further backporting of ASoC v2
3146 * registration APIs.
3147 */
3148static int snd_soc_unregister_card(struct snd_soc_card *card)
3149{
3150        mutex_lock(&client_mutex);
3151        list_del(&card->list);
3152        mutex_unlock(&client_mutex);
3153        dev_dbg(card->dev, "Unregistered card '%s'\n", card->name);
3154
3155        return 0;
3156}
3157
3158/*
3159 * Simplify DAI link configuration by removing ".-1" from device names
3160 * and sanitizing names.
3161 */
3162static char *fmt_single_name(struct device *dev, int *id)
3163{
3164        char *found, name[NAME_SIZE];
3165        int id1, id2;
3166
3167        if (dev_name(dev) == NULL)
3168                return NULL;
3169
3170        strlcpy(name, dev_name(dev), NAME_SIZE);
3171
3172        /* are we a "%s.%d" name (platform and SPI components) */
3173        found = strstr(name, dev->driver->name);
3174        if (found) {
3175                /* get ID */
3176                if (sscanf(&found[strlen(dev->driver->name)], ".%d", id) == 1) {
3177
3178                        /* discard ID from name if ID == -1 */
3179                        if (*id == -1)
3180                                found[strlen(dev->driver->name)] = '\0';
3181                }
3182
3183        } else {
3184                /* I2C component devices are named "bus-addr"  */
3185                if (sscanf(name, "%x-%x", &id1, &id2) == 2) {
3186                        char tmp[NAME_SIZE];
3187
3188                        /* create unique ID number from I2C addr and bus */
3189                        *id = ((id1 & 0xffff) << 16) + id2;
3190
3191                        /* sanitize component name for DAI link creation */
3192                        snprintf(tmp, NAME_SIZE, "%s.%s", dev->driver->name, name);
3193                        strlcpy(name, tmp, NAME_SIZE);
3194                } else
3195                        *id = 0;
3196        }
3197
3198        return kstrdup(name, GFP_KERNEL);
3199}
3200
3201/*
3202 * Simplify DAI link naming for single devices with multiple DAIs by removing
3203 * any ".-1" and using the DAI name (instead of device name).
3204 */
3205static inline char *fmt_multiple_name(struct device *dev,
3206                struct snd_soc_dai_driver *dai_drv)
3207{
3208        if (dai_drv->name == NULL) {
3209                printk(KERN_ERR "asoc: error - multiple DAI %s registered with no name\n",
3210                                dev_name(dev));
3211                return NULL;
3212        }
3213
3214        return kstrdup(dai_drv->name, GFP_KERNEL);
3215}
3216
3217/**
3218 * snd_soc_register_dai - Register a DAI with the ASoC core
3219 *
3220 * @dai: DAI to register
3221 */
3222int snd_soc_register_dai(struct device *dev,
3223                struct snd_soc_dai_driver *dai_drv)
3224{
3225        struct snd_soc_dai *dai;
3226
3227        dev_dbg(dev, "dai register %s\n", dev_name(dev));
3228
3229        dai = kzalloc(sizeof(struct snd_soc_dai), GFP_KERNEL);
3230        if (dai == NULL)
3231                        return -ENOMEM;
3232
3233        /* create DAI component name */
3234        dai->name = fmt_single_name(dev, &dai->id);
3235        if (dai->name == NULL) {
3236                kfree(dai);
3237                return -ENOMEM;
3238        }
3239
3240        dai->dev = dev;
3241        dai->driver = dai_drv;
3242        if (!dai->driver->ops)
3243                dai->driver->ops = &null_dai_ops;
3244
3245        mutex_lock(&client_mutex);
3246        list_add(&dai->list, &dai_list);
3247        snd_soc_instantiate_cards();
3248        mutex_unlock(&client_mutex);
3249
3250        pr_debug("Registered DAI '%s'\n", dai->name);
3251
3252        return 0;
3253}
3254EXPORT_SYMBOL_GPL(snd_soc_register_dai);
3255
3256/**
3257 * snd_soc_unregister_dai - Unregister a DAI from the ASoC core
3258 *
3259 * @dai: DAI to unregister
3260 */
3261void snd_soc_unregister_dai(struct device *dev)
3262{
3263        struct snd_soc_dai *dai;
3264
3265        list_for_each_entry(dai, &dai_list, list) {
3266                if (dev == dai->dev)
3267                        goto found;
3268        }
3269        return;
3270
3271found:
3272        mutex_lock(&client_mutex);
3273        list_del(&dai->list);
3274        mutex_unlock(&client_mutex);
3275
3276        pr_debug("Unregistered DAI '%s'\n", dai->name);
3277        kfree(dai->name);
3278        kfree(dai);
3279}
3280EXPORT_SYMBOL_GPL(snd_soc_unregister_dai);
3281
3282/**
3283 * snd_soc_register_dais - Register multiple DAIs with the ASoC core
3284 *
3285 * @dai: Array of DAIs to register
3286 * @count: Number of DAIs
3287 */
3288int snd_soc_register_dais(struct device *dev,
3289                struct snd_soc_dai_driver *dai_drv, size_t count)
3290{
3291        struct snd_soc_dai *dai;
3292        int i, ret = 0;
3293
3294        dev_dbg(dev, "dai register %s #%Zu\n", dev_name(dev), count);
3295
3296        for (i = 0; i < count; i++) {
3297
3298                dai = kzalloc(sizeof(struct snd_soc_dai), GFP_KERNEL);
3299                if (dai == NULL) {
3300                        ret = -ENOMEM;
3301                        goto err;
3302                }
3303
3304                /* create DAI component name */
3305                dai->name = fmt_multiple_name(dev, &dai_drv[i]);
3306                if (dai->name == NULL) {
3307                        kfree(dai);
3308                        ret = -EINVAL;
3309                        goto err;
3310                }
3311
3312                dai->dev = dev;
3313                dai->driver = &dai_drv[i];
3314                if (dai->driver->id)
3315                        dai->id = dai->driver->id;
3316                else
3317                        dai->id = i;
3318                if (!dai->driver->ops)
3319                        dai->driver->ops = &null_dai_ops;
3320
3321                mutex_lock(&client_mutex);
3322                list_add(&dai->list, &dai_list);
3323                mutex_unlock(&client_mutex);
3324
3325                pr_debug("Registered DAI '%s'\n", dai->name);
3326        }
3327
3328        mutex_lock(&client_mutex);
3329        snd_soc_instantiate_cards();
3330        mutex_unlock(&client_mutex);
3331        return 0;
3332
3333err:
3334        for (i--; i >= 0; i--)
3335                snd_soc_unregister_dai(dev);
3336
3337        return ret;
3338}
3339EXPORT_SYMBOL_GPL(snd_soc_register_dais);
3340
3341/**
3342 * snd_soc_unregister_dais - Unregister multiple DAIs from the ASoC core
3343 *
3344 * @dai: Array of DAIs to unregister
3345 * @count: Number of DAIs
3346 */
3347void snd_soc_unregister_dais(struct device *dev, size_t count)
3348{
3349        int i;
3350
3351        for (i = 0; i < count; i++)
3352                snd_soc_unregister_dai(dev);
3353}
3354EXPORT_SYMBOL_GPL(snd_soc_unregister_dais);
3355
3356/**
3357 * snd_soc_register_platform - Register a platform with the ASoC core
3358 *
3359 * @platform: platform to register
3360 */
3361int snd_soc_register_platform(struct device *dev,
3362                struct snd_soc_platform_driver *platform_drv)
3363{
3364        struct snd_soc_platform *platform;
3365
3366        dev_dbg(dev, "platform register %s\n", dev_name(dev));
3367
3368        platform = kzalloc(sizeof(struct snd_soc_platform), GFP_KERNEL);
3369        if (platform == NULL)
3370                        return -ENOMEM;
3371
3372        /* create platform component name */
3373        platform->name = fmt_single_name(dev, &platform->id);
3374        if (platform->name == NULL) {
3375                kfree(platform);
3376                return -ENOMEM;
3377        }
3378
3379        platform->dev = dev;
3380        platform->driver = platform_drv;
3381
3382        mutex_lock(&client_mutex);
3383        list_add(&platform->list, &platform_list);
3384        snd_soc_instantiate_cards();
3385        mutex_unlock(&client_mutex);
3386
3387        pr_debug("Registered platform '%s'\n", platform->name);
3388
3389        return 0;
3390}
3391EXPORT_SYMBOL_GPL(snd_soc_register_platform);
3392
3393/**
3394 * snd_soc_unregister_platform - Unregister a platform from the ASoC core
3395 *
3396 * @platform: platform to unregister
3397 */
3398void snd_soc_unregister_platform(struct device *dev)
3399{
3400        struct snd_soc_platform *platform;
3401
3402        list_for_each_entry(platform, &platform_list, list) {
3403                if (dev == platform->dev)
3404                        goto found;
3405        }
3406        return;
3407
3408found:
3409        mutex_lock(&client_mutex);
3410        list_del(&platform->list);
3411        mutex_unlock(&client_mutex);
3412
3413        pr_debug("Unregistered platform '%s'\n", platform->name);
3414        kfree(platform->name);
3415        kfree(platform);
3416}
3417EXPORT_SYMBOL_GPL(snd_soc_unregister_platform);
3418
3419static u64 codec_format_map[] = {
3420        SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S16_BE,
3421        SNDRV_PCM_FMTBIT_U16_LE | SNDRV_PCM_FMTBIT_U16_BE,
3422        SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S24_BE,
3423        SNDRV_PCM_FMTBIT_U24_LE | SNDRV_PCM_FMTBIT_U24_BE,
3424        SNDRV_PCM_FMTBIT_S32_LE | SNDRV_PCM_FMTBIT_S32_BE,
3425        SNDRV_PCM_FMTBIT_U32_LE | SNDRV_PCM_FMTBIT_U32_BE,
3426        SNDRV_PCM_FMTBIT_S24_3LE | SNDRV_PCM_FMTBIT_U24_3BE,
3427        SNDRV_PCM_FMTBIT_U24_3LE | SNDRV_PCM_FMTBIT_U24_3BE,
3428        SNDRV_PCM_FMTBIT_S20_3LE | SNDRV_PCM_FMTBIT_S20_3BE,
3429        SNDRV_PCM_FMTBIT_U20_3LE | SNDRV_PCM_FMTBIT_U20_3BE,
3430        SNDRV_PCM_FMTBIT_S18_3LE | SNDRV_PCM_FMTBIT_S18_3BE,
3431        SNDRV_PCM_FMTBIT_U18_3LE | SNDRV_PCM_FMTBIT_U18_3BE,
3432        SNDRV_PCM_FMTBIT_FLOAT_LE | SNDRV_PCM_FMTBIT_FLOAT_BE,
3433        SNDRV_PCM_FMTBIT_FLOAT64_LE | SNDRV_PCM_FMTBIT_FLOAT64_BE,
3434        SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE
3435        | SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_BE,
3436};
3437
3438/* Fix up the DAI formats for endianness: codecs don't actually see
3439 * the endianness of the data but we're using the CPU format
3440 * definitions which do need to include endianness so we ensure that
3441 * codec DAIs always have both big and little endian variants set.
3442 */
3443static void fixup_codec_formats(struct snd_soc_pcm_stream *stream)
3444{
3445        int i;
3446
3447        for (i = 0; i < ARRAY_SIZE(codec_format_map); i++)
3448                if (stream->formats & codec_format_map[i])
3449                        stream->formats |= codec_format_map[i];
3450}
3451
3452/**
3453 * snd_soc_register_codec - Register a codec with the ASoC core
3454 *
3455 * @codec: codec to register
3456 */
3457int snd_soc_register_codec(struct device *dev,
3458                           const struct snd_soc_codec_driver *codec_drv,
3459                           struct snd_soc_dai_driver *dai_drv,
3460                           int num_dai)
3461{
3462        size_t reg_size;
3463        struct snd_soc_codec *codec;
3464        int ret, i;
3465
3466        dev_dbg(dev, "codec register %s\n", dev_name(dev));
3467
3468        codec = kzalloc(sizeof(struct snd_soc_codec), GFP_KERNEL);
3469        if (codec == NULL)
3470                return -ENOMEM;
3471
3472        /* create CODEC component name */
3473        codec->name = fmt_single_name(dev, &codec->id);
3474        if (codec->name == NULL) {
3475                kfree(codec);
3476                return -ENOMEM;
3477        }
3478
3479        if (codec_drv->compress_type)
3480                codec->compress_type = codec_drv->compress_type;
3481        else
3482                codec->compress_type = SND_SOC_FLAT_COMPRESSION;
3483
3484        codec->write = codec_drv->write;
3485        codec->read = codec_drv->read;
3486        codec->dapm.bias_level = SND_SOC_BIAS_OFF;
3487        codec->dapm.dev = dev;
3488        codec->dapm.codec = codec;
3489        codec->dev = dev;
3490        codec->driver = codec_drv;
3491        codec->num_dai = num_dai;
3492        mutex_init(&codec->mutex);
3493
3494        /* allocate CODEC register cache */
3495        if (codec_drv->reg_cache_size && codec_drv->reg_word_size) {
3496                reg_size = codec_drv->reg_cache_size * codec_drv->reg_word_size;
3497                /* it is necessary to make a copy of the default register cache
3498                 * because in the case of using a compression type that requires
3499                 * the default register cache to be marked as __devinitconst the
3500                 * kernel might have freed the array by the time we initialize
3501                 * the cache.
3502                 */
3503                codec->reg_def_copy = kmemdup(codec_drv->reg_cache_default,
3504                                              reg_size, GFP_KERNEL);
3505                if (!codec->reg_def_copy) {
3506                        ret = -ENOMEM;
3507                        goto fail;
3508                }
3509        }
3510
3511        for (i = 0; i < num_dai; i++) {
3512                fixup_codec_formats(&dai_drv[i].playback);
3513                fixup_codec_formats(&dai_drv[i].capture);
3514        }
3515
3516        /* register any DAIs */
3517        if (num_dai) {
3518                ret = snd_soc_register_dais(dev, dai_drv, num_dai);
3519                if (ret < 0)
3520                        goto fail;
3521        }
3522
3523        mutex_lock(&client_mutex);
3524        list_add(&codec->list, &codec_list);
3525        snd_soc_instantiate_cards();
3526        mutex_unlock(&client_mutex);
3527
3528        pr_debug("Registered codec '%s'\n", codec->name);
3529        return 0;
3530
3531fail:
3532        kfree(codec->reg_def_copy);
3533        codec->reg_def_copy = NULL;
3534        kfree(codec->name);
3535        kfree(codec);
3536        return ret;
3537}
3538EXPORT_SYMBOL_GPL(snd_soc_register_codec);
3539
3540/**
3541 * snd_soc_unregister_codec - Unregister a codec from the ASoC core
3542 *
3543 * @codec: codec to unregister
3544 */
3545void snd_soc_unregister_codec(struct device *dev)
3546{
3547        struct snd_soc_codec *codec;
3548        int i;
3549
3550        list_for_each_entry(codec, &codec_list, list) {
3551                if (dev == codec->dev)
3552                        goto found;
3553        }
3554        return;
3555
3556found:
3557        if (codec->num_dai)
3558                for (i = 0; i < codec->num_dai; i++)
3559                        snd_soc_unregister_dai(dev);
3560
3561        mutex_lock(&client_mutex);
3562        list_del(&codec->list);
3563        mutex_unlock(&client_mutex);
3564
3565        pr_debug("Unregistered codec '%s'\n", codec->name);
3566
3567        snd_soc_cache_exit(codec);
3568        kfree(codec->reg_def_copy);
3569        kfree(codec->name);
3570        kfree(codec);
3571}
3572EXPORT_SYMBOL_GPL(snd_soc_unregister_codec);
3573
3574static int __init snd_soc_init(void)
3575{
3576#ifdef CONFIG_DEBUG_FS
3577        debugfs_root = debugfs_create_dir("asoc", NULL);
3578        if (IS_ERR(debugfs_root) || !debugfs_root) {
3579                printk(KERN_WARNING
3580                       "ASoC: Failed to create debugfs directory\n");
3581                debugfs_root = NULL;
3582        }
3583
3584        if (!debugfs_create_file("codecs", 0444, debugfs_root, NULL,
3585                                 &codec_list_fops))
3586                pr_warn("ASoC: Failed to create CODEC list debugfs file\n");
3587
3588        if (!debugfs_create_file("dais", 0444, debugfs_root, NULL,
3589                                 &dai_list_fops))
3590                pr_warn("ASoC: Failed to create DAI list debugfs file\n");
3591
3592        if (!debugfs_create_file("platforms", 0444, debugfs_root, NULL,
3593                                 &platform_list_fops))
3594                pr_warn("ASoC: Failed to create platform list debugfs file\n");
3595#endif
3596
3597        return platform_driver_register(&soc_driver);
3598}
3599module_init(snd_soc_init);
3600
3601static void __exit snd_soc_exit(void)
3602{
3603#ifdef CONFIG_DEBUG_FS
3604        debugfs_remove_recursive(debugfs_root);
3605#endif
3606        platform_driver_unregister(&soc_driver);
3607}
3608module_exit(snd_soc_exit);
3609
3610/* Module information */
3611MODULE_AUTHOR("Liam Girdwood, lrg@slimlogic.co.uk");
3612MODULE_DESCRIPTION("ALSA SoC Core");
3613MODULE_LICENSE("GPL");
3614MODULE_ALIAS("platform:soc-audio");
3615