[GitHub/mt8127/android_kernel_alcatel_ttab.git] / sound / soc / codecs / wm8776.c

/*
 * wm8776.c  --  WM8776 ALSA SoC Audio driver
 *
 * Copyright 2009-12 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.
 *
 * TODO: Input ALC/limiter support
 */

#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/of_device.h>
#include <linux/regmap.h>
#include <linux/spi/spi.h>
#include <linux/slab.h>
#include <sound/core.h>
#include <sound/pcm.h>
#include <sound/pcm_params.h>
#include <sound/soc.h>
#include <sound/initval.h>
#include <sound/tlv.h>

#include "wm8776.h"

enum wm8776_chip_type {
	WM8775 = 1,
	WM8776,
};

/* codec private data */
struct wm8776_priv {
	struct regmap *regmap;
	int sysclk[2];
};

static const struct reg_default wm8776_reg_defaults[] = {
	{  0, 0x79 },
	{  1, 0x79 },
	{  2, 0x79 },
	{  3, 0xff },
	{  4, 0xff },
	{  5, 0xff },
	{  6, 0x00 },
	{  7, 0x90 },
	{  8, 0x00 },
	{  9, 0x00 },
	{ 10, 0x22 },
	{ 11, 0x22 },
	{ 12, 0x22 },
	{ 13, 0x08 },
	{ 14, 0xcf },
	{ 15, 0xcf },
	{ 16, 0x7b },
	{ 17, 0x00 },
	{ 18, 0x32 },
	{ 19, 0x00 },
	{ 20, 0xa6 },
	{ 21, 0x01 },
	{ 22, 0x01 },
};

static bool wm8776_volatile(struct device *dev, unsigned int reg)
{
	switch (reg) {
	case WM8776_RESET:
		return true;
	default:
		return false;
	}
}

static int wm8776_reset(struct snd_soc_codec *codec)
{
	return snd_soc_write(codec, WM8776_RESET, 0);
}

static const DECLARE_TLV_DB_SCALE(hp_tlv, -12100, 100, 1);
static const DECLARE_TLV_DB_SCALE(dac_tlv, -12750, 50, 1);
static const DECLARE_TLV_DB_SCALE(adc_tlv, -10350, 50, 1);

static const struct snd_kcontrol_new wm8776_snd_controls[] = {
SOC_DOUBLE_R_TLV("Headphone Playback Volume", WM8776_HPLVOL, WM8776_HPRVOL,
		 0, 127, 0, hp_tlv),
SOC_DOUBLE_R_TLV("Digital Playback Volume", WM8776_DACLVOL, WM8776_DACRVOL,
		 0, 255, 0, dac_tlv),
SOC_SINGLE("Digital Playback ZC Switch", WM8776_DACCTRL1, 0, 1, 0),

SOC_SINGLE("Deemphasis Switch", WM8776_DACCTRL2, 0, 1, 0),

SOC_DOUBLE_R_TLV("Capture Volume", WM8776_ADCLVOL, WM8776_ADCRVOL,
		 0, 255, 0, adc_tlv),
SOC_DOUBLE("Capture Switch", WM8776_ADCMUX, 7, 6, 1, 1),
SOC_DOUBLE_R("Capture ZC Switch", WM8776_ADCLVOL, WM8776_ADCRVOL, 8, 1, 0),
SOC_SINGLE("Capture HPF Switch", WM8776_ADCIFCTRL, 8, 1, 1),
};

static const struct snd_kcontrol_new inmix_controls[] = {
SOC_DAPM_SINGLE("AIN1 Switch", WM8776_ADCMUX, 0, 1, 0),
SOC_DAPM_SINGLE("AIN2 Switch", WM8776_ADCMUX, 1, 1, 0),
SOC_DAPM_SINGLE("AIN3 Switch", WM8776_ADCMUX, 2, 1, 0),
SOC_DAPM_SINGLE("AIN4 Switch", WM8776_ADCMUX, 3, 1, 0),
SOC_DAPM_SINGLE("AIN5 Switch", WM8776_ADCMUX, 4, 1, 0),
};

static const struct snd_kcontrol_new outmix_controls[] = {
SOC_DAPM_SINGLE("DAC Switch", WM8776_OUTMUX, 0, 1, 0),
SOC_DAPM_SINGLE("AUX Switch", WM8776_OUTMUX, 1, 1, 0),
SOC_DAPM_SINGLE("Bypass Switch", WM8776_OUTMUX, 2, 1, 0),
};

static const struct snd_soc_dapm_widget wm8776_dapm_widgets[] = {
SND_SOC_DAPM_INPUT("AUX"),

SND_SOC_DAPM_INPUT("AIN1"),
SND_SOC_DAPM_INPUT("AIN2"),
SND_SOC_DAPM_INPUT("AIN3"),
SND_SOC_DAPM_INPUT("AIN4"),
SND_SOC_DAPM_INPUT("AIN5"),

SND_SOC_DAPM_MIXER("Input Mixer", WM8776_PWRDOWN, 6, 1,
		   inmix_controls, ARRAY_SIZE(inmix_controls)),

SND_SOC_DAPM_ADC("ADC", "Capture", WM8776_PWRDOWN, 1, 1),
SND_SOC_DAPM_DAC("DAC", "Playback", WM8776_PWRDOWN, 2, 1),

SND_SOC_DAPM_MIXER("Output Mixer", SND_SOC_NOPM, 0, 0,
		   outmix_controls, ARRAY_SIZE(outmix_controls)),

SND_SOC_DAPM_PGA("Headphone PGA", WM8776_PWRDOWN, 3, 1, NULL, 0),

SND_SOC_DAPM_OUTPUT("VOUT"),

SND_SOC_DAPM_OUTPUT("HPOUTL"),
SND_SOC_DAPM_OUTPUT("HPOUTR"),
};

