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

/*
 * ak4641.c  --  AK4641 ALSA Soc Audio driver
 *
 * Copyright (C) 2008 Harald Welte <laforge@gnufiish.org>
 * Copyright (C) 2011 Dmitry Artamonow <mad_soft@inbox.ru>
 *
 * Based on ak4535.c by Richard Purdie
 *
 * 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/init.h>
#include <linux/delay.h>
#include <linux/gpio.h>
#include <linux/pm.h>
#include <linux/i2c.h>
#include <linux/regmap.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 <sound/ak4641.h>

#include "ak4641.h"

/* codec private data */
struct ak4641_priv {
	struct regmap *regmap;
	unsigned int sysclk;
	int deemph;
	int playback_fs;
};

/*
 * ak4641 register cache
 */
static const struct reg_default ak4641_reg_defaults[] = {
	{  0, 0x00 }, {  1, 0x80 }, {  2, 0x00 }, {  3, 0x80 },
	{  4, 0x02 }, {  5, 0x00 }, {  6, 0x11 }, {  7, 0x05 },
	{  8, 0x00 }, {  9, 0x00 }, { 10, 0x36 }, { 11, 0x10 },
	{ 12, 0x00 }, { 13, 0x00 }, { 14, 0x57 }, { 15, 0x00 },
	{ 16, 0x88 }, { 17, 0x88 }, { 18, 0x08 }, { 19, 0x08 }
};

static const int deemph_settings[] = {44100, 0, 48000, 32000};

static int ak4641_set_deemph(struct snd_soc_codec *codec)
{
	struct ak4641_priv *ak4641 = snd_soc_codec_get_drvdata(codec);
	int i, best = 0;

	for (i = 0 ; i < ARRAY_SIZE(deemph_settings); i++) {
		/* if deemphasis is on, select the nearest available rate */
		if (ak4641->deemph && deemph_settings[i] != 0 &&
		    abs(deemph_settings[i] - ak4641->playback_fs) <
		    abs(deemph_settings[best] - ak4641->playback_fs))
			best = i;

		if (!ak4641->deemph && deemph_settings[i] == 0)
			best = i;
	}

	dev_dbg(codec->dev, "Set deemphasis %d\n", best);

	return snd_soc_update_bits(codec, AK4641_DAC, 0x3, best);
}

static int ak4641_put_deemph(struct snd_kcontrol *kcontrol,
				struct snd_ctl_elem_value *ucontrol)
{
	struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);
	struct ak4641_priv *ak4641 = snd_soc_codec_get_drvdata(codec);
	int deemph = ucontrol->value.integer.value[0];

	if (deemph > 1)
		return -EINVAL;

	ak4641->deemph = deemph;

	return ak4641_set_deemph(codec);
}

static int ak4641_get_deemph(struct snd_kcontrol *kcontrol,
				struct snd_ctl_elem_value *ucontrol)
{
	struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);
	struct ak4641_priv *ak4641 = snd_soc_codec_get_drvdata(codec);

	ucontrol->value.integer.value[0] = ak4641->deemph;
	return 0;
};

static const char *ak4641_mono_out[] = {"(L + R)/2", "Hi-Z"};
static const char *ak4641_hp_out[] = {"Stereo", "Mono"};
static const char *ak4641_mic_select[] = {"Internal", "External"};
static const char *ak4641_mic_or_dac[] = {"Microphone", "Voice DAC"};


static const DECLARE_TLV_DB_SCALE(mono_gain_tlv, -1700, 2300, 0);
static const DECLARE_TLV_DB_SCALE(mic_boost_tlv, 0, 2000, 0);
static const DECLARE_TLV_DB_SCALE(eq_tlv, -1050, 150, 0);
static const DECLARE_TLV_DB_SCALE(master_tlv, -12750, 50, 0);
static const DECLARE_TLV_DB_SCALE(mic_stereo_sidetone_tlv, -2700, 300, 0);
static const DECLARE_TLV_DB_SCALE(mic_mono_sidetone_tlv, -400, 400, 0);
static const DECLARE_TLV_DB_SCALE(capture_tlv, -800, 50, 0);
static const DECLARE_TLV_DB_SCALE(alc_tlv, -800, 50, 0);
static const DECLARE_TLV_DB_SCALE(aux_in_tlv, -2100, 300, 0);


static SOC_ENUM_SINGLE_DECL(ak4641_mono_out_enum,
			    AK4641_SIG1, 6, ak4641_mono_out);
static SOC_ENUM_SINGLE_DECL(ak4641_hp_out_enum,
			    AK4641_MODE2, 2, ak4641_hp_out);
static SOC_ENUM_SINGLE_DECL(ak4641_mic_select_enum,
			    AK4641_MIC, 1, ak4641_mic_select);
static SOC_ENUM_SINGLE_DECL(ak4641_mic_or_dac_enum,
			    AK4641_BTIF, 4, ak4641_mic_or_dac);

static const struct snd_kcontrol_new ak4641_snd_controls[] = {
	SOC_ENUM("Mono 1 Output", ak4641_mono_out_enum),
	SOC_SINGLE_TLV("Mono 1 Gain Volume", AK4641_SIG1, 7, 1, 1,
							mono_gain_tlv),
	SOC_ENUM("Headphone Output", ak4641_hp_out_enum),
	SOC_SINGLE_BOOL_EXT("Playback Deemphasis Switch", 0,
					ak4641_get_deemph, ak4641_put_deemph),

	SOC_SINGLE_TLV("Mic Boost Volume", AK4641_MIC, 0, 1, 0, mic_boost_tlv),

	SOC_SINGLE("ALC Operation Time", AK4641_TIMER, 0, 3, 0),
	SOC_SINGLE("ALC Recovery Time", AK4641_TIMER, 2, 3, 0),
	SOC_SINGLE("ALC ZC Time", AK4641_TIMER, 4, 3, 0),

	SOC_SINGLE("ALC 1 Switch", AK4641_ALC1, 5, 1, 0),

	SOC_SINGLE_TLV("ALC Volume", AK4641_ALC2, 0, 71, 0, alc_tlv),
	SOC_SINGLE("Left Out Enable Switch", AK4641_SIG2, 1, 1, 0),
	SOC_SINGLE("Right Out Enable Switch", AK4641_SIG2, 0, 1, 0),

	SOC_SINGLE_TLV("Capture Volume", AK4641_PGA, 0, 71, 0, capture_tlv),

	SOC_DOUBLE_R_TLV("Master Playback Volume", AK4641_LATT,
				AK4641_RATT, 0, 255, 1, master_tlv),

	SOC_SINGLE_TLV("AUX In Volume", AK4641_VOL, 0, 15, 0, aux_in_tlv),

	SOC_SINGLE("Equalizer Switch", AK4641_DAC, 2, 1, 0),
	SOC_SINGLE_TLV("EQ1 100 Hz Volume", AK4641_EQLO, 0, 15, 1, eq_tlv),
	SOC_SINGLE_TLV("EQ2 250 Hz Volume", AK4641_EQLO, 4, 15, 1, eq_tlv),
	SOC_SINGLE_TLV("EQ3 1 kHz Volume", AK4641_EQMID, 0, 15, 1, eq_tlv),
	SOC_SINGLE_TLV("EQ4 3.5 kHz Volume", AK4641_EQMID, 4, 15, 1, eq_tlv),
	SOC_SINGLE_TLV("EQ5 10 kHz Volume", AK4641_EQHI, 0, 15, 1, eq_tlv),
};

