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