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