static const struct snd_soc_dapm_route routes[] = {
	{ "Input Mixer", "AIN1 Switch", "AIN1" },
	{ "Input Mixer", "AIN2 Switch", "AIN2" },
	{ "Input Mixer", "AIN3 Switch", "AIN3" },
	{ "Input Mixer", "AIN4 Switch", "AIN4" },
	{ "Input Mixer", "AIN5 Switch", "AIN5" },

	{ "ADC", NULL, "Input Mixer" },

	{ "Output Mixer", "DAC Switch", "DAC" },
	{ "Output Mixer", "AUX Switch", "AUX" },
	{ "Output Mixer", "Bypass Switch", "Input Mixer" },

	{ "VOUT", NULL, "Output Mixer" },

	{ "Headphone PGA", NULL, "Output Mixer" },

	{ "HPOUTL", NULL, "Headphone PGA" },
	{ "HPOUTR", NULL, "Headphone PGA" },
};

static int wm8776_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)
{
	struct snd_soc_codec *codec = dai->codec;
	int reg, iface, master;

	switch (dai->driver->id) {
	case WM8776_DAI_DAC:
		reg = WM8776_DACIFCTRL;
		master = 0x80;
		break;
	case WM8776_DAI_ADC:
		reg = WM8776_ADCIFCTRL;
		master = 0x100;
		break;
	default:
		return -EINVAL;
	}

	iface = 0;

	switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
	case SND_SOC_DAIFMT_CBM_CFM:
		break;
	case SND_SOC_DAIFMT_CBS_CFS:
		master = 0;
		break;
	default:
		return -EINVAL;
	}

	switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
	case SND_SOC_DAIFMT_I2S:
		iface |= 0x0002;
		break;
	case SND_SOC_DAIFMT_RIGHT_J:
		break;
	case SND_SOC_DAIFMT_LEFT_J:
		iface |= 0x0001;
		break;
	default:
		return -EINVAL;
	}

	switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
	case SND_SOC_DAIFMT_NB_NF:
		break;
	case SND_SOC_DAIFMT_IB_IF:
		iface |= 0x00c;
		break;
	case SND_SOC_DAIFMT_IB_NF:
		iface |= 0x008;
		break;
	case SND_SOC_DAIFMT_NB_IF:
		iface |= 0x004;
		break;
	default:
		return -EINVAL;
	}

	/* Finally, write out the values */
	snd_soc_update_bits(codec, reg, 0xf, iface);
	snd_soc_update_bits(codec, WM8776_MSTRCTRL, 0x180, master);

	return 0;
}

static int mclk_ratios[] = {
	128,
	192,
	256,
	384,
	512,
	768,
};

static int wm8776_hw_params(struct snd_pcm_substream *substream,
			    struct snd_pcm_hw_params *params,
			    struct snd_soc_dai *dai)
{
	struct snd_soc_codec *codec = dai->codec;
	struct wm8776_priv *wm8776 = snd_soc_codec_get_drvdata(codec);
	int iface_reg, iface;
	int ratio_shift, master;
	int i;

	switch (dai->driver->id) {
	case WM8776_DAI_DAC:
		iface_reg = WM8776_DACIFCTRL;
		master = 0x80;
		ratio_shift = 4;
		break;
	case WM8776_DAI_ADC:
		iface_reg = WM8776_ADCIFCTRL;
		master = 0x100;
		ratio_shift = 0;
		break;
	default:
		return -EINVAL;
	}

	/* Set word length */
	switch (snd_pcm_format_width(params_format(params))) {
	case 16:
		iface = 0;
		break;
	case 20:
		iface = 0x10;
		break;
	case 24:
		iface = 0x20;
		break;
	case 32:
		iface = 0x30;
		break;
	default:
		dev_err(codec->dev, "Unsupported sample size: %i\n",
			snd_pcm_format_width(params_format(params)));
		return -EINVAL;
	}

	/* Only need to set MCLK/LRCLK ratio if we're master */
	if (snd_soc_read(codec, WM8776_MSTRCTRL) & master) {
		for (i = 0; i < ARRAY_SIZE(mclk_ratios); i++) {
			if (wm8776->sysclk[dai->driver->id] / params_rate(params)
			    == mclk_ratios[i])
				break;
		}

		if (i == ARRAY_SIZE(mclk_ratios)) {
			dev_err(codec->dev,
				"Unable to configure MCLK ratio %d/%d\n",
				wm8776->sysclk[dai->driver->id], params_rate(params));
			return -EINVAL;
		}

		dev_dbg(codec->dev, "MCLK is %dfs\n", mclk_ratios[i]);

		snd_soc_update_bits(codec, WM8776_MSTRCTRL,
				    0x7 << ratio_shift, i << ratio_shift);
	} else {
		dev_dbg(codec->dev, "DAI in slave mode\n");
	}

	snd_soc_update_bits(codec, iface_reg, 0x30, iface);

	return 0;
}

static int wm8776_mute(struct snd_soc_dai *dai, int mute)
{
	struct snd_soc_codec *codec = dai->codec;

	return snd_soc_write(codec, WM8776_DACMUTE, !!mute);
}

static int wm8776_set_sysclk(struct snd_soc_dai *dai,
			     int clk_id, unsigned int freq, int dir)
{
	struct snd_soc_codec *codec = dai->codec;
	struct wm8776_priv *wm8776 = snd_soc_codec_get_drvdata(codec);

	BUG_ON(dai->driver->id >= ARRAY_SIZE(wm8776->sysclk));

	wm8776->sysclk[dai->driver->id] = freq;

	return 0;
}

static int wm8776_set_bias_level(struct snd_soc_codec *codec,
				 enum snd_soc_bias_level level)
{
	struct wm8776_priv *wm8776 = snd_soc_codec_get_drvdata(codec);

	switch (level) {
	case SND_SOC_BIAS_ON:
		break;
	case SND_SOC_BIAS_PREPARE:
		break;
	case SND_SOC_BIAS_STANDBY:
		if (codec->dapm.bias_level == SND_SOC_BIAS_OFF) {
			regcache_sync(wm8776->regmap);

			/* Disable the global powerdown; DAPM does the rest */
			snd_soc_update_bits(codec, WM8776_PWRDOWN, 1, 0);
		}

		break;
	case SND_SOC_BIAS_OFF:
		snd_soc_update_bits(codec, WM8776_PWRDOWN, 1, 1);
		break;
	}

