?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
treewide: remove redundant IS_ERR() before error code check
[linux/fpc-iii.git] / sound / soc / codecs / cs43130.c
blob7fb34422a2a4b087d5a785597ee225f3cf4b684e
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * cs43130.c -- CS43130 ALSA Soc Audio driver
4 *
5 * Copyright 2017 Cirrus Logic, Inc.
6 *
7 * Authors: Li Xu <li.xu@cirrus.com>
8 */
9 #include <linux/module.h>
10 #include <linux/moduleparam.h>
11 #include <linux/kernel.h>
12 #include <linux/init.h>
13 #include <linux/delay.h>
14 #include <linux/gpio.h>
15 #include <linux/gpio/consumer.h>
16 #include <linux/platform_device.h>
17 #include <linux/pm.h>
18 #include <linux/i2c.h>
19 #include <linux/of_device.h>
20 #include <linux/regmap.h>
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/soc-dapm.h>
27 #include <sound/initval.h>
28 #include <sound/tlv.h>
29 #include <linux/of_gpio.h>
30 #include <linux/regulator/consumer.h>
31 #include <linux/pm_runtime.h>
32 #include <linux/of_irq.h>
33 #include <linux/completion.h>
34 #include <linux/mutex.h>
35 #include <linux/workqueue.h>
36 #include <sound/jack.h>
37
38 #include "cs43130.h"
39
40 static const struct reg_default cs43130_reg_defaults[] = {
41 {CS43130_SYS_CLK_CTL_1, 0x06},
42 {CS43130_SP_SRATE, 0x01},
43 {CS43130_SP_BITSIZE, 0x05},
44 {CS43130_PAD_INT_CFG, 0x03},
45 {CS43130_PWDN_CTL, 0xFE},
46 {CS43130_CRYSTAL_SET, 0x04},
47 {CS43130_PLL_SET_1, 0x00},
48 {CS43130_PLL_SET_2, 0x00},
49 {CS43130_PLL_SET_3, 0x00},
50 {CS43130_PLL_SET_4, 0x00},
51 {CS43130_PLL_SET_5, 0x40},
52 {CS43130_PLL_SET_6, 0x10},
53 {CS43130_PLL_SET_7, 0x80},
54 {CS43130_PLL_SET_8, 0x03},
55 {CS43130_PLL_SET_9, 0x02},
56 {CS43130_PLL_SET_10, 0x02},
57 {CS43130_CLKOUT_CTL, 0x00},
58 {CS43130_ASP_NUM_1, 0x01},
59 {CS43130_ASP_NUM_2, 0x00},
60 {CS43130_ASP_DEN_1, 0x08},
61 {CS43130_ASP_DEN_2, 0x00},
62 {CS43130_ASP_LRCK_HI_TIME_1, 0x1F},
63 {CS43130_ASP_LRCK_HI_TIME_2, 0x00},
64 {CS43130_ASP_LRCK_PERIOD_1, 0x3F},
65 {CS43130_ASP_LRCK_PERIOD_2, 0x00},
66 {CS43130_ASP_CLOCK_CONF, 0x0C},
67 {CS43130_ASP_FRAME_CONF, 0x0A},
68 {CS43130_XSP_NUM_1, 0x01},
69 {CS43130_XSP_NUM_2, 0x00},
70 {CS43130_XSP_DEN_1, 0x02},
71 {CS43130_XSP_DEN_2, 0x00},
72 {CS43130_XSP_LRCK_HI_TIME_1, 0x1F},
73 {CS43130_XSP_LRCK_HI_TIME_2, 0x00},
74 {CS43130_XSP_LRCK_PERIOD_1, 0x3F},
75 {CS43130_XSP_LRCK_PERIOD_2, 0x00},
76 {CS43130_XSP_CLOCK_CONF, 0x0C},
77 {CS43130_XSP_FRAME_CONF, 0x0A},
78 {CS43130_ASP_CH_1_LOC, 0x00},
79 {CS43130_ASP_CH_2_LOC, 0x00},
80 {CS43130_ASP_CH_1_SZ_EN, 0x06},
81 {CS43130_ASP_CH_2_SZ_EN, 0x0E},
82 {CS43130_XSP_CH_1_LOC, 0x00},
83 {CS43130_XSP_CH_2_LOC, 0x00},
84 {CS43130_XSP_CH_1_SZ_EN, 0x06},
85 {CS43130_XSP_CH_2_SZ_EN, 0x0E},
86 {CS43130_DSD_VOL_B, 0x78},
87 {CS43130_DSD_VOL_A, 0x78},
88 {CS43130_DSD_PATH_CTL_1, 0xA8},
89 {CS43130_DSD_INT_CFG, 0x00},
90 {CS43130_DSD_PATH_CTL_2, 0x02},
91 {CS43130_DSD_PCM_MIX_CTL, 0x00},
92 {CS43130_DSD_PATH_CTL_3, 0x40},
93 {CS43130_HP_OUT_CTL_1, 0x30},
94 {CS43130_PCM_FILT_OPT, 0x02},
95 {CS43130_PCM_VOL_B, 0x78},
96 {CS43130_PCM_VOL_A, 0x78},
97 {CS43130_PCM_PATH_CTL_1, 0xA8},
98 {CS43130_PCM_PATH_CTL_2, 0x00},
99 {CS43130_CLASS_H_CTL, 0x1E},
100 {CS43130_HP_DETECT, 0x04},
101 {CS43130_HP_LOAD_1, 0x00},
102 {CS43130_HP_MEAS_LOAD_1, 0x00},
103 {CS43130_HP_MEAS_LOAD_2, 0x00},
104 {CS43130_INT_MASK_1, 0xFF},
105 {CS43130_INT_MASK_2, 0xFF},
106 {CS43130_INT_MASK_3, 0xFF},
107 {CS43130_INT_MASK_4, 0xFF},
108 {CS43130_INT_MASK_5, 0xFF},
109 };
110
111 static bool cs43130_volatile_register(struct device *dev, unsigned int reg)
112 {
113 switch (reg) {
114 case CS43130_INT_STATUS_1 ... CS43130_INT_STATUS_5:
115 case CS43130_HP_DC_STAT_1 ... CS43130_HP_DC_STAT_2:
116 case CS43130_HP_AC_STAT_1 ... CS43130_HP_AC_STAT_2:
117 return true;
118 default:
119 return false;
120 }
121 }
122
123 static bool cs43130_readable_register(struct device *dev, unsigned int reg)
124 {
125 switch (reg) {
126 case CS43130_DEVID_AB ... CS43130_SYS_CLK_CTL_1:
127 case CS43130_SP_SRATE ... CS43130_PAD_INT_CFG:
128 case CS43130_PWDN_CTL:
129 case CS43130_CRYSTAL_SET:
130 case CS43130_PLL_SET_1 ... CS43130_PLL_SET_5:
131 case CS43130_PLL_SET_6:
132 case CS43130_PLL_SET_7:
133 case CS43130_PLL_SET_8:
134 case CS43130_PLL_SET_9:
135 case CS43130_PLL_SET_10:
136 case CS43130_CLKOUT_CTL:
137 case CS43130_ASP_NUM_1 ... CS43130_ASP_FRAME_CONF:
138 case CS43130_XSP_NUM_1 ... CS43130_XSP_FRAME_CONF:
139 case CS43130_ASP_CH_1_LOC:
140 case CS43130_ASP_CH_2_LOC:
141 case CS43130_ASP_CH_1_SZ_EN:
142 case CS43130_ASP_CH_2_SZ_EN:
143 case CS43130_XSP_CH_1_LOC:
144 case CS43130_XSP_CH_2_LOC:
145 case CS43130_XSP_CH_1_SZ_EN:
146 case CS43130_XSP_CH_2_SZ_EN:
147 case CS43130_DSD_VOL_B ... CS43130_DSD_PATH_CTL_3:
148 case CS43130_HP_OUT_CTL_1:
149 case CS43130_PCM_FILT_OPT ... CS43130_PCM_PATH_CTL_2:
150 case CS43130_CLASS_H_CTL:
151 case CS43130_HP_DETECT:
152 case CS43130_HP_STATUS:
153 case CS43130_HP_LOAD_1:
154 case CS43130_HP_MEAS_LOAD_1:
155 case CS43130_HP_MEAS_LOAD_2:
156 case CS43130_HP_DC_STAT_1:
157 case CS43130_HP_DC_STAT_2:
158 case CS43130_HP_AC_STAT_1:
159 case CS43130_HP_AC_STAT_2:
160 case CS43130_HP_LOAD_STAT:
161 case CS43130_INT_STATUS_1 ... CS43130_INT_STATUS_5:
162 case CS43130_INT_MASK_1 ... CS43130_INT_MASK_5:
163 return true;
164 default:
165 return false;
166 }
167 }
168
169 static bool cs43130_precious_register(struct device *dev, unsigned int reg)
170 {
171 switch (reg) {
172 case CS43130_INT_STATUS_1 ... CS43130_INT_STATUS_5:
173 return true;
174 default:
175 return false;
176 }
177 }
178
179 struct cs43130_pll_params {
180 unsigned int pll_in;
181 u8 sclk_prediv;
182 u8 pll_div_int;
183 u32 pll_div_frac;
184 u8 pll_mode;
185 u8 pll_divout;
186 unsigned int pll_out;
187 u8 pll_cal_ratio;
188 };
189
190 static const struct cs43130_pll_params pll_ratio_table[] = {
191 {9600000, 0x02, 0x49, 0x800000, 0x00, 0x08, 22579200, 151},
192 {9600000, 0x02, 0x50, 0x000000, 0x00, 0x08, 24576000, 164},
193
194 {11289600, 0x02, 0X40, 0, 0x01, 0x08, 22579200, 128},
195 {11289600, 0x02, 0x44, 0x06F700, 0x0, 0x08, 24576000, 139},
196
197 {12000000, 0x02, 0x49, 0x800000, 0x00, 0x0A, 22579200, 120},
198 {12000000, 0x02, 0x40, 0x000000, 0x00, 0x08, 24576000, 131},
199
200 {12288000, 0x02, 0x49, 0x800000, 0x01, 0x0A, 22579200, 118},
201 {12288000, 0x02, 0x40, 0x000000, 0x01, 0x08, 24576000, 128},
202
203 {13000000, 0x02, 0x45, 0x797680, 0x01, 0x0A, 22579200, 111},
204 {13000000, 0x02, 0x3C, 0x7EA940, 0x01, 0x08, 24576000, 121},
205
206 {19200000, 0x03, 0x49, 0x800000, 0x00, 0x08, 22579200, 151},
207 {19200000, 0x03, 0x50, 0x000000, 0x00, 0x08, 24576000, 164},
208
209 {22579200, 0, 0, 0, 0, 0, 22579200, 0},
210 {22579200, 0x03, 0x44, 0x06F700, 0x00, 0x08, 24576000, 139},
211
212 {24000000, 0x03, 0x49, 0x800000, 0x00, 0x0A, 22579200, 120},
213 {24000000, 0x03, 0x40, 0x000000, 0x00, 0x08, 24576000, 131},
214
215 {24576000, 0x03, 0x49, 0x800000, 0x01, 0x0A, 22579200, 118},
216 {24576000, 0, 0, 0, 0, 0, 24576000, 0},
217
218 {26000000, 0x03, 0x45, 0x797680, 0x01, 0x0A, 22579200, 111},
219 {26000000, 0x03, 0x3C, 0x7EA940, 0x01, 0x08, 24576000, 121},
220 };
221
222 static const struct cs43130_pll_params *cs43130_get_pll_table(
223 unsigned int freq_in, unsigned int freq_out)
224 {
225 int i;
226
227 for (i = 0; i < ARRAY_SIZE(pll_ratio_table); i++) {
228 if (pll_ratio_table[i].pll_in == freq_in &&
229 pll_ratio_table[i].pll_out == freq_out)
230 return &pll_ratio_table[i];
231 }
232
233 return NULL;
234 }
235
236 static int cs43130_pll_config(struct snd_soc_component *component)
237 {
238 struct cs43130_private *cs43130 = snd_soc_component_get_drvdata(component);
239 const struct cs43130_pll_params *pll_entry;
240
241 dev_dbg(component->dev, "cs43130->mclk = %u, cs43130->mclk_int = %u\n",
242 cs43130->mclk, cs43130->mclk_int);
243
244 pll_entry = cs43130_get_pll_table(cs43130->mclk, cs43130->mclk_int);
245 if (!pll_entry)
246 return -EINVAL;
247
248 if (pll_entry->pll_cal_ratio == 0) {
249 regmap_update_bits(cs43130->regmap, CS43130_PLL_SET_1,
250 CS43130_PLL_START_MASK, 0);
251
252 cs43130->pll_bypass = true;
253 return 0;
254 }
255
256 cs43130->pll_bypass = false;
257
258 regmap_update_bits(cs43130->regmap, CS43130_PLL_SET_2,
259 CS43130_PLL_DIV_DATA_MASK,
260 pll_entry->pll_div_frac >>
261 CS43130_PLL_DIV_FRAC_0_DATA_SHIFT);
262 regmap_update_bits(cs43130->regmap, CS43130_PLL_SET_3,
263 CS43130_PLL_DIV_DATA_MASK,
264 pll_entry->pll_div_frac >>
265 CS43130_PLL_DIV_FRAC_1_DATA_SHIFT);
266 regmap_update_bits(cs43130->regmap, CS43130_PLL_SET_4,
267 CS43130_PLL_DIV_DATA_MASK,
268 pll_entry->pll_div_frac >>
269 CS43130_PLL_DIV_FRAC_2_DATA_SHIFT);
270 regmap_write(cs43130->regmap, CS43130_PLL_SET_5,
271 pll_entry->pll_div_int);
272 regmap_write(cs43130->regmap, CS43130_PLL_SET_6, pll_entry->pll_divout);
273 regmap_write(cs43130->regmap, CS43130_PLL_SET_7,
274 pll_entry->pll_cal_ratio);
275 regmap_update_bits(cs43130->regmap, CS43130_PLL_SET_8,
276 CS43130_PLL_MODE_MASK,
277 pll_entry->pll_mode << CS43130_PLL_MODE_SHIFT);
278 regmap_write(cs43130->regmap, CS43130_PLL_SET_9,
279 pll_entry->sclk_prediv);
280 regmap_update_bits(cs43130->regmap, CS43130_PLL_SET_1,
281 CS43130_PLL_START_MASK, 1);
282
283 return 0;
284 }
285
286 static int cs43130_set_pll(struct snd_soc_component *component, int pll_id, int source,
287 unsigned int freq_in, unsigned int freq_out)
288 {
289 int ret = 0;
290 struct cs43130_private *cs43130 = snd_soc_component_get_drvdata(component);
291
292 switch (freq_in) {
293 case 9600000:
294 case 11289600:
295 case 12000000:
296 case 12288000:
297 case 13000000:
298 case 19200000:
299 case 22579200:
300 case 24000000:
301 case 24576000:
302 case 26000000:
303 cs43130->mclk = freq_in;
304 break;
305 default:
306 dev_err(component->dev,
307 "unsupported pll input reference clock:%d\n", freq_in);
308 return -EINVAL;
309 }
310
311 switch (freq_out) {
312 case 22579200:
313 cs43130->mclk_int = freq_out;
314 break;
315 case 24576000:
316 cs43130->mclk_int = freq_out;
317 break;
318 default:
319 dev_err(component->dev,
320 "unsupported pll output ref clock: %u\n", freq_out);
321 return -EINVAL;
322 }
323
324 ret = cs43130_pll_config(component);
325 dev_dbg(component->dev, "cs43130->pll_bypass = %d", cs43130->pll_bypass);
326 return ret;
327 }
328
329 static int cs43130_change_clksrc(struct snd_soc_component *component,
330 enum cs43130_mclk_src_sel src)
331 {
332 int ret;
333 struct cs43130_private *cs43130 = snd_soc_component_get_drvdata(component);
334 int mclk_int_decoded;
335
336 if (src == cs43130->mclk_int_src) {
337 /* clk source has not changed */
338 return 0;
339 }
340
341 switch (cs43130->mclk_int) {
342 case CS43130_MCLK_22M:
343 mclk_int_decoded = CS43130_MCLK_22P5;
344 break;
345 case CS43130_MCLK_24M:
346 mclk_int_decoded = CS43130_MCLK_24P5;
347 break;
348 default:
349 dev_err(component->dev, "Invalid MCLK INT freq: %u\n", cs43130->mclk_int);
350 return -EINVAL;
351 }
352
353 switch (src) {
354 case CS43130_MCLK_SRC_EXT:
355 cs43130->pll_bypass = true;
356 cs43130->mclk_int_src = CS43130_MCLK_SRC_EXT;
357 if (cs43130->xtal_ibias == CS43130_XTAL_UNUSED) {
358 regmap_update_bits(cs43130->regmap, CS43130_PWDN_CTL,
359 CS43130_PDN_XTAL_MASK,
360 1 << CS43130_PDN_XTAL_SHIFT);
361 } else {
362 reinit_completion(&cs43130->xtal_rdy);
363 regmap_update_bits(cs43130->regmap, CS43130_INT_MASK_1,
364 CS43130_XTAL_RDY_INT_MASK, 0);
365 regmap_update_bits(cs43130->regmap, CS43130_PWDN_CTL,
366 CS43130_PDN_XTAL_MASK, 0);
367 ret = wait_for_completion_timeout(&cs43130->xtal_rdy,
368 msecs_to_jiffies(100));
369 regmap_update_bits(cs43130->regmap, CS43130_INT_MASK_1,
370 CS43130_XTAL_RDY_INT_MASK,
371 1 << CS43130_XTAL_RDY_INT_SHIFT);
372 if (ret == 0) {
373 dev_err(component->dev, "Timeout waiting for XTAL_READY interrupt\n");
374 return -ETIMEDOUT;
375 }
376 }
377
378 regmap_update_bits(cs43130->regmap, CS43130_SYS_CLK_CTL_1,
379 CS43130_MCLK_SRC_SEL_MASK,
380 src << CS43130_MCLK_SRC_SEL_SHIFT);
381 regmap_update_bits(cs43130->regmap, CS43130_SYS_CLK_CTL_1,
382 CS43130_MCLK_INT_MASK,
383 mclk_int_decoded << CS43130_MCLK_INT_SHIFT);
384 usleep_range(150, 200);
385
386 regmap_update_bits(cs43130->regmap, CS43130_PWDN_CTL,
387 CS43130_PDN_PLL_MASK,
388 1 << CS43130_PDN_PLL_SHIFT);
389 break;
390 case CS43130_MCLK_SRC_PLL:
391 cs43130->pll_bypass = false;
392 cs43130->mclk_int_src = CS43130_MCLK_SRC_PLL;
393 if (cs43130->xtal_ibias == CS43130_XTAL_UNUSED) {
394 regmap_update_bits(cs43130->regmap, CS43130_PWDN_CTL,
395 CS43130_PDN_XTAL_MASK,
396 1 << CS43130_PDN_XTAL_SHIFT);
397 } else {
398 reinit_completion(&cs43130->xtal_rdy);
399 regmap_update_bits(cs43130->regmap, CS43130_INT_MASK_1,
400 CS43130_XTAL_RDY_INT_MASK, 0);
401 regmap_update_bits(cs43130->regmap, CS43130_PWDN_CTL,
402 CS43130_PDN_XTAL_MASK, 0);
403 ret = wait_for_completion_timeout(&cs43130->xtal_rdy,
404 msecs_to_jiffies(100));
405 regmap_update_bits(cs43130->regmap, CS43130_INT_MASK_1,
406 CS43130_XTAL_RDY_INT_MASK,
407 1 << CS43130_XTAL_RDY_INT_SHIFT);
408 if (ret == 0) {
409 dev_err(component->dev, "Timeout waiting for XTAL_READY interrupt\n");
410 return -ETIMEDOUT;
411 }
412 }
413
414 reinit_completion(&cs43130->pll_rdy);
415 regmap_update_bits(cs43130->regmap, CS43130_INT_MASK_1,
416 CS43130_PLL_RDY_INT_MASK, 0);
417 regmap_update_bits(cs43130->regmap, CS43130_PWDN_CTL,
418 CS43130_PDN_PLL_MASK, 0);
419 ret = wait_for_completion_timeout(&cs43130->pll_rdy,
420 msecs_to_jiffies(100));
421 regmap_update_bits(cs43130->regmap, CS43130_INT_MASK_1,
422 CS43130_PLL_RDY_INT_MASK,
423 1 << CS43130_PLL_RDY_INT_SHIFT);
424 if (ret == 0) {
425 dev_err(component->dev, "Timeout waiting for PLL_READY interrupt\n");
426 return -ETIMEDOUT;
427 }
428
429 regmap_update_bits(cs43130->regmap, CS43130_SYS_CLK_CTL_1,
430 CS43130_MCLK_SRC_SEL_MASK,
431 src << CS43130_MCLK_SRC_SEL_SHIFT);
432 regmap_update_bits(cs43130->regmap, CS43130_SYS_CLK_CTL_1,
433 CS43130_MCLK_INT_MASK,
434 mclk_int_decoded << CS43130_MCLK_INT_SHIFT);
435 usleep_range(150, 200);
436 break;
437 case CS43130_MCLK_SRC_RCO:
438 cs43130->mclk_int_src = CS43130_MCLK_SRC_RCO;
439
440 regmap_update_bits(cs43130->regmap, CS43130_SYS_CLK_CTL_1,
441 CS43130_MCLK_SRC_SEL_MASK,
442 src << CS43130_MCLK_SRC_SEL_SHIFT);
443 regmap_update_bits(cs43130->regmap, CS43130_SYS_CLK_CTL_1,
444 CS43130_MCLK_INT_MASK,
445 CS43130_MCLK_22P5 << CS43130_MCLK_INT_SHIFT);
446 usleep_range(150, 200);
447
448 regmap_update_bits(cs43130->regmap, CS43130_PWDN_CTL,
449 CS43130_PDN_XTAL_MASK,
450 1 << CS43130_PDN_XTAL_SHIFT);
451 regmap_update_bits(cs43130->regmap, CS43130_PWDN_CTL,
452 CS43130_PDN_PLL_MASK,
453 1 << CS43130_PDN_PLL_SHIFT);
454 break;
455 default:
456 dev_err(component->dev, "Invalid MCLK source value\n");
457 return -EINVAL;
458 }
459
460 return 0;
461 }
462
463 static const struct cs43130_bitwidth_map cs43130_bitwidth_table[] = {
464 {8, CS43130_SP_BIT_SIZE_8, CS43130_CH_BIT_SIZE_8},
465 {16, CS43130_SP_BIT_SIZE_16, CS43130_CH_BIT_SIZE_16},
466 {24, CS43130_SP_BIT_SIZE_24, CS43130_CH_BIT_SIZE_24},
467 {32, CS43130_SP_BIT_SIZE_32, CS43130_CH_BIT_SIZE_32},
468 };
469
470 static const struct cs43130_bitwidth_map *cs43130_get_bitwidth_table(
471 unsigned int bitwidth)
472 {
473 int i;
474
475 for (i = 0; i < ARRAY_SIZE(cs43130_bitwidth_table); i++) {
476 if (cs43130_bitwidth_table[i].bitwidth == bitwidth)
477 return &cs43130_bitwidth_table[i];
478 }
479
480 return NULL;
481 }
482
483 static int cs43130_set_bitwidth(int dai_id, unsigned int bitwidth_dai,
484 struct regmap *regmap)
485 {
486 const struct cs43130_bitwidth_map *bw_map;
487
488 bw_map = cs43130_get_bitwidth_table(bitwidth_dai);
489 if (!bw_map)
490 return -EINVAL;
491
492 switch (dai_id) {
493 case CS43130_ASP_PCM_DAI:
494 case CS43130_ASP_DOP_DAI:
495 regmap_update_bits(regmap, CS43130_ASP_CH_1_SZ_EN,
496 CS43130_CH_BITSIZE_MASK, bw_map->ch_bit);
497 regmap_update_bits(regmap, CS43130_ASP_CH_2_SZ_EN,
498 CS43130_CH_BITSIZE_MASK, bw_map->ch_bit);
499 regmap_update_bits(regmap, CS43130_SP_BITSIZE,
500 CS43130_ASP_BITSIZE_MASK, bw_map->sp_bit);
501 break;
502 case CS43130_XSP_DOP_DAI:
503 regmap_update_bits(regmap, CS43130_XSP_CH_1_SZ_EN,
504 CS43130_CH_BITSIZE_MASK, bw_map->ch_bit);
505 regmap_update_bits(regmap, CS43130_XSP_CH_2_SZ_EN,
506 CS43130_CH_BITSIZE_MASK, bw_map->ch_bit);
507 regmap_update_bits(regmap, CS43130_SP_BITSIZE,
508 CS43130_XSP_BITSIZE_MASK, bw_map->sp_bit <<
509 CS43130_XSP_BITSIZE_SHIFT);
510 break;
511 default:
512 return -EINVAL;
513 }
514
515 return 0;
516 }
517
518 static const struct cs43130_rate_map cs43130_rate_table[] = {
519 {32000, CS43130_ASP_SPRATE_32K},
520 {44100, CS43130_ASP_SPRATE_44_1K},
521 {48000, CS43130_ASP_SPRATE_48K},
522 {88200, CS43130_ASP_SPRATE_88_2K},
523 {96000, CS43130_ASP_SPRATE_96K},
524 {176400, CS43130_ASP_SPRATE_176_4K},
525 {192000, CS43130_ASP_SPRATE_192K},
526 {352800, CS43130_ASP_SPRATE_352_8K},
527 {384000, CS43130_ASP_SPRATE_384K},
528 };
529
530 static const struct cs43130_rate_map *cs43130_get_rate_table(int fs)
531 {
532 int i;
533
534 for (i = 0; i < ARRAY_SIZE(cs43130_rate_table); i++) {
535 if (cs43130_rate_table[i].fs == fs)
536 return &cs43130_rate_table[i];
537 }
538
539 return NULL;
540 }
541
542 static const struct cs43130_clk_gen *cs43130_get_clk_gen(int mclk_int, int fs,
543 const struct cs43130_clk_gen *clk_gen_table, int len_clk_gen_table)
544 {
545 int i;
546
547 for (i = 0; i < len_clk_gen_table; i++) {
548 if (clk_gen_table[i].mclk_int == mclk_int &&
549 clk_gen_table[i].fs == fs)
550 return &clk_gen_table[i];
551 }
552
553 return NULL;
554 }
555
556 static int cs43130_set_sp_fmt(int dai_id, unsigned int bitwidth_sclk,
557 struct snd_pcm_hw_params *params,
558 struct cs43130_private *cs43130)
559 {
560 u16 frm_size;
561 u16 hi_size;
562 u8 frm_delay;
563 u8 frm_phase;
564 u8 frm_data;
565 u8 sclk_edge;
566 u8 lrck_edge;
567 u8 clk_data;
568 u8 loc_ch1;
569 u8 loc_ch2;
570 u8 dai_mode_val;
571 const struct cs43130_clk_gen *clk_gen;
572
573 switch (cs43130->dais[dai_id].dai_format) {
574 case SND_SOC_DAIFMT_I2S:
575 hi_size = bitwidth_sclk;
576 frm_delay = 2;
577 frm_phase = 0;
578 break;
579 case SND_SOC_DAIFMT_LEFT_J:
580 hi_size = bitwidth_sclk;
581 frm_delay = 2;
582 frm_phase = 1;
583 break;
584 case SND_SOC_DAIFMT_DSP_A:
585 hi_size = 1;
586 frm_delay = 2;
587 frm_phase = 1;
588 break;
589 case SND_SOC_DAIFMT_DSP_B:
590 hi_size = 1;
591 frm_delay = 0;
592 frm_phase = 1;
593 break;
594 default:
595 return -EINVAL;
596 }
597
598 switch (cs43130->dais[dai_id].dai_mode) {
599 case SND_SOC_DAIFMT_CBS_CFS:
600 dai_mode_val = 0;
601 break;
602 case SND_SOC_DAIFMT_CBM_CFM:
603 dai_mode_val = 1;
604 break;
605 default:
606 return -EINVAL;
607 }
608
609 frm_size = bitwidth_sclk * params_channels(params);
610 sclk_edge = 1;
611 lrck_edge = 0;
612 loc_ch1 = 0;
613 loc_ch2 = bitwidth_sclk * (params_channels(params) - 1);
614
615 frm_data = frm_delay & CS43130_SP_FSD_MASK;
616 frm_data |= (frm_phase << CS43130_SP_STP_SHIFT) & CS43130_SP_STP_MASK;
617
618 clk_data = lrck_edge & CS43130_SP_LCPOL_IN_MASK;
619 clk_data |= (lrck_edge << CS43130_SP_LCPOL_OUT_SHIFT) &
620 CS43130_SP_LCPOL_OUT_MASK;
621 clk_data |= (sclk_edge << CS43130_SP_SCPOL_IN_SHIFT) &
622 CS43130_SP_SCPOL_IN_MASK;
623 clk_data |= (sclk_edge << CS43130_SP_SCPOL_OUT_SHIFT) &
624 CS43130_SP_SCPOL_OUT_MASK;
625 clk_data |= (dai_mode_val << CS43130_SP_MODE_SHIFT) &
626 CS43130_SP_MODE_MASK;
627
628 switch (dai_id) {
629 case CS43130_ASP_PCM_DAI:
630 case CS43130_ASP_DOP_DAI:
631 regmap_update_bits(cs43130->regmap, CS43130_ASP_LRCK_PERIOD_1,
632 CS43130_SP_LCPR_DATA_MASK, (frm_size - 1) >>
633 CS43130_SP_LCPR_LSB_DATA_SHIFT);
634 regmap_update_bits(cs43130->regmap, CS43130_ASP_LRCK_PERIOD_2,
635 CS43130_SP_LCPR_DATA_MASK, (frm_size - 1) >>
636 CS43130_SP_LCPR_MSB_DATA_SHIFT);
637 regmap_update_bits(cs43130->regmap, CS43130_ASP_LRCK_HI_TIME_1,
638 CS43130_SP_LCHI_DATA_MASK, (hi_size - 1) >>
639 CS43130_SP_LCHI_LSB_DATA_SHIFT);
640 regmap_update_bits(cs43130->regmap, CS43130_ASP_LRCK_HI_TIME_2,
641 CS43130_SP_LCHI_DATA_MASK, (hi_size - 1) >>
642 CS43130_SP_LCHI_MSB_DATA_SHIFT);
643 regmap_write(cs43130->regmap, CS43130_ASP_FRAME_CONF, frm_data);
644 regmap_write(cs43130->regmap, CS43130_ASP_CH_1_LOC, loc_ch1);
645 regmap_write(cs43130->regmap, CS43130_ASP_CH_2_LOC, loc_ch2);
646 regmap_update_bits(cs43130->regmap, CS43130_ASP_CH_1_SZ_EN,
647 CS43130_CH_EN_MASK, 1 << CS43130_CH_EN_SHIFT);
648 regmap_update_bits(cs43130->regmap, CS43130_ASP_CH_2_SZ_EN,
649 CS43130_CH_EN_MASK, 1 << CS43130_CH_EN_SHIFT);
650 regmap_write(cs43130->regmap, CS43130_ASP_CLOCK_CONF, clk_data);
651 break;
652 case CS43130_XSP_DOP_DAI:
653 regmap_update_bits(cs43130->regmap, CS43130_XSP_LRCK_PERIOD_1,
654 CS43130_SP_LCPR_DATA_MASK, (frm_size - 1) >>
655 CS43130_SP_LCPR_LSB_DATA_SHIFT);
656 regmap_update_bits(cs43130->regmap, CS43130_XSP_LRCK_PERIOD_2,
657 CS43130_SP_LCPR_DATA_MASK, (frm_size - 1) >>
658 CS43130_SP_LCPR_MSB_DATA_SHIFT);
659 regmap_update_bits(cs43130->regmap, CS43130_XSP_LRCK_HI_TIME_1,
660 CS43130_SP_LCHI_DATA_MASK, (hi_size - 1) >>
661 CS43130_SP_LCHI_LSB_DATA_SHIFT);
662 regmap_update_bits(cs43130->regmap, CS43130_XSP_LRCK_HI_TIME_2,
663 CS43130_SP_LCHI_DATA_MASK, (hi_size - 1) >>
664 CS43130_SP_LCHI_MSB_DATA_SHIFT);
665 regmap_write(cs43130->regmap, CS43130_XSP_FRAME_CONF, frm_data);
666 regmap_write(cs43130->regmap, CS43130_XSP_CH_1_LOC, loc_ch1);
667 regmap_write(cs43130->regmap, CS43130_XSP_CH_2_LOC, loc_ch2);
668 regmap_update_bits(cs43130->regmap, CS43130_XSP_CH_1_SZ_EN,
669 CS43130_CH_EN_MASK, 1 << CS43130_CH_EN_SHIFT);
670 regmap_update_bits(cs43130->regmap, CS43130_XSP_CH_2_SZ_EN,
671 CS43130_CH_EN_MASK, 1 << CS43130_CH_EN_SHIFT);
672 regmap_write(cs43130->regmap, CS43130_XSP_CLOCK_CONF, clk_data);
673 break;
674 default:
675 return -EINVAL;
676 }
677
678 switch (frm_size) {
679 case 16:
680 clk_gen = cs43130_get_clk_gen(cs43130->mclk_int,
681 params_rate(params),
682 cs43130_16_clk_gen,
683 ARRAY_SIZE(cs43130_16_clk_gen));
684 break;
685 case 32:
686 clk_gen = cs43130_get_clk_gen(cs43130->mclk_int,
687 params_rate(params),
688 cs43130_32_clk_gen,
689 ARRAY_SIZE(cs43130_32_clk_gen));
690 break;
691 case 48:
692 clk_gen = cs43130_get_clk_gen(cs43130->mclk_int,
693 params_rate(params),
694 cs43130_48_clk_gen,
695 ARRAY_SIZE(cs43130_48_clk_gen));
696 break;
697 case 64:
698 clk_gen = cs43130_get_clk_gen(cs43130->mclk_int,
699 params_rate(params),
700 cs43130_64_clk_gen,
701 ARRAY_SIZE(cs43130_64_clk_gen));
702 break;
703 default:
704 return -EINVAL;
705 }
706
707 if (!clk_gen)
708 return -EINVAL;
709
710 switch (dai_id) {
711 case CS43130_ASP_PCM_DAI:
712 case CS43130_ASP_DOP_DAI:
713 regmap_write(cs43130->regmap, CS43130_ASP_DEN_1,
714 (clk_gen->den & CS43130_SP_M_LSB_DATA_MASK) >>
715 CS43130_SP_M_LSB_DATA_SHIFT);
716 regmap_write(cs43130->regmap, CS43130_ASP_DEN_2,
717 (clk_gen->den & CS43130_SP_M_MSB_DATA_MASK) >>
718 CS43130_SP_M_MSB_DATA_SHIFT);
719 regmap_write(cs43130->regmap, CS43130_ASP_NUM_1,
720 (clk_gen->num & CS43130_SP_N_LSB_DATA_MASK) >>
721 CS43130_SP_N_LSB_DATA_SHIFT);
722 regmap_write(cs43130->regmap, CS43130_ASP_NUM_2,
723 (clk_gen->num & CS43130_SP_N_MSB_DATA_MASK) >>
724 CS43130_SP_N_MSB_DATA_SHIFT);
725 break;
726 case CS43130_XSP_DOP_DAI:
727 regmap_write(cs43130->regmap, CS43130_XSP_DEN_1,
728 (clk_gen->den & CS43130_SP_M_LSB_DATA_MASK) >>
729 CS43130_SP_M_LSB_DATA_SHIFT);
730 regmap_write(cs43130->regmap, CS43130_XSP_DEN_2,
731 (clk_gen->den & CS43130_SP_M_MSB_DATA_MASK) >>
732 CS43130_SP_M_MSB_DATA_SHIFT);
733 regmap_write(cs43130->regmap, CS43130_XSP_NUM_1,
734 (clk_gen->num & CS43130_SP_N_LSB_DATA_MASK) >>
735 CS43130_SP_N_LSB_DATA_SHIFT);
736 regmap_write(cs43130->regmap, CS43130_XSP_NUM_2,
737 (clk_gen->num & CS43130_SP_N_MSB_DATA_MASK) >>
738 CS43130_SP_N_MSB_DATA_SHIFT);
739 break;
740 default:
741 return -EINVAL;
742 }
743
744 return 0;
745 }
746
747 static int cs43130_pcm_dsd_mix(bool en, struct regmap *regmap)
748 {
749 if (en) {
750 regmap_update_bits(regmap, CS43130_DSD_PCM_MIX_CTL,
751 CS43130_MIX_PCM_PREP_MASK,
752 1 << CS43130_MIX_PCM_PREP_SHIFT);
753 usleep_range(6000, 6050);
754 regmap_update_bits(regmap, CS43130_DSD_PCM_MIX_CTL,
755 CS43130_MIX_PCM_DSD_MASK,
756 1 << CS43130_MIX_PCM_DSD_SHIFT);
757 } else {
758 regmap_update_bits(regmap, CS43130_DSD_PCM_MIX_CTL,
759 CS43130_MIX_PCM_DSD_MASK,
760 0 << CS43130_MIX_PCM_DSD_SHIFT);
761 usleep_range(1600, 1650);
762 regmap_update_bits(regmap, CS43130_DSD_PCM_MIX_CTL,
763 CS43130_MIX_PCM_PREP_MASK,
764 0 << CS43130_MIX_PCM_PREP_SHIFT);
765 }
766
767 return 0;
768 }
769
770 static int cs43130_dsd_hw_params(struct snd_pcm_substream *substream,
771 struct snd_pcm_hw_params *params,
772 struct snd_soc_dai *dai)
773 {
774 struct snd_soc_component *component = dai->component;
775 struct cs43130_private *cs43130 = snd_soc_component_get_drvdata(component);
776 unsigned int required_clk;
777 u8 dsd_speed;
778
779 mutex_lock(&cs43130->clk_mutex);
780 if (!cs43130->clk_req) {
781 /* no DAI is currently using clk */
782 if (!(CS43130_MCLK_22M % params_rate(params)))
783 required_clk = CS43130_MCLK_22M;
784 else
785 required_clk = CS43130_MCLK_24M;
786
787 cs43130_set_pll(component, 0, 0, cs43130->mclk, required_clk);
788 if (cs43130->pll_bypass)
789 cs43130_change_clksrc(component, CS43130_MCLK_SRC_EXT);
790 else
791 cs43130_change_clksrc(component, CS43130_MCLK_SRC_PLL);
792 }
793
794 cs43130->clk_req++;
795 if (cs43130->clk_req == 2)
796 cs43130_pcm_dsd_mix(true, cs43130->regmap);
797 mutex_unlock(&cs43130->clk_mutex);
798
799 switch (params_rate(params)) {
800 case 176400:
801 dsd_speed = 0;
802 break;
803 case 352800:
804 dsd_speed = 1;
805 break;
806 default:
807 dev_err(component->dev, "Rate(%u) not supported\n",
808 params_rate(params));
809 return -EINVAL;
810 }
811
812 if (cs43130->dais[dai->id].dai_mode == SND_SOC_DAIFMT_CBM_CFM)
813 regmap_update_bits(cs43130->regmap, CS43130_DSD_INT_CFG,
814 CS43130_DSD_MASTER, CS43130_DSD_MASTER);
815 else
816 regmap_update_bits(cs43130->regmap, CS43130_DSD_INT_CFG,
817 CS43130_DSD_MASTER, 0);
818
819 regmap_update_bits(cs43130->regmap, CS43130_DSD_PATH_CTL_2,
820 CS43130_DSD_SPEED_MASK,
821 dsd_speed << CS43130_DSD_SPEED_SHIFT);
822 regmap_update_bits(cs43130->regmap, CS43130_DSD_PATH_CTL_2,
823 CS43130_DSD_SRC_MASK, CS43130_DSD_SRC_DSD <<
824 CS43130_DSD_SRC_SHIFT);
825
826 return 0;
827 }
828
829 static int cs43130_hw_params(struct snd_pcm_substream *substream,
830 struct snd_pcm_hw_params *params,
831 struct snd_soc_dai *dai)
832 {
833 struct snd_soc_component *component = dai->component;
834 struct cs43130_private *cs43130 = snd_soc_component_get_drvdata(component);
835 const struct cs43130_rate_map *rate_map;
836 unsigned int sclk = cs43130->dais[dai->id].sclk;
837 unsigned int bitwidth_sclk;
838 unsigned int bitwidth_dai = (unsigned int)(params_width(params));
839 unsigned int required_clk;
840 u8 dsd_speed;
841
842 mutex_lock(&cs43130->clk_mutex);
843 if (!cs43130->clk_req) {
844 /* no DAI is currently using clk */
845 if (!(CS43130_MCLK_22M % params_rate(params)))
846 required_clk = CS43130_MCLK_22M;
847 else
848 required_clk = CS43130_MCLK_24M;
849
850 cs43130_set_pll(component, 0, 0, cs43130->mclk, required_clk);
851 if (cs43130->pll_bypass)
852 cs43130_change_clksrc(component, CS43130_MCLK_SRC_EXT);
853 else
854 cs43130_change_clksrc(component, CS43130_MCLK_SRC_PLL);
855 }
856
857 cs43130->clk_req++;
858 if (cs43130->clk_req == 2)
859 cs43130_pcm_dsd_mix(true, cs43130->regmap);
860 mutex_unlock(&cs43130->clk_mutex);
861
862 switch (dai->id) {
863 case CS43130_ASP_DOP_DAI:
864 case CS43130_XSP_DOP_DAI:
865 /* DoP bitwidth is always 24-bit */
866 bitwidth_dai = 24;
867 sclk = params_rate(params) * bitwidth_dai *
868 params_channels(params);
869
870 switch (params_rate(params)) {
871 case 176400:
872 dsd_speed = 0;
873 break;
874 case 352800:
875 dsd_speed = 1;
876 break;
877 default:
878 dev_err(component->dev, "Rate(%u) not supported\n",
879 params_rate(params));
880 return -EINVAL;
881 }
882
883 regmap_update_bits(cs43130->regmap, CS43130_DSD_PATH_CTL_2,
884 CS43130_DSD_SPEED_MASK,
885 dsd_speed << CS43130_DSD_SPEED_SHIFT);
886 break;
887 case CS43130_ASP_PCM_DAI:
888 rate_map = cs43130_get_rate_table(params_rate(params));
889 if (!rate_map)
890 return -EINVAL;
891
892 regmap_write(cs43130->regmap, CS43130_SP_SRATE, rate_map->val);
893 break;
894 default:
895 dev_err(component->dev, "Invalid DAI (%d)\n", dai->id);
896 return -EINVAL;
897 }
898
899 switch (dai->id) {
900 case CS43130_ASP_DOP_DAI:
901 regmap_update_bits(cs43130->regmap, CS43130_DSD_PATH_CTL_2,
902 CS43130_DSD_SRC_MASK, CS43130_DSD_SRC_ASP <<
903 CS43130_DSD_SRC_SHIFT);
904 break;
905 case CS43130_XSP_DOP_DAI:
906 regmap_update_bits(cs43130->regmap, CS43130_DSD_PATH_CTL_2,
907 CS43130_DSD_SRC_MASK, CS43130_DSD_SRC_XSP <<
908 CS43130_DSD_SRC_SHIFT);
909 break;
910 }
911
912 if (!sclk && cs43130->dais[dai->id].dai_mode == SND_SOC_DAIFMT_CBM_CFM)
913 /* Calculate SCLK in master mode if unassigned */
914 sclk = params_rate(params) * bitwidth_dai *
915 params_channels(params);
916
917 if (!sclk) {
918 /* at this point, SCLK must be set */
919 dev_err(component->dev, "SCLK freq is not set\n");
920 return -EINVAL;
921 }
922
923 bitwidth_sclk = (sclk / params_rate(params)) / params_channels(params);
924 if (bitwidth_sclk < bitwidth_dai) {
925 dev_err(component->dev, "Format not supported: SCLK freq is too low\n");
926 return -EINVAL;
927 }
928
929 dev_dbg(component->dev,
930 "sclk = %u, fs = %d, bitwidth_dai = %u\n",
931 sclk, params_rate(params), bitwidth_dai);
932
933 dev_dbg(component->dev,
934 "bitwidth_sclk = %u, num_ch = %u\n",
935 bitwidth_sclk, params_channels(params));
936
937 cs43130_set_bitwidth(dai->id, bitwidth_dai, cs43130->regmap);
938 cs43130_set_sp_fmt(dai->id, bitwidth_sclk, params, cs43130);
939
940 return 0;
941 }
942
943 static int cs43130_hw_free(struct snd_pcm_substream *substream,
944 struct snd_soc_dai *dai)
945 {
946 struct snd_soc_component *component = dai->component;
947 struct cs43130_private *cs43130 = snd_soc_component_get_drvdata(component);
948
949 mutex_lock(&cs43130->clk_mutex);
950 cs43130->clk_req--;
951 if (!cs43130->clk_req) {
952 /* no DAI is currently using clk */
953 cs43130_change_clksrc(component, CS43130_MCLK_SRC_RCO);
954 cs43130_pcm_dsd_mix(false, cs43130->regmap);
955 }
956 mutex_unlock(&cs43130->clk_mutex);
957
958 return 0;
959 }
960
961 static const DECLARE_TLV_DB_SCALE(pcm_vol_tlv, -12750, 50, 1);
962
963 static const char * const pcm_ch_text[] = {
964 "Left-Right Ch",
965 "Left-Left Ch",
966 "Right-Left Ch",
967 "Right-Right Ch",
968 };
969
970 static const struct reg_sequence pcm_ch_en_seq[] = {
971 {CS43130_DXD1, 0x99},
972 {0x180005, 0x8C},
973 {0x180007, 0xAB},
974 {0x180015, 0x31},
975 {0x180017, 0xB2},
976 {0x180025, 0x30},
977 {0x180027, 0x84},
978 {0x180035, 0x9C},
979 {0x180037, 0xAE},
980 {0x18000D, 0x24},
981 {0x18000F, 0xA3},
982 {0x18001D, 0x05},
983 {0x18001F, 0xD4},
984 {0x18002D, 0x0B},
985 {0x18002F, 0xC7},
986 {0x18003D, 0x71},
987 {0x18003F, 0xE7},
988 {CS43130_DXD1, 0},
989 };
990
991 static const struct reg_sequence pcm_ch_dis_seq[] = {
992 {CS43130_DXD1, 0x99},
993 {0x180005, 0x24},
994 {0x180007, 0xA3},
995 {0x180015, 0x05},
996 {0x180017, 0xD4},
997 {0x180025, 0x0B},
998 {0x180027, 0xC7},
999 {0x180035, 0x71},
1000 {0x180037, 0xE7},
1001 {0x18000D, 0x8C},
1002 {0x18000F, 0xAB},
1003 {0x18001D, 0x31},
1004 {0x18001F, 0xB2},
1005 {0x18002D, 0x30},
1006 {0x18002F, 0x84},
1007 {0x18003D, 0x9C},
1008 {0x18003F, 0xAE},
1009 {CS43130_DXD1, 0},
1010 };
1011
1012 static int cs43130_pcm_ch_get(struct snd_kcontrol *kcontrol,
1013 struct snd_ctl_elem_value *ucontrol)
1014 {
1015 return snd_soc_get_enum_double(kcontrol, ucontrol);
1016 }
1017
1018 static int cs43130_pcm_ch_put(struct snd_kcontrol *kcontrol,
1019 struct snd_ctl_elem_value *ucontrol)
1020 {
1021 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
1022 unsigned int *item = ucontrol->value.enumerated.item;
1023 struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
1024 struct cs43130_private *cs43130 = snd_soc_component_get_drvdata(component);
1025 unsigned int val;
1026
1027 if (item[0] >= e->items)
1028 return -EINVAL;
1029 val = snd_soc_enum_item_to_val(e, item[0]) << e->shift_l;
1030
1031 switch (cs43130->dev_id) {
1032 case CS43131_CHIP_ID:
1033 case CS43198_CHIP_ID:
1034 if (val >= 2)
1035 regmap_multi_reg_write(cs43130->regmap, pcm_ch_en_seq,
1036 ARRAY_SIZE(pcm_ch_en_seq));
1037 else
1038 regmap_multi_reg_write(cs43130->regmap, pcm_ch_dis_seq,
1039 ARRAY_SIZE(pcm_ch_dis_seq));
1040 break;
1041 }
1042
1043 return snd_soc_put_enum_double(kcontrol, ucontrol);
1044 }
1045
1046 static SOC_ENUM_SINGLE_DECL(pcm_ch_enum, CS43130_PCM_PATH_CTL_2, 0,
1047 pcm_ch_text);
1048
1049 static const char * const pcm_spd_texts[] = {
1050 "Fast",
1051 "Slow",
1052 };
1053
1054 static SOC_ENUM_SINGLE_DECL(pcm_spd_enum, CS43130_PCM_FILT_OPT, 7,
1055 pcm_spd_texts);
1056
1057 static const char * const dsd_texts[] = {
1058 "Off",
1059 "BCKA Mode",
1060 "BCKD Mode",
1061 };
1062
1063 static const unsigned int dsd_values[] = {
1064 CS43130_DSD_SRC_DSD,
1065 CS43130_DSD_SRC_ASP,
1066 CS43130_DSD_SRC_XSP,
1067 };
1068
1069 static SOC_VALUE_ENUM_SINGLE_DECL(dsd_enum, CS43130_DSD_INT_CFG, 0, 0x03,
1070 dsd_texts, dsd_values);
1071
1072 static const struct snd_kcontrol_new cs43130_snd_controls[] = {
1073 SOC_DOUBLE_R_TLV("Master Playback Volume",
1074 CS43130_PCM_VOL_A, CS43130_PCM_VOL_B, 0, 0xFF, 1,
1075 pcm_vol_tlv),
1076 SOC_DOUBLE_R_TLV("Master DSD Playback Volume",
1077 CS43130_DSD_VOL_A, CS43130_DSD_VOL_B, 0, 0xFF, 1,
1078 pcm_vol_tlv),
1079 SOC_ENUM_EXT("PCM Ch Select", pcm_ch_enum, cs43130_pcm_ch_get,
1080 cs43130_pcm_ch_put),
1081 SOC_ENUM("PCM Filter Speed", pcm_spd_enum),
1082 SOC_SINGLE("PCM Phase Compensation", CS43130_PCM_FILT_OPT, 6, 1, 0),
1083 SOC_SINGLE("PCM Nonoversample Emulate", CS43130_PCM_FILT_OPT, 5, 1, 0),
1084 SOC_SINGLE("PCM High-pass Filter", CS43130_PCM_FILT_OPT, 1, 1, 0),
1085 SOC_SINGLE("PCM De-emphasis Filter", CS43130_PCM_FILT_OPT, 0, 1, 0),
1086 SOC_ENUM("DSD Phase Modulation", dsd_enum),
1087 };
1088
1089 static const struct reg_sequence pcm_seq[] = {
1090 {CS43130_DXD1, 0x99},
1091 {CS43130_DXD7, 0x01},
1092 {CS43130_DXD8, 0},
1093 {CS43130_DXD9, 0x01},
1094 {CS43130_DXD3, 0x12},
1095 {CS43130_DXD4, 0},
1096 {CS43130_DXD10, 0x28},
1097 {CS43130_DXD11, 0x28},
1098 {CS43130_DXD1, 0},
1099 };
1100
1101 static const struct reg_sequence dsd_seq[] = {
1102 {CS43130_DXD1, 0x99},
1103 {CS43130_DXD7, 0x01},
1104 {CS43130_DXD8, 0},
1105 {CS43130_DXD9, 0x01},
1106 {CS43130_DXD3, 0x12},
1107 {CS43130_DXD4, 0},
1108 {CS43130_DXD10, 0x1E},
1109 {CS43130_DXD11, 0x20},
1110 {CS43130_DXD1, 0},
1111 };
1112
1113 static const struct reg_sequence pop_free_seq[] = {
1114 {CS43130_DXD1, 0x99},
1115 {CS43130_DXD12, 0x0A},
1116 {CS43130_DXD1, 0},
1117 };
1118
1119 static const struct reg_sequence pop_free_seq2[] = {
1120 {CS43130_DXD1, 0x99},
1121 {CS43130_DXD13, 0x20},
1122 {CS43130_DXD1, 0},
1123 };
1124
1125 static const struct reg_sequence mute_seq[] = {
1126 {CS43130_DXD1, 0x99},
1127 {CS43130_DXD3, 0x12},
1128 {CS43130_DXD5, 0x02},
1129 {CS43130_DXD4, 0x12},
1130 {CS43130_DXD1, 0},
1131 };
1132
1133 static const struct reg_sequence unmute_seq[] = {
1134 {CS43130_DXD1, 0x99},
1135 {CS43130_DXD3, 0x10},
1136 {CS43130_DXD5, 0},
1137 {CS43130_DXD4, 0x16},
1138 {CS43130_DXD1, 0},
1139 };
1140
1141 static int cs43130_dsd_event(struct snd_soc_dapm_widget *w,
1142 struct snd_kcontrol *kcontrol, int event)
1143 {
1144 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
1145 struct cs43130_private *cs43130 = snd_soc_component_get_drvdata(component);
1146
1147 switch (event) {
1148 case SND_SOC_DAPM_PRE_PMU:
1149 switch (cs43130->dev_id) {
1150 case CS43130_CHIP_ID:
1151 case CS4399_CHIP_ID:
1152 regmap_multi_reg_write(cs43130->regmap, dsd_seq,
1153 ARRAY_SIZE(dsd_seq));
1154 break;
1155 }
1156 break;
1157 case SND_SOC_DAPM_POST_PMU:
1158 regmap_update_bits(cs43130->regmap, CS43130_DSD_PATH_CTL_1,
1159 CS43130_MUTE_MASK, 0);
1160 switch (cs43130->dev_id) {
1161 case CS43130_CHIP_ID:
1162 case CS4399_CHIP_ID:
1163 regmap_multi_reg_write(cs43130->regmap, unmute_seq,
1164 ARRAY_SIZE(unmute_seq));
1165 break;
1166 }
1167 break;
1168 case SND_SOC_DAPM_PRE_PMD:
1169 switch (cs43130->dev_id) {
1170 case CS43130_CHIP_ID:
1171 case CS4399_CHIP_ID:
1172 regmap_multi_reg_write(cs43130->regmap, mute_seq,
1173 ARRAY_SIZE(mute_seq));
1174 regmap_update_bits(cs43130->regmap,
1175 CS43130_DSD_PATH_CTL_1,
1176 CS43130_MUTE_MASK, CS43130_MUTE_EN);
1177 /*
1178 * DSD Power Down Sequence
1179 * According to Design, 130ms is preferred.
1180 */
1181 msleep(130);
1182 break;
1183 case CS43131_CHIP_ID:
1184 case CS43198_CHIP_ID:
1185 regmap_update_bits(cs43130->regmap,
1186 CS43130_DSD_PATH_CTL_1,
1187 CS43130_MUTE_MASK, CS43130_MUTE_EN);
1188 break;
1189 }
1190 break;
1191 default:
1192 dev_err(component->dev, "Invalid event = 0x%x\n", event);
1193 return -EINVAL;
1194 }
1195 return 0;
1196 }
1197
1198 static int cs43130_pcm_event(struct snd_soc_dapm_widget *w,
1199 struct snd_kcontrol *kcontrol, int event)
1200 {
1201 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
1202 struct cs43130_private *cs43130 = snd_soc_component_get_drvdata(component);
1203
1204 switch (event) {
1205 case SND_SOC_DAPM_PRE_PMU:
1206 switch (cs43130->dev_id) {
1207 case CS43130_CHIP_ID:
1208 case CS4399_CHIP_ID:
1209 regmap_multi_reg_write(cs43130->regmap, pcm_seq,
1210 ARRAY_SIZE(pcm_seq));
1211 break;
1212 }
1213 break;
1214 case SND_SOC_DAPM_POST_PMU:
1215 regmap_update_bits(cs43130->regmap, CS43130_PCM_PATH_CTL_1,
1216 CS43130_MUTE_MASK, 0);
1217 switch (cs43130->dev_id) {
1218 case CS43130_CHIP_ID:
1219 case CS4399_CHIP_ID:
1220 regmap_multi_reg_write(cs43130->regmap, unmute_seq,
1221 ARRAY_SIZE(unmute_seq));
1222 break;
1223 }
1224 break;
1225 case SND_SOC_DAPM_PRE_PMD:
1226 switch (cs43130->dev_id) {
1227 case CS43130_CHIP_ID:
1228 case CS4399_CHIP_ID:
1229 regmap_multi_reg_write(cs43130->regmap, mute_seq,
1230 ARRAY_SIZE(mute_seq));
1231 regmap_update_bits(cs43130->regmap,
1232 CS43130_PCM_PATH_CTL_1,
1233 CS43130_MUTE_MASK, CS43130_MUTE_EN);
1234 /*
1235 * PCM Power Down Sequence
1236 * According to Design, 130ms is preferred.
1237 */
1238 msleep(130);
1239 break;
1240 case CS43131_CHIP_ID:
1241 case CS43198_CHIP_ID:
1242 regmap_update_bits(cs43130->regmap,
1243 CS43130_PCM_PATH_CTL_1,
1244 CS43130_MUTE_MASK, CS43130_MUTE_EN);
1245 break;
1246 }
1247 break;
1248 default:
1249 dev_err(component->dev, "Invalid event = 0x%x\n", event);
1250 return -EINVAL;
1251 }
1252 return 0;
1253 }
1254
1255 static const struct reg_sequence dac_postpmu_seq[] = {
1256 {CS43130_DXD9, 0x0C},
1257 {CS43130_DXD3, 0x10},
1258 {CS43130_DXD4, 0x20},
1259 };
1260
1261 static const struct reg_sequence dac_postpmd_seq[] = {
1262 {CS43130_DXD1, 0x99},
1263 {CS43130_DXD6, 0x01},
1264 {CS43130_DXD1, 0},
1265 };
1266
1267 static int cs43130_dac_event(struct snd_soc_dapm_widget *w,
1268 struct snd_kcontrol *kcontrol, int event)
1269 {
1270 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
1271 struct cs43130_private *cs43130 = snd_soc_component_get_drvdata(component);
1272
1273 switch (event) {
1274 case SND_SOC_DAPM_PRE_PMU:
1275 switch (cs43130->dev_id) {
1276 case CS43130_CHIP_ID:
1277 case CS4399_CHIP_ID:
1278 regmap_multi_reg_write(cs43130->regmap, pop_free_seq,
1279 ARRAY_SIZE(pop_free_seq));
1280 break;
1281 case CS43131_CHIP_ID:
1282 case CS43198_CHIP_ID:
1283 regmap_multi_reg_write(cs43130->regmap, pop_free_seq2,
1284 ARRAY_SIZE(pop_free_seq2));
1285 break;
1286 }
1287 break;
1288 case SND_SOC_DAPM_POST_PMU:
1289 usleep_range(10000, 10050);
1290
1291 regmap_write(cs43130->regmap, CS43130_DXD1, 0x99);
1292
1293 switch (cs43130->dev_id) {
1294 case CS43130_CHIP_ID:
1295 case CS4399_CHIP_ID:
1296 regmap_multi_reg_write(cs43130->regmap, dac_postpmu_seq,
1297 ARRAY_SIZE(dac_postpmu_seq));
1298 /*
1299 * Per datasheet, Sec. PCM Power-Up Sequence.
1300 * According to Design, CS43130_DXD12 must be 0 to meet
1301 * THDN and Dynamic Range spec.
1302 */
1303 msleep(1000);
1304 regmap_write(cs43130->regmap, CS43130_DXD12, 0);
1305 break;
1306 case CS43131_CHIP_ID:
1307 case CS43198_CHIP_ID:
1308 usleep_range(12000, 12010);
1309 regmap_write(cs43130->regmap, CS43130_DXD13, 0);
1310 break;
1311 }
1312
1313 regmap_write(cs43130->regmap, CS43130_DXD1, 0);
1314 break;
1315 case SND_SOC_DAPM_POST_PMD:
1316 switch (cs43130->dev_id) {
1317 case CS43130_CHIP_ID:
1318 case CS4399_CHIP_ID:
1319 regmap_multi_reg_write(cs43130->regmap, dac_postpmd_seq,
1320 ARRAY_SIZE(dac_postpmd_seq));
1321 break;
1322 }
1323 break;
1324 default:
1325 dev_err(component->dev, "Invalid DAC event = 0x%x\n", event);
1326 return -EINVAL;
1327 }
1328 return 0;
1329 }
1330
1331 static const struct reg_sequence hpin_prepmd_seq[] = {
1332 {CS43130_DXD1, 0x99},
1333 {CS43130_DXD15, 0x64},
1334 {CS43130_DXD14, 0},
1335 {CS43130_DXD2, 0},
1336 {CS43130_DXD1, 0},
1337 };
1338
1339 static const struct reg_sequence hpin_postpmu_seq[] = {
1340 {CS43130_DXD1, 0x99},
1341 {CS43130_DXD2, 1},
1342 {CS43130_DXD14, 0xDC},
1343 {CS43130_DXD15, 0xE4},
1344 {CS43130_DXD1, 0},
1345 };
1346
1347 static int cs43130_hpin_event(struct snd_soc_dapm_widget *w,
1348 struct snd_kcontrol *kcontrol, int event)
1349 {
1350 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
1351 struct cs43130_private *cs43130 = snd_soc_component_get_drvdata(component);
1352
1353 switch (event) {
1354 case SND_SOC_DAPM_POST_PMD:
1355 regmap_multi_reg_write(cs43130->regmap, hpin_prepmd_seq,
1356 ARRAY_SIZE(hpin_prepmd_seq));
1357 break;
1358 case SND_SOC_DAPM_PRE_PMU:
1359 regmap_multi_reg_write(cs43130->regmap, hpin_postpmu_seq,
1360 ARRAY_SIZE(hpin_postpmu_seq));
1361 break;
1362 default:
1363 dev_err(component->dev, "Invalid HPIN event = 0x%x\n", event);
1364 return -EINVAL;
1365 }
1366 return 0;
1367 }
1368
1369 static const struct snd_soc_dapm_widget digital_hp_widgets[] = {
1370 SND_SOC_DAPM_OUTPUT("HPOUTA"),
1371 SND_SOC_DAPM_OUTPUT("HPOUTB"),
1372
1373 SND_SOC_DAPM_AIF_IN_E("ASPIN PCM", NULL, 0, CS43130_PWDN_CTL,
1374 CS43130_PDN_ASP_SHIFT, 1, cs43130_pcm_event,
1375 (SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU |
1376 SND_SOC_DAPM_PRE_PMD)),
1377
1378 SND_SOC_DAPM_AIF_IN_E("ASPIN DoP", NULL, 0, CS43130_PWDN_CTL,
1379 CS43130_PDN_ASP_SHIFT, 1, cs43130_dsd_event,
1380 (SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU |
1381 SND_SOC_DAPM_PRE_PMD)),
1382
1383 SND_SOC_DAPM_AIF_IN_E("XSPIN DoP", NULL, 0, CS43130_PWDN_CTL,
1384 CS43130_PDN_XSP_SHIFT, 1, cs43130_dsd_event,
1385 (SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU |
1386 SND_SOC_DAPM_PRE_PMD)),
1387
1388 SND_SOC_DAPM_AIF_IN_E("XSPIN DSD", NULL, 0, CS43130_PWDN_CTL,
1389 CS43130_PDN_DSDIF_SHIFT, 1, cs43130_dsd_event,
1390 (SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU |
1391 SND_SOC_DAPM_PRE_PMD)),
1392
1393 SND_SOC_DAPM_DAC("DSD", NULL, CS43130_DSD_PATH_CTL_2,
1394 CS43130_DSD_EN_SHIFT, 0),
1395
1396 SND_SOC_DAPM_DAC_E("HiFi DAC", NULL, CS43130_PWDN_CTL,
1397 CS43130_PDN_HP_SHIFT, 1, cs43130_dac_event,
1398 (SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU |
1399 SND_SOC_DAPM_POST_PMD)),
1400 };
1401
1402 static const struct snd_soc_dapm_widget analog_hp_widgets[] = {
1403 SND_SOC_DAPM_DAC_E("Analog Playback", NULL, CS43130_HP_OUT_CTL_1,
1404 CS43130_HP_IN_EN_SHIFT, 0, cs43130_hpin_event,
1405 (SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD)),
1406 };
1407
1408 static struct snd_soc_dapm_widget all_hp_widgets[
1409 ARRAY_SIZE(digital_hp_widgets) +
1410 ARRAY_SIZE(analog_hp_widgets)];
1411
1412 static const struct snd_soc_dapm_route digital_hp_routes[] = {
1413 {"ASPIN PCM", NULL, "ASP PCM Playback"},
1414 {"ASPIN DoP", NULL, "ASP DoP Playback"},
1415 {"XSPIN DoP", NULL, "XSP DoP Playback"},
1416 {"XSPIN DSD", NULL, "XSP DSD Playback"},
1417 {"DSD", NULL, "ASPIN DoP"},
1418 {"DSD", NULL, "XSPIN DoP"},
1419 {"DSD", NULL, "XSPIN DSD"},
1420 {"HiFi DAC", NULL, "ASPIN PCM"},
1421 {"HiFi DAC", NULL, "DSD"},
1422 {"HPOUTA", NULL, "HiFi DAC"},
1423 {"HPOUTB", NULL, "HiFi DAC"},
1424 };
1425
1426 static const struct snd_soc_dapm_route analog_hp_routes[] = {
1427 {"HPOUTA", NULL, "Analog Playback"},
1428 {"HPOUTB", NULL, "Analog Playback"},
1429 };
1430
1431 static struct snd_soc_dapm_route all_hp_routes[
1432 ARRAY_SIZE(digital_hp_routes) +
1433 ARRAY_SIZE(analog_hp_routes)];
1434
1435 static const unsigned int cs43130_asp_src_rates[] = {
1436 32000, 44100, 48000, 88200, 96000, 176400, 192000, 352800, 384000
1437 };
1438
1439 static const struct snd_pcm_hw_constraint_list cs43130_asp_constraints = {
1440 .count = ARRAY_SIZE(cs43130_asp_src_rates),
1441 .list = cs43130_asp_src_rates,
1442 };
1443
1444 static int cs43130_pcm_startup(struct snd_pcm_substream *substream,
1445 struct snd_soc_dai *dai)
1446 {
1447 return snd_pcm_hw_constraint_list(substream->runtime, 0,
1448 SNDRV_PCM_HW_PARAM_RATE,
1449 &cs43130_asp_constraints);
1450 }
1451
1452 static const unsigned int cs43130_dop_src_rates[] = {
1453 176400, 352800,
1454 };
1455
1456 static const struct snd_pcm_hw_constraint_list cs43130_dop_constraints = {
1457 .count = ARRAY_SIZE(cs43130_dop_src_rates),
1458 .list = cs43130_dop_src_rates,
1459 };
1460
1461 static int cs43130_dop_startup(struct snd_pcm_substream *substream,
1462 struct snd_soc_dai *dai)
1463 {
1464 return snd_pcm_hw_constraint_list(substream->runtime, 0,
1465 SNDRV_PCM_HW_PARAM_RATE,
1466 &cs43130_dop_constraints);
1467 }
1468
1469 static int cs43130_pcm_set_fmt(struct snd_soc_dai *codec_dai, unsigned int fmt)
1470 {
1471 struct snd_soc_component *component = codec_dai->component;
1472 struct cs43130_private *cs43130 = snd_soc_component_get_drvdata(component);
1473
1474 switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
1475 case SND_SOC_DAIFMT_CBS_CFS:
1476 cs43130->dais[codec_dai->id].dai_mode = SND_SOC_DAIFMT_CBS_CFS;
1477 break;
1478 case SND_SOC_DAIFMT_CBM_CFM:
1479 cs43130->dais[codec_dai->id].dai_mode = SND_SOC_DAIFMT_CBM_CFM;
1480 break;
1481 default:
1482 dev_err(component->dev, "unsupported mode\n");
1483 return -EINVAL;
1484 }
1485
1486 switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
1487 case SND_SOC_DAIFMT_I2S:
1488 cs43130->dais[codec_dai->id].dai_format = SND_SOC_DAIFMT_I2S;
1489 break;
1490 case SND_SOC_DAIFMT_LEFT_J:
1491 cs43130->dais[codec_dai->id].dai_format = SND_SOC_DAIFMT_LEFT_J;
1492 break;
1493 case SND_SOC_DAIFMT_DSP_A:
1494 cs43130->dais[codec_dai->id].dai_format = SND_SOC_DAIFMT_DSP_A;
1495 break;
1496 case SND_SOC_DAIFMT_DSP_B:
1497 cs43130->dais[codec_dai->id].dai_format = SND_SOC_DAIFMT_DSP_B;
1498 break;
1499 default:
1500 dev_err(component->dev,
1501 "unsupported audio format\n");
1502 return -EINVAL;
1503 }
1504
1505 dev_dbg(component->dev, "dai_id = %d, dai_mode = %u, dai_format = %u\n",
1506 codec_dai->id,
1507 cs43130->dais[codec_dai->id].dai_mode,
1508 cs43130->dais[codec_dai->id].dai_format);
1509
1510 return 0;
1511 }
1512
1513 static int cs43130_dsd_set_fmt(struct snd_soc_dai *codec_dai, unsigned int fmt)
1514 {
1515 struct snd_soc_component *component = codec_dai->component;
1516 struct cs43130_private *cs43130 = snd_soc_component_get_drvdata(component);
1517
1518 switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
1519 case SND_SOC_DAIFMT_CBS_CFS:
1520 cs43130->dais[codec_dai->id].dai_mode = SND_SOC_DAIFMT_CBS_CFS;
1521 break;
1522 case SND_SOC_DAIFMT_CBM_CFM:
1523 cs43130->dais[codec_dai->id].dai_mode = SND_SOC_DAIFMT_CBM_CFM;
1524 break;
1525 default:
1526 dev_err(component->dev, "Unsupported DAI format.\n");
1527 return -EINVAL;
1528 }
1529
1530 dev_dbg(component->dev, "dai_mode = 0x%x\n",
1531 cs43130->dais[codec_dai->id].dai_mode);
1532
1533 return 0;
1534 }
1535
1536 static int cs43130_set_sysclk(struct snd_soc_dai *codec_dai,
1537 int clk_id, unsigned int freq, int dir)
1538 {
1539 struct snd_soc_component *component = codec_dai->component;
1540 struct cs43130_private *cs43130 = snd_soc_component_get_drvdata(component);
1541
1542 cs43130->dais[codec_dai->id].sclk = freq;
1543 dev_dbg(component->dev, "dai_id = %d, sclk = %u\n", codec_dai->id,
1544 cs43130->dais[codec_dai->id].sclk);
1545
1546 return 0;
1547 }
1548
1549 static const struct snd_soc_dai_ops cs43130_pcm_ops = {
1550 .startup = cs43130_pcm_startup,
1551 .hw_params = cs43130_hw_params,
1552 .hw_free = cs43130_hw_free,
1553 .set_sysclk = cs43130_set_sysclk,
1554 .set_fmt = cs43130_pcm_set_fmt,
1555 };
1556
1557 static const struct snd_soc_dai_ops cs43130_dop_ops = {
1558 .startup = cs43130_dop_startup,
1559 .hw_params = cs43130_hw_params,
1560 .hw_free = cs43130_hw_free,
1561 .set_sysclk = cs43130_set_sysclk,
1562 .set_fmt = cs43130_pcm_set_fmt,
1563 };
1564
1565 static const struct snd_soc_dai_ops cs43130_dsd_ops = {
1566 .startup = cs43130_dop_startup,
1567 .hw_params = cs43130_dsd_hw_params,
1568 .hw_free = cs43130_hw_free,
1569 .set_fmt = cs43130_dsd_set_fmt,
1570 };
1571
1572 static struct snd_soc_dai_driver cs43130_dai[] = {
1573 {
1574 .name = "cs43130-asp-pcm",
1575 .id = CS43130_ASP_PCM_DAI,
1576 .playback = {
1577 .stream_name = "ASP PCM Playback",
1578 .channels_min = 1,
1579 .channels_max = 2,
1580 .rates = SNDRV_PCM_RATE_KNOT,
1581 .formats = CS43130_PCM_FORMATS,
1582 },
1583 .ops = &cs43130_pcm_ops,
1584 .symmetric_rates = 1,
1585 },
1586 {
1587 .name = "cs43130-asp-dop",
1588 .id = CS43130_ASP_DOP_DAI,
1589 .playback = {
1590 .stream_name = "ASP DoP Playback",
1591 .channels_min = 1,
1592 .channels_max = 2,
1593 .rates = SNDRV_PCM_RATE_KNOT,
1594 .formats = CS43130_DOP_FORMATS,
1595 },
1596 .ops = &cs43130_dop_ops,
1597 .symmetric_rates = 1,
1598 },
1599 {
1600 .name = "cs43130-xsp-dop",
1601 .id = CS43130_XSP_DOP_DAI,
1602 .playback = {
1603 .stream_name = "XSP DoP Playback",
1604 .channels_min = 1,
1605 .channels_max = 2,
1606 .rates = SNDRV_PCM_RATE_KNOT,
1607 .formats = CS43130_DOP_FORMATS,
1608 },
1609 .ops = &cs43130_dop_ops,
1610 .symmetric_rates = 1,
1611 },
1612 {
1613 .name = "cs43130-xsp-dsd",
1614 .id = CS43130_XSP_DSD_DAI,
1615 .playback = {
1616 .stream_name = "XSP DSD Playback",
1617 .channels_min = 1,
1618 .channels_max = 2,
1619 .rates = SNDRV_PCM_RATE_KNOT,
1620 .formats = CS43130_DOP_FORMATS,
1621 },
1622 .ops = &cs43130_dsd_ops,
1623 },
1624
1625 };
1626
1627 static int cs43130_component_set_sysclk(struct snd_soc_component *component,
1628 int clk_id, int source, unsigned int freq,
1629 int dir)
1630 {
1631 struct cs43130_private *cs43130 = snd_soc_component_get_drvdata(component);
1632
1633 dev_dbg(component->dev, "clk_id = %d, source = %d, freq = %d, dir = %d\n",
1634 clk_id, source, freq, dir);
1635
1636 switch (freq) {
1637 case CS43130_MCLK_22M:
1638 case CS43130_MCLK_24M:
1639 cs43130->mclk = freq;
1640 break;
1641 default:
1642 dev_err(component->dev, "Invalid MCLK INT freq: %u\n", freq);
1643 return -EINVAL;
1644 }
1645
1646 if (source == CS43130_MCLK_SRC_EXT) {
1647 cs43130->pll_bypass = true;
1648 } else {
1649 dev_err(component->dev, "Invalid MCLK source\n");
1650 return -EINVAL;
1651 }
1652
1653 return 0;
1654 }
1655
1656 static inline u16 cs43130_get_ac_reg_val(u16 ac_freq)
1657 {
1658 /* AC freq is counted in 5.94Hz step. */
1659 return ac_freq / 6;
1660 }
1661
1662 static int cs43130_show_dc(struct device *dev, char *buf, u8 ch)
1663 {
1664 struct i2c_client *client = to_i2c_client(dev);
1665 struct cs43130_private *cs43130 = i2c_get_clientdata(client);
1666
1667 if (!cs43130->hpload_done)
1668 return scnprintf(buf, PAGE_SIZE, "NO_HPLOAD\n");
1669 else
1670 return scnprintf(buf, PAGE_SIZE, "%u\n",
1671 cs43130->hpload_dc[ch]);
1672 }
1673
1674 static ssize_t cs43130_show_dc_l(struct device *dev,
1675 struct device_attribute *attr, char *buf)
1676 {
1677 return cs43130_show_dc(dev, buf, HP_LEFT);
1678 }
1679
1680 static ssize_t cs43130_show_dc_r(struct device *dev,
1681 struct device_attribute *attr, char *buf)
1682 {
1683 return cs43130_show_dc(dev, buf, HP_RIGHT);
1684 }
1685
1686 static u16 const cs43130_ac_freq[CS43130_AC_FREQ] = {
1687 24,
1688 43,
1689 93,
1690 200,
1691 431,
1692 928,
1693 2000,
1694 4309,
1695 9283,
1696 20000,
1697 };
1698
1699 static int cs43130_show_ac(struct device *dev, char *buf, u8 ch)
1700 {
1701 int i, j = 0, tmp;
1702 struct i2c_client *client = to_i2c_client(dev);
1703 struct cs43130_private *cs43130 = i2c_get_clientdata(client);
1704
1705 if (cs43130->hpload_done && cs43130->ac_meas) {
1706 for (i = 0; i < ARRAY_SIZE(cs43130_ac_freq); i++) {
1707 tmp = scnprintf(buf + j, PAGE_SIZE - j, "%u\n",
1708 cs43130->hpload_ac[i][ch]);
1709 if (!tmp)
1710 break;
1711
1712 j += tmp;
1713 }
1714
1715 return j;
1716 } else {
1717 return scnprintf(buf, PAGE_SIZE, "NO_HPLOAD\n");
1718 }
1719 }
1720
1721 static ssize_t cs43130_show_ac_l(struct device *dev,
1722 struct device_attribute *attr, char *buf)
1723 {
1724 return cs43130_show_ac(dev, buf, HP_LEFT);
1725 }
1726
1727 static ssize_t cs43130_show_ac_r(struct device *dev,
1728 struct device_attribute *attr, char *buf)
1729 {
1730 return cs43130_show_ac(dev, buf, HP_RIGHT);
1731 }
1732
1733 static DEVICE_ATTR(hpload_dc_l, 0444, cs43130_show_dc_l, NULL);
1734 static DEVICE_ATTR(hpload_dc_r, 0444, cs43130_show_dc_r, NULL);
1735 static DEVICE_ATTR(hpload_ac_l, 0444, cs43130_show_ac_l, NULL);
1736 static DEVICE_ATTR(hpload_ac_r, 0444, cs43130_show_ac_r, NULL);
1737
1738 static struct reg_sequence hp_en_cal_seq[] = {
1739 {CS43130_INT_MASK_4, CS43130_INT_MASK_ALL},
1740 {CS43130_HP_MEAS_LOAD_1, 0},
1741 {CS43130_HP_MEAS_LOAD_2, 0},
1742 {CS43130_INT_MASK_4, 0},
1743 {CS43130_DXD1, 0x99},
1744 {CS43130_DXD16, 0xBB},
1745 {CS43130_DXD12, 0x01},
1746 {CS43130_DXD19, 0xCB},
1747 {CS43130_DXD17, 0x95},
1748 {CS43130_DXD18, 0x0B},
1749 {CS43130_DXD1, 0},
1750 {CS43130_HP_LOAD_1, 0x80},
1751 };
1752
1753 static struct reg_sequence hp_en_cal_seq2[] = {
1754 {CS43130_INT_MASK_4, CS43130_INT_MASK_ALL},
1755 {CS43130_HP_MEAS_LOAD_1, 0},
1756 {CS43130_HP_MEAS_LOAD_2, 0},
1757 {CS43130_INT_MASK_4, 0},
1758 {CS43130_HP_LOAD_1, 0x80},
1759 };
1760
1761 static struct reg_sequence hp_dis_cal_seq[] = {
1762 {CS43130_HP_LOAD_1, 0x80},
1763 {CS43130_DXD1, 0x99},
1764 {CS43130_DXD12, 0},
1765 {CS43130_DXD1, 0},
1766 {CS43130_HP_LOAD_1, 0},
1767 };
1768
1769 static struct reg_sequence hp_dis_cal_seq2[] = {
1770 {CS43130_HP_LOAD_1, 0x80},
1771 {CS43130_HP_LOAD_1, 0},
1772 };
1773
1774 static struct reg_sequence hp_dc_ch_l_seq[] = {
1775 {CS43130_DXD1, 0x99},
1776 {CS43130_DXD19, 0x0A},
1777 {CS43130_DXD17, 0x93},
1778 {CS43130_DXD18, 0x0A},
1779 {CS43130_DXD1, 0},
1780 {CS43130_HP_LOAD_1, 0x80},
1781 {CS43130_HP_LOAD_1, 0x81},
1782 };
1783
1784 static struct reg_sequence hp_dc_ch_l_seq2[] = {
1785 {CS43130_HP_LOAD_1, 0x80},
1786 {CS43130_HP_LOAD_1, 0x81},
1787 };
1788
1789 static struct reg_sequence hp_dc_ch_r_seq[] = {
1790 {CS43130_DXD1, 0x99},
1791 {CS43130_DXD19, 0x8A},
1792 {CS43130_DXD17, 0x15},
1793 {CS43130_DXD18, 0x06},
1794 {CS43130_DXD1, 0},
1795 {CS43130_HP_LOAD_1, 0x90},
1796 {CS43130_HP_LOAD_1, 0x91},
1797 };
1798
1799 static struct reg_sequence hp_dc_ch_r_seq2[] = {
1800 {CS43130_HP_LOAD_1, 0x90},
1801 {CS43130_HP_LOAD_1, 0x91},
1802 };
1803
1804 static struct reg_sequence hp_ac_ch_l_seq[] = {
1805 {CS43130_DXD1, 0x99},
1806 {CS43130_DXD19, 0x0A},
1807 {CS43130_DXD17, 0x93},
1808 {CS43130_DXD18, 0x0A},
1809 {CS43130_DXD1, 0},
1810 {CS43130_HP_LOAD_1, 0x80},
1811 {CS43130_HP_LOAD_1, 0x82},
1812 };
1813
1814 static struct reg_sequence hp_ac_ch_l_seq2[] = {
1815 {CS43130_HP_LOAD_1, 0x80},
1816 {CS43130_HP_LOAD_1, 0x82},
1817 };
1818
1819 static struct reg_sequence hp_ac_ch_r_seq[] = {
1820 {CS43130_DXD1, 0x99},
1821 {CS43130_DXD19, 0x8A},
1822 {CS43130_DXD17, 0x15},
1823 {CS43130_DXD18, 0x06},
1824 {CS43130_DXD1, 0},
1825 {CS43130_HP_LOAD_1, 0x90},
1826 {CS43130_HP_LOAD_1, 0x92},
1827 };
1828
1829 static struct reg_sequence hp_ac_ch_r_seq2[] = {
1830 {CS43130_HP_LOAD_1, 0x90},
1831 {CS43130_HP_LOAD_1, 0x92},
1832 };
1833
1834 static struct reg_sequence hp_cln_seq[] = {
1835 {CS43130_INT_MASK_4, CS43130_INT_MASK_ALL},
1836 {CS43130_HP_MEAS_LOAD_1, 0},
1837 {CS43130_HP_MEAS_LOAD_2, 0},
1838 };
1839
1840 struct reg_sequences {
1841 struct reg_sequence *seq;
1842 int size;
1843 unsigned int msk;
1844 };
1845
1846 static struct reg_sequences hpload_seq1[] = {
1847 {
1848 .seq = hp_en_cal_seq,
1849 .size = ARRAY_SIZE(hp_en_cal_seq),
1850 .msk = CS43130_HPLOAD_ON_INT,
1851 },
1852 {
1853 .seq = hp_dc_ch_l_seq,
1854 .size = ARRAY_SIZE(hp_dc_ch_l_seq),
1855 .msk = CS43130_HPLOAD_DC_INT,
1856 },
1857 {
1858 .seq = hp_ac_ch_l_seq,
1859 .size = ARRAY_SIZE(hp_ac_ch_l_seq),
1860 .msk = CS43130_HPLOAD_AC_INT,
1861 },
1862 {
1863 .seq = hp_dis_cal_seq,
1864 .size = ARRAY_SIZE(hp_dis_cal_seq),
1865 .msk = CS43130_HPLOAD_OFF_INT,
1866 },
1867 {
1868 .seq = hp_en_cal_seq,
1869 .size = ARRAY_SIZE(hp_en_cal_seq),
1870 .msk = CS43130_HPLOAD_ON_INT,
1871 },
1872 {
1873 .seq = hp_dc_ch_r_seq,
1874 .size = ARRAY_SIZE(hp_dc_ch_r_seq),
1875 .msk = CS43130_HPLOAD_DC_INT,
1876 },
1877 {
1878 .seq = hp_ac_ch_r_seq,
1879 .size = ARRAY_SIZE(hp_ac_ch_r_seq),
1880 .msk = CS43130_HPLOAD_AC_INT,
1881 },
1882 };
1883
1884 static struct reg_sequences hpload_seq2[] = {
1885 {
1886 .seq = hp_en_cal_seq2,
1887 .size = ARRAY_SIZE(hp_en_cal_seq2),
1888 .msk = CS43130_HPLOAD_ON_INT,
1889 },
1890 {
1891 .seq = hp_dc_ch_l_seq2,
1892 .size = ARRAY_SIZE(hp_dc_ch_l_seq2),
1893 .msk = CS43130_HPLOAD_DC_INT,
1894 },
1895 {
1896 .seq = hp_ac_ch_l_seq2,
1897 .size = ARRAY_SIZE(hp_ac_ch_l_seq2),
1898 .msk = CS43130_HPLOAD_AC_INT,
1899 },
1900 {
1901 .seq = hp_dis_cal_seq2,
1902 .size = ARRAY_SIZE(hp_dis_cal_seq2),
1903 .msk = CS43130_HPLOAD_OFF_INT,
1904 },
1905 {
1906 .seq = hp_en_cal_seq2,
1907 .size = ARRAY_SIZE(hp_en_cal_seq2),
1908 .msk = CS43130_HPLOAD_ON_INT,
1909 },
1910 {
1911 .seq = hp_dc_ch_r_seq2,
1912 .size = ARRAY_SIZE(hp_dc_ch_r_seq2),
1913 .msk = CS43130_HPLOAD_DC_INT,
1914 },
1915 {
1916 .seq = hp_ac_ch_r_seq2,
1917 .size = ARRAY_SIZE(hp_ac_ch_r_seq2),
1918 .msk = CS43130_HPLOAD_AC_INT,
1919 },
1920 };
1921
1922 static int cs43130_update_hpload(unsigned int msk, int ac_idx,
1923 struct cs43130_private *cs43130)
1924 {
1925 bool left_ch = true;
1926 unsigned int reg;
1927 u32 addr;
1928 u16 impedance;
1929 struct snd_soc_component *component = cs43130->component;
1930
1931 switch (msk) {
1932 case CS43130_HPLOAD_DC_INT:
1933 case CS43130_HPLOAD_AC_INT:
1934 break;
1935 default:
1936 return 0;
1937 }
1938
1939 regmap_read(cs43130->regmap, CS43130_HP_LOAD_1, &reg);
1940 if (reg & CS43130_HPLOAD_CHN_SEL)
1941 left_ch = false;
1942
1943 if (msk == CS43130_HPLOAD_DC_INT)
1944 addr = CS43130_HP_DC_STAT_1;
1945 else
1946 addr = CS43130_HP_AC_STAT_1;
1947
1948 regmap_read(cs43130->regmap, addr, &reg);
1949 impedance = reg >> 3;
1950 regmap_read(cs43130->regmap, addr + 1, &reg);
1951 impedance |= reg << 5;
1952
1953 if (msk == CS43130_HPLOAD_DC_INT) {
1954 if (left_ch)
1955 cs43130->hpload_dc[HP_LEFT] = impedance;
1956 else
1957 cs43130->hpload_dc[HP_RIGHT] = impedance;
1958
1959 dev_dbg(component->dev, "HP DC impedance (Ch %u): %u\n", !left_ch,
1960 impedance);
1961 } else {
1962 if (left_ch)
1963 cs43130->hpload_ac[ac_idx][HP_LEFT] = impedance;
1964 else
1965 cs43130->hpload_ac[ac_idx][HP_RIGHT] = impedance;
1966
1967 dev_dbg(component->dev, "HP AC (%u Hz) impedance (Ch %u): %u\n",
1968 cs43130->ac_freq[ac_idx], !left_ch, impedance);
1969 }
1970
1971 return 0;
1972 }
1973
1974 static int cs43130_hpload_proc(struct cs43130_private *cs43130,
1975 struct reg_sequence *seq, int seq_size,
1976 unsigned int rslt_msk, int ac_idx)
1977 {
1978 int ret;
1979 unsigned int msk;
1980 u16 ac_reg_val;
1981 struct snd_soc_component *component = cs43130->component;
1982
1983 reinit_completion(&cs43130->hpload_evt);
1984
1985 if (rslt_msk == CS43130_HPLOAD_AC_INT) {
1986 ac_reg_val = cs43130_get_ac_reg_val(cs43130->ac_freq[ac_idx]);
1987 regmap_update_bits(cs43130->regmap, CS43130_HP_LOAD_1,
1988 CS43130_HPLOAD_AC_START, 0);
1989 regmap_update_bits(cs43130->regmap, CS43130_HP_MEAS_LOAD_1,
1990 CS43130_HP_MEAS_LOAD_MASK,
1991 ac_reg_val >> CS43130_HP_MEAS_LOAD_1_SHIFT);
1992 regmap_update_bits(cs43130->regmap, CS43130_HP_MEAS_LOAD_2,
1993 CS43130_HP_MEAS_LOAD_MASK,
1994 ac_reg_val >> CS43130_HP_MEAS_LOAD_2_SHIFT);
1995 }
1996
1997 regmap_multi_reg_write(cs43130->regmap, seq,
1998 seq_size);
1999
2000 ret = wait_for_completion_timeout(&cs43130->hpload_evt,
2001 msecs_to_jiffies(1000));
2002 regmap_read(cs43130->regmap, CS43130_INT_MASK_4, &msk);
2003 if (!ret) {
2004 dev_err(component->dev, "Timeout waiting for HPLOAD interrupt\n");
2005 return -1;
2006 }
2007
2008 dev_dbg(component->dev, "HP load stat: %x, INT_MASK_4: %x\n",
2009 cs43130->hpload_stat, msk);
2010 if ((cs43130->hpload_stat & (CS43130_HPLOAD_NO_DC_INT |
2011 CS43130_HPLOAD_UNPLUG_INT |
2012 CS43130_HPLOAD_OOR_INT)) ||
2013 !(cs43130->hpload_stat & rslt_msk)) {
2014 dev_dbg(component->dev, "HP load measure failed\n");
2015 return -1;
2016 }
2017
2018 return 0;
2019 }
2020
2021 static const struct reg_sequence hv_seq[][2] = {
2022 {
2023 {CS43130_CLASS_H_CTL, 0x1C},
2024 {CS43130_HP_OUT_CTL_1, 0x10},
2025 },
2026 {
2027 {CS43130_CLASS_H_CTL, 0x1E},
2028 {CS43130_HP_OUT_CTL_1, 0x20},
2029 },
2030 {
2031 {CS43130_CLASS_H_CTL, 0x1E},
2032 {CS43130_HP_OUT_CTL_1, 0x30},
2033 },
2034 };
2035
2036 static int cs43130_set_hv(struct regmap *regmap, u16 hpload_dc,
2037 const u16 *dc_threshold)
2038 {
2039 int i;
2040
2041 for (i = 0; i < CS43130_DC_THRESHOLD; i++) {
2042 if (hpload_dc <= dc_threshold[i])
2043 break;
2044 }
2045
2046 regmap_multi_reg_write(regmap, hv_seq[i], ARRAY_SIZE(hv_seq[i]));
2047
2048 return 0;
2049 }
2050
2051 static void cs43130_imp_meas(struct work_struct *wk)
2052 {
2053 unsigned int reg, seq_size;
2054 int i, ret, ac_idx;
2055 struct cs43130_private *cs43130;
2056 struct snd_soc_component *component;
2057 struct reg_sequences *hpload_seq;
2058
2059 cs43130 = container_of(wk, struct cs43130_private, work);
2060 component = cs43130->component;
2061
2062 if (!cs43130->mclk)
2063 return;
2064
2065 cs43130->hpload_done = false;
2066
2067 mutex_lock(&cs43130->clk_mutex);
2068 if (!cs43130->clk_req) {
2069 /* clk not in use */
2070 cs43130_set_pll(component, 0, 0, cs43130->mclk, CS43130_MCLK_22M);
2071 if (cs43130->pll_bypass)
2072 cs43130_change_clksrc(component, CS43130_MCLK_SRC_EXT);
2073 else
2074 cs43130_change_clksrc(component, CS43130_MCLK_SRC_PLL);
2075 }
2076
2077 cs43130->clk_req++;
2078 mutex_unlock(&cs43130->clk_mutex);
2079
2080 regmap_read(cs43130->regmap, CS43130_INT_STATUS_4, &reg);
2081
2082 switch (cs43130->dev_id) {
2083 case CS43130_CHIP_ID:
2084 hpload_seq = hpload_seq1;
2085 seq_size = ARRAY_SIZE(hpload_seq1);
2086 break;
2087 case CS43131_CHIP_ID:
2088 hpload_seq = hpload_seq2;
2089 seq_size = ARRAY_SIZE(hpload_seq2);
2090 break;
2091 default:
2092 WARN(1, "Invalid dev_id for meas: %d", cs43130->dev_id);
2093 return;
2094 }
2095
2096 i = 0;
2097 ac_idx = 0;
2098 while (i < seq_size) {
2099 ret = cs43130_hpload_proc(cs43130, hpload_seq[i].seq,
2100 hpload_seq[i].size,
2101 hpload_seq[i].msk, ac_idx);
2102 if (ret < 0)
2103 goto exit;
2104
2105 cs43130_update_hpload(hpload_seq[i].msk, ac_idx, cs43130);
2106
2107 if (cs43130->ac_meas &&
2108 hpload_seq[i].msk == CS43130_HPLOAD_AC_INT &&
2109 ac_idx < CS43130_AC_FREQ - 1) {
2110 ac_idx++;
2111 } else {
2112 ac_idx = 0;
2113 i++;
2114 }
2115 }
2116 cs43130->hpload_done = true;
2117
2118 if (cs43130->hpload_dc[HP_LEFT] >= CS43130_LINEOUT_LOAD)
2119 snd_soc_jack_report(&cs43130->jack, CS43130_JACK_LINEOUT,
2120 CS43130_JACK_MASK);
2121 else
2122 snd_soc_jack_report(&cs43130->jack, CS43130_JACK_HEADPHONE,
2123 CS43130_JACK_MASK);
2124
2125 dev_dbg(component->dev, "Set HP output control. DC threshold\n");
2126 for (i = 0; i < CS43130_DC_THRESHOLD; i++)
2127 dev_dbg(component->dev, "DC threshold[%d]: %u.\n", i,
2128 cs43130->dc_threshold[i]);
2129
2130 cs43130_set_hv(cs43130->regmap, cs43130->hpload_dc[HP_LEFT],
2131 cs43130->dc_threshold);
2132
2133 exit:
2134 switch (cs43130->dev_id) {
2135 case CS43130_CHIP_ID:
2136 cs43130_hpload_proc(cs43130, hp_dis_cal_seq,
2137 ARRAY_SIZE(hp_dis_cal_seq),
2138 CS43130_HPLOAD_OFF_INT, ac_idx);
2139 break;
2140 case CS43131_CHIP_ID:
2141 cs43130_hpload_proc(cs43130, hp_dis_cal_seq2,
2142 ARRAY_SIZE(hp_dis_cal_seq2),
2143 CS43130_HPLOAD_OFF_INT, ac_idx);
2144 break;
2145 }
2146
2147 regmap_multi_reg_write(cs43130->regmap, hp_cln_seq,
2148 ARRAY_SIZE(hp_cln_seq));
2149
2150 mutex_lock(&cs43130->clk_mutex);
2151 cs43130->clk_req--;
2152 /* clk not in use */
2153 if (!cs43130->clk_req)
2154 cs43130_change_clksrc(component, CS43130_MCLK_SRC_RCO);
2155 mutex_unlock(&cs43130->clk_mutex);
2156 }
2157
2158 static irqreturn_t cs43130_irq_thread(int irq, void *data)
2159 {
2160 struct cs43130_private *cs43130 = (struct cs43130_private *)data;
2161 struct snd_soc_component *component = cs43130->component;
2162 unsigned int stickies[CS43130_NUM_INT];
2163 unsigned int irq_occurrence = 0;
2164 unsigned int masks[CS43130_NUM_INT];
2165 int i, j;
2166
2167 for (i = 0; i < ARRAY_SIZE(stickies); i++) {
2168 regmap_read(cs43130->regmap, CS43130_INT_STATUS_1 + i,
2169 &stickies[i]);
2170 regmap_read(cs43130->regmap, CS43130_INT_MASK_1 + i,
2171 &masks[i]);
2172 }
2173
2174 for (i = 0; i < ARRAY_SIZE(stickies); i++) {
2175 stickies[i] = stickies[i] & (~masks[i]);
2176 for (j = 0; j < 8; j++)
2177 irq_occurrence += (stickies[i] >> j) & 1;
2178 }
2179 dev_dbg(component->dev, "number of interrupts occurred (%u)\n",
2180 irq_occurrence);
2181
2182 if (!irq_occurrence)
2183 return IRQ_NONE;
2184
2185 if (stickies[0] & CS43130_XTAL_RDY_INT) {
2186 complete(&cs43130->xtal_rdy);
2187 return IRQ_HANDLED;
2188 }
2189
2190 if (stickies[0] & CS43130_PLL_RDY_INT) {
2191 complete(&cs43130->pll_rdy);
2192 return IRQ_HANDLED;
2193 }
2194
2195 if (stickies[3] & CS43130_HPLOAD_NO_DC_INT) {
2196 cs43130->hpload_stat = stickies[3];
2197 dev_err(component->dev,
2198 "DC load has not completed before AC load (%x)\n",
2199 cs43130->hpload_stat);
2200 complete(&cs43130->hpload_evt);
2201 return IRQ_HANDLED;
2202 }
2203
2204 if (stickies[3] & CS43130_HPLOAD_UNPLUG_INT) {
2205 cs43130->hpload_stat = stickies[3];
2206 dev_err(component->dev, "HP unplugged during measurement (%x)\n",
2207 cs43130->hpload_stat);
2208 complete(&cs43130->hpload_evt);
2209 return IRQ_HANDLED;
2210 }
2211
2212 if (stickies[3] & CS43130_HPLOAD_OOR_INT) {
2213 cs43130->hpload_stat = stickies[3];
2214 dev_err(component->dev, "HP load out of range (%x)\n",
2215 cs43130->hpload_stat);
2216 complete(&cs43130->hpload_evt);
2217 return IRQ_HANDLED;
2218 }
2219
2220 if (stickies[3] & CS43130_HPLOAD_AC_INT) {
2221 cs43130->hpload_stat = stickies[3];
2222 dev_dbg(component->dev, "HP AC load measurement done (%x)\n",
2223 cs43130->hpload_stat);
2224 complete(&cs43130->hpload_evt);
2225 return IRQ_HANDLED;
2226 }
2227
2228 if (stickies[3] & CS43130_HPLOAD_DC_INT) {
2229 cs43130->hpload_stat = stickies[3];
2230 dev_dbg(component->dev, "HP DC load measurement done (%x)\n",
2231 cs43130->hpload_stat);
2232 complete(&cs43130->hpload_evt);
2233 return IRQ_HANDLED;
2234 }
2235
2236 if (stickies[3] & CS43130_HPLOAD_ON_INT) {
2237 cs43130->hpload_stat = stickies[3];
2238 dev_dbg(component->dev, "HP load state machine on done (%x)\n",
2239 cs43130->hpload_stat);
2240 complete(&cs43130->hpload_evt);
2241 return IRQ_HANDLED;
2242 }
2243
2244 if (stickies[3] & CS43130_HPLOAD_OFF_INT) {
2245 cs43130->hpload_stat = stickies[3];
2246 dev_dbg(component->dev, "HP load state machine off done (%x)\n",
2247 cs43130->hpload_stat);
2248 complete(&cs43130->hpload_evt);
2249 return IRQ_HANDLED;
2250 }
2251
2252 if (stickies[0] & CS43130_XTAL_ERR_INT) {
2253 dev_err(component->dev, "Crystal err: clock is not running\n");
2254 return IRQ_HANDLED;
2255 }
2256
2257 if (stickies[0] & CS43130_HP_UNPLUG_INT) {
2258 dev_dbg(component->dev, "HP unplugged\n");
2259 cs43130->hpload_done = false;
2260 snd_soc_jack_report(&cs43130->jack, 0, CS43130_JACK_MASK);
2261 return IRQ_HANDLED;
2262 }
2263
2264 if (stickies[0] & CS43130_HP_PLUG_INT) {
2265 if (cs43130->dc_meas && !cs43130->hpload_done &&
2266 !work_busy(&cs43130->work)) {
2267 dev_dbg(component->dev, "HP load queue work\n");
2268 queue_work(cs43130->wq, &cs43130->work);
2269 }
2270
2271 snd_soc_jack_report(&cs43130->jack, SND_JACK_MECHANICAL,
2272 CS43130_JACK_MASK);
2273 return IRQ_HANDLED;
2274 }
2275
2276 return IRQ_NONE;
2277 }
2278
2279 static int cs43130_probe(struct snd_soc_component *component)
2280 {
2281 int ret;
2282 struct cs43130_private *cs43130 = snd_soc_component_get_drvdata(component);
2283 struct snd_soc_card *card = component->card;
2284 unsigned int reg;
2285
2286 cs43130->component = component;
2287
2288 if (cs43130->xtal_ibias != CS43130_XTAL_UNUSED) {
2289 regmap_update_bits(cs43130->regmap, CS43130_CRYSTAL_SET,
2290 CS43130_XTAL_IBIAS_MASK,
2291 cs43130->xtal_ibias);
2292 regmap_update_bits(cs43130->regmap, CS43130_INT_MASK_1,
2293 CS43130_XTAL_ERR_INT, 0);
2294 }
2295
2296 ret = snd_soc_card_jack_new(card, "Headphone", CS43130_JACK_MASK,
2297 &cs43130->jack, NULL, 0);
2298 if (ret < 0) {
2299 dev_err(component->dev, "Cannot create jack\n");
2300 return ret;
2301 }
2302
2303 cs43130->hpload_done = false;
2304 if (cs43130->dc_meas) {
2305 ret = device_create_file(component->dev, &dev_attr_hpload_dc_l);
2306 if (ret < 0)
2307 return ret;
2308
2309 ret = device_create_file(component->dev, &dev_attr_hpload_dc_r);
2310 if (ret < 0)
2311 return ret;
2312
2313 ret = device_create_file(component->dev, &dev_attr_hpload_ac_l);
2314 if (ret < 0)
2315 return ret;
2316
2317 ret = device_create_file(component->dev, &dev_attr_hpload_ac_r);
2318 if (ret < 0)
2319 return ret;
2320
2321 cs43130->wq = create_singlethread_workqueue("cs43130_hp");
2322 if (!cs43130->wq)
2323 return -ENOMEM;
2324 INIT_WORK(&cs43130->work, cs43130_imp_meas);
2325 }
2326
2327 regmap_read(cs43130->regmap, CS43130_INT_STATUS_1, &reg);
2328 regmap_read(cs43130->regmap, CS43130_HP_STATUS, &reg);
2329 regmap_update_bits(cs43130->regmap, CS43130_INT_MASK_1,
2330 CS43130_HP_PLUG_INT | CS43130_HP_UNPLUG_INT, 0);
2331 regmap_update_bits(cs43130->regmap, CS43130_HP_DETECT,
2332 CS43130_HP_DETECT_CTRL_MASK, 0);
2333 regmap_update_bits(cs43130->regmap, CS43130_HP_DETECT,
2334 CS43130_HP_DETECT_CTRL_MASK,
2335 CS43130_HP_DETECT_CTRL_MASK);
2336
2337 return 0;
2338 }
2339
2340 static struct snd_soc_component_driver soc_component_dev_cs43130 = {
2341 .probe = cs43130_probe,
2342 .controls = cs43130_snd_controls,
2343 .num_controls = ARRAY_SIZE(cs43130_snd_controls),
2344 .set_sysclk = cs43130_component_set_sysclk,
2345 .set_pll = cs43130_set_pll,
2346 .idle_bias_on = 1,
2347 .use_pmdown_time = 1,
2348 .endianness = 1,
2349 .non_legacy_dai_naming = 1,
2350 };
2351
2352 static const struct regmap_config cs43130_regmap = {
2353 .reg_bits = 24,
2354 .pad_bits = 8,
2355 .val_bits = 8,
2356
2357 .max_register = CS43130_LASTREG,
2358 .reg_defaults = cs43130_reg_defaults,
2359 .num_reg_defaults = ARRAY_SIZE(cs43130_reg_defaults),
2360 .readable_reg = cs43130_readable_register,
2361 .precious_reg = cs43130_precious_register,
2362 .volatile_reg = cs43130_volatile_register,
2363 .cache_type = REGCACHE_RBTREE,
2364 /* needed for regcache_sync */
2365 .use_single_read = true,
2366 .use_single_write = true,
2367 };
2368
2369 static u16 const cs43130_dc_threshold[CS43130_DC_THRESHOLD] = {
2370 50,
2371 120,
2372 };
2373
2374 static int cs43130_handle_device_data(struct i2c_client *i2c_client,
2375 struct cs43130_private *cs43130)
2376 {
2377 struct device_node *np = i2c_client->dev.of_node;
2378 unsigned int val;
2379 int i;
2380
2381 if (of_property_read_u32(np, "cirrus,xtal-ibias", &val) < 0) {
2382 /* Crystal is unused. System clock is used for external MCLK */
2383 cs43130->xtal_ibias = CS43130_XTAL_UNUSED;
2384 return 0;
2385 }
2386
2387 switch (val) {
2388 case 1:
2389 cs43130->xtal_ibias = CS43130_XTAL_IBIAS_7_5UA;
2390 break;
2391 case 2:
2392 cs43130->xtal_ibias = CS43130_XTAL_IBIAS_12_5UA;
2393 break;
2394 case 3:
2395 cs43130->xtal_ibias = CS43130_XTAL_IBIAS_15UA;
2396 break;
2397 default:
2398 dev_err(&i2c_client->dev,
2399 "Invalid cirrus,xtal-ibias value: %d\n", val);
2400 return -EINVAL;
2401 }
2402
2403 cs43130->dc_meas = of_property_read_bool(np, "cirrus,dc-measure");
2404 cs43130->ac_meas = of_property_read_bool(np, "cirrus,ac-measure");
2405
2406 if (of_property_read_u16_array(np, "cirrus,ac-freq", cs43130->ac_freq,
2407 CS43130_AC_FREQ) < 0) {
2408 for (i = 0; i < CS43130_AC_FREQ; i++)
2409 cs43130->ac_freq[i] = cs43130_ac_freq[i];
2410 }
2411
2412 if (of_property_read_u16_array(np, "cirrus,dc-threshold",
2413 cs43130->dc_threshold,
2414 CS43130_DC_THRESHOLD) < 0) {
2415 for (i = 0; i < CS43130_DC_THRESHOLD; i++)
2416 cs43130->dc_threshold[i] = cs43130_dc_threshold[i];
2417 }
2418
2419 return 0;
2420 }
2421
2422 static int cs43130_i2c_probe(struct i2c_client *client,
2423 const struct i2c_device_id *id)
2424 {
2425 struct cs43130_private *cs43130;
2426 int ret;
2427 unsigned int devid = 0;
2428 unsigned int reg;
2429 int i;
2430
2431 cs43130 = devm_kzalloc(&client->dev, sizeof(*cs43130), GFP_KERNEL);
2432 if (!cs43130)
2433 return -ENOMEM;
2434
2435 i2c_set_clientdata(client, cs43130);
2436
2437 cs43130->regmap = devm_regmap_init_i2c(client, &cs43130_regmap);
2438 if (IS_ERR(cs43130->regmap)) {
2439 ret = PTR_ERR(cs43130->regmap);
2440 return ret;
2441 }
2442
2443 if (client->dev.of_node) {
2444 ret = cs43130_handle_device_data(client, cs43130);
2445 if (ret != 0)
2446 return ret;
2447 }
2448 for (i = 0; i < ARRAY_SIZE(cs43130->supplies); i++)
2449 cs43130->supplies[i].supply = cs43130_supply_names[i];
2450
2451 ret = devm_regulator_bulk_get(&client->dev,
2452 ARRAY_SIZE(cs43130->supplies),
2453 cs43130->supplies);
2454 if (ret != 0) {
2455 dev_err(&client->dev, "Failed to request supplies: %d\n", ret);
2456 return ret;
2457 }
2458 ret = regulator_bulk_enable(ARRAY_SIZE(cs43130->supplies),
2459 cs43130->supplies);
2460 if (ret != 0) {
2461 dev_err(&client->dev, "Failed to enable supplies: %d\n", ret);
2462 return ret;
2463 }
2464
2465 cs43130->reset_gpio = devm_gpiod_get_optional(&client->dev,
2466 "reset", GPIOD_OUT_LOW);
2467 if (IS_ERR(cs43130->reset_gpio))
2468 return PTR_ERR(cs43130->reset_gpio);
2469
2470 gpiod_set_value_cansleep(cs43130->reset_gpio, 1);
2471
2472 usleep_range(2000, 2050);
2473
2474 ret = regmap_read(cs43130->regmap, CS43130_DEVID_AB, &reg);
2475
2476 devid = (reg & 0xFF) << 12;
2477 ret = regmap_read(cs43130->regmap, CS43130_DEVID_CD, &reg);
2478 devid |= (reg & 0xFF) << 4;
2479 ret = regmap_read(cs43130->regmap, CS43130_DEVID_E, &reg);
2480 devid |= (reg & 0xF0) >> 4;
2481
2482 switch (devid) {
2483 case CS43130_CHIP_ID:
2484 case CS4399_CHIP_ID:
2485 case CS43131_CHIP_ID:
2486 case CS43198_CHIP_ID:
2487 break;
2488 default:
2489 dev_err(&client->dev,
2490 "CS43130 Device ID %X. Expected ID %X, %X, %X or %X\n",
2491 devid, CS43130_CHIP_ID, CS4399_CHIP_ID,
2492 CS43131_CHIP_ID, CS43198_CHIP_ID);
2493 ret = -ENODEV;
2494 goto err;
2495 }
2496
2497 cs43130->dev_id = devid;
2498 ret = regmap_read(cs43130->regmap, CS43130_REV_ID, &reg);
2499 if (ret < 0) {
2500 dev_err(&client->dev, "Get Revision ID failed\n");
2501 goto err;
2502 }
2503
2504 dev_info(&client->dev,
2505 "Cirrus Logic CS43130 (%x), Revision: %02X\n", devid,
2506 reg & 0xFF);
2507
2508 mutex_init(&cs43130->clk_mutex);
2509
2510 init_completion(&cs43130->xtal_rdy);
2511 init_completion(&cs43130->pll_rdy);
2512 init_completion(&cs43130->hpload_evt);
2513
2514 ret = devm_request_threaded_irq(&client->dev, client->irq,
2515 NULL, cs43130_irq_thread,
2516 IRQF_ONESHOT | IRQF_TRIGGER_LOW,
2517 "cs43130", cs43130);
2518 if (ret != 0) {
2519 dev_err(&client->dev, "Failed to request IRQ: %d\n", ret);
2520 return ret;
2521 }
2522
2523 cs43130->mclk_int_src = CS43130_MCLK_SRC_RCO;
2524
2525 pm_runtime_set_autosuspend_delay(&client->dev, 100);
2526 pm_runtime_use_autosuspend(&client->dev);
2527 pm_runtime_set_active(&client->dev);
2528 pm_runtime_enable(&client->dev);
2529
2530 switch (cs43130->dev_id) {
2531 case CS43130_CHIP_ID:
2532 case CS43131_CHIP_ID:
2533 memcpy(all_hp_widgets, digital_hp_widgets,
2534 sizeof(digital_hp_widgets));
2535 memcpy(all_hp_widgets + ARRAY_SIZE(digital_hp_widgets),
2536 analog_hp_widgets, sizeof(analog_hp_widgets));
2537 memcpy(all_hp_routes, digital_hp_routes,
2538 sizeof(digital_hp_routes));
2539 memcpy(all_hp_routes + ARRAY_SIZE(digital_hp_routes),
2540 analog_hp_routes, sizeof(analog_hp_routes));
2541
2542 soc_component_dev_cs43130.dapm_widgets =
2543 all_hp_widgets;
2544 soc_component_dev_cs43130.num_dapm_widgets =
2545 ARRAY_SIZE(all_hp_widgets);
2546 soc_component_dev_cs43130.dapm_routes =
2547 all_hp_routes;
2548 soc_component_dev_cs43130.num_dapm_routes =
2549 ARRAY_SIZE(all_hp_routes);
2550 break;
2551 case CS43198_CHIP_ID:
2552 case CS4399_CHIP_ID:
2553 soc_component_dev_cs43130.dapm_widgets =
2554 digital_hp_widgets;
2555 soc_component_dev_cs43130.num_dapm_widgets =
2556 ARRAY_SIZE(digital_hp_widgets);
2557 soc_component_dev_cs43130.dapm_routes =
2558 digital_hp_routes;
2559 soc_component_dev_cs43130.num_dapm_routes =
2560 ARRAY_SIZE(digital_hp_routes);
2561 break;
2562 }
2563
2564 ret = devm_snd_soc_register_component(&client->dev,
2565 &soc_component_dev_cs43130,
2566 cs43130_dai, ARRAY_SIZE(cs43130_dai));
2567 if (ret < 0) {
2568 dev_err(&client->dev,
2569 "snd_soc_register_component failed with ret = %d\n", ret);
2570 goto err;
2571 }
2572
2573 regmap_update_bits(cs43130->regmap, CS43130_PAD_INT_CFG,
2574 CS43130_ASP_3ST_MASK, 0);
2575 regmap_update_bits(cs43130->regmap, CS43130_PAD_INT_CFG,
2576 CS43130_XSP_3ST_MASK, 0);
2577
2578 return 0;
2579 err:
2580 return ret;
2581 }
2582
2583 static int cs43130_i2c_remove(struct i2c_client *client)
2584 {
2585 struct cs43130_private *cs43130 = i2c_get_clientdata(client);
2586
2587 if (cs43130->xtal_ibias != CS43130_XTAL_UNUSED)
2588 regmap_update_bits(cs43130->regmap, CS43130_INT_MASK_1,
2589 CS43130_XTAL_ERR_INT,
2590 1 << CS43130_XTAL_ERR_INT_SHIFT);
2591
2592 regmap_update_bits(cs43130->regmap, CS43130_INT_MASK_1,
2593 CS43130_HP_PLUG_INT | CS43130_HP_UNPLUG_INT,
2594 CS43130_HP_PLUG_INT | CS43130_HP_UNPLUG_INT);
2595
2596 if (cs43130->dc_meas) {
2597 cancel_work_sync(&cs43130->work);
2598 flush_workqueue(cs43130->wq);
2599
2600 device_remove_file(&client->dev, &dev_attr_hpload_dc_l);
2601 device_remove_file(&client->dev, &dev_attr_hpload_dc_r);
2602 device_remove_file(&client->dev, &dev_attr_hpload_ac_l);
2603 device_remove_file(&client->dev, &dev_attr_hpload_ac_r);
2604 }
2605
2606 gpiod_set_value_cansleep(cs43130->reset_gpio, 0);
2607
2608 pm_runtime_disable(&client->dev);
2609 regulator_bulk_disable(CS43130_NUM_SUPPLIES, cs43130->supplies);
2610
2611 return 0;
2612 }
2613
2614 static int __maybe_unused cs43130_runtime_suspend(struct device *dev)
2615 {
2616 struct cs43130_private *cs43130 = dev_get_drvdata(dev);
2617
2618 if (cs43130->xtal_ibias != CS43130_XTAL_UNUSED)
2619 regmap_update_bits(cs43130->regmap, CS43130_INT_MASK_1,
2620 CS43130_XTAL_ERR_INT,
2621 1 << CS43130_XTAL_ERR_INT_SHIFT);
2622
2623 regcache_cache_only(cs43130->regmap, true);
2624 regcache_mark_dirty(cs43130->regmap);
2625
2626 gpiod_set_value_cansleep(cs43130->reset_gpio, 0);
2627
2628 regulator_bulk_disable(CS43130_NUM_SUPPLIES, cs43130->supplies);
2629
2630 return 0;
2631 }
2632
2633 static int __maybe_unused cs43130_runtime_resume(struct device *dev)
2634 {
2635 struct cs43130_private *cs43130 = dev_get_drvdata(dev);
2636 int ret;
2637
2638 ret = regulator_bulk_enable(CS43130_NUM_SUPPLIES, cs43130->supplies);
2639 if (ret != 0) {
2640 dev_err(dev, "Failed to enable supplies: %d\n", ret);
2641 return ret;
2642 }
2643
2644 regcache_cache_only(cs43130->regmap, false);
2645
2646 gpiod_set_value_cansleep(cs43130->reset_gpio, 1);
2647
2648 usleep_range(2000, 2050);
2649
2650 ret = regcache_sync(cs43130->regmap);
2651 if (ret != 0) {
2652 dev_err(dev, "Failed to restore register cache\n");
2653 goto err;
2654 }
2655
2656 if (cs43130->xtal_ibias != CS43130_XTAL_UNUSED)
2657 regmap_update_bits(cs43130->regmap, CS43130_INT_MASK_1,
2658 CS43130_XTAL_ERR_INT, 0);
2659
2660 return 0;
2661 err:
2662 regcache_cache_only(cs43130->regmap, true);
2663 regulator_bulk_disable(CS43130_NUM_SUPPLIES, cs43130->supplies);
2664
2665 return ret;
2666 }
2667
2668 static const struct dev_pm_ops cs43130_runtime_pm = {
2669 SET_RUNTIME_PM_OPS(cs43130_runtime_suspend, cs43130_runtime_resume,
2670 NULL)
2671 };
2672
2673 static const struct of_device_id cs43130_of_match[] = {
2674 {.compatible = "cirrus,cs43130",},
2675 {.compatible = "cirrus,cs4399",},
2676 {.compatible = "cirrus,cs43131",},
2677 {.compatible = "cirrus,cs43198",},
2678 {},
2679 };
2680
2681 MODULE_DEVICE_TABLE(of, cs43130_of_match);
2682
2683 static const struct i2c_device_id cs43130_i2c_id[] = {
2684 {"cs43130", 0},
2685 {"cs4399", 0},
2686 {"cs43131", 0},
2687 {"cs43198", 0},
2688 {}
2689 };
2690
2691 MODULE_DEVICE_TABLE(i2c, cs43130_i2c_id);
2692
2693 static struct i2c_driver cs43130_i2c_driver = {
2694 .driver = {
2695 .name = "cs43130",
2696 .of_match_table = cs43130_of_match,
2697 .pm = &cs43130_runtime_pm,
2698 },
2699 .id_table = cs43130_i2c_id,
2700 .probe = cs43130_i2c_probe,
2701 .remove = cs43130_i2c_remove,
2702 };
2703
2704 module_i2c_driver(cs43130_i2c_driver);
2705
2706 MODULE_AUTHOR("Li Xu <li.xu@cirrus.com>");
2707 MODULE_DESCRIPTION("Cirrus Logic CS43130 ALSA SoC Codec Driver");
2708 MODULE_LICENSE("GPL");
Linux with added FPC-III support