[deliverable/linux.git] / sound / soc / codecs / wm8728.c

/*
 * wm8728.c  --  WM8728 ALSA SoC Audio driver
 *
 * Copyright 2008 Wolfson Microelectronics plc
 *
 * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/pm.h>
#include <linux/i2c.h>
#include <linux/platform_device.h>
#include <linux/spi/spi.h>
#include <sound/core.h>
#include <sound/pcm.h>
#include <sound/pcm_params.h>
#include <sound/soc.h>
#include <sound/soc-dapm.h>
#include <sound/initval.h>
#include <sound/tlv.h>

#include "wm8728.h"

struct snd_soc_codec_device soc_codec_dev_wm8728;

/*
 * We can't read the WM8728 register space so we cache them instead.
 * Note that the defaults here aren't the physical defaults, we latch
 * the volume update bits, mute the output and enable infinite zero
 * detect.
 */
static const u16 wm8728_reg_defaults[] = {
	0x1ff,
	0x1ff,
	0x001,
	0x100,
};

static const DECLARE_TLV_DB_SCALE(wm8728_tlv, -12750, 50, 1);

static const struct snd_kcontrol_new wm8728_snd_controls[] = {

SOC_DOUBLE_R_TLV("Digital Playback Volume", WM8728_DACLVOL, WM8728_DACRVOL,
		 0, 255, 0, wm8728_tlv),

SOC_SINGLE("Deemphasis", WM8728_DACCTL, 1, 1, 0),
};

/*
 * DAPM controls.
 */
static const struct snd_soc_dapm_widget wm8728_dapm_widgets[] = {
SND_SOC_DAPM_DAC("DAC", "HiFi Playback", SND_SOC_NOPM, 0, 0),
SND_SOC_DAPM_OUTPUT("VOUTL"),
SND_SOC_DAPM_OUTPUT("VOUTR"),
};

static const struct snd_soc_dapm_route intercon[] = {
	{"VOUTL", NULL, "DAC"},
	{"VOUTR", NULL, "DAC"},
};

static int wm8728_add_widgets(struct snd_soc_codec *codec)
{
	snd_soc_dapm_new_controls(codec, wm8728_dapm_widgets,
				  ARRAY_SIZE(wm8728_dapm_widgets));

	snd_soc_dapm_add_routes(codec, intercon, ARRAY_SIZE(intercon));

	return 0;
}

static int wm8728_mute(struct snd_soc_dai *dai, int mute)
{
	struct snd_soc_codec *codec = dai->codec;
	u16 mute_reg = snd_soc_read(codec, WM8728_DACCTL);

	if (mute)
		snd_soc_write(codec, WM8728_DACCTL, mute_reg | 1);
	else
		snd_soc_write(codec, WM8728_DACCTL, mute_reg & ~1);

	return 0;
}

static int wm8728_hw_params(struct snd_pcm_substream *substream,
	struct snd_pcm_hw_params *params,
	struct snd_soc_dai *dai)
{
	struct snd_soc_pcm_runtime *rtd = substream->private_data;
	struct snd_soc_device *socdev = rtd->socdev;
	struct snd_soc_codec *codec = socdev->card->codec;
	u16 dac = snd_soc_read(codec, WM8728_DACCTL);

	dac &= ~0x18;

	switch (params_format(params)) {
	case SNDRV_PCM_FORMAT_S16_LE:
		break;
	case SNDRV_PCM_FORMAT_S20_3LE:
		dac |= 0x10;
		break;
	case SNDRV_PCM_FORMAT_S24_LE:
		dac |= 0x08;
		break;
	default:
		return -EINVAL;
	}

	snd_soc_write(codec, WM8728_DACCTL, dac);

	return 0;
}

static int wm8728_set_dai_fmt(struct snd_soc_dai *codec_dai,
		unsigned int fmt)
{
	struct snd_soc_codec *codec = codec_dai->codec;
	u16 iface = snd_soc_read(codec, WM8728_IFCTL);

	/* Currently only I2S is supported by the driver, though the
	 * hardware is more flexible.
	 */
	switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
	case SND_SOC_DAIFMT_I2S:
		iface |= 1;
		break;
	default:
		return -EINVAL;
	}

	/* The hardware only support full slave mode */
	switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
	case SND_SOC_DAIFMT_CBS_CFS:
		break;
	default:
		return -EINVAL;
	}

	switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
	case SND_SOC_DAIFMT_NB_NF:
		iface &= ~0x22;
		break;
	case SND_SOC_DAIFMT_IB_NF:
		iface |=  0x20;
		iface &= ~0x02;
		break;
	case SND_SOC_DAIFMT_NB_IF:
		iface |= 0x02;
		iface &= ~0x20;
		break;
	case SND_SOC_DAIFMT_IB_IF:
		iface |= 0x22;
		break;
	default:
		return -EINVAL;
	}

	snd_soc_write(codec, WM8728_IFCTL, iface);
	return 0;
}