	codec->dapm.bias_level = level;
	return 0;
}

#define WM8776_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE |\
			SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S32_LE)

static const struct snd_soc_dai_ops wm8776_dac_ops = {
	.digital_mute	= wm8776_mute,
	.hw_params      = wm8776_hw_params,
	.set_fmt        = wm8776_set_fmt,
	.set_sysclk     = wm8776_set_sysclk,
};

static const struct snd_soc_dai_ops wm8776_adc_ops = {
	.hw_params      = wm8776_hw_params,
	.set_fmt        = wm8776_set_fmt,
	.set_sysclk     = wm8776_set_sysclk,
};

static struct snd_soc_dai_driver wm8776_dai[] = {
	{
		.name = "wm8776-hifi-playback",
		.id	= WM8776_DAI_DAC,
		.playback = {
			.stream_name = "Playback",
			.channels_min = 2,
			.channels_max = 2,
			.rates = SNDRV_PCM_RATE_CONTINUOUS,
			.rate_min = 32000,
			.rate_max = 192000,
			.formats = WM8776_FORMATS,
		},
		.ops = &wm8776_dac_ops,
	},
	{
		.name = "wm8776-hifi-capture",
		.id	= WM8776_DAI_ADC,
		.capture = {
			.stream_name = "Capture",
			.channels_min = 2,
			.channels_max = 2,
			.rates = SNDRV_PCM_RATE_CONTINUOUS,
			.rate_min = 32000,
			.rate_max = 96000,
			.formats = WM8776_FORMATS,
		},
		.ops = &wm8776_adc_ops,
	},
};

#ifdef CONFIG_PM
static int wm8776_suspend(struct snd_soc_codec *codec)
{
	wm8776_set_bias_level(codec, SND_SOC_BIAS_OFF);

	return 0;
}

static int wm8776_resume(struct snd_soc_codec *codec)
{
	wm8776_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
	return 0;
}
#else
#define wm8776_suspend NULL
#define wm8776_resume NULL
#endif

static int wm8776_probe(struct snd_soc_codec *codec)
{
	int ret = 0;

	ret = snd_soc_codec_set_cache_io(codec, 7, 9, SND_SOC_REGMAP);
	if (ret < 0) {
		dev_err(codec->dev, "Failed to set cache I/O: %d\n", ret);
		return ret;
	}

	ret = wm8776_reset(codec);
	if (ret < 0) {
		dev_err(codec->dev, "Failed to issue reset: %d\n", ret);
		return ret;
	}

	wm8776_set_bias_level(codec, SND_SOC_BIAS_STANDBY);

	/* Latch the update bits; right channel only since we always
	 * update both. */
	snd_soc_update_bits(codec, WM8776_HPRVOL, 0x100, 0x100);
	snd_soc_update_bits(codec, WM8776_DACRVOL, 0x100, 0x100);

	return ret;
}

/* power down chip */
static int wm8776_remove(struct snd_soc_codec *codec)
{
	wm8776_set_bias_level(codec, SND_SOC_BIAS_OFF);
	return 0;
}

static struct snd_soc_codec_driver soc_codec_dev_wm8776 = {
	.probe = 	wm8776_probe,
	.remove = 	wm8776_remove,
	.suspend = 	wm8776_suspend,
	.resume =	wm8776_resume,
	.set_bias_level = wm8776_set_bias_level,

	.controls = wm8776_snd_controls,
	.num_controls = ARRAY_SIZE(wm8776_snd_controls),
	.dapm_widgets = wm8776_dapm_widgets,
	.num_dapm_widgets = ARRAY_SIZE(wm8776_dapm_widgets),
	.dapm_routes = routes,
	.num_dapm_routes = ARRAY_SIZE(routes),
};

static const struct of_device_id wm8776_of_match[] = {
	{ .compatible = "wlf,wm8776", },
	{ }
};
MODULE_DEVICE_TABLE(of, wm8776_of_match);

static const struct regmap_config wm8776_regmap = {
	.reg_bits = 7,
	.val_bits = 9,
	.max_register = WM8776_RESET,

	.reg_defaults = wm8776_reg_defaults,
	.num_reg_defaults = ARRAY_SIZE(wm8776_reg_defaults),
	.cache_type = REGCACHE_RBTREE,

	.volatile_reg = wm8776_volatile,
};

#if defined(CONFIG_SPI_MASTER)
static int wm8776_spi_probe(struct spi_device *spi)
{
	struct wm8776_priv *wm8776;
	int ret;

	wm8776 = devm_kzalloc(&spi->dev, sizeof(struct wm8776_priv),
			      GFP_KERNEL);
	if (wm8776 == NULL)
		return -ENOMEM;

	wm8776->regmap = devm_regmap_init_spi(spi, &wm8776_regmap);
	if (IS_ERR(wm8776->regmap))
		return PTR_ERR(wm8776->regmap);

	spi_set_drvdata(spi, wm8776);

	ret = snd_soc_register_codec(&spi->dev,
			&soc_codec_dev_wm8776, wm8776_dai, ARRAY_SIZE(wm8776_dai));

	return ret;
}

static int wm8776_spi_remove(struct spi_device *spi)
{
	snd_soc_unregister_codec(&spi->dev);
	return 0;
}

static struct spi_driver wm8776_spi_driver = {
	.driver = {
		.name	= "wm8776",
		.owner	= THIS_MODULE,
		.of_match_table = wm8776_of_match,
	},
	.probe		= wm8776_spi_probe,
	.remove		= wm8776_spi_remove,
};
#endif /* CONFIG_SPI_MASTER */