/* Mono 1 Mixer */
static const struct snd_kcontrol_new ak4641_mono1_mixer_controls[] = {
	SOC_DAPM_SINGLE_TLV("Mic Mono Sidetone Volume", AK4641_VOL, 7, 1, 0,
						mic_mono_sidetone_tlv),
	SOC_DAPM_SINGLE("Mic Mono Sidetone Switch", AK4641_SIG1, 4, 1, 0),
	SOC_DAPM_SINGLE("Mono Playback Switch", AK4641_SIG1, 5, 1, 0),
};

/* Stereo Mixer */
static const struct snd_kcontrol_new ak4641_stereo_mixer_controls[] = {
	SOC_DAPM_SINGLE_TLV("Mic Sidetone Volume", AK4641_VOL, 4, 7, 0,
						mic_stereo_sidetone_tlv),
	SOC_DAPM_SINGLE("Mic Sidetone Switch", AK4641_SIG2, 4, 1, 0),
	SOC_DAPM_SINGLE("Playback Switch", AK4641_SIG2, 7, 1, 0),
	SOC_DAPM_SINGLE("Aux Bypass Switch", AK4641_SIG2, 5, 1, 0),
};

/* Input Mixer */
static const struct snd_kcontrol_new ak4641_input_mixer_controls[] = {
	SOC_DAPM_SINGLE("Mic Capture Switch", AK4641_MIC, 2, 1, 0),
	SOC_DAPM_SINGLE("Aux Capture Switch", AK4641_MIC, 5, 1, 0),
};

/* Mic mux */
static const struct snd_kcontrol_new ak4641_mic_mux_control =
	SOC_DAPM_ENUM("Mic Select", ak4641_mic_select_enum);

/* Input mux */
static const struct snd_kcontrol_new ak4641_input_mux_control =
	SOC_DAPM_ENUM("Input Select", ak4641_mic_or_dac_enum);

/* mono 2 switch */
static const struct snd_kcontrol_new ak4641_mono2_control =
	SOC_DAPM_SINGLE("Switch", AK4641_SIG1, 0, 1, 0);

/* ak4641 dapm widgets */
static const struct snd_soc_dapm_widget ak4641_dapm_widgets[] = {
	SND_SOC_DAPM_MIXER("Stereo Mixer", SND_SOC_NOPM, 0, 0,
		&ak4641_stereo_mixer_controls[0],
		ARRAY_SIZE(ak4641_stereo_mixer_controls)),
	SND_SOC_DAPM_MIXER("Mono1 Mixer", SND_SOC_NOPM, 0, 0,
		&ak4641_mono1_mixer_controls[0],
		ARRAY_SIZE(ak4641_mono1_mixer_controls)),
	SND_SOC_DAPM_MIXER("Input Mixer", SND_SOC_NOPM, 0, 0,
		&ak4641_input_mixer_controls[0],
		ARRAY_SIZE(ak4641_input_mixer_controls)),
	SND_SOC_DAPM_MUX("Mic Mux", SND_SOC_NOPM, 0, 0,
		&ak4641_mic_mux_control),
	SND_SOC_DAPM_MUX("Input Mux", SND_SOC_NOPM, 0, 0,
		&ak4641_input_mux_control),
	SND_SOC_DAPM_SWITCH("Mono 2 Enable", SND_SOC_NOPM, 0, 0,
		&ak4641_mono2_control),

	SND_SOC_DAPM_OUTPUT("LOUT"),
	SND_SOC_DAPM_OUTPUT("ROUT"),
	SND_SOC_DAPM_OUTPUT("MOUT1"),
	SND_SOC_DAPM_OUTPUT("MOUT2"),
	SND_SOC_DAPM_OUTPUT("MICOUT"),

	SND_SOC_DAPM_ADC("ADC", "HiFi Capture", AK4641_PM1, 0, 0),
	SND_SOC_DAPM_PGA("Mic", AK4641_PM1, 1, 0, NULL, 0),
	SND_SOC_DAPM_PGA("AUX In", AK4641_PM1, 2, 0, NULL, 0),
	SND_SOC_DAPM_PGA("Mono Out", AK4641_PM1, 3, 0, NULL, 0),
	SND_SOC_DAPM_PGA("Line Out", AK4641_PM1, 4, 0, NULL, 0),

	SND_SOC_DAPM_DAC("DAC", "HiFi Playback", AK4641_PM2, 0, 0),
	SND_SOC_DAPM_PGA("Mono Out 2", AK4641_PM2, 3, 0, NULL, 0),

	SND_SOC_DAPM_ADC("Voice ADC", "Voice Capture", AK4641_BTIF, 0, 0),
	SND_SOC_DAPM_DAC("Voice DAC", "Voice Playback", AK4641_BTIF, 1, 0),

	SND_SOC_DAPM_MICBIAS("Mic Int Bias", AK4641_MIC, 3, 0),
	SND_SOC_DAPM_MICBIAS("Mic Ext Bias", AK4641_MIC, 4, 0),

	SND_SOC_DAPM_INPUT("MICIN"),
	SND_SOC_DAPM_INPUT("MICEXT"),
	SND_SOC_DAPM_INPUT("AUX"),
	SND_SOC_DAPM_INPUT("AIN"),
};

static const struct snd_soc_dapm_route ak4641_audio_map[] = {
	/* Stereo Mixer */
	{"Stereo Mixer", "Playback Switch", "DAC"},
	{"Stereo Mixer", "Mic Sidetone Switch", "Input Mux"},
	{"Stereo Mixer", "Aux Bypass Switch", "AUX In"},

	/* Mono 1 Mixer */
	{"Mono1 Mixer", "Mic Mono Sidetone Switch", "Input Mux"},
	{"Mono1 Mixer", "Mono Playback Switch", "DAC"},

	/* Mic */
	{"Mic", NULL, "AIN"},
	{"Mic Mux", "Internal", "Mic Int Bias"},
	{"Mic Mux", "External", "Mic Ext Bias"},
	{"Mic Int Bias", NULL, "MICIN"},
	{"Mic Ext Bias", NULL, "MICEXT"},
	{"MICOUT", NULL, "Mic Mux"},

	/* Input Mux */
	{"Input Mux", "Microphone", "Mic"},
	{"Input Mux", "Voice DAC", "Voice DAC"},

	/* Line Out */
	{"LOUT", NULL, "Line Out"},
	{"ROUT", NULL, "Line Out"},
	{"Line Out", NULL, "Stereo Mixer"},

	/* Mono 1 Out */
	{"MOUT1", NULL, "Mono Out"},
	{"Mono Out", NULL, "Mono1 Mixer"},

	/* Mono 2 Out */
	{"MOUT2", NULL, "Mono 2 Enable"},
	{"Mono 2 Enable", "Switch", "Mono Out 2"},
	{"Mono Out 2", NULL, "Stereo Mixer"},

	{"Voice ADC", NULL, "Mono 2 Enable"},

	/* Aux In */
	{"AUX In", NULL, "AUX"},

	/* ADC */
	{"ADC", NULL, "Input Mixer"},
	{"Input Mixer", "Mic Capture Switch", "Mic"},
	{"Input Mixer", "Aux Capture Switch", "AUX In"},
};

