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

/*
 * ASoC codec driver for spear platform
 *
 * sound/soc/codecs/sta529.c -- spear ALSA Soc codec driver
 *
 * Copyright (C) 2012 ST Microelectronics
 * Rajeev Kumar <rajeevkumar.linux@gmail.com>
 *
 * This file is licensed under the terms of the GNU General Public
 * License version 2. This program is licensed "as is" without any
 * warranty of any kind, whether express or implied.
 */

#include <linux/clk.h>
#include <linux/init.h>
#include <linux/i2c.h>
#include <linux/io.h>
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/pm.h>
#include <linux/regmap.h>
#include <linux/slab.h>

#include <sound/core.h>
#include <sound/initval.h>
#include <sound/pcm.h>
#include <sound/pcm_params.h>
#include <sound/soc.h>
#include <sound/soc-dapm.h>
#include <sound/tlv.h>

/* STA529 Register offsets */
#define	 STA529_FFXCFG0		0x00
#define	 STA529_FFXCFG1		0x01
#define	 STA529_MVOL		0x02
#define	 STA529_LVOL		0x03
#define	 STA529_RVOL		0x04
#define	 STA529_TTF0		0x05
#define	 STA529_TTF1		0x06
#define	 STA529_TTP0		0x07
#define	 STA529_TTP1		0x08
#define	 STA529_S2PCFG0		0x0A
#define	 STA529_S2PCFG1		0x0B
#define	 STA529_P2SCFG0		0x0C
#define	 STA529_P2SCFG1		0x0D
#define	 STA529_PLLCFG0		0x14
#define	 STA529_PLLCFG1		0x15
#define	 STA529_PLLCFG2		0x16
#define	 STA529_PLLCFG3		0x17
#define	 STA529_PLLPFE		0x18
#define	 STA529_PLLST		0x19
#define	 STA529_ADCCFG		0x1E /*mic_select*/
#define	 STA529_CKOCFG		0x1F
#define	 STA529_MISC		0x20
#define	 STA529_PADST0		0x21
#define	 STA529_PADST1		0x22
#define	 STA529_FFXST		0x23
#define	 STA529_PWMIN1		0x2D
#define	 STA529_PWMIN2		0x2E
#define	 STA529_POWST		0x32

#define STA529_MAX_REGISTER	0x32

#define STA529_RATES		(SNDRV_PCM_RATE_8000 | \
				SNDRV_PCM_RATE_11025 | \
				SNDRV_PCM_RATE_16000 | \
				SNDRV_PCM_RATE_22050 | \
				SNDRV_PCM_RATE_32000 | \
				SNDRV_PCM_RATE_44100 | \
				SNDRV_PCM_RATE_48000)

#define STA529_FORMAT		(SNDRV_PCM_FMTBIT_S16_LE | \
				SNDRV_PCM_FMTBIT_S24_LE | \
				SNDRV_PCM_FMTBIT_S32_LE)
#define	S2PC_VALUE		0x98
#define CLOCK_OUT		0x60
#define DATA_FORMAT_MSK		0x0E
#define LEFT_J_DATA_FORMAT	0x00
#define I2S_DATA_FORMAT		0x02
#define RIGHT_J_DATA_FORMAT	0x04
#define CODEC_MUTE_VAL		0x80

#define POWER_CNTLMSAK		0x40
#define POWER_STDBY		0x40
#define FFX_MASK		0x80
#define FFX_OFF			0x80
#define POWER_UP		0x00
#define FFX_CLK_ENB		0x01
#define FFX_CLK_DIS		0x00
#define FFX_CLK_MSK		0x01
#define PLAY_FREQ_RANGE_MSK	0x70
#define CAP_FREQ_RANGE_MSK	0x0C
#define PDATA_LEN_MSK		0xC0
#define BCLK_TO_FS_MSK		0x30
#define AUDIO_MUTE_MSK		0x80