#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
static int wm8776_i2c_probe(struct i2c_client *i2c,
			    const struct i2c_device_id *id)
{
	struct wm8776_priv *wm8776;
	int ret;

	wm8776 = devm_kzalloc(&i2c->dev, sizeof(struct wm8776_priv),
			      GFP_KERNEL);
	if (wm8776 == NULL)
		return -ENOMEM;

	wm8776->regmap = devm_regmap_init_i2c(i2c, &wm8776_regmap);
	if (IS_ERR(wm8776->regmap))
		return PTR_ERR(wm8776->regmap);

	i2c_set_clientdata(i2c, wm8776);

	ret =  snd_soc_register_codec(&i2c->dev,
			&soc_codec_dev_wm8776, wm8776_dai, ARRAY_SIZE(wm8776_dai));

	return ret;
}

static int wm8776_i2c_remove(struct i2c_client *client)
{
	snd_soc_unregister_codec(&client->dev);
	return 0;
}

static const struct i2c_device_id wm8776_i2c_id[] = {
	{ "wm8775", WM8775 },
	{ "wm8776", WM8776 },
	{ }
};
MODULE_DEVICE_TABLE(i2c, wm8776_i2c_id);

static struct i2c_driver wm8776_i2c_driver = {
	.driver = {
		.name = "wm8776",
		.owner = THIS_MODULE,
		.of_match_table = wm8776_of_match,
	},
	.probe =    wm8776_i2c_probe,
	.remove =   wm8776_i2c_remove,
	.id_table = wm8776_i2c_id,
};
#endif

static int __init wm8776_modinit(void)
{
	int ret = 0;
#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
	ret = i2c_add_driver(&wm8776_i2c_driver);
	if (ret != 0) {
		printk(KERN_ERR "Failed to register wm8776 I2C driver: %d\n",
		       ret);
	}
#endif
#if defined(CONFIG_SPI_MASTER)
	ret = spi_register_driver(&wm8776_spi_driver);
	if (ret != 0) {
		printk(KERN_ERR "Failed to register wm8776 SPI driver: %d\n",
		       ret);
	}
#endif
	return ret;
}
module_init(wm8776_modinit);

static void __exit wm8776_exit(void)
{
#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
	i2c_del_driver(&wm8776_i2c_driver);
#endif
#if defined(CONFIG_SPI_MASTER)
	spi_unregister_driver(&wm8776_spi_driver);
#endif
}
module_exit(wm8776_exit);

MODULE_DESCRIPTION("ASoC WM8776 driver");
MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
MODULE_LICENSE("GPL");
Commit	Line	Data
924914ee MB	1	/*
	2	* wm8776.c -- WM8776 ALSA SoC Audio driver
	3	*
656baaeb	4	* Copyright 2009-12 Wolfson Microelectronics plc
924914ee MB	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	* TODO: Input ALC/limiter support
	13	*/
	14
	15	#include <linux/module.h>
	16	#include <linux/moduleparam.h>
	17	#include <linux/init.h>
	18	#include <linux/delay.h>
	19	#include <linux/pm.h>
	20	#include <linux/i2c.h>
b6de4315	21	#include <linux/of_device.h>
2cbde7ab	22	#include <linux/regmap.h>
924914ee	23	#include <linux/spi/spi.h>
5a0e3ad6	24	#include <linux/slab.h>
924914ee MB	25	#include <sound/core.h>
	26	#include <sound/pcm.h>
	27	#include <sound/pcm_params.h>
	28	#include <sound/soc.h>
924914ee MB	29	#include <sound/initval.h>
	30	#include <sound/tlv.h>
	31
	32	#include "wm8776.h"
	33
fdd48f9d MB	34	enum wm8776_chip_type {
	35	WM8775 = 1,
	36	WM8776,
	37	};
	38
924914ee MB	39	/* codec private data */
924914ee MB	40	struct wm8776_priv {
2cbde7ab	41	struct regmap *regmap;
924914ee MB	42	int sysclk[2];
	43	};
	44
2cbde7ab MB	45	static const struct reg_default wm8776_reg_defaults[] = {
	46	{ 0, 0x79 },
	47	{ 1, 0x79 },
	48	{ 2, 0x79 },
	49	{ 3, 0xff },
	50	{ 4, 0xff },
	51	{ 5, 0xff },
	52	{ 6, 0x00 },
	53	{ 7, 0x90 },
	54	{ 8, 0x00 },
	55	{ 9, 0x00 },
	56	{ 10, 0x22 },
	57	{ 11, 0x22 },
	58	{ 12, 0x22 },
	59	{ 13, 0x08 },
	60	{ 14, 0xcf },
	61	{ 15, 0xcf },
	62	{ 16, 0x7b },
	63	{ 17, 0x00 },
	64	{ 18, 0x32 },
	65	{ 19, 0x00 },
	66	{ 20, 0xa6 },
	67	{ 21, 0x01 },
	68	{ 22, 0x01 },
924914ee MB	69	};
924914ee MB	70
2cbde7ab MB	71	static bool wm8776_volatile(struct device *dev, unsigned int reg)
	72	{
	73	switch (reg) {
	74	case WM8776_RESET:
	75	return true;
	76	default:
	77	return false;
	78	}
	79	}
	80