static int ak4641_set_dai_sysclk(struct snd_soc_dai *codec_dai,
	int clk_id, unsigned int freq, int dir)
{
	struct snd_soc_codec *codec = codec_dai->codec;
	struct ak4641_priv *ak4641 = snd_soc_codec_get_drvdata(codec);

	ak4641->sysclk = freq;
	return 0;
}

static int ak4641_i2s_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 ak4641_priv *ak4641 = snd_soc_codec_get_drvdata(codec);
	int rate = params_rate(params), fs = 256;
	u8 mode2;

	if (rate)
		fs = ak4641->sysclk / rate;
	else
		return -EINVAL;

	/* set fs */
	switch (fs) {
	case 1024:
		mode2 = (0x2 << 5);
		break;
	case 512:
		mode2 = (0x1 << 5);
		break;
	case 256:
		mode2 = (0x0 << 5);
		break;
	default:
		dev_err(codec->dev, "Error: unsupported fs=%d\n", fs);
		return -EINVAL;
	}

	snd_soc_update_bits(codec, AK4641_MODE2, (0x3 << 5), mode2);

	/* Update de-emphasis filter for the new rate */
	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
		ak4641->playback_fs = rate;
		ak4641_set_deemph(codec);
	}

	return 0;
}

static int ak4641_pcm_set_dai_fmt(struct snd_soc_dai *codec_dai,
				  unsigned int fmt)
{
	struct snd_soc_codec *codec = codec_dai->codec;
	u8 btif;
	int ret;

	/* interface format */
	switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
	case SND_SOC_DAIFMT_I2S:
		btif = (0x3 << 5);
		break;
	case SND_SOC_DAIFMT_LEFT_J:
		btif = (0x2 << 5);
		break;
	case SND_SOC_DAIFMT_DSP_A:	/* MSB after FRM */
		btif = (0x0 << 5);
		break;
	case SND_SOC_DAIFMT_DSP_B:	/* MSB during FRM */
		btif = (0x1 << 5);
		break;
	default:
		return -EINVAL;
	}

	ret = snd_soc_update_bits(codec, AK4641_BTIF, (0x3 << 5), btif);
	if (ret < 0)
		return ret;

	return 0;
}

static int ak4641_i2s_set_dai_fmt(struct snd_soc_dai *codec_dai,
		unsigned int fmt)
{
	struct snd_soc_codec *codec = codec_dai->codec;
	u8 mode1 = 0;

	/* interface format */
	switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
	case SND_SOC_DAIFMT_I2S:
		mode1 = 0x02;
		break;
	case SND_SOC_DAIFMT_LEFT_J:
		mode1 = 0x01;
		break;
	default:
		return -EINVAL;
	}

	return snd_soc_write(codec, AK4641_MODE1, mode1);
}

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

	return snd_soc_update_bits(codec, AK4641_DAC, 0x20, mute ? 0x20 : 0);
}

static int ak4641_set_bias_level(struct snd_soc_codec *codec,
	enum snd_soc_bias_level level)
{
	struct ak4641_priv *ak4641 = snd_soc_codec_get_drvdata(codec);
	struct ak4641_platform_data *pdata = codec->dev->platform_data;
	int ret;

	switch (level) {
	case SND_SOC_BIAS_ON:
		/* unmute */
		snd_soc_update_bits(codec, AK4641_DAC, 0x20, 0);
		break;
	case SND_SOC_BIAS_PREPARE:
		/* mute */
		snd_soc_update_bits(codec, AK4641_DAC, 0x20, 0x20);
		break;
	case SND_SOC_BIAS_STANDBY:
		if (snd_soc_codec_get_bias_level(codec) == SND_SOC_BIAS_OFF) {
			if (pdata && gpio_is_valid(pdata->gpio_power))
				gpio_set_value(pdata->gpio_power, 1);
			mdelay(1);
			if (pdata && gpio_is_valid(pdata->gpio_npdn))
				gpio_set_value(pdata->gpio_npdn, 1);
			mdelay(1);

			ret = regcache_sync(ak4641->regmap);
			if (ret) {
				dev_err(codec->dev,
					"Failed to sync cache: %d\n", ret);
				return ret;
			}
		}
		snd_soc_update_bits(codec, AK4641_PM1, 0x80, 0x80);
		snd_soc_update_bits(codec, AK4641_PM2, 0x80, 0);
		break;
	case SND_SOC_BIAS_OFF:
		snd_soc_update_bits(codec, AK4641_PM1, 0x80, 0);
		if (pdata && gpio_is_valid(pdata->gpio_npdn))
			gpio_set_value(pdata->gpio_npdn, 0);
		if (pdata && gpio_is_valid(pdata->gpio_power))
			gpio_set_value(pdata->gpio_power, 0);
		regcache_mark_dirty(ak4641->regmap);
		break;
	}
	return 0;
}

#define AK4641_RATES	(SNDRV_PCM_RATE_8000_48000)
#define AK4641_RATES_BT (SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_11025 |\
			 SNDRV_PCM_RATE_16000)
#define AK4641_FORMATS	(SNDRV_PCM_FMTBIT_S16_LE)

static const struct snd_soc_dai_ops ak4641_i2s_dai_ops = {
	.hw_params    = ak4641_i2s_hw_params,
	.set_fmt      = ak4641_i2s_set_dai_fmt,
	.digital_mute = ak4641_mute,
	.set_sysclk   = ak4641_set_dai_sysclk,
};

static const struct snd_soc_dai_ops ak4641_pcm_dai_ops = {
	.hw_params    = NULL, /* rates are controlled by BT chip */
	.set_fmt      = ak4641_pcm_set_dai_fmt,
	.digital_mute = ak4641_mute,
	.set_sysclk   = ak4641_set_dai_sysclk,
};

static struct snd_soc_dai_driver ak4641_dai[] = {
{
	.name = "ak4641-hifi",
	.id = 1,
	.playback = {
		.stream_name = "HiFi Playback",
		.channels_min = 1,
		.channels_max = 2,
		.rates = AK4641_RATES,
		.formats = AK4641_FORMATS,
	},
	.capture = {
		.stream_name = "HiFi Capture",
		.channels_min = 1,
		.channels_max = 2,
		.rates = AK4641_RATES,
		.formats = AK4641_FORMATS,
	},
	.ops = &ak4641_i2s_dai_ops,
	.symmetric_rates = 1,
},
{
	.name = "ak4641-voice",
	.id = 1,
	.playback = {
		.stream_name = "Voice Playback",
		.channels_min = 1,
		.channels_max = 1,
		.rates = AK4641_RATES_BT,
		.formats = AK4641_FORMATS,
	},
	.capture = {
		.stream_name = "Voice Capture",
		.channels_min = 1,
		.channels_max = 1,
		.rates = AK4641_RATES_BT,
		.formats = AK4641_FORMATS,
	},
	.ops = &ak4641_pcm_dai_ops,
	.symmetric_rates = 1,
},
};