static int wm8728_set_bias_level(struct snd_soc_codec *codec,
				 enum snd_soc_bias_level level)
{
	u16 reg;
	int i;

	switch (level) {
	case SND_SOC_BIAS_ON:
	case SND_SOC_BIAS_PREPARE:
	case SND_SOC_BIAS_STANDBY:
		if (codec->bias_level == SND_SOC_BIAS_OFF) {
			/* Power everything up... */
			reg = snd_soc_read(codec, WM8728_DACCTL);
			snd_soc_write(codec, WM8728_DACCTL, reg & ~0x4);

			/* ..then sync in the register cache. */
			for (i = 0; i < ARRAY_SIZE(wm8728_reg_defaults); i++)
				snd_soc_write(codec, i,
					     snd_soc_read(codec, i));
		}
		break;

	case SND_SOC_BIAS_OFF:
		reg = snd_soc_read(codec, WM8728_DACCTL);
		snd_soc_write(codec, WM8728_DACCTL, reg | 0x4);
		break;
	}
	codec->bias_level = level;
	return 0;
}

#define WM8728_RATES (SNDRV_PCM_RATE_8000_192000)

#define WM8728_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE |\
	SNDRV_PCM_FMTBIT_S24_LE)

static struct snd_soc_dai_ops wm8728_dai_ops = {
	.hw_params	= wm8728_hw_params,
	.digital_mute	= wm8728_mute,
	.set_fmt	= wm8728_set_dai_fmt,
};

struct snd_soc_dai wm8728_dai = {
	.name = "WM8728",
	.playback = {
		.stream_name = "Playback",
		.channels_min = 2,
		.channels_max = 2,
		.rates = WM8728_RATES,
		.formats = WM8728_FORMATS,
	},
	.ops = &wm8728_dai_ops,
};
EXPORT_SYMBOL_GPL(wm8728_dai);

static int wm8728_suspend(struct platform_device *pdev, pm_message_t state)
{
	struct snd_soc_device *socdev = platform_get_drvdata(pdev);
	struct snd_soc_codec *codec = socdev->card->codec;

	wm8728_set_bias_level(codec, SND_SOC_BIAS_OFF);

	return 0;
}

static int wm8728_resume(struct platform_device *pdev)
{
	struct snd_soc_device *socdev = platform_get_drvdata(pdev);
	struct snd_soc_codec *codec = socdev->card->codec;

	wm8728_set_bias_level(codec, codec->suspend_bias_level);

	return 0;
}

/*
 * initialise the WM8728 driver
 * register the mixer and dsp interfaces with the kernel
 */
static int wm8728_init(struct snd_soc_device *socdev,
		       enum snd_soc_control_type control)
{
	struct snd_soc_codec *codec = socdev->card->codec;
	int ret = 0;

	codec->name = "WM8728";
	codec->owner = THIS_MODULE;
	codec->set_bias_level = wm8728_set_bias_level;
	codec->dai = &wm8728_dai;
	codec->num_dai = 1;
	codec->bias_level = SND_SOC_BIAS_OFF;
	codec->reg_cache_size = ARRAY_SIZE(wm8728_reg_defaults);
	codec->reg_cache = kmemdup(wm8728_reg_defaults,
				   sizeof(wm8728_reg_defaults),
				   GFP_KERNEL);
	if (codec->reg_cache == NULL)
		return -ENOMEM;

	ret = snd_soc_codec_set_cache_io(codec, 7, 9, control);
	if (ret < 0) {
		printk(KERN_ERR "wm8728: failed to configure cache I/O: %d\n",
		       ret);
		goto err;
	}

	/* register pcms */
	ret = snd_soc_new_pcms(socdev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1);
	if (ret < 0) {
		printk(KERN_ERR "wm8728: failed to create pcms\n");
		goto err;
	}

	/* power on device */
	wm8728_set_bias_level(codec, SND_SOC_BIAS_STANDBY);