static const struct reg_default sta529_reg_defaults[] = {
	{ 0,  0x35 },     /* R0   - FFX Configuration reg 0 */
	{ 1,  0xc8 },     /* R1   - FFX Configuration reg 1 */
	{ 2,  0x50 },     /* R2   - Master Volume */
	{ 3,  0x00 },     /* R3   - Left Volume */
	{ 4,  0x00 },     /* R4  -  Right Volume */
	{ 10, 0xb2 },     /* R10  - S2P Config Reg 0 */
	{ 11, 0x41 },     /* R11  - S2P Config Reg 1 */
	{ 12, 0x92 },     /* R12  - P2S Config Reg 0 */
	{ 13, 0x41 },     /* R13  - P2S Config Reg 1 */
	{ 30, 0xd2 },     /* R30  - ADC Config Reg */
	{ 31, 0x40 },     /* R31  - clock Out Reg */
	{ 32, 0x21 },     /* R32  - Misc Register */
};

struct sta529 {
	struct regmap *regmap;
};

static bool sta529_readable(struct device *dev, unsigned int reg)
{
	switch (reg) {

	case STA529_FFXCFG0:
	case STA529_FFXCFG1:
	case STA529_MVOL:
	case STA529_LVOL:
	case STA529_RVOL:
	case STA529_S2PCFG0:
	case STA529_S2PCFG1:
	case STA529_P2SCFG0:
	case STA529_P2SCFG1:
	case STA529_ADCCFG:
	case STA529_CKOCFG:
	case STA529_MISC:
		return true;
	default:
		return false;
	}
}


static const char *pwm_mode_text[] = { "Binary", "Headphone", "Ternary",
	"Phase-shift"};

static const DECLARE_TLV_DB_SCALE(out_gain_tlv, -9150, 50, 0);
static const DECLARE_TLV_DB_SCALE(master_vol_tlv, -12750, 50, 0);
static SOC_ENUM_SINGLE_DECL(pwm_src, STA529_FFXCFG1, 4, pwm_mode_text);

static const struct snd_kcontrol_new sta529_snd_controls[] = {
	SOC_DOUBLE_R_TLV("Digital Playback Volume", STA529_LVOL, STA529_RVOL, 0,
			127, 0, out_gain_tlv),
	SOC_SINGLE_TLV("Master Playback Volume", STA529_MVOL, 0, 127, 1,
			master_vol_tlv),
	SOC_ENUM("PWM Select", pwm_src),
};

static int sta529_set_bias_level(struct snd_soc_codec *codec, enum
		snd_soc_bias_level level)
{
	struct sta529 *sta529 = snd_soc_codec_get_drvdata(codec);

	switch (level) {
	case SND_SOC_BIAS_ON:
	case SND_SOC_BIAS_PREPARE:
		snd_soc_update_bits(codec, STA529_FFXCFG0, POWER_CNTLMSAK,
				POWER_UP);
		snd_soc_update_bits(codec, STA529_MISC,	FFX_CLK_MSK,
				FFX_CLK_ENB);
		break;
	case SND_SOC_BIAS_STANDBY:
		if (codec->dapm.bias_level == SND_SOC_BIAS_OFF)
			regcache_sync(sta529->regmap);
		snd_soc_update_bits(codec, STA529_FFXCFG0,
					POWER_CNTLMSAK, POWER_STDBY);
		/* Making FFX output to zero */
		snd_soc_update_bits(codec, STA529_FFXCFG0, FFX_MASK,
				FFX_OFF);
		snd_soc_update_bits(codec, STA529_MISC, FFX_CLK_MSK,
				FFX_CLK_DIS);
		break;
	case SND_SOC_BIAS_OFF:
		break;
	}

	/*
	 * store the label for powers down audio subsystem for suspend.This is
	 * used by soc core layer
	 */
	codec->dapm.bias_level = level;

	return 0;

}

