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