924914ee MB	81	static int wm8776_reset(struct snd_soc_codec *codec)
924914ee MB	82	{
35b1207b	83	return snd_soc_write(codec, WM8776_RESET, 0);
924914ee MB	84	}
	85
	86	static const DECLARE_TLV_DB_SCALE(hp_tlv, -12100, 100, 1);
	87	static const DECLARE_TLV_DB_SCALE(dac_tlv, -12750, 50, 1);
	88	static const DECLARE_TLV_DB_SCALE(adc_tlv, -10350, 50, 1);
	89
	90	static const struct snd_kcontrol_new wm8776_snd_controls[] = {
	91	SOC_DOUBLE_R_TLV("Headphone Playback Volume", WM8776_HPLVOL, WM8776_HPRVOL,
	92	0, 127, 0, hp_tlv),
	93	SOC_DOUBLE_R_TLV("Digital Playback Volume", WM8776_DACLVOL, WM8776_DACRVOL,
	94	0, 255, 0, dac_tlv),
	95	SOC_SINGLE("Digital Playback ZC Switch", WM8776_DACCTRL1, 0, 1, 0),
	96
	97	SOC_SINGLE("Deemphasis Switch", WM8776_DACCTRL2, 0, 1, 0),
	98
	99	SOC_DOUBLE_R_TLV("Capture Volume", WM8776_ADCLVOL, WM8776_ADCRVOL,
	100	0, 255, 0, adc_tlv),
	101	SOC_DOUBLE("Capture Switch", WM8776_ADCMUX, 7, 6, 1, 1),
	102	SOC_DOUBLE_R("Capture ZC Switch", WM8776_ADCLVOL, WM8776_ADCRVOL, 8, 1, 0),
	103	SOC_SINGLE("Capture HPF Switch", WM8776_ADCIFCTRL, 8, 1, 1),
	104	};
	105
	106	static const struct snd_kcontrol_new inmix_controls[] = {
	107	SOC_DAPM_SINGLE("AIN1 Switch", WM8776_ADCMUX, 0, 1, 0),
	108	SOC_DAPM_SINGLE("AIN2 Switch", WM8776_ADCMUX, 1, 1, 0),
	109	SOC_DAPM_SINGLE("AIN3 Switch", WM8776_ADCMUX, 2, 1, 0),
	110	SOC_DAPM_SINGLE("AIN4 Switch", WM8776_ADCMUX, 3, 1, 0),
	111	SOC_DAPM_SINGLE("AIN5 Switch", WM8776_ADCMUX, 4, 1, 0),
	112	};
	113
	114	static const struct snd_kcontrol_new outmix_controls[] = {
	115	SOC_DAPM_SINGLE("DAC Switch", WM8776_OUTMUX, 0, 1, 0),
	116	SOC_DAPM_SINGLE("AUX Switch", WM8776_OUTMUX, 1, 1, 0),
	117	SOC_DAPM_SINGLE("Bypass Switch", WM8776_OUTMUX, 2, 1, 0),
	118	};
	119
	120	static const struct snd_soc_dapm_widget wm8776_dapm_widgets[] = {
	121	SND_SOC_DAPM_INPUT("AUX"),
924914ee MB	122
	123	SND_SOC_DAPM_INPUT("AIN1"),
	124	SND_SOC_DAPM_INPUT("AIN2"),
	125	SND_SOC_DAPM_INPUT("AIN3"),
	126	SND_SOC_DAPM_INPUT("AIN4"),
	127	SND_SOC_DAPM_INPUT("AIN5"),
	128
	129	SND_SOC_DAPM_MIXER("Input Mixer", WM8776_PWRDOWN, 6, 1,
	130	inmix_controls, ARRAY_SIZE(inmix_controls)),
	131
	132	SND_SOC_DAPM_ADC("ADC", "Capture", WM8776_PWRDOWN, 1, 1),
	133	SND_SOC_DAPM_DAC("DAC", "Playback", WM8776_PWRDOWN, 2, 1),
	134
	135	SND_SOC_DAPM_MIXER("Output Mixer", SND_SOC_NOPM, 0, 0,
	136	outmix_controls, ARRAY_SIZE(outmix_controls)),
	137
	138	SND_SOC_DAPM_PGA("Headphone PGA", WM8776_PWRDOWN, 3, 1, NULL, 0),
	139
	140	SND_SOC_DAPM_OUTPUT("VOUT"),
	141
	142	SND_SOC_DAPM_OUTPUT("HPOUTL"),
	143	SND_SOC_DAPM_OUTPUT("HPOUTR"),
	144	};
	145
	146	static const struct snd_soc_dapm_route routes[] = {
	147	{ "Input Mixer", "AIN1 Switch", "AIN1" },
	148	{ "Input Mixer", "AIN2 Switch", "AIN2" },
	149	{ "Input Mixer", "AIN3 Switch", "AIN3" },
	150	{ "Input Mixer", "AIN4 Switch", "AIN4" },
	151	{ "Input Mixer", "AIN5 Switch", "AIN5" },
	152
	153	{ "ADC", NULL, "Input Mixer" },
	154
	155	{ "Output Mixer", "DAC Switch", "DAC" },
	156	{ "Output Mixer", "AUX Switch", "AUX" },
	157	{ "Output Mixer", "Bypass Switch", "Input Mixer" },
	158
	159	{ "VOUT", NULL, "Output Mixer" },
	160
	161	{ "Headphone PGA", NULL, "Output Mixer" },
	162
	163	{ "HPOUTL", NULL, "Headphone PGA" },
	164	{ "HPOUTR", NULL, "Headphone PGA" },
	165	};
	166
	167	static int wm8776_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)
	168	{
	169	struct snd_soc_codec *codec = dai->codec;
	170	int reg, iface, master;
	171
f0fba2ad	172	switch (dai->driver->id) {
924914ee MB	173	case WM8776_DAI_DAC:
	174	reg = WM8776_DACIFCTRL;
	175	master = 0x80;
	176	break;
	177	case WM8776_DAI_ADC:
	178	reg = WM8776_ADCIFCTRL;
	179	master = 0x100;
	180	break;
	181	default:
	182	return -EINVAL;
	183	}
	184
	185	iface = 0;
	186
	187	switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
	188	case SND_SOC_DAIFMT_CBM_CFM:
	189	break;
	190	case SND_SOC_DAIFMT_CBS_CFS:
	191	master = 0;
	192	break;
	193	default:
	194	return -EINVAL;
	195	}
	196
	197	switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
	198	case SND_SOC_DAIFMT_I2S:
	199	iface \|= 0x0002;
	200	break;
	201	case SND_SOC_DAIFMT_RIGHT_J:
	202	break;
	203	case SND_SOC_DAIFMT_LEFT_J:
	204	iface \|= 0x0001;
	205	break;
