2 * extcon-arizona.c - Extcon driver Wolfson Arizona devices
4 * Copyright (C) 2012-2014 Wolfson Microelectronics plc
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
17 #include <linux/kernel.h>
18 #include <linux/module.h>
19 #include <linux/i2c.h>
20 #include <linux/slab.h>
21 #include <linux/interrupt.h>
22 #include <linux/err.h>
23 #include <linux/gpio/consumer.h>
24 #include <linux/gpio.h>
25 #include <linux/input.h>
26 #include <linux/platform_device.h>
27 #include <linux/pm_runtime.h>
28 #include <linux/property.h>
29 #include <linux/regulator/consumer.h>
30 #include <linux/extcon.h>
32 #include <sound/soc.h>
34 #include <linux/mfd/arizona/core.h>
35 #include <linux/mfd/arizona/pdata.h>
36 #include <linux/mfd/arizona/registers.h>
37 #include <dt-bindings/mfd/arizona.h>
39 #define ARIZONA_MAX_MICD_RANGE 8
41 #define ARIZONA_MICD_CLAMP_MODE_JDL 0x4
42 #define ARIZONA_MICD_CLAMP_MODE_JDH 0x5
43 #define ARIZONA_MICD_CLAMP_MODE_JDL_GP5H 0x9
44 #define ARIZONA_MICD_CLAMP_MODE_JDH_GP5H 0xb
46 #define ARIZONA_TST_CAP_DEFAULT 0x3
47 #define ARIZONA_TST_CAP_CLAMP 0x1
49 #define ARIZONA_HPDET_MAX 10000
51 #define HPDET_DEBOUNCE 500
52 #define DEFAULT_MICD_TIMEOUT 2000
54 #define QUICK_HEADPHONE_MAX_OHM 3
55 #define MICROPHONE_MIN_OHM 1257
56 #define MICROPHONE_MAX_OHM 30000
58 #define MICD_DBTIME_TWO_READINGS 2
59 #define MICD_DBTIME_FOUR_READINGS 4
61 #define MICD_LVL_1_TO_7 (ARIZONA_MICD_LVL_1 | ARIZONA_MICD_LVL_2 | \
62 ARIZONA_MICD_LVL_3 | ARIZONA_MICD_LVL_4 | \
63 ARIZONA_MICD_LVL_5 | ARIZONA_MICD_LVL_6 | \
66 #define MICD_LVL_0_TO_7 (ARIZONA_MICD_LVL_0 | MICD_LVL_1_TO_7)
68 #define MICD_LVL_0_TO_8 (MICD_LVL_0_TO_7 | ARIZONA_MICD_LVL_8)
70 struct arizona_extcon_info {
72 struct arizona *arizona;
74 struct regulator *micvdd;
75 struct input_dev *input;
80 const struct arizona_micd_config *micd_modes;
83 const struct arizona_micd_range *micd_ranges;
91 struct delayed_work hpdet_work;
92 struct delayed_work micd_detect_work;
93 struct delayed_work micd_timeout_work;
100 unsigned int hpdet_res[3];
106 int hpdet_ip_version;
108 struct extcon_dev *edev;
110 struct gpio_desc *micd_pol_gpio;
113 static const struct arizona_micd_config micd_default_modes[] = {
114 { ARIZONA_ACCDET_SRC, 1, 0 },
118 static const struct arizona_micd_range micd_default_ranges[] = {
119 { .max = 11, .key = BTN_0 },
120 { .max = 28, .key = BTN_1 },
121 { .max = 54, .key = BTN_2 },
122 { .max = 100, .key = BTN_3 },
123 { .max = 186, .key = BTN_4 },
124 { .max = 430, .key = BTN_5 },
127 /* The number of levels in arizona_micd_levels valid for button thresholds */
128 #define ARIZONA_NUM_MICD_BUTTON_LEVELS 64
130 static const int arizona_micd_levels[] = {
131 3, 6, 8, 11, 13, 16, 18, 21, 23, 26, 28, 31, 34, 36, 39, 41, 44, 46,
132 49, 52, 54, 57, 60, 62, 65, 67, 70, 73, 75, 78, 81, 83, 89, 94, 100,
133 105, 111, 116, 122, 127, 139, 150, 161, 173, 186, 196, 209, 220, 245,
134 270, 295, 321, 348, 375, 402, 430, 489, 550, 614, 681, 752, 903, 1071,
138 static const unsigned int arizona_cable[] = {
140 EXTCON_JACK_MICROPHONE,
141 EXTCON_JACK_HEADPHONE,
142 EXTCON_JACK_LINE_OUT,
146 static void arizona_start_hpdet_acc_id(struct arizona_extcon_info *info);
148 static void arizona_extcon_hp_clamp(struct arizona_extcon_info *info,
151 struct arizona *arizona = info->arizona;
152 unsigned int mask = 0, val = 0;
153 unsigned int cap_sel = 0;
156 switch (arizona->type) {
163 mask = ARIZONA_HP1L_SHRTO | ARIZONA_HP1L_FLWR |
166 val = ARIZONA_HP1L_SHRTO;
167 cap_sel = ARIZONA_TST_CAP_CLAMP;
169 val = ARIZONA_HP1L_FLWR | ARIZONA_HP1L_SHRTI;
170 cap_sel = ARIZONA_TST_CAP_DEFAULT;
173 ret = regmap_update_bits(arizona->regmap,
174 ARIZONA_HP_TEST_CTRL_1,
175 ARIZONA_HP1_TST_CAP_SEL_MASK,
178 dev_warn(arizona->dev,
179 "Failed to set TST_CAP_SEL: %d\n", ret);
182 mask = ARIZONA_RMV_SHRT_HP1L;
184 val = ARIZONA_RMV_SHRT_HP1L;
188 snd_soc_dapm_mutex_lock(arizona->dapm);
190 arizona->hpdet_clamp = clamp;
192 /* Keep the HP output stages disabled while doing the clamp */
194 ret = regmap_update_bits(arizona->regmap,
195 ARIZONA_OUTPUT_ENABLES_1,
197 ARIZONA_OUT1R_ENA, 0);
199 dev_warn(arizona->dev,
200 "Failed to disable headphone outputs: %d\n",
205 ret = regmap_update_bits(arizona->regmap, ARIZONA_HP_CTRL_1L,
208 dev_warn(arizona->dev, "Failed to do clamp: %d\n",
211 ret = regmap_update_bits(arizona->regmap, ARIZONA_HP_CTRL_1R,
214 dev_warn(arizona->dev, "Failed to do clamp: %d\n",
218 /* Restore the desired state while not doing the clamp */
220 ret = regmap_update_bits(arizona->regmap,
221 ARIZONA_OUTPUT_ENABLES_1,
223 ARIZONA_OUT1R_ENA, arizona->hp_ena);
225 dev_warn(arizona->dev,
226 "Failed to restore headphone outputs: %d\n",
230 snd_soc_dapm_mutex_unlock(arizona->dapm);
233 static void arizona_extcon_set_mode(struct arizona_extcon_info *info, int mode)
235 struct arizona *arizona = info->arizona;
237 mode %= info->micd_num_modes;
239 if (arizona->pdata.micd_pol_gpio > 0)
240 gpio_set_value_cansleep(arizona->pdata.micd_pol_gpio,
241 info->micd_modes[mode].gpio);
243 gpiod_set_value_cansleep(info->micd_pol_gpio,
244 info->micd_modes[mode].gpio);
246 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_1,
247 ARIZONA_MICD_BIAS_SRC_MASK,
248 info->micd_modes[mode].bias <<
249 ARIZONA_MICD_BIAS_SRC_SHIFT);
250 regmap_update_bits(arizona->regmap, ARIZONA_ACCESSORY_DETECT_MODE_1,
251 ARIZONA_ACCDET_SRC, info->micd_modes[mode].src);
253 info->micd_mode = mode;
255 dev_dbg(arizona->dev, "Set jack polarity to %d\n", mode);
258 static const char *arizona_extcon_get_micbias(struct arizona_extcon_info *info)
260 switch (info->micd_modes[0].bias) {
272 static void arizona_extcon_pulse_micbias(struct arizona_extcon_info *info)
274 struct arizona *arizona = info->arizona;
275 const char *widget = arizona_extcon_get_micbias(info);
276 struct snd_soc_dapm_context *dapm = arizona->dapm;
279 ret = snd_soc_dapm_force_enable_pin(dapm, widget);
281 dev_warn(arizona->dev, "Failed to enable %s: %d\n",
284 snd_soc_dapm_sync(dapm);
286 if (!arizona->pdata.micd_force_micbias) {
287 ret = snd_soc_dapm_disable_pin(arizona->dapm, widget);
289 dev_warn(arizona->dev, "Failed to disable %s: %d\n",
292 snd_soc_dapm_sync(dapm);
296 static void arizona_start_mic(struct arizona_extcon_info *info)
298 struct arizona *arizona = info->arizona;
303 /* Microphone detection can't use idle mode */
304 pm_runtime_get(info->dev);
306 if (info->detecting) {
307 ret = regulator_allow_bypass(info->micvdd, false);
309 dev_err(arizona->dev,
310 "Failed to regulate MICVDD: %d\n",
315 ret = regulator_enable(info->micvdd);
317 dev_err(arizona->dev, "Failed to enable MICVDD: %d\n",
321 if (info->micd_reva) {
322 regmap_write(arizona->regmap, 0x80, 0x3);
323 regmap_write(arizona->regmap, 0x294, 0);
324 regmap_write(arizona->regmap, 0x80, 0x0);
327 if (info->detecting && arizona->pdata.micd_software_compare)
328 mode = ARIZONA_ACCDET_MODE_ADC;
330 mode = ARIZONA_ACCDET_MODE_MIC;
332 regmap_update_bits(arizona->regmap,
333 ARIZONA_ACCESSORY_DETECT_MODE_1,
334 ARIZONA_ACCDET_MODE_MASK, mode);
336 arizona_extcon_pulse_micbias(info);
338 regmap_update_bits_check(arizona->regmap, ARIZONA_MIC_DETECT_1,
339 ARIZONA_MICD_ENA, ARIZONA_MICD_ENA,
342 regulator_disable(info->micvdd);
343 pm_runtime_put_autosuspend(info->dev);
347 static void arizona_stop_mic(struct arizona_extcon_info *info)
349 struct arizona *arizona = info->arizona;
350 const char *widget = arizona_extcon_get_micbias(info);
351 struct snd_soc_dapm_context *dapm = arizona->dapm;
355 regmap_update_bits_check(arizona->regmap, ARIZONA_MIC_DETECT_1,
359 ret = snd_soc_dapm_disable_pin(dapm, widget);
361 dev_warn(arizona->dev,
362 "Failed to disable %s: %d\n",
365 snd_soc_dapm_sync(dapm);
367 if (info->micd_reva) {
368 regmap_write(arizona->regmap, 0x80, 0x3);
369 regmap_write(arizona->regmap, 0x294, 2);
370 regmap_write(arizona->regmap, 0x80, 0x0);
373 ret = regulator_allow_bypass(info->micvdd, true);
375 dev_err(arizona->dev, "Failed to bypass MICVDD: %d\n",
380 regulator_disable(info->micvdd);
381 pm_runtime_mark_last_busy(info->dev);
382 pm_runtime_put_autosuspend(info->dev);
387 unsigned int threshold;
388 unsigned int factor_a;
389 unsigned int factor_b;
390 } arizona_hpdet_b_ranges[] = {
391 { 100, 5528, 362464 },
392 { 169, 11084, 6186851 },
393 { 169, 11065, 65460395 },
396 #define ARIZONA_HPDET_B_RANGE_MAX 0x3fb
401 } arizona_hpdet_c_ranges[] = {
408 static int arizona_hpdet_read(struct arizona_extcon_info *info)
410 struct arizona *arizona = info->arizona;
411 unsigned int val, range;
414 ret = regmap_read(arizona->regmap, ARIZONA_HEADPHONE_DETECT_2, &val);
416 dev_err(arizona->dev, "Failed to read HPDET status: %d\n",
421 switch (info->hpdet_ip_version) {
423 if (!(val & ARIZONA_HP_DONE)) {
424 dev_err(arizona->dev, "HPDET did not complete: %x\n",
429 val &= ARIZONA_HP_LVL_MASK;
433 if (!(val & ARIZONA_HP_DONE_B)) {
434 dev_err(arizona->dev, "HPDET did not complete: %x\n",
439 ret = regmap_read(arizona->regmap, ARIZONA_HP_DACVAL, &val);
441 dev_err(arizona->dev, "Failed to read HP value: %d\n",
446 regmap_read(arizona->regmap, ARIZONA_HEADPHONE_DETECT_1,
448 range = (range & ARIZONA_HP_IMPEDANCE_RANGE_MASK)
449 >> ARIZONA_HP_IMPEDANCE_RANGE_SHIFT;
451 if (range < ARRAY_SIZE(arizona_hpdet_b_ranges) - 1 &&
452 (val < arizona_hpdet_b_ranges[range].threshold ||
453 val >= ARIZONA_HPDET_B_RANGE_MAX)) {
455 dev_dbg(arizona->dev, "Moving to HPDET range %d\n",
457 regmap_update_bits(arizona->regmap,
458 ARIZONA_HEADPHONE_DETECT_1,
459 ARIZONA_HP_IMPEDANCE_RANGE_MASK,
461 ARIZONA_HP_IMPEDANCE_RANGE_SHIFT);
465 /* If we go out of range report top of range */
466 if (val < arizona_hpdet_b_ranges[range].threshold ||
467 val >= ARIZONA_HPDET_B_RANGE_MAX) {
468 dev_dbg(arizona->dev, "Measurement out of range\n");
469 return ARIZONA_HPDET_MAX;
472 dev_dbg(arizona->dev, "HPDET read %d in range %d\n",
475 val = arizona_hpdet_b_ranges[range].factor_b
477 arizona_hpdet_b_ranges[range].factor_a);
481 if (!(val & ARIZONA_HP_DONE_B)) {
482 dev_err(arizona->dev, "HPDET did not complete: %x\n",
487 val &= ARIZONA_HP_LVL_B_MASK;
488 /* Convert to ohms, the value is in 0.5 ohm increments */
491 regmap_read(arizona->regmap, ARIZONA_HEADPHONE_DETECT_1,
493 range = (range & ARIZONA_HP_IMPEDANCE_RANGE_MASK)
494 >> ARIZONA_HP_IMPEDANCE_RANGE_SHIFT;
496 /* Skip up a range, or report? */
497 if (range < ARRAY_SIZE(arizona_hpdet_c_ranges) - 1 &&
498 (val >= arizona_hpdet_c_ranges[range].max)) {
500 dev_dbg(arizona->dev, "Moving to HPDET range %d-%d\n",
501 arizona_hpdet_c_ranges[range].min,
502 arizona_hpdet_c_ranges[range].max);
503 regmap_update_bits(arizona->regmap,
504 ARIZONA_HEADPHONE_DETECT_1,
505 ARIZONA_HP_IMPEDANCE_RANGE_MASK,
507 ARIZONA_HP_IMPEDANCE_RANGE_SHIFT);
511 if (range && (val < arizona_hpdet_c_ranges[range].min)) {
512 dev_dbg(arizona->dev, "Reporting range boundary %d\n",
513 arizona_hpdet_c_ranges[range].min);
514 val = arizona_hpdet_c_ranges[range].min;
519 dev_warn(arizona->dev, "Unknown HPDET IP revision %d\n",
520 info->hpdet_ip_version);
524 dev_dbg(arizona->dev, "HP impedance %d ohms\n", val);
528 static int arizona_hpdet_do_id(struct arizona_extcon_info *info, int *reading,
531 struct arizona *arizona = info->arizona;
532 int id_gpio = arizona->pdata.hpdet_id_gpio;
535 * If we're using HPDET for accessory identification we need
536 * to take multiple measurements, step through them in sequence.
538 if (arizona->pdata.hpdet_acc_id) {
539 info->hpdet_res[info->num_hpdet_res++] = *reading;
541 /* Only check the mic directly if we didn't already ID it */
542 if (id_gpio && info->num_hpdet_res == 1) {
543 dev_dbg(arizona->dev, "Measuring mic\n");
545 regmap_update_bits(arizona->regmap,
546 ARIZONA_ACCESSORY_DETECT_MODE_1,
547 ARIZONA_ACCDET_MODE_MASK |
549 ARIZONA_ACCDET_MODE_HPR |
550 info->micd_modes[0].src);
552 gpio_set_value_cansleep(id_gpio, 1);
554 regmap_update_bits(arizona->regmap,
555 ARIZONA_HEADPHONE_DETECT_1,
556 ARIZONA_HP_POLL, ARIZONA_HP_POLL);
560 /* OK, got both. Now, compare... */
561 dev_dbg(arizona->dev, "HPDET measured %d %d\n",
562 info->hpdet_res[0], info->hpdet_res[1]);
564 /* Take the headphone impedance for the main report */
565 *reading = info->hpdet_res[0];
567 /* Sometimes we get false readings due to slow insert */
568 if (*reading >= ARIZONA_HPDET_MAX && !info->hpdet_retried) {
569 dev_dbg(arizona->dev, "Retrying high impedance\n");
570 info->num_hpdet_res = 0;
571 info->hpdet_retried = true;
572 arizona_start_hpdet_acc_id(info);
573 pm_runtime_put(info->dev);
578 * If we measure the mic as high impedance
580 if (!id_gpio || info->hpdet_res[1] > 50) {
581 dev_dbg(arizona->dev, "Detected mic\n");
583 info->detecting = true;
585 dev_dbg(arizona->dev, "Detected headphone\n");
588 /* Make sure everything is reset back to the real polarity */
589 regmap_update_bits(arizona->regmap,
590 ARIZONA_ACCESSORY_DETECT_MODE_1,
592 info->micd_modes[0].src);
598 static irqreturn_t arizona_hpdet_irq(int irq, void *data)
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;
607 mutex_lock(&info->lock);
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);
616 /* If the cable was removed while measuring ignore the result */
617 state = extcon_get_state(info->edev, EXTCON_MECHANICAL);
619 dev_err(arizona->dev, "Failed to check cable state: %d\n", state);
622 dev_dbg(arizona->dev, "Ignoring HPDET for removed cable\n");
626 ret = arizona_hpdet_read(info);
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,
639 ret = arizona_hpdet_do_id(info, &reading, &mic);
645 /* Report high impedence cables as line outputs */
647 report = EXTCON_JACK_LINE_OUT;
649 report = EXTCON_JACK_HEADPHONE;
651 ret = extcon_set_state_sync(info->edev, report, true);
653 dev_err(arizona->dev, "Failed to report HP/line: %d\n",
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,
663 arizona_extcon_hp_clamp(info, false);
666 gpio_set_value_cansleep(id_gpio, 0);
668 /* Revert back to MICDET mode */
669 regmap_update_bits(arizona->regmap,
670 ARIZONA_ACCESSORY_DETECT_MODE_1,
671 ARIZONA_ACCDET_MODE_MASK, ARIZONA_ACCDET_MODE_MIC);
673 /* If we have a mic then reenable MICDET */
674 if (state && (mic || info->mic))
675 arizona_start_mic(info);
677 if (info->hpdet_active) {
678 pm_runtime_put_autosuspend(info->dev);
679 info->hpdet_active = false;
682 /* Do not set hp_det done when the cable has been unplugged */
684 info->hpdet_done = true;
687 mutex_unlock(&info->lock);
692 static void arizona_identify_headphone(struct arizona_extcon_info *info)
694 struct arizona *arizona = info->arizona;
697 if (info->hpdet_done)
700 dev_dbg(arizona->dev, "Starting HPDET\n");
702 /* Make sure we keep the device enabled during the measurement */
703 pm_runtime_get(info->dev);
705 info->hpdet_active = true;
708 arizona_stop_mic(info);
710 arizona_extcon_hp_clamp(info, true);
712 ret = regmap_update_bits(arizona->regmap,
713 ARIZONA_ACCESSORY_DETECT_MODE_1,
714 ARIZONA_ACCDET_MODE_MASK,
715 arizona->pdata.hpdet_channel);
717 dev_err(arizona->dev, "Failed to set HPDET mode: %d\n", ret);
721 ret = regmap_update_bits(arizona->regmap, ARIZONA_HEADPHONE_DETECT_1,
722 ARIZONA_HP_POLL, ARIZONA_HP_POLL);
724 dev_err(arizona->dev, "Can't start HPDETL measurement: %d\n",
732 regmap_update_bits(arizona->regmap, ARIZONA_ACCESSORY_DETECT_MODE_1,
733 ARIZONA_ACCDET_MODE_MASK, ARIZONA_ACCDET_MODE_MIC);
735 /* Just report headphone */
736 ret = extcon_set_state_sync(info->edev, EXTCON_JACK_HEADPHONE, true);
738 dev_err(arizona->dev, "Failed to report headphone: %d\n", ret);
741 arizona_start_mic(info);
743 info->hpdet_active = false;
746 static void arizona_start_hpdet_acc_id(struct arizona_extcon_info *info)
748 struct arizona *arizona = info->arizona;
753 dev_dbg(arizona->dev, "Starting identification via HPDET\n");
755 /* Make sure we keep the device enabled during the measurement */
756 pm_runtime_get_sync(info->dev);
758 info->hpdet_active = true;
760 arizona_extcon_hp_clamp(info, true);
762 ret = regmap_update_bits(arizona->regmap,
763 ARIZONA_ACCESSORY_DETECT_MODE_1,
764 ARIZONA_ACCDET_SRC | ARIZONA_ACCDET_MODE_MASK,
765 info->micd_modes[0].src |
766 arizona->pdata.hpdet_channel);
768 dev_err(arizona->dev, "Failed to set HPDET mode: %d\n", ret);
772 if (arizona->pdata.hpdet_acc_id_line) {
773 ret = regmap_update_bits(arizona->regmap,
774 ARIZONA_HEADPHONE_DETECT_1,
775 ARIZONA_HP_POLL, ARIZONA_HP_POLL);
777 dev_err(arizona->dev,
778 "Can't start HPDETL measurement: %d\n",
783 arizona_hpdet_do_id(info, &hp_reading, &mic);
789 regmap_update_bits(arizona->regmap, ARIZONA_ACCESSORY_DETECT_MODE_1,
790 ARIZONA_ACCDET_MODE_MASK, ARIZONA_ACCDET_MODE_MIC);
792 /* Just report headphone */
793 ret = extcon_set_state_sync(info->edev, EXTCON_JACK_HEADPHONE, true);
795 dev_err(arizona->dev, "Failed to report headphone: %d\n", ret);
797 info->hpdet_active = false;
800 static void arizona_micd_timeout_work(struct work_struct *work)
802 struct arizona_extcon_info *info = container_of(work,
803 struct arizona_extcon_info,
804 micd_timeout_work.work);
806 mutex_lock(&info->lock);
808 dev_dbg(info->arizona->dev, "MICD timed out, reporting HP\n");
810 info->detecting = false;
812 arizona_identify_headphone(info);
814 arizona_stop_mic(info);
816 mutex_unlock(&info->lock);
819 static void arizona_micd_detect(struct work_struct *work)
821 struct arizona_extcon_info *info = container_of(work,
822 struct arizona_extcon_info,
823 micd_detect_work.work);
824 struct arizona *arizona = info->arizona;
825 unsigned int val = 0, lvl;
828 cancel_delayed_work_sync(&info->micd_timeout_work);
830 mutex_lock(&info->lock);
832 /* If the cable was removed while measuring ignore the result */
833 ret = extcon_get_state(info->edev, EXTCON_MECHANICAL);
835 dev_err(arizona->dev, "Failed to check cable state: %d\n",
837 mutex_unlock(&info->lock);
840 dev_dbg(arizona->dev, "Ignoring MICDET for removed cable\n");
841 mutex_unlock(&info->lock);
845 if (info->detecting && arizona->pdata.micd_software_compare) {
846 /* Must disable MICD before we read the ADCVAL */
847 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_1,
848 ARIZONA_MICD_ENA, 0);
849 ret = regmap_read(arizona->regmap, ARIZONA_MIC_DETECT_4, &val);
851 dev_err(arizona->dev,
852 "Failed to read MICDET_ADCVAL: %d\n",
854 mutex_unlock(&info->lock);
858 dev_dbg(arizona->dev, "MICDET_ADCVAL: %x\n", val);
860 val &= ARIZONA_MICDET_ADCVAL_MASK;
861 if (val < ARRAY_SIZE(arizona_micd_levels))
862 val = arizona_micd_levels[val];
866 if (val <= QUICK_HEADPHONE_MAX_OHM)
867 val = ARIZONA_MICD_STS | ARIZONA_MICD_LVL_0;
868 else if (val <= MICROPHONE_MIN_OHM)
869 val = ARIZONA_MICD_STS | ARIZONA_MICD_LVL_1;
870 else if (val <= MICROPHONE_MAX_OHM)
871 val = ARIZONA_MICD_STS | ARIZONA_MICD_LVL_8;
873 val = ARIZONA_MICD_LVL_8;
876 for (i = 0; i < 10 && !(val & MICD_LVL_0_TO_8); i++) {
877 ret = regmap_read(arizona->regmap, ARIZONA_MIC_DETECT_3, &val);
879 dev_err(arizona->dev,
880 "Failed to read MICDET: %d\n", ret);
881 mutex_unlock(&info->lock);
885 dev_dbg(arizona->dev, "MICDET: %x\n", val);
887 if (!(val & ARIZONA_MICD_VALID)) {
888 dev_warn(arizona->dev,
889 "Microphone detection state invalid\n");
890 mutex_unlock(&info->lock);
895 if (i == 10 && !(val & MICD_LVL_0_TO_8)) {
896 dev_err(arizona->dev, "Failed to get valid MICDET value\n");
897 mutex_unlock(&info->lock);
901 /* Due to jack detect this should never happen */
902 if (!(val & ARIZONA_MICD_STS)) {
903 dev_warn(arizona->dev, "Detected open circuit\n");
905 arizona_stop_mic(info);
906 info->detecting = false;
907 arizona_identify_headphone(info);
911 /* If we got a high impedence we should have a headset, report it. */
912 if (info->detecting && (val & ARIZONA_MICD_LVL_8)) {
914 info->detecting = false;
916 arizona_identify_headphone(info);
918 ret = extcon_set_state_sync(info->edev,
919 EXTCON_JACK_MICROPHONE, true);
921 dev_err(arizona->dev, "Headset report failed: %d\n",
924 /* Don't need to regulate for button detection */
925 ret = regulator_allow_bypass(info->micvdd, true);
927 dev_err(arizona->dev, "Failed to bypass MICVDD: %d\n",
934 /* If we detected a lower impedence during initial startup
935 * then we probably have the wrong polarity, flip it. Don't
936 * do this for the lowest impedences to speed up detection of
937 * plain headphones. If both polarities report a low
938 * impedence then give up and report headphones.
940 if (info->detecting && (val & MICD_LVL_1_TO_7)) {
941 if (info->jack_flips >= info->micd_num_modes * 10) {
942 dev_dbg(arizona->dev, "Detected HP/line\n");
944 info->detecting = false;
946 arizona_identify_headphone(info);
948 arizona_stop_mic(info);
951 if (info->micd_mode == info->micd_num_modes)
953 arizona_extcon_set_mode(info, info->micd_mode);
962 * If we're still detecting and we detect a short then we've
963 * got a headphone. Otherwise it's a button press.
965 if (val & MICD_LVL_0_TO_7) {
967 dev_dbg(arizona->dev, "Mic button detected\n");
969 lvl = val & ARIZONA_MICD_LVL_MASK;
970 lvl >>= ARIZONA_MICD_LVL_SHIFT;
972 for (i = 0; i < info->num_micd_ranges; i++)
973 input_report_key(info->input,
974 info->micd_ranges[i].key, 0);
977 WARN_ON(ffs(lvl) - 1 >= info->num_micd_ranges);
978 if (lvl && ffs(lvl) - 1 < info->num_micd_ranges) {
979 key = info->micd_ranges[ffs(lvl) - 1].key;
980 input_report_key(info->input, key, 1);
981 input_sync(info->input);
984 } else if (info->detecting) {
985 dev_dbg(arizona->dev, "Headphone detected\n");
986 info->detecting = false;
987 arizona_stop_mic(info);
989 arizona_identify_headphone(info);
991 dev_warn(arizona->dev, "Button with no mic: %x\n",
995 dev_dbg(arizona->dev, "Mic button released\n");
996 for (i = 0; i < info->num_micd_ranges; i++)
997 input_report_key(info->input,
998 info->micd_ranges[i].key, 0);
999 input_sync(info->input);
1000 arizona_extcon_pulse_micbias(info);
1004 if (info->detecting) {
1005 if (arizona->pdata.micd_software_compare)
1006 regmap_update_bits(arizona->regmap,
1007 ARIZONA_MIC_DETECT_1,
1011 queue_delayed_work(system_power_efficient_wq,
1012 &info->micd_timeout_work,
1013 msecs_to_jiffies(info->micd_timeout));
1016 pm_runtime_mark_last_busy(info->dev);
1017 mutex_unlock(&info->lock);
1020 static irqreturn_t arizona_micdet(int irq, void *data)
1022 struct arizona_extcon_info *info = data;
1023 struct arizona *arizona = info->arizona;
1024 int debounce = arizona->pdata.micd_detect_debounce;
1026 cancel_delayed_work_sync(&info->micd_detect_work);
1027 cancel_delayed_work_sync(&info->micd_timeout_work);
1029 mutex_lock(&info->lock);
1030 if (!info->detecting)
1032 mutex_unlock(&info->lock);
1035 queue_delayed_work(system_power_efficient_wq,
1036 &info->micd_detect_work,
1037 msecs_to_jiffies(debounce));
1039 arizona_micd_detect(&info->micd_detect_work.work);
1044 static void arizona_hpdet_work(struct work_struct *work)
1046 struct arizona_extcon_info *info = container_of(work,
1047 struct arizona_extcon_info,
1050 mutex_lock(&info->lock);
1051 arizona_start_hpdet_acc_id(info);
1052 mutex_unlock(&info->lock);
1055 static irqreturn_t arizona_jackdet(int irq, void *data)
1057 struct arizona_extcon_info *info = data;
1058 struct arizona *arizona = info->arizona;
1059 unsigned int val, present, mask;
1060 bool cancelled_hp, cancelled_mic;
1063 cancelled_hp = cancel_delayed_work_sync(&info->hpdet_work);
1064 cancelled_mic = cancel_delayed_work_sync(&info->micd_timeout_work);
1066 pm_runtime_get_sync(info->dev);
1068 mutex_lock(&info->lock);
1070 if (info->micd_clamp) {
1071 mask = ARIZONA_MICD_CLAMP_STS;
1074 mask = ARIZONA_JD1_STS;
1075 if (arizona->pdata.jd_invert)
1078 present = ARIZONA_JD1_STS;
1081 ret = regmap_read(arizona->regmap, ARIZONA_AOD_IRQ_RAW_STATUS, &val);
1083 dev_err(arizona->dev, "Failed to read jackdet status: %d\n",
1085 mutex_unlock(&info->lock);
1086 pm_runtime_put_autosuspend(info->dev);
1091 if (val == info->last_jackdet) {
1092 dev_dbg(arizona->dev, "Suppressing duplicate JACKDET\n");
1094 queue_delayed_work(system_power_efficient_wq,
1096 msecs_to_jiffies(HPDET_DEBOUNCE));
1098 if (cancelled_mic) {
1099 int micd_timeout = info->micd_timeout;
1101 queue_delayed_work(system_power_efficient_wq,
1102 &info->micd_timeout_work,
1103 msecs_to_jiffies(micd_timeout));
1108 info->last_jackdet = val;
1110 if (info->last_jackdet == present) {
1111 dev_dbg(arizona->dev, "Detected jack\n");
1112 ret = extcon_set_state_sync(info->edev,
1113 EXTCON_MECHANICAL, true);
1116 dev_err(arizona->dev, "Mechanical report failed: %d\n",
1119 if (!arizona->pdata.hpdet_acc_id) {
1120 info->detecting = true;
1122 info->jack_flips = 0;
1124 arizona_start_mic(info);
1126 queue_delayed_work(system_power_efficient_wq,
1128 msecs_to_jiffies(HPDET_DEBOUNCE));
1131 if (info->micd_clamp || !arizona->pdata.jd_invert)
1132 regmap_update_bits(arizona->regmap,
1133 ARIZONA_JACK_DETECT_DEBOUNCE,
1134 ARIZONA_MICD_CLAMP_DB |
1137 dev_dbg(arizona->dev, "Detected jack removal\n");
1139 arizona_stop_mic(info);
1141 info->num_hpdet_res = 0;
1142 for (i = 0; i < ARRAY_SIZE(info->hpdet_res); i++)
1143 info->hpdet_res[i] = 0;
1145 info->hpdet_done = false;
1146 info->hpdet_retried = false;
1148 for (i = 0; i < info->num_micd_ranges; i++)
1149 input_report_key(info->input,
1150 info->micd_ranges[i].key, 0);
1151 input_sync(info->input);
1153 for (i = 0; i < ARRAY_SIZE(arizona_cable) - 1; i++) {
1154 ret = extcon_set_state_sync(info->edev,
1155 arizona_cable[i], false);
1157 dev_err(arizona->dev,
1158 "Removal report failed: %d\n", ret);
1161 regmap_update_bits(arizona->regmap,
1162 ARIZONA_JACK_DETECT_DEBOUNCE,
1163 ARIZONA_MICD_CLAMP_DB | ARIZONA_JD1_DB,
1164 ARIZONA_MICD_CLAMP_DB | ARIZONA_JD1_DB);
1167 if (arizona->pdata.micd_timeout)
1168 info->micd_timeout = arizona->pdata.micd_timeout;
1170 info->micd_timeout = DEFAULT_MICD_TIMEOUT;
1173 /* Clear trig_sts to make sure DCVDD is not forced up */
1174 regmap_write(arizona->regmap, ARIZONA_AOD_WKUP_AND_TRIG,
1175 ARIZONA_MICD_CLAMP_FALL_TRIG_STS |
1176 ARIZONA_MICD_CLAMP_RISE_TRIG_STS |
1177 ARIZONA_JD1_FALL_TRIG_STS |
1178 ARIZONA_JD1_RISE_TRIG_STS);
1180 mutex_unlock(&info->lock);
1182 pm_runtime_mark_last_busy(info->dev);
1183 pm_runtime_put_autosuspend(info->dev);
1188 /* Map a level onto a slot in the register bank */
1189 static void arizona_micd_set_level(struct arizona *arizona, int index,
1195 reg = ARIZONA_MIC_DETECT_LEVEL_4 - (index / 2);
1204 /* Program the level itself */
1205 regmap_update_bits(arizona->regmap, reg, mask, level);
1208 static int arizona_extcon_get_micd_configs(struct device *dev,
1209 struct arizona *arizona)
1211 const char * const prop = "wlf,micd-configs";
1212 const int entries_per_config = 3;
1213 struct arizona_micd_config *micd_configs;
1218 nconfs = device_property_read_u32_array(arizona->dev, prop, NULL, 0);
1222 vals = kcalloc(nconfs, sizeof(u32), GFP_KERNEL);
1226 ret = device_property_read_u32_array(arizona->dev, prop, vals, nconfs);
1230 nconfs /= entries_per_config;
1232 micd_configs = devm_kzalloc(dev,
1233 nconfs * sizeof(struct arizona_micd_range),
1235 if (!micd_configs) {
1240 for (i = 0, j = 0; i < nconfs; ++i) {
1241 micd_configs[i].src = vals[j++] ? ARIZONA_ACCDET_SRC : 0;
1242 micd_configs[i].bias = vals[j++];
1243 micd_configs[i].gpio = vals[j++];
1246 arizona->pdata.micd_configs = micd_configs;
1247 arizona->pdata.num_micd_configs = nconfs;
1254 static int arizona_extcon_device_get_pdata(struct device *dev,
1255 struct arizona *arizona)
1257 struct arizona_pdata *pdata = &arizona->pdata;
1258 unsigned int val = ARIZONA_ACCDET_MODE_HPL;
1261 device_property_read_u32(arizona->dev, "wlf,hpdet-channel", &val);
1263 case ARIZONA_ACCDET_MODE_HPL:
1264 case ARIZONA_ACCDET_MODE_HPR:
1265 pdata->hpdet_channel = val;
1268 dev_err(arizona->dev,
1269 "Wrong wlf,hpdet-channel DT value %d\n", val);
1270 pdata->hpdet_channel = ARIZONA_ACCDET_MODE_HPL;
1273 device_property_read_u32(arizona->dev, "wlf,micd-detect-debounce",
1274 &pdata->micd_detect_debounce);
1276 device_property_read_u32(arizona->dev, "wlf,micd-bias-start-time",
1277 &pdata->micd_bias_start_time);
1279 device_property_read_u32(arizona->dev, "wlf,micd-rate",
1282 device_property_read_u32(arizona->dev, "wlf,micd-dbtime",
1283 &pdata->micd_dbtime);
1285 device_property_read_u32(arizona->dev, "wlf,micd-timeout-ms",
1286 &pdata->micd_timeout);
1288 pdata->micd_force_micbias = device_property_read_bool(arizona->dev,
1289 "wlf,micd-force-micbias");
1291 pdata->micd_software_compare = device_property_read_bool(arizona->dev,
1292 "wlf,micd-software-compare");
1294 pdata->jd_invert = device_property_read_bool(arizona->dev,
1297 device_property_read_u32(arizona->dev, "wlf,gpsw", &pdata->gpsw);
1299 pdata->jd_gpio5 = device_property_read_bool(arizona->dev,
1301 pdata->jd_gpio5_nopull = device_property_read_bool(arizona->dev,
1302 "wlf,use-jd2-nopull");
1304 ret = arizona_extcon_get_micd_configs(dev, arizona);
1306 dev_err(arizona->dev, "Failed to read micd configs: %d\n", ret);
1311 static int arizona_extcon_probe(struct platform_device *pdev)
1313 struct arizona *arizona = dev_get_drvdata(pdev->dev.parent);
1314 struct arizona_pdata *pdata = &arizona->pdata;
1315 struct arizona_extcon_info *info;
1317 unsigned int clamp_mode;
1318 int jack_irq_fall, jack_irq_rise;
1319 int ret, mode, i, j;
1321 if (!arizona->dapm || !arizona->dapm->card)
1322 return -EPROBE_DEFER;
1324 info = devm_kzalloc(&pdev->dev, sizeof(*info), GFP_KERNEL);
1328 if (!dev_get_platdata(arizona->dev))
1329 arizona_extcon_device_get_pdata(&pdev->dev, arizona);
1331 info->micvdd = devm_regulator_get(&pdev->dev, "MICVDD");
1332 if (IS_ERR(info->micvdd)) {
1333 ret = PTR_ERR(info->micvdd);
1334 dev_err(arizona->dev, "Failed to get MICVDD: %d\n", ret);
1338 mutex_init(&info->lock);
1339 info->arizona = arizona;
1340 info->dev = &pdev->dev;
1341 info->last_jackdet = ~(ARIZONA_MICD_CLAMP_STS | ARIZONA_JD1_STS);
1342 INIT_DELAYED_WORK(&info->hpdet_work, arizona_hpdet_work);
1343 INIT_DELAYED_WORK(&info->micd_detect_work, arizona_micd_detect);
1344 INIT_DELAYED_WORK(&info->micd_timeout_work, arizona_micd_timeout_work);
1345 platform_set_drvdata(pdev, info);
1347 switch (arizona->type) {
1349 switch (arizona->rev) {
1351 info->micd_reva = true;
1354 info->micd_clamp = true;
1355 info->hpdet_ip_version = 1;
1361 switch (arizona->rev) {
1365 info->micd_clamp = true;
1366 info->hpdet_ip_version = 2;
1372 info->micd_clamp = true;
1373 info->hpdet_ip_version = 2;
1379 info->edev = devm_extcon_dev_allocate(&pdev->dev, arizona_cable);
1380 if (IS_ERR(info->edev)) {
1381 dev_err(&pdev->dev, "failed to allocate extcon device\n");
1385 ret = devm_extcon_dev_register(&pdev->dev, info->edev);
1387 dev_err(arizona->dev, "extcon_dev_register() failed: %d\n",
1392 info->input = devm_input_allocate_device(&pdev->dev);
1394 dev_err(arizona->dev, "Can't allocate input dev\n");
1399 info->input->name = "Headset";
1400 info->input->phys = "arizona/extcon";
1402 if (pdata->num_micd_configs) {
1403 info->micd_modes = pdata->micd_configs;
1404 info->micd_num_modes = pdata->num_micd_configs;
1406 info->micd_modes = micd_default_modes;
1407 info->micd_num_modes = ARRAY_SIZE(micd_default_modes);
1410 if (arizona->pdata.gpsw > 0)
1411 regmap_update_bits(arizona->regmap, ARIZONA_GP_SWITCH_1,
1412 ARIZONA_SW1_MODE_MASK, arizona->pdata.gpsw);
1414 if (arizona->pdata.micd_pol_gpio > 0) {
1415 if (info->micd_modes[0].gpio)
1416 mode = GPIOF_OUT_INIT_HIGH;
1418 mode = GPIOF_OUT_INIT_LOW;
1420 ret = devm_gpio_request_one(&pdev->dev,
1421 arizona->pdata.micd_pol_gpio,
1425 dev_err(arizona->dev, "Failed to request GPIO%d: %d\n",
1426 arizona->pdata.micd_pol_gpio, ret);
1430 if (info->micd_modes[0].gpio)
1431 mode = GPIOD_OUT_HIGH;
1433 mode = GPIOD_OUT_LOW;
1435 /* We can't use devm here because we need to do the get
1436 * against the MFD device, as that is where the of_node
1437 * will reside, but if we devm against that the GPIO
1438 * will not be freed if the extcon driver is unloaded.
1440 info->micd_pol_gpio = gpiod_get_optional(arizona->dev,
1443 if (IS_ERR(info->micd_pol_gpio)) {
1444 ret = PTR_ERR(info->micd_pol_gpio);
1445 dev_err(arizona->dev,
1446 "Failed to get microphone polarity GPIO: %d\n",
1452 if (arizona->pdata.hpdet_id_gpio > 0) {
1453 ret = devm_gpio_request_one(&pdev->dev,
1454 arizona->pdata.hpdet_id_gpio,
1458 dev_err(arizona->dev, "Failed to request GPIO%d: %d\n",
1459 arizona->pdata.hpdet_id_gpio, ret);
1464 if (arizona->pdata.micd_bias_start_time)
1465 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_1,
1466 ARIZONA_MICD_BIAS_STARTTIME_MASK,
1467 arizona->pdata.micd_bias_start_time
1468 << ARIZONA_MICD_BIAS_STARTTIME_SHIFT);
1470 if (arizona->pdata.micd_rate)
1471 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_1,
1472 ARIZONA_MICD_RATE_MASK,
1473 arizona->pdata.micd_rate
1474 << ARIZONA_MICD_RATE_SHIFT);
1476 switch (arizona->pdata.micd_dbtime) {
1477 case MICD_DBTIME_FOUR_READINGS:
1478 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_1,
1479 ARIZONA_MICD_DBTIME_MASK,
1480 ARIZONA_MICD_DBTIME);
1482 case MICD_DBTIME_TWO_READINGS:
1483 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_1,
1484 ARIZONA_MICD_DBTIME_MASK, 0);
1490 BUILD_BUG_ON(ARRAY_SIZE(arizona_micd_levels) <
1491 ARIZONA_NUM_MICD_BUTTON_LEVELS);
1493 if (arizona->pdata.num_micd_ranges) {
1494 info->micd_ranges = pdata->micd_ranges;
1495 info->num_micd_ranges = pdata->num_micd_ranges;
1497 info->micd_ranges = micd_default_ranges;
1498 info->num_micd_ranges = ARRAY_SIZE(micd_default_ranges);
1501 if (arizona->pdata.num_micd_ranges > ARIZONA_MAX_MICD_RANGE) {
1502 dev_err(arizona->dev, "Too many MICD ranges: %d\n",
1503 arizona->pdata.num_micd_ranges);
1506 if (info->num_micd_ranges > 1) {
1507 for (i = 1; i < info->num_micd_ranges; i++) {
1508 if (info->micd_ranges[i - 1].max >
1509 info->micd_ranges[i].max) {
1510 dev_err(arizona->dev,
1511 "MICD ranges must be sorted\n");
1518 /* Disable all buttons by default */
1519 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_2,
1520 ARIZONA_MICD_LVL_SEL_MASK, 0x81);
1522 /* Set up all the buttons the user specified */
1523 for (i = 0; i < info->num_micd_ranges; i++) {
1524 for (j = 0; j < ARIZONA_NUM_MICD_BUTTON_LEVELS; j++)
1525 if (arizona_micd_levels[j] >= info->micd_ranges[i].max)
1528 if (j == ARIZONA_NUM_MICD_BUTTON_LEVELS) {
1529 dev_err(arizona->dev, "Unsupported MICD level %d\n",
1530 info->micd_ranges[i].max);
1535 dev_dbg(arizona->dev, "%d ohms for MICD threshold %d\n",
1536 arizona_micd_levels[j], i);
1538 arizona_micd_set_level(arizona, i, j);
1539 input_set_capability(info->input, EV_KEY,
1540 info->micd_ranges[i].key);
1542 /* Enable reporting of that range */
1543 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_2,
1547 /* Set all the remaining keys to a maximum */
1548 for (; i < ARIZONA_MAX_MICD_RANGE; i++)
1549 arizona_micd_set_level(arizona, i, 0x3f);
1552 * If we have a clamp use it, activating in conjunction with
1553 * GPIO5 if that is connected for jack detect operation.
1555 if (info->micd_clamp) {
1556 if (arizona->pdata.jd_gpio5) {
1557 /* Put the GPIO into input mode with optional pull */
1559 if (arizona->pdata.jd_gpio5_nopull)
1560 val &= ~ARIZONA_GPN_PU;
1562 regmap_write(arizona->regmap, ARIZONA_GPIO5_CTRL,
1565 if (arizona->pdata.jd_invert)
1566 clamp_mode = ARIZONA_MICD_CLAMP_MODE_JDH_GP5H;
1568 clamp_mode = ARIZONA_MICD_CLAMP_MODE_JDL_GP5H;
1570 if (arizona->pdata.jd_invert)
1571 clamp_mode = ARIZONA_MICD_CLAMP_MODE_JDH;
1573 clamp_mode = ARIZONA_MICD_CLAMP_MODE_JDL;
1576 regmap_update_bits(arizona->regmap,
1577 ARIZONA_MICD_CLAMP_CONTROL,
1578 ARIZONA_MICD_CLAMP_MODE_MASK, clamp_mode);
1580 regmap_update_bits(arizona->regmap,
1581 ARIZONA_JACK_DETECT_DEBOUNCE,
1582 ARIZONA_MICD_CLAMP_DB,
1583 ARIZONA_MICD_CLAMP_DB);
1586 arizona_extcon_set_mode(info, 0);
1588 pm_runtime_enable(&pdev->dev);
1589 pm_runtime_idle(&pdev->dev);
1590 pm_runtime_get_sync(&pdev->dev);
1592 if (info->micd_clamp) {
1593 jack_irq_rise = ARIZONA_IRQ_MICD_CLAMP_RISE;
1594 jack_irq_fall = ARIZONA_IRQ_MICD_CLAMP_FALL;
1596 jack_irq_rise = ARIZONA_IRQ_JD_RISE;
1597 jack_irq_fall = ARIZONA_IRQ_JD_FALL;
1600 ret = arizona_request_irq(arizona, jack_irq_rise,
1601 "JACKDET rise", arizona_jackdet, info);
1603 dev_err(&pdev->dev, "Failed to get JACKDET rise IRQ: %d\n",
1608 ret = arizona_set_irq_wake(arizona, jack_irq_rise, 1);
1610 dev_err(&pdev->dev, "Failed to set JD rise IRQ wake: %d\n",
1615 ret = arizona_request_irq(arizona, jack_irq_fall,
1616 "JACKDET fall", arizona_jackdet, info);
1618 dev_err(&pdev->dev, "Failed to get JD fall IRQ: %d\n", ret);
1622 ret = arizona_set_irq_wake(arizona, jack_irq_fall, 1);
1624 dev_err(&pdev->dev, "Failed to set JD fall IRQ wake: %d\n",
1629 ret = arizona_request_irq(arizona, ARIZONA_IRQ_MICDET,
1630 "MICDET", arizona_micdet, info);
1632 dev_err(&pdev->dev, "Failed to get MICDET IRQ: %d\n", ret);
1636 ret = arizona_request_irq(arizona, ARIZONA_IRQ_HPDET,
1637 "HPDET", arizona_hpdet_irq, info);
1639 dev_err(&pdev->dev, "Failed to get HPDET IRQ: %d\n", ret);
1643 arizona_clk32k_enable(arizona);
1644 regmap_update_bits(arizona->regmap, ARIZONA_JACK_DETECT_DEBOUNCE,
1645 ARIZONA_JD1_DB, ARIZONA_JD1_DB);
1646 regmap_update_bits(arizona->regmap, ARIZONA_JACK_DETECT_ANALOGUE,
1647 ARIZONA_JD1_ENA, ARIZONA_JD1_ENA);
1649 ret = regulator_allow_bypass(info->micvdd, true);
1651 dev_warn(arizona->dev, "Failed to set MICVDD to bypass: %d\n",
1654 pm_runtime_put(&pdev->dev);
1656 ret = input_register_device(info->input);
1658 dev_err(&pdev->dev, "Can't register input device: %d\n", ret);
1665 arizona_free_irq(arizona, ARIZONA_IRQ_HPDET, info);
1667 arizona_free_irq(arizona, ARIZONA_IRQ_MICDET, info);
1669 arizona_set_irq_wake(arizona, jack_irq_fall, 0);
1671 arizona_free_irq(arizona, jack_irq_fall, info);
1673 arizona_set_irq_wake(arizona, jack_irq_rise, 0);
1675 arizona_free_irq(arizona, jack_irq_rise, info);
1677 gpiod_put(info->micd_pol_gpio);
1679 pm_runtime_disable(&pdev->dev);
1683 static int arizona_extcon_remove(struct platform_device *pdev)
1685 struct arizona_extcon_info *info = platform_get_drvdata(pdev);
1686 struct arizona *arizona = info->arizona;
1687 int jack_irq_rise, jack_irq_fall;
1690 regmap_update_bits_check(arizona->regmap, ARIZONA_MIC_DETECT_1,
1691 ARIZONA_MICD_ENA, 0,
1695 regulator_disable(info->micvdd);
1696 pm_runtime_put(info->dev);
1699 gpiod_put(info->micd_pol_gpio);
1701 pm_runtime_disable(&pdev->dev);
1703 regmap_update_bits(arizona->regmap,
1704 ARIZONA_MICD_CLAMP_CONTROL,
1705 ARIZONA_MICD_CLAMP_MODE_MASK, 0);
1707 if (info->micd_clamp) {
1708 jack_irq_rise = ARIZONA_IRQ_MICD_CLAMP_RISE;
1709 jack_irq_fall = ARIZONA_IRQ_MICD_CLAMP_FALL;
1711 jack_irq_rise = ARIZONA_IRQ_JD_RISE;
1712 jack_irq_fall = ARIZONA_IRQ_JD_FALL;
1715 arizona_set_irq_wake(arizona, jack_irq_rise, 0);
1716 arizona_set_irq_wake(arizona, jack_irq_fall, 0);
1717 arizona_free_irq(arizona, ARIZONA_IRQ_HPDET, info);
1718 arizona_free_irq(arizona, ARIZONA_IRQ_MICDET, info);
1719 arizona_free_irq(arizona, jack_irq_rise, info);
1720 arizona_free_irq(arizona, jack_irq_fall, info);
1721 cancel_delayed_work_sync(&info->hpdet_work);
1722 regmap_update_bits(arizona->regmap, ARIZONA_JACK_DETECT_ANALOGUE,
1723 ARIZONA_JD1_ENA, 0);
1724 arizona_clk32k_disable(arizona);
1729 static struct platform_driver arizona_extcon_driver = {
1731 .name = "arizona-extcon",
1733 .probe = arizona_extcon_probe,
1734 .remove = arizona_extcon_remove,
1737 module_platform_driver(arizona_extcon_driver);
1739 MODULE_DESCRIPTION("Arizona Extcon driver");
1740 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
1741 MODULE_LICENSE("GPL");
1742 MODULE_ALIAS("platform:extcon-arizona");