static struct snd_soc_codec_driver soc_codec_dev_ak4641 = {
	.component_driver = {
		.controls		= ak4641_snd_controls,
		.num_controls		= ARRAY_SIZE(ak4641_snd_controls),
		.dapm_widgets		= ak4641_dapm_widgets,
		.num_dapm_widgets	= ARRAY_SIZE(ak4641_dapm_widgets),
		.dapm_routes		= ak4641_audio_map,
		.num_dapm_routes	= ARRAY_SIZE(ak4641_audio_map),
	},
	.set_bias_level		= ak4641_set_bias_level,
	.suspend_bias_off	= true,
};

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

	.max_register = AK4641_BTIF,
	.reg_defaults = ak4641_reg_defaults,
	.num_reg_defaults = ARRAY_SIZE(ak4641_reg_defaults),
	.cache_type = REGCACHE_RBTREE,
};

static int ak4641_i2c_probe(struct i2c_client *i2c,
			    const struct i2c_device_id *id)
{
	struct ak4641_platform_data *pdata = i2c->dev.platform_data;
	struct ak4641_priv *ak4641;
	int ret;

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

	ak4641->regmap = devm_regmap_init_i2c(i2c, &ak4641_regmap);
	if (IS_ERR(ak4641->regmap))
		return PTR_ERR(ak4641->regmap);

	if (pdata) {
		if (gpio_is_valid(pdata->gpio_power)) {
			ret = gpio_request_one(pdata->gpio_power,
					GPIOF_OUT_INIT_LOW, "ak4641 power");
			if (ret)
				goto err_out;
		}
		if (gpio_is_valid(pdata->gpio_npdn)) {
			ret = gpio_request_one(pdata->gpio_npdn,
					GPIOF_OUT_INIT_LOW, "ak4641 npdn");
			if (ret)
				goto err_gpio;

			udelay(1); /* > 150 ns */
			gpio_set_value(pdata->gpio_npdn, 1);
		}
	}

	i2c_set_clientdata(i2c, ak4641);

	ret = snd_soc_register_codec(&i2c->dev, &soc_codec_dev_ak4641,
				ak4641_dai, ARRAY_SIZE(ak4641_dai));
	if (ret != 0)
		goto err_gpio2;

	return 0;

err_gpio2:
	if (pdata) {
		if (gpio_is_valid(pdata->gpio_power))
			gpio_set_value(pdata->gpio_power, 0);
		if (gpio_is_valid(pdata->gpio_npdn))
			gpio_free(pdata->gpio_npdn);
	}
err_gpio:
	if (pdata && gpio_is_valid(pdata->gpio_power))
		gpio_free(pdata->gpio_power);
err_out:
	return ret;
}

static int ak4641_i2c_remove(struct i2c_client *i2c)
{
	struct ak4641_platform_data *pdata = i2c->dev.platform_data;

	snd_soc_unregister_codec(&i2c->dev);

	if (pdata) {
		if (gpio_is_valid(pdata->gpio_power)) {
			gpio_set_value(pdata->gpio_power, 0);
			gpio_free(pdata->gpio_power);
		}
		if (gpio_is_valid(pdata->gpio_npdn))
			gpio_free(pdata->gpio_npdn);
	}

	return 0;
}

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

static struct i2c_driver ak4641_i2c_driver = {
	.driver = {
		.name = "ak4641",
	},
	.probe =    ak4641_i2c_probe,
	.remove =   ak4641_i2c_remove,
	.id_table = ak4641_i2c_id,
};

module_i2c_driver(ak4641_i2c_driver);

MODULE_DESCRIPTION("SoC AK4641 driver");
MODULE_AUTHOR("Harald Welte <laforge@gnufiish.org>");
MODULE_LICENSE("GPL");
Commit	Line	Data
00d27010 DA	1	/*
	2	* ak4641.c -- AK4641 ALSA Soc Audio driver
	3	*
	4	* Copyright (C) 2008 Harald Welte <laforge@gnufiish.org>
	5	* Copyright (C) 2011 Dmitry Artamonow <mad_soft@inbox.ru>
	6	*
	7	* Based on ak4535.c by Richard Purdie
	8	*
	9	* This program is free software; you can redistribute it and/or modify
	10	* it under the terms of the GNU General Public License version 2 as
	11	* published by the Free Software Foundation.
	12	*/
	13
	14	#include <linux/module.h>
	15	#include <linux/init.h>
	16	#include <linux/delay.h>
	17	#include <linux/gpio.h>
	18	#include <linux/pm.h>
	19	#include <linux/i2c.h>
4f534777	20	#include <linux/regmap.h>
00d27010 DA	21	#include <linux/slab.h>
	22	#include <sound/core.h>
	23	#include <sound/pcm.h>
	24	#include <sound/pcm_params.h>
	25	#include <sound/soc.h>
	26	#include <sound/initval.h>
	27	#include <sound/tlv.h>
	28	#include <sound/ak4641.h>
	29
	30	#include "ak4641.h"
	31
	32	/* codec private data */
	33	struct ak4641_priv {
4f534777	34	struct regmap *regmap;
00d27010 DA	35	unsigned int sysclk;
	36	int deemph;
	37	int playback_fs;
	38	};
	39
	40	/*
	41	* ak4641 register cache
	42	*/
