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 mutex_lock(&arizona->dapm->card->dapm_mutex);
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 mutex_unlock(&arizona->dapm->card->dapm_mutex);
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;
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 ret = extcon_get_cable_state_(info->edev, EXTCON_MECHANICAL);
619 dev_err(arizona->dev, "Failed to check cable state: %d\n",
623 dev_dbg(arizona->dev, "Ignoring HPDET for removed cable\n");
627 ret = arizona_hpdet_read(info);
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,
640 ret = arizona_hpdet_do_id(info, &reading, &mic);
646 /* Report high impedence cables as line outputs */
648 report = EXTCON_JACK_LINE_OUT;
650 report = EXTCON_JACK_HEADPHONE;
652 ret = extcon_set_cable_state_(info->edev, report, true);
654 dev_err(arizona->dev, "Failed to report HP/line: %d\n",
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,
664 arizona_extcon_hp_clamp(info, false);
667 gpio_set_value_cansleep(id_gpio, 0);
669 /* Revert back to MICDET mode */
670 regmap_update_bits(arizona->regmap,
671 ARIZONA_ACCESSORY_DETECT_MODE_1,
672 ARIZONA_ACCDET_MODE_MASK, ARIZONA_ACCDET_MODE_MIC);
674 /* If we have a mic then reenable MICDET */
675 if (mic || info->mic)
676 arizona_start_mic(info);
678 if (info->hpdet_active) {
679 pm_runtime_put_autosuspend(info->dev);
680 info->hpdet_active = false;
683 info->hpdet_done = true;
686 mutex_unlock(&info->lock);
691 static void arizona_identify_headphone(struct arizona_extcon_info *info)
693 struct arizona *arizona = info->arizona;
696 if (info->hpdet_done)
699 dev_dbg(arizona->dev, "Starting HPDET\n");
701 /* Make sure we keep the device enabled during the measurement */
702 pm_runtime_get(info->dev);
704 info->hpdet_active = true;
707 arizona_stop_mic(info);
709 arizona_extcon_hp_clamp(info, true);
711 ret = regmap_update_bits(arizona->regmap,
712 ARIZONA_ACCESSORY_DETECT_MODE_1,
713 ARIZONA_ACCDET_MODE_MASK,
714 arizona->pdata.hpdet_channel);
716 dev_err(arizona->dev, "Failed to set HPDET mode: %d\n", ret);
720 ret = regmap_update_bits(arizona->regmap, ARIZONA_HEADPHONE_DETECT_1,
721 ARIZONA_HP_POLL, ARIZONA_HP_POLL);
723 dev_err(arizona->dev, "Can't start HPDETL measurement: %d\n",
731 regmap_update_bits(arizona->regmap, ARIZONA_ACCESSORY_DETECT_MODE_1,
732 ARIZONA_ACCDET_MODE_MASK, ARIZONA_ACCDET_MODE_MIC);
734 /* Just report headphone */
735 ret = extcon_set_cable_state_(info->edev, EXTCON_JACK_HEADPHONE, true);
737 dev_err(arizona->dev, "Failed to report headphone: %d\n", ret);
740 arizona_start_mic(info);
742 info->hpdet_active = false;
745 static void arizona_start_hpdet_acc_id(struct arizona_extcon_info *info)
747 struct arizona *arizona = info->arizona;
752 dev_dbg(arizona->dev, "Starting identification via HPDET\n");
754 /* Make sure we keep the device enabled during the measurement */
755 pm_runtime_get_sync(info->dev);
757 info->hpdet_active = true;
759 arizona_extcon_hp_clamp(info, true);
761 ret = regmap_update_bits(arizona->regmap,
762 ARIZONA_ACCESSORY_DETECT_MODE_1,
763 ARIZONA_ACCDET_SRC | ARIZONA_ACCDET_MODE_MASK,
764 info->micd_modes[0].src |
765 arizona->pdata.hpdet_channel);
767 dev_err(arizona->dev, "Failed to set HPDET mode: %d\n", ret);
771 if (arizona->pdata.hpdet_acc_id_line) {
772 ret = regmap_update_bits(arizona->regmap,
773 ARIZONA_HEADPHONE_DETECT_1,
774 ARIZONA_HP_POLL, ARIZONA_HP_POLL);
776 dev_err(arizona->dev,
777 "Can't start HPDETL measurement: %d\n",
782 arizona_hpdet_do_id(info, &hp_reading, &mic);
788 regmap_update_bits(arizona->regmap, ARIZONA_ACCESSORY_DETECT_MODE_1,
789 ARIZONA_ACCDET_MODE_MASK, ARIZONA_ACCDET_MODE_MIC);
791 /* Just report headphone */
792 ret = extcon_set_cable_state_(info->edev, EXTCON_JACK_HEADPHONE, true);
794 dev_err(arizona->dev, "Failed to report headphone: %d\n", ret);
796 info->hpdet_active = false;
799 static void arizona_micd_timeout_work(struct work_struct *work)
801 struct arizona_extcon_info *info = container_of(work,
802 struct arizona_extcon_info,
803 micd_timeout_work.work);
805 mutex_lock(&info->lock);
807 dev_dbg(info->arizona->dev, "MICD timed out, reporting HP\n");
809 info->detecting = false;
811 arizona_identify_headphone(info);
813 arizona_stop_mic(info);
815 mutex_unlock(&info->lock);
818 static void arizona_micd_detect(struct work_struct *work)
820 struct arizona_extcon_info *info = container_of(work,
821 struct arizona_extcon_info,
822 micd_detect_work.work);
823 struct arizona *arizona = info->arizona;
824 unsigned int val = 0, lvl;
827 cancel_delayed_work_sync(&info->micd_timeout_work);
829 mutex_lock(&info->lock);
831 /* If the cable was removed while measuring ignore the result */
832 ret = extcon_get_cable_state_(info->edev, EXTCON_MECHANICAL);
834 dev_err(arizona->dev, "Failed to check cable state: %d\n",
836 mutex_unlock(&info->lock);
839 dev_dbg(arizona->dev, "Ignoring MICDET for removed cable\n");
840 mutex_unlock(&info->lock);
844 if (info->detecting && arizona->pdata.micd_software_compare) {
845 /* Must disable MICD before we read the ADCVAL */
846 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_1,
847 ARIZONA_MICD_ENA, 0);
848 ret = regmap_read(arizona->regmap, ARIZONA_MIC_DETECT_4, &val);
850 dev_err(arizona->dev,
851 "Failed to read MICDET_ADCVAL: %d\n",
853 mutex_unlock(&info->lock);
857 dev_dbg(arizona->dev, "MICDET_ADCVAL: %x\n", val);
859 val &= ARIZONA_MICDET_ADCVAL_MASK;
860 if (val < ARRAY_SIZE(arizona_micd_levels))
861 val = arizona_micd_levels[val];
865 if (val <= QUICK_HEADPHONE_MAX_OHM)
866 val = ARIZONA_MICD_STS | ARIZONA_MICD_LVL_0;
867 else if (val <= MICROPHONE_MIN_OHM)
868 val = ARIZONA_MICD_STS | ARIZONA_MICD_LVL_1;
869 else if (val <= MICROPHONE_MAX_OHM)
870 val = ARIZONA_MICD_STS | ARIZONA_MICD_LVL_8;
872 val = ARIZONA_MICD_LVL_8;
875 for (i = 0; i < 10 && !(val & MICD_LVL_0_TO_8); i++) {
876 ret = regmap_read(arizona->regmap, ARIZONA_MIC_DETECT_3, &val);
878 dev_err(arizona->dev,
879 "Failed to read MICDET: %d\n", ret);
880 mutex_unlock(&info->lock);
884 dev_dbg(arizona->dev, "MICDET: %x\n", val);
886 if (!(val & ARIZONA_MICD_VALID)) {
887 dev_warn(arizona->dev,
888 "Microphone detection state invalid\n");
889 mutex_unlock(&info->lock);
894 if (i == 10 && !(val & MICD_LVL_0_TO_8)) {
895 dev_err(arizona->dev, "Failed to get valid MICDET value\n");
896 mutex_unlock(&info->lock);
900 /* Due to jack detect this should never happen */
901 if (!(val & ARIZONA_MICD_STS)) {
902 dev_warn(arizona->dev, "Detected open circuit\n");
904 arizona_stop_mic(info);
905 info->detecting = false;
906 arizona_identify_headphone(info);
910 /* If we got a high impedence we should have a headset, report it. */
911 if (info->detecting && (val & ARIZONA_MICD_LVL_8)) {
913 info->detecting = false;
915 arizona_identify_headphone(info);
917 ret = extcon_set_cable_state_(info->edev,
918 EXTCON_JACK_MICROPHONE, true);
920 dev_err(arizona->dev, "Headset report failed: %d\n",
923 /* Don't need to regulate for button detection */
924 ret = regulator_allow_bypass(info->micvdd, true);
926 dev_err(arizona->dev, "Failed to bypass MICVDD: %d\n",
933 /* If we detected a lower impedence during initial startup
934 * then we probably have the wrong polarity, flip it. Don't
935 * do this for the lowest impedences to speed up detection of
936 * plain headphones. If both polarities report a low
937 * impedence then give up and report headphones.
939 if (info->detecting && (val & MICD_LVL_1_TO_7)) {
940 if (info->jack_flips >= info->micd_num_modes * 10) {
941 dev_dbg(arizona->dev, "Detected HP/line\n");
943 info->detecting = false;
945 arizona_identify_headphone(info);
947 arizona_stop_mic(info);
950 if (info->micd_mode == info->micd_num_modes)
952 arizona_extcon_set_mode(info, info->micd_mode);
961 * If we're still detecting and we detect a short then we've
962 * got a headphone. Otherwise it's a button press.
964 if (val & MICD_LVL_0_TO_7) {
966 dev_dbg(arizona->dev, "Mic button detected\n");
968 lvl = val & ARIZONA_MICD_LVL_MASK;
969 lvl >>= ARIZONA_MICD_LVL_SHIFT;
971 for (i = 0; i < info->num_micd_ranges; i++)
972 input_report_key(info->input,
973 info->micd_ranges[i].key, 0);
976 WARN_ON(ffs(lvl) - 1 >= info->num_micd_ranges);
977 if (lvl && ffs(lvl) - 1 < info->num_micd_ranges) {
978 key = info->micd_ranges[ffs(lvl) - 1].key;
979 input_report_key(info->input, key, 1);
980 input_sync(info->input);
983 } else if (info->detecting) {
984 dev_dbg(arizona->dev, "Headphone detected\n");
985 info->detecting = false;
986 arizona_stop_mic(info);
988 arizona_identify_headphone(info);
990 dev_warn(arizona->dev, "Button with no mic: %x\n",
994 dev_dbg(arizona->dev, "Mic button released\n");
995 for (i = 0; i < info->num_micd_ranges; i++)
996 input_report_key(info->input,
997 info->micd_ranges[i].key, 0);
998 input_sync(info->input);
999 arizona_extcon_pulse_micbias(info);
1003 if (info->detecting) {
1004 if (arizona->pdata.micd_software_compare)
1005 regmap_update_bits(arizona->regmap,
1006 ARIZONA_MIC_DETECT_1,
1010 queue_delayed_work(system_power_efficient_wq,
1011 &info->micd_timeout_work,
1012 msecs_to_jiffies(info->micd_timeout));
1015 pm_runtime_mark_last_busy(info->dev);
1016 mutex_unlock(&info->lock);
1019 static irqreturn_t arizona_micdet(int irq, void *data)
1021 struct arizona_extcon_info *info = data;
1022 struct arizona *arizona = info->arizona;
1023 int debounce = arizona->pdata.micd_detect_debounce;
1025 cancel_delayed_work_sync(&info->micd_detect_work);
1026 cancel_delayed_work_sync(&info->micd_timeout_work);
1028 mutex_lock(&info->lock);
1029 if (!info->detecting)
1031 mutex_unlock(&info->lock);
1034 queue_delayed_work(system_power_efficient_wq,
1035 &info->micd_detect_work,
1036 msecs_to_jiffies(debounce));
1038 arizona_micd_detect(&info->micd_detect_work.work);
1043 static void arizona_hpdet_work(struct work_struct *work)
1045 struct arizona_extcon_info *info = container_of(work,
1046 struct arizona_extcon_info,
1049 mutex_lock(&info->lock);
1050 arizona_start_hpdet_acc_id(info);
1051 mutex_unlock(&info->lock);
1054 static irqreturn_t arizona_jackdet(int irq, void *data)
1056 struct arizona_extcon_info *info = data;
1057 struct arizona *arizona = info->arizona;
1058 unsigned int val, present, mask;
1059 bool cancelled_hp, cancelled_mic;
1062 cancelled_hp = cancel_delayed_work_sync(&info->hpdet_work);
1063 cancelled_mic = cancel_delayed_work_sync(&info->micd_timeout_work);
1065 pm_runtime_get_sync(info->dev);
1067 mutex_lock(&info->lock);
1069 if (info->micd_clamp) {
1070 mask = ARIZONA_MICD_CLAMP_STS;
1073 mask = ARIZONA_JD1_STS;
1074 if (arizona->pdata.jd_invert)
1077 present = ARIZONA_JD1_STS;
1080 ret = regmap_read(arizona->regmap, ARIZONA_AOD_IRQ_RAW_STATUS, &val);
1082 dev_err(arizona->dev, "Failed to read jackdet status: %d\n",
1084 mutex_unlock(&info->lock);
1085 pm_runtime_put_autosuspend(info->dev);
1090 if (val == info->last_jackdet) {
1091 dev_dbg(arizona->dev, "Suppressing duplicate JACKDET\n");
1093 queue_delayed_work(system_power_efficient_wq,
1095 msecs_to_jiffies(HPDET_DEBOUNCE));
1097 if (cancelled_mic) {
1098 int micd_timeout = info->micd_timeout;
1100 queue_delayed_work(system_power_efficient_wq,
1101 &info->micd_timeout_work,
1102 msecs_to_jiffies(micd_timeout));
1107 info->last_jackdet = val;
1109 if (info->last_jackdet == present) {
1110 dev_dbg(arizona->dev, "Detected jack\n");
1111 ret = extcon_set_cable_state_(info->edev,
1112 EXTCON_MECHANICAL, true);
1115 dev_err(arizona->dev, "Mechanical report failed: %d\n",
1118 if (!arizona->pdata.hpdet_acc_id) {
1119 info->detecting = true;
1121 info->jack_flips = 0;
1123 arizona_start_mic(info);
1125 queue_delayed_work(system_power_efficient_wq,
1127 msecs_to_jiffies(HPDET_DEBOUNCE));
1130 if (info->micd_clamp || !arizona->pdata.jd_invert)
1131 regmap_update_bits(arizona->regmap,
1132 ARIZONA_JACK_DETECT_DEBOUNCE,
1133 ARIZONA_MICD_CLAMP_DB |
1136 dev_dbg(arizona->dev, "Detected jack removal\n");
1138 arizona_stop_mic(info);
1140 info->num_hpdet_res = 0;
1141 for (i = 0; i < ARRAY_SIZE(info->hpdet_res); i++)
1142 info->hpdet_res[i] = 0;
1144 info->hpdet_done = false;
1145 info->hpdet_retried = false;
1147 for (i = 0; i < info->num_micd_ranges; i++)
1148 input_report_key(info->input,
1149 info->micd_ranges[i].key, 0);
1150 input_sync(info->input);
1152 ret = extcon_update_state(info->edev, 0xffffffff, 0);
1154 dev_err(arizona->dev, "Removal report failed: %d\n",
1157 regmap_update_bits(arizona->regmap,
1158 ARIZONA_JACK_DETECT_DEBOUNCE,
1159 ARIZONA_MICD_CLAMP_DB | ARIZONA_JD1_DB,
1160 ARIZONA_MICD_CLAMP_DB | ARIZONA_JD1_DB);
1163 if (arizona->pdata.micd_timeout)
1164 info->micd_timeout = arizona->pdata.micd_timeout;
1166 info->micd_timeout = DEFAULT_MICD_TIMEOUT;
1169 /* Clear trig_sts to make sure DCVDD is not forced up */
1170 regmap_write(arizona->regmap, ARIZONA_AOD_WKUP_AND_TRIG,
1171 ARIZONA_MICD_CLAMP_FALL_TRIG_STS |
1172 ARIZONA_MICD_CLAMP_RISE_TRIG_STS |
1173 ARIZONA_JD1_FALL_TRIG_STS |
1174 ARIZONA_JD1_RISE_TRIG_STS);
1176 mutex_unlock(&info->lock);
1178 pm_runtime_mark_last_busy(info->dev);
1179 pm_runtime_put_autosuspend(info->dev);
1184 /* Map a level onto a slot in the register bank */
1185 static void arizona_micd_set_level(struct arizona *arizona, int index,
1191 reg = ARIZONA_MIC_DETECT_LEVEL_4 - (index / 2);
1200 /* Program the level itself */
1201 regmap_update_bits(arizona->regmap, reg, mask, level);
1204 static int arizona_extcon_device_get_pdata(struct arizona *arizona)
1206 struct arizona_pdata *pdata = &arizona->pdata;
1207 unsigned int val = ARIZONA_ACCDET_MODE_HPL;
1209 device_property_read_u32(arizona->dev, "wlf,hpdet-channel", &val);
1211 case ARIZONA_ACCDET_MODE_HPL:
1212 case ARIZONA_ACCDET_MODE_HPR:
1213 pdata->hpdet_channel = val;
1216 dev_err(arizona->dev,
1217 "Wrong wlf,hpdet-channel DT value %d\n", val);
1218 pdata->hpdet_channel = ARIZONA_ACCDET_MODE_HPL;
1221 device_property_read_u32(arizona->dev, "wlf,micd-detect-debounce",
1222 &pdata->micd_detect_debounce);
1224 device_property_read_u32(arizona->dev, "wlf,micd-bias-start-time",
1225 &pdata->micd_bias_start_time);
1227 device_property_read_u32(arizona->dev, "wlf,micd-rate",
1230 device_property_read_u32(arizona->dev, "wlf,micd-dbtime",
1231 &pdata->micd_dbtime);
1233 device_property_read_u32(arizona->dev, "wlf,micd-timeout",
1234 &pdata->micd_timeout);
1236 pdata->micd_force_micbias = device_property_read_bool(arizona->dev,
1237 "wlf,micd-force-micbias");
1239 pdata->micd_software_compare = device_property_read_bool(arizona->dev,
1240 "wlf,micd-software-compare");
1242 pdata->jd_invert = device_property_read_bool(arizona->dev,
1245 device_property_read_u32(arizona->dev, "wlf,gpsw", &pdata->gpsw);
1250 static int arizona_extcon_probe(struct platform_device *pdev)
1252 struct arizona *arizona = dev_get_drvdata(pdev->dev.parent);
1253 struct arizona_pdata *pdata = &arizona->pdata;
1254 struct arizona_extcon_info *info;
1256 unsigned int clamp_mode;
1257 int jack_irq_fall, jack_irq_rise;
1258 int ret, mode, i, j;
1260 if (!arizona->dapm || !arizona->dapm->card)
1261 return -EPROBE_DEFER;
1263 info = devm_kzalloc(&pdev->dev, sizeof(*info), GFP_KERNEL);
1267 if (!dev_get_platdata(arizona->dev))
1268 arizona_extcon_device_get_pdata(arizona);
1270 info->micvdd = devm_regulator_get(&pdev->dev, "MICVDD");
1271 if (IS_ERR(info->micvdd)) {
1272 ret = PTR_ERR(info->micvdd);
1273 dev_err(arizona->dev, "Failed to get MICVDD: %d\n", ret);
1277 mutex_init(&info->lock);
1278 info->arizona = arizona;
1279 info->dev = &pdev->dev;
1280 info->last_jackdet = ~(ARIZONA_MICD_CLAMP_STS | ARIZONA_JD1_STS);
1281 INIT_DELAYED_WORK(&info->hpdet_work, arizona_hpdet_work);
1282 INIT_DELAYED_WORK(&info->micd_detect_work, arizona_micd_detect);
1283 INIT_DELAYED_WORK(&info->micd_timeout_work, arizona_micd_timeout_work);
1284 platform_set_drvdata(pdev, info);
1286 switch (arizona->type) {
1288 switch (arizona->rev) {
1290 info->micd_reva = true;
1293 info->micd_clamp = true;
1294 info->hpdet_ip_version = 1;
1300 switch (arizona->rev) {
1304 info->micd_clamp = true;
1305 info->hpdet_ip_version = 2;
1311 info->micd_clamp = true;
1312 info->hpdet_ip_version = 2;
1318 info->edev = devm_extcon_dev_allocate(&pdev->dev, arizona_cable);
1319 if (IS_ERR(info->edev)) {
1320 dev_err(&pdev->dev, "failed to allocate extcon device\n");
1324 ret = devm_extcon_dev_register(&pdev->dev, info->edev);
1326 dev_err(arizona->dev, "extcon_dev_register() failed: %d\n",
1331 info->input = devm_input_allocate_device(&pdev->dev);
1333 dev_err(arizona->dev, "Can't allocate input dev\n");
1338 info->input->name = "Headset";
1339 info->input->phys = "arizona/extcon";
1341 if (pdata->num_micd_configs) {
1342 info->micd_modes = pdata->micd_configs;
1343 info->micd_num_modes = pdata->num_micd_configs;
1345 info->micd_modes = micd_default_modes;
1346 info->micd_num_modes = ARRAY_SIZE(micd_default_modes);
1349 if (arizona->pdata.gpsw > 0)
1350 regmap_update_bits(arizona->regmap, ARIZONA_GP_SWITCH_1,
1351 ARIZONA_SW1_MODE_MASK, arizona->pdata.gpsw);
1353 if (arizona->pdata.micd_pol_gpio > 0) {
1354 if (info->micd_modes[0].gpio)
1355 mode = GPIOF_OUT_INIT_HIGH;
1357 mode = GPIOF_OUT_INIT_LOW;
1359 ret = devm_gpio_request_one(&pdev->dev,
1360 arizona->pdata.micd_pol_gpio,
1364 dev_err(arizona->dev, "Failed to request GPIO%d: %d\n",
1365 arizona->pdata.micd_pol_gpio, ret);
1369 if (info->micd_modes[0].gpio)
1370 mode = GPIOD_OUT_HIGH;
1372 mode = GPIOD_OUT_LOW;
1374 /* We can't use devm here because we need to do the get
1375 * against the MFD device, as that is where the of_node
1376 * will reside, but if we devm against that the GPIO
1377 * will not be freed if the extcon driver is unloaded.
1379 info->micd_pol_gpio = gpiod_get_optional(arizona->dev,
1382 if (IS_ERR(info->micd_pol_gpio)) {
1383 ret = PTR_ERR(info->micd_pol_gpio);
1384 dev_err(arizona->dev,
1385 "Failed to get microphone polarity GPIO: %d\n",
1391 if (arizona->pdata.hpdet_id_gpio > 0) {
1392 ret = devm_gpio_request_one(&pdev->dev,
1393 arizona->pdata.hpdet_id_gpio,
1397 dev_err(arizona->dev, "Failed to request GPIO%d: %d\n",
1398 arizona->pdata.hpdet_id_gpio, ret);
1403 if (arizona->pdata.micd_bias_start_time)
1404 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_1,
1405 ARIZONA_MICD_BIAS_STARTTIME_MASK,
1406 arizona->pdata.micd_bias_start_time
1407 << ARIZONA_MICD_BIAS_STARTTIME_SHIFT);
1409 if (arizona->pdata.micd_rate)
1410 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_1,
1411 ARIZONA_MICD_RATE_MASK,
1412 arizona->pdata.micd_rate
1413 << ARIZONA_MICD_RATE_SHIFT);
1415 switch (arizona->pdata.micd_dbtime) {
1416 case MICD_DBTIME_FOUR_READINGS:
1417 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_1,
1418 ARIZONA_MICD_DBTIME_MASK,
1419 ARIZONA_MICD_DBTIME);
1421 case MICD_DBTIME_TWO_READINGS:
1422 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_1,
1423 ARIZONA_MICD_DBTIME_MASK, 0);
1429 BUILD_BUG_ON(ARRAY_SIZE(arizona_micd_levels) <
1430 ARIZONA_NUM_MICD_BUTTON_LEVELS);
1432 if (arizona->pdata.num_micd_ranges) {
1433 info->micd_ranges = pdata->micd_ranges;
1434 info->num_micd_ranges = pdata->num_micd_ranges;
1436 info->micd_ranges = micd_default_ranges;
1437 info->num_micd_ranges = ARRAY_SIZE(micd_default_ranges);
1440 if (arizona->pdata.num_micd_ranges > ARIZONA_MAX_MICD_RANGE) {
1441 dev_err(arizona->dev, "Too many MICD ranges: %d\n",
1442 arizona->pdata.num_micd_ranges);
1445 if (info->num_micd_ranges > 1) {
1446 for (i = 1; i < info->num_micd_ranges; i++) {
1447 if (info->micd_ranges[i - 1].max >
1448 info->micd_ranges[i].max) {
1449 dev_err(arizona->dev,
1450 "MICD ranges must be sorted\n");
1457 /* Disable all buttons by default */
1458 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_2,
1459 ARIZONA_MICD_LVL_SEL_MASK, 0x81);
1461 /* Set up all the buttons the user specified */
1462 for (i = 0; i < info->num_micd_ranges; i++) {
1463 for (j = 0; j < ARIZONA_NUM_MICD_BUTTON_LEVELS; j++)
1464 if (arizona_micd_levels[j] >= info->micd_ranges[i].max)
1467 if (j == ARIZONA_NUM_MICD_BUTTON_LEVELS) {
1468 dev_err(arizona->dev, "Unsupported MICD level %d\n",
1469 info->micd_ranges[i].max);
1474 dev_dbg(arizona->dev, "%d ohms for MICD threshold %d\n",
1475 arizona_micd_levels[j], i);
1477 arizona_micd_set_level(arizona, i, j);
1478 input_set_capability(info->input, EV_KEY,
1479 info->micd_ranges[i].key);
1481 /* Enable reporting of that range */
1482 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_2,
1486 /* Set all the remaining keys to a maximum */
1487 for (; i < ARIZONA_MAX_MICD_RANGE; i++)
1488 arizona_micd_set_level(arizona, i, 0x3f);
1491 * If we have a clamp use it, activating in conjunction with
1492 * GPIO5 if that is connected for jack detect operation.
1494 if (info->micd_clamp) {
1495 if (arizona->pdata.jd_gpio5) {
1496 /* Put the GPIO into input mode with optional pull */
1498 if (arizona->pdata.jd_gpio5_nopull)
1499 val &= ~ARIZONA_GPN_PU;
1501 regmap_write(arizona->regmap, ARIZONA_GPIO5_CTRL,
1504 if (arizona->pdata.jd_invert)
1505 clamp_mode = ARIZONA_MICD_CLAMP_MODE_JDH_GP5H;
1507 clamp_mode = ARIZONA_MICD_CLAMP_MODE_JDL_GP5H;
1509 if (arizona->pdata.jd_invert)
1510 clamp_mode = ARIZONA_MICD_CLAMP_MODE_JDH;
1512 clamp_mode = ARIZONA_MICD_CLAMP_MODE_JDL;
1515 regmap_update_bits(arizona->regmap,
1516 ARIZONA_MICD_CLAMP_CONTROL,
1517 ARIZONA_MICD_CLAMP_MODE_MASK, clamp_mode);
1519 regmap_update_bits(arizona->regmap,
1520 ARIZONA_JACK_DETECT_DEBOUNCE,
1521 ARIZONA_MICD_CLAMP_DB,
1522 ARIZONA_MICD_CLAMP_DB);
1525 arizona_extcon_set_mode(info, 0);
1527 pm_runtime_enable(&pdev->dev);
1528 pm_runtime_idle(&pdev->dev);
1529 pm_runtime_get_sync(&pdev->dev);
1531 if (info->micd_clamp) {
1532 jack_irq_rise = ARIZONA_IRQ_MICD_CLAMP_RISE;
1533 jack_irq_fall = ARIZONA_IRQ_MICD_CLAMP_FALL;
1535 jack_irq_rise = ARIZONA_IRQ_JD_RISE;
1536 jack_irq_fall = ARIZONA_IRQ_JD_FALL;
1539 ret = arizona_request_irq(arizona, jack_irq_rise,
1540 "JACKDET rise", arizona_jackdet, info);
1542 dev_err(&pdev->dev, "Failed to get JACKDET rise IRQ: %d\n",
1547 ret = arizona_set_irq_wake(arizona, jack_irq_rise, 1);
1549 dev_err(&pdev->dev, "Failed to set JD rise IRQ wake: %d\n",
1554 ret = arizona_request_irq(arizona, jack_irq_fall,
1555 "JACKDET fall", arizona_jackdet, info);
1557 dev_err(&pdev->dev, "Failed to get JD fall IRQ: %d\n", ret);
1561 ret = arizona_set_irq_wake(arizona, jack_irq_fall, 1);
1563 dev_err(&pdev->dev, "Failed to set JD fall IRQ wake: %d\n",
1568 ret = arizona_request_irq(arizona, ARIZONA_IRQ_MICDET,
1569 "MICDET", arizona_micdet, info);
1571 dev_err(&pdev->dev, "Failed to get MICDET IRQ: %d\n", ret);
1575 ret = arizona_request_irq(arizona, ARIZONA_IRQ_HPDET,
1576 "HPDET", arizona_hpdet_irq, info);
1578 dev_err(&pdev->dev, "Failed to get HPDET IRQ: %d\n", ret);
1582 arizona_clk32k_enable(arizona);
1583 regmap_update_bits(arizona->regmap, ARIZONA_JACK_DETECT_DEBOUNCE,
1584 ARIZONA_JD1_DB, ARIZONA_JD1_DB);
1585 regmap_update_bits(arizona->regmap, ARIZONA_JACK_DETECT_ANALOGUE,
1586 ARIZONA_JD1_ENA, ARIZONA_JD1_ENA);
1588 ret = regulator_allow_bypass(info->micvdd, true);
1590 dev_warn(arizona->dev, "Failed to set MICVDD to bypass: %d\n",
1593 pm_runtime_put(&pdev->dev);
1595 ret = input_register_device(info->input);
1597 dev_err(&pdev->dev, "Can't register input device: %d\n", ret);
1604 arizona_free_irq(arizona, ARIZONA_IRQ_HPDET, info);
1606 arizona_free_irq(arizona, ARIZONA_IRQ_MICDET, info);
1608 arizona_set_irq_wake(arizona, jack_irq_fall, 0);
1610 arizona_free_irq(arizona, jack_irq_fall, info);
1612 arizona_set_irq_wake(arizona, jack_irq_rise, 0);
1614 arizona_free_irq(arizona, jack_irq_rise, info);
1616 gpiod_put(info->micd_pol_gpio);
1618 pm_runtime_disable(&pdev->dev);
1622 static int arizona_extcon_remove(struct platform_device *pdev)
1624 struct arizona_extcon_info *info = platform_get_drvdata(pdev);
1625 struct arizona *arizona = info->arizona;
1626 int jack_irq_rise, jack_irq_fall;
1628 gpiod_put(info->micd_pol_gpio);
1630 pm_runtime_disable(&pdev->dev);
1632 regmap_update_bits(arizona->regmap,
1633 ARIZONA_MICD_CLAMP_CONTROL,
1634 ARIZONA_MICD_CLAMP_MODE_MASK, 0);
1636 if (info->micd_clamp) {
1637 jack_irq_rise = ARIZONA_IRQ_MICD_CLAMP_RISE;
1638 jack_irq_fall = ARIZONA_IRQ_MICD_CLAMP_FALL;
1640 jack_irq_rise = ARIZONA_IRQ_JD_RISE;
1641 jack_irq_fall = ARIZONA_IRQ_JD_FALL;
1644 arizona_set_irq_wake(arizona, jack_irq_rise, 0);
1645 arizona_set_irq_wake(arizona, jack_irq_fall, 0);
1646 arizona_free_irq(arizona, ARIZONA_IRQ_HPDET, info);
1647 arizona_free_irq(arizona, ARIZONA_IRQ_MICDET, info);
1648 arizona_free_irq(arizona, jack_irq_rise, info);
1649 arizona_free_irq(arizona, jack_irq_fall, info);
1650 cancel_delayed_work_sync(&info->hpdet_work);
1651 regmap_update_bits(arizona->regmap, ARIZONA_JACK_DETECT_ANALOGUE,
1652 ARIZONA_JD1_ENA, 0);
1653 arizona_clk32k_disable(arizona);
1658 static struct platform_driver arizona_extcon_driver = {
1660 .name = "arizona-extcon",
1662 .probe = arizona_extcon_probe,
1663 .remove = arizona_extcon_remove,
1666 module_platform_driver(arizona_extcon_driver);
1668 MODULE_DESCRIPTION("Arizona Extcon driver");
1669 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
1670 MODULE_LICENSE("GPL");
1671 MODULE_ALIAS("platform:extcon-arizona");