xref: /openbmc/linux/sound/soc/codecs/arizona-jack.c (revision 69c58eb6)
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * extcon-arizona.c - Extcon driver Wolfson Arizona devices
4  *
5  *  Copyright (C) 2012-2014 Wolfson Microelectronics plc
6  */
7 
8 #include <linux/kernel.h>
9 #include <linux/module.h>
10 #include <linux/slab.h>
11 #include <linux/interrupt.h>
12 #include <linux/err.h>
13 #include <linux/gpio/consumer.h>
14 #include <linux/gpio.h>
15 #include <linux/input.h>
16 #include <linux/pm_runtime.h>
17 #include <linux/property.h>
18 #include <linux/regulator/consumer.h>
19 
20 #include <sound/jack.h>
21 #include <sound/soc.h>
22 
23 #include <linux/mfd/arizona/core.h>
24 #include <linux/mfd/arizona/pdata.h>
25 #include <linux/mfd/arizona/registers.h>
26 #include <dt-bindings/mfd/arizona.h>
27 
28 #include "arizona.h"
29 
30 #define ARIZONA_MAX_MICD_RANGE 8
31 
32 /*
33  * The hardware supports 8 ranges / buttons, but the snd-jack interface
34  * only supports 6 buttons (button 0-5).
35  */
36 #define ARIZONA_MAX_MICD_BUTTONS 6
37 
38 #define ARIZONA_MICD_CLAMP_MODE_JDL      0x4
39 #define ARIZONA_MICD_CLAMP_MODE_JDH      0x5
40 #define ARIZONA_MICD_CLAMP_MODE_JDL_GP5H 0x9
41 #define ARIZONA_MICD_CLAMP_MODE_JDH_GP5H 0xb
42 
43 #define ARIZONA_TST_CAP_DEFAULT 0x3
44 #define ARIZONA_TST_CAP_CLAMP   0x1
45 
46 #define ARIZONA_HPDET_MAX 10000
47 
48 #define HPDET_DEBOUNCE 500
49 #define DEFAULT_MICD_TIMEOUT 2000
50 
51 #define ARIZONA_HPDET_WAIT_COUNT 15
52 #define ARIZONA_HPDET_WAIT_DELAY_MS 20
53 
54 #define QUICK_HEADPHONE_MAX_OHM 3
55 #define MICROPHONE_MIN_OHM      1257
56 #define MICROPHONE_MAX_OHM      30000
57 
58 #define MICD_DBTIME_TWO_READINGS 2
59 #define MICD_DBTIME_FOUR_READINGS 4
60 
61 #define MICD_LVL_1_TO_7 (ARIZONA_MICD_LVL_1 | ARIZONA_MICD_LVL_2 | \
62 			 ARIZONA_MICD_LVL_3 | ARIZONA_MICD_LVL_4 | \
63 			 ARIZONA_MICD_LVL_5 | ARIZONA_MICD_LVL_6 | \
64 			 ARIZONA_MICD_LVL_7)
65 
66 #define MICD_LVL_0_TO_7 (ARIZONA_MICD_LVL_0 | MICD_LVL_1_TO_7)
67 
68 #define MICD_LVL_0_TO_8 (MICD_LVL_0_TO_7 | ARIZONA_MICD_LVL_8)
69 
70 static const struct arizona_micd_config micd_default_modes[] = {
71 	{ ARIZONA_ACCDET_SRC, 1, 0 },
72 	{ 0,                  2, 1 },
73 };
74 
75 static const struct arizona_micd_range micd_default_ranges[] = {
76 	{ .max =  11, .key = BTN_0 },
77 	{ .max =  28, .key = BTN_1 },
78 	{ .max =  54, .key = BTN_2 },
79 	{ .max = 100, .key = BTN_3 },
80 	{ .max = 186, .key = BTN_4 },
81 	{ .max = 430, .key = BTN_5 },
82 };
83 
84 /* The number of levels in arizona_micd_levels valid for button thresholds */
85 #define ARIZONA_NUM_MICD_BUTTON_LEVELS 64
86 
87 static const int arizona_micd_levels[] = {
88 	3, 6, 8, 11, 13, 16, 18, 21, 23, 26, 28, 31, 34, 36, 39, 41, 44, 46,
89 	49, 52, 54, 57, 60, 62, 65, 67, 70, 73, 75, 78, 81, 83, 89, 94, 100,
90 	105, 111, 116, 122, 127, 139, 150, 161, 173, 186, 196, 209, 220, 245,
91 	270, 295, 321, 348, 375, 402, 430, 489, 550, 614, 681, 752, 903, 1071,
92 	1257, 30000,
93 };
94 
95 static void arizona_start_hpdet_acc_id(struct arizona_priv *info);
96 
arizona_extcon_hp_clamp(struct arizona_priv * info,bool clamp)97 static void arizona_extcon_hp_clamp(struct arizona_priv *info,
98 				    bool clamp)
99 {
100 	struct arizona *arizona = info->arizona;
101 	unsigned int mask = 0, val = 0;
102 	unsigned int cap_sel = 0;
103 	int ret;
104 
105 	switch (arizona->type) {
106 	case WM8998:
107 	case WM1814:
108 		mask = 0;
109 		break;
110 	case WM5110:
111 	case WM8280:
112 		mask = ARIZONA_HP1L_SHRTO | ARIZONA_HP1L_FLWR |
113 		       ARIZONA_HP1L_SHRTI;
114 		if (clamp) {
115 			val = ARIZONA_HP1L_SHRTO;
116 			cap_sel = ARIZONA_TST_CAP_CLAMP;
117 		} else {
118 			val = ARIZONA_HP1L_FLWR | ARIZONA_HP1L_SHRTI;
119 			cap_sel = ARIZONA_TST_CAP_DEFAULT;
120 		}
121 
122 		ret = regmap_update_bits(arizona->regmap,
123 					 ARIZONA_HP_TEST_CTRL_1,
124 					 ARIZONA_HP1_TST_CAP_SEL_MASK,
125 					 cap_sel);
126 		if (ret)
127 			dev_warn(arizona->dev, "Failed to set TST_CAP_SEL: %d\n", ret);
128 		break;
129 	default:
130 		mask = ARIZONA_RMV_SHRT_HP1L;
131 		if (clamp)
132 			val = ARIZONA_RMV_SHRT_HP1L;
133 		break;
134 	}
135 
136 	snd_soc_dapm_mutex_lock(arizona->dapm);
137 
138 	arizona->hpdet_clamp = clamp;
139 
140 	/* Keep the HP output stages disabled while doing the clamp */
141 	if (clamp) {
142 		ret = regmap_update_bits(arizona->regmap,
143 					 ARIZONA_OUTPUT_ENABLES_1,
144 					 ARIZONA_OUT1L_ENA |
145 					 ARIZONA_OUT1R_ENA, 0);
146 		if (ret)
147 			dev_warn(arizona->dev, "Failed to disable headphone outputs: %d\n", ret);
148 	}
149 
150 	if (mask) {
151 		ret = regmap_update_bits(arizona->regmap, ARIZONA_HP_CTRL_1L,
152 					 mask, val);
153 		if (ret)
154 			dev_warn(arizona->dev, "Failed to do clamp: %d\n", ret);
155 
156 		ret = regmap_update_bits(arizona->regmap, ARIZONA_HP_CTRL_1R,
157 					 mask, val);
158 		if (ret)
159 			dev_warn(arizona->dev, "Failed to do clamp: %d\n", ret);
160 	}
161 
162 	/* Restore the desired state while not doing the clamp */
163 	if (!clamp) {
164 		ret = regmap_update_bits(arizona->regmap,
165 					 ARIZONA_OUTPUT_ENABLES_1,
166 					 ARIZONA_OUT1L_ENA |
167 					 ARIZONA_OUT1R_ENA, arizona->hp_ena);
168 		if (ret)
169 			dev_warn(arizona->dev, "Failed to restore headphone outputs: %d\n", ret);
170 	}
171 
172 	snd_soc_dapm_mutex_unlock(arizona->dapm);
173 }
174 
arizona_extcon_set_mode(struct arizona_priv * info,int mode)175 static void arizona_extcon_set_mode(struct arizona_priv *info, int mode)
176 {
177 	struct arizona *arizona = info->arizona;
178 
179 	mode %= info->micd_num_modes;
180 
181 	gpiod_set_value_cansleep(info->micd_pol_gpio,
182 				 info->micd_modes[mode].gpio);
183 
184 	regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_1,
185 			   ARIZONA_MICD_BIAS_SRC_MASK,
186 			   info->micd_modes[mode].bias <<
187 			   ARIZONA_MICD_BIAS_SRC_SHIFT);
188 	regmap_update_bits(arizona->regmap, ARIZONA_ACCESSORY_DETECT_MODE_1,
189 			   ARIZONA_ACCDET_SRC, info->micd_modes[mode].src);
190 
191 	info->micd_mode = mode;
192 
193 	dev_dbg(arizona->dev, "Set jack polarity to %d\n", mode);
194 }
195 
arizona_extcon_get_micbias(struct arizona_priv * info)196 static const char *arizona_extcon_get_micbias(struct arizona_priv *info)
197 {
198 	switch (info->micd_modes[0].bias) {
199 	case 1:
200 		return "MICBIAS1";
201 	case 2:
202 		return "MICBIAS2";
203 	case 3:
204 		return "MICBIAS3";
205 	default:
206 		return "MICVDD";
207 	}
208 }
209 
arizona_extcon_pulse_micbias(struct arizona_priv * info)210 static void arizona_extcon_pulse_micbias(struct arizona_priv *info)
211 {
212 	struct arizona *arizona = info->arizona;
213 	const char *widget = arizona_extcon_get_micbias(info);
214 	struct snd_soc_dapm_context *dapm = arizona->dapm;
215 	struct snd_soc_component *component = snd_soc_dapm_to_component(dapm);
216 	int ret;
217 
218 	ret = snd_soc_component_force_enable_pin(component, widget);
219 	if (ret)
220 		dev_warn(arizona->dev, "Failed to enable %s: %d\n", widget, ret);
221 
222 	snd_soc_dapm_sync(dapm);
223 
224 	if (!arizona->pdata.micd_force_micbias) {
225 		ret = snd_soc_component_disable_pin(component, widget);
226 		if (ret)
227 			dev_warn(arizona->dev, "Failed to disable %s: %d\n", widget, ret);
228 
229 		snd_soc_dapm_sync(dapm);
230 	}
231 }
232 
arizona_start_mic(struct arizona_priv * info)233 static void arizona_start_mic(struct arizona_priv *info)
234 {
235 	struct arizona *arizona = info->arizona;
236 	bool change;
237 	int ret;
238 	unsigned int mode;
239 
240 	/* Microphone detection can't use idle mode */
241 	pm_runtime_get_sync(arizona->dev);
242 
243 	if (info->detecting) {
244 		ret = regulator_allow_bypass(info->micvdd, false);
245 		if (ret)
246 			dev_err(arizona->dev, "Failed to regulate MICVDD: %d\n", ret);
247 	}
248 
249 	ret = regulator_enable(info->micvdd);
250 	if (ret)
251 		dev_err(arizona->dev, "Failed to enable MICVDD: %d\n", ret);
252 
253 	if (info->micd_reva) {
254 		const struct reg_sequence reva[] = {
255 			{ 0x80,  0x3 },
256 			{ 0x294, 0x0 },
257 			{ 0x80,  0x0 },
258 		};
259 
260 		regmap_multi_reg_write(arizona->regmap, reva, ARRAY_SIZE(reva));
261 	}
262 
263 	if (info->detecting && arizona->pdata.micd_software_compare)
264 		mode = ARIZONA_ACCDET_MODE_ADC;
265 	else
266 		mode = ARIZONA_ACCDET_MODE_MIC;
267 
268 	regmap_update_bits(arizona->regmap,
269 			   ARIZONA_ACCESSORY_DETECT_MODE_1,
270 			   ARIZONA_ACCDET_MODE_MASK, mode);
271 
272 	arizona_extcon_pulse_micbias(info);
273 
274 	ret = regmap_update_bits_check(arizona->regmap, ARIZONA_MIC_DETECT_1,
275 				       ARIZONA_MICD_ENA, ARIZONA_MICD_ENA,
276 				       &change);
277 	if (ret < 0) {
278 		dev_err(arizona->dev, "Failed to enable micd: %d\n", ret);
279 	} else if (!change) {
280 		regulator_disable(info->micvdd);
281 		pm_runtime_put_autosuspend(arizona->dev);
282 	}
283 }
284 
arizona_stop_mic(struct arizona_priv * info)285 static void arizona_stop_mic(struct arizona_priv *info)
286 {
287 	struct arizona *arizona = info->arizona;
288 	const char *widget = arizona_extcon_get_micbias(info);
289 	struct snd_soc_dapm_context *dapm = arizona->dapm;
290 	struct snd_soc_component *component = snd_soc_dapm_to_component(dapm);
291 	bool change = false;
292 	int ret;
293 
294 	ret = regmap_update_bits_check(arizona->regmap, ARIZONA_MIC_DETECT_1,
295 				       ARIZONA_MICD_ENA, 0,
296 				       &change);
297 	if (ret < 0)
298 		dev_err(arizona->dev, "Failed to disable micd: %d\n", ret);
299 
300 	ret = snd_soc_component_disable_pin(component, widget);
301 	if (ret)
302 		dev_warn(arizona->dev, "Failed to disable %s: %d\n", widget, ret);
303 
304 	snd_soc_dapm_sync(dapm);
305 
306 	if (info->micd_reva) {
307 		const struct reg_sequence reva[] = {
308 			{ 0x80,  0x3 },
309 			{ 0x294, 0x2 },
310 			{ 0x80,  0x0 },
311 		};
312 
313 		regmap_multi_reg_write(arizona->regmap, reva, ARRAY_SIZE(reva));
314 	}
315 
316 	ret = regulator_allow_bypass(info->micvdd, true);
317 	if (ret)
318 		dev_err(arizona->dev, "Failed to bypass MICVDD: %d\n", ret);
319 
320 	if (change) {
321 		regulator_disable(info->micvdd);
322 		pm_runtime_mark_last_busy(arizona->dev);
323 		pm_runtime_put_autosuspend(arizona->dev);
324 	}
325 }
326 
327 static struct {
328 	unsigned int threshold;
329 	unsigned int factor_a;
330 	unsigned int factor_b;
331 } arizona_hpdet_b_ranges[] = {
332 	{ 100,  5528,   362464 },
333 	{ 169, 11084,  6186851 },
334 	{ 169, 11065, 65460395 },
335 };
336 
337 #define ARIZONA_HPDET_B_RANGE_MAX 0x3fb
338 
339 static struct {
340 	int min;
341 	int max;
342 } arizona_hpdet_c_ranges[] = {
343 	{ 0,       30 },
344 	{ 8,      100 },
345 	{ 100,   1000 },
346 	{ 1000, 10000 },
347 };
348 
arizona_hpdet_read(struct arizona_priv * info)349 static int arizona_hpdet_read(struct arizona_priv *info)
350 {
351 	struct arizona *arizona = info->arizona;
352 	unsigned int val, range;
353 	int ret;
354 
355 	ret = regmap_read(arizona->regmap, ARIZONA_HEADPHONE_DETECT_2, &val);
356 	if (ret) {
357 		dev_err(arizona->dev, "Failed to read HPDET status: %d\n", ret);
358 		return ret;
359 	}
360 
361 	switch (info->hpdet_ip_version) {
362 	case 0:
363 		if (!(val & ARIZONA_HP_DONE)) {
364 			dev_err(arizona->dev, "HPDET did not complete: %x\n", val);
365 			return -EAGAIN;
366 		}
367 
368 		val &= ARIZONA_HP_LVL_MASK;
369 		break;
370 
371 	case 1:
372 		if (!(val & ARIZONA_HP_DONE_B)) {
373 			dev_err(arizona->dev, "HPDET did not complete: %x\n", val);
374 			return -EAGAIN;
375 		}
376 
377 		ret = regmap_read(arizona->regmap, ARIZONA_HP_DACVAL, &val);
378 		if (ret) {
379 			dev_err(arizona->dev, "Failed to read HP value: %d\n", ret);
380 			return -EAGAIN;
381 		}
382 
383 		regmap_read(arizona->regmap, ARIZONA_HEADPHONE_DETECT_1,
384 			    &range);
385 		range = (range & ARIZONA_HP_IMPEDANCE_RANGE_MASK)
386 			   >> ARIZONA_HP_IMPEDANCE_RANGE_SHIFT;
387 
388 		if (range < ARRAY_SIZE(arizona_hpdet_b_ranges) - 1 &&
389 		    (val < arizona_hpdet_b_ranges[range].threshold ||
390 		     val >= ARIZONA_HPDET_B_RANGE_MAX)) {
391 			range++;
392 			dev_dbg(arizona->dev, "Moving to HPDET range %d\n", range);
393 			regmap_update_bits(arizona->regmap,
394 					   ARIZONA_HEADPHONE_DETECT_1,
395 					   ARIZONA_HP_IMPEDANCE_RANGE_MASK,
396 					   range <<
397 					   ARIZONA_HP_IMPEDANCE_RANGE_SHIFT);
398 			return -EAGAIN;
399 		}
400 
401 		/* If we go out of range report top of range */
402 		if (val < arizona_hpdet_b_ranges[range].threshold ||
403 		    val >= ARIZONA_HPDET_B_RANGE_MAX) {
404 			dev_dbg(arizona->dev, "Measurement out of range\n");
405 			return ARIZONA_HPDET_MAX;
406 		}
407 
408 		dev_dbg(arizona->dev, "HPDET read %d in range %d\n", val, range);
409 
410 		val = arizona_hpdet_b_ranges[range].factor_b
411 			/ ((val * 100) -
412 			   arizona_hpdet_b_ranges[range].factor_a);
413 		break;
414 
415 	case 2:
416 		if (!(val & ARIZONA_HP_DONE_B)) {
417 			dev_err(arizona->dev, "HPDET did not complete: %x\n", val);
418 			return -EAGAIN;
419 		}
420 
421 		val &= ARIZONA_HP_LVL_B_MASK;
422 		/* Convert to ohms, the value is in 0.5 ohm increments */
423 		val /= 2;
424 
425 		regmap_read(arizona->regmap, ARIZONA_HEADPHONE_DETECT_1,
426 			    &range);
427 		range = (range & ARIZONA_HP_IMPEDANCE_RANGE_MASK)
428 			   >> ARIZONA_HP_IMPEDANCE_RANGE_SHIFT;
429 
430 		/* Skip up a range, or report? */
431 		if (range < ARRAY_SIZE(arizona_hpdet_c_ranges) - 1 &&
432 		    (val >= arizona_hpdet_c_ranges[range].max)) {
433 			range++;
434 			dev_dbg(arizona->dev, "Moving to HPDET range %d-%d\n",
435 				arizona_hpdet_c_ranges[range].min,
436 				arizona_hpdet_c_ranges[range].max);
437 			regmap_update_bits(arizona->regmap,
438 					   ARIZONA_HEADPHONE_DETECT_1,
439 					   ARIZONA_HP_IMPEDANCE_RANGE_MASK,
440 					   range <<
441 					   ARIZONA_HP_IMPEDANCE_RANGE_SHIFT);
442 			return -EAGAIN;
443 		}
444 
445 		if (range && (val < arizona_hpdet_c_ranges[range].min)) {
446 			dev_dbg(arizona->dev, "Reporting range boundary %d\n",
447 				arizona_hpdet_c_ranges[range].min);
448 			val = arizona_hpdet_c_ranges[range].min;
449 		}
450 		break;
451 
452 	default:
453 		dev_warn(arizona->dev, "Unknown HPDET IP revision %d\n", info->hpdet_ip_version);
454 		return -EINVAL;
455 	}
456 
457 	dev_dbg(arizona->dev, "HP impedance %d ohms\n", val);
458 	return val;
459 }
460 
arizona_hpdet_do_id(struct arizona_priv * info,int * reading,bool * mic)461 static int arizona_hpdet_do_id(struct arizona_priv *info, int *reading,
462 			       bool *mic)
463 {
464 	struct arizona *arizona = info->arizona;
465 	int id_gpio = arizona->pdata.hpdet_id_gpio;
466 
467 	if (!arizona->pdata.hpdet_acc_id)
468 		return 0;
469 
470 	/*
471 	 * If we're using HPDET for accessory identification we need
472 	 * to take multiple measurements, step through them in sequence.
473 	 */
474 	info->hpdet_res[info->num_hpdet_res++] = *reading;
475 
476 	/* Only check the mic directly if we didn't already ID it */
477 	if (id_gpio && info->num_hpdet_res == 1) {
478 		dev_dbg(arizona->dev, "Measuring mic\n");
479 
480 		regmap_update_bits(arizona->regmap,
481 				   ARIZONA_ACCESSORY_DETECT_MODE_1,
482 				   ARIZONA_ACCDET_MODE_MASK |
483 				   ARIZONA_ACCDET_SRC,
484 				   ARIZONA_ACCDET_MODE_HPR |
485 				   info->micd_modes[0].src);
486 
487 		gpio_set_value_cansleep(id_gpio, 1);
488 
489 		regmap_update_bits(arizona->regmap, ARIZONA_HEADPHONE_DETECT_1,
490 				   ARIZONA_HP_POLL, ARIZONA_HP_POLL);
491 		return -EAGAIN;
492 	}
493 
494 	/* OK, got both.  Now, compare... */
495 	dev_dbg(arizona->dev, "HPDET measured %d %d\n",
496 		info->hpdet_res[0], info->hpdet_res[1]);
497 
498 	/* Take the headphone impedance for the main report */
499 	*reading = info->hpdet_res[0];
500 
501 	/* Sometimes we get false readings due to slow insert */
502 	if (*reading >= ARIZONA_HPDET_MAX && !info->hpdet_retried) {
503 		dev_dbg(arizona->dev, "Retrying high impedance\n");
504 		info->num_hpdet_res = 0;
505 		info->hpdet_retried = true;
506 		arizona_start_hpdet_acc_id(info);
507 		pm_runtime_put(arizona->dev);
508 		return -EAGAIN;
509 	}
510 
511 	/*
512 	 * If we measure the mic as high impedance
513 	 */
514 	if (!id_gpio || info->hpdet_res[1] > 50) {
515 		dev_dbg(arizona->dev, "Detected mic\n");
516 		*mic = true;
517 		info->detecting = true;
518 	} else {
519 		dev_dbg(arizona->dev, "Detected headphone\n");
520 	}
521 
522 	/* Make sure everything is reset back to the real polarity */
523 	regmap_update_bits(arizona->regmap, ARIZONA_ACCESSORY_DETECT_MODE_1,
524 			   ARIZONA_ACCDET_SRC, info->micd_modes[0].src);
525 
526 	return 0;
527 }
528 
arizona_hpdet_irq(int irq,void * data)529 static irqreturn_t arizona_hpdet_irq(int irq, void *data)
530 {
531 	struct arizona_priv *info = data;
532 	struct arizona *arizona = info->arizona;
533 	int id_gpio = arizona->pdata.hpdet_id_gpio;
534 	int ret, reading, state, report;
535 	bool mic = false;
536 
537 	mutex_lock(&info->lock);
538 
539 	/* If we got a spurious IRQ for some reason then ignore it */
540 	if (!info->hpdet_active) {
541 		dev_warn(arizona->dev, "Spurious HPDET IRQ\n");
542 		mutex_unlock(&info->lock);
543 		return IRQ_NONE;
544 	}
545 
546 	/* If the cable was removed while measuring ignore the result */
547 	state = info->jack->status & SND_JACK_MECHANICAL;
548 	if (!state) {
549 		dev_dbg(arizona->dev, "Ignoring HPDET for removed cable\n");
550 		goto done;
551 	}
552 
553 	ret = arizona_hpdet_read(info);
554 	if (ret == -EAGAIN)
555 		goto out;
556 	else if (ret < 0)
557 		goto done;
558 	reading = ret;
559 
560 	/* Reset back to starting range */
561 	regmap_update_bits(arizona->regmap,
562 			   ARIZONA_HEADPHONE_DETECT_1,
563 			   ARIZONA_HP_IMPEDANCE_RANGE_MASK | ARIZONA_HP_POLL,
564 			   0);
565 
566 	ret = arizona_hpdet_do_id(info, &reading, &mic);
567 	if (ret == -EAGAIN)
568 		goto out;
569 	else if (ret < 0)
570 		goto done;
571 
572 	/* Report high impedence cables as line outputs */
573 	if (reading >= 5000)
574 		report = SND_JACK_LINEOUT;
575 	else
576 		report = SND_JACK_HEADPHONE;
577 
578 	snd_soc_jack_report(info->jack, report, SND_JACK_LINEOUT | SND_JACK_HEADPHONE);
579 
580 done:
581 	/* Reset back to starting range */
582 	regmap_update_bits(arizona->regmap,
583 			   ARIZONA_HEADPHONE_DETECT_1,
584 			   ARIZONA_HP_IMPEDANCE_RANGE_MASK | ARIZONA_HP_POLL,
585 			   0);
586 
587 	arizona_extcon_hp_clamp(info, false);
588 
589 	if (id_gpio)
590 		gpio_set_value_cansleep(id_gpio, 0);
591 
592 	/* If we have a mic then reenable MICDET */
593 	if (state && (mic || info->mic))
594 		arizona_start_mic(info);
595 
596 	if (info->hpdet_active) {
597 		pm_runtime_put_autosuspend(arizona->dev);
598 		info->hpdet_active = false;
599 	}
600 
601 	/* Do not set hp_det done when the cable has been unplugged */
602 	if (state)
603 		info->hpdet_done = true;
604 
605 out:
606 	mutex_unlock(&info->lock);
607 
608 	return IRQ_HANDLED;
609 }
610 
arizona_identify_headphone(struct arizona_priv * info)611 static void arizona_identify_headphone(struct arizona_priv *info)
612 {
613 	struct arizona *arizona = info->arizona;
614 	int ret;
615 
616 	if (info->hpdet_done)
617 		return;
618 
619 	dev_dbg(arizona->dev, "Starting HPDET\n");
620 
621 	/* Make sure we keep the device enabled during the measurement */
622 	pm_runtime_get_sync(arizona->dev);
623 
624 	info->hpdet_active = true;
625 
626 	arizona_stop_mic(info);
627 
628 	arizona_extcon_hp_clamp(info, true);
629 
630 	ret = regmap_update_bits(arizona->regmap,
631 				 ARIZONA_ACCESSORY_DETECT_MODE_1,
632 				 ARIZONA_ACCDET_MODE_MASK,
633 				 arizona->pdata.hpdet_channel);
634 	if (ret != 0) {
635 		dev_err(arizona->dev, "Failed to set HPDET mode: %d\n", ret);
636 		goto err;
637 	}
638 
639 	ret = regmap_update_bits(arizona->regmap, ARIZONA_HEADPHONE_DETECT_1,
640 				 ARIZONA_HP_POLL, ARIZONA_HP_POLL);
641 	if (ret) {
642 		dev_err(arizona->dev, "Can't start HPDETL measurement: %d\n", ret);
643 		goto err;
644 	}
645 
646 	return;
647 
648 err:
649 	arizona_extcon_hp_clamp(info, false);
650 	pm_runtime_put_autosuspend(arizona->dev);
651 
652 	/* Just report headphone */
653 	snd_soc_jack_report(info->jack, SND_JACK_HEADPHONE,
654 			    SND_JACK_LINEOUT | SND_JACK_HEADPHONE);
655 
656 	if (info->mic)
657 		arizona_start_mic(info);
658 
659 	info->hpdet_active = false;
660 }
661 
arizona_start_hpdet_acc_id(struct arizona_priv * info)662 static void arizona_start_hpdet_acc_id(struct arizona_priv *info)
663 {
664 	struct arizona *arizona = info->arizona;
665 	int hp_reading = 32;
666 	bool mic;
667 	int ret;
668 
669 	dev_dbg(arizona->dev, "Starting identification via HPDET\n");
670 
671 	/* Make sure we keep the device enabled during the measurement */
672 	pm_runtime_get_sync(arizona->dev);
673 
674 	info->hpdet_active = true;
675 
676 	arizona_extcon_hp_clamp(info, true);
677 
678 	ret = regmap_update_bits(arizona->regmap,
679 				 ARIZONA_ACCESSORY_DETECT_MODE_1,
680 				 ARIZONA_ACCDET_SRC | ARIZONA_ACCDET_MODE_MASK,
681 				 info->micd_modes[0].src |
682 				 arizona->pdata.hpdet_channel);
683 	if (ret != 0) {
684 		dev_err(arizona->dev, "Failed to set HPDET mode: %d\n", ret);
685 		goto err;
686 	}
687 
688 	if (arizona->pdata.hpdet_acc_id_line) {
689 		ret = regmap_update_bits(arizona->regmap,
690 					 ARIZONA_HEADPHONE_DETECT_1,
691 					 ARIZONA_HP_POLL, ARIZONA_HP_POLL);
692 		if (ret) {
693 			dev_err(arizona->dev, "Can't start HPDETL measurement: %d\n", ret);
694 			goto err;
695 		}
696 	} else {
697 		arizona_hpdet_do_id(info, &hp_reading, &mic);
698 	}
699 
700 	return;
701 
702 err:
703 	/* Just report headphone */
704 	snd_soc_jack_report(info->jack, SND_JACK_HEADPHONE,
705 			    SND_JACK_LINEOUT | SND_JACK_HEADPHONE);
706 
707 	info->hpdet_active = false;
708 }
709 
arizona_micd_timeout_work(struct work_struct * work)710 static void arizona_micd_timeout_work(struct work_struct *work)
711 {
712 	struct arizona_priv *info = container_of(work,
713 						struct arizona_priv,
714 						micd_timeout_work.work);
715 
716 	mutex_lock(&info->lock);
717 
718 	dev_dbg(info->arizona->dev, "MICD timed out, reporting HP\n");
719 
720 	info->detecting = false;
721 
722 	arizona_identify_headphone(info);
723 
724 	mutex_unlock(&info->lock);
725 }
726 
arizona_micd_adc_read(struct arizona_priv * info)727 static int arizona_micd_adc_read(struct arizona_priv *info)
728 {
729 	struct arizona *arizona = info->arizona;
730 	unsigned int val;
731 	int ret;
732 
733 	/* Must disable MICD before we read the ADCVAL */
734 	regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_1,
735 			   ARIZONA_MICD_ENA, 0);
736 
737 	ret = regmap_read(arizona->regmap, ARIZONA_MIC_DETECT_4, &val);
738 	if (ret) {
739 		dev_err(arizona->dev, "Failed to read MICDET_ADCVAL: %d\n", ret);
740 		return ret;
741 	}
742 
743 	dev_dbg(arizona->dev, "MICDET_ADCVAL: %x\n", val);
744 
745 	val &= ARIZONA_MICDET_ADCVAL_MASK;
746 	if (val < ARRAY_SIZE(arizona_micd_levels))
747 		val = arizona_micd_levels[val];
748 	else
749 		val = INT_MAX;
750 
751 	if (val <= QUICK_HEADPHONE_MAX_OHM)
752 		val = ARIZONA_MICD_STS | ARIZONA_MICD_LVL_0;
753 	else if (val <= MICROPHONE_MIN_OHM)
754 		val = ARIZONA_MICD_STS | ARIZONA_MICD_LVL_1;
755 	else if (val <= MICROPHONE_MAX_OHM)
756 		val = ARIZONA_MICD_STS | ARIZONA_MICD_LVL_8;
757 	else
758 		val = ARIZONA_MICD_LVL_8;
759 
760 	return val;
761 }
762 
arizona_micd_read(struct arizona_priv * info)763 static int arizona_micd_read(struct arizona_priv *info)
764 {
765 	struct arizona *arizona = info->arizona;
766 	unsigned int val = 0;
767 	int ret, i;
768 
769 	for (i = 0; i < 10 && !(val & MICD_LVL_0_TO_8); i++) {
770 		ret = regmap_read(arizona->regmap, ARIZONA_MIC_DETECT_3, &val);
771 		if (ret) {
772 			dev_err(arizona->dev, "Failed to read MICDET: %d\n", ret);
773 			return ret;
774 		}
775 
776 		dev_dbg(arizona->dev, "MICDET: %x\n", val);
777 
778 		if (!(val & ARIZONA_MICD_VALID)) {
779 			dev_warn(arizona->dev, "Microphone detection state invalid\n");
780 			return -EINVAL;
781 		}
782 	}
783 
784 	if (i == 10 && !(val & MICD_LVL_0_TO_8)) {
785 		dev_err(arizona->dev, "Failed to get valid MICDET value\n");
786 		return -EINVAL;
787 	}
788 
789 	return val;
790 }
791 
arizona_micdet_reading(void * priv)792 static int arizona_micdet_reading(void *priv)
793 {
794 	struct arizona_priv *info = priv;
795 	struct arizona *arizona = info->arizona;
796 	int ret, val;
797 
798 	if (info->detecting && arizona->pdata.micd_software_compare)
799 		ret = arizona_micd_adc_read(info);
800 	else
801 		ret = arizona_micd_read(info);
802 	if (ret < 0)
803 		return ret;
804 
805 	val = ret;
806 
807 	/* Due to jack detect this should never happen */
808 	if (!(val & ARIZONA_MICD_STS)) {
809 		dev_warn(arizona->dev, "Detected open circuit\n");
810 		info->mic = false;
811 		info->detecting = false;
812 		arizona_identify_headphone(info);
813 		return 0;
814 	}
815 
816 	/* If we got a high impedence we should have a headset, report it. */
817 	if (val & ARIZONA_MICD_LVL_8) {
818 		info->mic = true;
819 		info->detecting = false;
820 
821 		arizona_identify_headphone(info);
822 
823 		snd_soc_jack_report(info->jack, SND_JACK_MICROPHONE, SND_JACK_MICROPHONE);
824 
825 		/* Don't need to regulate for button detection */
826 		ret = regulator_allow_bypass(info->micvdd, true);
827 		if (ret)
828 			dev_err(arizona->dev, "Failed to bypass MICVDD: %d\n", ret);
829 
830 		return 0;
831 	}
832 
833 	/* If we detected a lower impedence during initial startup
834 	 * then we probably have the wrong polarity, flip it.  Don't
835 	 * do this for the lowest impedences to speed up detection of
836 	 * plain headphones.  If both polarities report a low
837 	 * impedence then give up and report headphones.
838 	 */
839 	if (val & MICD_LVL_1_TO_7) {
840 		if (info->jack_flips >= info->micd_num_modes * 10) {
841 			dev_dbg(arizona->dev, "Detected HP/line\n");
842 
843 			info->detecting = false;
844 
845 			arizona_identify_headphone(info);
846 		} else {
847 			info->micd_mode++;
848 			if (info->micd_mode == info->micd_num_modes)
849 				info->micd_mode = 0;
850 			arizona_extcon_set_mode(info, info->micd_mode);
851 
852 			info->jack_flips++;
853 
854 			if (arizona->pdata.micd_software_compare)
855 				regmap_update_bits(arizona->regmap,
856 						   ARIZONA_MIC_DETECT_1,
857 						   ARIZONA_MICD_ENA,
858 						   ARIZONA_MICD_ENA);
859 
860 			queue_delayed_work(system_power_efficient_wq,
861 					   &info->micd_timeout_work,
862 					   msecs_to_jiffies(arizona->pdata.micd_timeout));
863 		}
864 
865 		return 0;
866 	}
867 
868 	/*
869 	 * If we're still detecting and we detect a short then we've
870 	 * got a headphone.
871 	 */
872 	dev_dbg(arizona->dev, "Headphone detected\n");
873 	info->detecting = false;
874 
875 	arizona_identify_headphone(info);
876 
877 	return 0;
878 }
879 
arizona_button_reading(void * priv)880 static int arizona_button_reading(void *priv)
881 {
882 	struct arizona_priv *info = priv;
883 	struct arizona *arizona = info->arizona;
884 	int val, key, lvl;
885 
886 	val = arizona_micd_read(info);
887 	if (val < 0)
888 		return val;
889 
890 	/*
891 	 * If we're still detecting and we detect a short then we've
892 	 * got a headphone.  Otherwise it's a button press.
893 	 */
894 	if (val & MICD_LVL_0_TO_7) {
895 		if (info->mic) {
896 			dev_dbg(arizona->dev, "Mic button detected\n");
897 
898 			lvl = val & ARIZONA_MICD_LVL_MASK;
899 			lvl >>= ARIZONA_MICD_LVL_SHIFT;
900 
901 			if (lvl && ffs(lvl) - 1 < info->num_micd_ranges) {
902 				key = ffs(lvl) - 1;
903 				snd_soc_jack_report(info->jack,
904 						    SND_JACK_BTN_0 >> key,
905 						    info->micd_button_mask);
906 			} else {
907 				dev_err(arizona->dev, "Button out of range\n");
908 			}
909 		} else {
910 			dev_warn(arizona->dev, "Button with no mic: %x\n", val);
911 		}
912 	} else {
913 		dev_dbg(arizona->dev, "Mic button released\n");
914 		snd_soc_jack_report(info->jack, 0, info->micd_button_mask);
915 		arizona_extcon_pulse_micbias(info);
916 	}
917 
918 	return 0;
919 }
920 
arizona_micd_detect(struct work_struct * work)921 static void arizona_micd_detect(struct work_struct *work)
922 {
923 	struct arizona_priv *info = container_of(work,
924 						struct arizona_priv,
925 						micd_detect_work.work);
926 	struct arizona *arizona = info->arizona;
927 
928 	cancel_delayed_work_sync(&info->micd_timeout_work);
929 
930 	mutex_lock(&info->lock);
931 
932 	/* If the cable was removed while measuring ignore the result */
933 	if (!(info->jack->status & SND_JACK_MECHANICAL)) {
934 		dev_dbg(arizona->dev, "Ignoring MICDET for removed cable\n");
935 		mutex_unlock(&info->lock);
936 		return;
937 	}
938 
939 	if (info->detecting)
940 		arizona_micdet_reading(info);
941 	else
942 		arizona_button_reading(info);
943 
944 	pm_runtime_mark_last_busy(arizona->dev);
945 	mutex_unlock(&info->lock);
946 }
947 
arizona_micdet(int irq,void * data)948 static irqreturn_t arizona_micdet(int irq, void *data)
949 {
950 	struct arizona_priv *info = data;
951 	struct arizona *arizona = info->arizona;
952 	int debounce = arizona->pdata.micd_detect_debounce;
953 
954 	cancel_delayed_work_sync(&info->micd_detect_work);
955 	cancel_delayed_work_sync(&info->micd_timeout_work);
956 
957 	mutex_lock(&info->lock);
958 	if (!info->detecting)
959 		debounce = 0;
960 	mutex_unlock(&info->lock);
961 
962 	if (debounce)
963 		queue_delayed_work(system_power_efficient_wq,
964 				   &info->micd_detect_work,
965 				   msecs_to_jiffies(debounce));
966 	else
967 		arizona_micd_detect(&info->micd_detect_work.work);
968 
969 	return IRQ_HANDLED;
970 }
971 
arizona_hpdet_work(struct work_struct * work)972 static void arizona_hpdet_work(struct work_struct *work)
973 {
974 	struct arizona_priv *info = container_of(work,
975 						struct arizona_priv,
976 						hpdet_work.work);
977 
978 	mutex_lock(&info->lock);
979 	arizona_start_hpdet_acc_id(info);
980 	mutex_unlock(&info->lock);
981 }
982 
arizona_hpdet_wait(struct arizona_priv * info)983 static int arizona_hpdet_wait(struct arizona_priv *info)
984 {
985 	struct arizona *arizona = info->arizona;
986 	unsigned int val;
987 	int i, ret;
988 
989 	for (i = 0; i < ARIZONA_HPDET_WAIT_COUNT; i++) {
990 		ret = regmap_read(arizona->regmap, ARIZONA_HEADPHONE_DETECT_2,
991 				&val);
992 		if (ret) {
993 			dev_err(arizona->dev, "Failed to read HPDET state: %d\n", ret);
994 			return ret;
995 		}
996 
997 		switch (info->hpdet_ip_version) {
998 		case 0:
999 			if (val & ARIZONA_HP_DONE)
1000 				return 0;
1001 			break;
1002 		default:
1003 			if (val & ARIZONA_HP_DONE_B)
1004 				return 0;
1005 			break;
1006 		}
1007 
1008 		msleep(ARIZONA_HPDET_WAIT_DELAY_MS);
1009 	}
1010 
1011 	dev_warn(arizona->dev, "HPDET did not appear to complete\n");
1012 
1013 	return -ETIMEDOUT;
1014 }
1015 
arizona_jackdet(int irq,void * data)1016 static irqreturn_t arizona_jackdet(int irq, void *data)
1017 {
1018 	struct arizona_priv *info = data;
1019 	struct arizona *arizona = info->arizona;
1020 	unsigned int val, present, mask;
1021 	bool cancelled_hp, cancelled_mic;
1022 	int ret, i;
1023 
1024 	cancelled_hp = cancel_delayed_work_sync(&info->hpdet_work);
1025 	cancelled_mic = cancel_delayed_work_sync(&info->micd_timeout_work);
1026 
1027 	pm_runtime_get_sync(arizona->dev);
1028 
1029 	mutex_lock(&info->lock);
1030 
1031 	if (info->micd_clamp) {
1032 		mask = ARIZONA_MICD_CLAMP_STS;
1033 		present = 0;
1034 	} else {
1035 		mask = ARIZONA_JD1_STS;
1036 		if (arizona->pdata.jd_invert)
1037 			present = 0;
1038 		else
1039 			present = ARIZONA_JD1_STS;
1040 	}
1041 
1042 	ret = regmap_read(arizona->regmap, ARIZONA_AOD_IRQ_RAW_STATUS, &val);
1043 	if (ret) {
1044 		dev_err(arizona->dev, "Failed to read jackdet status: %d\n", ret);
1045 		mutex_unlock(&info->lock);
1046 		pm_runtime_put_autosuspend(arizona->dev);
1047 		return IRQ_NONE;
1048 	}
1049 
1050 	val &= mask;
1051 	if (val == info->last_jackdet) {
1052 		dev_dbg(arizona->dev, "Suppressing duplicate JACKDET\n");
1053 		if (cancelled_hp)
1054 			queue_delayed_work(system_power_efficient_wq,
1055 					   &info->hpdet_work,
1056 					   msecs_to_jiffies(HPDET_DEBOUNCE));
1057 
1058 		if (cancelled_mic) {
1059 			int micd_timeout = arizona->pdata.micd_timeout;
1060 
1061 			queue_delayed_work(system_power_efficient_wq,
1062 					   &info->micd_timeout_work,
1063 					   msecs_to_jiffies(micd_timeout));
1064 		}
1065 
1066 		goto out;
1067 	}
1068 	info->last_jackdet = val;
1069 
1070 	if (info->last_jackdet == present) {
1071 		dev_dbg(arizona->dev, "Detected jack\n");
1072 		snd_soc_jack_report(info->jack, SND_JACK_MECHANICAL, SND_JACK_MECHANICAL);
1073 
1074 		info->detecting = true;
1075 		info->mic = false;
1076 		info->jack_flips = 0;
1077 
1078 		if (!arizona->pdata.hpdet_acc_id) {
1079 			arizona_start_mic(info);
1080 		} else {
1081 			queue_delayed_work(system_power_efficient_wq,
1082 					   &info->hpdet_work,
1083 					   msecs_to_jiffies(HPDET_DEBOUNCE));
1084 		}
1085 
1086 		if (info->micd_clamp || !arizona->pdata.jd_invert)
1087 			regmap_update_bits(arizona->regmap,
1088 					   ARIZONA_JACK_DETECT_DEBOUNCE,
1089 					   ARIZONA_MICD_CLAMP_DB |
1090 					   ARIZONA_JD1_DB, 0);
1091 	} else {
1092 		dev_dbg(arizona->dev, "Detected jack removal\n");
1093 
1094 		arizona_stop_mic(info);
1095 
1096 		info->num_hpdet_res = 0;
1097 		for (i = 0; i < ARRAY_SIZE(info->hpdet_res); i++)
1098 			info->hpdet_res[i] = 0;
1099 		info->mic = false;
1100 		info->hpdet_done = false;
1101 		info->hpdet_retried = false;
1102 
1103 		snd_soc_jack_report(info->jack, 0, ARIZONA_JACK_MASK | info->micd_button_mask);
1104 
1105 		/*
1106 		 * If the jack was removed during a headphone detection we
1107 		 * need to wait for the headphone detection to finish, as
1108 		 * it can not be aborted. We don't want to be able to start
1109 		 * a new headphone detection from a fresh insert until this
1110 		 * one is finished.
1111 		 */
1112 		arizona_hpdet_wait(info);
1113 
1114 		regmap_update_bits(arizona->regmap,
1115 				   ARIZONA_JACK_DETECT_DEBOUNCE,
1116 				   ARIZONA_MICD_CLAMP_DB | ARIZONA_JD1_DB,
1117 				   ARIZONA_MICD_CLAMP_DB | ARIZONA_JD1_DB);
1118 	}
1119 
1120 out:
1121 	/* Clear trig_sts to make sure DCVDD is not forced up */
1122 	regmap_write(arizona->regmap, ARIZONA_AOD_WKUP_AND_TRIG,
1123 		     ARIZONA_MICD_CLAMP_FALL_TRIG_STS |
1124 		     ARIZONA_MICD_CLAMP_RISE_TRIG_STS |
1125 		     ARIZONA_JD1_FALL_TRIG_STS |
1126 		     ARIZONA_JD1_RISE_TRIG_STS);
1127 
1128 	mutex_unlock(&info->lock);
1129 
1130 	pm_runtime_mark_last_busy(arizona->dev);
1131 	pm_runtime_put_autosuspend(arizona->dev);
1132 
1133 	return IRQ_HANDLED;
1134 }
1135 
1136 /* Map a level onto a slot in the register bank */
arizona_micd_set_level(struct arizona * arizona,int index,unsigned int level)1137 static void arizona_micd_set_level(struct arizona *arizona, int index,
1138 				   unsigned int level)
1139 {
1140 	int reg;
1141 	unsigned int mask;
1142 
1143 	reg = ARIZONA_MIC_DETECT_LEVEL_4 - (index / 2);
1144 
1145 	if (!(index % 2)) {
1146 		mask = 0x3f00;
1147 		level <<= 8;
1148 	} else {
1149 		mask = 0x3f;
1150 	}
1151 
1152 	/* Program the level itself */
1153 	regmap_update_bits(arizona->regmap, reg, mask, level);
1154 }
1155 
arizona_extcon_get_micd_configs(struct device * dev,struct arizona * arizona)1156 static int arizona_extcon_get_micd_configs(struct device *dev,
1157 					   struct arizona *arizona)
1158 {
1159 	const char * const prop = "wlf,micd-configs";
1160 	const int entries_per_config = 3;
1161 	struct arizona_micd_config *micd_configs;
1162 	int nconfs, ret;
1163 	int i, j;
1164 	u32 *vals;
1165 
1166 	nconfs = device_property_count_u32(arizona->dev, prop);
1167 	if (nconfs <= 0)
1168 		return 0;
1169 
1170 	vals = kcalloc(nconfs, sizeof(u32), GFP_KERNEL);
1171 	if (!vals)
1172 		return -ENOMEM;
1173 
1174 	ret = device_property_read_u32_array(arizona->dev, prop, vals, nconfs);
1175 	if (ret < 0)
1176 		goto out;
1177 
1178 	nconfs /= entries_per_config;
1179 	micd_configs = devm_kcalloc(dev, nconfs, sizeof(*micd_configs),
1180 				    GFP_KERNEL);
1181 	if (!micd_configs) {
1182 		ret = -ENOMEM;
1183 		goto out;
1184 	}
1185 
1186 	for (i = 0, j = 0; i < nconfs; ++i) {
1187 		micd_configs[i].src = vals[j++] ? ARIZONA_ACCDET_SRC : 0;
1188 		micd_configs[i].bias = vals[j++];
1189 		micd_configs[i].gpio = vals[j++];
1190 	}
1191 
1192 	arizona->pdata.micd_configs = micd_configs;
1193 	arizona->pdata.num_micd_configs = nconfs;
1194 
1195 out:
1196 	kfree(vals);
1197 	return ret;
1198 }
1199 
arizona_extcon_device_get_pdata(struct device * dev,struct arizona * arizona)1200 static int arizona_extcon_device_get_pdata(struct device *dev,
1201 					   struct arizona *arizona)
1202 {
1203 	struct arizona_pdata *pdata = &arizona->pdata;
1204 	unsigned int val = ARIZONA_ACCDET_MODE_HPL;
1205 	int ret;
1206 
1207 	device_property_read_u32(arizona->dev, "wlf,hpdet-channel", &val);
1208 	switch (val) {
1209 	case ARIZONA_ACCDET_MODE_HPL:
1210 	case ARIZONA_ACCDET_MODE_HPR:
1211 		pdata->hpdet_channel = val;
1212 		break;
1213 	default:
1214 		dev_err(arizona->dev, "Wrong wlf,hpdet-channel DT value %d\n", val);
1215 		pdata->hpdet_channel = ARIZONA_ACCDET_MODE_HPL;
1216 	}
1217 
1218 	device_property_read_u32(arizona->dev, "wlf,micd-detect-debounce",
1219 				 &pdata->micd_detect_debounce);
1220 
1221 	device_property_read_u32(arizona->dev, "wlf,micd-bias-start-time",
1222 				 &pdata->micd_bias_start_time);
1223 
1224 	device_property_read_u32(arizona->dev, "wlf,micd-rate",
1225 				 &pdata->micd_rate);
1226 
1227 	device_property_read_u32(arizona->dev, "wlf,micd-dbtime",
1228 				 &pdata->micd_dbtime);
1229 
1230 	device_property_read_u32(arizona->dev, "wlf,micd-timeout-ms",
1231 				 &pdata->micd_timeout);
1232 
1233 	pdata->micd_force_micbias = device_property_read_bool(arizona->dev,
1234 						"wlf,micd-force-micbias");
1235 
1236 	pdata->micd_software_compare = device_property_read_bool(arizona->dev,
1237 						"wlf,micd-software-compare");
1238 
1239 	pdata->jd_invert = device_property_read_bool(arizona->dev,
1240 						     "wlf,jd-invert");
1241 
1242 	device_property_read_u32(arizona->dev, "wlf,gpsw", &pdata->gpsw);
1243 
1244 	pdata->jd_gpio5 = device_property_read_bool(arizona->dev,
1245 						    "wlf,use-jd2");
1246 	pdata->jd_gpio5_nopull = device_property_read_bool(arizona->dev,
1247 						"wlf,use-jd2-nopull");
1248 
1249 	ret = arizona_extcon_get_micd_configs(dev, arizona);
1250 	if (ret < 0)
1251 		dev_err(arizona->dev, "Failed to read micd configs: %d\n", ret);
1252 
1253 	return 0;
1254 }
1255 
arizona_jack_codec_dev_probe(struct arizona_priv * info,struct device * dev)1256 int arizona_jack_codec_dev_probe(struct arizona_priv *info, struct device *dev)
1257 {
1258 	struct arizona *arizona = info->arizona;
1259 	struct arizona_pdata *pdata = &arizona->pdata;
1260 	int ret, mode;
1261 
1262 	if (!dev_get_platdata(arizona->dev))
1263 		arizona_extcon_device_get_pdata(dev, arizona);
1264 
1265 	info->micvdd = devm_regulator_get(dev, "MICVDD");
1266 	if (IS_ERR(info->micvdd))
1267 		return dev_err_probe(arizona->dev, PTR_ERR(info->micvdd), "getting MICVDD\n");
1268 
1269 	mutex_init(&info->lock);
1270 	info->last_jackdet = ~(ARIZONA_MICD_CLAMP_STS | ARIZONA_JD1_STS);
1271 	INIT_DELAYED_WORK(&info->hpdet_work, arizona_hpdet_work);
1272 	INIT_DELAYED_WORK(&info->micd_detect_work, arizona_micd_detect);
1273 	INIT_DELAYED_WORK(&info->micd_timeout_work, arizona_micd_timeout_work);
1274 
1275 	switch (arizona->type) {
1276 	case WM5102:
1277 		switch (arizona->rev) {
1278 		case 0:
1279 			info->micd_reva = true;
1280 			break;
1281 		default:
1282 			info->micd_clamp = true;
1283 			info->hpdet_ip_version = 1;
1284 			break;
1285 		}
1286 		break;
1287 	case WM5110:
1288 	case WM8280:
1289 		switch (arizona->rev) {
1290 		case 0 ... 2:
1291 			break;
1292 		default:
1293 			info->micd_clamp = true;
1294 			info->hpdet_ip_version = 2;
1295 			break;
1296 		}
1297 		break;
1298 	case WM8998:
1299 	case WM1814:
1300 		info->micd_clamp = true;
1301 		info->hpdet_ip_version = 2;
1302 		break;
1303 	default:
1304 		break;
1305 	}
1306 
1307 	if (!pdata->micd_timeout)
1308 		pdata->micd_timeout = DEFAULT_MICD_TIMEOUT;
1309 
1310 	if (pdata->num_micd_configs) {
1311 		info->micd_modes = pdata->micd_configs;
1312 		info->micd_num_modes = pdata->num_micd_configs;
1313 	} else {
1314 		info->micd_modes = micd_default_modes;
1315 		info->micd_num_modes = ARRAY_SIZE(micd_default_modes);
1316 	}
1317 
1318 	if (arizona->pdata.gpsw > 0)
1319 		regmap_update_bits(arizona->regmap, ARIZONA_GP_SWITCH_1,
1320 				ARIZONA_SW1_MODE_MASK, arizona->pdata.gpsw);
1321 
1322 	if (pdata->micd_pol_gpio > 0) {
1323 		if (info->micd_modes[0].gpio)
1324 			mode = GPIOF_OUT_INIT_HIGH;
1325 		else
1326 			mode = GPIOF_OUT_INIT_LOW;
1327 
1328 		ret = devm_gpio_request_one(dev, pdata->micd_pol_gpio,
1329 					    mode, "MICD polarity");
1330 		if (ret != 0) {
1331 			dev_err(arizona->dev, "Failed to request GPIO%d: %d\n",
1332 				pdata->micd_pol_gpio, ret);
1333 			return ret;
1334 		}
1335 
1336 		info->micd_pol_gpio = gpio_to_desc(pdata->micd_pol_gpio);
1337 	} else {
1338 		if (info->micd_modes[0].gpio)
1339 			mode = GPIOD_OUT_HIGH;
1340 		else
1341 			mode = GPIOD_OUT_LOW;
1342 
1343 		/* We can't use devm here because we need to do the get
1344 		 * against the MFD device, as that is where the of_node
1345 		 * will reside, but if we devm against that the GPIO
1346 		 * will not be freed if the extcon driver is unloaded.
1347 		 */
1348 		info->micd_pol_gpio = gpiod_get_optional(arizona->dev,
1349 							 "wlf,micd-pol",
1350 							 mode);
1351 		if (IS_ERR(info->micd_pol_gpio)) {
1352 			ret = PTR_ERR(info->micd_pol_gpio);
1353 			dev_err_probe(arizona->dev, ret, "getting microphone polarity GPIO\n");
1354 			return ret;
1355 		}
1356 	}
1357 
1358 	if (arizona->pdata.hpdet_id_gpio > 0) {
1359 		ret = devm_gpio_request_one(dev, arizona->pdata.hpdet_id_gpio,
1360 					    GPIOF_OUT_INIT_LOW,
1361 					    "HPDET");
1362 		if (ret != 0) {
1363 			dev_err(arizona->dev, "Failed to request GPIO%d: %d\n",
1364 				arizona->pdata.hpdet_id_gpio, ret);
1365 			gpiod_put(info->micd_pol_gpio);
1366 			return ret;
1367 		}
1368 	}
1369 
1370 	return 0;
1371 }
1372 EXPORT_SYMBOL_GPL(arizona_jack_codec_dev_probe);
1373 
arizona_jack_codec_dev_remove(struct arizona_priv * info)1374 int arizona_jack_codec_dev_remove(struct arizona_priv *info)
1375 {
1376 	gpiod_put(info->micd_pol_gpio);
1377 	return 0;
1378 }
1379 EXPORT_SYMBOL_GPL(arizona_jack_codec_dev_remove);
1380 
arizona_jack_enable_jack_detect(struct arizona_priv * info,struct snd_soc_jack * jack)1381 static int arizona_jack_enable_jack_detect(struct arizona_priv *info,
1382 					   struct snd_soc_jack *jack)
1383 {
1384 	struct arizona *arizona = info->arizona;
1385 	struct arizona_pdata *pdata = &arizona->pdata;
1386 	unsigned int val;
1387 	unsigned int clamp_mode;
1388 	int jack_irq_fall, jack_irq_rise;
1389 	int ret, i, j;
1390 
1391 	if (arizona->pdata.micd_bias_start_time)
1392 		regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_1,
1393 				   ARIZONA_MICD_BIAS_STARTTIME_MASK,
1394 				   arizona->pdata.micd_bias_start_time
1395 				   << ARIZONA_MICD_BIAS_STARTTIME_SHIFT);
1396 
1397 	if (arizona->pdata.micd_rate)
1398 		regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_1,
1399 				   ARIZONA_MICD_RATE_MASK,
1400 				   arizona->pdata.micd_rate
1401 				   << ARIZONA_MICD_RATE_SHIFT);
1402 
1403 	switch (arizona->pdata.micd_dbtime) {
1404 	case MICD_DBTIME_FOUR_READINGS:
1405 		regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_1,
1406 				   ARIZONA_MICD_DBTIME_MASK,
1407 				   ARIZONA_MICD_DBTIME);
1408 		break;
1409 	case MICD_DBTIME_TWO_READINGS:
1410 		regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_1,
1411 				   ARIZONA_MICD_DBTIME_MASK, 0);
1412 		break;
1413 	default:
1414 		break;
1415 	}
1416 
1417 	BUILD_BUG_ON(ARRAY_SIZE(arizona_micd_levels) <
1418 		     ARIZONA_NUM_MICD_BUTTON_LEVELS);
1419 
1420 	if (arizona->pdata.num_micd_ranges) {
1421 		info->micd_ranges = pdata->micd_ranges;
1422 		info->num_micd_ranges = pdata->num_micd_ranges;
1423 	} else {
1424 		info->micd_ranges = micd_default_ranges;
1425 		info->num_micd_ranges = ARRAY_SIZE(micd_default_ranges);
1426 	}
1427 
1428 	if (arizona->pdata.num_micd_ranges > ARIZONA_MAX_MICD_BUTTONS) {
1429 		dev_err(arizona->dev, "Too many MICD ranges: %d > %d\n",
1430 			arizona->pdata.num_micd_ranges, ARIZONA_MAX_MICD_BUTTONS);
1431 		return -EINVAL;
1432 	}
1433 
1434 	if (info->num_micd_ranges > 1) {
1435 		for (i = 1; i < info->num_micd_ranges; i++) {
1436 			if (info->micd_ranges[i - 1].max >
1437 			    info->micd_ranges[i].max) {
1438 				dev_err(arizona->dev, "MICD ranges must be sorted\n");
1439 				return -EINVAL;
1440 			}
1441 		}
1442 	}
1443 
1444 	/* Disable all buttons by default */
1445 	regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_2,
1446 			   ARIZONA_MICD_LVL_SEL_MASK, 0x81);
1447 
1448 	/* Set up all the buttons the user specified */
1449 	for (i = 0; i < info->num_micd_ranges; i++) {
1450 		for (j = 0; j < ARIZONA_NUM_MICD_BUTTON_LEVELS; j++)
1451 			if (arizona_micd_levels[j] >= info->micd_ranges[i].max)
1452 				break;
1453 
1454 		if (j == ARIZONA_NUM_MICD_BUTTON_LEVELS) {
1455 			dev_err(arizona->dev, "Unsupported MICD level %d\n",
1456 				info->micd_ranges[i].max);
1457 			return -EINVAL;
1458 		}
1459 
1460 		dev_dbg(arizona->dev, "%d ohms for MICD threshold %d\n",
1461 			arizona_micd_levels[j], i);
1462 
1463 		arizona_micd_set_level(arizona, i, j);
1464 
1465 		/* SND_JACK_BTN_# masks start with the most significant bit */
1466 		info->micd_button_mask |= SND_JACK_BTN_0 >> i;
1467 		snd_jack_set_key(jack->jack, SND_JACK_BTN_0 >> i,
1468 				 info->micd_ranges[i].key);
1469 
1470 		/* Enable reporting of that range */
1471 		regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_2,
1472 				   1 << i, 1 << i);
1473 	}
1474 
1475 	/* Set all the remaining keys to a maximum */
1476 	for (; i < ARIZONA_MAX_MICD_RANGE; i++)
1477 		arizona_micd_set_level(arizona, i, 0x3f);
1478 
1479 	/*
1480 	 * If we have a clamp use it, activating in conjunction with
1481 	 * GPIO5 if that is connected for jack detect operation.
1482 	 */
1483 	if (info->micd_clamp) {
1484 		if (arizona->pdata.jd_gpio5) {
1485 			/* Put the GPIO into input mode with optional pull */
1486 			val = 0xc101;
1487 			if (arizona->pdata.jd_gpio5_nopull)
1488 				val &= ~ARIZONA_GPN_PU;
1489 
1490 			regmap_write(arizona->regmap, ARIZONA_GPIO5_CTRL,
1491 				     val);
1492 
1493 			if (arizona->pdata.jd_invert)
1494 				clamp_mode = ARIZONA_MICD_CLAMP_MODE_JDH_GP5H;
1495 			else
1496 				clamp_mode = ARIZONA_MICD_CLAMP_MODE_JDL_GP5H;
1497 		} else {
1498 			if (arizona->pdata.jd_invert)
1499 				clamp_mode = ARIZONA_MICD_CLAMP_MODE_JDH;
1500 			else
1501 				clamp_mode = ARIZONA_MICD_CLAMP_MODE_JDL;
1502 		}
1503 
1504 		regmap_update_bits(arizona->regmap,
1505 				   ARIZONA_MICD_CLAMP_CONTROL,
1506 				   ARIZONA_MICD_CLAMP_MODE_MASK, clamp_mode);
1507 
1508 		regmap_update_bits(arizona->regmap,
1509 				   ARIZONA_JACK_DETECT_DEBOUNCE,
1510 				   ARIZONA_MICD_CLAMP_DB,
1511 				   ARIZONA_MICD_CLAMP_DB);
1512 	}
1513 
1514 	arizona_extcon_set_mode(info, 0);
1515 
1516 	info->jack = jack;
1517 
1518 	pm_runtime_get_sync(arizona->dev);
1519 
1520 	if (info->micd_clamp) {
1521 		jack_irq_rise = ARIZONA_IRQ_MICD_CLAMP_RISE;
1522 		jack_irq_fall = ARIZONA_IRQ_MICD_CLAMP_FALL;
1523 	} else {
1524 		jack_irq_rise = ARIZONA_IRQ_JD_RISE;
1525 		jack_irq_fall = ARIZONA_IRQ_JD_FALL;
1526 	}
1527 
1528 	ret = arizona_request_irq(arizona, jack_irq_rise,
1529 				  "JACKDET rise", arizona_jackdet, info);
1530 	if (ret != 0) {
1531 		dev_err(arizona->dev, "Failed to get JACKDET rise IRQ: %d\n", ret);
1532 		goto err_pm;
1533 	}
1534 
1535 	ret = arizona_set_irq_wake(arizona, jack_irq_rise, 1);
1536 	if (ret != 0) {
1537 		dev_err(arizona->dev, "Failed to set JD rise IRQ wake: %d\n", ret);
1538 		goto err_rise;
1539 	}
1540 
1541 	ret = arizona_request_irq(arizona, jack_irq_fall,
1542 				  "JACKDET fall", arizona_jackdet, info);
1543 	if (ret != 0) {
1544 		dev_err(arizona->dev, "Failed to get JD fall IRQ: %d\n", ret);
1545 		goto err_rise_wake;
1546 	}
1547 
1548 	ret = arizona_set_irq_wake(arizona, jack_irq_fall, 1);
1549 	if (ret != 0) {
1550 		dev_err(arizona->dev, "Failed to set JD fall IRQ wake: %d\n", ret);
1551 		goto err_fall;
1552 	}
1553 
1554 	ret = arizona_request_irq(arizona, ARIZONA_IRQ_MICDET,
1555 				  "MICDET", arizona_micdet, info);
1556 	if (ret != 0) {
1557 		dev_err(arizona->dev, "Failed to get MICDET IRQ: %d\n", ret);
1558 		goto err_fall_wake;
1559 	}
1560 
1561 	ret = arizona_request_irq(arizona, ARIZONA_IRQ_HPDET,
1562 				  "HPDET", arizona_hpdet_irq, info);
1563 	if (ret != 0) {
1564 		dev_err(arizona->dev, "Failed to get HPDET IRQ: %d\n", ret);
1565 		goto err_micdet;
1566 	}
1567 
1568 	arizona_clk32k_enable(arizona);
1569 	regmap_update_bits(arizona->regmap, ARIZONA_JACK_DETECT_DEBOUNCE,
1570 			   ARIZONA_JD1_DB, ARIZONA_JD1_DB);
1571 	regmap_update_bits(arizona->regmap, ARIZONA_JACK_DETECT_ANALOGUE,
1572 			   ARIZONA_JD1_ENA, ARIZONA_JD1_ENA);
1573 
1574 	ret = regulator_allow_bypass(info->micvdd, true);
1575 	if (ret != 0)
1576 		dev_warn(arizona->dev, "Failed to set MICVDD to bypass: %d\n", ret);
1577 
1578 	pm_runtime_put(arizona->dev);
1579 
1580 	return 0;
1581 
1582 err_micdet:
1583 	arizona_free_irq(arizona, ARIZONA_IRQ_MICDET, info);
1584 err_fall_wake:
1585 	arizona_set_irq_wake(arizona, jack_irq_fall, 0);
1586 err_fall:
1587 	arizona_free_irq(arizona, jack_irq_fall, info);
1588 err_rise_wake:
1589 	arizona_set_irq_wake(arizona, jack_irq_rise, 0);
1590 err_rise:
1591 	arizona_free_irq(arizona, jack_irq_rise, info);
1592 err_pm:
1593 	pm_runtime_put(arizona->dev);
1594 	info->jack = NULL;
1595 	return ret;
1596 }
1597 
arizona_jack_disable_jack_detect(struct arizona_priv * info)1598 static int arizona_jack_disable_jack_detect(struct arizona_priv *info)
1599 {
1600 	struct arizona *arizona = info->arizona;
1601 	int jack_irq_rise, jack_irq_fall;
1602 	bool change;
1603 	int ret;
1604 
1605 	if (!info->jack)
1606 		return 0;
1607 
1608 	if (info->micd_clamp) {
1609 		jack_irq_rise = ARIZONA_IRQ_MICD_CLAMP_RISE;
1610 		jack_irq_fall = ARIZONA_IRQ_MICD_CLAMP_FALL;
1611 	} else {
1612 		jack_irq_rise = ARIZONA_IRQ_JD_RISE;
1613 		jack_irq_fall = ARIZONA_IRQ_JD_FALL;
1614 	}
1615 
1616 	arizona_set_irq_wake(arizona, jack_irq_rise, 0);
1617 	arizona_set_irq_wake(arizona, jack_irq_fall, 0);
1618 	arizona_free_irq(arizona, ARIZONA_IRQ_HPDET, info);
1619 	arizona_free_irq(arizona, ARIZONA_IRQ_MICDET, info);
1620 	arizona_free_irq(arizona, jack_irq_rise, info);
1621 	arizona_free_irq(arizona, jack_irq_fall, info);
1622 	cancel_delayed_work_sync(&info->hpdet_work);
1623 	cancel_delayed_work_sync(&info->micd_detect_work);
1624 	cancel_delayed_work_sync(&info->micd_timeout_work);
1625 
1626 	ret = regmap_update_bits_check(arizona->regmap, ARIZONA_MIC_DETECT_1,
1627 				       ARIZONA_MICD_ENA, 0,
1628 				       &change);
1629 	if (ret < 0) {
1630 		dev_err(arizona->dev, "Failed to disable micd on remove: %d\n", ret);
1631 	} else if (change) {
1632 		regulator_disable(info->micvdd);
1633 		pm_runtime_put(arizona->dev);
1634 	}
1635 
1636 	regmap_update_bits(arizona->regmap,
1637 			   ARIZONA_MICD_CLAMP_CONTROL,
1638 			   ARIZONA_MICD_CLAMP_MODE_MASK, 0);
1639 	regmap_update_bits(arizona->regmap, ARIZONA_JACK_DETECT_ANALOGUE,
1640 			   ARIZONA_JD1_ENA, 0);
1641 	arizona_clk32k_disable(arizona);
1642 	info->jack = NULL;
1643 
1644 	return 0;
1645 }
1646 
arizona_jack_set_jack(struct snd_soc_component * component,struct snd_soc_jack * jack,void * data)1647 int arizona_jack_set_jack(struct snd_soc_component *component,
1648 			  struct snd_soc_jack *jack, void *data)
1649 {
1650 	struct arizona_priv *info = snd_soc_component_get_drvdata(component);
1651 
1652 	if (jack)
1653 		return arizona_jack_enable_jack_detect(info, jack);
1654 	else
1655 		return arizona_jack_disable_jack_detect(info);
1656 }
1657 EXPORT_SYMBOL_GPL(arizona_jack_set_jack);
1658