[linux-2.6-block.git] / sound / soc / codecs / wm8776.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * wm8776.c  --  WM8776 ALSA SoC Audio driver
 *
 * Copyright 2009-12 Wolfson Microelectronics plc
 *
 * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
 *
 * 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_component *component)
{
	return snd_soc_component_write(component, 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_component *component = dai->component;
	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_component_update_bits(component, reg, 0xf, iface);
	snd_soc_component_update_bits(component, 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_component *component = dai->component;
	struct wm8776_priv *wm8776 = snd_soc_component_get_drvdata(component);
	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 (params_width(params)) {
	case 16:
		iface = 0;
		break;
	case 20:
		iface = 0x10;
		break;
	case 24:
		iface = 0x20;
		break;
	case 32:
		iface = 0x30;
		break;
	default:
		dev_err(component->dev, "Unsupported sample size: %i\n",
			params_width(params));
		return -EINVAL;
	}

	/* Only need to set MCLK/LRCLK ratio if we're master */
	if (snd_soc_component_read(component, 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(component->dev,
				"Unable to configure MCLK ratio %d/%d\n",
				wm8776->sysclk[dai->driver->id], params_rate(params));
			return -EINVAL;
		}

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

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

	snd_soc_component_update_bits(component, iface_reg, 0x30, iface);

	return 0;
}

static int wm8776_mute(struct snd_soc_dai *dai, int mute, int direction)
{
	struct snd_soc_component *component = dai->component;

	return snd_soc_component_write(component, WM8776_DACMUTE, !!mute);
}

static int wm8776_set_sysclk(struct snd_soc_dai *dai,
			     int clk_id, unsigned int freq, int dir)
{
	struct snd_soc_component *component = dai->component;
	struct wm8776_priv *wm8776 = snd_soc_component_get_drvdata(component);

	if (WARN_ON(dai->driver->id >= ARRAY_SIZE(wm8776->sysclk)))
		return -EINVAL;

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

	return 0;
}

static int wm8776_set_bias_level(struct snd_soc_component *component,
				 enum snd_soc_bias_level level)
{
	struct wm8776_priv *wm8776 = snd_soc_component_get_drvdata(component);

	switch (level) {
	case SND_SOC_BIAS_ON:
		break;
	case SND_SOC_BIAS_PREPARE:
		break;
	case SND_SOC_BIAS_STANDBY:
		if (snd_soc_component_get_bias_level(component) == SND_SOC_BIAS_OFF) {
			regcache_sync(wm8776->regmap);

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

		break;
	case SND_SOC_BIAS_OFF:
		snd_soc_component_update_bits(component, WM8776_PWRDOWN, 1, 1);
		break;
	}

	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 = {
	.mute_stream	= wm8776_mute,
	.hw_params      = wm8776_hw_params,
	.set_fmt        = wm8776_set_fmt,
	.set_sysclk     = wm8776_set_sysclk,
	.no_capture_mute = 1,
};

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,
	},
};

static int wm8776_probe(struct snd_soc_component *component)
{
	int ret = 0;

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

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

	return ret;
}

static const struct snd_soc_component_driver soc_component_dev_wm8776 = {
	.probe			= wm8776_probe,
	.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),
	.suspend_bias_off	= 1,
	.idle_bias_on		= 1,
	.use_pmdown_time	= 1,
	.endianness		= 1,
	.non_legacy_dai_naming	= 1,
};

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 = devm_snd_soc_register_component(&spi->dev,
			&soc_component_dev_wm8776, wm8776_dai, ARRAY_SIZE(wm8776_dai));

	return ret;
}

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

#if IS_ENABLED(CONFIG_I2C)
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 = devm_snd_soc_register_component(&i2c->dev,
			&soc_component_dev_wm8776, wm8776_dai, ARRAY_SIZE(wm8776_dai));

	return ret;
}

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",
		.of_match_table = wm8776_of_match,
	},
	.probe =    wm8776_i2c_probe,
	.id_table = wm8776_i2c_id,
};
#endif

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