	snd_soc_add_controls(codec, wm8728_snd_controls,
				ARRAY_SIZE(wm8728_snd_controls));
	wm8728_add_widgets(codec);

	return ret;

err:
	kfree(codec->reg_cache);
	return ret;
}

static struct snd_soc_device *wm8728_socdev;

#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)

/*
 * WM8728 2 wire address is determined by GPIO5
 * state during powerup.
 *    low  = 0x1a
 *    high = 0x1b
 */

static int wm8728_i2c_probe(struct i2c_client *i2c,
			    const struct i2c_device_id *id)
{
	struct snd_soc_device *socdev = wm8728_socdev;
	struct snd_soc_codec *codec = socdev->card->codec;
	int ret;

	i2c_set_clientdata(i2c, codec);
	codec->control_data = i2c;

	ret = wm8728_init(socdev, SND_SOC_I2C);
	if (ret < 0)
		pr_err("failed to initialise WM8728\n");

	return ret;
}

static int wm8728_i2c_remove(struct i2c_client *client)
{
	struct snd_soc_codec *codec = i2c_get_clientdata(client);
	kfree(codec->reg_cache);
	return 0;
}

static const struct i2c_device_id wm8728_i2c_id[] = {
	{ "wm8728", 0 },
	{ }
};
MODULE_DEVICE_TABLE(i2c, wm8728_i2c_id);

static struct i2c_driver wm8728_i2c_driver = {
	.driver = {
		.name = "WM8728 I2C Codec",
		.owner = THIS_MODULE,
	},
	.probe =    wm8728_i2c_probe,
	.remove =   wm8728_i2c_remove,
	.id_table = wm8728_i2c_id,
};

static int wm8728_add_i2c_device(struct platform_device *pdev,
				 const struct wm8728_setup_data *setup)
{
	struct i2c_board_info info;
	struct i2c_adapter *adapter;
	struct i2c_client *client;
	int ret;

	ret = i2c_add_driver(&wm8728_i2c_driver);
	if (ret != 0) {
		dev_err(&pdev->dev, "can't add i2c driver\n");
		return ret;
	}

	memset(&info, 0, sizeof(struct i2c_board_info));
	info.addr = setup->i2c_address;
	strlcpy(info.type, "wm8728", I2C_NAME_SIZE);

	adapter = i2c_get_adapter(setup->i2c_bus);
	if (!adapter) {
		dev_err(&pdev->dev, "can't get i2c adapter %d\n",
			setup->i2c_bus);
		goto err_driver;
	}

	client = i2c_new_device(adapter, &info);
	i2c_put_adapter(adapter);
	if (!client) {
		dev_err(&pdev->dev, "can't add i2c device at 0x%x\n",
			(unsigned int)info.addr);
		goto err_driver;
	}

	return 0;

err_driver:
	i2c_del_driver(&wm8728_i2c_driver);
	return -ENODEV;
}
#endif

#if defined(CONFIG_SPI_MASTER)
static int __devinit wm8728_spi_probe(struct spi_device *spi)
{
	struct snd_soc_device *socdev = wm8728_socdev;
	struct snd_soc_codec *codec = socdev->card->codec;
	int ret;

	codec->control_data = spi;

	ret = wm8728_init(socdev, SND_SOC_SPI);
	if (ret < 0)
		dev_err(&spi->dev, "failed to initialise WM8728\n");

	return ret;
}

static int __devexit wm8728_spi_remove(struct spi_device *spi)
{
	return 0;
}

static struct spi_driver wm8728_spi_driver = {
	.driver = {
		.name	= "wm8728",
		.bus	= &spi_bus_type,
		.owner	= THIS_MODULE,
	},
	.probe		= wm8728_spi_probe,
	.remove		= __devexit_p(wm8728_spi_remove),
};
#endif /* CONFIG_SPI_MASTER */

static int wm8728_probe(struct platform_device *pdev)
{
	struct snd_soc_device *socdev = platform_get_drvdata(pdev);
	struct wm8728_setup_data *setup;
	struct snd_soc_codec *codec;
	int ret = 0;

	setup = socdev->codec_data;
	codec = kzalloc(sizeof(struct snd_soc_codec), GFP_KERNEL);
	if (codec == NULL)
		return -ENOMEM;

	socdev->card->codec = codec;
	mutex_init(&codec->mutex);
	INIT_LIST_HEAD(&codec->dapm_widgets);
	INIT_LIST_HEAD(&codec->dapm_paths);

	wm8728_socdev = socdev;
	ret = -ENODEV;

#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
	if (setup->i2c_address) {
		ret = wm8728_add_i2c_device(pdev, setup);
	}
#endif
#if defined(CONFIG_SPI_MASTER)
	if (setup->spi) {
		ret = spi_register_driver(&wm8728_spi_driver);
		if (ret != 0)
			printk(KERN_ERR "can't add spi driver");
	}
#endif

	if (ret != 0)
		kfree(codec);

	return ret;
}

