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;
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 ret = extcon_get_state(info->edev, EXTCON_MECHANICAL);
620 dev_err(arizona->dev, "Failed to check cable state: %d\n",
624 dev_dbg(arizona->dev, "Ignoring HPDET for removed cable\n");
628 ret = arizona_hpdet_read(info);
635 /* Reset back to starting range */
636 regmap_update_bits(arizona->regmap,
637 ARIZONA_HEADPHONE_DETECT_1,
638 ARIZONA_HP_IMPEDANCE_RANGE_MASK | ARIZONA_HP_POLL,
641 ret = arizona_hpdet_do_id(info, &reading, &mic);
647 /* Report high impedence cables as line outputs */
649 report = EXTCON_JACK_LINE_OUT;
651 report = EXTCON_JACK_HEADPHONE;
653 ret = extcon_set_state_sync(info->edev, report, true);
655 dev_err(arizona->dev, "Failed to report HP/line: %d\n",
659 /* Reset back to starting range */
660 regmap_update_bits(arizona->regmap,
661 ARIZONA_HEADPHONE_DETECT_1,
662 ARIZONA_HP_IMPEDANCE_RANGE_MASK | ARIZONA_HP_POLL,
665 arizona_extcon_hp_clamp(info, false);
668 gpio_set_value_cansleep(id_gpio, 0);
670 /* Revert back to MICDET mode */
671 regmap_update_bits(arizona->regmap,
672 ARIZONA_ACCESSORY_DETECT_MODE_1,
673 ARIZONA_ACCDET_MODE_MASK, ARIZONA_ACCDET_MODE_MIC);
675 /* If we have a mic then reenable MICDET */
676 if (mic || info->mic)
677 arizona_start_mic(info);
679 if (info->hpdet_active) {
680 pm_runtime_put_autosuspend(info->dev);
681 info->hpdet_active = false;
684 info->hpdet_done = true;
687 mutex_unlock(&info->lock);
692 static void arizona_identify_headphone(struct arizona_extcon_info *info)
694 struct arizona *arizona = info->arizona;
697 if (info->hpdet_done)
700 dev_dbg(arizona->dev, "Starting HPDET\n");
702 /* Make sure we keep the device enabled during the measurement */
703 pm_runtime_get(info->dev);
705 info->hpdet_active = true;
708 arizona_stop_mic(info);
710 arizona_extcon_hp_clamp(info, true);
712 ret = regmap_update_bits(arizona->regmap,
713 ARIZONA_ACCESSORY_DETECT_MODE_1,
714 ARIZONA_ACCDET_MODE_MASK,
715 arizona->pdata.hpdet_channel);
717 dev_err(arizona->dev, "Failed to set HPDET mode: %d\n", ret);
721 ret = regmap_update_bits(arizona->regmap, ARIZONA_HEADPHONE_DETECT_1,
722 ARIZONA_HP_POLL, ARIZONA_HP_POLL);
724 dev_err(arizona->dev, "Can't start HPDETL measurement: %d\n",
732 regmap_update_bits(arizona->regmap, ARIZONA_ACCESSORY_DETECT_MODE_1,
733 ARIZONA_ACCDET_MODE_MASK, ARIZONA_ACCDET_MODE_MIC);
735 /* Just report headphone */
736 ret = extcon_set_state_sync(info->edev, EXTCON_JACK_HEADPHONE, true);
738 dev_err(arizona->dev, "Failed to report headphone: %d\n", ret);
741 arizona_start_mic(info);
743 info->hpdet_active = false;
746 static void arizona_start_hpdet_acc_id(struct arizona_extcon_info *info)
748 struct arizona *arizona = info->arizona;
753 dev_dbg(arizona->dev, "Starting identification via HPDET\n");
755 /* Make sure we keep the device enabled during the measurement */
756 pm_runtime_get_sync(info->dev);
758 info->hpdet_active = true;
760 arizona_extcon_hp_clamp(info, true);
762 ret = regmap_update_bits(arizona->regmap,
763 ARIZONA_ACCESSORY_DETECT_MODE_1,
764 ARIZONA_ACCDET_SRC | ARIZONA_ACCDET_MODE_MASK,
765 info->micd_modes[0].src |
766 arizona->pdata.hpdet_channel);
768 dev_err(arizona->dev, "Failed to set HPDET mode: %d\n", ret);
772 if (arizona->pdata.hpdet_acc_id_line) {
773 ret = regmap_update_bits(arizona->regmap,
774 ARIZONA_HEADPHONE_DETECT_1,
775 ARIZONA_HP_POLL, ARIZONA_HP_POLL);
777 dev_err(arizona->dev,
778 "Can't start HPDETL measurement: %d\n",
783 arizona_hpdet_do_id(info, &hp_reading, &mic);
789 regmap_update_bits(arizona->regmap, ARIZONA_ACCESSORY_DETECT_MODE_1,
790 ARIZONA_ACCDET_MODE_MASK, ARIZONA_ACCDET_MODE_MIC);
792 /* Just report headphone */
793 ret = extcon_set_state_sync(info->edev, EXTCON_JACK_HEADPHONE, true);
795 dev_err(arizona->dev, "Failed to report headphone: %d\n", ret);
797 info->hpdet_active = false;
800 static void arizona_micd_timeout_work(struct work_struct *work)
802 struct arizona_extcon_info *info = container_of(work,
803 struct arizona_extcon_info,
804 micd_timeout_work.work);
806 mutex_lock(&info->lock);
808 dev_dbg(info->arizona->dev, "MICD timed out, reporting HP\n");
810 info->detecting = false;
812 arizona_identify_headphone(info);
814 arizona_stop_mic(info);
816 mutex_unlock(&info->lock);
819 static void arizona_micd_detect(struct work_struct *work)
821 struct arizona_extcon_info *info = container_of(work,
822 struct arizona_extcon_info,
823 micd_detect_work.work);
824 struct arizona *arizona = info->arizona;
825 unsigned int val = 0, lvl;
828 cancel_delayed_work_sync(&info->micd_timeout_work);
830 mutex_lock(&info->lock);
832 /* If the cable was removed while measuring ignore the result */
833 ret = extcon_get_state(info->edev, EXTCON_MECHANICAL);
835 dev_err(arizona->dev, "Failed to check cable state: %d\n",
837 mutex_unlock(&info->lock);
840 dev_dbg(arizona->dev, "Ignoring MICDET for removed cable\n");
841 mutex_unlock(&info->lock);
845 if (info->detecting && arizona->pdata.micd_software_compare) {
846 /* Must disable MICD before we read the ADCVAL */
847 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_1,
848 ARIZONA_MICD_ENA, 0);
849 ret = regmap_read(arizona->regmap, ARIZONA_MIC_DETECT_4, &val);
851 dev_err(arizona->dev,
852 "Failed to read MICDET_ADCVAL: %d\n",
854 mutex_unlock(&info->lock);
858 dev_dbg(arizona->dev, "MICDET_ADCVAL: %x\n", val);
860 val &= ARIZONA_MICDET_ADCVAL_MASK;
861 if (val < ARRAY_SIZE(arizona_micd_levels))
862 val = arizona_micd_levels[val];
866 if (val <= QUICK_HEADPHONE_MAX_OHM)
867 val = ARIZONA_MICD_STS | ARIZONA_MICD_LVL_0;
868 else if (val <= MICROPHONE_MIN_OHM)
869 val = ARIZONA_MICD_STS | ARIZONA_MICD_LVL_1;
870 else if (val <= MICROPHONE_MAX_OHM)
871 val = ARIZONA_MICD_STS | ARIZONA_MICD_LVL_8;
873 val = ARIZONA_MICD_LVL_8;
876 for (i = 0; i < 10 && !(val & MICD_LVL_0_TO_8); i++) {
877 ret = regmap_read(arizona->regmap, ARIZONA_MIC_DETECT_3, &val);
879 dev_err(arizona->dev,
880 "Failed to read MICDET: %d\n", ret);
881 mutex_unlock(&info->lock);
885 dev_dbg(arizona->dev, "MICDET: %x\n", val);
887 if (!(val & ARIZONA_MICD_VALID)) {
888 dev_warn(arizona->dev,
889 "Microphone detection state invalid\n");
890 mutex_unlock(&info->lock);
895 if (i == 10 && !(val & MICD_LVL_0_TO_8)) {
896 dev_err(arizona->dev, "Failed to get valid MICDET value\n");
897 mutex_unlock(&info->lock);
901 /* Due to jack detect this should never happen */
902 if (!(val & ARIZONA_MICD_STS)) {
903 dev_warn(arizona->dev, "Detected open circuit\n");
905 arizona_stop_mic(info);
906 info->detecting = false;
907 arizona_identify_headphone(info);
911 /* If we got a high impedence we should have a headset, report it. */
912 if (info->detecting && (val & ARIZONA_MICD_LVL_8)) {
914 info->detecting = false;
916 arizona_identify_headphone(info);
918 ret = extcon_set_state_sync(info->edev,
919 EXTCON_JACK_MICROPHONE, true);
921 dev_err(arizona->dev, "Headset report failed: %d\n",
924 /* Don't need to regulate for button detection */
925 ret = regulator_allow_bypass(info->micvdd, true);
927 dev_err(arizona->dev, "Failed to bypass MICVDD: %d\n",
934 /* If we detected a lower impedence during initial startup
935 * then we probably have the wrong polarity, flip it. Don't
936 * do this for the lowest impedences to speed up detection of
937 * plain headphones. If both polarities report a low
938 * impedence then give up and report headphones.
940 if (info->detecting && (val & MICD_LVL_1_TO_7)) {
941 if (info->jack_flips >= info->micd_num_modes * 10) {
942 dev_dbg(arizona->dev, "Detected HP/line\n");
944 info->detecting = false;
946 arizona_identify_headphone(info);
948 arizona_stop_mic(info);
951 if (info->micd_mode == info->micd_num_modes)
953 arizona_extcon_set_mode(info, info->micd_mode);
962 * If we're still detecting and we detect a short then we've
963 * got a headphone. Otherwise it's a button press.
965 if (val & MICD_LVL_0_TO_7) {
967 dev_dbg(arizona->dev, "Mic button detected\n");
969 lvl = val & ARIZONA_MICD_LVL_MASK;
970 lvl >>= ARIZONA_MICD_LVL_SHIFT;
972 for (i = 0; i < info->num_micd_ranges; i++)
973 input_report_key(info->input,
974 info->micd_ranges[i].key, 0);
977 WARN_ON(ffs(lvl) - 1 >= info->num_micd_ranges);
978 if (lvl && ffs(lvl) - 1 < info->num_micd_ranges) {
979 key = info->micd_ranges[ffs(lvl) - 1].key;
980 input_report_key(info->input, key, 1);
981 input_sync(info->input);
984 } else if (info->detecting) {
985 dev_dbg(arizona->dev, "Headphone detected\n");
986 info->detecting = false;
987 arizona_stop_mic(info);
989 arizona_identify_headphone(info);
991 dev_warn(arizona->dev, "Button with no mic: %x\n",
995 dev_dbg(arizona->dev, "Mic button released\n");
996 for (i = 0; i < info->num_micd_ranges; i++)
997 input_report_key(info->input,
998 info->micd_ranges[i].key, 0);
999 input_sync(info->input);
1000 arizona_extcon_pulse_micbias(info);
1004 if (info->detecting) {
1005 if (arizona->pdata.micd_software_compare)
1006 regmap_update_bits(arizona->regmap,
1007 ARIZONA_MIC_DETECT_1,
1011 queue_delayed_work(system_power_efficient_wq,
1012 &info->micd_timeout_work,
1013 msecs_to_jiffies(info->micd_timeout));
1016 pm_runtime_mark_last_busy(info->dev);
1017 mutex_unlock(&info->lock);
1020 static irqreturn_t arizona_micdet(int irq, void *data)
1022 struct arizona_extcon_info *info = data;
1023 struct arizona *arizona = info->arizona;
1024 int debounce = arizona->pdata.micd_detect_debounce;
1026 cancel_delayed_work_sync(&info->micd_detect_work);
1027 cancel_delayed_work_sync(&info->micd_timeout_work);
1029 mutex_lock(&info->lock);
1030 if (!info->detecting)
1032 mutex_unlock(&info->lock);
1035 queue_delayed_work(system_power_efficient_wq,
1036 &info->micd_detect_work,
1037 msecs_to_jiffies(debounce));
1039 arizona_micd_detect(&info->micd_detect_work.work);
1044 static void arizona_hpdet_work(struct work_struct *work)
1046 struct arizona_extcon_info *info = container_of(work,
1047 struct arizona_extcon_info,
1050 mutex_lock(&info->lock);
1051 arizona_start_hpdet_acc_id(info);
1052 mutex_unlock(&info->lock);
1055 static int arizona_hpdet_wait(struct arizona_extcon_info *info)
1057 struct arizona *arizona = info->arizona;
1061 for (i = 0; i < ARIZONA_HPDET_WAIT_COUNT; i++) {
1062 ret = regmap_read(arizona->regmap, ARIZONA_HEADPHONE_DETECT_2,
1065 dev_err(arizona->dev,
1066 "Failed to read HPDET state: %d\n", ret);
1070 switch (info->hpdet_ip_version) {
1072 if (val & ARIZONA_HP_DONE)
1076 if (val & ARIZONA_HP_DONE_B)
1081 msleep(ARIZONA_HPDET_WAIT_DELAY_MS);
1084 dev_warn(arizona->dev, "HPDET did not appear to complete\n");
1089 static irqreturn_t arizona_jackdet(int irq, void *data)
1091 struct arizona_extcon_info *info = data;
1092 struct arizona *arizona = info->arizona;
1093 unsigned int val, present, mask;
1094 bool cancelled_hp, cancelled_mic;
1097 cancelled_hp = cancel_delayed_work_sync(&info->hpdet_work);
1098 cancelled_mic = cancel_delayed_work_sync(&info->micd_timeout_work);
1100 pm_runtime_get_sync(info->dev);
1102 mutex_lock(&info->lock);
1104 if (info->micd_clamp) {
1105 mask = ARIZONA_MICD_CLAMP_STS;
1108 mask = ARIZONA_JD1_STS;
1109 if (arizona->pdata.jd_invert)
1112 present = ARIZONA_JD1_STS;
1115 ret = regmap_read(arizona->regmap, ARIZONA_AOD_IRQ_RAW_STATUS, &val);
1117 dev_err(arizona->dev, "Failed to read jackdet status: %d\n",
1119 mutex_unlock(&info->lock);
1120 pm_runtime_put_autosuspend(info->dev);
1125 if (val == info->last_jackdet) {
1126 dev_dbg(arizona->dev, "Suppressing duplicate JACKDET\n");
1128 queue_delayed_work(system_power_efficient_wq,
1130 msecs_to_jiffies(HPDET_DEBOUNCE));
1132 if (cancelled_mic) {
1133 int micd_timeout = info->micd_timeout;
1135 queue_delayed_work(system_power_efficient_wq,
1136 &info->micd_timeout_work,
1137 msecs_to_jiffies(micd_timeout));
1142 info->last_jackdet = val;
1144 if (info->last_jackdet == present) {
1145 dev_dbg(arizona->dev, "Detected jack\n");
1146 ret = extcon_set_state_sync(info->edev,
1147 EXTCON_MECHANICAL, true);
1150 dev_err(arizona->dev, "Mechanical report failed: %d\n",
1153 if (!arizona->pdata.hpdet_acc_id) {
1154 info->detecting = true;
1156 info->jack_flips = 0;
1158 arizona_start_mic(info);
1160 queue_delayed_work(system_power_efficient_wq,
1162 msecs_to_jiffies(HPDET_DEBOUNCE));
1165 if (info->micd_clamp || !arizona->pdata.jd_invert)
1166 regmap_update_bits(arizona->regmap,
1167 ARIZONA_JACK_DETECT_DEBOUNCE,
1168 ARIZONA_MICD_CLAMP_DB |
1171 dev_dbg(arizona->dev, "Detected jack removal\n");
1173 arizona_stop_mic(info);
1175 info->num_hpdet_res = 0;
1176 for (i = 0; i < ARRAY_SIZE(info->hpdet_res); i++)
1177 info->hpdet_res[i] = 0;
1179 info->hpdet_done = false;
1180 info->hpdet_retried = false;
1182 for (i = 0; i < info->num_micd_ranges; i++)
1183 input_report_key(info->input,
1184 info->micd_ranges[i].key, 0);
1185 input_sync(info->input);
1187 for (i = 0; i < ARRAY_SIZE(arizona_cable) - 1; i++) {
1188 ret = extcon_set_state_sync(info->edev,
1189 arizona_cable[i], false);
1191 dev_err(arizona->dev,
1192 "Removal report failed: %d\n", ret);
1196 * If the jack was removed during a headphone detection we
1197 * need to wait for the headphone detection to finish, as
1198 * it can not be aborted. We don't want to be able to start
1199 * a new headphone detection from a fresh insert until this
1202 arizona_hpdet_wait(info);
1204 regmap_update_bits(arizona->regmap,
1205 ARIZONA_JACK_DETECT_DEBOUNCE,
1206 ARIZONA_MICD_CLAMP_DB | ARIZONA_JD1_DB,
1207 ARIZONA_MICD_CLAMP_DB | ARIZONA_JD1_DB);
1210 if (arizona->pdata.micd_timeout)
1211 info->micd_timeout = arizona->pdata.micd_timeout;
1213 info->micd_timeout = DEFAULT_MICD_TIMEOUT;
1216 /* Clear trig_sts to make sure DCVDD is not forced up */
1217 regmap_write(arizona->regmap, ARIZONA_AOD_WKUP_AND_TRIG,
1218 ARIZONA_MICD_CLAMP_FALL_TRIG_STS |
1219 ARIZONA_MICD_CLAMP_RISE_TRIG_STS |
1220 ARIZONA_JD1_FALL_TRIG_STS |
1221 ARIZONA_JD1_RISE_TRIG_STS);
1223 mutex_unlock(&info->lock);
1225 pm_runtime_mark_last_busy(info->dev);
1226 pm_runtime_put_autosuspend(info->dev);
1231 /* Map a level onto a slot in the register bank */
1232 static void arizona_micd_set_level(struct arizona *arizona, int index,
1238 reg = ARIZONA_MIC_DETECT_LEVEL_4 - (index / 2);
1247 /* Program the level itself */
1248 regmap_update_bits(arizona->regmap, reg, mask, level);
1251 static int arizona_extcon_get_micd_configs(struct device *dev,
1252 struct arizona *arizona)
1254 const char * const prop = "wlf,micd-configs";
1255 const int entries_per_config = 3;
1256 struct arizona_micd_config *micd_configs;
1261 nconfs = device_property_read_u32_array(arizona->dev, prop, NULL, 0);
1265 vals = kcalloc(nconfs, sizeof(u32), GFP_KERNEL);
1269 ret = device_property_read_u32_array(arizona->dev, prop, vals, nconfs);
1273 nconfs /= entries_per_config;
1275 micd_configs = devm_kzalloc(dev,
1276 nconfs * sizeof(struct arizona_micd_range),
1278 if (!micd_configs) {
1283 for (i = 0, j = 0; i < nconfs; ++i) {
1284 micd_configs[i].src = vals[j++] ? ARIZONA_ACCDET_SRC : 0;
1285 micd_configs[i].bias = vals[j++];
1286 micd_configs[i].gpio = vals[j++];
1289 arizona->pdata.micd_configs = micd_configs;
1290 arizona->pdata.num_micd_configs = nconfs;
1297 static int arizona_extcon_device_get_pdata(struct device *dev,
1298 struct arizona *arizona)
1300 struct arizona_pdata *pdata = &arizona->pdata;
1301 unsigned int val = ARIZONA_ACCDET_MODE_HPL;
1304 device_property_read_u32(arizona->dev, "wlf,hpdet-channel", &val);
1306 case ARIZONA_ACCDET_MODE_HPL:
1307 case ARIZONA_ACCDET_MODE_HPR:
1308 pdata->hpdet_channel = val;
1311 dev_err(arizona->dev,
1312 "Wrong wlf,hpdet-channel DT value %d\n", val);
1313 pdata->hpdet_channel = ARIZONA_ACCDET_MODE_HPL;
1316 device_property_read_u32(arizona->dev, "wlf,micd-detect-debounce",
1317 &pdata->micd_detect_debounce);
1319 device_property_read_u32(arizona->dev, "wlf,micd-bias-start-time",
1320 &pdata->micd_bias_start_time);
1322 device_property_read_u32(arizona->dev, "wlf,micd-rate",
1325 device_property_read_u32(arizona->dev, "wlf,micd-dbtime",
1326 &pdata->micd_dbtime);
1328 device_property_read_u32(arizona->dev, "wlf,micd-timeout-ms",
1329 &pdata->micd_timeout);
1331 pdata->micd_force_micbias = device_property_read_bool(arizona->dev,
1332 "wlf,micd-force-micbias");
1334 pdata->micd_software_compare = device_property_read_bool(arizona->dev,
1335 "wlf,micd-software-compare");
1337 pdata->jd_invert = device_property_read_bool(arizona->dev,
1340 device_property_read_u32(arizona->dev, "wlf,gpsw", &pdata->gpsw);
1342 pdata->jd_gpio5 = device_property_read_bool(arizona->dev,
1344 pdata->jd_gpio5_nopull = device_property_read_bool(arizona->dev,
1345 "wlf,use-jd2-nopull");
1347 ret = arizona_extcon_get_micd_configs(dev, arizona);
1349 dev_err(arizona->dev, "Failed to read micd configs: %d\n", ret);
1354 static int arizona_extcon_probe(struct platform_device *pdev)
1356 struct arizona *arizona = dev_get_drvdata(pdev->dev.parent);
1357 struct arizona_pdata *pdata = &arizona->pdata;
1358 struct arizona_extcon_info *info;
1360 unsigned int clamp_mode;
1361 int jack_irq_fall, jack_irq_rise;
1362 int ret, mode, i, j;
1364 if (!arizona->dapm || !arizona->dapm->card)
1365 return -EPROBE_DEFER;
1367 info = devm_kzalloc(&pdev->dev, sizeof(*info), GFP_KERNEL);
1371 if (!dev_get_platdata(arizona->dev))
1372 arizona_extcon_device_get_pdata(&pdev->dev, arizona);
1374 info->micvdd = devm_regulator_get(&pdev->dev, "MICVDD");
1375 if (IS_ERR(info->micvdd)) {
1376 ret = PTR_ERR(info->micvdd);
1377 dev_err(arizona->dev, "Failed to get MICVDD: %d\n", ret);
1381 mutex_init(&info->lock);
1382 info->arizona = arizona;
1383 info->dev = &pdev->dev;
1384 info->last_jackdet = ~(ARIZONA_MICD_CLAMP_STS | ARIZONA_JD1_STS);
1385 INIT_DELAYED_WORK(&info->hpdet_work, arizona_hpdet_work);
1386 INIT_DELAYED_WORK(&info->micd_detect_work, arizona_micd_detect);
1387 INIT_DELAYED_WORK(&info->micd_timeout_work, arizona_micd_timeout_work);
1388 platform_set_drvdata(pdev, info);
1390 switch (arizona->type) {
1392 switch (arizona->rev) {
1394 info->micd_reva = true;
1397 info->micd_clamp = true;
1398 info->hpdet_ip_version = 1;
1404 switch (arizona->rev) {
1408 info->micd_clamp = true;
1409 info->hpdet_ip_version = 2;
1415 info->micd_clamp = true;
1416 info->hpdet_ip_version = 2;
1422 info->edev = devm_extcon_dev_allocate(&pdev->dev, arizona_cable);
1423 if (IS_ERR(info->edev)) {
1424 dev_err(&pdev->dev, "failed to allocate extcon device\n");
1428 ret = devm_extcon_dev_register(&pdev->dev, info->edev);
1430 dev_err(arizona->dev, "extcon_dev_register() failed: %d\n",
1435 info->input = devm_input_allocate_device(&pdev->dev);
1437 dev_err(arizona->dev, "Can't allocate input dev\n");
1442 info->input->name = "Headset";
1443 info->input->phys = "arizona/extcon";
1445 if (pdata->num_micd_configs) {
1446 info->micd_modes = pdata->micd_configs;
1447 info->micd_num_modes = pdata->num_micd_configs;
1449 info->micd_modes = micd_default_modes;
1450 info->micd_num_modes = ARRAY_SIZE(micd_default_modes);
1453 if (arizona->pdata.gpsw > 0)
1454 regmap_update_bits(arizona->regmap, ARIZONA_GP_SWITCH_1,
1455 ARIZONA_SW1_MODE_MASK, arizona->pdata.gpsw);
1457 if (pdata->micd_pol_gpio > 0) {
1458 if (info->micd_modes[0].gpio)
1459 mode = GPIOF_OUT_INIT_HIGH;
1461 mode = GPIOF_OUT_INIT_LOW;
1463 ret = devm_gpio_request_one(&pdev->dev, pdata->micd_pol_gpio,
1464 mode, "MICD polarity");
1466 dev_err(arizona->dev, "Failed to request GPIO%d: %d\n",
1467 pdata->micd_pol_gpio, ret);
1471 info->micd_pol_gpio = gpio_to_desc(pdata->micd_pol_gpio);
1473 if (info->micd_modes[0].gpio)
1474 mode = GPIOD_OUT_HIGH;
1476 mode = GPIOD_OUT_LOW;
1478 /* We can't use devm here because we need to do the get
1479 * against the MFD device, as that is where the of_node
1480 * will reside, but if we devm against that the GPIO
1481 * will not be freed if the extcon driver is unloaded.
1483 info->micd_pol_gpio = gpiod_get_optional(arizona->dev,
1486 if (IS_ERR(info->micd_pol_gpio)) {
1487 ret = PTR_ERR(info->micd_pol_gpio);
1488 dev_err(arizona->dev,
1489 "Failed to get microphone polarity GPIO: %d\n",
1495 if (arizona->pdata.hpdet_id_gpio > 0) {
1496 ret = devm_gpio_request_one(&pdev->dev,
1497 arizona->pdata.hpdet_id_gpio,
1501 dev_err(arizona->dev, "Failed to request GPIO%d: %d\n",
1502 arizona->pdata.hpdet_id_gpio, ret);
1507 if (arizona->pdata.micd_bias_start_time)
1508 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_1,
1509 ARIZONA_MICD_BIAS_STARTTIME_MASK,
1510 arizona->pdata.micd_bias_start_time
1511 << ARIZONA_MICD_BIAS_STARTTIME_SHIFT);
1513 if (arizona->pdata.micd_rate)
1514 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_1,
1515 ARIZONA_MICD_RATE_MASK,
1516 arizona->pdata.micd_rate
1517 << ARIZONA_MICD_RATE_SHIFT);
1519 switch (arizona->pdata.micd_dbtime) {
1520 case MICD_DBTIME_FOUR_READINGS:
1521 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_1,
1522 ARIZONA_MICD_DBTIME_MASK,
1523 ARIZONA_MICD_DBTIME);
1525 case MICD_DBTIME_TWO_READINGS:
1526 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_1,
1527 ARIZONA_MICD_DBTIME_MASK, 0);
1533 BUILD_BUG_ON(ARRAY_SIZE(arizona_micd_levels) <
1534 ARIZONA_NUM_MICD_BUTTON_LEVELS);
1536 if (arizona->pdata.num_micd_ranges) {
1537 info->micd_ranges = pdata->micd_ranges;
1538 info->num_micd_ranges = pdata->num_micd_ranges;
1540 info->micd_ranges = micd_default_ranges;
1541 info->num_micd_ranges = ARRAY_SIZE(micd_default_ranges);
1544 if (arizona->pdata.num_micd_ranges > ARIZONA_MAX_MICD_RANGE) {
1545 dev_err(arizona->dev, "Too many MICD ranges: %d\n",
1546 arizona->pdata.num_micd_ranges);
1549 if (info->num_micd_ranges > 1) {
1550 for (i = 1; i < info->num_micd_ranges; i++) {
1551 if (info->micd_ranges[i - 1].max >
1552 info->micd_ranges[i].max) {
1553 dev_err(arizona->dev,
1554 "MICD ranges must be sorted\n");
1561 /* Disable all buttons by default */
1562 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_2,
1563 ARIZONA_MICD_LVL_SEL_MASK, 0x81);
1565 /* Set up all the buttons the user specified */
1566 for (i = 0; i < info->num_micd_ranges; i++) {
1567 for (j = 0; j < ARIZONA_NUM_MICD_BUTTON_LEVELS; j++)
1568 if (arizona_micd_levels[j] >= info->micd_ranges[i].max)
1571 if (j == ARIZONA_NUM_MICD_BUTTON_LEVELS) {
1572 dev_err(arizona->dev, "Unsupported MICD level %d\n",
1573 info->micd_ranges[i].max);
1578 dev_dbg(arizona->dev, "%d ohms for MICD threshold %d\n",
1579 arizona_micd_levels[j], i);
1581 arizona_micd_set_level(arizona, i, j);
1582 input_set_capability(info->input, EV_KEY,
1583 info->micd_ranges[i].key);
1585 /* Enable reporting of that range */
1586 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_2,
1590 /* Set all the remaining keys to a maximum */
1591 for (; i < ARIZONA_MAX_MICD_RANGE; i++)
1592 arizona_micd_set_level(arizona, i, 0x3f);
1595 * If we have a clamp use it, activating in conjunction with
1596 * GPIO5 if that is connected for jack detect operation.
1598 if (info->micd_clamp) {
1599 if (arizona->pdata.jd_gpio5) {
1600 /* Put the GPIO into input mode with optional pull */
1602 if (arizona->pdata.jd_gpio5_nopull)
1603 val &= ~ARIZONA_GPN_PU;
1605 regmap_write(arizona->regmap, ARIZONA_GPIO5_CTRL,
1608 if (arizona->pdata.jd_invert)
1609 clamp_mode = ARIZONA_MICD_CLAMP_MODE_JDH_GP5H;
1611 clamp_mode = ARIZONA_MICD_CLAMP_MODE_JDL_GP5H;
1613 if (arizona->pdata.jd_invert)
1614 clamp_mode = ARIZONA_MICD_CLAMP_MODE_JDH;
1616 clamp_mode = ARIZONA_MICD_CLAMP_MODE_JDL;
1619 regmap_update_bits(arizona->regmap,
1620 ARIZONA_MICD_CLAMP_CONTROL,
1621 ARIZONA_MICD_CLAMP_MODE_MASK, clamp_mode);
1623 regmap_update_bits(arizona->regmap,
1624 ARIZONA_JACK_DETECT_DEBOUNCE,
1625 ARIZONA_MICD_CLAMP_DB,
1626 ARIZONA_MICD_CLAMP_DB);
1629 arizona_extcon_set_mode(info, 0);
1631 pm_runtime_enable(&pdev->dev);
1632 pm_runtime_idle(&pdev->dev);
1633 pm_runtime_get_sync(&pdev->dev);
1635 if (info->micd_clamp) {
1636 jack_irq_rise = ARIZONA_IRQ_MICD_CLAMP_RISE;
1637 jack_irq_fall = ARIZONA_IRQ_MICD_CLAMP_FALL;
1639 jack_irq_rise = ARIZONA_IRQ_JD_RISE;
1640 jack_irq_fall = ARIZONA_IRQ_JD_FALL;
1643 ret = arizona_request_irq(arizona, jack_irq_rise,
1644 "JACKDET rise", arizona_jackdet, info);
1646 dev_err(&pdev->dev, "Failed to get JACKDET rise IRQ: %d\n",
1651 ret = arizona_set_irq_wake(arizona, jack_irq_rise, 1);
1653 dev_err(&pdev->dev, "Failed to set JD rise IRQ wake: %d\n",
1658 ret = arizona_request_irq(arizona, jack_irq_fall,
1659 "JACKDET fall", arizona_jackdet, info);
1661 dev_err(&pdev->dev, "Failed to get JD fall IRQ: %d\n", ret);
1665 ret = arizona_set_irq_wake(arizona, jack_irq_fall, 1);
1667 dev_err(&pdev->dev, "Failed to set JD fall IRQ wake: %d\n",
1672 ret = arizona_request_irq(arizona, ARIZONA_IRQ_MICDET,
1673 "MICDET", arizona_micdet, info);
1675 dev_err(&pdev->dev, "Failed to get MICDET IRQ: %d\n", ret);
1679 ret = arizona_request_irq(arizona, ARIZONA_IRQ_HPDET,
1680 "HPDET", arizona_hpdet_irq, info);
1682 dev_err(&pdev->dev, "Failed to get HPDET IRQ: %d\n", ret);
1686 arizona_clk32k_enable(arizona);
1687 regmap_update_bits(arizona->regmap, ARIZONA_JACK_DETECT_DEBOUNCE,
1688 ARIZONA_JD1_DB, ARIZONA_JD1_DB);
1689 regmap_update_bits(arizona->regmap, ARIZONA_JACK_DETECT_ANALOGUE,
1690 ARIZONA_JD1_ENA, ARIZONA_JD1_ENA);
1692 ret = regulator_allow_bypass(info->micvdd, true);
1694 dev_warn(arizona->dev, "Failed to set MICVDD to bypass: %d\n",
1697 pm_runtime_put(&pdev->dev);
1699 ret = input_register_device(info->input);
1701 dev_err(&pdev->dev, "Can't register input device: %d\n", ret);
1708 arizona_free_irq(arizona, ARIZONA_IRQ_HPDET, info);
1710 arizona_free_irq(arizona, ARIZONA_IRQ_MICDET, info);
1712 arizona_set_irq_wake(arizona, jack_irq_fall, 0);
1714 arizona_free_irq(arizona, jack_irq_fall, info);
1716 arizona_set_irq_wake(arizona, jack_irq_rise, 0);
1718 arizona_free_irq(arizona, jack_irq_rise, info);
1720 gpiod_put(info->micd_pol_gpio);
1722 pm_runtime_disable(&pdev->dev);
1726 static int arizona_extcon_remove(struct platform_device *pdev)
1728 struct arizona_extcon_info *info = platform_get_drvdata(pdev);
1729 struct arizona *arizona = info->arizona;
1730 int jack_irq_rise, jack_irq_fall;
1732 gpiod_put(info->micd_pol_gpio);
1734 pm_runtime_disable(&pdev->dev);
1736 regmap_update_bits(arizona->regmap,
1737 ARIZONA_MICD_CLAMP_CONTROL,
1738 ARIZONA_MICD_CLAMP_MODE_MASK, 0);
1740 if (info->micd_clamp) {
1741 jack_irq_rise = ARIZONA_IRQ_MICD_CLAMP_RISE;
1742 jack_irq_fall = ARIZONA_IRQ_MICD_CLAMP_FALL;
1744 jack_irq_rise = ARIZONA_IRQ_JD_RISE;
1745 jack_irq_fall = ARIZONA_IRQ_JD_FALL;
1748 arizona_set_irq_wake(arizona, jack_irq_rise, 0);
1749 arizona_set_irq_wake(arizona, jack_irq_fall, 0);
1750 arizona_free_irq(arizona, ARIZONA_IRQ_HPDET, info);
1751 arizona_free_irq(arizona, ARIZONA_IRQ_MICDET, info);
1752 arizona_free_irq(arizona, jack_irq_rise, info);
1753 arizona_free_irq(arizona, jack_irq_fall, info);
1754 cancel_delayed_work_sync(&info->hpdet_work);
1755 regmap_update_bits(arizona->regmap, ARIZONA_JACK_DETECT_ANALOGUE,
1756 ARIZONA_JD1_ENA, 0);
1757 arizona_clk32k_disable(arizona);
1762 static struct platform_driver arizona_extcon_driver = {
1764 .name = "arizona-extcon",
1766 .probe = arizona_extcon_probe,
1767 .remove = arizona_extcon_remove,
1770 module_platform_driver(arizona_extcon_driver);
1772 MODULE_DESCRIPTION("Arizona Extcon driver");
1773 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
1774 MODULE_LICENSE("GPL");
1775 MODULE_ALIAS("platform:extcon-arizona");