4f534777 MB	43	static const struct reg_default ak4641_reg_defaults[] = {
	44	{ 0, 0x00 }, { 1, 0x80 }, { 2, 0x00 }, { 3, 0x80 },
	45	{ 4, 0x02 }, { 5, 0x00 }, { 6, 0x11 }, { 7, 0x05 },
	46	{ 8, 0x00 }, { 9, 0x00 }, { 10, 0x36 }, { 11, 0x10 },
	47	{ 12, 0x00 }, { 13, 0x00 }, { 14, 0x57 }, { 15, 0x00 },
	48	{ 16, 0x88 }, { 17, 0x88 }, { 18, 0x08 }, { 19, 0x08 }
00d27010 DA	49	};
	50
	51	static const int deemph_settings[] = {44100, 0, 48000, 32000};
	52
	53	static int ak4641_set_deemph(struct snd_soc_codec *codec)
	54	{
	55	struct ak4641_priv *ak4641 = snd_soc_codec_get_drvdata(codec);
	56	int i, best = 0;
	57
	58	for (i = 0 ; i < ARRAY_SIZE(deemph_settings); i++) {
	59	/* if deemphasis is on, select the nearest available rate */
	60	if (ak4641->deemph && deemph_settings[i] != 0 &&
	61	abs(deemph_settings[i] - ak4641->playback_fs) <
	62	abs(deemph_settings[best] - ak4641->playback_fs))
	63	best = i;
	64
	65	if (!ak4641->deemph && deemph_settings[i] == 0)
	66	best = i;
	67	}
	68
	69	dev_dbg(codec->dev, "Set deemphasis %d\n", best);
	70
	71	return snd_soc_update_bits(codec, AK4641_DAC, 0x3, best);
	72	}
	73
	74	static int ak4641_put_deemph(struct snd_kcontrol *kcontrol,
	75	struct snd_ctl_elem_value *ucontrol)
	76	{
ea53bf77	77	struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);
00d27010	78	struct ak4641_priv *ak4641 = snd_soc_codec_get_drvdata(codec);
08641d9b	79	int deemph = ucontrol->value.integer.value[0];
00d27010 DA	80
	81	if (deemph > 1)
	82	return -EINVAL;
	83
	84	ak4641->deemph = deemph;
	85
	86	return ak4641_set_deemph(codec);
	87	}
	88
	89	static int ak4641_get_deemph(struct snd_kcontrol *kcontrol,
	90	struct snd_ctl_elem_value *ucontrol)
	91	{
ea53bf77	92	struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);
00d27010 DA	93	struct ak4641_priv *ak4641 = snd_soc_codec_get_drvdata(codec);
00d27010 DA	94
08641d9b	95	ucontrol->value.integer.value[0] = ak4641->deemph;
00d27010 DA	96	return 0;
	97	};
	98
	99	static const char *ak4641_mono_out[] = {"(L + R)/2", "Hi-Z"};
	100	static const char *ak4641_hp_out[] = {"Stereo", "Mono"};
	101	static const char *ak4641_mic_select[] = {"Internal", "External"};
	102	static const char *ak4641_mic_or_dac[] = {"Microphone", "Voice DAC"};
	103
	104
	105	static const DECLARE_TLV_DB_SCALE(mono_gain_tlv, -1700, 2300, 0);
	106	static const DECLARE_TLV_DB_SCALE(mic_boost_tlv, 0, 2000, 0);
	107	static const DECLARE_TLV_DB_SCALE(eq_tlv, -1050, 150, 0);
	108	static const DECLARE_TLV_DB_SCALE(master_tlv, -12750, 50, 0);
	109	static const DECLARE_TLV_DB_SCALE(mic_stereo_sidetone_tlv, -2700, 300, 0);
	110	static const DECLARE_TLV_DB_SCALE(mic_mono_sidetone_tlv, -400, 400, 0);
	111	static const DECLARE_TLV_DB_SCALE(capture_tlv, -800, 50, 0);
	112	static const DECLARE_TLV_DB_SCALE(alc_tlv, -800, 50, 0);
	113	static const DECLARE_TLV_DB_SCALE(aux_in_tlv, -2100, 300, 0);
	114
	115
cbf62422 TI	116	static SOC_ENUM_SINGLE_DECL(ak4641_mono_out_enum,
	117	AK4641_SIG1, 6, ak4641_mono_out);
	118	static SOC_ENUM_SINGLE_DECL(ak4641_hp_out_enum,
	119	AK4641_MODE2, 2, ak4641_hp_out);
	120	static SOC_ENUM_SINGLE_DECL(ak4641_mic_select_enum,
	121	AK4641_MIC, 1, ak4641_mic_select);
	122	static SOC_ENUM_SINGLE_DECL(ak4641_mic_or_dac_enum,
	123	AK4641_BTIF, 4, ak4641_mic_or_dac);
00d27010 DA	124
	125	static const struct snd_kcontrol_new ak4641_snd_controls[] = {
	126	SOC_ENUM("Mono 1 Output", ak4641_mono_out_enum),
	127	SOC_SINGLE_TLV("Mono 1 Gain Volume", AK4641_SIG1, 7, 1, 1,
	128	mono_gain_tlv),
	129	SOC_ENUM("Headphone Output", ak4641_hp_out_enum),
	130	SOC_SINGLE_BOOL_EXT("Playback Deemphasis Switch", 0,
	131	ak4641_get_deemph, ak4641_put_deemph),
	132
	133	SOC_SINGLE_TLV("Mic Boost Volume", AK4641_MIC, 0, 1, 0, mic_boost_tlv),
	134
	135	SOC_SINGLE("ALC Operation Time", AK4641_TIMER, 0, 3, 0),
	136	SOC_SINGLE("ALC Recovery Time", AK4641_TIMER, 2, 3, 0),
	137	SOC_SINGLE("ALC ZC Time", AK4641_TIMER, 4, 3, 0),
	138
	139	SOC_SINGLE("ALC 1 Switch", AK4641_ALC1, 5, 1, 0),
	140
	141	SOC_SINGLE_TLV("ALC Volume", AK4641_ALC2, 0, 71, 0, alc_tlv),
	142	SOC_SINGLE("Left Out Enable Switch", AK4641_SIG2, 1, 1, 0),
	143	SOC_SINGLE("Right Out Enable Switch", AK4641_SIG2, 0, 1, 0),
	144
	145	SOC_SINGLE_TLV("Capture Volume", AK4641_PGA, 0, 71, 0, capture_tlv),
	146
	147	SOC_DOUBLE_R_TLV("Master Playback Volume", AK4641_LATT,
	148	AK4641_RATT, 0, 255, 1, master_tlv),
	149
	150	SOC_SINGLE_TLV("AUX In Volume", AK4641_VOL, 0, 15, 0, aux_in_tlv),
	151
	152	SOC_SINGLE("Equalizer Switch", AK4641_DAC, 2, 1, 0),
	153	SOC_SINGLE_TLV("EQ1 100 Hz Volume", AK4641_EQLO, 0, 15, 1, eq_tlv),
	154	SOC_SINGLE_TLV("EQ2 250 Hz Volume", AK4641_EQLO, 4, 15, 1, eq_tlv),
	155	SOC_SINGLE_TLV("EQ3 1 kHz Volume", AK4641_EQMID, 0, 15, 1, eq_tlv),
	156	SOC_SINGLE_TLV("EQ4 3.5 kHz Volume", AK4641_EQMID, 4, 15, 1, eq_tlv),
	157	SOC_SINGLE_TLV("EQ5 10 kHz Volume", AK4641_EQHI, 0, 15, 1, eq_tlv),
	158	};
	159
	160	/* Mono 1 Mixer */
	161	static const struct snd_kcontrol_new ak4641_mono1_mixer_controls[] = {
	162	SOC_DAPM_SINGLE_TLV("Mic Mono Sidetone Volume", AK4641_VOL, 7, 1, 0,
	163	mic_mono_sidetone_tlv),
	164	SOC_DAPM_SINGLE("Mic Mono Sidetone Switch", AK4641_SIG1, 4, 1, 0),
	165	SOC_DAPM_SINGLE("Mono Playback Switch", AK4641_SIG1, 5, 1, 0),
	166	};
	167
	168	/* Stereo Mixer */
	169	static const struct snd_kcontrol_new ak4641_stereo_mixer_controls[] = {
	170	SOC_DAPM_SINGLE_TLV("Mic Sidetone Volume", AK4641_VOL, 4, 7, 0,
	171	mic_stereo_sidetone_tlv),
	172	SOC_DAPM_SINGLE("Mic Sidetone Switch", AK4641_SIG2, 4, 1, 0),
	173	SOC_DAPM_SINGLE("Playback Switch", AK4641_SIG2, 7, 1, 0),
	174	SOC_DAPM_SINGLE("Aux Bypass Switch", AK4641_SIG2, 5, 1, 0),
	175	};
	176
	177	/* Input Mixer */
	178	static const struct snd_kcontrol_new ak4641_input_mixer_controls[] = {
	179	SOC_DAPM_SINGLE("Mic Capture Switch", AK4641_MIC, 2, 1, 0),
	180	SOC_DAPM_SINGLE("Aux Capture Switch", AK4641_MIC, 5, 1, 0),
	181	};
	182
	183	/* Mic mux */
	184	static const struct snd_kcontrol_new ak4641_mic_mux_control =
	185	SOC_DAPM_ENUM("Mic Select", ak4641_mic_select_enum);
	186
	187	/* Input mux */
