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 ARIZONA_HPDET_WAIT_COUNT 15
55 #define ARIZONA_HPDET_WAIT_DELAY_MS 20
57 #define QUICK_HEADPHONE_MAX_OHM 3
58 #define MICROPHONE_MIN_OHM 1257
59 #define MICROPHONE_MAX_OHM 30000
61 #define MICD_DBTIME_TWO_READINGS 2
62 #define MICD_DBTIME_FOUR_READINGS 4
64 #define MICD_LVL_1_TO_7 (ARIZONA_MICD_LVL_1 | ARIZONA_MICD_LVL_2 | \
65 ARIZONA_MICD_LVL_3 | ARIZONA_MICD_LVL_4 | \
66 ARIZONA_MICD_LVL_5 | ARIZONA_MICD_LVL_6 | \
69 #define MICD_LVL_0_TO_7 (ARIZONA_MICD_LVL_0 | MICD_LVL_1_TO_7)
71 #define MICD_LVL_0_TO_8 (MICD_LVL_0_TO_7 | ARIZONA_MICD_LVL_8)
73 struct arizona_extcon_info {
75 struct arizona *arizona;
77 struct regulator *micvdd;
78 struct input_dev *input;
83 const struct arizona_micd_config *micd_modes;
86 const struct arizona_micd_range *micd_ranges;
94 struct delayed_work hpdet_work;
95 struct delayed_work micd_detect_work;
96 struct delayed_work micd_timeout_work;
103 unsigned int hpdet_res[3];
109 int hpdet_ip_version;
111 struct extcon_dev *edev;
113 struct gpio_desc *micd_pol_gpio;
116 static const struct arizona_micd_config micd_default_modes[] = {
117 { ARIZONA_ACCDET_SRC, 1, 0 },
121 static const struct arizona_micd_range micd_default_ranges[] = {
122 { .max = 11, .key = BTN_0 },
123 { .max = 28, .key = BTN_1 },
124 { .max = 54, .key = BTN_2 },
125 { .max = 100, .key = BTN_3 },
126 { .max = 186, .key = BTN_4 },
127 { .max = 430, .key = BTN_5 },
130 /* The number of levels in arizona_micd_levels valid for button thresholds */
131 #define ARIZONA_NUM_MICD_BUTTON_LEVELS 64
133 static const int arizona_micd_levels[] = {
134 3, 6, 8, 11, 13, 16, 18, 21, 23, 26, 28, 31, 34, 36, 39, 41, 44, 46,
135 49, 52, 54, 57, 60, 62, 65, 67, 70, 73, 75, 78, 81, 83, 89, 94, 100,
136 105, 111, 116, 122, 127, 139, 150, 161, 173, 186, 196, 209, 220, 245,
137 270, 295, 321, 348, 375, 402, 430, 489, 550, 614, 681, 752, 903, 1071,
141 static const unsigned int arizona_cable[] = {
143 EXTCON_JACK_MICROPHONE,
144 EXTCON_JACK_HEADPHONE,
145 EXTCON_JACK_LINE_OUT,
149 static void arizona_start_hpdet_acc_id(struct arizona_extcon_info *info);
151 static void arizona_extcon_hp_clamp(struct arizona_extcon_info *info,
154 struct arizona *arizona = info->arizona;
155 unsigned int mask = 0, val = 0;
156 unsigned int cap_sel = 0;
159 switch (arizona->type) {
166 mask = ARIZONA_HP1L_SHRTO | ARIZONA_HP1L_FLWR |
169 val = ARIZONA_HP1L_SHRTO;
170 cap_sel = ARIZONA_TST_CAP_CLAMP;
172 val = ARIZONA_HP1L_FLWR | ARIZONA_HP1L_SHRTI;
173 cap_sel = ARIZONA_TST_CAP_DEFAULT;
176 ret = regmap_update_bits(arizona->regmap,
177 ARIZONA_HP_TEST_CTRL_1,
178 ARIZONA_HP1_TST_CAP_SEL_MASK,
181 dev_warn(arizona->dev,
182 "Failed to set TST_CAP_SEL: %d\n", ret);
185 mask = ARIZONA_RMV_SHRT_HP1L;
187 val = ARIZONA_RMV_SHRT_HP1L;
191 snd_soc_dapm_mutex_lock(arizona->dapm);
193 arizona->hpdet_clamp = clamp;
195 /* Keep the HP output stages disabled while doing the clamp */
197 ret = regmap_update_bits(arizona->regmap,
198 ARIZONA_OUTPUT_ENABLES_1,
200 ARIZONA_OUT1R_ENA, 0);
202 dev_warn(arizona->dev,
203 "Failed to disable headphone outputs: %d\n",
208 ret = regmap_update_bits(arizona->regmap, ARIZONA_HP_CTRL_1L,
211 dev_warn(arizona->dev, "Failed to do clamp: %d\n",
214 ret = regmap_update_bits(arizona->regmap, ARIZONA_HP_CTRL_1R,
217 dev_warn(arizona->dev, "Failed to do clamp: %d\n",
221 /* Restore the desired state while not doing the clamp */
223 ret = regmap_update_bits(arizona->regmap,
224 ARIZONA_OUTPUT_ENABLES_1,
226 ARIZONA_OUT1R_ENA, arizona->hp_ena);
228 dev_warn(arizona->dev,
229 "Failed to restore headphone outputs: %d\n",
233 snd_soc_dapm_mutex_unlock(arizona->dapm);
236 static void arizona_extcon_set_mode(struct arizona_extcon_info *info, int mode)
238 struct arizona *arizona = info->arizona;
240 mode %= info->micd_num_modes;
242 gpiod_set_value_cansleep(info->micd_pol_gpio,
243 info->micd_modes[mode].gpio);
245 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_1,
246 ARIZONA_MICD_BIAS_SRC_MASK,
247 info->micd_modes[mode].bias <<
248 ARIZONA_MICD_BIAS_SRC_SHIFT);
249 regmap_update_bits(arizona->regmap, ARIZONA_ACCESSORY_DETECT_MODE_1,
250 ARIZONA_ACCDET_SRC, info->micd_modes[mode].src);
252 info->micd_mode = mode;
254 dev_dbg(arizona->dev, "Set jack polarity to %d\n", mode);
257 static const char *arizona_extcon_get_micbias(struct arizona_extcon_info *info)
259 switch (info->micd_modes[0].bias) {
271 static void arizona_extcon_pulse_micbias(struct arizona_extcon_info *info)
273 struct arizona *arizona = info->arizona;
274 const char *widget = arizona_extcon_get_micbias(info);
275 struct snd_soc_dapm_context *dapm = arizona->dapm;
276 struct snd_soc_component *component = snd_soc_dapm_to_component(dapm);
279 ret = snd_soc_component_force_enable_pin(component, 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_component_disable_pin(component, 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;
352 struct snd_soc_component *component = snd_soc_dapm_to_component(dapm);
356 regmap_update_bits_check(arizona->regmap, ARIZONA_MIC_DETECT_1,
360 ret = snd_soc_component_disable_pin(component, widget);
362 dev_warn(arizona->dev,
363 "Failed to disable %s: %d\n",
366 snd_soc_dapm_sync(dapm);
368 if (info->micd_reva) {
369 regmap_write(arizona->regmap, 0x80, 0x3);
370 regmap_write(arizona->regmap, 0x294, 2);
371 regmap_write(arizona->regmap, 0x80, 0x0);
374 ret = regulator_allow_bypass(info->micvdd, true);
376 dev_err(arizona->dev, "Failed to bypass MICVDD: %d\n",
381 regulator_disable(info->micvdd);
382 pm_runtime_mark_last_busy(info->dev);
383 pm_runtime_put_autosuspend(info->dev);
388 unsigned int threshold;
389 unsigned int factor_a;
390 unsigned int factor_b;
391 } arizona_hpdet_b_ranges[] = {
392 { 100, 5528, 362464 },
393 { 169, 11084, 6186851 },
394 { 169, 11065, 65460395 },
397 #define ARIZONA_HPDET_B_RANGE_MAX 0x3fb
402 } arizona_hpdet_c_ranges[] = {
409 static int arizona_hpdet_read(struct arizona_extcon_info *info)
411 struct arizona *arizona = info->arizona;
412 unsigned int val, range;
415 ret = regmap_read(arizona->regmap, ARIZONA_HEADPHONE_DETECT_2, &val);
417 dev_err(arizona->dev, "Failed to read HPDET status: %d\n",
422 switch (info->hpdet_ip_version) {
424 if (!(val & ARIZONA_HP_DONE)) {
425 dev_err(arizona->dev, "HPDET did not complete: %x\n",
430 val &= ARIZONA_HP_LVL_MASK;
434 if (!(val & ARIZONA_HP_DONE_B)) {
435 dev_err(arizona->dev, "HPDET did not complete: %x\n",
440 ret = regmap_read(arizona->regmap, ARIZONA_HP_DACVAL, &val);
442 dev_err(arizona->dev, "Failed to read HP value: %d\n",
447 regmap_read(arizona->regmap, ARIZONA_HEADPHONE_DETECT_1,
449 range = (range & ARIZONA_HP_IMPEDANCE_RANGE_MASK)
450 >> ARIZONA_HP_IMPEDANCE_RANGE_SHIFT;
452 if (range < ARRAY_SIZE(arizona_hpdet_b_ranges) - 1 &&
453 (val < arizona_hpdet_b_ranges[range].threshold ||
454 val >= ARIZONA_HPDET_B_RANGE_MAX)) {
456 dev_dbg(arizona->dev, "Moving to HPDET range %d\n",
458 regmap_update_bits(arizona->regmap,
459 ARIZONA_HEADPHONE_DETECT_1,
460 ARIZONA_HP_IMPEDANCE_RANGE_MASK,
462 ARIZONA_HP_IMPEDANCE_RANGE_SHIFT);
466 /* If we go out of range report top of range */
467 if (val < arizona_hpdet_b_ranges[range].threshold ||
468 val >= ARIZONA_HPDET_B_RANGE_MAX) {
469 dev_dbg(arizona->dev, "Measurement out of range\n");
470 return ARIZONA_HPDET_MAX;
473 dev_dbg(arizona->dev, "HPDET read %d in range %d\n",
476 val = arizona_hpdet_b_ranges[range].factor_b
478 arizona_hpdet_b_ranges[range].factor_a);
482 if (!(val & ARIZONA_HP_DONE_B)) {
483 dev_err(arizona->dev, "HPDET did not complete: %x\n",
488 val &= ARIZONA_HP_LVL_B_MASK;
489 /* Convert to ohms, the value is in 0.5 ohm increments */
492 regmap_read(arizona->regmap, ARIZONA_HEADPHONE_DETECT_1,
494 range = (range & ARIZONA_HP_IMPEDANCE_RANGE_MASK)
495 >> ARIZONA_HP_IMPEDANCE_RANGE_SHIFT;
497 /* Skip up a range, or report? */
498 if (range < ARRAY_SIZE(arizona_hpdet_c_ranges) - 1 &&
499 (val >= arizona_hpdet_c_ranges[range].max)) {
501 dev_dbg(arizona->dev, "Moving to HPDET range %d-%d\n",
502 arizona_hpdet_c_ranges[range].min,
503 arizona_hpdet_c_ranges[range].max);
504 regmap_update_bits(arizona->regmap,
505 ARIZONA_HEADPHONE_DETECT_1,
506 ARIZONA_HP_IMPEDANCE_RANGE_MASK,
508 ARIZONA_HP_IMPEDANCE_RANGE_SHIFT);
512 if (range && (val < arizona_hpdet_c_ranges[range].min)) {
513 dev_dbg(arizona->dev, "Reporting range boundary %d\n",
514 arizona_hpdet_c_ranges[range].min);
515 val = arizona_hpdet_c_ranges[range].min;
520 dev_warn(arizona->dev, "Unknown HPDET IP revision %d\n",
521 info->hpdet_ip_version);
525 dev_dbg(arizona->dev, "HP impedance %d ohms\n", val);
529 static int arizona_hpdet_do_id(struct arizona_extcon_info *info, int *reading,
532 struct arizona *arizona = info->arizona;
533 int id_gpio = arizona->pdata.hpdet_id_gpio;
536 * If we're using HPDET for accessory identification we need
537 * to take multiple measurements, step through them in sequence.
539 if (arizona->pdata.hpdet_acc_id) {
540 info->hpdet_res[info->num_hpdet_res++] = *reading;
542 /* Only check the mic directly if we didn't already ID it */
543 if (id_gpio && info->num_hpdet_res == 1) {
544 dev_dbg(arizona->dev, "Measuring mic\n");
546 regmap_update_bits(arizona->regmap,
547 ARIZONA_ACCESSORY_DETECT_MODE_1,
548 ARIZONA_ACCDET_MODE_MASK |
550 ARIZONA_ACCDET_MODE_HPR |
551 info->micd_modes[0].src);
553 gpio_set_value_cansleep(id_gpio, 1);
555 regmap_update_bits(arizona->regmap,
556 ARIZONA_HEADPHONE_DETECT_1,
557 ARIZONA_HP_POLL, ARIZONA_HP_POLL);
561 /* OK, got both. Now, compare... */
562 dev_dbg(arizona->dev, "HPDET measured %d %d\n",
563 info->hpdet_res[0], info->hpdet_res[1]);
565 /* Take the headphone impedance for the main report */
566 *reading = info->hpdet_res[0];
568 /* Sometimes we get false readings due to slow insert */
569 if (*reading >= ARIZONA_HPDET_MAX && !info->hpdet_retried) {
570 dev_dbg(arizona->dev, "Retrying high impedance\n");
571 info->num_hpdet_res = 0;
572 info->hpdet_retried = true;
573 arizona_start_hpdet_acc_id(info);
574 pm_runtime_put(info->dev);
579 * If we measure the mic as high impedance
581 if (!id_gpio || info->hpdet_res[1] > 50) {
582 dev_dbg(arizona->dev, "Detected mic\n");
584 info->detecting = true;
586 dev_dbg(arizona->dev, "Detected headphone\n");
589 /* Make sure everything is reset back to the real polarity */
590 regmap_update_bits(arizona->regmap,
591 ARIZONA_ACCESSORY_DETECT_MODE_1,
593 info->micd_modes[0].src);
599 static irqreturn_t arizona_hpdet_irq(int irq, void *data)
601 struct arizona_extcon_info *info = data;
602 struct arizona *arizona = info->arizona;
603 int id_gpio = arizona->pdata.hpdet_id_gpio;
604 unsigned int report = EXTCON_JACK_HEADPHONE;
605 int ret, reading, state;
608 mutex_lock(&info->lock);
610 /* If we got a spurious IRQ for some reason then ignore it */
611 if (!info->hpdet_active) {
612 dev_warn(arizona->dev, "Spurious HPDET IRQ\n");
613 mutex_unlock(&info->lock);
617 /* If the cable was removed while measuring ignore the result */
618 state = extcon_get_state(info->edev, EXTCON_MECHANICAL);
620 dev_err(arizona->dev, "Failed to check cable state: %d\n", state);
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_state_sync(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 (state && (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 /* Do not set hp_det done when the cable has been unplugged */
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 int arizona_hpdet_wait(struct arizona_extcon_info *info)
1058 struct arizona *arizona = info->arizona;
1062 for (i = 0; i < ARIZONA_HPDET_WAIT_COUNT; i++) {
1063 ret = regmap_read(arizona->regmap, ARIZONA_HEADPHONE_DETECT_2,
1066 dev_err(arizona->dev,
1067 "Failed to read HPDET state: %d\n", ret);
1071 switch (info->hpdet_ip_version) {
1073 if (val & ARIZONA_HP_DONE)
1077 if (val & ARIZONA_HP_DONE_B)
1082 msleep(ARIZONA_HPDET_WAIT_DELAY_MS);
1085 dev_warn(arizona->dev, "HPDET did not appear to complete\n");
1090 static irqreturn_t arizona_jackdet(int irq, void *data)
1092 struct arizona_extcon_info *info = data;
1093 struct arizona *arizona = info->arizona;
1094 unsigned int val, present, mask;
1095 bool cancelled_hp, cancelled_mic;
1098 cancelled_hp = cancel_delayed_work_sync(&info->hpdet_work);
1099 cancelled_mic = cancel_delayed_work_sync(&info->micd_timeout_work);
1101 pm_runtime_get_sync(info->dev);
1103 mutex_lock(&info->lock);
1105 if (info->micd_clamp) {
1106 mask = ARIZONA_MICD_CLAMP_STS;
1109 mask = ARIZONA_JD1_STS;
1110 if (arizona->pdata.jd_invert)
1113 present = ARIZONA_JD1_STS;
1116 ret = regmap_read(arizona->regmap, ARIZONA_AOD_IRQ_RAW_STATUS, &val);
1118 dev_err(arizona->dev, "Failed to read jackdet status: %d\n",
1120 mutex_unlock(&info->lock);
1121 pm_runtime_put_autosuspend(info->dev);
1126 if (val == info->last_jackdet) {
1127 dev_dbg(arizona->dev, "Suppressing duplicate JACKDET\n");
1129 queue_delayed_work(system_power_efficient_wq,
1131 msecs_to_jiffies(HPDET_DEBOUNCE));
1133 if (cancelled_mic) {
1134 int micd_timeout = info->micd_timeout;
1136 queue_delayed_work(system_power_efficient_wq,
1137 &info->micd_timeout_work,
1138 msecs_to_jiffies(micd_timeout));
1143 info->last_jackdet = val;
1145 if (info->last_jackdet == present) {
1146 dev_dbg(arizona->dev, "Detected jack\n");
1147 ret = extcon_set_state_sync(info->edev,
1148 EXTCON_MECHANICAL, true);
1151 dev_err(arizona->dev, "Mechanical report failed: %d\n",
1154 if (!arizona->pdata.hpdet_acc_id) {
1155 info->detecting = true;
1157 info->jack_flips = 0;
1159 arizona_start_mic(info);
1161 queue_delayed_work(system_power_efficient_wq,
1163 msecs_to_jiffies(HPDET_DEBOUNCE));
1166 if (info->micd_clamp || !arizona->pdata.jd_invert)
1167 regmap_update_bits(arizona->regmap,
1168 ARIZONA_JACK_DETECT_DEBOUNCE,
1169 ARIZONA_MICD_CLAMP_DB |
1172 dev_dbg(arizona->dev, "Detected jack removal\n");
1174 arizona_stop_mic(info);
1176 info->num_hpdet_res = 0;
1177 for (i = 0; i < ARRAY_SIZE(info->hpdet_res); i++)
1178 info->hpdet_res[i] = 0;
1180 info->hpdet_done = false;
1181 info->hpdet_retried = false;
1183 for (i = 0; i < info->num_micd_ranges; i++)
1184 input_report_key(info->input,
1185 info->micd_ranges[i].key, 0);
1186 input_sync(info->input);
1188 for (i = 0; i < ARRAY_SIZE(arizona_cable) - 1; i++) {
1189 ret = extcon_set_state_sync(info->edev,
1190 arizona_cable[i], false);
1192 dev_err(arizona->dev,
1193 "Removal report failed: %d\n", ret);
1197 * If the jack was removed during a headphone detection we
1198 * need to wait for the headphone detection to finish, as
1199 * it can not be aborted. We don't want to be able to start
1200 * a new headphone detection from a fresh insert until this
1203 arizona_hpdet_wait(info);
1205 regmap_update_bits(arizona->regmap,
1206 ARIZONA_JACK_DETECT_DEBOUNCE,
1207 ARIZONA_MICD_CLAMP_DB | ARIZONA_JD1_DB,
1208 ARIZONA_MICD_CLAMP_DB | ARIZONA_JD1_DB);
1211 if (arizona->pdata.micd_timeout)
1212 info->micd_timeout = arizona->pdata.micd_timeout;
1214 info->micd_timeout = DEFAULT_MICD_TIMEOUT;
1217 /* Clear trig_sts to make sure DCVDD is not forced up */
1218 regmap_write(arizona->regmap, ARIZONA_AOD_WKUP_AND_TRIG,
1219 ARIZONA_MICD_CLAMP_FALL_TRIG_STS |
1220 ARIZONA_MICD_CLAMP_RISE_TRIG_STS |
1221 ARIZONA_JD1_FALL_TRIG_STS |
1222 ARIZONA_JD1_RISE_TRIG_STS);
1224 mutex_unlock(&info->lock);
1226 pm_runtime_mark_last_busy(info->dev);
1227 pm_runtime_put_autosuspend(info->dev);
1232 /* Map a level onto a slot in the register bank */
1233 static void arizona_micd_set_level(struct arizona *arizona, int index,
1239 reg = ARIZONA_MIC_DETECT_LEVEL_4 - (index / 2);
1248 /* Program the level itself */
1249 regmap_update_bits(arizona->regmap, reg, mask, level);
1252 static int arizona_extcon_get_micd_configs(struct device *dev,
1253 struct arizona *arizona)
1255 const char * const prop = "wlf,micd-configs";
1256 const int entries_per_config = 3;
1257 struct arizona_micd_config *micd_configs;
1262 nconfs = device_property_read_u32_array(arizona->dev, prop, NULL, 0);
1266 vals = kcalloc(nconfs, sizeof(u32), GFP_KERNEL);
1270 ret = device_property_read_u32_array(arizona->dev, prop, vals, nconfs);
1274 nconfs /= entries_per_config;
1275 micd_configs = devm_kcalloc(dev, nconfs, sizeof(*micd_configs),
1277 if (!micd_configs) {
1282 for (i = 0, j = 0; i < nconfs; ++i) {
1283 micd_configs[i].src = vals[j++] ? ARIZONA_ACCDET_SRC : 0;
1284 micd_configs[i].bias = vals[j++];
1285 micd_configs[i].gpio = vals[j++];
1288 arizona->pdata.micd_configs = micd_configs;
1289 arizona->pdata.num_micd_configs = nconfs;
1296 static int arizona_extcon_device_get_pdata(struct device *dev,
1297 struct arizona *arizona)
1299 struct arizona_pdata *pdata = &arizona->pdata;
1300 unsigned int val = ARIZONA_ACCDET_MODE_HPL;
1303 device_property_read_u32(arizona->dev, "wlf,hpdet-channel", &val);
1305 case ARIZONA_ACCDET_MODE_HPL:
1306 case ARIZONA_ACCDET_MODE_HPR:
1307 pdata->hpdet_channel = val;
1310 dev_err(arizona->dev,
1311 "Wrong wlf,hpdet-channel DT value %d\n", val);
1312 pdata->hpdet_channel = ARIZONA_ACCDET_MODE_HPL;
1315 device_property_read_u32(arizona->dev, "wlf,micd-detect-debounce",
1316 &pdata->micd_detect_debounce);
1318 device_property_read_u32(arizona->dev, "wlf,micd-bias-start-time",
1319 &pdata->micd_bias_start_time);
1321 device_property_read_u32(arizona->dev, "wlf,micd-rate",
1324 device_property_read_u32(arizona->dev, "wlf,micd-dbtime",
1325 &pdata->micd_dbtime);
1327 device_property_read_u32(arizona->dev, "wlf,micd-timeout-ms",
1328 &pdata->micd_timeout);
1330 pdata->micd_force_micbias = device_property_read_bool(arizona->dev,
1331 "wlf,micd-force-micbias");
1333 pdata->micd_software_compare = device_property_read_bool(arizona->dev,
1334 "wlf,micd-software-compare");
1336 pdata->jd_invert = device_property_read_bool(arizona->dev,
1339 device_property_read_u32(arizona->dev, "wlf,gpsw", &pdata->gpsw);
1341 pdata->jd_gpio5 = device_property_read_bool(arizona->dev,
1343 pdata->jd_gpio5_nopull = device_property_read_bool(arizona->dev,
1344 "wlf,use-jd2-nopull");
1346 ret = arizona_extcon_get_micd_configs(dev, arizona);
1348 dev_err(arizona->dev, "Failed to read micd configs: %d\n", ret);
1353 static int arizona_extcon_probe(struct platform_device *pdev)
1355 struct arizona *arizona = dev_get_drvdata(pdev->dev.parent);
1356 struct arizona_pdata *pdata = &arizona->pdata;
1357 struct arizona_extcon_info *info;
1359 unsigned int clamp_mode;
1360 int jack_irq_fall, jack_irq_rise;
1361 int ret, mode, i, j;
1363 if (!arizona->dapm || !arizona->dapm->card)
1364 return -EPROBE_DEFER;
1366 info = devm_kzalloc(&pdev->dev, sizeof(*info), GFP_KERNEL);
1370 if (!dev_get_platdata(arizona->dev))
1371 arizona_extcon_device_get_pdata(&pdev->dev, arizona);
1373 info->micvdd = devm_regulator_get(&pdev->dev, "MICVDD");
1374 if (IS_ERR(info->micvdd)) {
1375 ret = PTR_ERR(info->micvdd);
1376 dev_err(arizona->dev, "Failed to get MICVDD: %d\n", ret);
1380 mutex_init(&info->lock);
1381 info->arizona = arizona;
1382 info->dev = &pdev->dev;
1383 info->last_jackdet = ~(ARIZONA_MICD_CLAMP_STS | ARIZONA_JD1_STS);
1384 INIT_DELAYED_WORK(&info->hpdet_work, arizona_hpdet_work);
1385 INIT_DELAYED_WORK(&info->micd_detect_work, arizona_micd_detect);
1386 INIT_DELAYED_WORK(&info->micd_timeout_work, arizona_micd_timeout_work);
1387 platform_set_drvdata(pdev, info);
1389 switch (arizona->type) {
1391 switch (arizona->rev) {
1393 info->micd_reva = true;
1396 info->micd_clamp = true;
1397 info->hpdet_ip_version = 1;
1403 switch (arizona->rev) {
1407 info->micd_clamp = true;
1408 info->hpdet_ip_version = 2;
1414 info->micd_clamp = true;
1415 info->hpdet_ip_version = 2;
1421 info->edev = devm_extcon_dev_allocate(&pdev->dev, arizona_cable);
1422 if (IS_ERR(info->edev)) {
1423 dev_err(&pdev->dev, "failed to allocate extcon device\n");
1427 ret = devm_extcon_dev_register(&pdev->dev, info->edev);
1429 dev_err(arizona->dev, "extcon_dev_register() failed: %d\n",
1434 info->input = devm_input_allocate_device(&pdev->dev);
1436 dev_err(arizona->dev, "Can't allocate input dev\n");
1441 info->input->name = "Headset";
1442 info->input->phys = "arizona/extcon";
1444 if (pdata->num_micd_configs) {
1445 info->micd_modes = pdata->micd_configs;
1446 info->micd_num_modes = pdata->num_micd_configs;
1448 info->micd_modes = micd_default_modes;
1449 info->micd_num_modes = ARRAY_SIZE(micd_default_modes);
1452 if (arizona->pdata.gpsw > 0)
1453 regmap_update_bits(arizona->regmap, ARIZONA_GP_SWITCH_1,
1454 ARIZONA_SW1_MODE_MASK, arizona->pdata.gpsw);
1456 if (pdata->micd_pol_gpio > 0) {
1457 if (info->micd_modes[0].gpio)
1458 mode = GPIOF_OUT_INIT_HIGH;
1460 mode = GPIOF_OUT_INIT_LOW;
1462 ret = devm_gpio_request_one(&pdev->dev, pdata->micd_pol_gpio,
1463 mode, "MICD polarity");
1465 dev_err(arizona->dev, "Failed to request GPIO%d: %d\n",
1466 pdata->micd_pol_gpio, ret);
1470 info->micd_pol_gpio = gpio_to_desc(pdata->micd_pol_gpio);
1472 if (info->micd_modes[0].gpio)
1473 mode = GPIOD_OUT_HIGH;
1475 mode = GPIOD_OUT_LOW;
1477 /* We can't use devm here because we need to do the get
1478 * against the MFD device, as that is where the of_node
1479 * will reside, but if we devm against that the GPIO
1480 * will not be freed if the extcon driver is unloaded.
1482 info->micd_pol_gpio = gpiod_get_optional(arizona->dev,
1485 if (IS_ERR(info->micd_pol_gpio)) {
1486 ret = PTR_ERR(info->micd_pol_gpio);
1487 dev_err(arizona->dev,
1488 "Failed to get microphone polarity GPIO: %d\n",
1494 if (arizona->pdata.hpdet_id_gpio > 0) {
1495 ret = devm_gpio_request_one(&pdev->dev,
1496 arizona->pdata.hpdet_id_gpio,
1500 dev_err(arizona->dev, "Failed to request GPIO%d: %d\n",
1501 arizona->pdata.hpdet_id_gpio, ret);
1506 if (arizona->pdata.micd_bias_start_time)
1507 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_1,
1508 ARIZONA_MICD_BIAS_STARTTIME_MASK,
1509 arizona->pdata.micd_bias_start_time
1510 << ARIZONA_MICD_BIAS_STARTTIME_SHIFT);
1512 if (arizona->pdata.micd_rate)
1513 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_1,
1514 ARIZONA_MICD_RATE_MASK,
1515 arizona->pdata.micd_rate
1516 << ARIZONA_MICD_RATE_SHIFT);
1518 switch (arizona->pdata.micd_dbtime) {
1519 case MICD_DBTIME_FOUR_READINGS:
1520 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_1,
1521 ARIZONA_MICD_DBTIME_MASK,
1522 ARIZONA_MICD_DBTIME);
1524 case MICD_DBTIME_TWO_READINGS:
1525 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_1,
1526 ARIZONA_MICD_DBTIME_MASK, 0);
1532 BUILD_BUG_ON(ARRAY_SIZE(arizona_micd_levels) <
1533 ARIZONA_NUM_MICD_BUTTON_LEVELS);
1535 if (arizona->pdata.num_micd_ranges) {
1536 info->micd_ranges = pdata->micd_ranges;
1537 info->num_micd_ranges = pdata->num_micd_ranges;
1539 info->micd_ranges = micd_default_ranges;
1540 info->num_micd_ranges = ARRAY_SIZE(micd_default_ranges);
1543 if (arizona->pdata.num_micd_ranges > ARIZONA_MAX_MICD_RANGE) {
1544 dev_err(arizona->dev, "Too many MICD ranges: %d\n",
1545 arizona->pdata.num_micd_ranges);
1548 if (info->num_micd_ranges > 1) {
1549 for (i = 1; i < info->num_micd_ranges; i++) {
1550 if (info->micd_ranges[i - 1].max >
1551 info->micd_ranges[i].max) {
1552 dev_err(arizona->dev,
1553 "MICD ranges must be sorted\n");
1560 /* Disable all buttons by default */
1561 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_2,
1562 ARIZONA_MICD_LVL_SEL_MASK, 0x81);
1564 /* Set up all the buttons the user specified */
1565 for (i = 0; i < info->num_micd_ranges; i++) {
1566 for (j = 0; j < ARIZONA_NUM_MICD_BUTTON_LEVELS; j++)
1567 if (arizona_micd_levels[j] >= info->micd_ranges[i].max)
1570 if (j == ARIZONA_NUM_MICD_BUTTON_LEVELS) {
1571 dev_err(arizona->dev, "Unsupported MICD level %d\n",
1572 info->micd_ranges[i].max);
1577 dev_dbg(arizona->dev, "%d ohms for MICD threshold %d\n",
1578 arizona_micd_levels[j], i);
1580 arizona_micd_set_level(arizona, i, j);
1581 input_set_capability(info->input, EV_KEY,
1582 info->micd_ranges[i].key);
1584 /* Enable reporting of that range */
1585 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_2,
1589 /* Set all the remaining keys to a maximum */
1590 for (; i < ARIZONA_MAX_MICD_RANGE; i++)
1591 arizona_micd_set_level(arizona, i, 0x3f);
1594 * If we have a clamp use it, activating in conjunction with
1595 * GPIO5 if that is connected for jack detect operation.
1597 if (info->micd_clamp) {
1598 if (arizona->pdata.jd_gpio5) {
1599 /* Put the GPIO into input mode with optional pull */
1601 if (arizona->pdata.jd_gpio5_nopull)
1602 val &= ~ARIZONA_GPN_PU;
1604 regmap_write(arizona->regmap, ARIZONA_GPIO5_CTRL,
1607 if (arizona->pdata.jd_invert)
1608 clamp_mode = ARIZONA_MICD_CLAMP_MODE_JDH_GP5H;
1610 clamp_mode = ARIZONA_MICD_CLAMP_MODE_JDL_GP5H;
1612 if (arizona->pdata.jd_invert)
1613 clamp_mode = ARIZONA_MICD_CLAMP_MODE_JDH;
1615 clamp_mode = ARIZONA_MICD_CLAMP_MODE_JDL;
1618 regmap_update_bits(arizona->regmap,
1619 ARIZONA_MICD_CLAMP_CONTROL,
1620 ARIZONA_MICD_CLAMP_MODE_MASK, clamp_mode);
1622 regmap_update_bits(arizona->regmap,
1623 ARIZONA_JACK_DETECT_DEBOUNCE,
1624 ARIZONA_MICD_CLAMP_DB,
1625 ARIZONA_MICD_CLAMP_DB);
1628 arizona_extcon_set_mode(info, 0);
1630 pm_runtime_enable(&pdev->dev);
1631 pm_runtime_idle(&pdev->dev);
1632 pm_runtime_get_sync(&pdev->dev);
1634 if (info->micd_clamp) {
1635 jack_irq_rise = ARIZONA_IRQ_MICD_CLAMP_RISE;
1636 jack_irq_fall = ARIZONA_IRQ_MICD_CLAMP_FALL;
1638 jack_irq_rise = ARIZONA_IRQ_JD_RISE;
1639 jack_irq_fall = ARIZONA_IRQ_JD_FALL;
1642 ret = arizona_request_irq(arizona, jack_irq_rise,
1643 "JACKDET rise", arizona_jackdet, info);
1645 dev_err(&pdev->dev, "Failed to get JACKDET rise IRQ: %d\n",
1650 ret = arizona_set_irq_wake(arizona, jack_irq_rise, 1);
1652 dev_err(&pdev->dev, "Failed to set JD rise IRQ wake: %d\n",
1657 ret = arizona_request_irq(arizona, jack_irq_fall,
1658 "JACKDET fall", arizona_jackdet, info);
1660 dev_err(&pdev->dev, "Failed to get JD fall IRQ: %d\n", ret);
1664 ret = arizona_set_irq_wake(arizona, jack_irq_fall, 1);
1666 dev_err(&pdev->dev, "Failed to set JD fall IRQ wake: %d\n",
1671 ret = arizona_request_irq(arizona, ARIZONA_IRQ_MICDET,
1672 "MICDET", arizona_micdet, info);
1674 dev_err(&pdev->dev, "Failed to get MICDET IRQ: %d\n", ret);
1678 ret = arizona_request_irq(arizona, ARIZONA_IRQ_HPDET,
1679 "HPDET", arizona_hpdet_irq, info);
1681 dev_err(&pdev->dev, "Failed to get HPDET IRQ: %d\n", ret);
1685 arizona_clk32k_enable(arizona);
1686 regmap_update_bits(arizona->regmap, ARIZONA_JACK_DETECT_DEBOUNCE,
1687 ARIZONA_JD1_DB, ARIZONA_JD1_DB);
1688 regmap_update_bits(arizona->regmap, ARIZONA_JACK_DETECT_ANALOGUE,
1689 ARIZONA_JD1_ENA, ARIZONA_JD1_ENA);
1691 ret = regulator_allow_bypass(info->micvdd, true);
1693 dev_warn(arizona->dev, "Failed to set MICVDD to bypass: %d\n",
1696 pm_runtime_put(&pdev->dev);
1698 ret = input_register_device(info->input);
1700 dev_err(&pdev->dev, "Can't register input device: %d\n", ret);
1707 arizona_free_irq(arizona, ARIZONA_IRQ_HPDET, info);
1709 arizona_free_irq(arizona, ARIZONA_IRQ_MICDET, info);
1711 arizona_set_irq_wake(arizona, jack_irq_fall, 0);
1713 arizona_free_irq(arizona, jack_irq_fall, info);
1715 arizona_set_irq_wake(arizona, jack_irq_rise, 0);
1717 arizona_free_irq(arizona, jack_irq_rise, info);
1719 gpiod_put(info->micd_pol_gpio);
1721 pm_runtime_disable(&pdev->dev);
1725 static int arizona_extcon_remove(struct platform_device *pdev)
1727 struct arizona_extcon_info *info = platform_get_drvdata(pdev);
1728 struct arizona *arizona = info->arizona;
1729 int jack_irq_rise, jack_irq_fall;
1732 regmap_update_bits_check(arizona->regmap, ARIZONA_MIC_DETECT_1,
1733 ARIZONA_MICD_ENA, 0,
1737 regulator_disable(info->micvdd);
1738 pm_runtime_put(info->dev);
1741 gpiod_put(info->micd_pol_gpio);
1743 pm_runtime_disable(&pdev->dev);
1745 regmap_update_bits(arizona->regmap,
1746 ARIZONA_MICD_CLAMP_CONTROL,
1747 ARIZONA_MICD_CLAMP_MODE_MASK, 0);
1749 if (info->micd_clamp) {
1750 jack_irq_rise = ARIZONA_IRQ_MICD_CLAMP_RISE;
1751 jack_irq_fall = ARIZONA_IRQ_MICD_CLAMP_FALL;
1753 jack_irq_rise = ARIZONA_IRQ_JD_RISE;
1754 jack_irq_fall = ARIZONA_IRQ_JD_FALL;
1757 arizona_set_irq_wake(arizona, jack_irq_rise, 0);
1758 arizona_set_irq_wake(arizona, jack_irq_fall, 0);
1759 arizona_free_irq(arizona, ARIZONA_IRQ_HPDET, info);
1760 arizona_free_irq(arizona, ARIZONA_IRQ_MICDET, info);
1761 arizona_free_irq(arizona, jack_irq_rise, info);
1762 arizona_free_irq(arizona, jack_irq_fall, info);
1763 cancel_delayed_work_sync(&info->hpdet_work);
1764 regmap_update_bits(arizona->regmap, ARIZONA_JACK_DETECT_ANALOGUE,
1765 ARIZONA_JD1_ENA, 0);
1766 arizona_clk32k_disable(arizona);
1771 static struct platform_driver arizona_extcon_driver = {
1773 .name = "arizona-extcon",
1775 .probe = arizona_extcon_probe,
1776 .remove = arizona_extcon_remove,
1779 module_platform_driver(arizona_extcon_driver);
1781 MODULE_DESCRIPTION("Arizona Extcon driver");
1782 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
1783 MODULE_LICENSE("GPL");
1784 MODULE_ALIAS("platform:extcon-arizona");