/*
   * soc-core.c  --  ALSA SoC Audio Layer
   *
   * Copyright 2005 Wolfson Microelectronics PLC.

   * Copyright 2005 Openedhand Ltd.

   * Copyright (C) 2010 Slimlogic Ltd.
   * Copyright (C) 2010 Texas Instruments Inc.

   *

   * Author: Liam Girdwood <lrg@slimlogic.co.uk>

   *         with code, comments and ideas from :-
   *         Richard Purdie <richard@openedhand.com>

   *
   *  This program is free software; you can redistribute  it and/or modify it
   *  under  the terms of  the GNU General  Public License as published by the
   *  Free Software Foundation;  either version 2 of the  License, or (at your
   *  option) any later version.
   *

   *  TODO:
   *   o Add hw rules to enforce rates, etc.
   *   o More testing with other codecs/machines.
   *   o Add more codecs and platforms to ensure good API coverage.
   *   o Support TDM on PCM and I2S
   */
  
  #include <linux/module.h>
  #include <linux/moduleparam.h>
  #include <linux/init.h>
  #include <linux/delay.h>
  #include <linux/pm.h>
  #include <linux/bitops.h>

  #include <linux/debugfs.h>

  #include <linux/platform_device.h>

  #include <linux/slab.h>

  #include <sound/ac97_codec.h>

  #include <sound/core.h>

  #include <sound/jack.h>

  #include <sound/pcm.h>
  #include <sound/pcm_params.h>
  #include <sound/soc.h>

  #include <sound/initval.h>

  #define CREATE_TRACE_POINTS
  #include <trace/events/asoc.h>

  #define NAME_SIZE	32

  static DECLARE_WAIT_QUEUE_HEAD(soc_pm_waitq);

  #ifdef CONFIG_DEBUG_FS

  struct dentry *snd_soc_debugfs_root;
  EXPORT_SYMBOL_GPL(snd_soc_debugfs_root);

  #endif

  static DEFINE_MUTEX(client_mutex);
  static LIST_HEAD(card_list);

  static LIST_HEAD(dai_list);

  static LIST_HEAD(platform_list);

  static LIST_HEAD(codec_list);

  int soc_new_pcm(struct snd_soc_pcm_runtime *rtd, int num);

  /*
   * This is a timeout to do a DAPM powerdown after a stream is closed().
   * It can be used to eliminate pops between different playback streams, e.g.
   * between two audio tracks.
   */
  static int pmdown_time = 5000;
  module_param(pmdown_time, int, 0);
  MODULE_PARM_DESC(pmdown_time, "DAPM stream powerdown time (msecs)");

  /* returns the minimum number of bytes needed to represent
   * a particular given value */
  static int min_bytes_needed(unsigned long val)
  {
  	int c = 0;
  	int i;
  
  	for (i = (sizeof val * 8) - 1; i >= 0; --i, ++c)
  		if (val & (1UL << i))
  			break;
  	c = (sizeof val * 8) - c;
  	if (!c || (c % 8))
  		c = (c + 8) / 8;
  	else
  		c /= 8;
  	return c;
  }

  /* fill buf which is 'len' bytes with a formatted
   * string of the form 'reg: value
  ' */
  static int format_register_str(struct snd_soc_codec *codec,
  			       unsigned int reg, char *buf, size_t len)
  {

  	int wordsize = min_bytes_needed(codec->driver->reg_cache_size) * 2;
  	int regsize = codec->driver->reg_word_size * 2;

  	int ret;
  	char tmpbuf[len + 1];
  	char regbuf[regsize + 1];
  
  	/* since tmpbuf is allocated on the stack, warn the callers if they
  	 * try to abuse this function */
  	WARN_ON(len > 63);
  
  	/* +2 for ': ' and + 1 for '
  ' */
  	if (wordsize + regsize + 2 + 1 != len)
  		return -EINVAL;
  
  	ret = snd_soc_read(codec , reg);
  	if (ret < 0) {
  		memset(regbuf, 'X', regsize);
  		regbuf[regsize] = '\0';
  	} else {
  		snprintf(regbuf, regsize + 1, "%.*x", regsize, ret);
  	}
  
  	/* prepare the buffer */
  	snprintf(tmpbuf, len + 1, "%.*x: %s
  ", wordsize, reg, regbuf);
  	/* copy it back to the caller without the '\0' */
  	memcpy(buf, tmpbuf, len);
  
  	return 0;
  }

  /* codec register dump */

  static ssize_t soc_codec_reg_show(struct snd_soc_codec *codec, char *buf,
  				  size_t count, loff_t pos)

  {

  	int i, step = 1;

  	int wordsize, regsize;

  	int len;
  	size_t total = 0;
  	loff_t p = 0;

  	wordsize = min_bytes_needed(codec->driver->reg_cache_size) * 2;
  	regsize = codec->driver->reg_word_size * 2;

  	len = wordsize + regsize + 2 + 1;

  	if (!codec->driver->reg_cache_size)

  		return 0;

  	if (codec->driver->reg_cache_step)
  		step = codec->driver->reg_cache_step;

  	for (i = 0; i < codec->driver->reg_cache_size; i += step) {

  		if (codec->readable_register && !codec->readable_register(codec, i))

  			continue;

  		if (codec->driver->display_register) {
  			count += codec->driver->display_register(codec, buf + count,

  							 PAGE_SIZE - count, i);

  		} else {

  			/* only support larger than PAGE_SIZE bytes debugfs
  			 * entries for the default case */
  			if (p >= pos) {
  				if (total + len >= count - 1)
  					break;
  				format_register_str(codec, i, buf + total, len);
  				total += len;
  			}
  			p += len;

  		}

  	}

  	total = min(total, count - 1);

  	return total;

  }

  static ssize_t codec_reg_show(struct device *dev,
  	struct device_attribute *attr, char *buf)
  {

  	struct snd_soc_pcm_runtime *rtd =
  			container_of(dev, struct snd_soc_pcm_runtime, dev);

  	return soc_codec_reg_show(rtd->codec, buf, PAGE_SIZE, 0);

  }
  
  static DEVICE_ATTR(codec_reg, 0444, codec_reg_show, NULL);

  static ssize_t pmdown_time_show(struct device *dev,
  				struct device_attribute *attr, char *buf)
  {

  	struct snd_soc_pcm_runtime *rtd =
  			container_of(dev, struct snd_soc_pcm_runtime, dev);

  	return sprintf(buf, "%ld
  ", rtd->pmdown_time);

  }
  
  static ssize_t pmdown_time_set(struct device *dev,
  			       struct device_attribute *attr,
  			       const char *buf, size_t count)
  {

  	struct snd_soc_pcm_runtime *rtd =
  			container_of(dev, struct snd_soc_pcm_runtime, dev);

  	int ret;

  	ret = strict_strtol(buf, 10, &rtd->pmdown_time);
  	if (ret)
  		return ret;

  
  	return count;
  }
  
  static DEVICE_ATTR(pmdown_time, 0644, pmdown_time_show, pmdown_time_set);

  #ifdef CONFIG_DEBUG_FS
  static int codec_reg_open_file(struct inode *inode, struct file *file)
  {
  	file->private_data = inode->i_private;
  	return 0;
  }
  
  static ssize_t codec_reg_read_file(struct file *file, char __user *user_buf,

  				   size_t count, loff_t *ppos)

  {
  	ssize_t ret;
  	struct snd_soc_codec *codec = file->private_data;

  	char *buf;
  
  	if (*ppos < 0 || !count)
  		return -EINVAL;
  
  	buf = kmalloc(count, GFP_KERNEL);

  	if (!buf)
  		return -ENOMEM;

  
  	ret = soc_codec_reg_show(codec, buf, count, *ppos);
  	if (ret >= 0) {
  		if (copy_to_user(user_buf, buf, ret)) {
  			kfree(buf);
  			return -EFAULT;
  		}
  		*ppos += ret;
  	}

  	kfree(buf);
  	return ret;
  }
  
  static ssize_t codec_reg_write_file(struct file *file,
  		const char __user *user_buf, size_t count, loff_t *ppos)
  {
  	char buf[32];

  	size_t buf_size;

  	char *start = buf;
  	unsigned long reg, value;
  	int step = 1;
  	struct snd_soc_codec *codec = file->private_data;
  
  	buf_size = min(count, (sizeof(buf)-1));
  	if (copy_from_user(buf, user_buf, buf_size))
  		return -EFAULT;
  	buf[buf_size] = 0;

  	if (codec->driver->reg_cache_step)
  		step = codec->driver->reg_cache_step;

  
  	while (*start == ' ')
  		start++;
  	reg = simple_strtoul(start, &start, 16);

  	while (*start == ' ')
  		start++;
  	if (strict_strtoul(start, 16, &value))
  		return -EINVAL;

  
  	/* Userspace has been fiddling around behind the kernel's back */
  	add_taint(TAINT_USER);

  	snd_soc_write(codec, reg, value);

  	return buf_size;
  }
  
  static const struct file_operations codec_reg_fops = {
  	.open = codec_reg_open_file,
  	.read = codec_reg_read_file,
  	.write = codec_reg_write_file,

  	.llseek = default_llseek,

  };
  
  static void soc_init_codec_debugfs(struct snd_soc_codec *codec)
  {

  	struct dentry *debugfs_card_root = codec->card->debugfs_card_root;
  
  	codec->debugfs_codec_root = debugfs_create_dir(codec->name,
  						       debugfs_card_root);

  	if (!codec->debugfs_codec_root) {
  		printk(KERN_WARNING
  		       "ASoC: Failed to create codec debugfs directory
  ");
  		return;
  	}

  	debugfs_create_bool("cache_sync", 0444, codec->debugfs_codec_root,
  			    &codec->cache_sync);
  	debugfs_create_bool("cache_only", 0444, codec->debugfs_codec_root,
  			    &codec->cache_only);

  	codec->debugfs_reg = debugfs_create_file("codec_reg", 0644,
  						 codec->debugfs_codec_root,
  						 codec, &codec_reg_fops);
  	if (!codec->debugfs_reg)
  		printk(KERN_WARNING
  		       "ASoC: Failed to create codec register debugfs file
  ");

  	snd_soc_dapm_debugfs_init(&codec->dapm, codec->debugfs_codec_root);

  }
  
  static void soc_cleanup_codec_debugfs(struct snd_soc_codec *codec)
  {
  	debugfs_remove_recursive(codec->debugfs_codec_root);
  }

  static ssize_t codec_list_read_file(struct file *file, char __user *user_buf,
  				    size_t count, loff_t *ppos)
  {
  	char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL);

  	ssize_t len, ret = 0;

  	struct snd_soc_codec *codec;
  
  	if (!buf)
  		return -ENOMEM;

  	list_for_each_entry(codec, &codec_list, list) {
  		len = snprintf(buf + ret, PAGE_SIZE - ret, "%s
  ",
  			       codec->name);
  		if (len >= 0)
  			ret += len;
  		if (ret > PAGE_SIZE) {
  			ret = PAGE_SIZE;
  			break;
  		}
  	}

  
  	if (ret >= 0)
  		ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
  
  	kfree(buf);
  
  	return ret;
  }
  
  static const struct file_operations codec_list_fops = {
  	.read = codec_list_read_file,
  	.llseek = default_llseek,/* read accesses f_pos */
  };

  static ssize_t dai_list_read_file(struct file *file, char __user *user_buf,
  				  size_t count, loff_t *ppos)
  {
  	char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL);

  	ssize_t len, ret = 0;

  	struct snd_soc_dai *dai;
  
  	if (!buf)
  		return -ENOMEM;

  	list_for_each_entry(dai, &dai_list, list) {
  		len = snprintf(buf + ret, PAGE_SIZE - ret, "%s
  ", dai->name);
  		if (len >= 0)
  			ret += len;
  		if (ret > PAGE_SIZE) {
  			ret = PAGE_SIZE;
  			break;
  		}
  	}

  	ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);

  
  	kfree(buf);
  
  	return ret;
  }
  
  static const struct file_operations dai_list_fops = {
  	.read = dai_list_read_file,
  	.llseek = default_llseek,/* read accesses f_pos */
  };

  static ssize_t platform_list_read_file(struct file *file,
  				       char __user *user_buf,
  				       size_t count, loff_t *ppos)
  {
  	char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL);

  	ssize_t len, ret = 0;

  	struct snd_soc_platform *platform;
  
  	if (!buf)
  		return -ENOMEM;

  	list_for_each_entry(platform, &platform_list, list) {
  		len = snprintf(buf + ret, PAGE_SIZE - ret, "%s
  ",
  			       platform->name);
  		if (len >= 0)
  			ret += len;
  		if (ret > PAGE_SIZE) {
  			ret = PAGE_SIZE;
  			break;
  		}
  	}

  	ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);

  
  	kfree(buf);
  
  	return ret;
  }
  
  static const struct file_operations platform_list_fops = {
  	.read = platform_list_read_file,
  	.llseek = default_llseek,/* read accesses f_pos */
  };

  static void soc_init_card_debugfs(struct snd_soc_card *card)
  {
  	card->debugfs_card_root = debugfs_create_dir(card->name,

  						     snd_soc_debugfs_root);

  	if (!card->debugfs_card_root) {

  		dev_warn(card->dev,
  			 "ASoC: Failed to create codec debugfs directory
  ");

  		return;
  	}
  
  	card->debugfs_pop_time = debugfs_create_u32("dapm_pop_time", 0644,
  						    card->debugfs_card_root,
  						    &card->pop_time);
  	if (!card->debugfs_pop_time)
  		dev_warn(card->dev,
  		       "Failed to create pop time debugfs file
  ");

  }
  
  static void soc_cleanup_card_debugfs(struct snd_soc_card *card)
  {
  	debugfs_remove_recursive(card->debugfs_card_root);
  }

  #else
  
  static inline void soc_init_codec_debugfs(struct snd_soc_codec *codec)
  {
  }
  
  static inline void soc_cleanup_codec_debugfs(struct snd_soc_codec *codec)
  {
  }

  
  static inline void soc_init_card_debugfs(struct snd_soc_card *card)
  {
  }
  
  static inline void soc_cleanup_card_debugfs(struct snd_soc_card *card)
  {
  }

  #endif

  #ifdef CONFIG_SND_SOC_AC97_BUS
  /* unregister ac97 codec */
  static int soc_ac97_dev_unregister(struct snd_soc_codec *codec)
  {
  	if (codec->ac97->dev.bus)
  		device_unregister(&codec->ac97->dev);
  	return 0;
  }
  
  /* stop no dev release warning */
  static void soc_ac97_device_release(struct device *dev){}
  
  /* register ac97 codec to bus */
  static int soc_ac97_dev_register(struct snd_soc_codec *codec)
  {
  	int err;
  
  	codec->ac97->dev.bus = &ac97_bus_type;

  	codec->ac97->dev.parent = codec->card->dev;

  	codec->ac97->dev.release = soc_ac97_device_release;

  	dev_set_name(&codec->ac97->dev, "%d-%d:%s",

  		     codec->card->snd_card->number, 0, codec->name);

  	err = device_register(&codec->ac97->dev);
  	if (err < 0) {
  		snd_printk(KERN_ERR "Can't register ac97 bus
  ");
  		codec->ac97->dev.bus = NULL;
  		return err;
  	}
  	return 0;
  }
  #endif

  #ifdef CONFIG_PM_SLEEP

  /* powers down audio subsystem for suspend */

  int snd_soc_suspend(struct device *dev)

  {

  	struct snd_soc_card *card = dev_get_drvdata(dev);

  	struct snd_soc_codec *codec;

  	int i;

  	/* If the initialization of this soc device failed, there is no codec
  	 * associated with it. Just bail out in this case.
  	 */

  	if (list_empty(&card->codec_dev_list))

  		return 0;

  	/* Due to the resume being scheduled into a workqueue we could
  	* suspend before that's finished - wait for it to complete.
  	 */

  	snd_power_lock(card->snd_card);
  	snd_power_wait(card->snd_card, SNDRV_CTL_POWER_D0);
  	snd_power_unlock(card->snd_card);

  
  	/* we're going to block userspace touching us until resume completes */

  	snd_power_change_state(card->snd_card, SNDRV_CTL_POWER_D3hot);

  	/* mute any active DACs */

  	for (i = 0; i < card->num_rtd; i++) {
  		struct snd_soc_dai *dai = card->rtd[i].codec_dai;
  		struct snd_soc_dai_driver *drv = dai->driver;

  		if (card->rtd[i].dai_link->ignore_suspend)

  			continue;

  		if (drv->ops->digital_mute && dai->playback_active)
  			drv->ops->digital_mute(dai, 1);

  	}

  	/* suspend all pcms */

  	for (i = 0; i < card->num_rtd; i++) {
  		if (card->rtd[i].dai_link->ignore_suspend)

  			continue;

  		snd_pcm_suspend_all(card->rtd[i].pcm);

  	}

  	if (card->suspend_pre)

  		card->suspend_pre(card);

  	for (i = 0; i < card->num_rtd; i++) {
  		struct snd_soc_dai *cpu_dai = card->rtd[i].cpu_dai;
  		struct snd_soc_platform *platform = card->rtd[i].platform;

  		if (card->rtd[i].dai_link->ignore_suspend)

  			continue;

  		if (cpu_dai->driver->suspend && !cpu_dai->driver->ac97_control)
  			cpu_dai->driver->suspend(cpu_dai);
  		if (platform->driver->suspend && !platform->suspended) {
  			platform->driver->suspend(cpu_dai);
  			platform->suspended = 1;
  		}

  	}
  
  	/* close any waiting streams and save state */

  	for (i = 0; i < card->num_rtd; i++) {

  		flush_delayed_work_sync(&card->rtd[i].delayed_work);

  		card->rtd[i].codec->dapm.suspend_bias_level = card->rtd[i].codec->dapm.bias_level;

  	}

  	for (i = 0; i < card->num_rtd; i++) {
  		struct snd_soc_dai_driver *driver = card->rtd[i].codec_dai->driver;

  		if (card->rtd[i].dai_link->ignore_suspend)

  			continue;

  		if (driver->playback.stream_name != NULL)
  			snd_soc_dapm_stream_event(&card->rtd[i], driver->playback.stream_name,

  				SND_SOC_DAPM_STREAM_SUSPEND);

  
  		if (driver->capture.stream_name != NULL)
  			snd_soc_dapm_stream_event(&card->rtd[i], driver->capture.stream_name,

  				SND_SOC_DAPM_STREAM_SUSPEND);
  	}

  	/* suspend all CODECs */

  	list_for_each_entry(codec, &card->codec_dev_list, card_list) {

  		/* If there are paths active then the CODEC will be held with
  		 * bias _ON and should not be suspended. */
  		if (!codec->suspended && codec->driver->suspend) {

  			switch (codec->dapm.bias_level) {

  			case SND_SOC_BIAS_STANDBY:
  			case SND_SOC_BIAS_OFF:
  				codec->driver->suspend(codec, PMSG_SUSPEND);
  				codec->suspended = 1;

  				codec->cache_sync = 1;

  				break;
  			default:
  				dev_dbg(codec->dev, "CODEC is on over suspend
  ");
  				break;
  			}

  		}
  	}

  	for (i = 0; i < card->num_rtd; i++) {
  		struct snd_soc_dai *cpu_dai = card->rtd[i].cpu_dai;

  		if (card->rtd[i].dai_link->ignore_suspend)

  			continue;

  		if (cpu_dai->driver->suspend && cpu_dai->driver->ac97_control)
  			cpu_dai->driver->suspend(cpu_dai);

  	}

  	if (card->suspend_post)

  		card->suspend_post(card);

  
  	return 0;
  }

  EXPORT_SYMBOL_GPL(snd_soc_suspend);

  /* deferred resume work, so resume can complete before we finished
   * setting our codec back up, which can be very slow on I2C
   */
  static void soc_resume_deferred(struct work_struct *work)

  {

  	struct snd_soc_card *card =
  			container_of(work, struct snd_soc_card, deferred_resume_work);

  	struct snd_soc_codec *codec;

  	int i;

  	/* our power state is still SNDRV_CTL_POWER_D3hot from suspend time,
  	 * so userspace apps are blocked from touching us
  	 */

  	dev_dbg(card->dev, "starting resume work
  ");

  	/* Bring us up into D2 so that DAPM starts enabling things */

  	snd_power_change_state(card->snd_card, SNDRV_CTL_POWER_D2);

  	if (card->resume_pre)

  		card->resume_pre(card);

  	/* resume AC97 DAIs */
  	for (i = 0; i < card->num_rtd; i++) {
  		struct snd_soc_dai *cpu_dai = card->rtd[i].cpu_dai;

  		if (card->rtd[i].dai_link->ignore_suspend)

  			continue;

  		if (cpu_dai->driver->resume && cpu_dai->driver->ac97_control)
  			cpu_dai->driver->resume(cpu_dai);
  	}

  	list_for_each_entry(codec, &card->codec_dev_list, card_list) {

  		/* If the CODEC was idle over suspend then it will have been
  		 * left with bias OFF or STANDBY and suspended so we must now
  		 * resume.  Otherwise the suspend was suppressed.
  		 */
  		if (codec->driver->resume && codec->suspended) {

  			switch (codec->dapm.bias_level) {

  			case SND_SOC_BIAS_STANDBY:
  			case SND_SOC_BIAS_OFF:
  				codec->driver->resume(codec);
  				codec->suspended = 0;
  				break;
  			default:
  				dev_dbg(codec->dev, "CODEC was on over suspend
  ");
  				break;
  			}

  		}
  	}

  	for (i = 0; i < card->num_rtd; i++) {
  		struct snd_soc_dai_driver *driver = card->rtd[i].codec_dai->driver;

  		if (card->rtd[i].dai_link->ignore_suspend)

  			continue;

  		if (driver->playback.stream_name != NULL)
  			snd_soc_dapm_stream_event(&card->rtd[i], driver->playback.stream_name,

  				SND_SOC_DAPM_STREAM_RESUME);

  
  		if (driver->capture.stream_name != NULL)
  			snd_soc_dapm_stream_event(&card->rtd[i], driver->capture.stream_name,

  				SND_SOC_DAPM_STREAM_RESUME);
  	}

  	/* unmute any active DACs */

  	for (i = 0; i < card->num_rtd; i++) {
  		struct snd_soc_dai *dai = card->rtd[i].codec_dai;
  		struct snd_soc_dai_driver *drv = dai->driver;

  		if (card->rtd[i].dai_link->ignore_suspend)

  			continue;

  		if (drv->ops->digital_mute && dai->playback_active)
  			drv->ops->digital_mute(dai, 0);

  	}

  	for (i = 0; i < card->num_rtd; i++) {
  		struct snd_soc_dai *cpu_dai = card->rtd[i].cpu_dai;
  		struct snd_soc_platform *platform = card->rtd[i].platform;

  		if (card->rtd[i].dai_link->ignore_suspend)

  			continue;

  		if (cpu_dai->driver->resume && !cpu_dai->driver->ac97_control)
  			cpu_dai->driver->resume(cpu_dai);
  		if (platform->driver->resume && platform->suspended) {
  			platform->driver->resume(cpu_dai);
  			platform->suspended = 0;
  		}

  	}

  	if (card->resume_post)

  		card->resume_post(card);

  	dev_dbg(card->dev, "resume work completed
  ");

  
  	/* userspace can access us now we are back as we were before */

  	snd_power_change_state(card->snd_card, SNDRV_CTL_POWER_D0);

  }
  
  /* powers up audio subsystem after a suspend */

  int snd_soc_resume(struct device *dev)

  {

  	struct snd_soc_card *card = dev_get_drvdata(dev);

  	int i, ac97_control = 0;

  	/* AC97 devices might have other drivers hanging off them so
  	 * need to resume immediately.  Other drivers don't have that
  	 * problem and may take a substantial amount of time to resume
  	 * due to I/O costs and anti-pop so handle them out of line.
  	 */

  	for (i = 0; i < card->num_rtd; i++) {
  		struct snd_soc_dai *cpu_dai = card->rtd[i].cpu_dai;

  		ac97_control |= cpu_dai->driver->ac97_control;
  	}
  	if (ac97_control) {
  		dev_dbg(dev, "Resuming AC97 immediately
  ");
  		soc_resume_deferred(&card->deferred_resume_work);
  	} else {
  		dev_dbg(dev, "Scheduling resume work
  ");
  		if (!schedule_work(&card->deferred_resume_work))
  			dev_err(dev, "resume work item may be lost
  ");

  	}

  	return 0;
  }

  EXPORT_SYMBOL_GPL(snd_soc_resume);

  #else

  #define snd_soc_suspend NULL
  #define snd_soc_resume NULL

  #endif

  static struct snd_soc_dai_ops null_dai_ops = {
  };

  static int soc_bind_dai_link(struct snd_soc_card *card, int num)

  {

  	struct snd_soc_dai_link *dai_link = &card->dai_link[num];
  	struct snd_soc_pcm_runtime *rtd = &card->rtd[num];

  	struct snd_soc_codec *codec;

  	struct snd_soc_platform *platform;

  	struct snd_soc_dai *codec_dai, *cpu_dai;

  	const char *platform_name;

  	if (rtd->complete)
  		return 1;
  	dev_dbg(card->dev, "binding %s at idx %d
  ", dai_link->name, num);

  	/* do we already have the CPU DAI for this link ? */
  	if (rtd->cpu_dai) {
  		goto find_codec;
  	}
  	/* no, then find CPU DAI from registered DAIs*/
  	list_for_each_entry(cpu_dai, &dai_list, list) {
  		if (!strcmp(cpu_dai->name, dai_link->cpu_dai_name)) {

  			rtd->cpu_dai = cpu_dai;
  			goto find_codec;

  		}

  	}

  	dev_dbg(card->dev, "CPU DAI %s not registered
  ",
  			dai_link->cpu_dai_name);

  find_codec:
  	/* do we already have the CODEC for this link ? */
  	if (rtd->codec) {
  		goto find_platform;
  	}
  
  	/* no, then find CODEC from registered CODECs*/
  	list_for_each_entry(codec, &codec_list, list) {
  		if (!strcmp(codec->name, dai_link->codec_name)) {
  			rtd->codec = codec;

  			/* CODEC found, so find CODEC DAI from registered DAIs from this CODEC*/
  			list_for_each_entry(codec_dai, &dai_list, list) {
  				if (codec->dev == codec_dai->dev &&
  						!strcmp(codec_dai->name, dai_link->codec_dai_name)) {
  					rtd->codec_dai = codec_dai;
  					goto find_platform;
  				}

  			}

  			dev_dbg(card->dev, "CODEC DAI %s not registered
  ",
  					dai_link->codec_dai_name);
  
  			goto find_platform;

  		}

  	}
  	dev_dbg(card->dev, "CODEC %s not registered
  ",
  			dai_link->codec_name);

  find_platform:

  	/* do we need a platform? */
  	if (rtd->platform)

  		goto out;

  
  	/* if there's no platform we match on the empty platform */
  	platform_name = dai_link->platform_name;
  	if (!platform_name)
  		platform_name = "snd-soc-dummy";
  
  	/* no, then find one from the set of registered platforms */

  	list_for_each_entry(platform, &platform_list, list) {

  		if (!strcmp(platform->name, platform_name)) {

  			rtd->platform = platform;
  			goto out;
  		}

  	}

  	dev_dbg(card->dev, "platform %s not registered
  ",
  			dai_link->platform_name);
  	return 0;
  
  out:
  	/* mark rtd as complete if we found all 4 of our client devices */
  	if (rtd->codec && rtd->codec_dai && rtd->platform && rtd->cpu_dai) {
  		rtd->complete = 1;
  		card->num_rtd++;
  	}
  	return 1;
  }

  static void soc_remove_codec(struct snd_soc_codec *codec)
  {
  	int err;
  
  	if (codec->driver->remove) {
  		err = codec->driver->remove(codec);
  		if (err < 0)
  			dev_err(codec->dev,
  				"asoc: failed to remove %s: %d
  ",
  				codec->name, err);
  	}
  
  	/* Make sure all DAPM widgets are freed */
  	snd_soc_dapm_free(&codec->dapm);
  
  	soc_cleanup_codec_debugfs(codec);
  	codec->probed = 0;
  	list_del(&codec->card_list);
  	module_put(codec->dev->driver->owner);
  }

  static void soc_remove_dai_link(struct snd_soc_card *card, int num, int order)

  {
  	struct snd_soc_pcm_runtime *rtd = &card->rtd[num];
  	struct snd_soc_codec *codec = rtd->codec;
  	struct snd_soc_platform *platform = rtd->platform;
  	struct snd_soc_dai *codec_dai = rtd->codec_dai, *cpu_dai = rtd->cpu_dai;
  	int err;
  
  	/* unregister the rtd device */
  	if (rtd->dev_registered) {
  		device_remove_file(&rtd->dev, &dev_attr_pmdown_time);

  		device_remove_file(&rtd->dev, &dev_attr_codec_reg);

  		device_unregister(&rtd->dev);
  		rtd->dev_registered = 0;
  	}
  
  	/* remove the CODEC DAI */

  	if (codec_dai && codec_dai->probed &&
  			codec_dai->driver->remove_order == order) {

  		if (codec_dai->driver->remove) {
  			err = codec_dai->driver->remove(codec_dai);
  			if (err < 0)
  				printk(KERN_ERR "asoc: failed to remove %s
  ", codec_dai->name);

  		}

  		codec_dai->probed = 0;
  		list_del(&codec_dai->card_list);
  	}

  	/* remove the platform */

  	if (platform && platform->probed &&
  			platform->driver->remove_order == order) {

  		if (platform->driver->remove) {
  			err = platform->driver->remove(platform);
  			if (err < 0)
  				printk(KERN_ERR "asoc: failed to remove %s
  ", platform->name);
  		}
  		platform->probed = 0;
  		list_del(&platform->card_list);
  		module_put(platform->dev->driver->owner);
  	}

  	/* remove the CODEC */

  	if (codec && codec->probed &&
  			codec->driver->remove_order == order)

  		soc_remove_codec(codec);

  	/* remove the cpu_dai */

  	if (cpu_dai && cpu_dai->probed &&
  			cpu_dai->driver->remove_order == order) {

  		if (cpu_dai->driver->remove) {
  			err = cpu_dai->driver->remove(cpu_dai);
  			if (err < 0)
  				printk(KERN_ERR "asoc: failed to remove %s
  ", cpu_dai->name);

  		}

  		cpu_dai->probed = 0;
  		list_del(&cpu_dai->card_list);
  		module_put(cpu_dai->dev->driver->owner);

  	}

  }

  static void soc_remove_dai_links(struct snd_soc_card *card)
  {

  	int dai, order;

  	for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
  			order++) {
  		for (dai = 0; dai < card->num_rtd; dai++)
  			soc_remove_dai_link(card, dai, order);
  	}

  	card->num_rtd = 0;
  }

  static void soc_set_name_prefix(struct snd_soc_card *card,
  				struct snd_soc_codec *codec)
  {
  	int i;

  	if (card->codec_conf == NULL)

  		return;

  	for (i = 0; i < card->num_configs; i++) {
  		struct snd_soc_codec_conf *map = &card->codec_conf[i];

  		if (map->dev_name && !strcmp(codec->name, map->dev_name)) {
  			codec->name_prefix = map->name_prefix;
  			break;
  		}
  	}
  }

  static int soc_probe_codec(struct snd_soc_card *card,
  			   struct snd_soc_codec *codec)
  {
  	int ret = 0;

  	const struct snd_soc_codec_driver *driver = codec->driver;

  
  	codec->card = card;
  	codec->dapm.card = card;
  	soc_set_name_prefix(card, codec);

  	if (!try_module_get(codec->dev->driver->owner))
  		return -ENODEV;

  	soc_init_codec_debugfs(codec);

  	if (driver->dapm_widgets)
  		snd_soc_dapm_new_controls(&codec->dapm, driver->dapm_widgets,
  					  driver->num_dapm_widgets);

  	if (driver->probe) {
  		ret = driver->probe(codec);

  		if (ret < 0) {
  			dev_err(codec->dev,
  				"asoc: failed to probe CODEC %s: %d
  ",
  				codec->name, ret);

  			goto err_probe;

  		}
  	}

  	if (driver->controls)
  		snd_soc_add_controls(codec, driver->controls,
  				     driver->num_controls);

  	if (driver->dapm_routes)
  		snd_soc_dapm_add_routes(&codec->dapm, driver->dapm_routes,
  					driver->num_dapm_routes);

  	/* mark codec as probed and add to card codec list */
  	codec->probed = 1;
  	list_add(&codec->card_list, &card->codec_dev_list);

  	list_add(&codec->dapm.list, &card->dapm_list);

  	return 0;
  
  err_probe:

  	soc_cleanup_codec_debugfs(codec);

  	module_put(codec->dev->driver->owner);

  	return ret;
  }

  static int soc_probe_platform(struct snd_soc_card *card,
  			   struct snd_soc_platform *platform)
  {
  	int ret = 0;
  	const struct snd_soc_platform_driver *driver = platform->driver;
  
  	platform->card = card;

  	platform->dapm.card = card;

  
  	if (!try_module_get(platform->dev->driver->owner))
  		return -ENODEV;

  	if (driver->dapm_widgets)
  		snd_soc_dapm_new_controls(&platform->dapm,
  			driver->dapm_widgets, driver->num_dapm_widgets);

  	if (driver->probe) {
  		ret = driver->probe(platform);
  		if (ret < 0) {
  			dev_err(platform->dev,
  				"asoc: failed to probe platform %s: %d
  ",
  				platform->name, ret);
  			goto err_probe;
  		}
  	}

  	if (driver->controls)
  		snd_soc_add_platform_controls(platform, driver->controls,
  				     driver->num_controls);
  	if (driver->dapm_routes)
  		snd_soc_dapm_add_routes(&platform->dapm, driver->dapm_routes,
  					driver->num_dapm_routes);

  	/* mark platform as probed and add to card platform list */
  	platform->probed = 1;
  	list_add(&platform->card_list, &card->platform_dev_list);

  	list_add(&platform->dapm.list, &card->dapm_list);

  
  	return 0;
  
  err_probe:
  	module_put(platform->dev->driver->owner);
  
  	return ret;
  }

  static void rtd_release(struct device *dev) {}

  static int soc_post_component_init(struct snd_soc_card *card,
  				   struct snd_soc_codec *codec,
  				   int num, int dailess)
  {
  	struct snd_soc_dai_link *dai_link = NULL;
  	struct snd_soc_aux_dev *aux_dev = NULL;
  	struct snd_soc_pcm_runtime *rtd;
  	const char *temp, *name;
  	int ret = 0;
  
  	if (!dailess) {
  		dai_link = &card->dai_link[num];
  		rtd = &card->rtd[num];
  		name = dai_link->name;
  	} else {
  		aux_dev = &card->aux_dev[num];
  		rtd = &card->rtd_aux[num];
  		name = aux_dev->name;
  	}

  	rtd->card = card;

  
  	/* machine controls, routes and widgets are not prefixed */
  	temp = codec->name_prefix;
  	codec->name_prefix = NULL;
  
  	/* do machine specific initialization */
  	if (!dailess && dai_link->init)
  		ret = dai_link->init(rtd);
  	else if (dailess && aux_dev->init)
  		ret = aux_dev->init(&codec->dapm);
  	if (ret < 0) {
  		dev_err(card->dev, "asoc: failed to init %s: %d
  ", name, ret);
  		return ret;
  	}
  	codec->name_prefix = temp;
  
  	/* Make sure all DAPM widgets are instantiated */
  	snd_soc_dapm_new_widgets(&codec->dapm);

  
  	/* register the rtd device */
  	rtd->codec = codec;

  	rtd->dev.parent = card->dev;
  	rtd->dev.release = rtd_release;
  	rtd->dev.init_name = name;

  	mutex_init(&rtd->pcm_mutex);

  	ret = device_register(&rtd->dev);
  	if (ret < 0) {
  		dev_err(card->dev,
  			"asoc: failed to register runtime device: %d
  ", ret);
  		return ret;
  	}
  	rtd->dev_registered = 1;
  
  	/* add DAPM sysfs entries for this codec */
  	ret = snd_soc_dapm_sys_add(&rtd->dev);
  	if (ret < 0)
  		dev_err(codec->dev,
  			"asoc: failed to add codec dapm sysfs entries: %d
  ",
  			ret);
  
  	/* add codec sysfs entries */
  	ret = device_create_file(&rtd->dev, &dev_attr_codec_reg);
  	if (ret < 0)
  		dev_err(codec->dev,
  			"asoc: failed to add codec sysfs files: %d
  ", ret);
  
  	return 0;
  }

  static int soc_probe_dai_link(struct snd_soc_card *card, int num, int order)

  {
  	struct snd_soc_dai_link *dai_link = &card->dai_link[num];
  	struct snd_soc_pcm_runtime *rtd = &card->rtd[num];
  	struct snd_soc_codec *codec = rtd->codec;
  	struct snd_soc_platform *platform = rtd->platform;
  	struct snd_soc_dai *codec_dai = rtd->codec_dai, *cpu_dai = rtd->cpu_dai;
  	int ret;

  	dev_dbg(card->dev, "probe %s dai link %d late %d
  ",
  			card->name, num, order);

  
  	/* config components */
  	codec_dai->codec = codec;

  	cpu_dai->platform = platform;

  	codec_dai->card = card;
  	cpu_dai->card = card;
  
  	/* set default power off timeout */
  	rtd->pmdown_time = pmdown_time;
  
  	/* probe the cpu_dai */

  	if (!cpu_dai->probed &&
  			cpu_dai->driver->probe_order == order) {

  		if (!try_module_get(cpu_dai->dev->driver->owner))
  			return -ENODEV;

  		if (cpu_dai->driver->probe) {
  			ret = cpu_dai->driver->probe(cpu_dai);
  			if (ret < 0) {
  				printk(KERN_ERR "asoc: failed to probe CPU DAI %s
  ",
  						cpu_dai->name);

  				module_put(cpu_dai->dev->driver->owner);

  				return ret;
  			}
  		}
  		cpu_dai->probed = 1;

  		/* mark cpu_dai as probed and add to card dai list */

  		list_add(&cpu_dai->card_list, &card->dai_dev_list);

  	}

  	/* probe the CODEC */

  	if (!codec->probed &&
  			codec->driver->probe_order == order) {

  		ret = soc_probe_codec(card, codec);
  		if (ret < 0)
  			return ret;

  	}

  	/* probe the platform */

  	if (!platform->probed &&
  			platform->driver->probe_order == order) {

  		ret = soc_probe_platform(card, platform);
  		if (ret < 0)
  			return ret;

  	}

  	/* probe the CODEC DAI */

  	if (!codec_dai->probed && codec_dai->driver->probe_order == order) {

  		if (codec_dai->driver->probe) {
  			ret = codec_dai->driver->probe(codec_dai);

  			if (ret < 0) {

  				printk(KERN_ERR "asoc: failed to probe CODEC DAI %s
  ",
  						codec_dai->name);
  				return ret;

  			}
  		}

  		/* mark codec_dai as probed and add to card dai list */

  		codec_dai->probed = 1;
  		list_add(&codec_dai->card_list, &card->dai_dev_list);

  	}

  	/* complete DAI probe during last probe */
  	if (order != SND_SOC_COMP_ORDER_LAST)
  		return 0;

  	ret = soc_post_component_init(card, codec, num, 0);
  	if (ret)

  		return ret;

  	ret = device_create_file(&rtd->dev, &dev_attr_pmdown_time);
  	if (ret < 0)
  		printk(KERN_WARNING "asoc: failed to add pmdown_time sysfs
  ");

  	/* create the pcm */
  	ret = soc_new_pcm(rtd, num);
  	if (ret < 0) {
  		printk(KERN_ERR "asoc: can't create pcm %s
  ", dai_link->stream_name);
  		return ret;
  	}
  
  	/* add platform data for AC97 devices */
  	if (rtd->codec_dai->driver->ac97_control)
  		snd_ac97_dev_add_pdata(codec->ac97, rtd->cpu_dai->ac97_pdata);
  
  	return 0;
  }

  #ifdef CONFIG_SND_SOC_AC97_BUS

  static int soc_register_ac97_dai_link(struct snd_soc_pcm_runtime *rtd)
  {
  	int ret;

  	/* Only instantiate AC97 if not already done by the adaptor
  	 * for the generic AC97 subsystem.
  	 */

  	if (rtd->codec_dai->driver->ac97_control && !rtd->codec->ac97_registered) {

  		/*
  		 * It is possible that the AC97 device is already registered to
  		 * the device subsystem. This happens when the device is created
  		 * via snd_ac97_mixer(). Currently only SoC codec that does so
  		 * is the generic AC97 glue but others migh emerge.
  		 *
  		 * In those cases we don't try to register the device again.
  		 */
  		if (!rtd->codec->ac97_created)
  			return 0;

  
  		ret = soc_ac97_dev_register(rtd->codec);

  		if (ret < 0) {
  			printk(KERN_ERR "asoc: AC97 device register failed
  ");

  			return ret;

  		}

  
  		rtd->codec->ac97_registered = 1;

  	}

  	return 0;
  }
  
  static void soc_unregister_ac97_dai_link(struct snd_soc_codec *codec)
  {
  	if (codec->ac97_registered) {
  		soc_ac97_dev_unregister(codec);
  		codec->ac97_registered = 0;
  	}
  }

  #endif

  static int soc_probe_aux_dev(struct snd_soc_card *card, int num)
  {
  	struct snd_soc_aux_dev *aux_dev = &card->aux_dev[num];

  	struct snd_soc_codec *codec;

  	int ret = -ENODEV;

  
  	/* find CODEC from registered CODECs*/
  	list_for_each_entry(codec, &codec_list, list) {
  		if (!strcmp(codec->name, aux_dev->codec_name)) {
  			if (codec->probed) {
  				dev_err(codec->dev,
  					"asoc: codec already probed");
  				ret = -EBUSY;
  				goto out;
  			}

  			goto found;

  		}
  	}

  	/* codec not found */
  	dev_err(card->dev, "asoc: codec %s not found", aux_dev->codec_name);
  	goto out;

  found:

  	ret = soc_probe_codec(card, codec);

  	if (ret < 0)

  		return ret;

  	ret = soc_post_component_init(card, codec, num, 1);

  
  out:
  	return ret;
  }
  
  static void soc_remove_aux_dev(struct snd_soc_card *card, int num)
  {
  	struct snd_soc_pcm_runtime *rtd = &card->rtd_aux[num];
  	struct snd_soc_codec *codec = rtd->codec;

  
  	/* unregister the rtd device */
  	if (rtd->dev_registered) {

  		device_remove_file(&rtd->dev, &dev_attr_codec_reg);

  		device_unregister(&rtd->dev);
  		rtd->dev_registered = 0;
  	}

  	if (codec && codec->probed)
  		soc_remove_codec(codec);

  }

  static int snd_soc_init_codec_cache(struct snd_soc_codec *codec,
  				    enum snd_soc_compress_type compress_type)
  {
  	int ret;
  
  	if (codec->cache_init)
  		return 0;
  
  	/* override the compress_type if necessary */
  	if (compress_type && codec->compress_type != compress_type)
  		codec->compress_type = compress_type;

  	ret = snd_soc_cache_init(codec);
  	if (ret < 0) {
  		dev_err(codec->dev, "Failed to set cache compression type: %d
  ",
  			ret);
  		return ret;
  	}
  	codec->cache_init = 1;
  	return 0;
  }

  static void snd_soc_instantiate_card(struct snd_soc_card *card)
  {

  	struct snd_soc_codec *codec;
  	struct snd_soc_codec_conf *codec_conf;
  	enum snd_soc_compress_type compress_type;

  	int ret, i, order;

  	mutex_lock(&card->mutex);

  	if (card->instantiated) {
  		mutex_unlock(&card->mutex);
  		return;
  	}

  	/* bind DAIs */
  	for (i = 0; i < card->num_links; i++)
  		soc_bind_dai_link(card, i);

  	/* bind completed ? */
  	if (card->num_rtd != card->num_links) {
  		mutex_unlock(&card->mutex);
  		return;
  	}

  	/* initialize the register cache for each available codec */
  	list_for_each_entry(codec, &codec_list, list) {
  		if (codec->cache_init)
  			continue;

  		/* by default we don't override the compress_type */
  		compress_type = 0;

  		/* check to see if we need to override the compress_type */
  		for (i = 0; i < card->num_configs; ++i) {
  			codec_conf = &card->codec_conf[i];
  			if (!strcmp(codec->name, codec_conf->dev_name)) {
  				compress_type = codec_conf->compress_type;
  				if (compress_type && compress_type
  				    != codec->compress_type)
  					break;
  			}
  		}

  		ret = snd_soc_init_codec_cache(codec, compress_type);
  		if (ret < 0) {
  			mutex_unlock(&card->mutex);
  			return;
  		}
  	}

  	/* card bind complete so register a sound card */
  	ret = snd_card_create(SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1,
  			card->owner, 0, &card->snd_card);
  	if (ret < 0) {
  		printk(KERN_ERR "asoc: can't create sound card for card %s
  ",
  			card->name);
  		mutex_unlock(&card->mutex);
  		return;
  	}
  	card->snd_card->dev = card->dev;

  	card->dapm.bias_level = SND_SOC_BIAS_OFF;
  	card->dapm.dev = card->dev;
  	card->dapm.card = card;
  	list_add(&card->dapm.list, &card->dapm_list);

  #ifdef CONFIG_DEBUG_FS
  	snd_soc_dapm_debugfs_init(&card->dapm, card->debugfs_card_root);
  #endif

  #ifdef CONFIG_PM_SLEEP

  	/* deferred resume work */
  	INIT_WORK(&card->deferred_resume_work, soc_resume_deferred);
  #endif

  	if (card->dapm_widgets)
  		snd_soc_dapm_new_controls(&card->dapm, card->dapm_widgets,
  					  card->num_dapm_widgets);

  	/* initialise the sound card only once */
  	if (card->probe) {

  		ret = card->probe(card);

  		if (ret < 0)
  			goto card_probe_error;
  	}

  	/* early DAI link probe */
  	for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
  			order++) {
  		for (i = 0; i < card->num_links; i++) {
  			ret = soc_probe_dai_link(card, i, order);
  			if (ret < 0) {
  				pr_err("asoc: failed to instantiate card %s: %d
  ",

  			       card->name, ret);

  				goto probe_dai_err;
  			}

  		}
  	}

  	for (i = 0; i < card->num_aux_devs; i++) {
  		ret = soc_probe_aux_dev(card, i);
  		if (ret < 0) {
  			pr_err("asoc: failed to add auxiliary devices %s: %d
  ",
  			       card->name, ret);
  			goto probe_aux_dev_err;
  		}
  	}

  	/* We should have a non-codec control add function but we don't */
  	if (card->controls)
  		snd_soc_add_controls(list_first_entry(&card->codec_dev_list,
  						      struct snd_soc_codec,
  						      card_list),
  				     card->controls,
  				     card->num_controls);

  	if (card->dapm_routes)
  		snd_soc_dapm_add_routes(&card->dapm, card->dapm_routes,
  					card->num_dapm_routes);

  	snprintf(card->snd_card->shortname, sizeof(card->snd_card->shortname),

  		 "%s", card->name);

  	snprintf(card->snd_card->longname, sizeof(card->snd_card->longname),
  		 "%s", card->long_name ? card->long_name : card->name);

  	if (card->driver_name)
  		strlcpy(card->snd_card->driver, card->driver_name,
  			sizeof(card->snd_card->driver));

  	if (card->late_probe) {
  		ret = card->late_probe(card);
  		if (ret < 0) {
  			dev_err(card->dev, "%s late_probe() failed: %d
  ",
  				card->name, ret);
  			goto probe_aux_dev_err;
  		}
  	}

  	ret = snd_card_register(card->snd_card);
  	if (ret < 0) {
  		printk(KERN_ERR "asoc: failed to register soundcard for %s
  ", card->name);

  		goto probe_aux_dev_err;

  	}

  #ifdef CONFIG_SND_SOC_AC97_BUS
  	/* register any AC97 codecs */
  	for (i = 0; i < card->num_rtd; i++) {

  		ret = soc_register_ac97_dai_link(&card->rtd[i]);
  		if (ret < 0) {
  			printk(KERN_ERR "asoc: failed to register AC97 %s
  ", card->name);
  			while (--i >= 0)

  				soc_unregister_ac97_dai_link(card->rtd[i].codec);

  			goto probe_aux_dev_err;

  		}

  	}

  #endif
  
  	card->instantiated = 1;
  	mutex_unlock(&card->mutex);
  	return;

  probe_aux_dev_err:
  	for (i = 0; i < card->num_aux_devs; i++)
  		soc_remove_aux_dev(card, i);

  probe_dai_err:

  	soc_remove_dai_links(card);

  
  card_probe_error:

  	if (card->remove)

  		card->remove(card);

  
  	snd_card_free(card->snd_card);
  
  	mutex_unlock(&card->mutex);

  }

  /*

   * Attempt to initialise any uninitialised cards.  Must be called with

   * client_mutex.
   */
  static void snd_soc_instantiate_cards(void)
  {
  	struct snd_soc_card *card;
  	list_for_each_entry(card, &card_list, list)
  		snd_soc_instantiate_card(card);
  }
  
  /* probes a new socdev */
  static int soc_probe(struct platform_device *pdev)
  {

  	struct snd_soc_card *card = platform_get_drvdata(pdev);

  	int ret = 0;

  	/*
  	 * no card, so machine driver should be registering card
  	 * we should not be here in that case so ret error
  	 */
  	if (!card)
  		return -EINVAL;

  	/* Bodge while we unpick instantiation */
  	card->dev = &pdev->dev;

  	ret = snd_soc_register_card(card);
  	if (ret != 0) {
  		dev_err(&pdev->dev, "Failed to register card
  ");
  		return ret;
  	}
  
  	return 0;

  }

  static int soc_cleanup_card_resources(struct snd_soc_card *card)

  {
  	int i;

  	/* make sure any delayed work runs */
  	for (i = 0; i < card->num_rtd; i++) {
  		struct snd_soc_pcm_runtime *rtd = &card->rtd[i];
  		flush_delayed_work_sync(&rtd->delayed_work);
  	}

  	/* remove auxiliary devices */
  	for (i = 0; i < card->num_aux_devs; i++)
  		soc_remove_aux_dev(card, i);

  	/* remove and free each DAI */

  	soc_remove_dai_links(card);

  	soc_cleanup_card_debugfs(card);

  	/* remove the card */
  	if (card->remove)

  		card->remove(card);

  	snd_soc_dapm_free(&card->dapm);

  	kfree(card->rtd);
  	snd_card_free(card->snd_card);
  	return 0;
  
  }
  
  /* removes a socdev */
  static int soc_remove(struct platform_device *pdev)
  {
  	struct snd_soc_card *card = platform_get_drvdata(pdev);

  	snd_soc_unregister_card(card);

  	return 0;
  }

  int snd_soc_poweroff(struct device *dev)

  {

  	struct snd_soc_card *card = dev_get_drvdata(dev);

  	int i;

  
  	if (!card->instantiated)

  		return 0;

  
  	/* Flush out pmdown_time work - we actually do want to run it
  	 * now, we're shutting down so no imminent restart. */

  	for (i = 0; i < card->num_rtd; i++) {
  		struct snd_soc_pcm_runtime *rtd = &card->rtd[i];

  		flush_delayed_work_sync(&rtd->delayed_work);

  	}

  	snd_soc_dapm_shutdown(card);

  
  	return 0;

  }

  EXPORT_SYMBOL_GPL(snd_soc_poweroff);

  const struct dev_pm_ops snd_soc_pm_ops = {
  	.suspend = snd_soc_suspend,
  	.resume = snd_soc_resume,
  	.poweroff = snd_soc_poweroff,

  };

  EXPORT_SYMBOL_GPL(snd_soc_pm_ops);

  /* ASoC platform driver */
  static struct platform_driver soc_driver = {
  	.driver		= {
  		.name		= "soc-audio",

  		.owner		= THIS_MODULE,

  		.pm		= &snd_soc_pm_ops,

  	},
  	.probe		= soc_probe,
  	.remove		= soc_remove,

  };

  /**
   * snd_soc_codec_volatile_register: Report if a register is volatile.
   *
   * @codec: CODEC to query.
   * @reg: Register to query.
   *
   * Boolean function indiciating if a CODEC register is volatile.
   */

  int snd_soc_codec_volatile_register(struct snd_soc_codec *codec,
  				    unsigned int reg)

  {

  	if (codec->volatile_register)
  		return codec->volatile_register(codec, reg);

  	else
  		return 0;
  }
  EXPORT_SYMBOL_GPL(snd_soc_codec_volatile_register);

  /**

   * snd_soc_codec_readable_register: Report if a register is readable.
   *
   * @codec: CODEC to query.
   * @reg: Register to query.
   *
   * Boolean function indicating if a CODEC register is readable.
   */
  int snd_soc_codec_readable_register(struct snd_soc_codec *codec,
  				    unsigned int reg)
  {
  	if (codec->readable_register)
  		return codec->readable_register(codec, reg);
  	else

  		return 1;

  }
  EXPORT_SYMBOL_GPL(snd_soc_codec_readable_register);
  
  /**
   * snd_soc_codec_writable_register: Report if a register is writable.
   *
   * @codec: CODEC to query.
   * @reg: Register to query.
   *
   * Boolean function indicating if a CODEC register is writable.
   */
  int snd_soc_codec_writable_register(struct snd_soc_codec *codec,
  				    unsigned int reg)
  {
  	if (codec->writable_register)
  		return codec->writable_register(codec, reg);
  	else

  		return 1;

  }
  EXPORT_SYMBOL_GPL(snd_soc_codec_writable_register);

  int snd_soc_platform_read(struct snd_soc_platform *platform,
  					unsigned int reg)
  {
  	unsigned int ret;
  
  	if (!platform->driver->read) {
  		dev_err(platform->dev, "platform has no read back
  ");
  		return -1;
  	}
  
  	ret = platform->driver->read(platform, reg);
  	dev_dbg(platform->dev, "read %x => %x
  ", reg, ret);

  	trace_snd_soc_preg_read(platform, reg, ret);

  
  	return ret;
  }
  EXPORT_SYMBOL_GPL(snd_soc_platform_read);
  
  int snd_soc_platform_write(struct snd_soc_platform *platform,
  					 unsigned int reg, unsigned int val)
  {
  	if (!platform->driver->write) {
  		dev_err(platform->dev, "platform has no write back
  ");
  		return -1;
  	}
  
  	dev_dbg(platform->dev, "write %x = %x
  ", reg, val);

  	trace_snd_soc_preg_write(platform, reg, val);

  	return platform->driver->write(platform, reg, val);
  }
  EXPORT_SYMBOL_GPL(snd_soc_platform_write);

  /**

   * snd_soc_new_ac97_codec - initailise AC97 device
   * @codec: audio codec
   * @ops: AC97 bus operations
   * @num: AC97 codec number
   *
   * Initialises AC97 codec resources for use by ad-hoc devices only.
   */
  int snd_soc_new_ac97_codec(struct snd_soc_codec *codec,
  	struct snd_ac97_bus_ops *ops, int num)
  {
  	mutex_lock(&codec->mutex);
  
  	codec->ac97 = kzalloc(sizeof(struct snd_ac97), GFP_KERNEL);
  	if (codec->ac97 == NULL) {
  		mutex_unlock(&codec->mutex);
  		return -ENOMEM;
  	}
  
  	codec->ac97->bus = kzalloc(sizeof(struct snd_ac97_bus), GFP_KERNEL);
  	if (codec->ac97->bus == NULL) {
  		kfree(codec->ac97);
  		codec->ac97 = NULL;
  		mutex_unlock(&codec->mutex);
  		return -ENOMEM;
  	}
  
  	codec->ac97->bus->ops = ops;
  	codec->ac97->num = num;

  
  	/*
  	 * Mark the AC97 device to be created by us. This way we ensure that the
  	 * device will be registered with the device subsystem later on.
  	 */
  	codec->ac97_created = 1;

  	mutex_unlock(&codec->mutex);
  	return 0;
  }
  EXPORT_SYMBOL_GPL(snd_soc_new_ac97_codec);
  
  /**
   * snd_soc_free_ac97_codec - free AC97 codec device
   * @codec: audio codec
   *
   * Frees AC97 codec device resources.
   */
  void snd_soc_free_ac97_codec(struct snd_soc_codec *codec)
  {
  	mutex_lock(&codec->mutex);

  #ifdef CONFIG_SND_SOC_AC97_BUS
  	soc_unregister_ac97_dai_link(codec);
  #endif

  	kfree(codec->ac97->bus);
  	kfree(codec->ac97);
  	codec->ac97 = NULL;

  	codec->ac97_created = 0;

  	mutex_unlock(&codec->mutex);
  }
  EXPORT_SYMBOL_GPL(snd_soc_free_ac97_codec);

  unsigned int snd_soc_read(struct snd_soc_codec *codec, unsigned int reg)
  {
  	unsigned int ret;

  	ret = codec->read(codec, reg);

  	dev_dbg(codec->dev, "read %x => %x
  ", reg, ret);

  	trace_snd_soc_reg_read(codec, reg, ret);

  
  	return ret;
  }
  EXPORT_SYMBOL_GPL(snd_soc_read);
  
  unsigned int snd_soc_write(struct snd_soc_codec *codec,
  			   unsigned int reg, unsigned int val)
  {
  	dev_dbg(codec->dev, "write %x = %x
  ", reg, val);

  	trace_snd_soc_reg_write(codec, reg, val);

  	return codec->write(codec, reg, val);

  }
  EXPORT_SYMBOL_GPL(snd_soc_write);

  unsigned int snd_soc_bulk_write_raw(struct snd_soc_codec *codec,
  				    unsigned int reg, const void *data, size_t len)
  {
  	return codec->bulk_write_raw(codec, reg, data, len);
  }
  EXPORT_SYMBOL_GPL(snd_soc_bulk_write_raw);

  /**
   * snd_soc_update_bits - update codec register bits
   * @codec: audio codec
   * @reg: codec register
   * @mask: register mask
   * @value: new value
   *
   * Writes new register value.
   *

   * Returns 1 for change, 0 for no change, or negative error code.

   */
  int snd_soc_update_bits(struct snd_soc_codec *codec, unsigned short reg,

  				unsigned int mask, unsigned int value)

  {
  	int change;

  	unsigned int old, new;

  	int ret;
  
  	ret = snd_soc_read(codec, reg);
  	if (ret < 0)
  		return ret;

  	old = ret;

  	new = (old & ~mask) | (value & mask);

  	change = old != new;

  	if (change) {
  		ret = snd_soc_write(codec, reg, new);
  		if (ret < 0)
  			return ret;
  	}

  	return change;
  }
  EXPORT_SYMBOL_GPL(snd_soc_update_bits);
  
  /**

   * snd_soc_update_bits_locked - update codec register bits
   * @codec: audio codec
   * @reg: codec register
   * @mask: register mask
   * @value: new value
   *
   * Writes new register value, and takes the codec mutex.
   *
   * Returns 1 for change else 0.
   */

  int snd_soc_update_bits_locked(struct snd_soc_codec *codec,
  			       unsigned short reg, unsigned int mask,
  			       unsigned int value)

  {
  	int change;
  
  	mutex_lock(&codec->mutex);
  	change = snd_soc_update_bits(codec, reg, mask, value);
  	mutex_unlock(&codec->mutex);
  
  	return change;
  }

  EXPORT_SYMBOL_GPL(snd_soc_update_bits_locked);

  
  /**

   * snd_soc_test_bits - test register for change
   * @codec: audio codec
   * @reg: codec register
   * @mask: register mask
   * @value: new value
   *
   * Tests a register with a new value and checks if the new value is
   * different from the old value.
   *
   * Returns 1 for change else 0.
   */
  int snd_soc_test_bits(struct snd_soc_codec *codec, unsigned short reg,

  				unsigned int mask, unsigned int value)

  {
  	int change;

  	unsigned int old, new;

  	old = snd_soc_read(codec, reg);
  	new = (old & ~mask) | value;
  	change = old != new;

  
  	return change;
  }
  EXPORT_SYMBOL_GPL(snd_soc_test_bits);
  
  /**

   * snd_soc_set_runtime_hwparams - set the runtime hardware parameters
   * @substream: the pcm substream
   * @hw: the hardware parameters
   *
   * Sets the substream runtime hardware parameters.
   */
  int snd_soc_set_runtime_hwparams(struct snd_pcm_substream *substream,
  	const struct snd_pcm_hardware *hw)
  {
  	struct snd_pcm_runtime *runtime = substream->runtime;
  	runtime->hw.info = hw->info;
  	runtime->hw.formats = hw->formats;
  	runtime->hw.period_bytes_min = hw->period_bytes_min;
  	runtime->hw.period_bytes_max = hw->period_bytes_max;
  	runtime->hw.periods_min = hw->periods_min;
  	runtime->hw.periods_max = hw->periods_max;
  	runtime->hw.buffer_bytes_max = hw->buffer_bytes_max;
  	runtime->hw.fifo_size = hw->fifo_size;
  	return 0;
  }
  EXPORT_SYMBOL_GPL(snd_soc_set_runtime_hwparams);
  
  /**
   * snd_soc_cnew - create new control
   * @_template: control template
   * @data: control private data

   * @long_name: control long name

   * @prefix: control name prefix

   *
   * Create a new mixer control from a template control.
   *
   * Returns 0 for success, else error.
   */
  struct snd_kcontrol *snd_soc_cnew(const struct snd_kcontrol_new *_template,

  				  void *data, char *long_name,
  				  const char *prefix)

  {
  	struct snd_kcontrol_new template;

  	struct snd_kcontrol *kcontrol;
  	char *name = NULL;
  	int name_len;

  
  	memcpy(&template, _template, sizeof(template));

  	template.index = 0;

  	if (!long_name)
  		long_name = template.name;
  
  	if (prefix) {
  		name_len = strlen(long_name) + strlen(prefix) + 2;

  		name = kmalloc(name_len, GFP_KERNEL);

  		if (!name)
  			return NULL;
  
  		snprintf(name, name_len, "%s %s", prefix, long_name);
  
  		template.name = name;
  	} else {
  		template.name = long_name;
  	}
  
  	kcontrol = snd_ctl_new1(&template, data);
  
  	kfree(name);
  
  	return kcontrol;

  }
  EXPORT_SYMBOL_GPL(snd_soc_cnew);
  
  /**

   * snd_soc_add_controls - add an array of controls to a codec.
   * Convienience function to add a list of controls. Many codecs were
   * duplicating this code.
   *
   * @codec: codec to add controls to
   * @controls: array of controls to add
   * @num_controls: number of elements in the array
   *
   * Return 0 for success, else error.
   */
  int snd_soc_add_controls(struct snd_soc_codec *codec,
  	const struct snd_kcontrol_new *controls, int num_controls)
  {

  	struct snd_card *card = codec->card->snd_card;

  	int err, i;
  
  	for (i = 0; i < num_controls; i++) {
  		const struct snd_kcontrol_new *control = &controls[i];

  		err = snd_ctl_add(card, snd_soc_cnew(control, codec,
  						     control->name,
  						     codec->name_prefix));

  		if (err < 0) {

  			dev_err(codec->dev, "%s: Failed to add %s: %d
  ",

  				codec->name, control->name, err);

  			return err;
  		}
  	}
  
  	return 0;
  }
  EXPORT_SYMBOL_GPL(snd_soc_add_controls);
  
  /**

   * snd_soc_add_platform_controls - add an array of controls to a platform.
   * Convienience function to add a list of controls.
   *
   * @platform: platform to add controls to
   * @controls: array of controls to add
   * @num_controls: number of elements in the array
   *
   * Return 0 for success, else error.
   */
  int snd_soc_add_platform_controls(struct snd_soc_platform *platform,
  	const struct snd_kcontrol_new *controls, int num_controls)
  {
  	struct snd_card *card = platform->card->snd_card;
  	int err, i;
  
  	for (i = 0; i < num_controls; i++) {
  		const struct snd_kcontrol_new *control = &controls[i];
  		err = snd_ctl_add(card, snd_soc_cnew(control, platform,
  				control->name, NULL));
  		if (err < 0) {
  			dev_err(platform->dev, "Failed to add %s %d
  ",control->name, err);
  			return err;
  		}
  	}
  
  	return 0;
  }
  EXPORT_SYMBOL_GPL(snd_soc_add_platform_controls);
  
  /**

   * snd_soc_info_enum_double - enumerated double mixer info callback
   * @kcontrol: mixer control
   * @uinfo: control element information
   *
   * Callback to provide information about a double enumerated
   * mixer control.
   *
   * Returns 0 for success.
   */
  int snd_soc_info_enum_double(struct snd_kcontrol *kcontrol,
  	struct snd_ctl_elem_info *uinfo)
  {
  	struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
  
  	uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
  	uinfo->count = e->shift_l == e->shift_r ? 1 : 2;

  	uinfo->value.enumerated.items = e->max;

  	if (uinfo->value.enumerated.item > e->max - 1)
  		uinfo->value.enumerated.item = e->max - 1;

  	strcpy(uinfo->value.enumerated.name,
  		e->texts[uinfo->value.enumerated.item]);
  	return 0;
  }
  EXPORT_SYMBOL_GPL(snd_soc_info_enum_double);
  
  /**
   * snd_soc_get_enum_double - enumerated double mixer get callback
   * @kcontrol: mixer control

   * @ucontrol: control element information

   *
   * Callback to get the value of a double enumerated mixer.
   *
   * Returns 0 for success.
   */
  int snd_soc_get_enum_double(struct snd_kcontrol *kcontrol,
  	struct snd_ctl_elem_value *ucontrol)
  {
  	struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
  	struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;

  	unsigned int val, bitmask;

  	for (bitmask = 1; bitmask < e->max; bitmask <<= 1)

  		;
  	val = snd_soc_read(codec, e->reg);

  	ucontrol->value.enumerated.item[0]
  		= (val >> e->shift_l) & (bitmask - 1);

  	if (e->shift_l != e->shift_r)
  		ucontrol->value.enumerated.item[1] =
  			(val >> e->shift_r) & (bitmask - 1);
  
  	return 0;
  }
  EXPORT_SYMBOL_GPL(snd_soc_get_enum_double);
  
  /**
   * snd_soc_put_enum_double - enumerated double mixer put callback
   * @kcontrol: mixer control

   * @ucontrol: control element information

   *
   * Callback to set the value of a double enumerated mixer.
   *
   * Returns 0 for success.
   */
  int snd_soc_put_enum_double(struct snd_kcontrol *kcontrol,
  	struct snd_ctl_elem_value *ucontrol)
  {
  	struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
  	struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;

  	unsigned int val;
  	unsigned int mask, bitmask;