static int sta529_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;
	int pdata, play_freq_val, record_freq_val;
	int bclk_to_fs_ratio;

	switch (params_width(params)) {
	case 16:
		pdata = 1;
		bclk_to_fs_ratio = 0;
		break;
	case 24:
		pdata = 2;
		bclk_to_fs_ratio = 1;
		break;
	case 32:
		pdata = 3;
		bclk_to_fs_ratio = 2;
		break;
	default:
		dev_err(codec->dev, "Unsupported format\n");
		return -EINVAL;
	}

	switch (params_rate(params)) {
	case 8000:
	case 11025:
		play_freq_val = 0;
		record_freq_val = 2;
		break;
	case 16000:
	case 22050:
		play_freq_val = 1;
		record_freq_val = 0;
		break;

	case 32000:
	case 44100:
	case 48000:
		play_freq_val = 2;
		record_freq_val = 0;
		break;
	default:
		dev_err(codec->dev, "Unsupported rate\n");
		return -EINVAL;
	}

	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
		snd_soc_update_bits(codec, STA529_S2PCFG1, PDATA_LEN_MSK,
				pdata << 6);
		snd_soc_update_bits(codec, STA529_S2PCFG1, BCLK_TO_FS_MSK,
				bclk_to_fs_ratio << 4);
		snd_soc_update_bits(codec, STA529_MISC, PLAY_FREQ_RANGE_MSK,
				play_freq_val << 4);
	} else {
		snd_soc_update_bits(codec, STA529_P2SCFG1, PDATA_LEN_MSK,
				pdata << 6);
		snd_soc_update_bits(codec, STA529_P2SCFG1, BCLK_TO_FS_MSK,
				bclk_to_fs_ratio << 4);
		snd_soc_update_bits(codec, STA529_MISC, CAP_FREQ_RANGE_MSK,
				record_freq_val << 2);
	}

	return 0;
}

static int sta529_mute(struct snd_soc_dai *dai, int mute)
{
	u8 val = 0;

	if (mute)
		val |= CODEC_MUTE_VAL;

	snd_soc_update_bits(dai->codec, STA529_FFXCFG0, AUDIO_MUTE_MSK, val);

	return 0;
}

static int sta529_set_dai_fmt(struct snd_soc_dai *codec_dai, u32 fmt)
{
	struct snd_soc_codec *codec = codec_dai->codec;
	u8 mode = 0;

	/* interface format */
	switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
	case SND_SOC_DAIFMT_LEFT_J:
		mode = LEFT_J_DATA_FORMAT;
		break;
	case SND_SOC_DAIFMT_I2S:
		mode = I2S_DATA_FORMAT;
		break;
	case SND_SOC_DAIFMT_RIGHT_J:
		mode = RIGHT_J_DATA_FORMAT;
		break;
	default:
		return -EINVAL;
	}

	snd_soc_update_bits(codec, STA529_S2PCFG0, DATA_FORMAT_MSK, mode);

	return 0;
}

static const struct snd_soc_dai_ops sta529_dai_ops = {
	.hw_params	=	sta529_hw_params,
	.set_fmt	=	sta529_set_dai_fmt,
	.digital_mute	=	sta529_mute,
};

static struct snd_soc_dai_driver sta529_dai = {
	.name = "sta529-audio",
	.playback = {
		.stream_name = "Playback",
		.channels_min = 2,
		.channels_max = 2,
		.rates = STA529_RATES,
		.formats = STA529_FORMAT,
	},
	.capture = {
		.stream_name = "Capture",
		.channels_min = 2,
		.channels_max = 2,
		.rates = STA529_RATES,
		.formats = STA529_FORMAT,
	},
	.ops	= &sta529_dai_ops,
};

static int sta529_probe(struct snd_soc_codec *codec)
{
	sta529_set_bias_level(codec, SND_SOC_BIAS_STANDBY);

	return 0;
}

/* power down chip */
static int sta529_remove(struct snd_soc_codec *codec)
{
	sta529_set_bias_level(codec, SND_SOC_BIAS_OFF);

	return 0;
}

static int sta529_suspend(struct snd_soc_codec *codec)
{
	sta529_set_bias_level(codec, SND_SOC_BIAS_OFF);

	return 0;
}

static int sta529_resume(struct snd_soc_codec *codec)
{
	sta529_set_bias_level(codec, SND_SOC_BIAS_STANDBY);

	return 0;
}

