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;
277 struct snd_soc_component *component = snd_soc_dapm_to_component(dapm);
280 ret = snd_soc_component_force_enable_pin(component, widget);
282 dev_warn(arizona->dev, "Failed to enable %s: %d\n",
285 snd_soc_dapm_sync(dapm);
287 if (!arizona->pdata.micd_force_micbias) {
288 ret = snd_soc_component_disable_pin(component, widget);
290 dev_warn(arizona->dev, "Failed to disable %s: %d\n",
293 snd_soc_dapm_sync(dapm);
297 static void arizona_start_mic(struct arizona_extcon_info *info)
299 struct arizona *arizona = info->arizona;
304 /* Microphone detection can't use idle mode */
305 pm_runtime_get(info->dev);
307 if (info->detecting) {
308 ret = regulator_allow_bypass(info->micvdd, false);
310 dev_err(arizona->dev,
311 "Failed to regulate MICVDD: %d\n",
316 ret = regulator_enable(info->micvdd);
318 dev_err(arizona->dev, "Failed to enable MICVDD: %d\n",
322 if (info->micd_reva) {
323 regmap_write(arizona->regmap, 0x80, 0x3);
324 regmap_write(arizona->regmap, 0x294, 0);
325 regmap_write(arizona->regmap, 0x80, 0x0);
328 if (info->detecting && arizona->pdata.micd_software_compare)
329 mode = ARIZONA_ACCDET_MODE_ADC;
331 mode = ARIZONA_ACCDET_MODE_MIC;
333 regmap_update_bits(arizona->regmap,
334 ARIZONA_ACCESSORY_DETECT_MODE_1,
335 ARIZONA_ACCDET_MODE_MASK, mode);
337 arizona_extcon_pulse_micbias(info);
339 regmap_update_bits_check(arizona->regmap, ARIZONA_MIC_DETECT_1,
340 ARIZONA_MICD_ENA, ARIZONA_MICD_ENA,
343 regulator_disable(info->micvdd);
344 pm_runtime_put_autosuspend(info->dev);
348 static void arizona_stop_mic(struct arizona_extcon_info *info)
350 struct arizona *arizona = info->arizona;
351 const char *widget = arizona_extcon_get_micbias(info);
352 struct snd_soc_dapm_context *dapm = arizona->dapm;
353 struct snd_soc_component *component = snd_soc_dapm_to_component(dapm);
357 regmap_update_bits_check(arizona->regmap, ARIZONA_MIC_DETECT_1,
361 ret = snd_soc_component_disable_pin(component, widget);
363 dev_warn(arizona->dev,
364 "Failed to disable %s: %d\n",
367 snd_soc_dapm_sync(dapm);
369 if (info->micd_reva) {
370 regmap_write(arizona->regmap, 0x80, 0x3);
371 regmap_write(arizona->regmap, 0x294, 2);
372 regmap_write(arizona->regmap, 0x80, 0x0);
375 ret = regulator_allow_bypass(info->micvdd, true);
377 dev_err(arizona->dev, "Failed to bypass MICVDD: %d\n",
382 regulator_disable(info->micvdd);
383 pm_runtime_mark_last_busy(info->dev);
384 pm_runtime_put_autosuspend(info->dev);
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 },
398 #define ARIZONA_HPDET_B_RANGE_MAX 0x3fb
403 } arizona_hpdet_c_ranges[] = {
410 static int arizona_hpdet_read(struct arizona_extcon_info *info)
412 struct arizona *arizona = info->arizona;
413 unsigned int val, range;
416 ret = regmap_read(arizona->regmap, ARIZONA_HEADPHONE_DETECT_2, &val);
418 dev_err(arizona->dev, "Failed to read HPDET status: %d\n",
423 switch (info->hpdet_ip_version) {
425 if (!(val & ARIZONA_HP_DONE)) {
426 dev_err(arizona->dev, "HPDET did not complete: %x\n",
431 val &= ARIZONA_HP_LVL_MASK;
435 if (!(val & ARIZONA_HP_DONE_B)) {
436 dev_err(arizona->dev, "HPDET did not complete: %x\n",
441 ret = regmap_read(arizona->regmap, ARIZONA_HP_DACVAL, &val);
443 dev_err(arizona->dev, "Failed to read HP value: %d\n",
448 regmap_read(arizona->regmap, ARIZONA_HEADPHONE_DETECT_1,
450 range = (range & ARIZONA_HP_IMPEDANCE_RANGE_MASK)
451 >> ARIZONA_HP_IMPEDANCE_RANGE_SHIFT;
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)) {
457 dev_dbg(arizona->dev, "Moving to HPDET range %d\n",
459 regmap_update_bits(arizona->regmap,
460 ARIZONA_HEADPHONE_DETECT_1,
461 ARIZONA_HP_IMPEDANCE_RANGE_MASK,
463 ARIZONA_HP_IMPEDANCE_RANGE_SHIFT);
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;
474 dev_dbg(arizona->dev, "HPDET read %d in range %d\n",
477 val = arizona_hpdet_b_ranges[range].factor_b
479 arizona_hpdet_b_ranges[range].factor_a);
483 if (!(val & ARIZONA_HP_DONE_B)) {
484 dev_err(arizona->dev, "HPDET did not complete: %x\n",
489 val &= ARIZONA_HP_LVL_B_MASK;
490 /* Convert to ohms, the value is in 0.5 ohm increments */
493 regmap_read(arizona->regmap, ARIZONA_HEADPHONE_DETECT_1,
495 range = (range & ARIZONA_HP_IMPEDANCE_RANGE_MASK)
496 >> ARIZONA_HP_IMPEDANCE_RANGE_SHIFT;
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)) {
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,
509 ARIZONA_HP_IMPEDANCE_RANGE_SHIFT);
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;
521 dev_warn(arizona->dev, "Unknown HPDET IP revision %d\n",
522 info->hpdet_ip_version);
526 dev_dbg(arizona->dev, "HP impedance %d ohms\n", val);
530 static int arizona_hpdet_do_id(struct arizona_extcon_info *info, int *reading,
533 struct arizona *arizona = info->arizona;
534 int id_gpio = arizona->pdata.hpdet_id_gpio;
537 * If we're using HPDET for accessory identification we need
538 * to take multiple measurements, step through them in sequence.
540 if (arizona->pdata.hpdet_acc_id) {
541 info->hpdet_res[info->num_hpdet_res++] = *reading;
543 /* Only check the mic directly if we didn't already ID it */
544 if (id_gpio && info->num_hpdet_res == 1) {
545 dev_dbg(arizona->dev, "Measuring mic\n");
547 regmap_update_bits(arizona->regmap,
548 ARIZONA_ACCESSORY_DETECT_MODE_1,
549 ARIZONA_ACCDET_MODE_MASK |
551 ARIZONA_ACCDET_MODE_HPR |
552 info->micd_modes[0].src);
554 gpio_set_value_cansleep(id_gpio, 1);
556 regmap_update_bits(arizona->regmap,
557 ARIZONA_HEADPHONE_DETECT_1,
558 ARIZONA_HP_POLL, ARIZONA_HP_POLL);
562 /* OK, got both. Now, compare... */
563 dev_dbg(arizona->dev, "HPDET measured %d %d\n",
564 info->hpdet_res[0], info->hpdet_res[1]);
566 /* Take the headphone impedance for the main report */
567 *reading = info->hpdet_res[0];
569 /* Sometimes we get false readings due to slow insert */
570 if (*reading >= ARIZONA_HPDET_MAX && !info->hpdet_retried) {
571 dev_dbg(arizona->dev, "Retrying high impedance\n");
572 info->num_hpdet_res = 0;
573 info->hpdet_retried = true;
574 arizona_start_hpdet_acc_id(info);
575 pm_runtime_put(info->dev);
580 * If we measure the mic as high impedance
582 if (!id_gpio || info->hpdet_res[1] > 50) {
583 dev_dbg(arizona->dev, "Detected mic\n");
585 info->detecting = true;
587 dev_dbg(arizona->dev, "Detected headphone\n");
590 /* Make sure everything is reset back to the real polarity */
591 regmap_update_bits(arizona->regmap,
592 ARIZONA_ACCESSORY_DETECT_MODE_1,
594 info->micd_modes[0].src);
600 static irqreturn_t arizona_hpdet_irq(int irq, void *data)
602 struct arizona_extcon_info *info = data;
603 struct arizona *arizona = info->arizona;
604 int id_gpio = arizona->pdata.hpdet_id_gpio;
605 unsigned int report = EXTCON_JACK_HEADPHONE;
609 mutex_lock(&info->lock);
611 /* If we got a spurious IRQ for some reason then ignore it */
612 if (!info->hpdet_active) {
613 dev_warn(arizona->dev, "Spurious HPDET IRQ\n");
614 mutex_unlock(&info->lock);
618 /* If the cable was removed while measuring ignore the result */
619 ret = extcon_get_state(info->edev, EXTCON_MECHANICAL);
621 dev_err(arizona->dev, "Failed to check cable state: %d\n",
625 dev_dbg(arizona->dev, "Ignoring HPDET for removed cable\n");
629 ret = arizona_hpdet_read(info);
636 /* Reset back to starting range */
637 regmap_update_bits(arizona->regmap,
638 ARIZONA_HEADPHONE_DETECT_1,
639 ARIZONA_HP_IMPEDANCE_RANGE_MASK | ARIZONA_HP_POLL,
642 ret = arizona_hpdet_do_id(info, &reading, &mic);
648 /* Report high impedence cables as line outputs */
650 report = EXTCON_JACK_LINE_OUT;
652 report = EXTCON_JACK_HEADPHONE;
654 ret = extcon_set_state_sync(info->edev, report, true);
656 dev_err(arizona->dev, "Failed to report HP/line: %d\n",
660 /* Reset back to starting range */
661 regmap_update_bits(arizona->regmap,
662 ARIZONA_HEADPHONE_DETECT_1,
663 ARIZONA_HP_IMPEDANCE_RANGE_MASK | ARIZONA_HP_POLL,
666 arizona_extcon_hp_clamp(info, false);
669 gpio_set_value_cansleep(id_gpio, 0);
671 /* Revert back to MICDET mode */
672 regmap_update_bits(arizona->regmap,
673 ARIZONA_ACCESSORY_DETECT_MODE_1,
674 ARIZONA_ACCDET_MODE_MASK, ARIZONA_ACCDET_MODE_MIC);
676 /* If we have a mic then reenable MICDET */
677 if (mic || info->mic)
678 arizona_start_mic(info);
680 if (info->hpdet_active) {
681 pm_runtime_put_autosuspend(info->dev);
682 info->hpdet_active = false;
685 info->hpdet_done = true;
688 mutex_unlock(&info->lock);
693 static void arizona_identify_headphone(struct arizona_extcon_info *info)
695 struct arizona *arizona = info->arizona;
698 if (info->hpdet_done)
701 dev_dbg(arizona->dev, "Starting HPDET\n");
703 /* Make sure we keep the device enabled during the measurement */
704 pm_runtime_get(info->dev);
706 info->hpdet_active = true;
709 arizona_stop_mic(info);
711 arizona_extcon_hp_clamp(info, true);
713 ret = regmap_update_bits(arizona->regmap,
714 ARIZONA_ACCESSORY_DETECT_MODE_1,
715 ARIZONA_ACCDET_MODE_MASK,
716 arizona->pdata.hpdet_channel);
718 dev_err(arizona->dev, "Failed to set HPDET mode: %d\n", ret);
722 ret = regmap_update_bits(arizona->regmap, ARIZONA_HEADPHONE_DETECT_1,
723 ARIZONA_HP_POLL, ARIZONA_HP_POLL);
725 dev_err(arizona->dev, "Can't start HPDETL measurement: %d\n",
733 regmap_update_bits(arizona->regmap, ARIZONA_ACCESSORY_DETECT_MODE_1,
734 ARIZONA_ACCDET_MODE_MASK, ARIZONA_ACCDET_MODE_MIC);
736 /* Just report headphone */
737 ret = extcon_set_state_sync(info->edev, EXTCON_JACK_HEADPHONE, true);
739 dev_err(arizona->dev, "Failed to report headphone: %d\n", ret);
742 arizona_start_mic(info);
744 info->hpdet_active = false;
747 static void arizona_start_hpdet_acc_id(struct arizona_extcon_info *info)
749 struct arizona *arizona = info->arizona;
754 dev_dbg(arizona->dev, "Starting identification via HPDET\n");
756 /* Make sure we keep the device enabled during the measurement */
757 pm_runtime_get_sync(info->dev);
759 info->hpdet_active = true;
761 arizona_extcon_hp_clamp(info, true);
763 ret = regmap_update_bits(arizona->regmap,
764 ARIZONA_ACCESSORY_DETECT_MODE_1,
765 ARIZONA_ACCDET_SRC | ARIZONA_ACCDET_MODE_MASK,
766 info->micd_modes[0].src |
767 arizona->pdata.hpdet_channel);
769 dev_err(arizona->dev, "Failed to set HPDET mode: %d\n", ret);
773 if (arizona->pdata.hpdet_acc_id_line) {
774 ret = regmap_update_bits(arizona->regmap,
775 ARIZONA_HEADPHONE_DETECT_1,
776 ARIZONA_HP_POLL, ARIZONA_HP_POLL);
778 dev_err(arizona->dev,
779 "Can't start HPDETL measurement: %d\n",
784 arizona_hpdet_do_id(info, &hp_reading, &mic);
790 regmap_update_bits(arizona->regmap, ARIZONA_ACCESSORY_DETECT_MODE_1,
791 ARIZONA_ACCDET_MODE_MASK, ARIZONA_ACCDET_MODE_MIC);
793 /* Just report headphone */
794 ret = extcon_set_state_sync(info->edev, EXTCON_JACK_HEADPHONE, true);
796 dev_err(arizona->dev, "Failed to report headphone: %d\n", ret);
798 info->hpdet_active = false;
801 static void arizona_micd_timeout_work(struct work_struct *work)
803 struct arizona_extcon_info *info = container_of(work,
804 struct arizona_extcon_info,
805 micd_timeout_work.work);
807 mutex_lock(&info->lock);
809 dev_dbg(info->arizona->dev, "MICD timed out, reporting HP\n");
811 info->detecting = false;
813 arizona_identify_headphone(info);
815 arizona_stop_mic(info);
817 mutex_unlock(&info->lock);
820 static void arizona_micd_detect(struct work_struct *work)
822 struct arizona_extcon_info *info = container_of(work,
823 struct arizona_extcon_info,
824 micd_detect_work.work);
825 struct arizona *arizona = info->arizona;
826 unsigned int val = 0, lvl;
829 cancel_delayed_work_sync(&info->micd_timeout_work);
831 mutex_lock(&info->lock);
833 /* If the cable was removed while measuring ignore the result */
834 ret = extcon_get_state(info->edev, EXTCON_MECHANICAL);
836 dev_err(arizona->dev, "Failed to check cable state: %d\n",
838 mutex_unlock(&info->lock);
841 dev_dbg(arizona->dev, "Ignoring MICDET for removed cable\n");
842 mutex_unlock(&info->lock);
846 if (info->detecting && arizona->pdata.micd_software_compare) {
847 /* Must disable MICD before we read the ADCVAL */
848 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_1,
849 ARIZONA_MICD_ENA, 0);
850 ret = regmap_read(arizona->regmap, ARIZONA_MIC_DETECT_4, &val);
852 dev_err(arizona->dev,
853 "Failed to read MICDET_ADCVAL: %d\n",
855 mutex_unlock(&info->lock);
859 dev_dbg(arizona->dev, "MICDET_ADCVAL: %x\n", val);
861 val &= ARIZONA_MICDET_ADCVAL_MASK;
862 if (val < ARRAY_SIZE(arizona_micd_levels))
863 val = arizona_micd_levels[val];
867 if (val <= QUICK_HEADPHONE_MAX_OHM)
868 val = ARIZONA_MICD_STS | ARIZONA_MICD_LVL_0;
869 else if (val <= MICROPHONE_MIN_OHM)
870 val = ARIZONA_MICD_STS | ARIZONA_MICD_LVL_1;
871 else if (val <= MICROPHONE_MAX_OHM)
872 val = ARIZONA_MICD_STS | ARIZONA_MICD_LVL_8;
874 val = ARIZONA_MICD_LVL_8;
877 for (i = 0; i < 10 && !(val & MICD_LVL_0_TO_8); i++) {
878 ret = regmap_read(arizona->regmap, ARIZONA_MIC_DETECT_3, &val);
880 dev_err(arizona->dev,
881 "Failed to read MICDET: %d\n", ret);
882 mutex_unlock(&info->lock);
886 dev_dbg(arizona->dev, "MICDET: %x\n", val);
888 if (!(val & ARIZONA_MICD_VALID)) {
889 dev_warn(arizona->dev,
890 "Microphone detection state invalid\n");
891 mutex_unlock(&info->lock);
896 if (i == 10 && !(val & MICD_LVL_0_TO_8)) {
897 dev_err(arizona->dev, "Failed to get valid MICDET value\n");
898 mutex_unlock(&info->lock);
902 /* Due to jack detect this should never happen */
903 if (!(val & ARIZONA_MICD_STS)) {
904 dev_warn(arizona->dev, "Detected open circuit\n");
906 arizona_stop_mic(info);
907 info->detecting = false;
908 arizona_identify_headphone(info);
912 /* If we got a high impedence we should have a headset, report it. */
913 if (info->detecting && (val & ARIZONA_MICD_LVL_8)) {
915 info->detecting = false;
917 arizona_identify_headphone(info);
919 ret = extcon_set_state_sync(info->edev,
920 EXTCON_JACK_MICROPHONE, true);
922 dev_err(arizona->dev, "Headset report failed: %d\n",
925 /* Don't need to regulate for button detection */
926 ret = regulator_allow_bypass(info->micvdd, true);
928 dev_err(arizona->dev, "Failed to bypass MICVDD: %d\n",
935 /* If we detected a lower impedence during initial startup
936 * then we probably have the wrong polarity, flip it. Don't
937 * do this for the lowest impedences to speed up detection of
938 * plain headphones. If both polarities report a low
939 * impedence then give up and report headphones.
941 if (info->detecting && (val & MICD_LVL_1_TO_7)) {
942 if (info->jack_flips >= info->micd_num_modes * 10) {
943 dev_dbg(arizona->dev, "Detected HP/line\n");
945 info->detecting = false;
947 arizona_identify_headphone(info);
949 arizona_stop_mic(info);
952 if (info->micd_mode == info->micd_num_modes)
954 arizona_extcon_set_mode(info, info->micd_mode);
963 * If we're still detecting and we detect a short then we've
964 * got a headphone. Otherwise it's a button press.
966 if (val & MICD_LVL_0_TO_7) {
968 dev_dbg(arizona->dev, "Mic button detected\n");
970 lvl = val & ARIZONA_MICD_LVL_MASK;
971 lvl >>= ARIZONA_MICD_LVL_SHIFT;
973 for (i = 0; i < info->num_micd_ranges; i++)
974 input_report_key(info->input,
975 info->micd_ranges[i].key, 0);
978 WARN_ON(ffs(lvl) - 1 >= info->num_micd_ranges);
979 if (lvl && ffs(lvl) - 1 < info->num_micd_ranges) {
980 key = info->micd_ranges[ffs(lvl) - 1].key;
981 input_report_key(info->input, key, 1);
982 input_sync(info->input);
985 } else if (info->detecting) {
986 dev_dbg(arizona->dev, "Headphone detected\n");
987 info->detecting = false;
988 arizona_stop_mic(info);
990 arizona_identify_headphone(info);
992 dev_warn(arizona->dev, "Button with no mic: %x\n",
996 dev_dbg(arizona->dev, "Mic button released\n");
997 for (i = 0; i < info->num_micd_ranges; i++)
998 input_report_key(info->input,
999 info->micd_ranges[i].key, 0);
1000 input_sync(info->input);
1001 arizona_extcon_pulse_micbias(info);
1005 if (info->detecting) {
1006 if (arizona->pdata.micd_software_compare)
1007 regmap_update_bits(arizona->regmap,
1008 ARIZONA_MIC_DETECT_1,
1012 queue_delayed_work(system_power_efficient_wq,
1013 &info->micd_timeout_work,
1014 msecs_to_jiffies(info->micd_timeout));
1017 pm_runtime_mark_last_busy(info->dev);
1018 mutex_unlock(&info->lock);
1021 static irqreturn_t arizona_micdet(int irq, void *data)
1023 struct arizona_extcon_info *info = data;
1024 struct arizona *arizona = info->arizona;
1025 int debounce = arizona->pdata.micd_detect_debounce;
1027 cancel_delayed_work_sync(&info->micd_detect_work);
1028 cancel_delayed_work_sync(&info->micd_timeout_work);
1030 mutex_lock(&info->lock);
1031 if (!info->detecting)
1033 mutex_unlock(&info->lock);
1036 queue_delayed_work(system_power_efficient_wq,
1037 &info->micd_detect_work,
1038 msecs_to_jiffies(debounce));
1040 arizona_micd_detect(&info->micd_detect_work.work);
1045 static void arizona_hpdet_work(struct work_struct *work)
1047 struct arizona_extcon_info *info = container_of(work,
1048 struct arizona_extcon_info,
1051 mutex_lock(&info->lock);
1052 arizona_start_hpdet_acc_id(info);
1053 mutex_unlock(&info->lock);
1056 static irqreturn_t arizona_jackdet(int irq, void *data)
1058 struct arizona_extcon_info *info = data;
1059 struct arizona *arizona = info->arizona;
1060 unsigned int val, present, mask;
1061 bool cancelled_hp, cancelled_mic;
1064 cancelled_hp = cancel_delayed_work_sync(&info->hpdet_work);
1065 cancelled_mic = cancel_delayed_work_sync(&info->micd_timeout_work);
1067 pm_runtime_get_sync(info->dev);
1069 mutex_lock(&info->lock);
1071 if (info->micd_clamp) {
1072 mask = ARIZONA_MICD_CLAMP_STS;
1075 mask = ARIZONA_JD1_STS;
1076 if (arizona->pdata.jd_invert)
1079 present = ARIZONA_JD1_STS;
1082 ret = regmap_read(arizona->regmap, ARIZONA_AOD_IRQ_RAW_STATUS, &val);
1084 dev_err(arizona->dev, "Failed to read jackdet status: %d\n",
1086 mutex_unlock(&info->lock);
1087 pm_runtime_put_autosuspend(info->dev);
1092 if (val == info->last_jackdet) {
1093 dev_dbg(arizona->dev, "Suppressing duplicate JACKDET\n");
1095 queue_delayed_work(system_power_efficient_wq,
1097 msecs_to_jiffies(HPDET_DEBOUNCE));
1099 if (cancelled_mic) {
1100 int micd_timeout = info->micd_timeout;
1102 queue_delayed_work(system_power_efficient_wq,
1103 &info->micd_timeout_work,
1104 msecs_to_jiffies(micd_timeout));
1109 info->last_jackdet = val;
1111 if (info->last_jackdet == present) {
1112 dev_dbg(arizona->dev, "Detected jack\n");
1113 ret = extcon_set_state_sync(info->edev,
1114 EXTCON_MECHANICAL, true);
1117 dev_err(arizona->dev, "Mechanical report failed: %d\n",
1120 if (!arizona->pdata.hpdet_acc_id) {
1121 info->detecting = true;
1123 info->jack_flips = 0;
1125 arizona_start_mic(info);
1127 queue_delayed_work(system_power_efficient_wq,
1129 msecs_to_jiffies(HPDET_DEBOUNCE));
1132 if (info->micd_clamp || !arizona->pdata.jd_invert)
1133 regmap_update_bits(arizona->regmap,
1134 ARIZONA_JACK_DETECT_DEBOUNCE,
1135 ARIZONA_MICD_CLAMP_DB |
1138 dev_dbg(arizona->dev, "Detected jack removal\n");
1140 arizona_stop_mic(info);
1142 info->num_hpdet_res = 0;
1143 for (i = 0; i < ARRAY_SIZE(info->hpdet_res); i++)
1144 info->hpdet_res[i] = 0;
1146 info->hpdet_done = false;
1147 info->hpdet_retried = false;
1149 for (i = 0; i < info->num_micd_ranges; i++)
1150 input_report_key(info->input,
1151 info->micd_ranges[i].key, 0);
1152 input_sync(info->input);
1154 for (i = 0; i < ARRAY_SIZE(arizona_cable) - 1; i++) {
1155 ret = extcon_set_state_sync(info->edev,
1156 arizona_cable[i], false);
1158 dev_err(arizona->dev,
1159 "Removal report failed: %d\n", ret);
1162 regmap_update_bits(arizona->regmap,
1163 ARIZONA_JACK_DETECT_DEBOUNCE,
1164 ARIZONA_MICD_CLAMP_DB | ARIZONA_JD1_DB,
1165 ARIZONA_MICD_CLAMP_DB | ARIZONA_JD1_DB);
1168 if (arizona->pdata.micd_timeout)
1169 info->micd_timeout = arizona->pdata.micd_timeout;
1171 info->micd_timeout = DEFAULT_MICD_TIMEOUT;
1174 /* Clear trig_sts to make sure DCVDD is not forced up */
1175 regmap_write(arizona->regmap, ARIZONA_AOD_WKUP_AND_TRIG,
1176 ARIZONA_MICD_CLAMP_FALL_TRIG_STS |
1177 ARIZONA_MICD_CLAMP_RISE_TRIG_STS |
1178 ARIZONA_JD1_FALL_TRIG_STS |
1179 ARIZONA_JD1_RISE_TRIG_STS);
1181 mutex_unlock(&info->lock);
1183 pm_runtime_mark_last_busy(info->dev);
1184 pm_runtime_put_autosuspend(info->dev);
1189 /* Map a level onto a slot in the register bank */
1190 static void arizona_micd_set_level(struct arizona *arizona, int index,
1196 reg = ARIZONA_MIC_DETECT_LEVEL_4 - (index / 2);
1205 /* Program the level itself */
1206 regmap_update_bits(arizona->regmap, reg, mask, level);
1209 static int arizona_extcon_get_micd_configs(struct device *dev,
1210 struct arizona *arizona)
1212 const char * const prop = "wlf,micd-configs";
1213 const int entries_per_config = 3;
1214 struct arizona_micd_config *micd_configs;
1219 nconfs = device_property_read_u32_array(arizona->dev, prop, NULL, 0);
1223 vals = kcalloc(nconfs, sizeof(u32), GFP_KERNEL);
1227 ret = device_property_read_u32_array(arizona->dev, prop, vals, nconfs);
1231 nconfs /= entries_per_config;
1233 micd_configs = devm_kzalloc(dev,
1234 nconfs * sizeof(struct arizona_micd_range),
1236 if (!micd_configs) {
1241 for (i = 0, j = 0; i < nconfs; ++i) {
1242 micd_configs[i].src = vals[j++] ? ARIZONA_ACCDET_SRC : 0;
1243 micd_configs[i].bias = vals[j++];
1244 micd_configs[i].gpio = vals[j++];
1247 arizona->pdata.micd_configs = micd_configs;
1248 arizona->pdata.num_micd_configs = nconfs;
1255 static int arizona_extcon_device_get_pdata(struct device *dev,
1256 struct arizona *arizona)
1258 struct arizona_pdata *pdata = &arizona->pdata;
1259 unsigned int val = ARIZONA_ACCDET_MODE_HPL;
1262 device_property_read_u32(arizona->dev, "wlf,hpdet-channel", &val);
1264 case ARIZONA_ACCDET_MODE_HPL:
1265 case ARIZONA_ACCDET_MODE_HPR:
1266 pdata->hpdet_channel = val;
1269 dev_err(arizona->dev,
1270 "Wrong wlf,hpdet-channel DT value %d\n", val);
1271 pdata->hpdet_channel = ARIZONA_ACCDET_MODE_HPL;
1274 device_property_read_u32(arizona->dev, "wlf,micd-detect-debounce",
1275 &pdata->micd_detect_debounce);
1277 device_property_read_u32(arizona->dev, "wlf,micd-bias-start-time",
1278 &pdata->micd_bias_start_time);
1280 device_property_read_u32(arizona->dev, "wlf,micd-rate",
1283 device_property_read_u32(arizona->dev, "wlf,micd-dbtime",
1284 &pdata->micd_dbtime);
1286 device_property_read_u32(arizona->dev, "wlf,micd-timeout-ms",
1287 &pdata->micd_timeout);
1289 pdata->micd_force_micbias = device_property_read_bool(arizona->dev,
1290 "wlf,micd-force-micbias");
1292 pdata->micd_software_compare = device_property_read_bool(arizona->dev,
1293 "wlf,micd-software-compare");
1295 pdata->jd_invert = device_property_read_bool(arizona->dev,
1298 device_property_read_u32(arizona->dev, "wlf,gpsw", &pdata->gpsw);
1300 pdata->jd_gpio5 = device_property_read_bool(arizona->dev,
1302 pdata->jd_gpio5_nopull = device_property_read_bool(arizona->dev,
1303 "wlf,use-jd2-nopull");
1305 ret = arizona_extcon_get_micd_configs(dev, arizona);
1307 dev_err(arizona->dev, "Failed to read micd configs: %d\n", ret);
1312 static int arizona_extcon_probe(struct platform_device *pdev)
1314 struct arizona *arizona = dev_get_drvdata(pdev->dev.parent);
1315 struct arizona_pdata *pdata = &arizona->pdata;
1316 struct arizona_extcon_info *info;
1318 unsigned int clamp_mode;
1319 int jack_irq_fall, jack_irq_rise;
1320 int ret, mode, i, j;
1322 if (!arizona->dapm || !arizona->dapm->card)
1323 return -EPROBE_DEFER;
1325 info = devm_kzalloc(&pdev->dev, sizeof(*info), GFP_KERNEL);
1329 if (!dev_get_platdata(arizona->dev))
1330 arizona_extcon_device_get_pdata(&pdev->dev, arizona);
1332 info->micvdd = devm_regulator_get(&pdev->dev, "MICVDD");
1333 if (IS_ERR(info->micvdd)) {
1334 ret = PTR_ERR(info->micvdd);
1335 dev_err(arizona->dev, "Failed to get MICVDD: %d\n", ret);
1339 mutex_init(&info->lock);
1340 info->arizona = arizona;
1341 info->dev = &pdev->dev;
1342 info->last_jackdet = ~(ARIZONA_MICD_CLAMP_STS | ARIZONA_JD1_STS);
1343 INIT_DELAYED_WORK(&info->hpdet_work, arizona_hpdet_work);
1344 INIT_DELAYED_WORK(&info->micd_detect_work, arizona_micd_detect);
1345 INIT_DELAYED_WORK(&info->micd_timeout_work, arizona_micd_timeout_work);
1346 platform_set_drvdata(pdev, info);
1348 switch (arizona->type) {
1350 switch (arizona->rev) {
1352 info->micd_reva = true;
1355 info->micd_clamp = true;
1356 info->hpdet_ip_version = 1;
1362 switch (arizona->rev) {
1366 info->micd_clamp = true;
1367 info->hpdet_ip_version = 2;
1373 info->micd_clamp = true;
1374 info->hpdet_ip_version = 2;
1380 info->edev = devm_extcon_dev_allocate(&pdev->dev, arizona_cable);
1381 if (IS_ERR(info->edev)) {
1382 dev_err(&pdev->dev, "failed to allocate extcon device\n");
1386 ret = devm_extcon_dev_register(&pdev->dev, info->edev);
1388 dev_err(arizona->dev, "extcon_dev_register() failed: %d\n",
1393 info->input = devm_input_allocate_device(&pdev->dev);
1395 dev_err(arizona->dev, "Can't allocate input dev\n");
1400 info->input->name = "Headset";
1401 info->input->phys = "arizona/extcon";
1403 if (pdata->num_micd_configs) {
1404 info->micd_modes = pdata->micd_configs;
1405 info->micd_num_modes = pdata->num_micd_configs;
1407 info->micd_modes = micd_default_modes;
1408 info->micd_num_modes = ARRAY_SIZE(micd_default_modes);
1411 if (arizona->pdata.gpsw > 0)
1412 regmap_update_bits(arizona->regmap, ARIZONA_GP_SWITCH_1,
1413 ARIZONA_SW1_MODE_MASK, arizona->pdata.gpsw);
1415 if (arizona->pdata.micd_pol_gpio > 0) {
1416 if (info->micd_modes[0].gpio)
1417 mode = GPIOF_OUT_INIT_HIGH;
1419 mode = GPIOF_OUT_INIT_LOW;
1421 ret = devm_gpio_request_one(&pdev->dev,
1422 arizona->pdata.micd_pol_gpio,
1426 dev_err(arizona->dev, "Failed to request GPIO%d: %d\n",
1427 arizona->pdata.micd_pol_gpio, ret);
1431 if (info->micd_modes[0].gpio)
1432 mode = GPIOD_OUT_HIGH;
1434 mode = GPIOD_OUT_LOW;
1436 /* We can't use devm here because we need to do the get
1437 * against the MFD device, as that is where the of_node
1438 * will reside, but if we devm against that the GPIO
1439 * will not be freed if the extcon driver is unloaded.
1441 info->micd_pol_gpio = gpiod_get_optional(arizona->dev,
1444 if (IS_ERR(info->micd_pol_gpio)) {
1445 ret = PTR_ERR(info->micd_pol_gpio);
1446 dev_err(arizona->dev,
1447 "Failed to get microphone polarity GPIO: %d\n",
1453 if (arizona->pdata.hpdet_id_gpio > 0) {
1454 ret = devm_gpio_request_one(&pdev->dev,
1455 arizona->pdata.hpdet_id_gpio,
1459 dev_err(arizona->dev, "Failed to request GPIO%d: %d\n",
1460 arizona->pdata.hpdet_id_gpio, ret);
1465 if (arizona->pdata.micd_bias_start_time)
1466 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_1,
1467 ARIZONA_MICD_BIAS_STARTTIME_MASK,
1468 arizona->pdata.micd_bias_start_time
1469 << ARIZONA_MICD_BIAS_STARTTIME_SHIFT);
1471 if (arizona->pdata.micd_rate)
1472 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_1,
1473 ARIZONA_MICD_RATE_MASK,
1474 arizona->pdata.micd_rate
1475 << ARIZONA_MICD_RATE_SHIFT);
1477 switch (arizona->pdata.micd_dbtime) {
1478 case MICD_DBTIME_FOUR_READINGS:
1479 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_1,
1480 ARIZONA_MICD_DBTIME_MASK,
1481 ARIZONA_MICD_DBTIME);
1483 case MICD_DBTIME_TWO_READINGS:
1484 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_1,
1485 ARIZONA_MICD_DBTIME_MASK, 0);
1491 BUILD_BUG_ON(ARRAY_SIZE(arizona_micd_levels) <
1492 ARIZONA_NUM_MICD_BUTTON_LEVELS);
1494 if (arizona->pdata.num_micd_ranges) {
1495 info->micd_ranges = pdata->micd_ranges;
1496 info->num_micd_ranges = pdata->num_micd_ranges;
1498 info->micd_ranges = micd_default_ranges;
1499 info->num_micd_ranges = ARRAY_SIZE(micd_default_ranges);
1502 if (arizona->pdata.num_micd_ranges > ARIZONA_MAX_MICD_RANGE) {
1503 dev_err(arizona->dev, "Too many MICD ranges: %d\n",
1504 arizona->pdata.num_micd_ranges);
1507 if (info->num_micd_ranges > 1) {
1508 for (i = 1; i < info->num_micd_ranges; i++) {
1509 if (info->micd_ranges[i - 1].max >
1510 info->micd_ranges[i].max) {
1511 dev_err(arizona->dev,
1512 "MICD ranges must be sorted\n");
1519 /* Disable all buttons by default */
1520 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_2,
1521 ARIZONA_MICD_LVL_SEL_MASK, 0x81);
1523 /* Set up all the buttons the user specified */
1524 for (i = 0; i < info->num_micd_ranges; i++) {
1525 for (j = 0; j < ARIZONA_NUM_MICD_BUTTON_LEVELS; j++)
1526 if (arizona_micd_levels[j] >= info->micd_ranges[i].max)
1529 if (j == ARIZONA_NUM_MICD_BUTTON_LEVELS) {
1530 dev_err(arizona->dev, "Unsupported MICD level %d\n",
1531 info->micd_ranges[i].max);
1536 dev_dbg(arizona->dev, "%d ohms for MICD threshold %d\n",
1537 arizona_micd_levels[j], i);
1539 arizona_micd_set_level(arizona, i, j);
1540 input_set_capability(info->input, EV_KEY,
1541 info->micd_ranges[i].key);
1543 /* Enable reporting of that range */
1544 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_2,
1548 /* Set all the remaining keys to a maximum */
1549 for (; i < ARIZONA_MAX_MICD_RANGE; i++)
1550 arizona_micd_set_level(arizona, i, 0x3f);
1553 * If we have a clamp use it, activating in conjunction with
1554 * GPIO5 if that is connected for jack detect operation.
1556 if (info->micd_clamp) {
1557 if (arizona->pdata.jd_gpio5) {
1558 /* Put the GPIO into input mode with optional pull */
1560 if (arizona->pdata.jd_gpio5_nopull)
1561 val &= ~ARIZONA_GPN_PU;
1563 regmap_write(arizona->regmap, ARIZONA_GPIO5_CTRL,
1566 if (arizona->pdata.jd_invert)
1567 clamp_mode = ARIZONA_MICD_CLAMP_MODE_JDH_GP5H;
1569 clamp_mode = ARIZONA_MICD_CLAMP_MODE_JDL_GP5H;
1571 if (arizona->pdata.jd_invert)
1572 clamp_mode = ARIZONA_MICD_CLAMP_MODE_JDH;
1574 clamp_mode = ARIZONA_MICD_CLAMP_MODE_JDL;
1577 regmap_update_bits(arizona->regmap,
1578 ARIZONA_MICD_CLAMP_CONTROL,
1579 ARIZONA_MICD_CLAMP_MODE_MASK, clamp_mode);
1581 regmap_update_bits(arizona->regmap,
1582 ARIZONA_JACK_DETECT_DEBOUNCE,
1583 ARIZONA_MICD_CLAMP_DB,
1584 ARIZONA_MICD_CLAMP_DB);
1587 arizona_extcon_set_mode(info, 0);
1589 pm_runtime_enable(&pdev->dev);
1590 pm_runtime_idle(&pdev->dev);
1591 pm_runtime_get_sync(&pdev->dev);
1593 if (info->micd_clamp) {
1594 jack_irq_rise = ARIZONA_IRQ_MICD_CLAMP_RISE;
1595 jack_irq_fall = ARIZONA_IRQ_MICD_CLAMP_FALL;
1597 jack_irq_rise = ARIZONA_IRQ_JD_RISE;
1598 jack_irq_fall = ARIZONA_IRQ_JD_FALL;
1601 ret = arizona_request_irq(arizona, jack_irq_rise,
1602 "JACKDET rise", arizona_jackdet, info);
1604 dev_err(&pdev->dev, "Failed to get JACKDET rise IRQ: %d\n",
1609 ret = arizona_set_irq_wake(arizona, jack_irq_rise, 1);
1611 dev_err(&pdev->dev, "Failed to set JD rise IRQ wake: %d\n",
1616 ret = arizona_request_irq(arizona, jack_irq_fall,
1617 "JACKDET fall", arizona_jackdet, info);
1619 dev_err(&pdev->dev, "Failed to get JD fall IRQ: %d\n", ret);
1623 ret = arizona_set_irq_wake(arizona, jack_irq_fall, 1);
1625 dev_err(&pdev->dev, "Failed to set JD fall IRQ wake: %d\n",
1630 ret = arizona_request_irq(arizona, ARIZONA_IRQ_MICDET,
1631 "MICDET", arizona_micdet, info);
1633 dev_err(&pdev->dev, "Failed to get MICDET IRQ: %d\n", ret);
1637 ret = arizona_request_irq(arizona, ARIZONA_IRQ_HPDET,
1638 "HPDET", arizona_hpdet_irq, info);
1640 dev_err(&pdev->dev, "Failed to get HPDET IRQ: %d\n", ret);
1644 arizona_clk32k_enable(arizona);
1645 regmap_update_bits(arizona->regmap, ARIZONA_JACK_DETECT_DEBOUNCE,
1646 ARIZONA_JD1_DB, ARIZONA_JD1_DB);
1647 regmap_update_bits(arizona->regmap, ARIZONA_JACK_DETECT_ANALOGUE,
1648 ARIZONA_JD1_ENA, ARIZONA_JD1_ENA);
1650 ret = regulator_allow_bypass(info->micvdd, true);
1652 dev_warn(arizona->dev, "Failed to set MICVDD to bypass: %d\n",
1655 pm_runtime_put(&pdev->dev);
1657 ret = input_register_device(info->input);
1659 dev_err(&pdev->dev, "Can't register input device: %d\n", ret);
1666 arizona_free_irq(arizona, ARIZONA_IRQ_HPDET, info);
1668 arizona_free_irq(arizona, ARIZONA_IRQ_MICDET, info);
1670 arizona_set_irq_wake(arizona, jack_irq_fall, 0);
1672 arizona_free_irq(arizona, jack_irq_fall, info);
1674 arizona_set_irq_wake(arizona, jack_irq_rise, 0);
1676 arizona_free_irq(arizona, jack_irq_rise, info);
1678 gpiod_put(info->micd_pol_gpio);
1680 pm_runtime_disable(&pdev->dev);
1684 static int arizona_extcon_remove(struct platform_device *pdev)
1686 struct arizona_extcon_info *info = platform_get_drvdata(pdev);
1687 struct arizona *arizona = info->arizona;
1688 int jack_irq_rise, jack_irq_fall;
1690 gpiod_put(info->micd_pol_gpio);
1692 pm_runtime_disable(&pdev->dev);
1694 regmap_update_bits(arizona->regmap,
1695 ARIZONA_MICD_CLAMP_CONTROL,
1696 ARIZONA_MICD_CLAMP_MODE_MASK, 0);
1698 if (info->micd_clamp) {
1699 jack_irq_rise = ARIZONA_IRQ_MICD_CLAMP_RISE;
1700 jack_irq_fall = ARIZONA_IRQ_MICD_CLAMP_FALL;
1702 jack_irq_rise = ARIZONA_IRQ_JD_RISE;
1703 jack_irq_fall = ARIZONA_IRQ_JD_FALL;
1706 arizona_set_irq_wake(arizona, jack_irq_rise, 0);
1707 arizona_set_irq_wake(arizona, jack_irq_fall, 0);
1708 arizona_free_irq(arizona, ARIZONA_IRQ_HPDET, info);
1709 arizona_free_irq(arizona, ARIZONA_IRQ_MICDET, info);
1710 arizona_free_irq(arizona, jack_irq_rise, info);
1711 arizona_free_irq(arizona, jack_irq_fall, info);
1712 cancel_delayed_work_sync(&info->hpdet_work);
1713 regmap_update_bits(arizona->regmap, ARIZONA_JACK_DETECT_ANALOGUE,
1714 ARIZONA_JD1_ENA, 0);
1715 arizona_clk32k_disable(arizona);
1720 static struct platform_driver arizona_extcon_driver = {
1722 .name = "arizona-extcon",
1724 .probe = arizona_extcon_probe,
1725 .remove = arizona_extcon_remove,
1728 module_platform_driver(arizona_extcon_driver);
1730 MODULE_DESCRIPTION("Arizona Extcon driver");
1731 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
1732 MODULE_LICENSE("GPL");
1733 MODULE_ALIAS("platform:extcon-arizona");