/* power down chip */
static int wm8728_remove(struct platform_device *pdev)
{
	struct snd_soc_device *socdev = platform_get_drvdata(pdev);
	struct snd_soc_codec *codec = socdev->card->codec;

	if (codec->control_data)
		wm8728_set_bias_level(codec, SND_SOC_BIAS_OFF);

	snd_soc_free_pcms(socdev);
	snd_soc_dapm_free(socdev);
#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
	i2c_unregister_device(codec->control_data);
	i2c_del_driver(&wm8728_i2c_driver);
#endif
#if defined(CONFIG_SPI_MASTER)
	spi_unregister_driver(&wm8728_spi_driver);
#endif
	kfree(codec);

	return 0;
}

struct snd_soc_codec_device soc_codec_dev_wm8728 = {
	.probe = 	wm8728_probe,
	.remove = 	wm8728_remove,
	.suspend = 	wm8728_suspend,
	.resume =	wm8728_resume,
};
EXPORT_SYMBOL_GPL(soc_codec_dev_wm8728);

static int __init wm8728_modinit(void)
{
	return snd_soc_register_dai(&wm8728_dai);
}
module_init(wm8728_modinit);

static void __exit wm8728_exit(void)
{
	snd_soc_unregister_dai(&wm8728_dai);
}
module_exit(wm8728_exit);

MODULE_DESCRIPTION("ASoC WM8728 driver");
MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
MODULE_LICENSE("GPL");
Commit	Line	Data
71cfc902 MB	1	/*
	2	* wm8728.c -- WM8728 ALSA SoC Audio driver
	3	*
	4	* Copyright 2008 Wolfson Microelectronics plc
	5	*
	6	* Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
	7	*
	8	* This program is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License version 2 as
	10	* published by the Free Software Foundation.
	11	*/
	12
	13	#include <linux/module.h>
	14	#include <linux/moduleparam.h>
	15	#include <linux/init.h>
	16	#include <linux/delay.h>
	17	#include <linux/pm.h>
	18	#include <linux/i2c.h>
	19	#include <linux/platform_device.h>
	20	#include <linux/spi/spi.h>
	21	#include <sound/core.h>
	22	#include <sound/pcm.h>
	23	#include <sound/pcm_params.h>
	24	#include <sound/soc.h>
	25	#include <sound/soc-dapm.h>
	26	#include <sound/initval.h>
	27	#include <sound/tlv.h>
	28
	29	#include "wm8728.h"
	30
	31	struct snd_soc_codec_device soc_codec_dev_wm8728;
	32
	33	/*
	34	* We can't read the WM8728 register space so we cache them instead.
	35	* Note that the defaults here aren't the physical defaults, we latch
	36	* the volume update bits, mute the output and enable infinite zero
	37	* detect.
	38	*/
	39	static const u16 wm8728_reg_defaults[] = {
	40	0x1ff,
	41	0x1ff,
	42	0x001,
	43	0x100,
	44	};
	45
71cfc902 MB	46	static const DECLARE_TLV_DB_SCALE(wm8728_tlv, -12750, 50, 1);
	47
	48	static const struct snd_kcontrol_new wm8728_snd_controls[] = {
	49
	50	SOC_DOUBLE_R_TLV("Digital Playback Volume", WM8728_DACLVOL, WM8728_DACRVOL,
	51	0, 255, 0, wm8728_tlv),
	52
	53	SOC_SINGLE("Deemphasis", WM8728_DACCTL, 1, 1, 0),
	54	};
	55