188	static const struct snd_kcontrol_new ak4641_input_mux_control =
189	SOC_DAPM_ENUM("Input Select", ak4641_mic_or_dac_enum);
190
191	/* mono 2 switch */
192	static const struct snd_kcontrol_new ak4641_mono2_control =
193	SOC_DAPM_SINGLE("Switch", AK4641_SIG1, 0, 1, 0);
194
195	/* ak4641 dapm widgets */
196	static const struct snd_soc_dapm_widget ak4641_dapm_widgets[] = {
197	SND_SOC_DAPM_MIXER("Stereo Mixer", SND_SOC_NOPM, 0, 0,
198	&ak4641_stereo_mixer_controls[0],
199	ARRAY_SIZE(ak4641_stereo_mixer_controls)),
200	SND_SOC_DAPM_MIXER("Mono1 Mixer", SND_SOC_NOPM, 0, 0,
201	&ak4641_mono1_mixer_controls[0],
202	ARRAY_SIZE(ak4641_mono1_mixer_controls)),
203	SND_SOC_DAPM_MIXER("Input Mixer", SND_SOC_NOPM, 0, 0,
204	&ak4641_input_mixer_controls[0],
205	ARRAY_SIZE(ak4641_input_mixer_controls)),
206	SND_SOC_DAPM_MUX("Mic Mux", SND_SOC_NOPM, 0, 0,
207	&ak4641_mic_mux_control),
208	SND_SOC_DAPM_MUX("Input Mux", SND_SOC_NOPM, 0, 0,
209	&ak4641_input_mux_control),
210	SND_SOC_DAPM_SWITCH("Mono 2 Enable", SND_SOC_NOPM, 0, 0,
211	&ak4641_mono2_control),
212
213	SND_SOC_DAPM_OUTPUT("LOUT"),
214	SND_SOC_DAPM_OUTPUT("ROUT"),
215	SND_SOC_DAPM_OUTPUT("MOUT1"),
216	SND_SOC_DAPM_OUTPUT("MOUT2"),
217	SND_SOC_DAPM_OUTPUT("MICOUT"),
218
219	SND_SOC_DAPM_ADC("ADC", "HiFi Capture", AK4641_PM1, 0, 0),
220	SND_SOC_DAPM_PGA("Mic", AK4641_PM1, 1, 0, NULL, 0),
221	SND_SOC_DAPM_PGA("AUX In", AK4641_PM1, 2, 0, NULL, 0),
222	SND_SOC_DAPM_PGA("Mono Out", AK4641_PM1, 3, 0, NULL, 0),
223	SND_SOC_DAPM_PGA("Line Out", AK4641_PM1, 4, 0, NULL, 0),
224
225	SND_SOC_DAPM_DAC("DAC", "HiFi Playback", AK4641_PM2, 0, 0),
226	SND_SOC_DAPM_PGA("Mono Out 2", AK4641_PM2, 3, 0, NULL, 0),
227
228	SND_SOC_DAPM_ADC("Voice ADC", "Voice Capture", AK4641_BTIF, 0, 0),
24441e17	229	SND_SOC_DAPM_DAC("Voice DAC", "Voice Playback", AK4641_BTIF, 1, 0),
00d27010 DA	230
	231	SND_SOC_DAPM_MICBIAS("Mic Int Bias", AK4641_MIC, 3, 0),
	232	SND_SOC_DAPM_MICBIAS("Mic Ext Bias", AK4641_MIC, 4, 0),
	233
	234	SND_SOC_DAPM_INPUT("MICIN"),
	235	SND_SOC_DAPM_INPUT("MICEXT"),
	236	SND_SOC_DAPM_INPUT("AUX"),
	237	SND_SOC_DAPM_INPUT("AIN"),
	238	};
	239
	240	static const struct snd_soc_dapm_route ak4641_audio_map[] = {
	241	/* Stereo Mixer */
	242	{"Stereo Mixer", "Playback Switch", "DAC"},
	243	{"Stereo Mixer", "Mic Sidetone Switch", "Input Mux"},
	244	{"Stereo Mixer", "Aux Bypass Switch", "AUX In"},
	245
	246	/* Mono 1 Mixer */
	247	{"Mono1 Mixer", "Mic Mono Sidetone Switch", "Input Mux"},
	248	{"Mono1 Mixer", "Mono Playback Switch", "DAC"},
	249
	250	/* Mic */
	251	{"Mic", NULL, "AIN"},
	252	{"Mic Mux", "Internal", "Mic Int Bias"},
	253	{"Mic Mux", "External", "Mic Ext Bias"},
	254	{"Mic Int Bias", NULL, "MICIN"},
	255	{"Mic Ext Bias", NULL, "MICEXT"},
	256	{"MICOUT", NULL, "Mic Mux"},
	257
	258	/* Input Mux */
	259	{"Input Mux", "Microphone", "Mic"},
	260	{"Input Mux", "Voice DAC", "Voice DAC"},
	261
	262	/* Line Out */
	263	{"LOUT", NULL, "Line Out"},
	264	{"ROUT", NULL, "Line Out"},
	265	{"Line Out", NULL, "Stereo Mixer"},
	266
	267	/* Mono 1 Out */
	268	{"MOUT1", NULL, "Mono Out"},
	269	{"Mono Out", NULL, "Mono1 Mixer"},
	270
	271	/* Mono 2 Out */
	272	{"MOUT2", NULL, "Mono 2 Enable"},
	273	{"Mono 2 Enable", "Switch", "Mono Out 2"},
	274	{"Mono Out 2", NULL, "Stereo Mixer"},
	275
	276	{"Voice ADC", NULL, "Mono 2 Enable"},
	277
	278	/* Aux In */
	279	{"AUX In", NULL, "AUX"},
	280
	281	/* ADC */
	282	{"ADC", NULL, "Input Mixer"},
	283	{"Input Mixer", "Mic Capture Switch", "Mic"},
	284	{"Input Mixer", "Aux Capture Switch", "AUX In"},
	285	};
	286
	287	static int ak4641_set_dai_sysclk(struct snd_soc_dai *codec_dai,
	288	int clk_id, unsigned int freq, int dir)
	289	{
	290	struct snd_soc_codec *codec = codec_dai->codec;
	291	struct ak4641_priv *ak4641 = snd_soc_codec_get_drvdata(codec);
	292
	293	ak4641->sysclk = freq;
294	return 0;
295	}
296
297	static int ak4641_i2s_hw_params(struct snd_pcm_substream *substream,
298	struct snd_pcm_hw_params *params,
299	struct snd_soc_dai *dai)
300	{
e6968a17	301	struct snd_soc_codec *codec = dai->codec;
00d27010 DA	302	struct ak4641_priv *ak4641 = snd_soc_codec_get_drvdata(codec);
	303	int rate = params_rate(params), fs = 256;
	304	u8 mode2;
	305
	306	if (rate)
	307	fs = ak4641->sysclk / rate;
	308	else
	309	return -EINVAL;
	310
	311	/* set fs */
	312	switch (fs) {
	313	case 1024:
	314	mode2 = (0x2 << 5);
	315	break;
	316	case 512:
	317	mode2 = (0x1 << 5);
	318	break;
	319	case 256:
	320	mode2 = (0x0 << 5);
	321	break;
	322	default:
	323	dev_err(codec->dev, "Error: unsupported fs=%d\n", fs);
	324	return -EINVAL;
	325	}
	326
	327	snd_soc_update_bits(codec, AK4641_MODE2, (0x3 << 5), mode2);
	328
	329	/* Update de-emphasis filter for the new rate */
	330	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
	331	ak4641->playback_fs = rate;
	332	ak4641_set_deemph(codec);
1d198f26	333	}
00d27010 DA	334
	335	return 0;
	336	}
	337
	338	static int ak4641_pcm_set_dai_fmt(struct snd_soc_dai *codec_dai,
	339	unsigned int fmt)
	340	{
	341	struct snd_soc_codec *codec = codec_dai->codec;
	342	u8 btif;
16aff769	343	int ret;
00d27010 DA	344
	345	/* interface format */
	346	switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
	347	case SND_SOC_DAIFMT_I2S:
	348	btif = (0x3 << 5);
	349	break;
	350	case SND_SOC_DAIFMT_LEFT_J:
	351	btif = (0x2 << 5);
	352	break;
	353	case SND_SOC_DAIFMT_DSP_A: /* MSB after FRM */
	354	btif = (0x0 << 5);
	355	break;
	356	case SND_SOC_DAIFMT_DSP_B: /* MSB during FRM */
	357	btif = (0x1 << 5);
	358	break;
	359	default:
	360	return -EINVAL;
	361	}
	362