static const struct snd_soc_codec_driver sta529_codec_driver = {
	.probe = sta529_probe,
	.remove = sta529_remove,
	.set_bias_level = sta529_set_bias_level,
	.suspend = sta529_suspend,
	.resume = sta529_resume,
	.controls = sta529_snd_controls,
	.num_controls = ARRAY_SIZE(sta529_snd_controls),
};

static const struct regmap_config sta529_regmap = {
	.reg_bits = 8,
	.val_bits = 8,

	.max_register = STA529_MAX_REGISTER,
	.readable_reg = sta529_readable,

	.cache_type = REGCACHE_RBTREE,
	.reg_defaults = sta529_reg_defaults,
	.num_reg_defaults = ARRAY_SIZE(sta529_reg_defaults),
};

static int sta529_i2c_probe(struct i2c_client *i2c,
			    const struct i2c_device_id *id)
{
	struct sta529 *sta529;
	int ret;

	if (!i2c_check_functionality(i2c->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
		return -EINVAL;

	sta529 = devm_kzalloc(&i2c->dev, sizeof(struct sta529), GFP_KERNEL);
	if (!sta529)
		return -ENOMEM;

	sta529->regmap = devm_regmap_init_i2c(i2c, &sta529_regmap);
	if (IS_ERR(sta529->regmap)) {
		ret = PTR_ERR(sta529->regmap);
		dev_err(&i2c->dev, "Failed to allocate regmap: %d\n", ret);
		return ret;
	}

	i2c_set_clientdata(i2c, sta529);

	ret = snd_soc_register_codec(&i2c->dev,
			&sta529_codec_driver, &sta529_dai, 1);
	if (ret != 0)
		dev_err(&i2c->dev, "Failed to register CODEC: %d\n", ret);

	return ret;
}

static int sta529_i2c_remove(struct i2c_client *client)
{
	snd_soc_unregister_codec(&client->dev);

	return 0;
}

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

static struct i2c_driver sta529_i2c_driver = {
	.driver = {
		.name = "sta529",
		.owner = THIS_MODULE,
	},
	.probe		= sta529_i2c_probe,
	.remove		= sta529_i2c_remove,
	.id_table	= sta529_i2c_id,
};

module_i2c_driver(sta529_i2c_driver);

MODULE_DESCRIPTION("ASoC STA529 codec driver");
MODULE_AUTHOR("Rajeev Kumar <rajeevkumar.linux@gmail.com>");
MODULE_LICENSE("GPL");
Commit	Line	Data
3be58dbb RK	1	/*
	2	* ASoC codec driver for spear platform
	3	*
	4	* sound/soc/codecs/sta529.c -- spear ALSA Soc codec driver
	5	*
	6	* Copyright (C) 2012 ST Microelectronics
b794dbcd	7	* Rajeev Kumar <rajeevkumar.linux@gmail.com>
3be58dbb RK	8	*
	9	* This file is licensed under the terms of the GNU General Public
	10	* License version 2. This program is licensed "as is" without any
	11	* warranty of any kind, whether express or implied.
	12	*/
	13
	14	#include <linux/clk.h>
	15	#include <linux/init.h>
	16	#include <linux/i2c.h>
	17	#include <linux/io.h>
	18	#include <linux/module.h>
	19	#include <linux/moduleparam.h>
	20	#include <linux/pm.h>
	21	#include <linux/regmap.h>
	22	#include <linux/slab.h>
	23
	24	#include <sound/core.h>
	25	#include <sound/initval.h>
	26	#include <sound/pcm.h>
	27	#include <sound/pcm_params.h>
	28	#include <sound/soc.h>
	29	#include <sound/soc-dapm.h>
	30	#include <sound/tlv.h>
	31
	32	/* STA529 Register offsets */
	33	#define STA529_FFXCFG0 0x00
	34	#define STA529_FFXCFG1 0x01
	35	#define STA529_MVOL 0x02
	36	#define STA529_LVOL 0x03
	37	#define STA529_RVOL 0x04
	38	#define STA529_TTF0 0x05
	39	#define STA529_TTF1 0x06
	40	#define STA529_TTP0 0x07
	41	#define STA529_TTP1 0x08
	42	#define STA529_S2PCFG0 0x0A
	43	#define STA529_S2PCFG1 0x0B
	44	#define STA529_P2SCFG0 0x0C
	45	#define STA529_P2SCFG1 0x0D
	46	#define STA529_PLLCFG0 0x14
	47	#define STA529_PLLCFG1 0x15
	48	#define STA529_PLLCFG2 0x16
	49	#define STA529_PLLCFG3 0x17
	50	#define STA529_PLLPFE 0x18
	51	#define STA529_PLLST 0x19
	52	#define STA529_ADCCFG 0x1E /mic_select/
	53	#define STA529_CKOCFG 0x1F
	54	#define STA529_MISC 0x20
	55	#define STA529_PADST0 0x21
	56	#define STA529_PADST1 0x22
	57	#define STA529_FFXST 0x23
	58	#define STA529_PWMIN1 0x2D
	59	#define STA529_PWMIN2 0x2E
	60	#define STA529_POWST 0x32
	61
	62	#define STA529_MAX_REGISTER 0x32
	63
	64	#define STA529_RATES (SNDRV_PCM_RATE_8000 \| \
	65	SNDRV_PCM_RATE_11025 \| \
	66	SNDRV_PCM_RATE_16000 \| \
	67	SNDRV_PCM_RATE_22050 \| \
	68	SNDRV_PCM_RATE_32000 \| \
	69	SNDRV_PCM_RATE_44100 \| \
	70	SNDRV_PCM_RATE_48000)
	71
72	#define STA529_FORMAT (SNDRV_PCM_FMTBIT_S16_LE \| \
73	SNDRV_PCM_FMTBIT_S24_LE \| \
74	SNDRV_PCM_FMTBIT_S32_LE)
75	#define S2PC_VALUE 0x98
76	#define CLOCK_OUT 0x60
ad1937cd AL	77	#define DATA_FORMAT_MSK 0x0E
	78	#define LEFT_J_DATA_FORMAT 0x00
	79	#define I2S_DATA_FORMAT 0x02
	80	#define RIGHT_J_DATA_FORMAT 0x04