924914ee MB	206	default:
	207	return -EINVAL;
	208	}
	209
	210	switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
	211	case SND_SOC_DAIFMT_NB_NF:
	212	break;
	213	case SND_SOC_DAIFMT_IB_IF:
	214	iface \|= 0x00c;
	215	break;
	216	case SND_SOC_DAIFMT_IB_NF:
	217	iface \|= 0x008;
	218	break;
	219	case SND_SOC_DAIFMT_NB_IF:
	220	iface \|= 0x004;
	221	break;
	222	default:
	223	return -EINVAL;
	224	}
	225
	226	/* Finally, write out the values */
	227	snd_soc_update_bits(codec, reg, 0xf, iface);
	228	snd_soc_update_bits(codec, WM8776_MSTRCTRL, 0x180, master);
	229
	230	return 0;
	231	}
	232
	233	static int mclk_ratios[] = {
	234	128,
	235	192,
	236	256,
	237	384,
	238	512,
	239	768,
	240	};
	241
	242	static int wm8776_hw_params(struct snd_pcm_substream *substream,
	243	struct snd_pcm_hw_params *params,
	244	struct snd_soc_dai *dai)
	245	{
	246	struct snd_soc_codec *codec = dai->codec;
b2c812e2	247	struct wm8776_priv *wm8776 = snd_soc_codec_get_drvdata(codec);
924914ee MB	248	int iface_reg, iface;
	249	int ratio_shift, master;
	250	int i;
	251
f0fba2ad	252	switch (dai->driver->id) {
924914ee MB	253	case WM8776_DAI_DAC:
	254	iface_reg = WM8776_DACIFCTRL;
	255	master = 0x80;
	256	ratio_shift = 4;
	257	break;
	258	case WM8776_DAI_ADC:
	259	iface_reg = WM8776_ADCIFCTRL;
	260	master = 0x100;
	261	ratio_shift = 0;
	262	break;
	263	default:
	264	return -EINVAL;
	265	}
	266
924914ee	267	/* Set word length */
d1dc698a TT	268	switch (snd_pcm_format_width(params_format(params))) {
	269	case 16:
	270	iface = 0;
990fc3d0	271	break;
d1dc698a TT	272	case 20:
d1dc698a TT	273	iface = 0x10;
924914ee	274	break;
d1dc698a TT	275	case 24:
d1dc698a TT	276	iface = 0x20;
924914ee	277	break;
d1dc698a TT	278	case 32:
d1dc698a TT	279	iface = 0x30;
924914ee	280	break;
d1dc698a TT	281	default:
	282	dev_err(codec->dev, "Unsupported sample size: %i\n",
	283	snd_pcm_format_width(params_format(params)));
	284	return -EINVAL;
924914ee MB	285	}
	286
	287	/* Only need to set MCLK/LRCLK ratio if we're master */
	288	if (snd_soc_read(codec, WM8776_MSTRCTRL) & master) {
	289	for (i = 0; i < ARRAY_SIZE(mclk_ratios); i++) {
f0fba2ad	290	if (wm8776->sysclk[dai->driver->id] / params_rate(params)
924914ee MB	291	== mclk_ratios[i])
	292	break;
	293	}
	294
	295	if (i == ARRAY_SIZE(mclk_ratios)) {
	296	dev_err(codec->dev,
	297	"Unable to configure MCLK ratio %d/%d\n",
f0fba2ad	298	wm8776->sysclk[dai->driver->id], params_rate(params));
924914ee MB	299	return -EINVAL;
	300	}
	301
	302	dev_dbg(codec->dev, "MCLK is %dfs\n", mclk_ratios[i]);
	303
	304	snd_soc_update_bits(codec, WM8776_MSTRCTRL,
	305	0x7 << ratio_shift, i << ratio_shift);
	306	} else {
	307	dev_dbg(codec->dev, "DAI in slave mode\n");
	308	}
	309
	310	snd_soc_update_bits(codec, iface_reg, 0x30, iface);
	311
	312	return 0;
	313	}
	314
	315	static int wm8776_mute(struct snd_soc_dai *dai, int mute)
	316	{
	317	struct snd_soc_codec *codec = dai->codec;
	318
	319	return snd_soc_write(codec, WM8776_DACMUTE, !!mute);
	320	}
	321
	322	static int wm8776_set_sysclk(struct snd_soc_dai *dai,
	323	int clk_id, unsigned int freq, int dir)
	324	{
	325	struct snd_soc_codec *codec = dai->codec;
b2c812e2	326	struct wm8776_priv *wm8776 = snd_soc_codec_get_drvdata(codec);
924914ee	327
f0fba2ad	328	BUG_ON(dai->driver->id >= ARRAY_SIZE(wm8776->sysclk));
924914ee	329
f0fba2ad	330	wm8776->sysclk[dai->driver->id] = freq;
924914ee MB	331
	332	return 0;
	333	}
	334
	335	static int wm8776_set_bias_level(struct snd_soc_codec *codec,
	336	enum snd_soc_bias_level level)
	337	{
2cbde7ab MB	338	struct wm8776_priv *wm8776 = snd_soc_codec_get_drvdata(codec);
2cbde7ab MB	339
924914ee MB	340	switch (level) {
	341	case SND_SOC_BIAS_ON:
	342	break;
	343	case SND_SOC_BIAS_PREPARE:
	344	break;
	345	case SND_SOC_BIAS_STANDBY:
ce6120cc	346	if (codec->dapm.bias_level == SND_SOC_BIAS_OFF) {
2cbde7ab	347	regcache_sync(wm8776->regmap);
abe11d0a	348
924914ee MB	349	/* Disable the global powerdown; DAPM does the rest */
	350	snd_soc_update_bits(codec, WM8776_PWRDOWN, 1, 0);
	351	}
	352
	353	break;
	354	case SND_SOC_BIAS_OFF:
	355	snd_soc_update_bits(codec, WM8776_PWRDOWN, 1, 1);
	356	break;
	357	}
	358
ce6120cc	359	codec->dapm.bias_level = level;
924914ee MB	360	return 0;
	361	}
	362
