1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * cs53l30.c  --  CS53l30 ALSA Soc Audio driver
4  *
5  * Copyright 2015 Cirrus Logic, Inc.
6  *
7  * Authors: Paul Handrigan <Paul.Handrigan@cirrus.com>,
8  *          Tim Howe <Tim.Howe@cirrus.com>
9  */
10 
11 #include <linux/clk.h>
12 #include <linux/delay.h>
13 #include <linux/i2c.h>
14 #include <linux/module.h>
15 #include <linux/of_gpio.h>
16 #include <linux/gpio/consumer.h>
17 #include <linux/regulator/consumer.h>
18 #include <sound/pcm_params.h>
19 #include <sound/soc.h>
20 #include <sound/tlv.h>
21 
22 #include "cs53l30.h"
23 #include "cirrus_legacy.h"
24 
25 #define CS53L30_NUM_SUPPLIES 2
26 static const char *const cs53l30_supply_names[CS53L30_NUM_SUPPLIES] = {
27 	"VA",
28 	"VP",
29 };
30 
31 struct cs53l30_private {
32 	struct regulator_bulk_data	supplies[CS53L30_NUM_SUPPLIES];
33 	struct regmap			*regmap;
34 	struct gpio_desc		*reset_gpio;
35 	struct gpio_desc		*mute_gpio;
36 	struct clk			*mclk;
37 	bool				use_sdout2;
38 	u32				mclk_rate;
39 };
40 
41 static const struct reg_default cs53l30_reg_defaults[] = {
42 	{ CS53L30_PWRCTL,		CS53L30_PWRCTL_DEFAULT },
43 	{ CS53L30_MCLKCTL,		CS53L30_MCLKCTL_DEFAULT },
44 	{ CS53L30_INT_SR_CTL,		CS53L30_INT_SR_CTL_DEFAULT },
45 	{ CS53L30_MICBIAS_CTL,		CS53L30_MICBIAS_CTL_DEFAULT },
46 	{ CS53L30_ASPCFG_CTL,		CS53L30_ASPCFG_CTL_DEFAULT },
47 	{ CS53L30_ASP_CTL1,		CS53L30_ASP_CTL1_DEFAULT },
48 	{ CS53L30_ASP_TDMTX_CTL1,	CS53L30_ASP_TDMTX_CTLx_DEFAULT },
49 	{ CS53L30_ASP_TDMTX_CTL2,	CS53L30_ASP_TDMTX_CTLx_DEFAULT },
50 	{ CS53L30_ASP_TDMTX_CTL3,	CS53L30_ASP_TDMTX_CTLx_DEFAULT },
51 	{ CS53L30_ASP_TDMTX_CTL4,	CS53L30_ASP_TDMTX_CTLx_DEFAULT },
52 	{ CS53L30_ASP_TDMTX_EN1,	CS53L30_ASP_TDMTX_ENx_DEFAULT },
53 	{ CS53L30_ASP_TDMTX_EN2,	CS53L30_ASP_TDMTX_ENx_DEFAULT },
54 	{ CS53L30_ASP_TDMTX_EN3,	CS53L30_ASP_TDMTX_ENx_DEFAULT },
55 	{ CS53L30_ASP_TDMTX_EN4,	CS53L30_ASP_TDMTX_ENx_DEFAULT },
56 	{ CS53L30_ASP_TDMTX_EN5,	CS53L30_ASP_TDMTX_ENx_DEFAULT },
57 	{ CS53L30_ASP_TDMTX_EN6,	CS53L30_ASP_TDMTX_ENx_DEFAULT },
58 	{ CS53L30_ASP_CTL2,		CS53L30_ASP_CTL2_DEFAULT },
59 	{ CS53L30_SFT_RAMP,		CS53L30_SFT_RMP_DEFAULT },
60 	{ CS53L30_LRCK_CTL1,		CS53L30_LRCK_CTLx_DEFAULT },
61 	{ CS53L30_LRCK_CTL2,		CS53L30_LRCK_CTLx_DEFAULT },
62 	{ CS53L30_MUTEP_CTL1,		CS53L30_MUTEP_CTL1_DEFAULT },
63 	{ CS53L30_MUTEP_CTL2,		CS53L30_MUTEP_CTL2_DEFAULT },
64 	{ CS53L30_INBIAS_CTL1,		CS53L30_INBIAS_CTL1_DEFAULT },
65 	{ CS53L30_INBIAS_CTL2,		CS53L30_INBIAS_CTL2_DEFAULT },
66 	{ CS53L30_DMIC1_STR_CTL,	CS53L30_DMIC1_STR_CTL_DEFAULT },
67 	{ CS53L30_DMIC2_STR_CTL,	CS53L30_DMIC2_STR_CTL_DEFAULT },
68 	{ CS53L30_ADCDMIC1_CTL1,	CS53L30_ADCDMICx_CTL1_DEFAULT },
69 	{ CS53L30_ADCDMIC1_CTL2,	CS53L30_ADCDMIC1_CTL2_DEFAULT },
70 	{ CS53L30_ADC1_CTL3,		CS53L30_ADCx_CTL3_DEFAULT },
71 	{ CS53L30_ADC1_NG_CTL,		CS53L30_ADCx_NG_CTL_DEFAULT },
72 	{ CS53L30_ADC1A_AFE_CTL,	CS53L30_ADCxy_AFE_CTL_DEFAULT },
73 	{ CS53L30_ADC1B_AFE_CTL,	CS53L30_ADCxy_AFE_CTL_DEFAULT },
74 	{ CS53L30_ADC1A_DIG_VOL,	CS53L30_ADCxy_DIG_VOL_DEFAULT },
75 	{ CS53L30_ADC1B_DIG_VOL,	CS53L30_ADCxy_DIG_VOL_DEFAULT },
76 	{ CS53L30_ADCDMIC2_CTL1,	CS53L30_ADCDMICx_CTL1_DEFAULT },
77 	{ CS53L30_ADCDMIC2_CTL2,	CS53L30_ADCDMIC1_CTL2_DEFAULT },
78 	{ CS53L30_ADC2_CTL3,		CS53L30_ADCx_CTL3_DEFAULT },
79 	{ CS53L30_ADC2_NG_CTL,		CS53L30_ADCx_NG_CTL_DEFAULT },
80 	{ CS53L30_ADC2A_AFE_CTL,	CS53L30_ADCxy_AFE_CTL_DEFAULT },
81 	{ CS53L30_ADC2B_AFE_CTL,	CS53L30_ADCxy_AFE_CTL_DEFAULT },
82 	{ CS53L30_ADC2A_DIG_VOL,	CS53L30_ADCxy_DIG_VOL_DEFAULT },
83 	{ CS53L30_ADC2B_DIG_VOL,	CS53L30_ADCxy_DIG_VOL_DEFAULT },
84 	{ CS53L30_INT_MASK,		CS53L30_DEVICE_INT_MASK },
85 };
86 
cs53l30_volatile_register(struct device * dev,unsigned int reg)87 static bool cs53l30_volatile_register(struct device *dev, unsigned int reg)
88 {
89 	if (reg == CS53L30_IS)
90 		return true;
91 	else
92 		return false;
93 }
94 
cs53l30_writeable_register(struct device * dev,unsigned int reg)95 static bool cs53l30_writeable_register(struct device *dev, unsigned int reg)
96 {
97 	switch (reg) {
98 	case CS53L30_DEVID_AB:
99 	case CS53L30_DEVID_CD:
100 	case CS53L30_DEVID_E:
101 	case CS53L30_REVID:
102 	case CS53L30_IS:
103 		return false;
104 	default:
105 		return true;
106 	}
107 }
108 
cs53l30_readable_register(struct device * dev,unsigned int reg)109 static bool cs53l30_readable_register(struct device *dev, unsigned int reg)
110 {
111 	switch (reg) {
112 	case CS53L30_DEVID_AB:
113 	case CS53L30_DEVID_CD:
114 	case CS53L30_DEVID_E:
115 	case CS53L30_REVID:
116 	case CS53L30_PWRCTL:
117 	case CS53L30_MCLKCTL:
118 	case CS53L30_INT_SR_CTL:
119 	case CS53L30_MICBIAS_CTL:
120 	case CS53L30_ASPCFG_CTL:
121 	case CS53L30_ASP_CTL1:
122 	case CS53L30_ASP_TDMTX_CTL1:
123 	case CS53L30_ASP_TDMTX_CTL2:
124 	case CS53L30_ASP_TDMTX_CTL3:
125 	case CS53L30_ASP_TDMTX_CTL4:
126 	case CS53L30_ASP_TDMTX_EN1:
127 	case CS53L30_ASP_TDMTX_EN2:
128 	case CS53L30_ASP_TDMTX_EN3:
129 	case CS53L30_ASP_TDMTX_EN4:
130 	case CS53L30_ASP_TDMTX_EN5:
131 	case CS53L30_ASP_TDMTX_EN6:
132 	case CS53L30_ASP_CTL2:
133 	case CS53L30_SFT_RAMP:
134 	case CS53L30_LRCK_CTL1:
135 	case CS53L30_LRCK_CTL2:
136 	case CS53L30_MUTEP_CTL1:
137 	case CS53L30_MUTEP_CTL2:
138 	case CS53L30_INBIAS_CTL1:
139 	case CS53L30_INBIAS_CTL2:
140 	case CS53L30_DMIC1_STR_CTL:
141 	case CS53L30_DMIC2_STR_CTL:
142 	case CS53L30_ADCDMIC1_CTL1:
143 	case CS53L30_ADCDMIC1_CTL2:
144 	case CS53L30_ADC1_CTL3:
145 	case CS53L30_ADC1_NG_CTL:
146 	case CS53L30_ADC1A_AFE_CTL:
147 	case CS53L30_ADC1B_AFE_CTL:
148 	case CS53L30_ADC1A_DIG_VOL:
149 	case CS53L30_ADC1B_DIG_VOL:
150 	case CS53L30_ADCDMIC2_CTL1:
151 	case CS53L30_ADCDMIC2_CTL2:
152 	case CS53L30_ADC2_CTL3:
153 	case CS53L30_ADC2_NG_CTL:
154 	case CS53L30_ADC2A_AFE_CTL:
155 	case CS53L30_ADC2B_AFE_CTL:
156 	case CS53L30_ADC2A_DIG_VOL:
157 	case CS53L30_ADC2B_DIG_VOL:
158 	case CS53L30_INT_MASK:
159 		return true;
160 	default:
161 		return false;
162 	}
163 }
164 
165 static DECLARE_TLV_DB_SCALE(adc_boost_tlv, 0, 2000, 0);
166 static DECLARE_TLV_DB_SCALE(adc_ng_boost_tlv, 0, 3000, 0);
167 static DECLARE_TLV_DB_SCALE(pga_tlv, -600, 50, 0);
168 static DECLARE_TLV_DB_SCALE(dig_tlv, -9600, 100, 1);
169 static DECLARE_TLV_DB_SCALE(pga_preamp_tlv, 0, 10000, 0);
170 
171 static const char * const input1_sel_text[] = {
172 	"DMIC1 On AB In",
173 	"DMIC1 On A In",
174 	"DMIC1 On B In",
175 	"ADC1 On AB In",
176 	"ADC1 On A In",
177 	"ADC1 On B In",
178 	"DMIC1 Off ADC1 Off",
179 };
180 
181 static unsigned int const input1_sel_values[] = {
182 	CS53L30_CH_TYPE,
183 	CS53L30_ADCxB_PDN | CS53L30_CH_TYPE,
184 	CS53L30_ADCxA_PDN | CS53L30_CH_TYPE,
185 	CS53L30_DMICx_PDN,
186 	CS53L30_ADCxB_PDN | CS53L30_DMICx_PDN,
187 	CS53L30_ADCxA_PDN | CS53L30_DMICx_PDN,
188 	CS53L30_ADCxA_PDN | CS53L30_ADCxB_PDN | CS53L30_DMICx_PDN,
189 };
190 
191 static const char * const input2_sel_text[] = {
192 	"DMIC2 On AB In",
193 	"DMIC2 On A In",
194 	"DMIC2 On B In",
195 	"ADC2 On AB In",
196 	"ADC2 On A In",
197 	"ADC2 On B In",
198 	"DMIC2 Off ADC2 Off",
199 };
200 
201 static unsigned int const input2_sel_values[] = {
202 	0x0,
203 	CS53L30_ADCxB_PDN,
204 	CS53L30_ADCxA_PDN,
205 	CS53L30_DMICx_PDN,
206 	CS53L30_ADCxB_PDN | CS53L30_DMICx_PDN,
207 	CS53L30_ADCxA_PDN | CS53L30_DMICx_PDN,
208 	CS53L30_ADCxA_PDN | CS53L30_ADCxB_PDN | CS53L30_DMICx_PDN,
209 };
210 
211 static const char * const input1_route_sel_text[] = {
212 	"ADC1_SEL", "DMIC1_SEL",
213 };
214 
215 static const struct soc_enum input1_route_sel_enum =
216 	SOC_ENUM_SINGLE(CS53L30_ADCDMIC1_CTL1, CS53L30_CH_TYPE_SHIFT,
217 			ARRAY_SIZE(input1_route_sel_text),
218 			input1_route_sel_text);
219 
220 static SOC_VALUE_ENUM_SINGLE_DECL(input1_sel_enum, CS53L30_ADCDMIC1_CTL1, 0,
221 				  CS53L30_ADCDMICx_PDN_MASK, input1_sel_text,
222 				  input1_sel_values);
223 
224 static const struct snd_kcontrol_new input1_route_sel_mux =
225 	SOC_DAPM_ENUM("Input 1 Route", input1_route_sel_enum);
226 
227 static const char * const input2_route_sel_text[] = {
228 	"ADC2_SEL", "DMIC2_SEL",
229 };
230 
231 /* Note: CS53L30_ADCDMIC1_CTL1 CH_TYPE controls inputs 1 and 2 */
232 static const struct soc_enum input2_route_sel_enum =
233 	SOC_ENUM_SINGLE(CS53L30_ADCDMIC1_CTL1, 0,
234 			ARRAY_SIZE(input2_route_sel_text),
235 			input2_route_sel_text);
236 
237 static SOC_VALUE_ENUM_SINGLE_DECL(input2_sel_enum, CS53L30_ADCDMIC2_CTL1, 0,
238 				  CS53L30_ADCDMICx_PDN_MASK, input2_sel_text,
239 				  input2_sel_values);
240 
241 static const struct snd_kcontrol_new input2_route_sel_mux =
242 	SOC_DAPM_ENUM("Input 2 Route", input2_route_sel_enum);
243 
244 /*
245  * TB = 6144*(MCLK(int) scaling factor)/MCLK(internal)
246  * TB - Time base
247  * NOTE: If MCLK_INT_SCALE = 0, then TB=1
248  */
249 static const char * const cs53l30_ng_delay_text[] = {
250 	"TB*50ms", "TB*100ms", "TB*150ms", "TB*200ms",
251 };
252 
253 static const struct soc_enum adc1_ng_delay_enum =
254 	SOC_ENUM_SINGLE(CS53L30_ADC1_NG_CTL, CS53L30_ADCx_NG_DELAY_SHIFT,
255 			ARRAY_SIZE(cs53l30_ng_delay_text),
256 			cs53l30_ng_delay_text);
257 
258 static const struct soc_enum adc2_ng_delay_enum =
259 	SOC_ENUM_SINGLE(CS53L30_ADC2_NG_CTL, CS53L30_ADCx_NG_DELAY_SHIFT,
260 			ARRAY_SIZE(cs53l30_ng_delay_text),
261 			cs53l30_ng_delay_text);
262 
263 /* The noise gate threshold selected will depend on NG Boost */
264 static const char * const cs53l30_ng_thres_text[] = {
265 	"-64dB/-34dB", "-66dB/-36dB", "-70dB/-40dB", "-73dB/-43dB",
266 	"-76dB/-46dB", "-82dB/-52dB", "-58dB", "-64dB",
267 };
268 
269 static const struct soc_enum adc1_ng_thres_enum =
270 	SOC_ENUM_SINGLE(CS53L30_ADC1_NG_CTL, CS53L30_ADCx_NG_THRESH_SHIFT,
271 			ARRAY_SIZE(cs53l30_ng_thres_text),
272 			cs53l30_ng_thres_text);
273 
274 static const struct soc_enum adc2_ng_thres_enum =
275 	SOC_ENUM_SINGLE(CS53L30_ADC2_NG_CTL, CS53L30_ADCx_NG_THRESH_SHIFT,
276 			ARRAY_SIZE(cs53l30_ng_thres_text),
277 			cs53l30_ng_thres_text);
278 
279 /* Corner frequencies are with an Fs of 48kHz. */
280 static const char * const hpf_corner_freq_text[] = {
281 	"1.86Hz", "120Hz", "235Hz", "466Hz",
282 };
283 
284 static const struct soc_enum adc1_hpf_enum =
285 	SOC_ENUM_SINGLE(CS53L30_ADC1_CTL3, CS53L30_ADCx_HPF_CF_SHIFT,
286 			ARRAY_SIZE(hpf_corner_freq_text), hpf_corner_freq_text);
287 
288 static const struct soc_enum adc2_hpf_enum =
289 	SOC_ENUM_SINGLE(CS53L30_ADC2_CTL3, CS53L30_ADCx_HPF_CF_SHIFT,
290 			ARRAY_SIZE(hpf_corner_freq_text), hpf_corner_freq_text);
291 
292 static const struct snd_kcontrol_new cs53l30_snd_controls[] = {
293 	SOC_SINGLE("Digital Soft-Ramp Switch", CS53L30_SFT_RAMP,
294 		   CS53L30_DIGSFT_SHIFT, 1, 0),
295 	SOC_SINGLE("ADC1 Noise Gate Ganging Switch", CS53L30_ADC1_CTL3,
296 		   CS53L30_ADCx_NG_ALL_SHIFT, 1, 0),
297 	SOC_SINGLE("ADC2 Noise Gate Ganging Switch", CS53L30_ADC2_CTL3,
298 		   CS53L30_ADCx_NG_ALL_SHIFT, 1, 0),
299 	SOC_SINGLE("ADC1A Noise Gate Enable Switch", CS53L30_ADC1_NG_CTL,
300 		   CS53L30_ADCxA_NG_SHIFT, 1, 0),
301 	SOC_SINGLE("ADC1B Noise Gate Enable Switch", CS53L30_ADC1_NG_CTL,
302 		   CS53L30_ADCxB_NG_SHIFT, 1, 0),
303 	SOC_SINGLE("ADC2A Noise Gate Enable Switch", CS53L30_ADC2_NG_CTL,
304 		   CS53L30_ADCxA_NG_SHIFT, 1, 0),
305 	SOC_SINGLE("ADC2B Noise Gate Enable Switch", CS53L30_ADC2_NG_CTL,
306 		   CS53L30_ADCxB_NG_SHIFT, 1, 0),
307 	SOC_SINGLE("ADC1 Notch Filter Switch", CS53L30_ADCDMIC1_CTL2,
308 		   CS53L30_ADCx_NOTCH_DIS_SHIFT, 1, 1),
309 	SOC_SINGLE("ADC2 Notch Filter Switch", CS53L30_ADCDMIC2_CTL2,
310 		   CS53L30_ADCx_NOTCH_DIS_SHIFT, 1, 1),
311 	SOC_SINGLE("ADC1A Invert Switch", CS53L30_ADCDMIC1_CTL2,
312 		   CS53L30_ADCxA_INV_SHIFT, 1, 0),
313 	SOC_SINGLE("ADC1B Invert Switch", CS53L30_ADCDMIC1_CTL2,
314 		   CS53L30_ADCxB_INV_SHIFT, 1, 0),
315 	SOC_SINGLE("ADC2A Invert Switch", CS53L30_ADCDMIC2_CTL2,
316 		   CS53L30_ADCxA_INV_SHIFT, 1, 0),
317 	SOC_SINGLE("ADC2B Invert Switch", CS53L30_ADCDMIC2_CTL2,
318 		   CS53L30_ADCxB_INV_SHIFT, 1, 0),
319 
320 	SOC_SINGLE_TLV("ADC1A Digital Boost Volume", CS53L30_ADCDMIC1_CTL2,
321 		       CS53L30_ADCxA_DIG_BOOST_SHIFT, 1, 0, adc_boost_tlv),
322 	SOC_SINGLE_TLV("ADC1B Digital Boost Volume", CS53L30_ADCDMIC1_CTL2,
323 		       CS53L30_ADCxB_DIG_BOOST_SHIFT, 1, 0, adc_boost_tlv),
324 	SOC_SINGLE_TLV("ADC2A Digital Boost Volume", CS53L30_ADCDMIC2_CTL2,
325 		       CS53L30_ADCxA_DIG_BOOST_SHIFT, 1, 0, adc_boost_tlv),
326 	SOC_SINGLE_TLV("ADC2B Digital Boost Volume", CS53L30_ADCDMIC2_CTL2,
327 		       CS53L30_ADCxB_DIG_BOOST_SHIFT, 1, 0, adc_boost_tlv),
328 	SOC_SINGLE_TLV("ADC1 NG Boost Volume", CS53L30_ADC1_NG_CTL,
329 		       CS53L30_ADCx_NG_BOOST_SHIFT, 1, 0, adc_ng_boost_tlv),
330 	SOC_SINGLE_TLV("ADC2 NG Boost Volume", CS53L30_ADC2_NG_CTL,
331 		       CS53L30_ADCx_NG_BOOST_SHIFT, 1, 0, adc_ng_boost_tlv),
332 
333 	SOC_DOUBLE_R_TLV("ADC1 Preamplifier Volume", CS53L30_ADC1A_AFE_CTL,
334 			 CS53L30_ADC1B_AFE_CTL, CS53L30_ADCxy_PREAMP_SHIFT,
335 			 2, 0, pga_preamp_tlv),
336 	SOC_DOUBLE_R_TLV("ADC2 Preamplifier Volume", CS53L30_ADC2A_AFE_CTL,
337 			 CS53L30_ADC2B_AFE_CTL, CS53L30_ADCxy_PREAMP_SHIFT,
338 			 2, 0, pga_preamp_tlv),
339 
340 	SOC_ENUM("Input 1 Channel Select", input1_sel_enum),
341 	SOC_ENUM("Input 2 Channel Select", input2_sel_enum),
342 
343 	SOC_ENUM("ADC1 HPF Select", adc1_hpf_enum),
344 	SOC_ENUM("ADC2 HPF Select", adc2_hpf_enum),
345 	SOC_ENUM("ADC1 NG Threshold", adc1_ng_thres_enum),
346 	SOC_ENUM("ADC2 NG Threshold", adc2_ng_thres_enum),
347 	SOC_ENUM("ADC1 NG Delay", adc1_ng_delay_enum),
348 	SOC_ENUM("ADC2 NG Delay", adc2_ng_delay_enum),
349 
350 	SOC_SINGLE_SX_TLV("ADC1A PGA Volume",
351 		    CS53L30_ADC1A_AFE_CTL, 0, 0x34, 0x24, pga_tlv),
352 	SOC_SINGLE_SX_TLV("ADC1B PGA Volume",
353 		    CS53L30_ADC1B_AFE_CTL, 0, 0x34, 0x24, pga_tlv),
354 	SOC_SINGLE_SX_TLV("ADC2A PGA Volume",
355 		    CS53L30_ADC2A_AFE_CTL, 0, 0x34, 0x24, pga_tlv),
356 	SOC_SINGLE_SX_TLV("ADC2B PGA Volume",
357 		    CS53L30_ADC2B_AFE_CTL, 0, 0x34, 0x24, pga_tlv),
358 
359 	SOC_SINGLE_SX_TLV("ADC1A Digital Volume",
360 		    CS53L30_ADC1A_DIG_VOL, 0, 0xA0, 0x6C, dig_tlv),
361 	SOC_SINGLE_SX_TLV("ADC1B Digital Volume",
362 		    CS53L30_ADC1B_DIG_VOL, 0, 0xA0, 0x6C, dig_tlv),
363 	SOC_SINGLE_SX_TLV("ADC2A Digital Volume",
364 		    CS53L30_ADC2A_DIG_VOL, 0, 0xA0, 0x6C, dig_tlv),
365 	SOC_SINGLE_SX_TLV("ADC2B Digital Volume",
366 		    CS53L30_ADC2B_DIG_VOL, 0, 0xA0, 0x6C, dig_tlv),
367 };
368 
369 static const struct snd_soc_dapm_widget cs53l30_dapm_widgets[] = {
370 	SND_SOC_DAPM_INPUT("IN1_DMIC1"),
371 	SND_SOC_DAPM_INPUT("IN2"),
372 	SND_SOC_DAPM_INPUT("IN3_DMIC2"),
373 	SND_SOC_DAPM_INPUT("IN4"),
374 	SND_SOC_DAPM_SUPPLY("MIC1 Bias", CS53L30_MICBIAS_CTL,
375 			    CS53L30_MIC1_BIAS_PDN_SHIFT, 1, NULL, 0),
376 	SND_SOC_DAPM_SUPPLY("MIC2 Bias", CS53L30_MICBIAS_CTL,
377 			    CS53L30_MIC2_BIAS_PDN_SHIFT, 1, NULL, 0),
378 	SND_SOC_DAPM_SUPPLY("MIC3 Bias", CS53L30_MICBIAS_CTL,
379 			    CS53L30_MIC3_BIAS_PDN_SHIFT, 1, NULL, 0),
380 	SND_SOC_DAPM_SUPPLY("MIC4 Bias", CS53L30_MICBIAS_CTL,
381 			    CS53L30_MIC4_BIAS_PDN_SHIFT, 1, NULL, 0),
382 
383 	SND_SOC_DAPM_AIF_OUT("ASP_SDOUT1", NULL, 0, CS53L30_ASP_CTL1,
384 			     CS53L30_ASP_SDOUTx_PDN_SHIFT, 1),
385 	SND_SOC_DAPM_AIF_OUT("ASP_SDOUT2", NULL, 0, CS53L30_ASP_CTL2,
386 			     CS53L30_ASP_SDOUTx_PDN_SHIFT, 1),
387 
388 	SND_SOC_DAPM_MUX("Input Mux 1", SND_SOC_NOPM, 0, 0,
389 			 &input1_route_sel_mux),
390 	SND_SOC_DAPM_MUX("Input Mux 2", SND_SOC_NOPM, 0, 0,
391 			 &input2_route_sel_mux),
392 
393 	SND_SOC_DAPM_ADC("ADC1A", NULL, CS53L30_ADCDMIC1_CTL1,
394 			 CS53L30_ADCxA_PDN_SHIFT, 1),
395 	SND_SOC_DAPM_ADC("ADC1B", NULL, CS53L30_ADCDMIC1_CTL1,
396 			 CS53L30_ADCxB_PDN_SHIFT, 1),
397 	SND_SOC_DAPM_ADC("ADC2A", NULL, CS53L30_ADCDMIC2_CTL1,
398 			 CS53L30_ADCxA_PDN_SHIFT, 1),
399 	SND_SOC_DAPM_ADC("ADC2B", NULL, CS53L30_ADCDMIC2_CTL1,
400 			 CS53L30_ADCxB_PDN_SHIFT, 1),
401 	SND_SOC_DAPM_ADC("DMIC1", NULL, CS53L30_ADCDMIC1_CTL1,
402 			 CS53L30_DMICx_PDN_SHIFT, 1),
403 	SND_SOC_DAPM_ADC("DMIC2", NULL, CS53L30_ADCDMIC2_CTL1,
404 			 CS53L30_DMICx_PDN_SHIFT, 1),
405 };
406 
407 static const struct snd_soc_dapm_route cs53l30_dapm_routes[] = {
408 	/* ADC Input Paths */
409 	{"ADC1A", NULL, "IN1_DMIC1"},
410 	{"Input Mux 1", "ADC1_SEL", "ADC1A"},
411 	{"ADC1B", NULL, "IN2"},
412 
413 	{"ADC2A", NULL, "IN3_DMIC2"},
414 	{"Input Mux 2", "ADC2_SEL", "ADC2A"},
415 	{"ADC2B", NULL, "IN4"},
416 
417 	/* MIC Bias Paths */
418 	{"ADC1A", NULL, "MIC1 Bias"},
419 	{"ADC1B", NULL, "MIC2 Bias"},
420 	{"ADC2A", NULL, "MIC3 Bias"},
421 	{"ADC2B", NULL, "MIC4 Bias"},
422 
423 	/* DMIC Paths */
424 	{"DMIC1", NULL, "IN1_DMIC1"},
425 	{"Input Mux 1", "DMIC1_SEL", "DMIC1"},
426 
427 	{"DMIC2", NULL, "IN3_DMIC2"},
428 	{"Input Mux 2", "DMIC2_SEL", "DMIC2"},
429 };
430 
431 static const struct snd_soc_dapm_route cs53l30_dapm_routes_sdout1[] = {
432 	/* Output Paths when using SDOUT1 only */
433 	{"ASP_SDOUT1", NULL, "ADC1A" },
434 	{"ASP_SDOUT1", NULL, "Input Mux 1"},
435 	{"ASP_SDOUT1", NULL, "ADC1B"},
436 
437 	{"ASP_SDOUT1", NULL, "ADC2A"},
438 	{"ASP_SDOUT1", NULL, "Input Mux 2"},
439 	{"ASP_SDOUT1", NULL, "ADC2B"},
440 
441 	{"Capture", NULL, "ASP_SDOUT1"},
442 };
443 
444 static const struct snd_soc_dapm_route cs53l30_dapm_routes_sdout2[] = {
445 	/* Output Paths when using both SDOUT1 and SDOUT2 */
446 	{"ASP_SDOUT1", NULL, "ADC1A" },
447 	{"ASP_SDOUT1", NULL, "Input Mux 1"},
448 	{"ASP_SDOUT1", NULL, "ADC1B"},
449 
450 	{"ASP_SDOUT2", NULL, "ADC2A"},
451 	{"ASP_SDOUT2", NULL, "Input Mux 2"},
452 	{"ASP_SDOUT2", NULL, "ADC2B"},
453 
454 	{"Capture", NULL, "ASP_SDOUT1"},
455 	{"Capture", NULL, "ASP_SDOUT2"},
456 };
457 
458 struct cs53l30_mclk_div {
459 	u32 mclk_rate;
460 	u32 srate;
461 	u8 asp_rate;
462 	u8 internal_fs_ratio;
463 	u8 mclk_int_scale;
464 };
465 
466 static const struct cs53l30_mclk_div cs53l30_mclk_coeffs[] = {
467 	/* NOTE: Enable MCLK_INT_SCALE to save power. */
468 
469 	/* MCLK, Sample Rate, asp_rate, internal_fs_ratio, mclk_int_scale */
470 	{5644800, 11025, 0x4, CS53L30_INTRNL_FS_RATIO, CS53L30_MCLK_INT_SCALE},
471 	{5644800, 22050, 0x8, CS53L30_INTRNL_FS_RATIO, CS53L30_MCLK_INT_SCALE},
472 	{5644800, 44100, 0xC, CS53L30_INTRNL_FS_RATIO, CS53L30_MCLK_INT_SCALE},
473 
474 	{6000000,  8000, 0x1, 0, CS53L30_MCLK_INT_SCALE},
475 	{6000000, 11025, 0x2, 0, CS53L30_MCLK_INT_SCALE},
476 	{6000000, 12000, 0x4, 0, CS53L30_MCLK_INT_SCALE},
477 	{6000000, 16000, 0x5, 0, CS53L30_MCLK_INT_SCALE},
478 	{6000000, 22050, 0x6, 0, CS53L30_MCLK_INT_SCALE},
479 	{6000000, 24000, 0x8, 0, CS53L30_MCLK_INT_SCALE},
480 	{6000000, 32000, 0x9, 0, CS53L30_MCLK_INT_SCALE},
481 	{6000000, 44100, 0xA, 0, CS53L30_MCLK_INT_SCALE},
482 	{6000000, 48000, 0xC, 0, CS53L30_MCLK_INT_SCALE},
483 
484 	{6144000,  8000, 0x1, CS53L30_INTRNL_FS_RATIO, CS53L30_MCLK_INT_SCALE},
485 	{6144000, 11025, 0x2, CS53L30_INTRNL_FS_RATIO, CS53L30_MCLK_INT_SCALE},
486 	{6144000, 12000, 0x4, CS53L30_INTRNL_FS_RATIO, CS53L30_MCLK_INT_SCALE},
487 	{6144000, 16000, 0x5, CS53L30_INTRNL_FS_RATIO, CS53L30_MCLK_INT_SCALE},
488 	{6144000, 22050, 0x6, CS53L30_INTRNL_FS_RATIO, CS53L30_MCLK_INT_SCALE},
489 	{6144000, 24000, 0x8, CS53L30_INTRNL_FS_RATIO, CS53L30_MCLK_INT_SCALE},
490 	{6144000, 32000, 0x9, CS53L30_INTRNL_FS_RATIO, CS53L30_MCLK_INT_SCALE},
491 	{6144000, 44100, 0xA, CS53L30_INTRNL_FS_RATIO, CS53L30_MCLK_INT_SCALE},
492 	{6144000, 48000, 0xC, CS53L30_INTRNL_FS_RATIO, CS53L30_MCLK_INT_SCALE},
493 
494 	{6400000,  8000, 0x1, CS53L30_INTRNL_FS_RATIO, CS53L30_MCLK_INT_SCALE},
495 	{6400000, 11025, 0x2, CS53L30_INTRNL_FS_RATIO, CS53L30_MCLK_INT_SCALE},
496 	{6400000, 12000, 0x4, CS53L30_INTRNL_FS_RATIO, CS53L30_MCLK_INT_SCALE},
497 	{6400000, 16000, 0x5, CS53L30_INTRNL_FS_RATIO, CS53L30_MCLK_INT_SCALE},
498 	{6400000, 22050, 0x6, CS53L30_INTRNL_FS_RATIO, CS53L30_MCLK_INT_SCALE},
499 	{6400000, 24000, 0x8, CS53L30_INTRNL_FS_RATIO, CS53L30_MCLK_INT_SCALE},
500 	{6400000, 32000, 0x9, CS53L30_INTRNL_FS_RATIO, CS53L30_MCLK_INT_SCALE},
501 	{6400000, 44100, 0xA, CS53L30_INTRNL_FS_RATIO, CS53L30_MCLK_INT_SCALE},
502 	{6400000, 48000, 0xC, CS53L30_INTRNL_FS_RATIO, CS53L30_MCLK_INT_SCALE},
503 };
504 
505 struct cs53l30_mclkx_div {
506 	u32 mclkx;
507 	u8 ratio;
508 	u8 mclkdiv;
509 };
510 
511 static const struct cs53l30_mclkx_div cs53l30_mclkx_coeffs[] = {
512 	{5644800,  1, CS53L30_MCLK_DIV_BY_1},
513 	{6000000,  1, CS53L30_MCLK_DIV_BY_1},
514 	{6144000,  1, CS53L30_MCLK_DIV_BY_1},
515 	{11289600, 2, CS53L30_MCLK_DIV_BY_2},
516 	{12288000, 2, CS53L30_MCLK_DIV_BY_2},
517 	{12000000, 2, CS53L30_MCLK_DIV_BY_2},
518 	{19200000, 3, CS53L30_MCLK_DIV_BY_3},
519 };
520 
cs53l30_get_mclkx_coeff(int mclkx)521 static int cs53l30_get_mclkx_coeff(int mclkx)
522 {
523 	int i;
524 
525 	for (i = 0; i < ARRAY_SIZE(cs53l30_mclkx_coeffs); i++) {
526 		if (cs53l30_mclkx_coeffs[i].mclkx == mclkx)
527 			return i;
528 	}
529 
530 	return -EINVAL;
531 }
532 
cs53l30_get_mclk_coeff(int mclk_rate,int srate)533 static int cs53l30_get_mclk_coeff(int mclk_rate, int srate)
534 {
535 	int i;
536 
537 	for (i = 0; i < ARRAY_SIZE(cs53l30_mclk_coeffs); i++) {
538 		if (cs53l30_mclk_coeffs[i].mclk_rate == mclk_rate &&
539 		    cs53l30_mclk_coeffs[i].srate == srate)
540 			return i;
541 	}
542 
543 	return -EINVAL;
544 }
545 
cs53l30_set_sysclk(struct snd_soc_dai * dai,int clk_id,unsigned int freq,int dir)546 static int cs53l30_set_sysclk(struct snd_soc_dai *dai,
547 			      int clk_id, unsigned int freq, int dir)
548 {
549 	struct cs53l30_private *priv = snd_soc_component_get_drvdata(dai->component);
550 	int mclkx_coeff;
551 	u32 mclk_rate;
552 
553 	/* MCLKX -> MCLK */
554 	mclkx_coeff = cs53l30_get_mclkx_coeff(freq);
555 	if (mclkx_coeff < 0)
556 		return mclkx_coeff;
557 
558 	mclk_rate = cs53l30_mclkx_coeffs[mclkx_coeff].mclkx /
559 		    cs53l30_mclkx_coeffs[mclkx_coeff].ratio;
560 
561 	regmap_update_bits(priv->regmap, CS53L30_MCLKCTL,
562 			   CS53L30_MCLK_DIV_MASK,
563 			   cs53l30_mclkx_coeffs[mclkx_coeff].mclkdiv);
564 
565 	priv->mclk_rate = mclk_rate;
566 
567 	return 0;
568 }
569 
cs53l30_set_dai_fmt(struct snd_soc_dai * dai,unsigned int fmt)570 static int cs53l30_set_dai_fmt(struct snd_soc_dai *dai, unsigned int fmt)
571 {
572 	struct cs53l30_private *priv = snd_soc_component_get_drvdata(dai->component);
573 	u8 aspcfg = 0, aspctl1 = 0;
574 
575 	switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
576 	case SND_SOC_DAIFMT_CBM_CFM:
577 		aspcfg |= CS53L30_ASP_MS;
578 		break;
579 	case SND_SOC_DAIFMT_CBS_CFS:
580 		break;
581 	default:
582 		return -EINVAL;
583 	}
584 
585 	/* DAI mode */
586 	switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
587 	case SND_SOC_DAIFMT_I2S:
588 		/* Set TDM_PDN to turn off TDM mode -- Reset default */
589 		aspctl1 |= CS53L30_ASP_TDM_PDN;
590 		break;
591 	case SND_SOC_DAIFMT_DSP_A:
592 		/*
593 		 * Clear TDM_PDN to turn on TDM mode; Use ASP_SCLK_INV = 0
594 		 * with SHIFT_LEFT = 1 combination as Figure 4-13 shows in
595 		 * the CS53L30 datasheet
596 		 */
597 		aspctl1 |= CS53L30_SHIFT_LEFT;
598 		break;
599 	default:
600 		return -EINVAL;
601 	}
602 
603 	/* Check to see if the SCLK is inverted */
604 	switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
605 	case SND_SOC_DAIFMT_IB_NF:
606 	case SND_SOC_DAIFMT_IB_IF:
607 		aspcfg ^= CS53L30_ASP_SCLK_INV;
608 		break;
609 	default:
610 		break;
611 	}
612 
613 	regmap_update_bits(priv->regmap, CS53L30_ASPCFG_CTL,
614 			   CS53L30_ASP_MS | CS53L30_ASP_SCLK_INV, aspcfg);
615 
616 	regmap_update_bits(priv->regmap, CS53L30_ASP_CTL1,
617 			   CS53L30_ASP_TDM_PDN | CS53L30_SHIFT_LEFT, aspctl1);
618 
619 	return 0;
620 }
621 
cs53l30_pcm_hw_params(struct snd_pcm_substream * substream,struct snd_pcm_hw_params * params,struct snd_soc_dai * dai)622 static int cs53l30_pcm_hw_params(struct snd_pcm_substream *substream,
623 				 struct snd_pcm_hw_params *params,
624 				 struct snd_soc_dai *dai)
625 {
626 	struct cs53l30_private *priv = snd_soc_component_get_drvdata(dai->component);
627 	int srate = params_rate(params);
628 	int mclk_coeff;
629 
630 	/* MCLK -> srate */
631 	mclk_coeff = cs53l30_get_mclk_coeff(priv->mclk_rate, srate);
632 	if (mclk_coeff < 0)
633 		return -EINVAL;
634 
635 	regmap_update_bits(priv->regmap, CS53L30_INT_SR_CTL,
636 			   CS53L30_INTRNL_FS_RATIO_MASK,
637 			   cs53l30_mclk_coeffs[mclk_coeff].internal_fs_ratio);
638 
639 	regmap_update_bits(priv->regmap, CS53L30_MCLKCTL,
640 			   CS53L30_MCLK_INT_SCALE_MASK,
641 			   cs53l30_mclk_coeffs[mclk_coeff].mclk_int_scale);
642 
643 	regmap_update_bits(priv->regmap, CS53L30_ASPCFG_CTL,
644 			   CS53L30_ASP_RATE_MASK,
645 			   cs53l30_mclk_coeffs[mclk_coeff].asp_rate);
646 
647 	return 0;
648 }
649 
cs53l30_set_bias_level(struct snd_soc_component * component,enum snd_soc_bias_level level)650 static int cs53l30_set_bias_level(struct snd_soc_component *component,
651 				  enum snd_soc_bias_level level)
652 {
653 	struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(component);
654 	struct cs53l30_private *priv = snd_soc_component_get_drvdata(component);
655 	unsigned int reg;
656 	int i, inter_max_check, ret;
657 
658 	switch (level) {
659 	case SND_SOC_BIAS_ON:
660 		break;
661 	case SND_SOC_BIAS_PREPARE:
662 		if (dapm->bias_level == SND_SOC_BIAS_STANDBY)
663 			regmap_update_bits(priv->regmap, CS53L30_PWRCTL,
664 					   CS53L30_PDN_LP_MASK, 0);
665 		break;
666 	case SND_SOC_BIAS_STANDBY:
667 		if (dapm->bias_level == SND_SOC_BIAS_OFF) {
668 			ret = clk_prepare_enable(priv->mclk);
669 			if (ret) {
670 				dev_err(component->dev,
671 					"failed to enable MCLK: %d\n", ret);
672 				return ret;
673 			}
674 			regmap_update_bits(priv->regmap, CS53L30_MCLKCTL,
675 					   CS53L30_MCLK_DIS_MASK, 0);
676 			regmap_update_bits(priv->regmap, CS53L30_PWRCTL,
677 					   CS53L30_PDN_ULP_MASK, 0);
678 			msleep(50);
679 		} else {
680 			regmap_update_bits(priv->regmap, CS53L30_PWRCTL,
681 					   CS53L30_PDN_ULP_MASK,
682 					   CS53L30_PDN_ULP);
683 		}
684 		break;
685 	case SND_SOC_BIAS_OFF:
686 		regmap_update_bits(priv->regmap, CS53L30_INT_MASK,
687 				   CS53L30_PDN_DONE, 0);
688 		/*
689 		 * If digital softramp is set, the amount of time required
690 		 * for power down increases and depends on the digital
691 		 * volume setting.
692 		 */
693 
694 		/* Set the max possible time if digsft is set */
695 		regmap_read(priv->regmap, CS53L30_SFT_RAMP, &reg);
696 		if (reg & CS53L30_DIGSFT_MASK)
697 			inter_max_check = CS53L30_PDN_POLL_MAX;
698 		else
699 			inter_max_check = 10;
700 
701 		regmap_update_bits(priv->regmap, CS53L30_PWRCTL,
702 				   CS53L30_PDN_ULP_MASK,
703 				   CS53L30_PDN_ULP);
704 		/* PDN_DONE will take a min of 20ms to be set.*/
705 		msleep(20);
706 		/* Clr status */
707 		regmap_read(priv->regmap, CS53L30_IS, &reg);
708 		for (i = 0; i < inter_max_check; i++) {
709 			if (inter_max_check < 10) {
710 				usleep_range(1000, 1100);
711 				regmap_read(priv->regmap, CS53L30_IS, &reg);
712 				if (reg & CS53L30_PDN_DONE)
713 					break;
714 			} else {
715 				usleep_range(10000, 10100);
716 				regmap_read(priv->regmap, CS53L30_IS, &reg);
717 				if (reg & CS53L30_PDN_DONE)
718 					break;
719 			}
720 		}
721 		/* PDN_DONE is set. We now can disable the MCLK */
722 		regmap_update_bits(priv->regmap, CS53L30_INT_MASK,
723 				   CS53L30_PDN_DONE, CS53L30_PDN_DONE);
724 		regmap_update_bits(priv->regmap, CS53L30_MCLKCTL,
725 				   CS53L30_MCLK_DIS_MASK,
726 				   CS53L30_MCLK_DIS);
727 		clk_disable_unprepare(priv->mclk);
728 		break;
729 	}
730 
731 	return 0;
732 }
733 
cs53l30_set_tristate(struct snd_soc_dai * dai,int tristate)734 static int cs53l30_set_tristate(struct snd_soc_dai *dai, int tristate)
735 {
736 	struct cs53l30_private *priv = snd_soc_component_get_drvdata(dai->component);
737 	u8 val = tristate ? CS53L30_ASP_3ST : 0;
738 
739 	return regmap_update_bits(priv->regmap, CS53L30_ASP_CTL1,
740 				  CS53L30_ASP_3ST_MASK, val);
741 }
742 
743 static unsigned int const cs53l30_src_rates[] = {
744 	8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000
745 };
746 
747 static const struct snd_pcm_hw_constraint_list src_constraints = {
748 	.count = ARRAY_SIZE(cs53l30_src_rates),
749 	.list = cs53l30_src_rates,
750 };
751 
cs53l30_pcm_startup(struct snd_pcm_substream * substream,struct snd_soc_dai * dai)752 static int cs53l30_pcm_startup(struct snd_pcm_substream *substream,
753 			       struct snd_soc_dai *dai)
754 {
755 	snd_pcm_hw_constraint_list(substream->runtime, 0,
756 				   SNDRV_PCM_HW_PARAM_RATE, &src_constraints);
757 
758 	return 0;
759 }
760 
761 /*
762  * Note: CS53L30 counts the slot number per byte while ASoC counts the slot
763  * number per slot_width. So there is a difference between the slots of ASoC
764  * and the slots of CS53L30.
765  */
cs53l30_set_dai_tdm_slot(struct snd_soc_dai * dai,unsigned int tx_mask,unsigned int rx_mask,int slots,int slot_width)766 static int cs53l30_set_dai_tdm_slot(struct snd_soc_dai *dai,
767 				    unsigned int tx_mask, unsigned int rx_mask,
768 				    int slots, int slot_width)
769 {
770 	struct cs53l30_private *priv = snd_soc_component_get_drvdata(dai->component);
771 	unsigned int loc[CS53L30_TDM_SLOT_MAX] = {48, 48, 48, 48};
772 	unsigned int slot_next, slot_step;
773 	u64 tx_enable = 0;
774 	int i;
775 
776 	if (!rx_mask) {
777 		dev_err(dai->dev, "rx masks must not be 0\n");
778 		return -EINVAL;
779 	}
780 
781 	/* Assuming slot_width is not supposed to be greater than 64 */
782 	if (slots <= 0 || slot_width <= 0 || slot_width > 64) {
783 		dev_err(dai->dev, "invalid slot number or slot width\n");
784 		return -EINVAL;
785 	}
786 
787 	if (slot_width & 0x7) {
788 		dev_err(dai->dev, "slot width must count in byte\n");
789 		return -EINVAL;
790 	}
791 
792 	/* How many bytes in each ASoC slot */
793 	slot_step = slot_width >> 3;
794 
795 	for (i = 0; rx_mask && i < CS53L30_TDM_SLOT_MAX; i++) {
796 		/* Find the first slot from LSB */
797 		slot_next = __ffs(rx_mask);
798 		/* Save the slot location by converting to CS53L30 slot */
799 		loc[i] = slot_next * slot_step;
800 		/* Create the mask of CS53L30 slot */
801 		tx_enable |= (u64)((u64)(1 << slot_step) - 1) << (u64)loc[i];
802 		/* Clear this slot from rx_mask */
803 		rx_mask &= ~(1 << slot_next);
804 	}
805 
806 	/* Error out to avoid slot shift */
807 	if (rx_mask && i == CS53L30_TDM_SLOT_MAX) {
808 		dev_err(dai->dev, "rx_mask exceeds max slot number: %d\n",
809 			CS53L30_TDM_SLOT_MAX);
810 		return -EINVAL;
811 	}
812 
813 	/* Validate the last active CS53L30 slot */
814 	slot_next = loc[i - 1] + slot_step - 1;
815 	if (slot_next > 47) {
816 		dev_err(dai->dev, "slot selection out of bounds: %u\n",
817 			slot_next);
818 		return -EINVAL;
819 	}
820 
821 	for (i = 0; i < CS53L30_TDM_SLOT_MAX && loc[i] != 48; i++) {
822 		regmap_update_bits(priv->regmap, CS53L30_ASP_TDMTX_CTL(i),
823 				   CS53L30_ASP_CHx_TX_LOC_MASK, loc[i]);
824 		dev_dbg(dai->dev, "loc[%d]=%x\n", i, loc[i]);
825 	}
826 
827 	for (i = 0; i < CS53L30_ASP_TDMTX_ENx_MAX && tx_enable; i++) {
828 		regmap_write(priv->regmap, CS53L30_ASP_TDMTX_ENx(i),
829 			     tx_enable & 0xff);
830 		tx_enable >>= 8;
831 		dev_dbg(dai->dev, "en_reg=%x, tx_enable=%llx\n",
832 			CS53L30_ASP_TDMTX_ENx(i), tx_enable & 0xff);
833 	}
834 
835 	return 0;
836 }
837 
cs53l30_mute_stream(struct snd_soc_dai * dai,int mute,int stream)838 static int cs53l30_mute_stream(struct snd_soc_dai *dai, int mute, int stream)
839 {
840 	struct cs53l30_private *priv = snd_soc_component_get_drvdata(dai->component);
841 
842 	gpiod_set_value_cansleep(priv->mute_gpio, mute);
843 
844 	return 0;
845 }
846 
847 /* SNDRV_PCM_RATE_KNOT -> 12000, 24000 Hz, limit with constraint list */
848 #define CS53L30_RATES (SNDRV_PCM_RATE_8000_48000 | SNDRV_PCM_RATE_KNOT)
849 
850 #define CS53L30_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE |\
851 			SNDRV_PCM_FMTBIT_S24_LE)
852 
853 static const struct snd_soc_dai_ops cs53l30_ops = {
854 	.startup = cs53l30_pcm_startup,
855 	.hw_params = cs53l30_pcm_hw_params,
856 	.set_fmt = cs53l30_set_dai_fmt,
857 	.set_sysclk = cs53l30_set_sysclk,
858 	.set_tristate = cs53l30_set_tristate,
859 	.set_tdm_slot = cs53l30_set_dai_tdm_slot,
860 	.mute_stream = cs53l30_mute_stream,
861 };
862 
863 static struct snd_soc_dai_driver cs53l30_dai = {
864 	.name = "cs53l30",
865 	.capture = {
866 		.stream_name = "Capture",
867 		.channels_min = 1,
868 		.channels_max = 4,
869 		.rates = CS53L30_RATES,
870 		.formats = CS53L30_FORMATS,
871 	},
872 	.ops = &cs53l30_ops,
873 	.symmetric_rate = 1,
874 };
875 
cs53l30_component_probe(struct snd_soc_component * component)876 static int cs53l30_component_probe(struct snd_soc_component *component)
877 {
878 	struct cs53l30_private *priv = snd_soc_component_get_drvdata(component);
879 	struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(component);
880 
881 	if (priv->use_sdout2)
882 		snd_soc_dapm_add_routes(dapm, cs53l30_dapm_routes_sdout2,
883 					ARRAY_SIZE(cs53l30_dapm_routes_sdout2));
884 	else
885 		snd_soc_dapm_add_routes(dapm, cs53l30_dapm_routes_sdout1,
886 					ARRAY_SIZE(cs53l30_dapm_routes_sdout1));
887 
888 	return 0;
889 }
890 
891 static const struct snd_soc_component_driver cs53l30_driver = {
892 	.probe			= cs53l30_component_probe,
893 	.set_bias_level		= cs53l30_set_bias_level,
894 	.controls		= cs53l30_snd_controls,
895 	.num_controls		= ARRAY_SIZE(cs53l30_snd_controls),
896 	.dapm_widgets		= cs53l30_dapm_widgets,
897 	.num_dapm_widgets	= ARRAY_SIZE(cs53l30_dapm_widgets),
898 	.dapm_routes		= cs53l30_dapm_routes,
899 	.num_dapm_routes	= ARRAY_SIZE(cs53l30_dapm_routes),
900 	.use_pmdown_time	= 1,
901 	.endianness		= 1,
902 };
903 
904 static struct regmap_config cs53l30_regmap = {
905 	.reg_bits = 8,
906 	.val_bits = 8,
907 
908 	.max_register = CS53L30_MAX_REGISTER,
909 	.reg_defaults = cs53l30_reg_defaults,
910 	.num_reg_defaults = ARRAY_SIZE(cs53l30_reg_defaults),
911 	.volatile_reg = cs53l30_volatile_register,
912 	.writeable_reg = cs53l30_writeable_register,
913 	.readable_reg = cs53l30_readable_register,
914 	.cache_type = REGCACHE_RBTREE,
915 
916 	.use_single_read = true,
917 	.use_single_write = true,
918 };
919 
cs53l30_i2c_probe(struct i2c_client * client)920 static int cs53l30_i2c_probe(struct i2c_client *client)
921 {
922 	const struct device_node *np = client->dev.of_node;
923 	struct device *dev = &client->dev;
924 	struct cs53l30_private *cs53l30;
925 	unsigned int reg;
926 	int ret = 0, i, devid;
927 	u8 val;
928 
929 	cs53l30 = devm_kzalloc(dev, sizeof(*cs53l30), GFP_KERNEL);
930 	if (!cs53l30)
931 		return -ENOMEM;
932 
933 	for (i = 0; i < ARRAY_SIZE(cs53l30->supplies); i++)
934 		cs53l30->supplies[i].supply = cs53l30_supply_names[i];
935 
936 	ret = devm_regulator_bulk_get(dev, ARRAY_SIZE(cs53l30->supplies),
937 				      cs53l30->supplies);
938 	if (ret) {
939 		dev_err(dev, "failed to get supplies: %d\n", ret);
940 		return ret;
941 	}
942 
943 	ret = regulator_bulk_enable(ARRAY_SIZE(cs53l30->supplies),
944 				    cs53l30->supplies);
945 	if (ret) {
946 		dev_err(dev, "failed to enable supplies: %d\n", ret);
947 		return ret;
948 	}
949 
950 	/* Reset the Device */
951 	cs53l30->reset_gpio = devm_gpiod_get_optional(dev, "reset",
952 						      GPIOD_OUT_LOW);
953 	if (IS_ERR(cs53l30->reset_gpio)) {
954 		ret = PTR_ERR(cs53l30->reset_gpio);
955 		goto error_supplies;
956 	}
957 
958 	gpiod_set_value_cansleep(cs53l30->reset_gpio, 1);
959 
960 	i2c_set_clientdata(client, cs53l30);
961 
962 	cs53l30->mclk_rate = 0;
963 
964 	cs53l30->regmap = devm_regmap_init_i2c(client, &cs53l30_regmap);
965 	if (IS_ERR(cs53l30->regmap)) {
966 		ret = PTR_ERR(cs53l30->regmap);
967 		dev_err(dev, "regmap_init() failed: %d\n", ret);
968 		goto error;
969 	}
970 
971 	/* Initialize codec */
972 	devid = cirrus_read_device_id(cs53l30->regmap, CS53L30_DEVID_AB);
973 	if (devid < 0) {
974 		ret = devid;
975 		dev_err(dev, "Failed to read device ID: %d\n", ret);
976 		goto error;
977 	}
978 
979 	if (devid != CS53L30_DEVID) {
980 		ret = -ENODEV;
981 		dev_err(dev, "Device ID (%X). Expected %X\n",
982 			devid, CS53L30_DEVID);
983 		goto error;
984 	}
985 
986 	ret = regmap_read(cs53l30->regmap, CS53L30_REVID, &reg);
987 	if (ret < 0) {
988 		dev_err(dev, "failed to get Revision ID: %d\n", ret);
989 		goto error;
990 	}
991 
992 	/* Check if MCLK provided */
993 	cs53l30->mclk = devm_clk_get(dev, "mclk");
994 	if (IS_ERR(cs53l30->mclk)) {
995 		if (PTR_ERR(cs53l30->mclk) != -ENOENT) {
996 			ret = PTR_ERR(cs53l30->mclk);
997 			goto error;
998 		}
999 		/* Otherwise mark the mclk pointer to NULL */
1000 		cs53l30->mclk = NULL;
1001 	}
1002 
1003 	/* Fetch the MUTE control */
1004 	cs53l30->mute_gpio = devm_gpiod_get_optional(dev, "mute",
1005 						     GPIOD_OUT_HIGH);
1006 	if (IS_ERR(cs53l30->mute_gpio)) {
1007 		ret = PTR_ERR(cs53l30->mute_gpio);
1008 		goto error;
1009 	}
1010 
1011 	if (cs53l30->mute_gpio) {
1012 		/* Enable MUTE controls via MUTE pin */
1013 		regmap_write(cs53l30->regmap, CS53L30_MUTEP_CTL1,
1014 			     CS53L30_MUTEP_CTL1_MUTEALL);
1015 		/* Flip the polarity of MUTE pin */
1016 		if (gpiod_is_active_low(cs53l30->mute_gpio))
1017 			regmap_update_bits(cs53l30->regmap, CS53L30_MUTEP_CTL2,
1018 					   CS53L30_MUTE_PIN_POLARITY, 0);
1019 	}
1020 
1021 	if (!of_property_read_u8(np, "cirrus,micbias-lvl", &val))
1022 		regmap_update_bits(cs53l30->regmap, CS53L30_MICBIAS_CTL,
1023 				   CS53L30_MIC_BIAS_CTRL_MASK, val);
1024 
1025 	if (of_property_read_bool(np, "cirrus,use-sdout2"))
1026 		cs53l30->use_sdout2 = true;
1027 
1028 	dev_info(dev, "Cirrus Logic CS53L30, Revision: %02X\n", reg & 0xFF);
1029 
1030 	ret = devm_snd_soc_register_component(dev, &cs53l30_driver, &cs53l30_dai, 1);
1031 	if (ret) {
1032 		dev_err(dev, "failed to register component: %d\n", ret);
1033 		goto error;
1034 	}
1035 
1036 	return 0;
1037 
1038 error:
1039 	gpiod_set_value_cansleep(cs53l30->reset_gpio, 0);
1040 error_supplies:
1041 	regulator_bulk_disable(ARRAY_SIZE(cs53l30->supplies),
1042 			       cs53l30->supplies);
1043 	return ret;
1044 }
1045 
cs53l30_i2c_remove(struct i2c_client * client)1046 static void cs53l30_i2c_remove(struct i2c_client *client)
1047 {
1048 	struct cs53l30_private *cs53l30 = i2c_get_clientdata(client);
1049 
1050 	/* Hold down reset */
1051 	gpiod_set_value_cansleep(cs53l30->reset_gpio, 0);
1052 
1053 	regulator_bulk_disable(ARRAY_SIZE(cs53l30->supplies),
1054 			       cs53l30->supplies);
1055 }
1056 
1057 #ifdef CONFIG_PM
cs53l30_runtime_suspend(struct device * dev)1058 static int cs53l30_runtime_suspend(struct device *dev)
1059 {
1060 	struct cs53l30_private *cs53l30 = dev_get_drvdata(dev);
1061 
1062 	regcache_cache_only(cs53l30->regmap, true);
1063 
1064 	/* Hold down reset */
1065 	gpiod_set_value_cansleep(cs53l30->reset_gpio, 0);
1066 
1067 	regulator_bulk_disable(ARRAY_SIZE(cs53l30->supplies),
1068 			       cs53l30->supplies);
1069 
1070 	return 0;
1071 }
1072 
cs53l30_runtime_resume(struct device * dev)1073 static int cs53l30_runtime_resume(struct device *dev)
1074 {
1075 	struct cs53l30_private *cs53l30 = dev_get_drvdata(dev);
1076 	int ret;
1077 
1078 	ret = regulator_bulk_enable(ARRAY_SIZE(cs53l30->supplies),
1079 				    cs53l30->supplies);
1080 	if (ret) {
1081 		dev_err(dev, "failed to enable supplies: %d\n", ret);
1082 		return ret;
1083 	}
1084 
1085 	gpiod_set_value_cansleep(cs53l30->reset_gpio, 1);
1086 
1087 	regcache_cache_only(cs53l30->regmap, false);
1088 	ret = regcache_sync(cs53l30->regmap);
1089 	if (ret) {
1090 		dev_err(dev, "failed to synchronize regcache: %d\n", ret);
1091 		return ret;
1092 	}
1093 
1094 	return 0;
1095 }
1096 #endif
1097 
1098 static const struct dev_pm_ops cs53l30_runtime_pm = {
1099 	SET_RUNTIME_PM_OPS(cs53l30_runtime_suspend, cs53l30_runtime_resume,
1100 			   NULL)
1101 };
1102 
1103 static const struct of_device_id cs53l30_of_match[] = {
1104 	{ .compatible = "cirrus,cs53l30", },
1105 	{},
1106 };
1107 
1108 MODULE_DEVICE_TABLE(of, cs53l30_of_match);
1109 
1110 static const struct i2c_device_id cs53l30_id[] = {
1111 	{ "cs53l30", 0 },
1112 	{}
1113 };
1114 
1115 MODULE_DEVICE_TABLE(i2c, cs53l30_id);
1116 
1117 static struct i2c_driver cs53l30_i2c_driver = {
1118 	.driver = {
1119 		.name = "cs53l30",
1120 		.of_match_table = cs53l30_of_match,
1121 		.pm = &cs53l30_runtime_pm,
1122 	},
1123 	.id_table = cs53l30_id,
1124 	.probe_new = cs53l30_i2c_probe,
1125 	.remove = cs53l30_i2c_remove,
1126 };
1127 
1128 module_i2c_driver(cs53l30_i2c_driver);
1129 
1130 MODULE_DESCRIPTION("ASoC CS53L30 driver");
1131 MODULE_AUTHOR("Paul Handrigan, Cirrus Logic Inc, <Paul.Handrigan@cirrus.com>");
1132 MODULE_LICENSE("GPL");
1133