16aff769 AL	363	ret = snd_soc_update_bits(codec, AK4641_BTIF, (0x3 << 5), btif);
	364	if (ret < 0)
	365	return ret;
	366
	367	return 0;
00d27010 DA	368	}
	369
	370	static int ak4641_i2s_set_dai_fmt(struct snd_soc_dai *codec_dai,
	371	unsigned int fmt)
	372	{
	373	struct snd_soc_codec *codec = codec_dai->codec;
	374	u8 mode1 = 0;
	375
	376	/* interface format */
	377	switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
	378	case SND_SOC_DAIFMT_I2S:
	379	mode1 = 0x02;
	380	break;
	381	case SND_SOC_DAIFMT_LEFT_J:
	382	mode1 = 0x01;
	383	break;
	384	default:
	385	return -EINVAL;
	386	}
	387
	388	return snd_soc_write(codec, AK4641_MODE1, mode1);
	389	}
	390
	391	static int ak4641_mute(struct snd_soc_dai *dai, int mute)
	392	{
	393	struct snd_soc_codec *codec = dai->codec;
	394
	395	return snd_soc_update_bits(codec, AK4641_DAC, 0x20, mute ? 0x20 : 0);
	396	}
	397
	398	static int ak4641_set_bias_level(struct snd_soc_codec *codec,
	399	enum snd_soc_bias_level level)
	400	{
4f534777	401	struct ak4641_priv *ak4641 = snd_soc_codec_get_drvdata(codec);
00d27010 DA	402	struct ak4641_platform_data *pdata = codec->dev->platform_data;
	403	int ret;
	404
	405	switch (level) {
	406	case SND_SOC_BIAS_ON:
	407	/* unmute */
	408	snd_soc_update_bits(codec, AK4641_DAC, 0x20, 0);
	409	break;
	410	case SND_SOC_BIAS_PREPARE:
	411	/* mute */
	412	snd_soc_update_bits(codec, AK4641_DAC, 0x20, 0x20);
	413	break;
	414	case SND_SOC_BIAS_STANDBY:
6d701b6d	415	if (snd_soc_codec_get_bias_level(codec) == SND_SOC_BIAS_OFF) {
00d27010 DA	416	if (pdata && gpio_is_valid(pdata->gpio_power))
	417	gpio_set_value(pdata->gpio_power, 1);
	418	mdelay(1);
	419	if (pdata && gpio_is_valid(pdata->gpio_npdn))
	420	gpio_set_value(pdata->gpio_npdn, 1);
	421	mdelay(1);
	422
4f534777	423	ret = regcache_sync(ak4641->regmap);
00d27010 DA	424	if (ret) {
	425	dev_err(codec->dev,
	426	"Failed to sync cache: %d\n", ret);
	427	return ret;
	428	}
	429	}
	430	snd_soc_update_bits(codec, AK4641_PM1, 0x80, 0x80);
	431	snd_soc_update_bits(codec, AK4641_PM2, 0x80, 0);
	432	break;
	433	case SND_SOC_BIAS_OFF:
	434	snd_soc_update_bits(codec, AK4641_PM1, 0x80, 0);
	435	if (pdata && gpio_is_valid(pdata->gpio_npdn))
	436	gpio_set_value(pdata->gpio_npdn, 0);
	437	if (pdata && gpio_is_valid(pdata->gpio_power))
	438	gpio_set_value(pdata->gpio_power, 0);
4f534777	439	regcache_mark_dirty(ak4641->regmap);
00d27010 DA	440	break;
00d27010 DA	441	}
00d27010 DA	442	return 0;
	443	}
	444
	445	#define AK4641_RATES (SNDRV_PCM_RATE_8000_48000)
	446	#define AK4641_RATES_BT (SNDRV_PCM_RATE_8000 \| SNDRV_PCM_RATE_11025 \|\
	447	SNDRV_PCM_RATE_16000)
	448	#define AK4641_FORMATS (SNDRV_PCM_FMTBIT_S16_LE)
	449
85e7652d	450	static const struct snd_soc_dai_ops ak4641_i2s_dai_ops = {
00d27010 DA	451	.hw_params = ak4641_i2s_hw_params,
	452	.set_fmt = ak4641_i2s_set_dai_fmt,
	453	.digital_mute = ak4641_mute,
	454	.set_sysclk = ak4641_set_dai_sysclk,
	455	};
	456