924914ee MB	363	#define WM8776_FORMATS (SNDRV_PCM_FMTBIT_S16_LE \| SNDRV_PCM_FMTBIT_S20_3LE \|\
	364	SNDRV_PCM_FMTBIT_S24_LE \| SNDRV_PCM_FMTBIT_S32_LE)
	365
85e7652d	366	static const struct snd_soc_dai_ops wm8776_dac_ops = {
924914ee MB	367	.digital_mute = wm8776_mute,
	368	.hw_params = wm8776_hw_params,
	369	.set_fmt = wm8776_set_fmt,
	370	.set_sysclk = wm8776_set_sysclk,
	371	};
	372
85e7652d	373	static const struct snd_soc_dai_ops wm8776_adc_ops = {
924914ee MB	374	.hw_params = wm8776_hw_params,
	375	.set_fmt = wm8776_set_fmt,
	376	.set_sysclk = wm8776_set_sysclk,
	377	};
	378
f0fba2ad	379	static struct snd_soc_dai_driver wm8776_dai[] = {
924914ee	380	{
f0fba2ad LG	381	.name = "wm8776-hifi-playback",
f0fba2ad LG	382	.id = WM8776_DAI_DAC,
924914ee MB	383	.playback = {
	384	.stream_name = "Playback",
	385	.channels_min = 2,
	386	.channels_max = 2,
0016226d TT	387	.rates = SNDRV_PCM_RATE_CONTINUOUS,
	388	.rate_min = 32000,
	389	.rate_max = 192000,
924914ee MB	390	.formats = WM8776_FORMATS,
	391	},
	392	.ops = &wm8776_dac_ops,
	393	},
	394	{
f0fba2ad LG	395	.name = "wm8776-hifi-capture",
f0fba2ad LG	396	.id = WM8776_DAI_ADC,
924914ee MB	397	.capture = {
	398	.stream_name = "Capture",
	399	.channels_min = 2,
	400	.channels_max = 2,
0016226d TT	401	.rates = SNDRV_PCM_RATE_CONTINUOUS,
	402	.rate_min = 32000,
	403	.rate_max = 96000,
924914ee MB	404	.formats = WM8776_FORMATS,
	405	},
	406	.ops = &wm8776_adc_ops,
	407	},
	408	};
924914ee MB	409
924914ee MB	410	#ifdef CONFIG_PM
84b315ee	411	static int wm8776_suspend(struct snd_soc_codec *codec)
924914ee	412	{
924914ee MB	413	wm8776_set_bias_level(codec, SND_SOC_BIAS_OFF);
	414
	415	return 0;
	416	}
	417
f0fba2ad	418	static int wm8776_resume(struct snd_soc_codec *codec)
924914ee	419	{
924914ee	420	wm8776_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
924914ee MB	421	return 0;
	422	}
	423	#else
	424	#define wm8776_suspend NULL
	425	#define wm8776_resume NULL
	426	#endif
	427
f0fba2ad	428	static int wm8776_probe(struct snd_soc_codec *codec)
924914ee	429	{
924914ee MB	430	int ret = 0;
924914ee MB	431
2cbde7ab	432	ret = snd_soc_codec_set_cache_io(codec, 7, 9, SND_SOC_REGMAP);
f0fba2ad LG	433	if (ret < 0) {
	434	dev_err(codec->dev, "Failed to set cache I/O: %d\n", ret);
	435	return ret;
924914ee MB	436	}
924914ee MB	437
f0fba2ad	438	ret = wm8776_reset(codec);
924914ee	439	if (ret < 0) {
f0fba2ad LG	440	dev_err(codec->dev, "Failed to issue reset: %d\n", ret);
f0fba2ad LG	441	return ret;
924914ee MB	442	}
924914ee MB	443
f0fba2ad LG	444	wm8776_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
	445
	446	/* Latch the update bits; right channel only since we always
	447	* update both. */
	448	snd_soc_update_bits(codec, WM8776_HPRVOL, 0x100, 0x100);
	449	snd_soc_update_bits(codec, WM8776_DACRVOL, 0x100, 0x100);
	450
924914ee	451	return ret;
924914ee MB	452	}
	453
	454	/* power down chip */
f0fba2ad	455	static int wm8776_remove(struct snd_soc_codec *codec)
924914ee	456	{
f0fba2ad	457	wm8776_set_bias_level(codec, SND_SOC_BIAS_OFF);
924914ee MB	458	return 0;
	459	}
	460
f0fba2ad	461	static struct snd_soc_codec_driver soc_codec_dev_wm8776 = {
924914ee MB	462	.probe = wm8776_probe,
	463	.remove = wm8776_remove,
	464	.suspend = wm8776_suspend,
	465	.resume = wm8776_resume,
f0fba2ad	466	.set_bias_level = wm8776_set_bias_level,
1db3c98e MB	467
	468	.controls = wm8776_snd_controls,
	469	.num_controls = ARRAY_SIZE(wm8776_snd_controls),
	470	.dapm_widgets = wm8776_dapm_widgets,
	471	.num_dapm_widgets = ARRAY_SIZE(wm8776_dapm_widgets),
	472	.dapm_routes = routes,
	473	.num_dapm_routes = ARRAY_SIZE(routes),
924914ee	474	};
924914ee	475
b6de4315 MB	476	static const struct of_device_id wm8776_of_match[] = {
	477	{ .compatible = "wlf,wm8776", },
	478	{ }
	479	};
	480	MODULE_DEVICE_TABLE(of, wm8776_of_match);
	481
2cbde7ab MB	482	static const struct regmap_config wm8776_regmap = {
	483	.reg_bits = 7,
	484	.val_bits = 9,
	485	.max_register = WM8776_RESET,
	486
	487	.reg_defaults = wm8776_reg_defaults,
	488	.num_reg_defaults = ARRAY_SIZE(wm8776_reg_defaults),
	489	.cache_type = REGCACHE_RBTREE,
	490
	491	.volatile_reg = wm8776_volatile,
	492	};
	493