71cfc902 MB	56	/*
	57	* DAPM controls.
	58	*/
	59	static const struct snd_soc_dapm_widget wm8728_dapm_widgets[] = {
	60	SND_SOC_DAPM_DAC("DAC", "HiFi Playback", SND_SOC_NOPM, 0, 0),
	61	SND_SOC_DAPM_OUTPUT("VOUTL"),
	62	SND_SOC_DAPM_OUTPUT("VOUTR"),
	63	};
	64
	65	static const struct snd_soc_dapm_route intercon[] = {
	66	{"VOUTL", NULL, "DAC"},
	67	{"VOUTR", NULL, "DAC"},
	68	};
	69
	70	static int wm8728_add_widgets(struct snd_soc_codec *codec)
	71	{
	72	snd_soc_dapm_new_controls(codec, wm8728_dapm_widgets,
	73	ARRAY_SIZE(wm8728_dapm_widgets));
	74
	75	snd_soc_dapm_add_routes(codec, intercon, ARRAY_SIZE(intercon));
	76
71cfc902 MB	77	return 0;
	78	}
	79
	80	static int wm8728_mute(struct snd_soc_dai *dai, int mute)
	81	{
	82	struct snd_soc_codec *codec = dai->codec;
17a52fd6	83	u16 mute_reg = snd_soc_read(codec, WM8728_DACCTL);
71cfc902 MB	84
71cfc902 MB	85	if (mute)
17a52fd6	86	snd_soc_write(codec, WM8728_DACCTL, mute_reg \| 1);
71cfc902	87	else
17a52fd6	88	snd_soc_write(codec, WM8728_DACCTL, mute_reg & ~1);
71cfc902 MB	89
	90	return 0;
	91	}
	92
	93	static int wm8728_hw_params(struct snd_pcm_substream *substream,
dee89c4d MB	94	struct snd_pcm_hw_params *params,
dee89c4d MB	95	struct snd_soc_dai *dai)
71cfc902 MB	96	{
	97	struct snd_soc_pcm_runtime *rtd = substream->private_data;
	98	struct snd_soc_device *socdev = rtd->socdev;
6627a653	99	struct snd_soc_codec *codec = socdev->card->codec;
17a52fd6	100	u16 dac = snd_soc_read(codec, WM8728_DACCTL);
71cfc902 MB	101
	102	dac &= ~0x18;
	103
	104	switch (params_format(params)) {
	105	case SNDRV_PCM_FORMAT_S16_LE:
	106	break;
	107	case SNDRV_PCM_FORMAT_S20_3LE:
	108	dac \|= 0x10;
	109	break;
	110	case SNDRV_PCM_FORMAT_S24_LE:
	111	dac \|= 0x08;
	112	break;
	113	default:
	114	return -EINVAL;
	115	}
	116
17a52fd6	117	snd_soc_write(codec, WM8728_DACCTL, dac);
71cfc902 MB	118
	119	return 0;
	120	}
	121
	122	static int wm8728_set_dai_fmt(struct snd_soc_dai *codec_dai,
	123	unsigned int fmt)
	124	{
	125	struct snd_soc_codec *codec = codec_dai->codec;
17a52fd6	126	u16 iface = snd_soc_read(codec, WM8728_IFCTL);
71cfc902 MB	127
	128	/* Currently only I2S is supported by the driver, though the
	129	* hardware is more flexible.
	130	*/
	131	switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
	132	case SND_SOC_DAIFMT_I2S:
	133	iface \|= 1;
	134	break;
	135	default:
	136	return -EINVAL;
	137	}
	138
	139	/* The hardware only support full slave mode */
	140	switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
	141	case SND_SOC_DAIFMT_CBS_CFS:
	142	break;
	143	default:
	144	return -EINVAL;
	145	}
	146
	147	switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
	148	case SND_SOC_DAIFMT_NB_NF:
	149	iface &= ~0x22;
	150	break;
	151	case SND_SOC_DAIFMT_IB_NF:
	152	iface \|= 0x20;
	153	iface &= ~0x02;
	154	break;
	155	case SND_SOC_DAIFMT_NB_IF:
	156	iface \|= 0x02;
	157	iface &= ~0x20;
	158	break;
	159	case SND_SOC_DAIFMT_IB_IF:
	160	iface \|= 0x22;
	161	break;
	162	default:
	163	return -EINVAL;
	164	}
	165
