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