924914ee	494	#if defined(CONFIG_SPI_MASTER)
7a79e94e	495	static int wm8776_spi_probe(struct spi_device *spi)
924914ee	496	{
924914ee	497	struct wm8776_priv *wm8776;
f0fba2ad	498	int ret;
924914ee	499
bf97ca9a MB	500	wm8776 = devm_kzalloc(&spi->dev, sizeof(struct wm8776_priv),
bf97ca9a MB	501	GFP_KERNEL);
924914ee MB	502	if (wm8776 == NULL)
	503	return -ENOMEM;
	504
2cbde7ab MB	505	wm8776->regmap = devm_regmap_init_spi(spi, &wm8776_regmap);
	506	if (IS_ERR(wm8776->regmap))
	507	return PTR_ERR(wm8776->regmap);
	508
f0fba2ad	509	spi_set_drvdata(spi, wm8776);
924914ee	510
f0fba2ad LG	511	ret = snd_soc_register_codec(&spi->dev,
f0fba2ad LG	512	&soc_codec_dev_wm8776, wm8776_dai, ARRAY_SIZE(wm8776_dai));
bf97ca9a	513
f0fba2ad	514	return ret;
924914ee MB	515	}
924914ee MB	516
7a79e94e	517	static int wm8776_spi_remove(struct spi_device *spi)
924914ee	518	{
f0fba2ad	519	snd_soc_unregister_codec(&spi->dev);
924914ee MB	520	return 0;
	521	}
	522
924914ee MB	523	static struct spi_driver wm8776_spi_driver = {
924914ee MB	524	.driver = {
1e3ad571	525	.name = "wm8776",
924914ee	526	.owner = THIS_MODULE,
b6de4315	527	.of_match_table = wm8776_of_match,
924914ee MB	528	},
924914ee MB	529	.probe = wm8776_spi_probe,
7a79e94e	530	.remove = wm8776_spi_remove,
924914ee MB	531	};
	532	#endif /* CONFIG_SPI_MASTER */
	533
	534	#if defined(CONFIG_I2C) \|\| defined(CONFIG_I2C_MODULE)
7a79e94e BP	535	static int wm8776_i2c_probe(struct i2c_client *i2c,
7a79e94e BP	536	const struct i2c_device_id *id)
924914ee MB	537	{
924914ee MB	538	struct wm8776_priv *wm8776;
f0fba2ad	539	int ret;
924914ee	540
bf97ca9a MB	541	wm8776 = devm_kzalloc(&i2c->dev, sizeof(struct wm8776_priv),
bf97ca9a MB	542	GFP_KERNEL);
924914ee MB	543	if (wm8776 == NULL)
	544	return -ENOMEM;
	545
2cbde7ab MB	546	wm8776->regmap = devm_regmap_init_i2c(i2c, &wm8776_regmap);
	547	if (IS_ERR(wm8776->regmap))
	548	return PTR_ERR(wm8776->regmap);
	549
924914ee	550	i2c_set_clientdata(i2c, wm8776);
924914ee	551
f0fba2ad LG	552	ret = snd_soc_register_codec(&i2c->dev,
f0fba2ad LG	553	&soc_codec_dev_wm8776, wm8776_dai, ARRAY_SIZE(wm8776_dai));
bf97ca9a	554
f0fba2ad	555	return ret;
924914ee MB	556	}
924914ee MB	557
7a79e94e	558	static int wm8776_i2c_remove(struct i2c_client *client)
924914ee	559	{
f0fba2ad	560	snd_soc_unregister_codec(&client->dev);
924914ee MB	561	return 0;
	562	}
	563
924914ee	564	static const struct i2c_device_id wm8776_i2c_id[] = {
fdd48f9d MB	565	{ "wm8775", WM8775 },
fdd48f9d MB	566	{ "wm8776", WM8776 },
924914ee MB	567	{ }
	568	};
	569	MODULE_DEVICE_TABLE(i2c, wm8776_i2c_id);
	570
	571	static struct i2c_driver wm8776_i2c_driver = {
	572	.driver = {
1e3ad571	573	.name = "wm8776",
924914ee	574	.owner = THIS_MODULE,
b6de4315	575	.of_match_table = wm8776_of_match,
924914ee MB	576	},
924914ee MB	577	.probe = wm8776_i2c_probe,
7a79e94e	578	.remove = wm8776_i2c_remove,
924914ee MB	579	.id_table = wm8776_i2c_id,
	580	};
	581	#endif
	582
	583	static int __init wm8776_modinit(void)
	584	{
f0fba2ad	585	int ret = 0;
924914ee MB	586	#if defined(CONFIG_I2C) \|\| defined(CONFIG_I2C_MODULE)
	587	ret = i2c_add_driver(&wm8776_i2c_driver);
	588	if (ret != 0) {
f0fba2ad	589	printk(KERN_ERR "Failed to register wm8776 I2C driver: %d\n",
924914ee MB	590	ret);
	591	}
	592	#endif
	593	#if defined(CONFIG_SPI_MASTER)
	594	ret = spi_register_driver(&wm8776_spi_driver);
	595	if (ret != 0) {
f0fba2ad	596	printk(KERN_ERR "Failed to register wm8776 SPI driver: %d\n",
924914ee MB	597	ret);
	598	}
	599	#endif
f0fba2ad	600	return ret;
924914ee MB	601	}
	602	module_init(wm8776_modinit);
	603
	604	static void __exit wm8776_exit(void)
	605	{
	606	#if defined(CONFIG_I2C) \|\| defined(CONFIG_I2C_MODULE)
	607	i2c_del_driver(&wm8776_i2c_driver);
	608	#endif
	609	#if defined(CONFIG_SPI_MASTER)
	610	spi_unregister_driver(&wm8776_spi_driver);
	611	#endif
	612	}
	613	module_exit(wm8776_exit);
	614
	615	MODULE_DESCRIPTION("ASoC WM8776 driver");
	616	MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
	617	MODULE_LICENSE("GPL");