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