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