17a52fd6	166	snd_soc_write(codec, WM8728_IFCTL, iface);
71cfc902 MB	167	return 0;
	168	}
	169
	170	static int wm8728_set_bias_level(struct snd_soc_codec *codec,
	171	enum snd_soc_bias_level level)
	172	{
	173	u16 reg;
	174	int i;
	175
	176	switch (level) {
	177	case SND_SOC_BIAS_ON:
	178	case SND_SOC_BIAS_PREPARE:
	179	case SND_SOC_BIAS_STANDBY:
	180	if (codec->bias_level == SND_SOC_BIAS_OFF) {
	181	/* Power everything up... */
17a52fd6 MB	182	reg = snd_soc_read(codec, WM8728_DACCTL);
17a52fd6 MB	183	snd_soc_write(codec, WM8728_DACCTL, reg & ~0x4);
71cfc902 MB	184
	185	/* ..then sync in the register cache. */
	186	for (i = 0; i < ARRAY_SIZE(wm8728_reg_defaults); i++)
17a52fd6 MB	187	snd_soc_write(codec, i,
17a52fd6 MB	188	snd_soc_read(codec, i));
71cfc902 MB	189	}
	190	break;
	191
	192	case SND_SOC_BIAS_OFF:
17a52fd6 MB	193	reg = snd_soc_read(codec, WM8728_DACCTL);
17a52fd6 MB	194	snd_soc_write(codec, WM8728_DACCTL, reg \| 0x4);
71cfc902 MB	195	break;
	196	}
	197	codec->bias_level = level;
	198	return 0;
	199	}
	200
	201	#define WM8728_RATES (SNDRV_PCM_RATE_8000_192000)
	202
	203	#define WM8728_FORMATS (SNDRV_PCM_FMTBIT_S16_LE \| SNDRV_PCM_FMTBIT_S20_3LE \|\
	204	SNDRV_PCM_FMTBIT_S24_LE)
	205
6335d055 EM	206	static struct snd_soc_dai_ops wm8728_dai_ops = {
	207	.hw_params = wm8728_hw_params,
	208	.digital_mute = wm8728_mute,
	209	.set_fmt = wm8728_set_dai_fmt,
	210	};
	211
71cfc902 MB	212	struct snd_soc_dai wm8728_dai = {
	213	.name = "WM8728",
	214	.playback = {
	215	.stream_name = "Playback",
	216	.channels_min = 2,
	217	.channels_max = 2,
	218	.rates = WM8728_RATES,
	219	.formats = WM8728_FORMATS,
	220	},
6335d055	221	.ops = &wm8728_dai_ops,
71cfc902 MB	222	};
	223	EXPORT_SYMBOL_GPL(wm8728_dai);
	224
	225	static int wm8728_suspend(struct platform_device *pdev, pm_message_t state)
	226	{
	227	struct snd_soc_device *socdev = platform_get_drvdata(pdev);
6627a653	228	struct snd_soc_codec *codec = socdev->card->codec;
71cfc902 MB	229
	230	wm8728_set_bias_level(codec, SND_SOC_BIAS_OFF);
	231
	232	return 0;
	233	}
	234
	235	static int wm8728_resume(struct platform_device *pdev)
	236	{
	237	struct snd_soc_device *socdev = platform_get_drvdata(pdev);
6627a653	238	struct snd_soc_codec *codec = socdev->card->codec;
71cfc902 MB	239
	240	wm8728_set_bias_level(codec, codec->suspend_bias_level);
	241
	242	return 0;
	243	}
	244
	245	/*
	246	* initialise the WM8728 driver
	247	* register the mixer and dsp interfaces with the kernel
	248	*/