85e7652d	457	static const struct snd_soc_dai_ops ak4641_pcm_dai_ops = {
00d27010 DA	458	.hw_params = NULL, /* rates are controlled by BT chip */
	459	.set_fmt = ak4641_pcm_set_dai_fmt,
	460	.digital_mute = ak4641_mute,
	461	.set_sysclk = ak4641_set_dai_sysclk,
	462	};
	463
37aa716a	464	static struct snd_soc_dai_driver ak4641_dai[] = {
00d27010 DA	465	{
	466	.name = "ak4641-hifi",
	467	.id = 1,
	468	.playback = {
	469	.stream_name = "HiFi Playback",
	470	.channels_min = 1,
	471	.channels_max = 2,
	472	.rates = AK4641_RATES,
	473	.formats = AK4641_FORMATS,
	474	},
	475	.capture = {
	476	.stream_name = "HiFi Capture",
	477	.channels_min = 1,
	478	.channels_max = 2,
	479	.rates = AK4641_RATES,
	480	.formats = AK4641_FORMATS,
	481	},
	482	.ops = &ak4641_i2s_dai_ops,
	483	.symmetric_rates = 1,
	484	},
	485	{
	486	.name = "ak4641-voice",
	487	.id = 1,
	488	.playback = {
	489	.stream_name = "Voice Playback",
	490	.channels_min = 1,
	491	.channels_max = 1,
	492	.rates = AK4641_RATES_BT,
	493	.formats = AK4641_FORMATS,
	494	},
	495	.capture = {
	496	.stream_name = "Voice Capture",
	497	.channels_min = 1,
	498	.channels_max = 1,
	499	.rates = AK4641_RATES_BT,
	500	.formats = AK4641_FORMATS,
	501	},
	502	.ops = &ak4641_pcm_dai_ops,
	503	.symmetric_rates = 1,
	504	},
	505	};
	506
00d27010	507	static struct snd_soc_codec_driver soc_codec_dev_ak4641 = {
f303eb9e KM	508	.component_driver = {
	509	.controls = ak4641_snd_controls,
	510	.num_controls = ARRAY_SIZE(ak4641_snd_controls),
	511	.dapm_widgets = ak4641_dapm_widgets,
	512	.num_dapm_widgets = ARRAY_SIZE(ak4641_dapm_widgets),
	513	.dapm_routes = ak4641_audio_map,
	514	.num_dapm_routes = ARRAY_SIZE(ak4641_audio_map),
	515	},
00d27010	516	.set_bias_level = ak4641_set_bias_level,
0b0171e3	517	.suspend_bias_off = true,
00d27010 DA	518	};
00d27010 DA	519
4f534777 MB	520	static const struct regmap_config ak4641_regmap = {
	521	.reg_bits = 8,
	522	.val_bits = 8,
	523
	524	.max_register = AK4641_BTIF,
	525	.reg_defaults = ak4641_reg_defaults,
	526	.num_reg_defaults = ARRAY_SIZE(ak4641_reg_defaults),
	527	.cache_type = REGCACHE_RBTREE,
	528	};
00d27010	529
7a79e94e BP	530	static int ak4641_i2c_probe(struct i2c_client *i2c,
7a79e94e BP	531	const struct i2c_device_id *id)
00d27010	532	{
253322c1	533	struct ak4641_platform_data *pdata = i2c->dev.platform_data;
00d27010 DA	534	struct ak4641_priv *ak4641;
	535	int ret;
	536
4273fcfd AL	537	ak4641 = devm_kzalloc(&i2c->dev, sizeof(struct ak4641_priv),
4273fcfd AL	538	GFP_KERNEL);
00d27010 DA	539	if (!ak4641)
	540	return -ENOMEM;
	541
4f534777 MB	542	ak4641->regmap = devm_regmap_init_i2c(i2c, &ak4641_regmap);
	543	if (IS_ERR(ak4641->regmap))
	544	return PTR_ERR(ak4641->regmap);
	545
253322c1 MB	546	if (pdata) {
	547	if (gpio_is_valid(pdata->gpio_power)) {
	548	ret = gpio_request_one(pdata->gpio_power,
	549	GPIOF_OUT_INIT_LOW, "ak4641 power");
	550	if (ret)
	551	goto err_out;
	552	}
	553	if (gpio_is_valid(pdata->gpio_npdn)) {
	554	ret = gpio_request_one(pdata->gpio_npdn,
	555	GPIOF_OUT_INIT_LOW, "ak4641 npdn");
	556	if (ret)
	557	goto err_gpio;
	558
	559	udelay(1); /* > 150 ns */
	560	gpio_set_value(pdata->gpio_npdn, 1);
	561	}
	562	}
	563
00d27010 DA	564	i2c_set_clientdata(i2c, ak4641);
	565
	566	ret = snd_soc_register_codec(&i2c->dev, &soc_codec_dev_ak4641,
	567	ak4641_dai, ARRAY_SIZE(ak4641_dai));
253322c1 MB	568	if (ret != 0)
	569	goto err_gpio2;
	570
	571	return 0;
	572
	573	err_gpio2:
	574	if (pdata) {
	575	if (gpio_is_valid(pdata->gpio_power))
	576	gpio_set_value(pdata->gpio_power, 0);
	577	if (gpio_is_valid(pdata->gpio_npdn))
	578	gpio_free(pdata->gpio_npdn);
	579	}
	580	err_gpio:
	581	if (pdata && gpio_is_valid(pdata->gpio_power))
	582	gpio_free(pdata->gpio_power);
	583	err_out:
00d27010 DA	584	return ret;
	585	}
	586
7a79e94e	587	static int ak4641_i2c_remove(struct i2c_client *i2c)
00d27010	588	{
253322c1 MB	589	struct ak4641_platform_data *pdata = i2c->dev.platform_data;
253322c1 MB	590
00d27010	591	snd_soc_unregister_codec(&i2c->dev);
253322c1 MB	592
	593	if (pdata) {
	594	if (gpio_is_valid(pdata->gpio_power)) {
	595	gpio_set_value(pdata->gpio_power, 0);
	596	gpio_free(pdata->gpio_power);
	597	}
	598	if (gpio_is_valid(pdata->gpio_npdn))
	599	gpio_free(pdata->gpio_npdn);
	600	}
	601
00d27010 DA	602	return 0;
	603	}
	604
	605	static const struct i2c_device_id ak4641_i2c_id[] = {
	606	{ "ak4641", 0 },
	607	{ }
	608	};
	609	MODULE_DEVICE_TABLE(i2c, ak4641_i2c_id);
	610
	611	static struct i2c_driver ak4641_i2c_driver = {
	612	.driver = {
	613	.name = "ak4641",
00d27010 DA	614	},
00d27010 DA	615	.probe = ak4641_i2c_probe,
7a79e94e	616	.remove = ak4641_i2c_remove,
00d27010 DA	617	.id_table = ak4641_i2c_id,
	618	};
	619
a0abacd8	620	module_i2c_driver(ak4641_i2c_driver);
00d27010 DA	621
	622	MODULE_DESCRIPTION("SoC AK4641 driver");
	623	MODULE_AUTHOR("Harald Welte <laforge@gnufiish.org>");
	624	MODULE_LICENSE("GPL");