3be58dbb RK	81	#define CODEC_MUTE_VAL 0x80
	82
	83	#define POWER_CNTLMSAK 0x40
	84	#define POWER_STDBY 0x40
	85	#define FFX_MASK 0x80
	86	#define FFX_OFF 0x80
	87	#define POWER_UP 0x00
	88	#define FFX_CLK_ENB 0x01
	89	#define FFX_CLK_DIS 0x00
	90	#define FFX_CLK_MSK 0x01
	91	#define PLAY_FREQ_RANGE_MSK 0x70
	92	#define CAP_FREQ_RANGE_MSK 0x0C
	93	#define PDATA_LEN_MSK 0xC0
	94	#define BCLK_TO_FS_MSK 0x30
	95	#define AUDIO_MUTE_MSK 0x80
	96
	97	static const struct reg_default sta529_reg_defaults[] = {
	98	{ 0, 0x35 }, /* R0 - FFX Configuration reg 0 */
	99	{ 1, 0xc8 }, /* R1 - FFX Configuration reg 1 */
	100	{ 2, 0x50 }, /* R2 - Master Volume */
	101	{ 3, 0x00 }, /* R3 - Left Volume */
	102	{ 4, 0x00 }, /* R4 - Right Volume */
	103	{ 10, 0xb2 }, /* R10 - S2P Config Reg 0 */
	104	{ 11, 0x41 }, /* R11 - S2P Config Reg 1 */
	105	{ 12, 0x92 }, /* R12 - P2S Config Reg 0 */
	106	{ 13, 0x41 }, /* R13 - P2S Config Reg 1 */
	107	{ 30, 0xd2 }, /* R30 - ADC Config Reg */
	108	{ 31, 0x40 }, /* R31 - clock Out Reg */
	109	{ 32, 0x21 }, /* R32 - Misc Register */
	110	};
	111
	112	struct sta529 {
	113	struct regmap *regmap;
	114	};
	115
	116	static bool sta529_readable(struct device *dev, unsigned int reg)
	117	{
	118	switch (reg) {
	119
	120	case STA529_FFXCFG0:
	121	case STA529_FFXCFG1:
	122	case STA529_MVOL:
	123	case STA529_LVOL:
	124	case STA529_RVOL:
	125	case STA529_S2PCFG0:
	126	case STA529_S2PCFG1:
	127	case STA529_P2SCFG0:
	128	case STA529_P2SCFG1:
	129	case STA529_ADCCFG:
	130	case STA529_CKOCFG:
	131	case STA529_MISC:
	132	return true;
	133	default:
	134	return false;
	135	}
	136	}
	137
	138
	139	static const char *pwm_mode_text[] = { "Binary", "Headphone", "Ternary",
	140	"Phase-shift"};
	141
	142	static const DECLARE_TLV_DB_SCALE(out_gain_tlv, -9150, 50, 0);
	143	static const DECLARE_TLV_DB_SCALE(master_vol_tlv, -12750, 50, 0);
