?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
gpio: rcar: Fix runtime PM imbalance on error
[linux/fpc-iii.git] / drivers / extcon / extcon-arizona.c
blob7401733db08bb7a8fbc77bfcd0c9dfdde95a1def
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
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
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
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
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
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
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
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
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
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;
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 ret = extcon_get_state(info->edev, EXTCON_MECHANICAL);
618 if (ret < 0) {
619 dev_err(arizona->dev, "Failed to check cable state: %d\n",
620 ret);
621 goto out;
622 } else if (!ret) {
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 /* If we have a mic then reenable MICDET */
670 if (mic || info->mic)
671 arizona_start_mic(info);
672
673 if (info->hpdet_active) {
674 pm_runtime_put_autosuspend(info->dev);
675 info->hpdet_active = false;
676 }
677
678 info->hpdet_done = true;
679
680 out:
681 mutex_unlock(&info->lock);
682
683 return IRQ_HANDLED;
684 }
685
686 static void arizona_identify_headphone(struct arizona_extcon_info *info)
687 {
688 struct arizona *arizona = info->arizona;
689 int ret;
690
691 if (info->hpdet_done)
692 return;
693
694 dev_dbg(arizona->dev, "Starting HPDET\n");
695
696 /* Make sure we keep the device enabled during the measurement */
697 pm_runtime_get(info->dev);
698
699 info->hpdet_active = true;
700
701 arizona_stop_mic(info);
702
703 arizona_extcon_hp_clamp(info, true);
704
705 ret = regmap_update_bits(arizona->regmap,
706 ARIZONA_ACCESSORY_DETECT_MODE_1,
707 ARIZONA_ACCDET_MODE_MASK,
708 arizona->pdata.hpdet_channel);
709 if (ret != 0) {
710 dev_err(arizona->dev, "Failed to set HPDET mode: %d\n", ret);
711 goto err;
712 }
713
714 ret = regmap_update_bits(arizona->regmap, ARIZONA_HEADPHONE_DETECT_1,
715 ARIZONA_HP_POLL, ARIZONA_HP_POLL);
716 if (ret != 0) {
717 dev_err(arizona->dev, "Can't start HPDETL measurement: %d\n",
718 ret);
719 goto err;
720 }
721
722 return;
723
724 err:
725 arizona_extcon_hp_clamp(info, false);
726 pm_runtime_put_autosuspend(info->dev);
727
728 /* Just report headphone */
729 ret = extcon_set_state_sync(info->edev, EXTCON_JACK_HEADPHONE, true);
730 if (ret != 0)
731 dev_err(arizona->dev, "Failed to report headphone: %d\n", ret);
732
733 if (info->mic)
734 arizona_start_mic(info);
735
736 info->hpdet_active = false;
737 }
738
739 static void arizona_start_hpdet_acc_id(struct arizona_extcon_info *info)
740 {
741 struct arizona *arizona = info->arizona;
742 int hp_reading = 32;
743 bool mic;
744 int ret;
745
746 dev_dbg(arizona->dev, "Starting identification via HPDET\n");
747
748 /* Make sure we keep the device enabled during the measurement */
749 pm_runtime_get_sync(info->dev);
750
751 info->hpdet_active = true;
752
753 arizona_extcon_hp_clamp(info, true);
754
755 ret = regmap_update_bits(arizona->regmap,
756 ARIZONA_ACCESSORY_DETECT_MODE_1,
757 ARIZONA_ACCDET_SRC | ARIZONA_ACCDET_MODE_MASK,
758 info->micd_modes[0].src |
759 arizona->pdata.hpdet_channel);
760 if (ret != 0) {
761 dev_err(arizona->dev, "Failed to set HPDET mode: %d\n", ret);
762 goto err;
763 }
764
765 if (arizona->pdata.hpdet_acc_id_line) {
766 ret = regmap_update_bits(arizona->regmap,
767 ARIZONA_HEADPHONE_DETECT_1,
768 ARIZONA_HP_POLL, ARIZONA_HP_POLL);
769 if (ret != 0) {
770 dev_err(arizona->dev,
771 "Can't start HPDETL measurement: %d\n",
772 ret);
773 goto err;
774 }
775 } else {
776 arizona_hpdet_do_id(info, &hp_reading, &mic);
777 }
778
779 return;
780
781 err:
782 /* Just report headphone */
783 ret = extcon_set_state_sync(info->edev, EXTCON_JACK_HEADPHONE, true);
784 if (ret != 0)
785 dev_err(arizona->dev, "Failed to report headphone: %d\n", ret);
786
787 info->hpdet_active = false;
788 }
789
790 static void arizona_micd_timeout_work(struct work_struct *work)
791 {
792 struct arizona_extcon_info *info = container_of(work,
793 struct arizona_extcon_info,
794 micd_timeout_work.work);
795
796 mutex_lock(&info->lock);
797
798 dev_dbg(info->arizona->dev, "MICD timed out, reporting HP\n");
799
800 info->detecting = false;
801
802 arizona_identify_headphone(info);
803
804 mutex_unlock(&info->lock);
805 }
806
807 static int arizona_micd_adc_read(struct arizona_extcon_info *info)
808 {
809 struct arizona *arizona = info->arizona;
810 unsigned int val;
811 int ret;
812
813 /* Must disable MICD before we read the ADCVAL */
814 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_1,
815 ARIZONA_MICD_ENA, 0);
816
817 ret = regmap_read(arizona->regmap, ARIZONA_MIC_DETECT_4, &val);
818 if (ret != 0) {
819 dev_err(arizona->dev,
820 "Failed to read MICDET_ADCVAL: %d\n", ret);
821 return ret;
822 }
823
824 dev_dbg(arizona->dev, "MICDET_ADCVAL: %x\n", val);
825
826 val &= ARIZONA_MICDET_ADCVAL_MASK;
827 if (val < ARRAY_SIZE(arizona_micd_levels))
828 val = arizona_micd_levels[val];
829 else
830 val = INT_MAX;
831
832 if (val <= QUICK_HEADPHONE_MAX_OHM)
833 val = ARIZONA_MICD_STS | ARIZONA_MICD_LVL_0;
834 else if (val <= MICROPHONE_MIN_OHM)
835 val = ARIZONA_MICD_STS | ARIZONA_MICD_LVL_1;
836 else if (val <= MICROPHONE_MAX_OHM)
837 val = ARIZONA_MICD_STS | ARIZONA_MICD_LVL_8;
838 else
839 val = ARIZONA_MICD_LVL_8;
840
841 return val;
842 }
843
844 static int arizona_micd_read(struct arizona_extcon_info *info)
845 {
846 struct arizona *arizona = info->arizona;
847 unsigned int val = 0;
848 int ret, i;
849
850 for (i = 0; i < 10 && !(val & MICD_LVL_0_TO_8); i++) {
851 ret = regmap_read(arizona->regmap, ARIZONA_MIC_DETECT_3, &val);
852 if (ret != 0) {
853 dev_err(arizona->dev,
854 "Failed to read MICDET: %d\n", ret);
855 return ret;
856 }
857
858 dev_dbg(arizona->dev, "MICDET: %x\n", val);
859
860 if (!(val & ARIZONA_MICD_VALID)) {
861 dev_warn(arizona->dev,
862 "Microphone detection state invalid\n");
863 return -EINVAL;
864 }
865 }
866
867 if (i == 10 && !(val & MICD_LVL_0_TO_8)) {
868 dev_err(arizona->dev, "Failed to get valid MICDET value\n");
869 return -EINVAL;
870 }
871
872 return val;
873 }
874
875 static int arizona_micdet_reading(void *priv)
876 {
877 struct arizona_extcon_info *info = priv;
878 struct arizona *arizona = info->arizona;
879 int ret, val;
880
881 if (info->detecting && arizona->pdata.micd_software_compare)
882 ret = arizona_micd_adc_read(info);
883 else
884 ret = arizona_micd_read(info);
885 if (ret < 0)
886 return ret;
887
888 val = ret;
889
890 /* Due to jack detect this should never happen */
891 if (!(val & ARIZONA_MICD_STS)) {
892 dev_warn(arizona->dev, "Detected open circuit\n");
893 info->mic = false;
894 info->detecting = false;
895 arizona_identify_headphone(info);
896 return 0;
897 }
898
899 /* If we got a high impedence we should have a headset, report it. */
900 if (val & ARIZONA_MICD_LVL_8) {
901 info->mic = true;
902 info->detecting = false;
903
904 arizona_identify_headphone(info);
905
906 ret = extcon_set_state_sync(info->edev,
907 EXTCON_JACK_MICROPHONE, true);
908 if (ret != 0)
909 dev_err(arizona->dev, "Headset report failed: %d\n",
910 ret);
911
912 /* Don't need to regulate for button detection */
913 ret = regulator_allow_bypass(info->micvdd, true);
914 if (ret != 0) {
915 dev_err(arizona->dev, "Failed to bypass MICVDD: %d\n",
916 ret);
917 }
918
919 return 0;
920 }
921
922 /* If we detected a lower impedence during initial startup
923 * then we probably have the wrong polarity, flip it. Don't
924 * do this for the lowest impedences to speed up detection of
925 * plain headphones. If both polarities report a low
926 * impedence then give up and report headphones.
927 */
928 if (val & MICD_LVL_1_TO_7) {
929 if (info->jack_flips >= info->micd_num_modes * 10) {
930 dev_dbg(arizona->dev, "Detected HP/line\n");
931
932 info->detecting = false;
933
934 arizona_identify_headphone(info);
935 } else {
936 info->micd_mode++;
937 if (info->micd_mode == info->micd_num_modes)
938 info->micd_mode = 0;
939 arizona_extcon_set_mode(info, info->micd_mode);
940
941 info->jack_flips++;
942
943 if (arizona->pdata.micd_software_compare)
944 regmap_update_bits(arizona->regmap,
945 ARIZONA_MIC_DETECT_1,
946 ARIZONA_MICD_ENA,
947 ARIZONA_MICD_ENA);
948
949 queue_delayed_work(system_power_efficient_wq,
950 &info->micd_timeout_work,
951 msecs_to_jiffies(arizona->pdata.micd_timeout));
952 }
953
954 return 0;
955 }
956
957 /*
958 * If we're still detecting and we detect a short then we've
959 * got a headphone.
960 */
961 dev_dbg(arizona->dev, "Headphone detected\n");
962 info->detecting = false;
963
964 arizona_identify_headphone(info);
965
966 return 0;
967 }
968
969 static int arizona_button_reading(void *priv)
970 {
971 struct arizona_extcon_info *info = priv;
972 struct arizona *arizona = info->arizona;
973 int val, key, lvl, i;
974
975 val = arizona_micd_read(info);
976 if (val < 0)
977 return val;
978
979 /*
980 * If we're still detecting and we detect a short then we've
981 * got a headphone. Otherwise it's a button press.
982 */
983 if (val & MICD_LVL_0_TO_7) {
984 if (info->mic) {
985 dev_dbg(arizona->dev, "Mic button detected\n");
986
987 lvl = val & ARIZONA_MICD_LVL_MASK;
988 lvl >>= ARIZONA_MICD_LVL_SHIFT;
989
990 for (i = 0; i < info->num_micd_ranges; i++)
991 input_report_key(info->input,
992 info->micd_ranges[i].key, 0);
993
994 if (lvl && ffs(lvl) - 1 < info->num_micd_ranges) {
995 key = info->micd_ranges[ffs(lvl) - 1].key;
996 input_report_key(info->input, key, 1);
997 input_sync(info->input);
998 } else {
999 dev_err(arizona->dev, "Button out of range\n");
1000 }
1001 } else {
1002 dev_warn(arizona->dev, "Button with no mic: %x\n",
1003 val);
1004 }
1005 } else {
1006 dev_dbg(arizona->dev, "Mic button released\n");
1007 for (i = 0; i < info->num_micd_ranges; i++)
1008 input_report_key(info->input,
1009 info->micd_ranges[i].key, 0);
1010 input_sync(info->input);
1011 arizona_extcon_pulse_micbias(info);
1012 }
1013
1014 return 0;
1015 }
1016
1017 static void arizona_micd_detect(struct work_struct *work)
1018 {
1019 struct arizona_extcon_info *info = container_of(work,
1020 struct arizona_extcon_info,
1021 micd_detect_work.work);
1022 struct arizona *arizona = info->arizona;
1023 int ret;
1024
1025 cancel_delayed_work_sync(&info->micd_timeout_work);
1026
1027 mutex_lock(&info->lock);
1028
1029 /* If the cable was removed while measuring ignore the result */
1030 ret = extcon_get_state(info->edev, EXTCON_MECHANICAL);
1031 if (ret < 0) {
1032 dev_err(arizona->dev, "Failed to check cable state: %d\n",
1033 ret);
1034 mutex_unlock(&info->lock);
1035 return;
1036 } else if (!ret) {
1037 dev_dbg(arizona->dev, "Ignoring MICDET for removed cable\n");
1038 mutex_unlock(&info->lock);
1039 return;
1040 }
1041
1042 if (info->detecting)
1043 arizona_micdet_reading(info);
1044 else
1045 arizona_button_reading(info);
1046
1047 pm_runtime_mark_last_busy(info->dev);
1048 mutex_unlock(&info->lock);
1049 }
1050
1051 static irqreturn_t arizona_micdet(int irq, void *data)
1052 {
1053 struct arizona_extcon_info *info = data;
1054 struct arizona *arizona = info->arizona;
1055 int debounce = arizona->pdata.micd_detect_debounce;
1056
1057 cancel_delayed_work_sync(&info->micd_detect_work);
1058 cancel_delayed_work_sync(&info->micd_timeout_work);
1059
1060 mutex_lock(&info->lock);
1061 if (!info->detecting)
1062 debounce = 0;
1063 mutex_unlock(&info->lock);
1064
1065 if (debounce)
1066 queue_delayed_work(system_power_efficient_wq,
1067 &info->micd_detect_work,
1068 msecs_to_jiffies(debounce));
1069 else
1070 arizona_micd_detect(&info->micd_detect_work.work);
1071
1072 return IRQ_HANDLED;
1073 }
1074
1075 static void arizona_hpdet_work(struct work_struct *work)
1076 {
1077 struct arizona_extcon_info *info = container_of(work,
1078 struct arizona_extcon_info,
1079 hpdet_work.work);
1080
1081 mutex_lock(&info->lock);
1082 arizona_start_hpdet_acc_id(info);
1083 mutex_unlock(&info->lock);
1084 }
1085
1086 static int arizona_hpdet_wait(struct arizona_extcon_info *info)
1087 {
1088 struct arizona *arizona = info->arizona;
1089 unsigned int val;
1090 int i, ret;
1091
1092 for (i = 0; i < ARIZONA_HPDET_WAIT_COUNT; i++) {
1093 ret = regmap_read(arizona->regmap, ARIZONA_HEADPHONE_DETECT_2,
1094 &val);
1095 if (ret) {
1096 dev_err(arizona->dev,
1097 "Failed to read HPDET state: %d\n", ret);
1098 return ret;
1099 }
1100
1101 switch (info->hpdet_ip_version) {
1102 case 0:
1103 if (val & ARIZONA_HP_DONE)
1104 return 0;
1105 break;
1106 default:
1107 if (val & ARIZONA_HP_DONE_B)
1108 return 0;
1109 break;
1110 }
1111
1112 msleep(ARIZONA_HPDET_WAIT_DELAY_MS);
1113 }
1114
1115 dev_warn(arizona->dev, "HPDET did not appear to complete\n");
1116
1117 return -ETIMEDOUT;
1118 }
1119
1120 static irqreturn_t arizona_jackdet(int irq, void *data)
1121 {
1122 struct arizona_extcon_info *info = data;
1123 struct arizona *arizona = info->arizona;
1124 unsigned int val, present, mask;
1125 bool cancelled_hp, cancelled_mic;
1126 int ret, i;
1127
1128 cancelled_hp = cancel_delayed_work_sync(&info->hpdet_work);
1129 cancelled_mic = cancel_delayed_work_sync(&info->micd_timeout_work);
1130
1131 pm_runtime_get_sync(info->dev);
1132
1133 mutex_lock(&info->lock);
1134
1135 if (info->micd_clamp) {
1136 mask = ARIZONA_MICD_CLAMP_STS;
1137 present = 0;
1138 } else {
1139 mask = ARIZONA_JD1_STS;
1140 if (arizona->pdata.jd_invert)
1141 present = 0;
1142 else
1143 present = ARIZONA_JD1_STS;
1144 }
1145
1146 ret = regmap_read(arizona->regmap, ARIZONA_AOD_IRQ_RAW_STATUS, &val);
1147 if (ret != 0) {
1148 dev_err(arizona->dev, "Failed to read jackdet status: %d\n",
1149 ret);
1150 mutex_unlock(&info->lock);
1151 pm_runtime_put_autosuspend(info->dev);
1152 return IRQ_NONE;
1153 }
1154
1155 val &= mask;
1156 if (val == info->last_jackdet) {
1157 dev_dbg(arizona->dev, "Suppressing duplicate JACKDET\n");
1158 if (cancelled_hp)
1159 queue_delayed_work(system_power_efficient_wq,
1160 &info->hpdet_work,
1161 msecs_to_jiffies(HPDET_DEBOUNCE));
1162
1163 if (cancelled_mic) {
1164 int micd_timeout = arizona->pdata.micd_timeout;
1165
1166 queue_delayed_work(system_power_efficient_wq,
1167 &info->micd_timeout_work,
1168 msecs_to_jiffies(micd_timeout));
1169 }
1170
1171 goto out;
1172 }
1173 info->last_jackdet = val;
1174
1175 if (info->last_jackdet == present) {
1176 dev_dbg(arizona->dev, "Detected jack\n");
1177 ret = extcon_set_state_sync(info->edev,
1178 EXTCON_MECHANICAL, true);
1179
1180 if (ret != 0)
1181 dev_err(arizona->dev, "Mechanical report failed: %d\n",
1182 ret);
1183
1184 info->detecting = true;
1185 info->mic = false;
1186 info->jack_flips = 0;
1187
1188 if (!arizona->pdata.hpdet_acc_id) {
1189 arizona_start_mic(info);
1190 } else {
1191 queue_delayed_work(system_power_efficient_wq,
1192 &info->hpdet_work,
1193 msecs_to_jiffies(HPDET_DEBOUNCE));
1194 }
1195
1196 if (info->micd_clamp || !arizona->pdata.jd_invert)
1197 regmap_update_bits(arizona->regmap,
1198 ARIZONA_JACK_DETECT_DEBOUNCE,
1199 ARIZONA_MICD_CLAMP_DB |
1200 ARIZONA_JD1_DB, 0);
1201 } else {
1202 dev_dbg(arizona->dev, "Detected jack removal\n");
1203
1204 arizona_stop_mic(info);
1205
1206 info->num_hpdet_res = 0;
1207 for (i = 0; i < ARRAY_SIZE(info->hpdet_res); i++)
1208 info->hpdet_res[i] = 0;
1209 info->mic = false;
1210 info->hpdet_done = false;
1211 info->hpdet_retried = false;
1212
1213 for (i = 0; i < info->num_micd_ranges; i++)
1214 input_report_key(info->input,
1215 info->micd_ranges[i].key, 0);
1216 input_sync(info->input);
1217
1218 for (i = 0; i < ARRAY_SIZE(arizona_cable) - 1; i++) {
1219 ret = extcon_set_state_sync(info->edev,
1220 arizona_cable[i], false);
1221 if (ret != 0)
1222 dev_err(arizona->dev,
1223 "Removal report failed: %d\n", ret);
1224 }
1225
1226 /*
1227 * If the jack was removed during a headphone detection we
1228 * need to wait for the headphone detection to finish, as
1229 * it can not be aborted. We don't want to be able to start
1230 * a new headphone detection from a fresh insert until this
1231 * one is finished.
1232 */
1233 arizona_hpdet_wait(info);
1234
1235 regmap_update_bits(arizona->regmap,
1236 ARIZONA_JACK_DETECT_DEBOUNCE,
1237 ARIZONA_MICD_CLAMP_DB | ARIZONA_JD1_DB,
1238 ARIZONA_MICD_CLAMP_DB | ARIZONA_JD1_DB);
1239 }
1240
1241 out:
1242 /* Clear trig_sts to make sure DCVDD is not forced up */
1243 regmap_write(arizona->regmap, ARIZONA_AOD_WKUP_AND_TRIG,
1244 ARIZONA_MICD_CLAMP_FALL_TRIG_STS |
1245 ARIZONA_MICD_CLAMP_RISE_TRIG_STS |
1246 ARIZONA_JD1_FALL_TRIG_STS |
1247 ARIZONA_JD1_RISE_TRIG_STS);
1248
1249 mutex_unlock(&info->lock);
1250
1251 pm_runtime_mark_last_busy(info->dev);
1252 pm_runtime_put_autosuspend(info->dev);
1253
1254 return IRQ_HANDLED;
1255 }
1256
1257 /* Map a level onto a slot in the register bank */
1258 static void arizona_micd_set_level(struct arizona *arizona, int index,
1259 unsigned int level)
1260 {
1261 int reg;
1262 unsigned int mask;
1263
1264 reg = ARIZONA_MIC_DETECT_LEVEL_4 - (index / 2);
1265
1266 if (!(index % 2)) {
1267 mask = 0x3f00;
1268 level <<= 8;
1269 } else {
1270 mask = 0x3f;
1271 }
1272
1273 /* Program the level itself */
1274 regmap_update_bits(arizona->regmap, reg, mask, level);
1275 }
1276
1277 static int arizona_extcon_get_micd_configs(struct device *dev,
1278 struct arizona *arizona)
1279 {
1280 const char * const prop = "wlf,micd-configs";
1281 const int entries_per_config = 3;
1282 struct arizona_micd_config *micd_configs;
1283 int nconfs, ret;
1284 int i, j;
1285 u32 *vals;
1286
1287 nconfs = device_property_count_u32(arizona->dev, prop);
1288 if (nconfs <= 0)
1289 return 0;
1290
1291 vals = kcalloc(nconfs, sizeof(u32), GFP_KERNEL);
1292 if (!vals)
1293 return -ENOMEM;
1294
1295 ret = device_property_read_u32_array(arizona->dev, prop, vals, nconfs);
1296 if (ret < 0)
1297 goto out;
1298
1299 nconfs /= entries_per_config;
1300 micd_configs = devm_kcalloc(dev, nconfs, sizeof(*micd_configs),
1301 GFP_KERNEL);
1302 if (!micd_configs) {
1303 ret = -ENOMEM;
1304 goto out;
1305 }
1306
1307 for (i = 0, j = 0; i < nconfs; ++i) {
1308 micd_configs[i].src = vals[j++] ? ARIZONA_ACCDET_SRC : 0;
1309 micd_configs[i].bias = vals[j++];
1310 micd_configs[i].gpio = vals[j++];
1311 }
1312
1313 arizona->pdata.micd_configs = micd_configs;
1314 arizona->pdata.num_micd_configs = nconfs;
1315
1316 out:
1317 kfree(vals);
1318 return ret;
1319 }
1320
1321 static int arizona_extcon_device_get_pdata(struct device *dev,
1322 struct arizona *arizona)
1323 {
1324 struct arizona_pdata *pdata = &arizona->pdata;
1325 unsigned int val = ARIZONA_ACCDET_MODE_HPL;
1326 int ret;
1327
1328 device_property_read_u32(arizona->dev, "wlf,hpdet-channel", &val);
1329 switch (val) {
1330 case ARIZONA_ACCDET_MODE_HPL:
1331 case ARIZONA_ACCDET_MODE_HPR:
1332 pdata->hpdet_channel = val;
1333 break;
1334 default:
1335 dev_err(arizona->dev,
1336 "Wrong wlf,hpdet-channel DT value %d\n", val);
1337 pdata->hpdet_channel = ARIZONA_ACCDET_MODE_HPL;
1338 }
1339
1340 device_property_read_u32(arizona->dev, "wlf,micd-detect-debounce",
1341 &pdata->micd_detect_debounce);
1342
1343 device_property_read_u32(arizona->dev, "wlf,micd-bias-start-time",
1344 &pdata->micd_bias_start_time);
1345
1346 device_property_read_u32(arizona->dev, "wlf,micd-rate",
1347 &pdata->micd_rate);
1348
1349 device_property_read_u32(arizona->dev, "wlf,micd-dbtime",
1350 &pdata->micd_dbtime);
1351
1352 device_property_read_u32(arizona->dev, "wlf,micd-timeout-ms",
1353 &pdata->micd_timeout);
1354
1355 pdata->micd_force_micbias = device_property_read_bool(arizona->dev,
1356 "wlf,micd-force-micbias");
1357
1358 pdata->micd_software_compare = device_property_read_bool(arizona->dev,
1359 "wlf,micd-software-compare");
1360
1361 pdata->jd_invert = device_property_read_bool(arizona->dev,
1362 "wlf,jd-invert");
1363
1364 device_property_read_u32(arizona->dev, "wlf,gpsw", &pdata->gpsw);
1365
1366 pdata->jd_gpio5 = device_property_read_bool(arizona->dev,
1367 "wlf,use-jd2");
1368 pdata->jd_gpio5_nopull = device_property_read_bool(arizona->dev,
1369 "wlf,use-jd2-nopull");
1370
1371 ret = arizona_extcon_get_micd_configs(dev, arizona);
1372 if (ret < 0)
1373 dev_err(arizona->dev, "Failed to read micd configs: %d\n", ret);
1374
1375 return 0;
1376 }
1377
1378 static int arizona_extcon_probe(struct platform_device *pdev)
1379 {
1380 struct arizona *arizona = dev_get_drvdata(pdev->dev.parent);
1381 struct arizona_pdata *pdata = &arizona->pdata;
1382 struct arizona_extcon_info *info;
1383 unsigned int val;
1384 unsigned int clamp_mode;
1385 int jack_irq_fall, jack_irq_rise;
1386 int ret, mode, i, j;
1387
1388 if (!arizona->dapm || !arizona->dapm->card)
1389 return -EPROBE_DEFER;
1390
1391 info = devm_kzalloc(&pdev->dev, sizeof(*info), GFP_KERNEL);
1392 if (!info)
1393 return -ENOMEM;
1394
1395 if (!dev_get_platdata(arizona->dev))
1396 arizona_extcon_device_get_pdata(&pdev->dev, arizona);
1397
1398 info->micvdd = devm_regulator_get(&pdev->dev, "MICVDD");
1399 if (IS_ERR(info->micvdd)) {
1400 ret = PTR_ERR(info->micvdd);
1401 dev_err(arizona->dev, "Failed to get MICVDD: %d\n", ret);
1402 return ret;
1403 }
1404
1405 mutex_init(&info->lock);
1406 info->arizona = arizona;
1407 info->dev = &pdev->dev;
1408 info->last_jackdet = ~(ARIZONA_MICD_CLAMP_STS | ARIZONA_JD1_STS);
1409 INIT_DELAYED_WORK(&info->hpdet_work, arizona_hpdet_work);
1410 INIT_DELAYED_WORK(&info->micd_detect_work, arizona_micd_detect);
1411 INIT_DELAYED_WORK(&info->micd_timeout_work, arizona_micd_timeout_work);
1412 platform_set_drvdata(pdev, info);
1413
1414 switch (arizona->type) {
1415 case WM5102:
1416 switch (arizona->rev) {
1417 case 0:
1418 info->micd_reva = true;
1419 break;
1420 default:
1421 info->micd_clamp = true;
1422 info->hpdet_ip_version = 1;
1423 break;
1424 }
1425 break;
1426 case WM5110:
1427 case WM8280:
1428 switch (arizona->rev) {
1429 case 0 ... 2:
1430 break;
1431 default:
1432 info->micd_clamp = true;
1433 info->hpdet_ip_version = 2;
1434 break;
1435 }
1436 break;
1437 case WM8998:
1438 case WM1814:
1439 info->micd_clamp = true;
1440 info->hpdet_ip_version = 2;
1441 break;
1442 default:
1443 break;
1444 }
1445
1446 info->edev = devm_extcon_dev_allocate(&pdev->dev, arizona_cable);
1447 if (IS_ERR(info->edev)) {
1448 dev_err(&pdev->dev, "failed to allocate extcon device\n");
1449 return -ENOMEM;
1450 }
1451
1452 ret = devm_extcon_dev_register(&pdev->dev, info->edev);
1453 if (ret < 0) {
1454 dev_err(arizona->dev, "extcon_dev_register() failed: %d\n",
1455 ret);
1456 return ret;
1457 }
1458
1459 info->input = devm_input_allocate_device(&pdev->dev);
1460 if (!info->input) {
1461 dev_err(arizona->dev, "Can't allocate input dev\n");
1462 ret = -ENOMEM;
1463 goto err_register;
1464 }
1465
1466 info->input->name = "Headset";
1467 info->input->phys = "arizona/extcon";
1468
1469 if (!pdata->micd_timeout)
1470 pdata->micd_timeout = DEFAULT_MICD_TIMEOUT;
1471
1472 if (pdata->num_micd_configs) {
1473 info->micd_modes = pdata->micd_configs;
1474 info->micd_num_modes = pdata->num_micd_configs;
1475 } else {
1476 info->micd_modes = micd_default_modes;
1477 info->micd_num_modes = ARRAY_SIZE(micd_default_modes);
1478 }
1479
1480 if (arizona->pdata.gpsw > 0)
1481 regmap_update_bits(arizona->regmap, ARIZONA_GP_SWITCH_1,
1482 ARIZONA_SW1_MODE_MASK, arizona->pdata.gpsw);
1483
1484 if (pdata->micd_pol_gpio > 0) {
1485 if (info->micd_modes[0].gpio)
1486 mode = GPIOF_OUT_INIT_HIGH;
1487 else
1488 mode = GPIOF_OUT_INIT_LOW;
1489
1490 ret = devm_gpio_request_one(&pdev->dev, pdata->micd_pol_gpio,
1491 mode, "MICD polarity");
1492 if (ret != 0) {
1493 dev_err(arizona->dev, "Failed to request GPIO%d: %d\n",
1494 pdata->micd_pol_gpio, ret);
1495 goto err_register;
1496 }
1497
1498 info->micd_pol_gpio = gpio_to_desc(pdata->micd_pol_gpio);
1499 } else {
1500 if (info->micd_modes[0].gpio)
1501 mode = GPIOD_OUT_HIGH;
1502 else
1503 mode = GPIOD_OUT_LOW;
1504
1505 /* We can't use devm here because we need to do the get
1506 * against the MFD device, as that is where the of_node
1507 * will reside, but if we devm against that the GPIO
1508 * will not be freed if the extcon driver is unloaded.
1509 */
1510 info->micd_pol_gpio = gpiod_get_optional(arizona->dev,
1511 "wlf,micd-pol",
1512 GPIOD_OUT_LOW);
1513 if (IS_ERR(info->micd_pol_gpio)) {
1514 ret = PTR_ERR(info->micd_pol_gpio);
1515 dev_err(arizona->dev,
1516 "Failed to get microphone polarity GPIO: %d\n",
1517 ret);
1518 goto err_register;
1519 }
1520 }
1521
1522 if (arizona->pdata.hpdet_id_gpio > 0) {
1523 ret = devm_gpio_request_one(&pdev->dev,
1524 arizona->pdata.hpdet_id_gpio,
1525 GPIOF_OUT_INIT_LOW,
1526 "HPDET");
1527 if (ret != 0) {
1528 dev_err(arizona->dev, "Failed to request GPIO%d: %d\n",
1529 arizona->pdata.hpdet_id_gpio, ret);
1530 goto err_gpio;
1531 }
1532 }
1533
1534 if (arizona->pdata.micd_bias_start_time)
1535 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_1,
1536 ARIZONA_MICD_BIAS_STARTTIME_MASK,
1537 arizona->pdata.micd_bias_start_time
1538 << ARIZONA_MICD_BIAS_STARTTIME_SHIFT);
1539
1540 if (arizona->pdata.micd_rate)
1541 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_1,
1542 ARIZONA_MICD_RATE_MASK,
1543 arizona->pdata.micd_rate
1544 << ARIZONA_MICD_RATE_SHIFT);
1545
1546 switch (arizona->pdata.micd_dbtime) {
1547 case MICD_DBTIME_FOUR_READINGS:
1548 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_1,
1549 ARIZONA_MICD_DBTIME_MASK,
1550 ARIZONA_MICD_DBTIME);
1551 break;
1552 case MICD_DBTIME_TWO_READINGS:
1553 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_1,
1554 ARIZONA_MICD_DBTIME_MASK, 0);
1555 break;
1556 default:
1557 break;
1558 }
1559
1560 BUILD_BUG_ON(ARRAY_SIZE(arizona_micd_levels) <
1561 ARIZONA_NUM_MICD_BUTTON_LEVELS);
1562
1563 if (arizona->pdata.num_micd_ranges) {
1564 info->micd_ranges = pdata->micd_ranges;
1565 info->num_micd_ranges = pdata->num_micd_ranges;
1566 } else {
1567 info->micd_ranges = micd_default_ranges;
1568 info->num_micd_ranges = ARRAY_SIZE(micd_default_ranges);
1569 }
1570
1571 if (arizona->pdata.num_micd_ranges > ARIZONA_MAX_MICD_RANGE) {
1572 dev_err(arizona->dev, "Too many MICD ranges: %d\n",
1573 arizona->pdata.num_micd_ranges);
1574 }
1575
1576 if (info->num_micd_ranges > 1) {
1577 for (i = 1; i < info->num_micd_ranges; i++) {
1578 if (info->micd_ranges[i - 1].max >
1579 info->micd_ranges[i].max) {
1580 dev_err(arizona->dev,
1581 "MICD ranges must be sorted\n");
1582 ret = -EINVAL;
1583 goto err_gpio;
1584 }
1585 }
1586 }
1587
1588 /* Disable all buttons by default */
1589 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_2,
1590 ARIZONA_MICD_LVL_SEL_MASK, 0x81);
1591
1592 /* Set up all the buttons the user specified */
1593 for (i = 0; i < info->num_micd_ranges; i++) {
1594 for (j = 0; j < ARIZONA_NUM_MICD_BUTTON_LEVELS; j++)
1595 if (arizona_micd_levels[j] >= info->micd_ranges[i].max)
1596 break;
1597
1598 if (j == ARIZONA_NUM_MICD_BUTTON_LEVELS) {
1599 dev_err(arizona->dev, "Unsupported MICD level %d\n",
1600 info->micd_ranges[i].max);
1601 ret = -EINVAL;
1602 goto err_gpio;
1603 }
1604
1605 dev_dbg(arizona->dev, "%d ohms for MICD threshold %d\n",
1606 arizona_micd_levels[j], i);
1607
1608 arizona_micd_set_level(arizona, i, j);
1609 input_set_capability(info->input, EV_KEY,
1610 info->micd_ranges[i].key);
1611
1612 /* Enable reporting of that range */
1613 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_2,
1614 1 << i, 1 << i);
1615 }
1616
1617 /* Set all the remaining keys to a maximum */
1618 for (; i < ARIZONA_MAX_MICD_RANGE; i++)
1619 arizona_micd_set_level(arizona, i, 0x3f);
1620
1621 /*
1622 * If we have a clamp use it, activating in conjunction with
1623 * GPIO5 if that is connected for jack detect operation.
1624 */
1625 if (info->micd_clamp) {
1626 if (arizona->pdata.jd_gpio5) {
1627 /* Put the GPIO into input mode with optional pull */
1628 val = 0xc101;
1629 if (arizona->pdata.jd_gpio5_nopull)
1630 val &= ~ARIZONA_GPN_PU;
1631
1632 regmap_write(arizona->regmap, ARIZONA_GPIO5_CTRL,
1633 val);
1634
1635 if (arizona->pdata.jd_invert)
1636 clamp_mode = ARIZONA_MICD_CLAMP_MODE_JDH_GP5H;
1637 else
1638 clamp_mode = ARIZONA_MICD_CLAMP_MODE_JDL_GP5H;
1639 } else {
1640 if (arizona->pdata.jd_invert)
1641 clamp_mode = ARIZONA_MICD_CLAMP_MODE_JDH;
1642 else
1643 clamp_mode = ARIZONA_MICD_CLAMP_MODE_JDL;
1644 }
1645
1646 regmap_update_bits(arizona->regmap,
1647 ARIZONA_MICD_CLAMP_CONTROL,
1648 ARIZONA_MICD_CLAMP_MODE_MASK, clamp_mode);
1649
1650 regmap_update_bits(arizona->regmap,
1651 ARIZONA_JACK_DETECT_DEBOUNCE,
1652 ARIZONA_MICD_CLAMP_DB,
1653 ARIZONA_MICD_CLAMP_DB);
1654 }
1655
1656 arizona_extcon_set_mode(info, 0);
1657
1658 pm_runtime_enable(&pdev->dev);
1659 pm_runtime_idle(&pdev->dev);
1660 pm_runtime_get_sync(&pdev->dev);
1661
1662 if (info->micd_clamp) {
1663 jack_irq_rise = ARIZONA_IRQ_MICD_CLAMP_RISE;
1664 jack_irq_fall = ARIZONA_IRQ_MICD_CLAMP_FALL;
1665 } else {
1666 jack_irq_rise = ARIZONA_IRQ_JD_RISE;
1667 jack_irq_fall = ARIZONA_IRQ_JD_FALL;
1668 }
1669
1670 ret = arizona_request_irq(arizona, jack_irq_rise,
1671 "JACKDET rise", arizona_jackdet, info);
1672 if (ret != 0) {
1673 dev_err(&pdev->dev, "Failed to get JACKDET rise IRQ: %d\n",
1674 ret);
1675 goto err_gpio;
1676 }
1677
1678 ret = arizona_set_irq_wake(arizona, jack_irq_rise, 1);
1679 if (ret != 0) {
1680 dev_err(&pdev->dev, "Failed to set JD rise IRQ wake: %d\n",
1681 ret);
1682 goto err_rise;
1683 }
1684
1685 ret = arizona_request_irq(arizona, jack_irq_fall,
1686 "JACKDET fall", arizona_jackdet, info);
1687 if (ret != 0) {
1688 dev_err(&pdev->dev, "Failed to get JD fall IRQ: %d\n", ret);
1689 goto err_rise_wake;
1690 }
1691
1692 ret = arizona_set_irq_wake(arizona, jack_irq_fall, 1);
1693 if (ret != 0) {
1694 dev_err(&pdev->dev, "Failed to set JD fall IRQ wake: %d\n",
1695 ret);
1696 goto err_fall;
1697 }
1698
1699 ret = arizona_request_irq(arizona, ARIZONA_IRQ_MICDET,
1700 "MICDET", arizona_micdet, info);
1701 if (ret != 0) {
1702 dev_err(&pdev->dev, "Failed to get MICDET IRQ: %d\n", ret);
1703 goto err_fall_wake;
1704 }
1705
1706 ret = arizona_request_irq(arizona, ARIZONA_IRQ_HPDET,
1707 "HPDET", arizona_hpdet_irq, info);
1708 if (ret != 0) {
1709 dev_err(&pdev->dev, "Failed to get HPDET IRQ: %d\n", ret);
1710 goto err_micdet;
1711 }
1712
1713 arizona_clk32k_enable(arizona);
1714 regmap_update_bits(arizona->regmap, ARIZONA_JACK_DETECT_DEBOUNCE,
1715 ARIZONA_JD1_DB, ARIZONA_JD1_DB);
1716 regmap_update_bits(arizona->regmap, ARIZONA_JACK_DETECT_ANALOGUE,
1717 ARIZONA_JD1_ENA, ARIZONA_JD1_ENA);
1718
1719 ret = regulator_allow_bypass(info->micvdd, true);
1720 if (ret != 0)
1721 dev_warn(arizona->dev, "Failed to set MICVDD to bypass: %d\n",
1722 ret);
1723
1724 pm_runtime_put(&pdev->dev);
1725
1726 ret = input_register_device(info->input);
1727 if (ret) {
1728 dev_err(&pdev->dev, "Can't register input device: %d\n", ret);
1729 goto err_hpdet;
1730 }
1731
1732 return 0;
1733
1734 err_hpdet:
1735 arizona_free_irq(arizona, ARIZONA_IRQ_HPDET, info);
1736 err_micdet:
1737 arizona_free_irq(arizona, ARIZONA_IRQ_MICDET, info);
1738 err_fall_wake:
1739 arizona_set_irq_wake(arizona, jack_irq_fall, 0);
1740 err_fall:
1741 arizona_free_irq(arizona, jack_irq_fall, info);
1742 err_rise_wake:
1743 arizona_set_irq_wake(arizona, jack_irq_rise, 0);
1744 err_rise:
1745 arizona_free_irq(arizona, jack_irq_rise, info);
1746 err_gpio:
1747 gpiod_put(info->micd_pol_gpio);
1748 err_register:
1749 pm_runtime_disable(&pdev->dev);
1750 return ret;
1751 }
1752
1753 static int arizona_extcon_remove(struct platform_device *pdev)
1754 {
1755 struct arizona_extcon_info *info = platform_get_drvdata(pdev);
1756 struct arizona *arizona = info->arizona;
1757 int jack_irq_rise, jack_irq_fall;
1758 bool change;
1759 int ret;
1760
1761 ret = regmap_update_bits_check(arizona->regmap, ARIZONA_MIC_DETECT_1,
1762 ARIZONA_MICD_ENA, 0,
1763 &change);
1764 if (ret < 0) {
1765 dev_err(&pdev->dev, "Failed to disable micd on remove: %d\n",
1766 ret);
1767 } else if (change) {
1768 regulator_disable(info->micvdd);
1769 pm_runtime_put(info->dev);
1770 }
1771
1772 gpiod_put(info->micd_pol_gpio);
1773
1774 pm_runtime_disable(&pdev->dev);
1775
1776 regmap_update_bits(arizona->regmap,
1777 ARIZONA_MICD_CLAMP_CONTROL,
1778 ARIZONA_MICD_CLAMP_MODE_MASK, 0);
1779
1780 if (info->micd_clamp) {
1781 jack_irq_rise = ARIZONA_IRQ_MICD_CLAMP_RISE;
1782 jack_irq_fall = ARIZONA_IRQ_MICD_CLAMP_FALL;
1783 } else {
1784 jack_irq_rise = ARIZONA_IRQ_JD_RISE;
1785 jack_irq_fall = ARIZONA_IRQ_JD_FALL;
1786 }
1787
1788 arizona_set_irq_wake(arizona, jack_irq_rise, 0);
1789 arizona_set_irq_wake(arizona, jack_irq_fall, 0);
1790 arizona_free_irq(arizona, ARIZONA_IRQ_HPDET, info);
1791 arizona_free_irq(arizona, ARIZONA_IRQ_MICDET, info);
1792 arizona_free_irq(arizona, jack_irq_rise, info);
1793 arizona_free_irq(arizona, jack_irq_fall, info);
1794 cancel_delayed_work_sync(&info->hpdet_work);
1795 regmap_update_bits(arizona->regmap, ARIZONA_JACK_DETECT_ANALOGUE,
1796 ARIZONA_JD1_ENA, 0);
1797 arizona_clk32k_disable(arizona);
1798
1799 return 0;
1800 }
1801
1802 static struct platform_driver arizona_extcon_driver = {
1803 .driver = {
1804 .name = "arizona-extcon",
1805 },
1806 .probe = arizona_extcon_probe,
1807 .remove = arizona_extcon_remove,
1808 };
1809
1810 module_platform_driver(arizona_extcon_driver);
1811
1812 MODULE_DESCRIPTION("Arizona Extcon driver");
1813 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
1814 MODULE_LICENSE("GPL");
1815 MODULE_ALIAS("platform:extcon-arizona");
Linux with added FPC-III support