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