7084a42b MB	249	static int wm8728_init(struct snd_soc_device *socdev,
7084a42b MB	250	enum snd_soc_control_type control)
71cfc902	251	{
6627a653	252	struct snd_soc_codec *codec = socdev->card->codec;
71cfc902 MB	253	int ret = 0;
	254
	255	codec->name = "WM8728";
	256	codec->owner = THIS_MODULE;
71cfc902 MB	257	codec->set_bias_level = wm8728_set_bias_level;
	258	codec->dai = &wm8728_dai;
	259	codec->num_dai = 1;
	260	codec->bias_level = SND_SOC_BIAS_OFF;
	261	codec->reg_cache_size = ARRAY_SIZE(wm8728_reg_defaults);
	262	codec->reg_cache = kmemdup(wm8728_reg_defaults,
	263	sizeof(wm8728_reg_defaults),
	264	GFP_KERNEL);
	265	if (codec->reg_cache == NULL)
	266	return -ENOMEM;
	267
7084a42b	268	ret = snd_soc_codec_set_cache_io(codec, 7, 9, control);
17a52fd6 MB	269	if (ret < 0) {
	270	printk(KERN_ERR "wm8728: failed to configure cache I/O: %d\n",
	271	ret);
	272	goto err;
	273	}
	274
71cfc902 MB	275	/* register pcms */
	276	ret = snd_soc_new_pcms(socdev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1);
	277	if (ret < 0) {
	278	printk(KERN_ERR "wm8728: failed to create pcms\n");
17a52fd6	279	goto err;
71cfc902 MB	280	}
	281
	282	/* power on device */
	283	wm8728_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
	284
3e8e1952 IM	285	snd_soc_add_controls(codec, wm8728_snd_controls,
3e8e1952 IM	286	ARRAY_SIZE(wm8728_snd_controls));
71cfc902	287	wm8728_add_widgets(codec);
71cfc902 MB	288
	289	return ret;
	290
17a52fd6	291	err:
71cfc902 MB	292	kfree(codec->reg_cache);
	293	return ret;
	294	}
	295
	296	static struct snd_soc_device *wm8728_socdev;
	297
	298	#if defined(CONFIG_I2C) \|\| defined(CONFIG_I2C_MODULE)
	299
	300	/*
	301	* WM8728 2 wire address is determined by GPIO5
	302	* state during powerup.
	303	* low = 0x1a
	304	* high = 0x1b
	305	*/
	306
	307	static int wm8728_i2c_probe(struct i2c_client *i2c,
	308	const struct i2c_device_id *id)
	309	{
	310	struct snd_soc_device *socdev = wm8728_socdev;
6627a653	311	struct snd_soc_codec *codec = socdev->card->codec;
71cfc902 MB	312	int ret;
	313
	314	i2c_set_clientdata(i2c, codec);
	315	codec->control_data = i2c;
	316
7084a42b	317	ret = wm8728_init(socdev, SND_SOC_I2C);
71cfc902 MB	318	if (ret < 0)
	319	pr_err("failed to initialise WM8728\n");
	320
	321	return ret;
	322	}
	323
	324	static int wm8728_i2c_remove(struct i2c_client *client)
	325	{
	326	struct snd_soc_codec *codec = i2c_get_clientdata(client);
	327	kfree(codec->reg_cache);
	328	return 0;
	329	}
	330
	331	static const struct i2c_device_id wm8728_i2c_id[] = {
	332	{ "wm8728", 0 },
	333	{ }
	334	};
	335	MODULE_DEVICE_TABLE(i2c, wm8728_i2c_id);
	336
	337	static struct i2c_driver wm8728_i2c_driver = {
	338	.driver = {
	339	.name = "WM8728 I2C Codec",
	340	.owner = THIS_MODULE,
	341	},
	342	.probe = wm8728_i2c_probe,
	343	.remove = wm8728_i2c_remove,
	344	.id_table = wm8728_i2c_id,
	345	};
	346
	347	static int wm8728_add_i2c_device(struct platform_device *pdev,
	348	const struct wm8728_setup_data *setup)
	349	{
	350	struct i2c_board_info info;
	351	struct i2c_adapter *adapter;
	352	struct i2c_client *client;
	353	int ret;
	354
	355	ret = i2c_add_driver(&wm8728_i2c_driver);
	356	if (ret != 0) {
	357	dev_err(&pdev->dev, "can't add i2c driver\n");
	358	return ret;
	359	}
	360
	361	memset(&info, 0, sizeof(struct i2c_board_info));
	362	info.addr = setup->i2c_address;
	363	strlcpy(info.type, "wm8728", I2C_NAME_SIZE);
	364
	365	adapter = i2c_get_adapter(setup->i2c_bus);
	366	if (!adapter) {
	367	dev_err(&pdev->dev, "can't get i2c adapter %d\n",
	368	setup->i2c_bus);
	369	goto err_driver;
	370	}
	371
	372	client = i2c_new_device(adapter, &info);
	373	i2c_put_adapter(adapter);
	374	if (!client) {
	375	dev_err(&pdev->dev, "can't add i2c device at 0x%x\n",
	376	(unsigned int)info.addr);
	377	goto err_driver;
	378	}
	379
	380	return 0;
	381
382	err_driver:
383	i2c_del_driver(&wm8728_i2c_driver);
384	return -ENODEV;
385	}
386	#endif
387
388	#if defined(CONFIG_SPI_MASTER)
389	static int __devinit wm8728_spi_probe(struct spi_device *spi)
390	{
391	struct snd_soc_device *socdev = wm8728_socdev;
6627a653	392	struct snd_soc_codec *codec = socdev->card->codec;
71cfc902 MB	393	int ret;
	394
	395	codec->control_data = spi;
	396
7084a42b	397	ret = wm8728_init(socdev, SND_SOC_SPI);
71cfc902 MB	398	if (ret < 0)
	399	dev_err(&spi->dev, "failed to initialise WM8728\n");
	400
	401	return ret;
	402	}
	403
	404	static int __devexit wm8728_spi_remove(struct spi_device *spi)
	405	{
	406	return 0;
	407	}
	408
	409	static struct spi_driver wm8728_spi_driver = {
	410	.driver = {
	411	.name = "wm8728",
	412	.bus = &spi_bus_type,
	413	.owner = THIS_MODULE,
	414	},
	415	.probe = wm8728_spi_probe,
	416	.remove = __devexit_p(wm8728_spi_remove),
	417	};