f2812054	144	static SOC_ENUM_SINGLE_DECL(pwm_src, STA529_FFXCFG1, 4, pwm_mode_text);
3be58dbb RK	145
	146	static const struct snd_kcontrol_new sta529_snd_controls[] = {
	147	SOC_DOUBLE_R_TLV("Digital Playback Volume", STA529_LVOL, STA529_RVOL, 0,
	148	127, 0, out_gain_tlv),
	149	SOC_SINGLE_TLV("Master Playback Volume", STA529_MVOL, 0, 127, 1,
	150	master_vol_tlv),
	151	SOC_ENUM("PWM Select", pwm_src),
	152	};
	153
	154	static int sta529_set_bias_level(struct snd_soc_codec *codec, enum
	155	snd_soc_bias_level level)
	156	{
	157	struct sta529 *sta529 = snd_soc_codec_get_drvdata(codec);
	158
	159	switch (level) {
	160	case SND_SOC_BIAS_ON:
	161	case SND_SOC_BIAS_PREPARE:
	162	snd_soc_update_bits(codec, STA529_FFXCFG0, POWER_CNTLMSAK,
	163	POWER_UP);
	164	snd_soc_update_bits(codec, STA529_MISC, FFX_CLK_MSK,
	165	FFX_CLK_ENB);
	166	break;
	167	case SND_SOC_BIAS_STANDBY:
	168	if (codec->dapm.bias_level == SND_SOC_BIAS_OFF)
	169	regcache_sync(sta529->regmap);
	170	snd_soc_update_bits(codec, STA529_FFXCFG0,
	171	POWER_CNTLMSAK, POWER_STDBY);
	172	/* Making FFX output to zero */
	173	snd_soc_update_bits(codec, STA529_FFXCFG0, FFX_MASK,
	174	FFX_OFF);
	175	snd_soc_update_bits(codec, STA529_MISC, FFX_CLK_MSK,
	176	FFX_CLK_DIS);
	177	break;
	178	case SND_SOC_BIAS_OFF:
	179	break;
	180	}
	181
	182	/*
	183	* store the label for powers down audio subsystem for suspend.This is
	184	* used by soc core layer
	185	*/
	186	codec->dapm.bias_level = level;
	187
	188	return 0;
	189
	190	}
	191
	192	static int sta529_hw_params(struct snd_pcm_substream *substream,
	193	struct snd_pcm_hw_params *params,
	194	struct snd_soc_dai *dai)
	195	{
ab64246c	196	struct snd_soc_codec *codec = dai->codec;
3be58dbb RK	197	int pdata, play_freq_val, record_freq_val;
	198	int bclk_to_fs_ratio;
	199
1f9ffcb0 MB	200	switch (params_width(params)) {
1f9ffcb0 MB	201	case 16:
3be58dbb RK	202	pdata = 1;
	203	bclk_to_fs_ratio = 0;
	204	break;
1f9ffcb0	205	case 24:
3be58dbb RK	206	pdata = 2;
	207	bclk_to_fs_ratio = 1;
	208	break;
1f9ffcb0	209	case 32:
3be58dbb RK	210	pdata = 3;
	211	bclk_to_fs_ratio = 2;
	212	break;
	213	default:
	214	dev_err(codec->dev, "Unsupported format\n");
	215	return -EINVAL;
	216	}
	217
	218	switch (params_rate(params)) {
	219	case 8000:
	220	case 11025:
	221	play_freq_val = 0;
	222	record_freq_val = 2;
	223	break;
	224	case 16000:
	225	case 22050:
	226	play_freq_val = 1;
	227	record_freq_val = 0;
	228	break;
	229
	230	case 32000:
	231	case 44100:
	232	case 48000:
	233	play_freq_val = 2;
	234	record_freq_val = 0;
	235	break;
	236	default:
	237	dev_err(codec->dev, "Unsupported rate\n");
	238	return -EINVAL;
	239	}
	240
	241	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
	242	snd_soc_update_bits(codec, STA529_S2PCFG1, PDATA_LEN_MSK,
	243	pdata << 6);
	244	snd_soc_update_bits(codec, STA529_S2PCFG1, BCLK_TO_FS_MSK,
	245	bclk_to_fs_ratio << 4);
	246	snd_soc_update_bits(codec, STA529_MISC, PLAY_FREQ_RANGE_MSK,
	247	play_freq_val << 4);
	248	} else {
	249	snd_soc_update_bits(codec, STA529_P2SCFG1, PDATA_LEN_MSK,
	250	pdata << 6);
	251	snd_soc_update_bits(codec, STA529_P2SCFG1, BCLK_TO_FS_MSK,
	252	bclk_to_fs_ratio << 4);
	253	snd_soc_update_bits(codec, STA529_MISC, CAP_FREQ_RANGE_MSK,
	254	record_freq_val << 2);
	255	}
	256
	257	return 0;
	258	}
	259
	260	static int sta529_mute(struct snd_soc_dai *dai, int mute)
	261	{
	262	u8 val = 0;
	263
	264	if (mute)
	265	val \|= CODEC_MUTE_VAL;
	266
	267	snd_soc_update_bits(dai->codec, STA529_FFXCFG0, AUDIO_MUTE_MSK, val);
	268
	269	return 0;
	270	}
	271
	272	static int sta529_set_dai_fmt(struct snd_soc_dai *codec_dai, u32 fmt)
	273	{
274	struct snd_soc_codec *codec = codec_dai->codec;
275	u8 mode = 0;
276
277	/* interface format */
278	switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
279	case SND_SOC_DAIFMT_LEFT_J:
280	mode = LEFT_J_DATA_FORMAT;
281	break;
282	case SND_SOC_DAIFMT_I2S:
283	mode = I2S_DATA_FORMAT;
284	break;
285	case SND_SOC_DAIFMT_RIGHT_J:
286	mode = RIGHT_J_DATA_FORMAT;
287	break;
288	default:
289	return -EINVAL;
290	}
291
ad1937cd	292	snd_soc_update_bits(codec, STA529_S2PCFG0, DATA_FORMAT_MSK, mode);
3be58dbb RK	293
	294	return 0;
	295	}
	296
	297	static const struct snd_soc_dai_ops sta529_dai_ops = {
	298	.hw_params = sta529_hw_params,
	299	.set_fmt = sta529_set_dai_fmt,
	300	.digital_mute = sta529_mute,
	301	};
	302
	303	static struct snd_soc_dai_driver sta529_dai = {
	304	.name = "sta529-audio",
	305	.playback = {
	306	.stream_name = "Playback",
	307	.channels_min = 2,
	308	.channels_max = 2,
	309	.rates = STA529_RATES,
	310	.formats = STA529_FORMAT,
	311	},
	312	.capture = {
	313	.stream_name = "Capture",
	314	.channels_min = 2,
	315	.channels_max = 2,
	316	.rates = STA529_RATES,
	317	.formats = STA529_FORMAT,
	318	},
	319	.ops = &sta529_dai_ops,
	320	};
	321
	322	static int sta529_probe(struct snd_soc_codec *codec)
	323	{
3be58dbb RK	324	sta529_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
	325
	326	return 0;
	327	}
	328
	329	/* power down chip */
	330	static int sta529_remove(struct snd_soc_codec *codec)
	331	{
	332	sta529_set_bias_level(codec, SND_SOC_BIAS_OFF);
	333
	334	return 0;
	335	}
	336
	337	static int sta529_suspend(struct snd_soc_codec *codec)
	338	{
	339	sta529_set_bias_level(codec, SND_SOC_BIAS_OFF);
	340
	341	return 0;
	342	}
	343
	344	static int sta529_resume(struct snd_soc_codec *codec)
	345	{
	346	sta529_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
	347
	348	return 0;
	349	}
	350
