1 // SPDX-License-Identifier: GPL-2.0
2 //
3 // CS42L43 CODEC driver jack handling
4 //
5 // Copyright (C) 2022-2023 Cirrus Logic, Inc. and
6 // Cirrus Logic International Semiconductor Ltd.
7
8 #include <linux/build_bug.h>
9 #include <linux/completion.h>
10 #include <linux/delay.h>
11 #include <linux/errno.h>
12 #include <linux/irq.h>
13 #include <linux/jiffies.h>
14 #include <linux/mfd/cs42l43.h>
15 #include <linux/mfd/cs42l43-regs.h>
16 #include <linux/mutex.h>
17 #include <linux/pm_runtime.h>
18 #include <linux/property.h>
19 #include <linux/regmap.h>
20 #include <linux/time.h>
21 #include <linux/workqueue.h>
22 #include <sound/control.h>
23 #include <sound/jack.h>
24 #include <sound/pcm.h>
25 #include <sound/pcm_params.h>
26 #include <sound/soc-component.h>
27 #include <sound/soc-jack.h>
28 #include <sound/soc.h>
29
30 #include "cs42l43.h"
31
32 static const unsigned int cs42l43_accdet_us[] = {
33 20, 100, 1000, 10000, 50000, 75000, 100000, 200000,
34 };
35
36 static const unsigned int cs42l43_accdet_db_ms[] = {
37 0, 125, 250, 500, 750, 1000, 1250, 1500,
38 };
39
40 static const unsigned int cs42l43_accdet_ramp_ms[] = { 10, 40, 90, 170 };
41
42 static const unsigned int cs42l43_accdet_bias_sense[] = {
43 14, 24, 43, 52, 61, 71, 90, 99, 0,
44 };
45
cs42l43_find_index(struct cs42l43_codec * priv,const char * const prop,unsigned int defval,unsigned int * val,const unsigned int * values,const int nvalues)46 static int cs42l43_find_index(struct cs42l43_codec *priv, const char * const prop,
47 unsigned int defval, unsigned int *val,
48 const unsigned int *values, const int nvalues)
49 {
50 struct cs42l43 *cs42l43 = priv->core;
51 int i, ret;
52
53 ret = device_property_read_u32(cs42l43->dev, prop, &defval);
54 if (ret != -EINVAL && ret < 0) {
55 dev_err(priv->dev, "Property %s malformed: %d\n", prop, ret);
56 return ret;
57 }
58
59 if (val)
60 *val = defval;
61
62 for (i = 0; i < nvalues; i++)
63 if (defval == values[i])
64 return i;
65
66 dev_err(priv->dev, "Invalid value for property %s: %d\n", prop, defval);
67 return -EINVAL;
68 }
69
cs42l43_set_jack(struct snd_soc_component * component,struct snd_soc_jack * jack,void * d)70 int cs42l43_set_jack(struct snd_soc_component *component,
71 struct snd_soc_jack *jack, void *d)
72 {
73 struct cs42l43_codec *priv = snd_soc_component_get_drvdata(component);
74 struct cs42l43 *cs42l43 = priv->core;
75 /* This tip sense invert is always set, HW wants an inverted signal */
76 unsigned int tip_deb = CS42L43_TIPSENSE_INV_MASK;
77 unsigned int hs2 = 0x2 << CS42L43_HSDET_MODE_SHIFT;
78 unsigned int autocontrol = 0, pdncntl = 0;
79 int ret;
80
81 dev_dbg(priv->dev, "Configure accessory detect\n");
82
83 ret = pm_runtime_resume_and_get(priv->dev);
84 if (ret) {
85 dev_err(priv->dev, "Failed to resume for jack config: %d\n", ret);
86 return ret;
87 }
88
89 mutex_lock(&priv->jack_lock);
90
91 priv->jack_hp = jack;
92
93 if (!jack)
94 goto done;
95
96 ret = device_property_count_u32(cs42l43->dev, "cirrus,buttons-ohms");
97 if (ret != -EINVAL) {
98 if (ret < 0) {
99 dev_err(priv->dev, "Property cirrus,buttons-ohms malformed: %d\n",
100 ret);
101 goto error;
102 }
103
104 if (ret > CS42L43_N_BUTTONS) {
105 ret = -EINVAL;
106 dev_err(priv->dev, "Property cirrus,buttons-ohms too many entries\n");
107 goto error;
108 }
109
110 ret = device_property_read_u32_array(cs42l43->dev, "cirrus,buttons-ohms",
111 priv->buttons, ret);
112 if (ret < 0) {
113 dev_err(priv->dev, "Property cirrus,button-ohms malformed: %d\n",
114 ret);
115 goto error;
116 }
117 } else {
118 priv->buttons[0] = 70;
119 priv->buttons[1] = 185;
120 priv->buttons[2] = 355;
121 priv->buttons[3] = 735;
122 }
123
124 ret = cs42l43_find_index(priv, "cirrus,detect-us", 50000, &priv->detect_us,
125 cs42l43_accdet_us, ARRAY_SIZE(cs42l43_accdet_us));
126 if (ret < 0)
127 goto error;
128
129 hs2 |= ret << CS42L43_AUTO_HSDET_TIME_SHIFT;
130
131 priv->bias_low = device_property_read_bool(cs42l43->dev, "cirrus,bias-low");
132
133 ret = cs42l43_find_index(priv, "cirrus,bias-ramp-ms", 170,
134 &priv->bias_ramp_ms, cs42l43_accdet_ramp_ms,
135 ARRAY_SIZE(cs42l43_accdet_ramp_ms));
136 if (ret < 0)
137 goto error;
138
139 hs2 |= ret << CS42L43_HSBIAS_RAMP_SHIFT;
140
141 ret = cs42l43_find_index(priv, "cirrus,bias-sense-microamp", 14,
142 &priv->bias_sense_ua, cs42l43_accdet_bias_sense,
143 ARRAY_SIZE(cs42l43_accdet_bias_sense));
144 if (ret < 0)
145 goto error;
146
147 if (priv->bias_sense_ua)
148 autocontrol |= ret << CS42L43_HSBIAS_SENSE_TRIP_SHIFT;
149
150 if (!device_property_read_bool(cs42l43->dev, "cirrus,button-automute"))
151 autocontrol |= CS42L43_S0_AUTO_ADCMUTE_DISABLE_MASK;
152
153 ret = device_property_read_u32(cs42l43->dev, "cirrus,tip-debounce-ms",
154 &priv->tip_debounce_ms);
155 if (ret < 0 && ret != -EINVAL) {
156 dev_err(priv->dev, "Property cirrus,tip-debounce-ms malformed: %d\n", ret);
157 goto error;
158 }
159
160 /* This tip sense invert is set normally, as TIPSENSE_INV already inverted */
161 if (device_property_read_bool(cs42l43->dev, "cirrus,tip-invert"))
162 autocontrol |= 0x1 << CS42L43_JACKDET_INV_SHIFT;
163
164 if (device_property_read_bool(cs42l43->dev, "cirrus,tip-disable-pullup"))
165 autocontrol |= 0x1 << CS42L43_JACKDET_MODE_SHIFT;
166 else
167 autocontrol |= 0x3 << CS42L43_JACKDET_MODE_SHIFT;
168
169 ret = cs42l43_find_index(priv, "cirrus,tip-fall-db-ms", 500,
170 &priv->tip_fall_db_ms, cs42l43_accdet_db_ms,
171 ARRAY_SIZE(cs42l43_accdet_db_ms));
172 if (ret < 0)
173 goto error;
174
175 tip_deb |= ret << CS42L43_TIPSENSE_FALLING_DB_TIME_SHIFT;
176
177 ret = cs42l43_find_index(priv, "cirrus,tip-rise-db-ms", 500,
178 &priv->tip_rise_db_ms, cs42l43_accdet_db_ms,
179 ARRAY_SIZE(cs42l43_accdet_db_ms));
180 if (ret < 0)
181 goto error;
182
183 tip_deb |= ret << CS42L43_TIPSENSE_RISING_DB_TIME_SHIFT;
184
185 if (device_property_read_bool(cs42l43->dev, "cirrus,use-ring-sense")) {
186 unsigned int ring_deb = 0;
187
188 priv->use_ring_sense = true;
189
190 /* HW wants an inverted signal, so invert the invert */
191 if (!device_property_read_bool(cs42l43->dev, "cirrus,ring-invert"))
192 ring_deb |= CS42L43_RINGSENSE_INV_MASK;
193
194 if (!device_property_read_bool(cs42l43->dev,
195 "cirrus,ring-disable-pullup"))
196 ring_deb |= CS42L43_RINGSENSE_PULLUP_PDNB_MASK;
197
198 ret = cs42l43_find_index(priv, "cirrus,ring-fall-db-ms", 500,
199 NULL, cs42l43_accdet_db_ms,
200 ARRAY_SIZE(cs42l43_accdet_db_ms));
201 if (ret < 0)
202 goto error;
203
204 ring_deb |= ret << CS42L43_RINGSENSE_FALLING_DB_TIME_SHIFT;
205
206 ret = cs42l43_find_index(priv, "cirrus,ring-rise-db-ms", 500,
207 NULL, cs42l43_accdet_db_ms,
208 ARRAY_SIZE(cs42l43_accdet_db_ms));
209 if (ret < 0)
210 goto error;
211
212 ring_deb |= ret << CS42L43_RINGSENSE_RISING_DB_TIME_SHIFT;
213 pdncntl |= CS42L43_RING_SENSE_EN_MASK;
214
215 regmap_update_bits(cs42l43->regmap, CS42L43_RINGSENSE_DEB_CTRL,
216 CS42L43_RINGSENSE_INV_MASK |
217 CS42L43_RINGSENSE_PULLUP_PDNB_MASK |
218 CS42L43_RINGSENSE_FALLING_DB_TIME_MASK |
219 CS42L43_RINGSENSE_RISING_DB_TIME_MASK,
220 ring_deb);
221 }
222
223 regmap_update_bits(cs42l43->regmap, CS42L43_TIPSENSE_DEB_CTRL,
224 CS42L43_TIPSENSE_INV_MASK |
225 CS42L43_TIPSENSE_FALLING_DB_TIME_MASK |
226 CS42L43_TIPSENSE_RISING_DB_TIME_MASK, tip_deb);
227 regmap_update_bits(cs42l43->regmap, CS42L43_HS2,
228 CS42L43_HSBIAS_RAMP_MASK | CS42L43_HSDET_MODE_MASK |
229 CS42L43_AUTO_HSDET_TIME_MASK, hs2);
230
231 done:
232 ret = 0;
233
234 regmap_update_bits(cs42l43->regmap, CS42L43_HS_BIAS_SENSE_AND_CLAMP_AUTOCONTROL,
235 CS42L43_JACKDET_MODE_MASK | CS42L43_S0_AUTO_ADCMUTE_DISABLE_MASK |
236 CS42L43_HSBIAS_SENSE_TRIP_MASK, autocontrol);
237 regmap_update_bits(cs42l43->regmap, CS42L43_PDNCNTL,
238 CS42L43_RING_SENSE_EN_MASK, pdncntl);
239
240 dev_dbg(priv->dev, "Successfully configured accessory detect\n");
241
242 error:
243 mutex_unlock(&priv->jack_lock);
244
245 pm_runtime_put_autosuspend(priv->dev);
246
247 return ret;
248 }
249
cs42l43_start_hs_bias(struct cs42l43_codec * priv,bool type_detect)250 static void cs42l43_start_hs_bias(struct cs42l43_codec *priv, bool type_detect)
251 {
252 struct cs42l43 *cs42l43 = priv->core;
253 unsigned int val = 0x3 << CS42L43_HSBIAS_MODE_SHIFT;
254
255 dev_dbg(priv->dev, "Start headset bias\n");
256
257 regmap_update_bits(cs42l43->regmap, CS42L43_HS2,
258 CS42L43_HS_CLAMP_DISABLE_MASK, CS42L43_HS_CLAMP_DISABLE_MASK);
259
260 if (!type_detect) {
261 if (priv->bias_low)
262 val = 0x2 << CS42L43_HSBIAS_MODE_SHIFT;
263
264 if (priv->bias_sense_ua)
265 regmap_update_bits(cs42l43->regmap,
266 CS42L43_HS_BIAS_SENSE_AND_CLAMP_AUTOCONTROL,
267 CS42L43_HSBIAS_SENSE_EN_MASK |
268 CS42L43_AUTO_HSBIAS_CLAMP_EN_MASK,
269 CS42L43_HSBIAS_SENSE_EN_MASK |
270 CS42L43_AUTO_HSBIAS_CLAMP_EN_MASK);
271 }
272
273 regmap_update_bits(cs42l43->regmap, CS42L43_MIC_DETECT_CONTROL_1,
274 CS42L43_HSBIAS_MODE_MASK, val);
275
276 msleep(priv->bias_ramp_ms);
277 }
278
cs42l43_stop_hs_bias(struct cs42l43_codec * priv)279 static void cs42l43_stop_hs_bias(struct cs42l43_codec *priv)
280 {
281 struct cs42l43 *cs42l43 = priv->core;
282
283 dev_dbg(priv->dev, "Stop headset bias\n");
284
285 regmap_update_bits(cs42l43->regmap, CS42L43_MIC_DETECT_CONTROL_1,
286 CS42L43_HSBIAS_MODE_MASK, 0x1 << CS42L43_HSBIAS_MODE_SHIFT);
287
288 regmap_update_bits(cs42l43->regmap, CS42L43_HS2,
289 CS42L43_HS_CLAMP_DISABLE_MASK, 0);
290
291 if (priv->bias_sense_ua) {
292 regmap_update_bits(cs42l43->regmap,
293 CS42L43_HS_BIAS_SENSE_AND_CLAMP_AUTOCONTROL,
294 CS42L43_HSBIAS_SENSE_EN_MASK |
295 CS42L43_AUTO_HSBIAS_CLAMP_EN_MASK, 0);
296 }
297 }
298
cs42l43_bias_detect_clamp(int irq,void * data)299 irqreturn_t cs42l43_bias_detect_clamp(int irq, void *data)
300 {
301 struct cs42l43_codec *priv = data;
302
303 queue_delayed_work(system_dfl_wq, &priv->bias_sense_timeout,
304 msecs_to_jiffies(1000));
305
306 return IRQ_HANDLED;
307 }
308
309 #define CS42L43_JACK_PRESENT 0x3
310 #define CS42L43_JACK_ABSENT 0x0
311
312 #define CS42L43_JACK_OPTICAL (SND_JACK_MECHANICAL | SND_JACK_AVOUT)
313 #define CS42L43_JACK_HEADPHONE (SND_JACK_MECHANICAL | SND_JACK_HEADPHONE)
314 #define CS42L43_JACK_HEADSET (SND_JACK_MECHANICAL | SND_JACK_HEADSET)
315 #define CS42L43_JACK_LINEOUT (SND_JACK_MECHANICAL | SND_JACK_LINEOUT)
316 #define CS42L43_JACK_LINEIN (SND_JACK_MECHANICAL | SND_JACK_LINEIN)
317 #define CS42L43_JACK_EXTENSION (SND_JACK_MECHANICAL)
318 #define CS42L43_JACK_BUTTONS (SND_JACK_BTN_0 | SND_JACK_BTN_1 | SND_JACK_BTN_2 | \
319 SND_JACK_BTN_3 | SND_JACK_BTN_4 | SND_JACK_BTN_5)
320
cs42l43_jack_present(struct cs42l43_codec * priv)321 static inline bool cs42l43_jack_present(struct cs42l43_codec *priv)
322 {
323 struct cs42l43 *cs42l43 = priv->core;
324 unsigned int sts = 0;
325
326 regmap_read(cs42l43->regmap, CS42L43_TIP_RING_SENSE_INTERRUPT_STATUS, &sts);
327
328 sts = (sts >> CS42L43_TIPSENSE_PLUG_DB_STS_SHIFT) & CS42L43_JACK_PRESENT;
329
330 return sts == CS42L43_JACK_PRESENT;
331 }
332
cs42l43_start_button_detect(struct cs42l43_codec * priv)333 static void cs42l43_start_button_detect(struct cs42l43_codec *priv)
334 {
335 struct cs42l43 *cs42l43 = priv->core;
336 unsigned int val = 0x3 << CS42L43_BUTTON_DETECT_MODE_SHIFT;
337
338 dev_dbg(priv->dev, "Start button detect\n");
339
340 priv->button_detect_running = true;
341
342 if (priv->bias_low)
343 val = 0x1 << CS42L43_BUTTON_DETECT_MODE_SHIFT;
344
345 regmap_update_bits(cs42l43->regmap, CS42L43_MIC_DETECT_CONTROL_1,
346 CS42L43_BUTTON_DETECT_MODE_MASK |
347 CS42L43_MIC_LVL_DET_DISABLE_MASK, val);
348 }
349
cs42l43_stop_button_detect(struct cs42l43_codec * priv)350 static void cs42l43_stop_button_detect(struct cs42l43_codec *priv)
351 {
352 struct cs42l43 *cs42l43 = priv->core;
353
354 dev_dbg(priv->dev, "Stop button detect\n");
355
356 regmap_update_bits(cs42l43->regmap, CS42L43_MIC_DETECT_CONTROL_1,
357 CS42L43_BUTTON_DETECT_MODE_MASK |
358 CS42L43_MIC_LVL_DET_DISABLE_MASK,
359 CS42L43_MIC_LVL_DET_DISABLE_MASK);
360
361 priv->button_detect_running = false;
362 }
363
364 #define CS42L43_BUTTON_COMB_US 11000
365 #define CS42L43_BUTTON_COMB_MAX 512
366 #define CS42L43_BUTTON_ROUT 2210
367
cs42l43_button_press(int irq,void * data)368 irqreturn_t cs42l43_button_press(int irq, void *data)
369 {
370 struct cs42l43_codec *priv = data;
371 struct cs42l43 *cs42l43 = priv->core;
372 irqreturn_t iret = IRQ_NONE;
373 unsigned int buttons = 0;
374 unsigned int val = 0;
375 int i, ret;
376
377 ret = pm_runtime_resume_and_get(priv->dev);
378 if (ret) {
379 dev_err(priv->dev, "Failed to resume for button press: %d\n", ret);
380 return iret;
381 }
382
383 mutex_lock(&priv->jack_lock);
384
385 if (!priv->button_detect_running) {
386 dev_dbg(priv->dev, "Spurious button press IRQ\n");
387 goto error;
388 }
389
390 // Wait for 2 full cycles of comb filter to ensure good reading
391 usleep_range(2 * CS42L43_BUTTON_COMB_US, 2 * CS42L43_BUTTON_COMB_US + 50);
392
393 regmap_read(cs42l43->regmap, CS42L43_DETECT_STATUS_1, &val);
394
395 /* Bail if jack removed, the button is irrelevant and likely invalid */
396 if (!cs42l43_jack_present(priv)) {
397 dev_dbg(priv->dev, "Button ignored due to removal\n");
398 goto error;
399 }
400
401 if (val & CS42L43_HSBIAS_CLAMP_STS_MASK) {
402 dev_dbg(priv->dev, "Button ignored due to bias sense\n");
403 goto error;
404 }
405
406 val = (val & CS42L43_HSDET_DC_STS_MASK) >> CS42L43_HSDET_DC_STS_SHIFT;
407 val = ((CS42L43_BUTTON_COMB_MAX << 20) / (val + 1)) - (1 << 20);
408 if (val)
409 val = (CS42L43_BUTTON_ROUT << 20) / val;
410 else
411 val = UINT_MAX;
412
413 for (i = 0; i < CS42L43_N_BUTTONS; i++) {
414 if (val < priv->buttons[i]) {
415 buttons = SND_JACK_BTN_0 >> i;
416 dev_dbg(priv->dev, "Detected button %d at %d Ohms\n", i, val);
417 break;
418 }
419 }
420
421 if (!buttons)
422 dev_dbg(priv->dev, "Unrecognised button: %d Ohms\n", val);
423
424 snd_soc_jack_report(priv->jack_hp, buttons, CS42L43_JACK_BUTTONS);
425
426 iret = IRQ_HANDLED;
427
428 error:
429 mutex_unlock(&priv->jack_lock);
430
431 pm_runtime_put_autosuspend(priv->dev);
432
433 return iret;
434 }
435
cs42l43_button_release(int irq,void * data)436 irqreturn_t cs42l43_button_release(int irq, void *data)
437 {
438 struct cs42l43_codec *priv = data;
439 irqreturn_t iret = IRQ_NONE;
440 int ret;
441
442 ret = pm_runtime_resume_and_get(priv->dev);
443 if (ret) {
444 dev_err(priv->dev, "Failed to resume for button release: %d\n", ret);
445 return iret;
446 }
447
448 mutex_lock(&priv->jack_lock);
449
450 if (priv->button_detect_running) {
451 dev_dbg(priv->dev, "Button release IRQ\n");
452
453 snd_soc_jack_report(priv->jack_hp, 0, CS42L43_JACK_BUTTONS);
454
455 iret = IRQ_HANDLED;
456 } else {
457 dev_dbg(priv->dev, "Spurious button release IRQ\n");
458 }
459
460 mutex_unlock(&priv->jack_lock);
461
462 pm_runtime_put_autosuspend(priv->dev);
463
464 return iret;
465 }
466
cs42l43_bias_sense_timeout(struct work_struct * work)467 void cs42l43_bias_sense_timeout(struct work_struct *work)
468 {
469 struct cs42l43_codec *priv = container_of(work, struct cs42l43_codec,
470 bias_sense_timeout.work);
471 struct cs42l43 *cs42l43 = priv->core;
472 int ret;
473
474 ret = pm_runtime_resume_and_get(priv->dev);
475 if (ret) {
476 dev_err(priv->dev, "Failed to resume for bias sense: %d\n", ret);
477 return;
478 }
479
480 mutex_lock(&priv->jack_lock);
481
482 if (cs42l43_jack_present(priv) && priv->button_detect_running) {
483 dev_dbg(priv->dev, "Bias sense timeout out, restore bias\n");
484
485 regmap_update_bits(cs42l43->regmap,
486 CS42L43_HS_BIAS_SENSE_AND_CLAMP_AUTOCONTROL,
487 CS42L43_AUTO_HSBIAS_CLAMP_EN_MASK, 0);
488 regmap_update_bits(cs42l43->regmap,
489 CS42L43_HS_BIAS_SENSE_AND_CLAMP_AUTOCONTROL,
490 CS42L43_AUTO_HSBIAS_CLAMP_EN_MASK,
491 CS42L43_AUTO_HSBIAS_CLAMP_EN_MASK);
492 }
493
494 mutex_unlock(&priv->jack_lock);
495
496 pm_runtime_put_autosuspend(priv->dev);
497 }
498
499 static const struct reg_sequence cs42l43_3pole_patch[] = {
500 { 0x4000, 0x00000055 },
501 { 0x4000, 0x000000AA },
502 { 0x17420, 0x8500F300 },
503 { 0x17424, 0x36003E00 },
504 { 0x4000, 0x00000000 },
505 };
506
507 static const struct reg_sequence cs42l43_4pole_patch[] = {
508 { 0x4000, 0x00000055 },
509 { 0x4000, 0x000000AA },
510 { 0x17420, 0x7800E600 },
511 { 0x17424, 0x36003800 },
512 { 0x4000, 0x00000000 },
513 };
514
cs42l43_start_load_detect(struct cs42l43_codec * priv,bool mic)515 static void cs42l43_start_load_detect(struct cs42l43_codec *priv, bool mic)
516 {
517 struct cs42l43 *cs42l43 = priv->core;
518
519 dev_dbg(priv->dev, "Start load detect\n");
520
521 snd_soc_dapm_mutex_lock(snd_soc_component_to_dapm(priv->component));
522
523 priv->load_detect_running = true;
524
525 if (priv->hp_ena && !priv->hp_ilimited) {
526 unsigned long time_left;
527
528 reinit_completion(&priv->hp_shutdown);
529
530 regmap_update_bits(cs42l43->regmap, CS42L43_BLOCK_EN8,
531 CS42L43_HP_EN_MASK, 0);
532
533 time_left = wait_for_completion_timeout(&priv->hp_shutdown,
534 msecs_to_jiffies(CS42L43_HP_TIMEOUT_MS));
535 if (!time_left)
536 dev_err(priv->dev, "Load detect HP power down timed out\n");
537 }
538
539 if (mic)
540 regmap_multi_reg_write_bypassed(cs42l43->regmap,
541 cs42l43_4pole_patch,
542 ARRAY_SIZE(cs42l43_4pole_patch));
543 else
544 regmap_multi_reg_write_bypassed(cs42l43->regmap,
545 cs42l43_3pole_patch,
546 ARRAY_SIZE(cs42l43_3pole_patch));
547
548 regmap_update_bits(cs42l43->regmap, CS42L43_BLOCK_EN3,
549 CS42L43_ADC1_EN_MASK | CS42L43_ADC2_EN_MASK, 0);
550 regmap_update_bits(cs42l43->regmap, CS42L43_DACCNFG2, CS42L43_HP_HPF_EN_MASK, 0);
551 regmap_update_bits(cs42l43->regmap, CS42L43_MIC_DETECT_CONTROL_1,
552 CS42L43_HSBIAS_MODE_MASK, 0);
553 regmap_update_bits(cs42l43->regmap, CS42L43_CTRL,
554 CS42L43_ADPTPWR_MODE_MASK, 0x4 << CS42L43_ADPTPWR_MODE_SHIFT);
555 regmap_update_bits(cs42l43->regmap, CS42L43_PGAVOL,
556 CS42L43_HP_DIG_VOL_RAMP_MASK | CS42L43_HP_ANA_VOL_RAMP_MASK, 0x6);
557 regmap_update_bits(cs42l43->regmap, CS42L43_DACCNFG1,
558 CS42L43_HP_MSTR_VOL_CTRL_EN_MASK, 0);
559
560 regmap_update_bits(cs42l43->regmap, CS42L43_HS2,
561 CS42L43_HS_CLAMP_DISABLE_MASK, CS42L43_HS_CLAMP_DISABLE_MASK);
562
563 regmap_update_bits(cs42l43->regmap, CS42L43_LOADDETENA,
564 CS42L43_HPLOAD_DET_EN_MASK,
565 CS42L43_HPLOAD_DET_EN_MASK);
566
567 snd_soc_dapm_mutex_unlock(snd_soc_component_to_dapm(priv->component));
568 }
569
cs42l43_stop_load_detect(struct cs42l43_codec * priv)570 static void cs42l43_stop_load_detect(struct cs42l43_codec *priv)
571 {
572 struct cs42l43 *cs42l43 = priv->core;
573
574 dev_dbg(priv->dev, "Stop load detect\n");
575
576 snd_soc_dapm_mutex_lock(snd_soc_component_to_dapm(priv->component));
577
578 regmap_update_bits(cs42l43->regmap, CS42L43_LOADDETENA,
579 CS42L43_HPLOAD_DET_EN_MASK, 0);
580 regmap_update_bits(cs42l43->regmap, CS42L43_HS2,
581 CS42L43_HS_CLAMP_DISABLE_MASK, 0);
582 regmap_update_bits(cs42l43->regmap, CS42L43_DACCNFG1,
583 CS42L43_HP_MSTR_VOL_CTRL_EN_MASK,
584 CS42L43_HP_MSTR_VOL_CTRL_EN_MASK);
585 regmap_update_bits(cs42l43->regmap, CS42L43_PGAVOL,
586 CS42L43_HP_DIG_VOL_RAMP_MASK | CS42L43_HP_ANA_VOL_RAMP_MASK,
587 0x4 << CS42L43_HP_DIG_VOL_RAMP_SHIFT);
588 regmap_update_bits(cs42l43->regmap, CS42L43_CTRL,
589 CS42L43_ADPTPWR_MODE_MASK, 0x7 << CS42L43_ADPTPWR_MODE_SHIFT);
590 regmap_update_bits(cs42l43->regmap, CS42L43_MIC_DETECT_CONTROL_1,
591 CS42L43_HSBIAS_MODE_MASK, 0x1 << CS42L43_HSBIAS_MODE_SHIFT);
592 regmap_update_bits(cs42l43->regmap, CS42L43_DACCNFG2,
593 CS42L43_HP_HPF_EN_MASK, CS42L43_HP_HPF_EN_MASK);
594
595 regmap_update_bits(cs42l43->regmap, CS42L43_BLOCK_EN3,
596 CS42L43_ADC1_EN_MASK | CS42L43_ADC2_EN_MASK,
597 priv->adc_ena);
598
599 if (priv->hp_ena && !priv->hp_ilimited) {
600 unsigned long time_left;
601
602 reinit_completion(&priv->hp_startup);
603
604 regmap_update_bits(cs42l43->regmap, CS42L43_BLOCK_EN8,
605 CS42L43_HP_EN_MASK, priv->hp_ena);
606
607 time_left = wait_for_completion_timeout(&priv->hp_startup,
608 msecs_to_jiffies(CS42L43_HP_TIMEOUT_MS));
609 if (!time_left)
610 dev_err(priv->dev, "Load detect HP restore timed out\n");
611 }
612
613 priv->load_detect_running = false;
614
615 snd_soc_dapm_mutex_unlock(snd_soc_component_to_dapm(priv->component));
616 }
617
cs42l43_run_load_detect(struct cs42l43_codec * priv,bool mic)618 static int cs42l43_run_load_detect(struct cs42l43_codec *priv, bool mic)
619 {
620 struct cs42l43 *cs42l43 = priv->core;
621 unsigned int val = 0;
622 unsigned long time_left;
623
624 reinit_completion(&priv->load_detect);
625
626 cs42l43_start_load_detect(priv, mic);
627 time_left = wait_for_completion_timeout(&priv->load_detect,
628 msecs_to_jiffies(CS42L43_LOAD_TIMEOUT_MS));
629 cs42l43_stop_load_detect(priv);
630
631 if (!time_left)
632 return -ETIMEDOUT;
633
634 regmap_read(cs42l43->regmap, CS42L43_LOADDETRESULTS, &val);
635
636 dev_dbg(priv->dev, "Headphone load detect: 0x%x\n", val);
637
638 /* Bail if jack removed, the load is irrelevant and likely invalid */
639 if (!cs42l43_jack_present(priv))
640 return -ENODEV;
641
642 if (mic) {
643 cs42l43_start_hs_bias(priv, false);
644 cs42l43_start_button_detect(priv);
645
646 return CS42L43_JACK_HEADSET;
647 }
648
649 switch (val & CS42L43_AMP3_RES_DET_MASK) {
650 case 0x0: // < 22 Ohm impedance
651 case 0x1: // < 150 Ohm impedance
652 case 0x2: // < 1000 Ohm impedance
653 return CS42L43_JACK_HEADPHONE;
654 case 0x3: // > 1000 Ohm impedance
655 return CS42L43_JACK_LINEOUT;
656 default:
657 return -EINVAL;
658 }
659 }
660
cs42l43_run_type_detect(struct cs42l43_codec * priv)661 static int cs42l43_run_type_detect(struct cs42l43_codec *priv)
662 {
663 struct cs42l43 *cs42l43 = priv->core;
664 int timeout_ms = ((2 * priv->detect_us) / USEC_PER_MSEC) + 200;
665 unsigned int type = 0xff;
666 unsigned long time_left;
667
668 reinit_completion(&priv->type_detect);
669
670 regmap_update_bits(cs42l43->regmap, CS42L43_STEREO_MIC_CLAMP_CTRL,
671 CS42L43_SMIC_HPAMP_CLAMP_DIS_FRC_VAL_MASK,
672 CS42L43_SMIC_HPAMP_CLAMP_DIS_FRC_VAL_MASK);
673
674 cs42l43_start_hs_bias(priv, true);
675 regmap_update_bits(cs42l43->regmap, CS42L43_HS2,
676 CS42L43_HSDET_MODE_MASK, 0x3 << CS42L43_HSDET_MODE_SHIFT);
677
678 time_left = wait_for_completion_timeout(&priv->type_detect,
679 msecs_to_jiffies(timeout_ms));
680
681 regmap_update_bits(cs42l43->regmap, CS42L43_HS2,
682 CS42L43_HSDET_MODE_MASK, 0x2 << CS42L43_HSDET_MODE_SHIFT);
683 cs42l43_stop_hs_bias(priv);
684
685 regmap_update_bits(cs42l43->regmap, CS42L43_STEREO_MIC_CLAMP_CTRL,
686 CS42L43_SMIC_HPAMP_CLAMP_DIS_FRC_VAL_MASK, 0);
687
688 if (!time_left)
689 return -ETIMEDOUT;
690
691 regmap_read(cs42l43->regmap, CS42L43_HS_STAT, &type);
692
693 dev_dbg(priv->dev, "Type detect: 0x%x\n", type);
694
695 /* Bail if jack removed, the type is irrelevant and likely invalid */
696 if (!cs42l43_jack_present(priv))
697 return -ENODEV;
698
699 switch (type & CS42L43_HSDET_TYPE_STS_MASK) {
700 case 0x0: // CTIA
701 case 0x1: // OMTP
702 case 0x4:
703 return cs42l43_run_load_detect(priv, true);
704 case 0x2: // 3-pole
705 return cs42l43_run_load_detect(priv, false);
706 case 0x3: // Open-circuit
707 return CS42L43_JACK_EXTENSION;
708 default:
709 return -EINVAL;
710 }
711 }
712
cs42l43_clear_jack(struct cs42l43_codec * priv)713 void cs42l43_clear_jack(struct cs42l43_codec *priv)
714 {
715 struct cs42l43 *cs42l43 = priv->core;
716
717 cs42l43_stop_button_detect(priv);
718 cs42l43_stop_hs_bias(priv);
719
720 regmap_update_bits(cs42l43->regmap, CS42L43_ADC_B_CTRL1,
721 CS42L43_PGA_WIDESWING_MODE_EN_MASK, 0);
722 regmap_update_bits(cs42l43->regmap, CS42L43_ADC_B_CTRL2,
723 CS42L43_PGA_WIDESWING_MODE_EN_MASK, 0);
724 regmap_update_bits(cs42l43->regmap, CS42L43_STEREO_MIC_CTRL,
725 CS42L43_JACK_STEREO_CONFIG_MASK, 0);
726 regmap_update_bits(cs42l43->regmap, CS42L43_STEREO_MIC_CLAMP_CTRL,
727 CS42L43_SMIC_HPAMP_CLAMP_DIS_FRC_MASK,
728 CS42L43_SMIC_HPAMP_CLAMP_DIS_FRC_MASK);
729 regmap_update_bits(cs42l43->regmap, CS42L43_HS2,
730 CS42L43_HSDET_MODE_MASK | CS42L43_HSDET_MANUAL_MODE_MASK,
731 0x2 << CS42L43_HSDET_MODE_SHIFT);
732 }
733
cs42l43_tip_sense_work(struct work_struct * work)734 void cs42l43_tip_sense_work(struct work_struct *work)
735 {
736 struct cs42l43_codec *priv = container_of(work, struct cs42l43_codec,
737 tip_sense_work.work);
738 struct cs42l43 *cs42l43 = priv->core;
739 unsigned int sts = 0;
740 unsigned int tip, ring;
741 int ret, report;
742
743 ret = pm_runtime_resume_and_get(priv->dev);
744 if (ret) {
745 dev_err(priv->dev, "Failed to resume for tip work: %d\n", ret);
746 return;
747 }
748
749 mutex_lock(&priv->jack_lock);
750
751 regmap_read(cs42l43->regmap, CS42L43_TIP_RING_SENSE_INTERRUPT_STATUS, &sts);
752
753 dev_dbg(priv->dev, "Tip sense: 0x%x\n", sts);
754
755 tip = (sts >> CS42L43_TIPSENSE_PLUG_DB_STS_SHIFT) & CS42L43_JACK_PRESENT;
756 ring = (sts >> CS42L43_RINGSENSE_PLUG_DB_STS_SHIFT) & CS42L43_JACK_PRESENT;
757
758 if (tip == CS42L43_JACK_PRESENT) {
759 if (cs42l43->sdw && !priv->jack_present) {
760 priv->jack_present = true;
761 pm_runtime_get(priv->dev);
762 }
763
764 if (priv->use_ring_sense && ring == CS42L43_JACK_ABSENT) {
765 report = CS42L43_JACK_OPTICAL;
766 } else {
767 report = cs42l43_run_type_detect(priv);
768 if (report < 0) {
769 dev_err(priv->dev, "Jack detect failed: %d\n", report);
770 goto error;
771 }
772 }
773
774 snd_soc_jack_report(priv->jack_hp, report, report);
775 } else {
776 priv->jack_override = 0;
777
778 cs42l43_clear_jack(priv);
779
780 snd_soc_jack_report(priv->jack_hp, 0, 0xFFFF);
781
782 if (cs42l43->sdw && priv->jack_present) {
783 pm_runtime_put(priv->dev);
784 priv->jack_present = false;
785 }
786 }
787
788 error:
789 mutex_unlock(&priv->jack_lock);
790
791 priv->suspend_jack_debounce = false;
792
793 pm_runtime_put_autosuspend(priv->dev);
794 }
795
cs42l43_tip_sense(int irq,void * data)796 irqreturn_t cs42l43_tip_sense(int irq, void *data)
797 {
798 struct cs42l43_codec *priv = data;
799 unsigned int db_delay = priv->tip_debounce_ms;
800
801 cancel_delayed_work(&priv->bias_sense_timeout);
802 cancel_delayed_work(&priv->tip_sense_work);
803
804 // Ensure delay after suspend is long enough to avoid false detection
805 if (priv->suspend_jack_debounce)
806 db_delay += priv->tip_fall_db_ms + priv->tip_rise_db_ms;
807
808 queue_delayed_work(system_long_wq, &priv->tip_sense_work,
809 msecs_to_jiffies(db_delay));
810
811 return IRQ_HANDLED;
812 }
813
814 enum cs42l43_raw_jack {
815 CS42L43_JACK_RAW_CTIA = 0,
816 CS42L43_JACK_RAW_OMTP,
817 CS42L43_JACK_RAW_HEADPHONE,
818 CS42L43_JACK_RAW_LINE_OUT,
819 CS42L43_JACK_RAW_LINE_IN,
820 CS42L43_JACK_RAW_MICROPHONE,
821 CS42L43_JACK_RAW_OPTICAL,
822 };
823
824 #define CS42L43_JACK_3_POLE_SWITCHES ((0x2 << CS42L43_HSDET_MANUAL_MODE_SHIFT) | \
825 CS42L43_AMP3_4_GNDREF_HS3_SEL_MASK | \
826 CS42L43_AMP3_4_GNDREF_HS4_SEL_MASK | \
827 CS42L43_HSBIAS_GNDREF_HS3_SEL_MASK | \
828 CS42L43_HSBIAS_GNDREF_HS4_SEL_MASK | \
829 CS42L43_HSGND_HS3_SEL_MASK | \
830 CS42L43_HSGND_HS4_SEL_MASK)
831
832 static const struct cs42l43_jack_override_mode {
833 unsigned int hsdet_mode;
834 unsigned int mic_ctrl;
835 unsigned int clamp_ctrl;
836 int report;
837 } cs42l43_jack_override_modes[] = {
838 [CS42L43_JACK_RAW_CTIA] = {
839 .hsdet_mode = CS42L43_AMP3_4_GNDREF_HS3_SEL_MASK |
840 CS42L43_HSBIAS_GNDREF_HS3_SEL_MASK |
841 CS42L43_HSBIAS_OUT_HS4_SEL_MASK |
842 CS42L43_HSGND_HS3_SEL_MASK,
843 .clamp_ctrl = CS42L43_SMIC_HPAMP_CLAMP_DIS_FRC_MASK,
844 .report = CS42L43_JACK_HEADSET,
845 },
846 [CS42L43_JACK_RAW_OMTP] = {
847 .hsdet_mode = (0x1 << CS42L43_HSDET_MANUAL_MODE_SHIFT) |
848 CS42L43_AMP3_4_GNDREF_HS4_SEL_MASK |
849 CS42L43_HSBIAS_GNDREF_HS4_SEL_MASK |
850 CS42L43_HSBIAS_OUT_HS3_SEL_MASK |
851 CS42L43_HSGND_HS4_SEL_MASK,
852 .clamp_ctrl = CS42L43_SMIC_HPAMP_CLAMP_DIS_FRC_MASK,
853 .report = CS42L43_JACK_HEADSET,
854 },
855 [CS42L43_JACK_RAW_HEADPHONE] = {
856 .hsdet_mode = CS42L43_JACK_3_POLE_SWITCHES,
857 .clamp_ctrl = CS42L43_SMIC_HPAMP_CLAMP_DIS_FRC_MASK,
858 .report = CS42L43_JACK_HEADPHONE,
859 },
860 [CS42L43_JACK_RAW_LINE_OUT] = {
861 .hsdet_mode = CS42L43_JACK_3_POLE_SWITCHES,
862 .clamp_ctrl = CS42L43_SMIC_HPAMP_CLAMP_DIS_FRC_MASK,
863 .report = CS42L43_JACK_LINEOUT,
864 },
865 [CS42L43_JACK_RAW_LINE_IN] = {
866 .hsdet_mode = CS42L43_JACK_3_POLE_SWITCHES,
867 .mic_ctrl = 0x2 << CS42L43_JACK_STEREO_CONFIG_SHIFT,
868 .report = CS42L43_JACK_LINEIN,
869 },
870 [CS42L43_JACK_RAW_MICROPHONE] = {
871 .hsdet_mode = CS42L43_JACK_3_POLE_SWITCHES,
872 .mic_ctrl = (0x3 << CS42L43_JACK_STEREO_CONFIG_SHIFT) |
873 CS42L43_HS1_BIAS_EN_MASK | CS42L43_HS2_BIAS_EN_MASK,
874 .report = CS42L43_JACK_LINEIN,
875 },
876 [CS42L43_JACK_RAW_OPTICAL] = {
877 .hsdet_mode = CS42L43_JACK_3_POLE_SWITCHES,
878 .clamp_ctrl = CS42L43_SMIC_HPAMP_CLAMP_DIS_FRC_MASK,
879 .report = CS42L43_JACK_OPTICAL,
880 },
881 };
882
883 static const char * const cs42l43_jack_text[] = {
884 "None", "CTIA", "OMTP", "Headphone", "Line-Out",
885 "Line-In", "Microphone", "Optical",
886 };
887
888 static_assert(ARRAY_SIZE(cs42l43_jack_override_modes) ==
889 ARRAY_SIZE(cs42l43_jack_text) - 1);
890
891 SOC_ENUM_SINGLE_VIRT_DECL(cs42l43_jack_enum, cs42l43_jack_text);
892
cs42l43_jack_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)893 int cs42l43_jack_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
894 {
895 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
896 struct cs42l43_codec *priv = snd_soc_component_get_drvdata(component);
897
898 mutex_lock(&priv->jack_lock);
899 ucontrol->value.integer.value[0] = priv->jack_override;
900 mutex_unlock(&priv->jack_lock);
901
902 return 0;
903 }
904
cs42l43_jack_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)905 int cs42l43_jack_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
906 {
907 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
908 struct cs42l43_codec *priv = snd_soc_component_get_drvdata(component);
909 struct cs42l43 *cs42l43 = priv->core;
910 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
911 unsigned int override = ucontrol->value.integer.value[0];
912
913 if (override >= e->items)
914 return -EINVAL;
915
916 mutex_lock(&priv->jack_lock);
917
918 if (!cs42l43_jack_present(priv)) {
919 mutex_unlock(&priv->jack_lock);
920 return -EBUSY;
921 }
922
923 if (override == priv->jack_override) {
924 mutex_unlock(&priv->jack_lock);
925 return 0;
926 }
927
928 priv->jack_override = override;
929
930 cs42l43_clear_jack(priv);
931
932 snd_soc_jack_report(priv->jack_hp, 0, 0xFFFF);
933
934 if (!override) {
935 queue_delayed_work(system_long_wq, &priv->tip_sense_work, 0);
936 } else {
937 override--;
938
939 regmap_update_bits(cs42l43->regmap, CS42L43_HS2,
940 CS42L43_HSDET_MODE_MASK |
941 CS42L43_HSDET_MANUAL_MODE_MASK |
942 CS42L43_AMP3_4_GNDREF_HS3_SEL_MASK |
943 CS42L43_AMP3_4_GNDREF_HS4_SEL_MASK |
944 CS42L43_HSBIAS_GNDREF_HS3_SEL_MASK |
945 CS42L43_HSBIAS_GNDREF_HS4_SEL_MASK |
946 CS42L43_HSBIAS_OUT_HS3_SEL_MASK |
947 CS42L43_HSBIAS_OUT_HS4_SEL_MASK |
948 CS42L43_HSGND_HS3_SEL_MASK |
949 CS42L43_HSGND_HS4_SEL_MASK,
950 cs42l43_jack_override_modes[override].hsdet_mode);
951 regmap_update_bits(cs42l43->regmap, CS42L43_STEREO_MIC_CTRL,
952 CS42L43_HS2_BIAS_EN_MASK | CS42L43_HS1_BIAS_EN_MASK |
953 CS42L43_JACK_STEREO_CONFIG_MASK,
954 cs42l43_jack_override_modes[override].mic_ctrl);
955 regmap_update_bits(cs42l43->regmap, CS42L43_STEREO_MIC_CLAMP_CTRL,
956 CS42L43_SMIC_HPAMP_CLAMP_DIS_FRC_MASK,
957 cs42l43_jack_override_modes[override].clamp_ctrl);
958
959 switch (override) {
960 case CS42L43_JACK_RAW_CTIA:
961 case CS42L43_JACK_RAW_OMTP:
962 cs42l43_start_hs_bias(priv, false);
963 cs42l43_start_button_detect(priv);
964 break;
965 case CS42L43_JACK_RAW_LINE_IN:
966 regmap_update_bits(cs42l43->regmap, CS42L43_ADC_B_CTRL1,
967 CS42L43_PGA_WIDESWING_MODE_EN_MASK,
968 CS42L43_PGA_WIDESWING_MODE_EN_MASK);
969 regmap_update_bits(cs42l43->regmap, CS42L43_ADC_B_CTRL2,
970 CS42L43_PGA_WIDESWING_MODE_EN_MASK,
971 CS42L43_PGA_WIDESWING_MODE_EN_MASK);
972 break;
973 case CS42L43_JACK_RAW_MICROPHONE:
974 cs42l43_start_hs_bias(priv, false);
975 break;
976 default:
977 break;
978 }
979
980 snd_soc_jack_report(priv->jack_hp,
981 cs42l43_jack_override_modes[override].report,
982 cs42l43_jack_override_modes[override].report);
983 }
984
985 mutex_unlock(&priv->jack_lock);
986
987 return 1;
988 }
989