71cfc902 MB	418	#endif /* CONFIG_SPI_MASTER */
	419
	420	static int wm8728_probe(struct platform_device *pdev)
	421	{
	422	struct snd_soc_device *socdev = platform_get_drvdata(pdev);
	423	struct wm8728_setup_data *setup;
	424	struct snd_soc_codec *codec;
	425	int ret = 0;
	426
	427	setup = socdev->codec_data;
	428	codec = kzalloc(sizeof(struct snd_soc_codec), GFP_KERNEL);
	429	if (codec == NULL)
	430	return -ENOMEM;
	431
6627a653	432	socdev->card->codec = codec;
71cfc902 MB	433	mutex_init(&codec->mutex);
	434	INIT_LIST_HEAD(&codec->dapm_widgets);
	435	INIT_LIST_HEAD(&codec->dapm_paths);
	436
	437	wm8728_socdev = socdev;
	438	ret = -ENODEV;
	439
	440	#if defined(CONFIG_I2C) \|\| defined(CONFIG_I2C_MODULE)
	441	if (setup->i2c_address) {
71cfc902 MB	442	ret = wm8728_add_i2c_device(pdev, setup);
	443	}
	444	#endif
	445	#if defined(CONFIG_SPI_MASTER)
	446	if (setup->spi) {
71cfc902 MB	447	ret = spi_register_driver(&wm8728_spi_driver);
	448	if (ret != 0)
	449	printk(KERN_ERR "can't add spi driver");
	450	}
	451	#endif
	452
	453	if (ret != 0)
	454	kfree(codec);
	455
	456	return ret;
	457	}
	458
	459	/* power down chip */
	460	static int wm8728_remove(struct platform_device *pdev)
	461	{
	462	struct snd_soc_device *socdev = platform_get_drvdata(pdev);
6627a653	463	struct snd_soc_codec *codec = socdev->card->codec;
71cfc902 MB	464
	465	if (codec->control_data)
	466	wm8728_set_bias_level(codec, SND_SOC_BIAS_OFF);
	467
	468	snd_soc_free_pcms(socdev);
	469	snd_soc_dapm_free(socdev);
	470	#if defined(CONFIG_I2C) \|\| defined(CONFIG_I2C_MODULE)
	471	i2c_unregister_device(codec->control_data);
	472	i2c_del_driver(&wm8728_i2c_driver);
	473	#endif
	474	#if defined(CONFIG_SPI_MASTER)
	475	spi_unregister_driver(&wm8728_spi_driver);
	476	#endif
	477	kfree(codec);
	478
	479	return 0;
	480	}
	481
	482	struct snd_soc_codec_device soc_codec_dev_wm8728 = {
	483	.probe = wm8728_probe,
	484	.remove = wm8728_remove,
	485	.suspend = wm8728_suspend,
	486	.resume = wm8728_resume,
	487	};
	488	EXPORT_SYMBOL_GPL(soc_codec_dev_wm8728);
	489
c9b3a40f	490	static int __init wm8728_modinit(void)
64089b84 MB	491	{
	492	return snd_soc_register_dai(&wm8728_dai);
	493	}
	494	module_init(wm8728_modinit);
	495
	496	static void __exit wm8728_exit(void)
	497	{
	498	snd_soc_unregister_dai(&wm8728_dai);
	499	}
	500	module_exit(wm8728_exit);
	501
71cfc902 MB	502	MODULE_DESCRIPTION("ASoC WM8728 driver");
	503	MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
	504	MODULE_LICENSE("GPL");