1427cc37	351	static const struct snd_soc_codec_driver sta529_codec_driver = {
3be58dbb RK	352	.probe = sta529_probe,
	353	.remove = sta529_remove,
	354	.set_bias_level = sta529_set_bias_level,
	355	.suspend = sta529_suspend,
	356	.resume = sta529_resume,
	357	.controls = sta529_snd_controls,
	358	.num_controls = ARRAY_SIZE(sta529_snd_controls),
	359	};
	360
	361	static const struct regmap_config sta529_regmap = {
	362	.reg_bits = 8,
	363	.val_bits = 8,
	364
	365	.max_register = STA529_MAX_REGISTER,
	366	.readable_reg = sta529_readable,
	367
	368	.cache_type = REGCACHE_RBTREE,
	369	.reg_defaults = sta529_reg_defaults,
	370	.num_reg_defaults = ARRAY_SIZE(sta529_reg_defaults),
	371	};
	372
7a79e94e BP	373	static int sta529_i2c_probe(struct i2c_client *i2c,
7a79e94e BP	374	const struct i2c_device_id *id)
3be58dbb RK	375	{
	376	struct sta529 *sta529;
	377	int ret;
	378
	379	if (!i2c_check_functionality(i2c->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
	380	return -EINVAL;
	381
	382	sta529 = devm_kzalloc(&i2c->dev, sizeof(struct sta529), GFP_KERNEL);
5c1573a3	383	if (!sta529)
3be58dbb	384	return -ENOMEM;
3be58dbb RK	385
	386	sta529->regmap = devm_regmap_init_i2c(i2c, &sta529_regmap);
	387	if (IS_ERR(sta529->regmap)) {
f96985e3	388	ret = PTR_ERR(sta529->regmap);
3be58dbb	389	dev_err(&i2c->dev, "Failed to allocate regmap: %d\n", ret);
f96985e3	390	return ret;
3be58dbb RK	391	}
	392
	393	i2c_set_clientdata(i2c, sta529);
	394
	395	ret = snd_soc_register_codec(&i2c->dev,
	396	&sta529_codec_driver, &sta529_dai, 1);
	397	if (ret != 0)
	398	dev_err(&i2c->dev, "Failed to register CODEC: %d\n", ret);
	399
	400	return ret;
	401	}
	402
7a79e94e	403	static int sta529_i2c_remove(struct i2c_client *client)
3be58dbb RK	404	{
	405	snd_soc_unregister_codec(&client->dev);
	406
	407	return 0;
	408	}
	409
	410	static const struct i2c_device_id sta529_i2c_id[] = {
	411	{ "sta529", 0 },
	412	{ }
	413	};
	414	MODULE_DEVICE_TABLE(i2c, sta529_i2c_id);
	415
	416	static struct i2c_driver sta529_i2c_driver = {
	417	.driver = {
	418	.name = "sta529",
	419	.owner = THIS_MODULE,
	420	},
	421	.probe = sta529_i2c_probe,
7a79e94e	422	.remove = sta529_i2c_remove,
3be58dbb RK	423	.id_table = sta529_i2c_id,
	424	};
	425
	426	module_i2c_driver(sta529_i2c_driver);
	427
	428	MODULE_DESCRIPTION("ASoC STA529 codec driver");
b794dbcd	429	MODULE_AUTHOR("Rajeev Kumar <rajeevkumar.linux@gmail.com>");
3be58dbb	430	MODULE_LICENSE("GPL");