projects / deliverable / linux.git / blob
? search:


b01030735f0ccbc30b1f2d088eadc6a6db0b6163
[deliverable/linux.git] / drivers / extcon / extcon-arizona.c
1 /*
2 * extcon-arizona.c - Extcon driver Wolfson Arizona devices
3 *
4 * Copyright (C) 2012-2014 Wolfson Microelectronics plc
5 *
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.
10 *
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.
15 */
16
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>
31
32 #include <sound/soc.h>
33
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>
38
39 #define ARIZONA_MAX_MICD_RANGE 8
40
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
45
46 #define ARIZONA_TST_CAP_DEFAULT 0x3
47 #define ARIZONA_TST_CAP_CLAMP 0x1
48
49 #define ARIZONA_HPDET_MAX 10000
50
51 #define HPDET_DEBOUNCE 500
52 #define DEFAULT_MICD_TIMEOUT 2000
53
54 #define QUICK_HEADPHONE_MAX_OHM 3
55 #define MICROPHONE_MIN_OHM 1257
56 #define MICROPHONE_MAX_OHM 30000
57
58 #define MICD_DBTIME_TWO_READINGS 2
59 #define MICD_DBTIME_FOUR_READINGS 4
60
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 | \
64 ARIZONA_MICD_LVL_7)
65
66 #define MICD_LVL_0_TO_7 (ARIZONA_MICD_LVL_0 | MICD_LVL_1_TO_7)
67
68 #define MICD_LVL_0_TO_8 (MICD_LVL_0_TO_7 | ARIZONA_MICD_LVL_8)
69
70 struct arizona_extcon_info {
71 struct device *dev;
72 struct arizona *arizona;
73 struct mutex lock;
74 struct regulator *micvdd;
75 struct input_dev *input;
76
77 u16 last_jackdet;
78
79 int micd_mode;
80 const struct arizona_micd_config *micd_modes;
81 int micd_num_modes;
82
83 const struct arizona_micd_range *micd_ranges;
84 int num_micd_ranges;
85
86 int micd_timeout;
87
88 bool micd_reva;
89 bool micd_clamp;
90
91 struct delayed_work hpdet_work;
92 struct delayed_work micd_detect_work;
93 struct delayed_work micd_timeout_work;
94
95 bool hpdet_active;
96 bool hpdet_done;
97 bool hpdet_retried;
98
99 int num_hpdet_res;
100 unsigned int hpdet_res[3];
101
102 bool mic;
103 bool detecting;
104 int jack_flips;
105
106 int hpdet_ip_version;
107
108 struct extcon_dev *edev;
109
110 struct gpio_desc *micd_pol_gpio;
111 };
112
113 static const struct arizona_micd_config micd_default_modes[] = {
114 { ARIZONA_ACCDET_SRC, 1, 0 },
115 { 0, 2, 1 },
116 };
117
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 },
125 };
126
127 /* The number of levels in arizona_micd_levels valid for button thresholds */
128 #define ARIZONA_NUM_MICD_BUTTON_LEVELS 64
129
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,
135 1257, 30000,
136 };
137
138 static const unsigned int arizona_cable[] = {
139 EXTCON_MECHANICAL,
140 EXTCON_MICROPHONE,
141 EXTCON_HEADPHONE,
142 EXTCON_LINE_OUT,
143 EXTCON_NONE,
144 };
145
146 static void arizona_start_hpdet_acc_id(struct arizona_extcon_info *info);
147
148 static void arizona_extcon_hp_clamp(struct arizona_extcon_info *info,
149 bool clamp)
150 {
151 struct arizona *arizona = info->arizona;
152 unsigned int mask = 0, val = 0;
153 unsigned int cap_sel = 0;
154 int ret;
155
156 switch (arizona->type) {
157 case WM8998:
158 case WM1814:
159 mask = 0;
160 break;
161 case WM5110:
162 case WM8280:
163 mask = ARIZONA_HP1L_SHRTO | ARIZONA_HP1L_FLWR |
164 ARIZONA_HP1L_SHRTI;
165 if (clamp) {
166 val = ARIZONA_HP1L_SHRTO;
167 cap_sel = ARIZONA_TST_CAP_CLAMP;
168 } else {
169 val = ARIZONA_HP1L_FLWR | ARIZONA_HP1L_SHRTI;
170 cap_sel = ARIZONA_TST_CAP_DEFAULT;
171 }
172
173 ret = regmap_update_bits(arizona->regmap,
174 ARIZONA_HP_TEST_CTRL_1,
175 ARIZONA_HP1_TST_CAP_SEL_MASK,
176 cap_sel);
177 if (ret != 0)
178 dev_warn(arizona->dev,
179 "Failed to set TST_CAP_SEL: %d\n", ret);
180 break;
181 default:
182 mask = ARIZONA_RMV_SHRT_HP1L;
183 if (clamp)
184 val = ARIZONA_RMV_SHRT_HP1L;
185 break;
186 };
187
188 mutex_lock(&arizona->dapm->card->dapm_mutex);
189
190 arizona->hpdet_clamp = clamp;
191
192 /* Keep the HP output stages disabled while doing the clamp */
193 if (clamp) {
194 ret = regmap_update_bits(arizona->regmap,
195 ARIZONA_OUTPUT_ENABLES_1,
196 ARIZONA_OUT1L_ENA |
197 ARIZONA_OUT1R_ENA, 0);
198 if (ret != 0)
199 dev_warn(arizona->dev,
200 "Failed to disable headphone outputs: %d\n",
201 ret);
202 }
203
204 if (mask) {
205 ret = regmap_update_bits(arizona->regmap, ARIZONA_HP_CTRL_1L,
206 mask, val);
207 if (ret != 0)
208 dev_warn(arizona->dev, "Failed to do clamp: %d\n",
209 ret);
210
211 ret = regmap_update_bits(arizona->regmap, ARIZONA_HP_CTRL_1R,
212 mask, val);
213 if (ret != 0)
214 dev_warn(arizona->dev, "Failed to do clamp: %d\n",
215 ret);
216 }
217
218 /* Restore the desired state while not doing the clamp */
219 if (!clamp) {
220 ret = regmap_update_bits(arizona->regmap,
221 ARIZONA_OUTPUT_ENABLES_1,
222 ARIZONA_OUT1L_ENA |
223 ARIZONA_OUT1R_ENA, arizona->hp_ena);
224 if (ret != 0)
225 dev_warn(arizona->dev,
226 "Failed to restore headphone outputs: %d\n",
227 ret);
228 }
229
230 mutex_unlock(&arizona->dapm->card->dapm_mutex);
231 }
232
233 static void arizona_extcon_set_mode(struct arizona_extcon_info *info, int mode)
234 {
235 struct arizona *arizona = info->arizona;
236
237 mode %= info->micd_num_modes;
238
239 if (arizona->pdata.micd_pol_gpio > 0)
240 gpio_set_value_cansleep(arizona->pdata.micd_pol_gpio,
241 info->micd_modes[mode].gpio);
242 else
243 gpiod_set_value_cansleep(info->micd_pol_gpio,
244 info->micd_modes[mode].gpio);
245
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);
252
253 info->micd_mode = mode;
254
255 dev_dbg(arizona->dev, "Set jack polarity to %d\n", mode);
256 }
257
258 static const char *arizona_extcon_get_micbias(struct arizona_extcon_info *info)
259 {
260 switch (info->micd_modes[0].bias) {
261 case 1:
262 return "MICBIAS1";
263 case 2:
264 return "MICBIAS2";
265 case 3:
266 return "MICBIAS3";
267 default:
268 return "MICVDD";
269 }
270 }
271
272 static void arizona_extcon_pulse_micbias(struct arizona_extcon_info *info)
273 {
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 int ret;
278
279 ret = snd_soc_dapm_force_enable_pin(dapm, widget);
280 if (ret != 0)
281 dev_warn(arizona->dev, "Failed to enable %s: %d\n",
282 widget, ret);
283
284 snd_soc_dapm_sync(dapm);
285
286 if (!arizona->pdata.micd_force_micbias) {
287 ret = snd_soc_dapm_disable_pin(arizona->dapm, widget);
288 if (ret != 0)
289 dev_warn(arizona->dev, "Failed to disable %s: %d\n",
290 widget, ret);
291
292 snd_soc_dapm_sync(dapm);
293 }
294 }
295
296 static void arizona_start_mic(struct arizona_extcon_info *info)
297 {
298 struct arizona *arizona = info->arizona;
299 bool change;
300 int ret;
301 unsigned int mode;
302
303 /* Microphone detection can't use idle mode */
304 pm_runtime_get(info->dev);
305
306 if (info->detecting) {
307 ret = regulator_allow_bypass(info->micvdd, false);
308 if (ret != 0) {
309 dev_err(arizona->dev,
310 "Failed to regulate MICVDD: %d\n",
311 ret);
312 }
313 }
314
315 ret = regulator_enable(info->micvdd);
316 if (ret != 0) {
317 dev_err(arizona->dev, "Failed to enable MICVDD: %d\n",
318 ret);
319 }
320
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);
325 }
326
327 if (info->detecting && arizona->pdata.micd_software_compare)
328 mode = ARIZONA_ACCDET_MODE_ADC;
329 else
330 mode = ARIZONA_ACCDET_MODE_MIC;
331
332 regmap_update_bits(arizona->regmap,
333 ARIZONA_ACCESSORY_DETECT_MODE_1,
334 ARIZONA_ACCDET_MODE_MASK, mode);
335
336 arizona_extcon_pulse_micbias(info);
337
338 regmap_update_bits_check(arizona->regmap, ARIZONA_MIC_DETECT_1,
339 ARIZONA_MICD_ENA, ARIZONA_MICD_ENA,
340 &change);
341 if (!change) {
342 regulator_disable(info->micvdd);
343 pm_runtime_put_autosuspend(info->dev);
344 }
345 }
346
347 static void arizona_stop_mic(struct arizona_extcon_info *info)
348 {
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 bool change;
353 int ret;
354
355 regmap_update_bits_check(arizona->regmap, ARIZONA_MIC_DETECT_1,
356 ARIZONA_MICD_ENA, 0,
357 &change);
358
359 ret = snd_soc_dapm_disable_pin(dapm, widget);
360 if (ret != 0)
361 dev_warn(arizona->dev,
362 "Failed to disable %s: %d\n",
363 widget, ret);
364
365 snd_soc_dapm_sync(dapm);
366
367 if (info->micd_reva) {
368 regmap_write(arizona->regmap, 0x80, 0x3);
369 regmap_write(arizona->regmap, 0x294, 2);
370 regmap_write(arizona->regmap, 0x80, 0x0);
371 }
372
373 ret = regulator_allow_bypass(info->micvdd, true);
374 if (ret != 0) {
375 dev_err(arizona->dev, "Failed to bypass MICVDD: %d\n",
376 ret);
377 }
378
379 if (change) {
380 regulator_disable(info->micvdd);
381 pm_runtime_mark_last_busy(info->dev);
382 pm_runtime_put_autosuspend(info->dev);
383 }
384 }
385
386 static struct {
387 unsigned int threshold;
388 unsigned int factor_a;
389 unsigned int factor_b;
390 } arizona_hpdet_b_ranges[] = {
391 { 100, 5528, 362464 },
392 { 169, 11084, 6186851 },
393 { 169, 11065, 65460395 },
394 };
395
396 #define ARIZONA_HPDET_B_RANGE_MAX 0x3fb
397
398 static struct {
399 int min;
400 int max;
401 } arizona_hpdet_c_ranges[] = {
402 { 0, 30 },
403 { 8, 100 },
404 { 100, 1000 },
405 { 1000, 10000 },
406 };
407
408 static int arizona_hpdet_read(struct arizona_extcon_info *info)
409 {
410 struct arizona *arizona = info->arizona;
411 unsigned int val, range;
412 int ret;
413
414 ret = regmap_read(arizona->regmap, ARIZONA_HEADPHONE_DETECT_2, &val);
415 if (ret != 0) {
416 dev_err(arizona->dev, "Failed to read HPDET status: %d\n",
417 ret);
418 return ret;
419 }
420
421 switch (info->hpdet_ip_version) {
422 case 0:
423 if (!(val & ARIZONA_HP_DONE)) {
424 dev_err(arizona->dev, "HPDET did not complete: %x\n",
425 val);
426 return -EAGAIN;
427 }
428
429 val &= ARIZONA_HP_LVL_MASK;
430 break;
431
432 case 1:
433 if (!(val & ARIZONA_HP_DONE_B)) {
434 dev_err(arizona->dev, "HPDET did not complete: %x\n",
435 val);
436 return -EAGAIN;
437 }
438
439 ret = regmap_read(arizona->regmap, ARIZONA_HP_DACVAL, &val);
440 if (ret != 0) {
441 dev_err(arizona->dev, "Failed to read HP value: %d\n",
442 ret);
443 return -EAGAIN;
444 }
445
446 regmap_read(arizona->regmap, ARIZONA_HEADPHONE_DETECT_1,
447 &range);
448 range = (range & ARIZONA_HP_IMPEDANCE_RANGE_MASK)
449 >> ARIZONA_HP_IMPEDANCE_RANGE_SHIFT;
450
451 if (range < ARRAY_SIZE(arizona_hpdet_b_ranges) - 1 &&
452 (val < arizona_hpdet_b_ranges[range].threshold ||
453 val >= ARIZONA_HPDET_B_RANGE_MAX)) {
454 range++;
455 dev_dbg(arizona->dev, "Moving to HPDET range %d\n",
456 range);
457 regmap_update_bits(arizona->regmap,
458 ARIZONA_HEADPHONE_DETECT_1,
459 ARIZONA_HP_IMPEDANCE_RANGE_MASK,
460 range <<
461 ARIZONA_HP_IMPEDANCE_RANGE_SHIFT);
462 return -EAGAIN;
463 }
464
465 /* If we go out of range report top of range */
466 if (val < arizona_hpdet_b_ranges[range].threshold ||
467 val >= ARIZONA_HPDET_B_RANGE_MAX) {
468 dev_dbg(arizona->dev, "Measurement out of range\n");
469 return ARIZONA_HPDET_MAX;
470 }
471
472 dev_dbg(arizona->dev, "HPDET read %d in range %d\n",
473 val, range);
474
475 val = arizona_hpdet_b_ranges[range].factor_b
476 / ((val * 100) -
477 arizona_hpdet_b_ranges[range].factor_a);
478 break;
479
480 default:
481 dev_warn(arizona->dev, "Unknown HPDET IP revision %d\n",
482 info->hpdet_ip_version);
483 case 2:
484 if (!(val & ARIZONA_HP_DONE_B)) {
485 dev_err(arizona->dev, "HPDET did not complete: %x\n",
486 val);
487 return -EAGAIN;
488 }
489
490 val &= ARIZONA_HP_LVL_B_MASK;
491 /* Convert to ohms, the value is in 0.5 ohm increments */
492 val /= 2;
493
494 regmap_read(arizona->regmap, ARIZONA_HEADPHONE_DETECT_1,
495 &range);
496 range = (range & ARIZONA_HP_IMPEDANCE_RANGE_MASK)
497 >> ARIZONA_HP_IMPEDANCE_RANGE_SHIFT;
498
499 /* Skip up a range, or report? */
500 if (range < ARRAY_SIZE(arizona_hpdet_c_ranges) - 1 &&
501 (val >= arizona_hpdet_c_ranges[range].max)) {
502 range++;
503 dev_dbg(arizona->dev, "Moving to HPDET range %d-%d\n",
504 arizona_hpdet_c_ranges[range].min,
505 arizona_hpdet_c_ranges[range].max);
506 regmap_update_bits(arizona->regmap,
507 ARIZONA_HEADPHONE_DETECT_1,
508 ARIZONA_HP_IMPEDANCE_RANGE_MASK,
509 range <<
510 ARIZONA_HP_IMPEDANCE_RANGE_SHIFT);
511 return -EAGAIN;
512 }
513
514 if (range && (val < arizona_hpdet_c_ranges[range].min)) {
515 dev_dbg(arizona->dev, "Reporting range boundary %d\n",
516 arizona_hpdet_c_ranges[range].min);
517 val = arizona_hpdet_c_ranges[range].min;
518 }
519 }
520
521 dev_dbg(arizona->dev, "HP impedance %d ohms\n", val);
522 return val;
523 }
524
525 static int arizona_hpdet_do_id(struct arizona_extcon_info *info, int *reading,
526 bool *mic)
527 {
528 struct arizona *arizona = info->arizona;
529 int id_gpio = arizona->pdata.hpdet_id_gpio;
530
531 /*
532 * If we're using HPDET for accessory identification we need
533 * to take multiple measurements, step through them in sequence.
534 */
535 if (arizona->pdata.hpdet_acc_id) {
536 info->hpdet_res[info->num_hpdet_res++] = *reading;
537
538 /* Only check the mic directly if we didn't already ID it */
539 if (id_gpio && info->num_hpdet_res == 1) {
540 dev_dbg(arizona->dev, "Measuring mic\n");
541
542 regmap_update_bits(arizona->regmap,
543 ARIZONA_ACCESSORY_DETECT_MODE_1,
544 ARIZONA_ACCDET_MODE_MASK |
545 ARIZONA_ACCDET_SRC,
546 ARIZONA_ACCDET_MODE_HPR |
547 info->micd_modes[0].src);
548
549 gpio_set_value_cansleep(id_gpio, 1);
550
551 regmap_update_bits(arizona->regmap,
552 ARIZONA_HEADPHONE_DETECT_1,
553 ARIZONA_HP_POLL, ARIZONA_HP_POLL);
554 return -EAGAIN;
555 }
556
557 /* OK, got both. Now, compare... */
558 dev_dbg(arizona->dev, "HPDET measured %d %d\n",
559 info->hpdet_res[0], info->hpdet_res[1]);
560
561 /* Take the headphone impedance for the main report */
562 *reading = info->hpdet_res[0];
563
564 /* Sometimes we get false readings due to slow insert */
565 if (*reading >= ARIZONA_HPDET_MAX && !info->hpdet_retried) {
566 dev_dbg(arizona->dev, "Retrying high impedance\n");
567 info->num_hpdet_res = 0;
568 info->hpdet_retried = true;
569 arizona_start_hpdet_acc_id(info);
570 pm_runtime_put(info->dev);
571 return -EAGAIN;
572 }
573
574 /*
575 * If we measure the mic as high impedance
576 */
577 if (!id_gpio || info->hpdet_res[1] > 50) {
578 dev_dbg(arizona->dev, "Detected mic\n");
579 *mic = true;
580 info->detecting = true;
581 } else {
582 dev_dbg(arizona->dev, "Detected headphone\n");
583 }
584
585 /* Make sure everything is reset back to the real polarity */
586 regmap_update_bits(arizona->regmap,
587 ARIZONA_ACCESSORY_DETECT_MODE_1,
588 ARIZONA_ACCDET_SRC,
589 info->micd_modes[0].src);
590 }
591
592 return 0;
593 }
594
595 static irqreturn_t arizona_hpdet_irq(int irq, void *data)
596 {
597 struct arizona_extcon_info *info = data;
598 struct arizona *arizona = info->arizona;
599 int id_gpio = arizona->pdata.hpdet_id_gpio;
600 unsigned int report = EXTCON_HEADPHONE;
601 int ret, reading;
602 bool mic = false;
603
604 mutex_lock(&info->lock);
605
606 /* If we got a spurious IRQ for some reason then ignore it */
607 if (!info->hpdet_active) {
608 dev_warn(arizona->dev, "Spurious HPDET IRQ\n");
609 mutex_unlock(&info->lock);
610 return IRQ_NONE;
611 }
612
613 /* If the cable was removed while measuring ignore the result */
614 ret = extcon_get_cable_state_(info->edev, EXTCON_MECHANICAL);
615 if (ret < 0) {
616 dev_err(arizona->dev, "Failed to check cable state: %d\n",
617 ret);
618 goto out;
619 } else if (!ret) {
620 dev_dbg(arizona->dev, "Ignoring HPDET for removed cable\n");
621 goto done;
622 }
623
624 ret = arizona_hpdet_read(info);
625 if (ret == -EAGAIN)
626 goto out;
627 else if (ret < 0)
628 goto done;
629 reading = ret;
630
631 /* Reset back to starting range */
632 regmap_update_bits(arizona->regmap,
633 ARIZONA_HEADPHONE_DETECT_1,
634 ARIZONA_HP_IMPEDANCE_RANGE_MASK | ARIZONA_HP_POLL,
635 0);
636
637 ret = arizona_hpdet_do_id(info, &reading, &mic);
638 if (ret == -EAGAIN)
639 goto out;
640 else if (ret < 0)
641 goto done;
642
643 /* Report high impedence cables as line outputs */
644 if (reading >= 5000)
645 report = EXTCON_LINE_OUT;
646 else
647 report = EXTCON_HEADPHONE;
648
649 ret = extcon_set_cable_state_(info->edev, report, true);
650 if (ret != 0)
651 dev_err(arizona->dev, "Failed to report HP/line: %d\n",
652 ret);
653
654 done:
655 /* Reset back to starting range */
656 regmap_update_bits(arizona->regmap,
657 ARIZONA_HEADPHONE_DETECT_1,
658 ARIZONA_HP_IMPEDANCE_RANGE_MASK | ARIZONA_HP_POLL,
659 0);
660
661 arizona_extcon_hp_clamp(info, false);
662
663 if (id_gpio)
664 gpio_set_value_cansleep(id_gpio, 0);
665
666 /* Revert back to MICDET mode */
667 regmap_update_bits(arizona->regmap,
668 ARIZONA_ACCESSORY_DETECT_MODE_1,
669 ARIZONA_ACCDET_MODE_MASK, ARIZONA_ACCDET_MODE_MIC);
670
671 /* If we have a mic then reenable MICDET */
672 if (mic || info->mic)
673 arizona_start_mic(info);
674
675 if (info->hpdet_active) {
676 pm_runtime_put_autosuspend(info->dev);
677 info->hpdet_active = false;
678 }
679
680 info->hpdet_done = true;
681
682 out:
683 mutex_unlock(&info->lock);
684
685 return IRQ_HANDLED;
686 }
687
688 static void arizona_identify_headphone(struct arizona_extcon_info *info)
689 {
690 struct arizona *arizona = info->arizona;
691 int ret;
692
693 if (info->hpdet_done)
694 return;
695
696 dev_dbg(arizona->dev, "Starting HPDET\n");
697
698 /* Make sure we keep the device enabled during the measurement */
699 pm_runtime_get(info->dev);
700
701 info->hpdet_active = true;
702
703 if (info->mic)
704 arizona_stop_mic(info);
705
706 arizona_extcon_hp_clamp(info, true);
707
708 ret = regmap_update_bits(arizona->regmap,
709 ARIZONA_ACCESSORY_DETECT_MODE_1,
710 ARIZONA_ACCDET_MODE_MASK,
711 arizona->pdata.hpdet_channel);
712 if (ret != 0) {
713 dev_err(arizona->dev, "Failed to set HPDET mode: %d\n", ret);
714 goto err;
715 }
716
717 ret = regmap_update_bits(arizona->regmap, ARIZONA_HEADPHONE_DETECT_1,
718 ARIZONA_HP_POLL, ARIZONA_HP_POLL);
719 if (ret != 0) {
720 dev_err(arizona->dev, "Can't start HPDETL measurement: %d\n",
721 ret);
722 goto err;
723 }
724
725 return;
726
727 err:
728 regmap_update_bits(arizona->regmap, ARIZONA_ACCESSORY_DETECT_MODE_1,
729 ARIZONA_ACCDET_MODE_MASK, ARIZONA_ACCDET_MODE_MIC);
730
731 /* Just report headphone */
732 ret = extcon_set_cable_state_(info->edev, EXTCON_HEADPHONE, true);
733 if (ret != 0)
734 dev_err(arizona->dev, "Failed to report headphone: %d\n", ret);
735
736 if (info->mic)
737 arizona_start_mic(info);
738
739 info->hpdet_active = false;
740 }
741
742 static void arizona_start_hpdet_acc_id(struct arizona_extcon_info *info)
743 {
744 struct arizona *arizona = info->arizona;
745 int hp_reading = 32;
746 bool mic;
747 int ret;
748
749 dev_dbg(arizona->dev, "Starting identification via HPDET\n");
750
751 /* Make sure we keep the device enabled during the measurement */
752 pm_runtime_get_sync(info->dev);
753
754 info->hpdet_active = true;
755
756 arizona_extcon_hp_clamp(info, true);
757
758 ret = regmap_update_bits(arizona->regmap,
759 ARIZONA_ACCESSORY_DETECT_MODE_1,
760 ARIZONA_ACCDET_SRC | ARIZONA_ACCDET_MODE_MASK,
761 info->micd_modes[0].src |
762 arizona->pdata.hpdet_channel);
763 if (ret != 0) {
764 dev_err(arizona->dev, "Failed to set HPDET mode: %d\n", ret);
765 goto err;
766 }
767
768 if (arizona->pdata.hpdet_acc_id_line) {
769 ret = regmap_update_bits(arizona->regmap,
770 ARIZONA_HEADPHONE_DETECT_1,
771 ARIZONA_HP_POLL, ARIZONA_HP_POLL);
772 if (ret != 0) {
773 dev_err(arizona->dev,
774 "Can't start HPDETL measurement: %d\n",
775 ret);
776 goto err;
777 }
778 } else {
779 arizona_hpdet_do_id(info, &hp_reading, &mic);
780 }
781
782 return;
783
784 err:
785 regmap_update_bits(arizona->regmap, ARIZONA_ACCESSORY_DETECT_MODE_1,
786 ARIZONA_ACCDET_MODE_MASK, ARIZONA_ACCDET_MODE_MIC);
787
788 /* Just report headphone */
789 ret = extcon_set_cable_state_(info->edev, EXTCON_HEADPHONE, true);
790 if (ret != 0)
791 dev_err(arizona->dev, "Failed to report headphone: %d\n", ret);
792
793 info->hpdet_active = false;
794 }
795
796 static void arizona_micd_timeout_work(struct work_struct *work)
797 {
798 struct arizona_extcon_info *info = container_of(work,
799 struct arizona_extcon_info,
800 micd_timeout_work.work);
801
802 mutex_lock(&info->lock);
803
804 dev_dbg(info->arizona->dev, "MICD timed out, reporting HP\n");
805
806 info->detecting = false;
807
808 arizona_identify_headphone(info);
809
810 arizona_stop_mic(info);
811
812 mutex_unlock(&info->lock);
813 }
814
815 static void arizona_micd_detect(struct work_struct *work)
816 {
817 struct arizona_extcon_info *info = container_of(work,
818 struct arizona_extcon_info,
819 micd_detect_work.work);
820 struct arizona *arizona = info->arizona;
821 unsigned int val = 0, lvl;
822 int ret, i, key;
823
824 cancel_delayed_work_sync(&info->micd_timeout_work);
825
826 mutex_lock(&info->lock);
827
828 /* If the cable was removed while measuring ignore the result */
829 ret = extcon_get_cable_state_(info->edev, EXTCON_MECHANICAL);
830 if (ret < 0) {
831 dev_err(arizona->dev, "Failed to check cable state: %d\n",
832 ret);
833 mutex_unlock(&info->lock);
834 return;
835 } else if (!ret) {
836 dev_dbg(arizona->dev, "Ignoring MICDET for removed cable\n");
837 mutex_unlock(&info->lock);
838 return;
839 }
840
841 if (info->detecting && arizona->pdata.micd_software_compare) {
842 /* Must disable MICD before we read the ADCVAL */
843 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_1,
844 ARIZONA_MICD_ENA, 0);
845 ret = regmap_read(arizona->regmap, ARIZONA_MIC_DETECT_4, &val);
846 if (ret != 0) {
847 dev_err(arizona->dev,
848 "Failed to read MICDET_ADCVAL: %d\n",
849 ret);
850 mutex_unlock(&info->lock);
851 return;
852 }
853
854 dev_dbg(arizona->dev, "MICDET_ADCVAL: %x\n", val);
855
856 val &= ARIZONA_MICDET_ADCVAL_MASK;
857 if (val < ARRAY_SIZE(arizona_micd_levels))
858 val = arizona_micd_levels[val];
859 else
860 val = INT_MAX;
861
862 if (val <= QUICK_HEADPHONE_MAX_OHM)
863 val = ARIZONA_MICD_STS | ARIZONA_MICD_LVL_0;
864 else if (val <= MICROPHONE_MIN_OHM)
865 val = ARIZONA_MICD_STS | ARIZONA_MICD_LVL_1;
866 else if (val <= MICROPHONE_MAX_OHM)
867 val = ARIZONA_MICD_STS | ARIZONA_MICD_LVL_8;
868 else
869 val = ARIZONA_MICD_LVL_8;
870 }
871
872 for (i = 0; i < 10 && !(val & MICD_LVL_0_TO_8); i++) {
873 ret = regmap_read(arizona->regmap, ARIZONA_MIC_DETECT_3, &val);
874 if (ret != 0) {
875 dev_err(arizona->dev,
876 "Failed to read MICDET: %d\n", ret);
877 mutex_unlock(&info->lock);
878 return;
879 }
880
881 dev_dbg(arizona->dev, "MICDET: %x\n", val);
882
883 if (!(val & ARIZONA_MICD_VALID)) {
884 dev_warn(arizona->dev,
885 "Microphone detection state invalid\n");
886 mutex_unlock(&info->lock);
887 return;
888 }
889 }
890
891 if (i == 10 && !(val & MICD_LVL_0_TO_8)) {
892 dev_err(arizona->dev, "Failed to get valid MICDET value\n");
893 mutex_unlock(&info->lock);
894 return;
895 }
896
897 /* Due to jack detect this should never happen */
898 if (!(val & ARIZONA_MICD_STS)) {
899 dev_warn(arizona->dev, "Detected open circuit\n");
900 info->mic = false;
901 arizona_stop_mic(info);
902 info->detecting = false;
903 arizona_identify_headphone(info);
904 goto handled;
905 }
906
907 /* If we got a high impedence we should have a headset, report it. */
908 if (info->detecting && (val & ARIZONA_MICD_LVL_8)) {
909 info->mic = true;
910 info->detecting = false;
911
912 arizona_identify_headphone(info);
913
914 ret = extcon_set_cable_state_(info->edev,
915 EXTCON_MICROPHONE, true);
916 if (ret != 0)
917 dev_err(arizona->dev, "Headset report failed: %d\n",
918 ret);
919
920 /* Don't need to regulate for button detection */
921 ret = regulator_allow_bypass(info->micvdd, true);
922 if (ret != 0) {
923 dev_err(arizona->dev, "Failed to bypass MICVDD: %d\n",
924 ret);
925 }
926
927 goto handled;
928 }
929
930 /* If we detected a lower impedence during initial startup
931 * then we probably have the wrong polarity, flip it. Don't
932 * do this for the lowest impedences to speed up detection of
933 * plain headphones. If both polarities report a low
934 * impedence then give up and report headphones.
935 */
936 if (info->detecting && (val & MICD_LVL_1_TO_7)) {
937 if (info->jack_flips >= info->micd_num_modes * 10) {
938 dev_dbg(arizona->dev, "Detected HP/line\n");
939
940 info->detecting = false;
941
942 arizona_identify_headphone(info);
943
944 arizona_stop_mic(info);
945 } else {
946 info->micd_mode++;
947 if (info->micd_mode == info->micd_num_modes)
948 info->micd_mode = 0;
949 arizona_extcon_set_mode(info, info->micd_mode);
950
951 info->jack_flips++;
952 }
953
954 goto handled;
955 }
956
957 /*
958 * If we're still detecting and we detect a short then we've
959 * got a headphone. Otherwise it's a button press.
960 */
961 if (val & MICD_LVL_0_TO_7) {
962 if (info->mic) {
963 dev_dbg(arizona->dev, "Mic button detected\n");
964
965 lvl = val & ARIZONA_MICD_LVL_MASK;
966 lvl >>= ARIZONA_MICD_LVL_SHIFT;
967
968 for (i = 0; i < info->num_micd_ranges; i++)
969 input_report_key(info->input,
970 info->micd_ranges[i].key, 0);
971
972 WARN_ON(!lvl);
973 WARN_ON(ffs(lvl) - 1 >= info->num_micd_ranges);
974 if (lvl && ffs(lvl) - 1 < info->num_micd_ranges) {
975 key = info->micd_ranges[ffs(lvl) - 1].key;
976 input_report_key(info->input, key, 1);
977 input_sync(info->input);
978 }
979
980 } else if (info->detecting) {
981 dev_dbg(arizona->dev, "Headphone detected\n");
982 info->detecting = false;
983 arizona_stop_mic(info);
984
985 arizona_identify_headphone(info);
986 } else {
987 dev_warn(arizona->dev, "Button with no mic: %x\n",
988 val);
989 }
990 } else {
991 dev_dbg(arizona->dev, "Mic button released\n");
992 for (i = 0; i < info->num_micd_ranges; i++)
993 input_report_key(info->input,
994 info->micd_ranges[i].key, 0);
995 input_sync(info->input);
996 arizona_extcon_pulse_micbias(info);
997 }
998
999 handled:
1000 if (info->detecting) {
1001 if (arizona->pdata.micd_software_compare)
1002 regmap_update_bits(arizona->regmap,
1003 ARIZONA_MIC_DETECT_1,
1004 ARIZONA_MICD_ENA,
1005 ARIZONA_MICD_ENA);
1006
1007 queue_delayed_work(system_power_efficient_wq,
1008 &info->micd_timeout_work,
1009 msecs_to_jiffies(info->micd_timeout));
1010 }
1011
1012 pm_runtime_mark_last_busy(info->dev);
1013 mutex_unlock(&info->lock);
1014 }
1015
1016 static irqreturn_t arizona_micdet(int irq, void *data)
1017 {
1018 struct arizona_extcon_info *info = data;
1019 struct arizona *arizona = info->arizona;
1020 int debounce = arizona->pdata.micd_detect_debounce;
1021
1022 cancel_delayed_work_sync(&info->micd_detect_work);
1023 cancel_delayed_work_sync(&info->micd_timeout_work);
1024
1025 mutex_lock(&info->lock);
1026 if (!info->detecting)
1027 debounce = 0;
1028 mutex_unlock(&info->lock);
1029
1030 if (debounce)
1031 queue_delayed_work(system_power_efficient_wq,
1032 &info->micd_detect_work,
1033 msecs_to_jiffies(debounce));
1034 else
1035 arizona_micd_detect(&info->micd_detect_work.work);
1036
1037 return IRQ_HANDLED;
1038 }
1039
1040 static void arizona_hpdet_work(struct work_struct *work)
1041 {
1042 struct arizona_extcon_info *info = container_of(work,
1043 struct arizona_extcon_info,
1044 hpdet_work.work);
1045
1046 mutex_lock(&info->lock);
1047 arizona_start_hpdet_acc_id(info);
1048 mutex_unlock(&info->lock);
1049 }
1050
1051 static irqreturn_t arizona_jackdet(int irq, void *data)
1052 {
1053 struct arizona_extcon_info *info = data;
1054 struct arizona *arizona = info->arizona;
1055 unsigned int val, present, mask;
1056 bool cancelled_hp, cancelled_mic;
1057 int ret, i;
1058
1059 cancelled_hp = cancel_delayed_work_sync(&info->hpdet_work);
1060 cancelled_mic = cancel_delayed_work_sync(&info->micd_timeout_work);
1061
1062 pm_runtime_get_sync(info->dev);
1063
1064 mutex_lock(&info->lock);
1065
1066 if (info->micd_clamp) {
1067 mask = ARIZONA_MICD_CLAMP_STS;
1068 present = 0;
1069 } else {
1070 mask = ARIZONA_JD1_STS;
1071 if (arizona->pdata.jd_invert)
1072 present = 0;
1073 else
1074 present = ARIZONA_JD1_STS;
1075 }
1076
1077 ret = regmap_read(arizona->regmap, ARIZONA_AOD_IRQ_RAW_STATUS, &val);
1078 if (ret != 0) {
1079 dev_err(arizona->dev, "Failed to read jackdet status: %d\n",
1080 ret);
1081 mutex_unlock(&info->lock);
1082 pm_runtime_put_autosuspend(info->dev);
1083 return IRQ_NONE;
1084 }
1085
1086 val &= mask;
1087 if (val == info->last_jackdet) {
1088 dev_dbg(arizona->dev, "Suppressing duplicate JACKDET\n");
1089 if (cancelled_hp)
1090 queue_delayed_work(system_power_efficient_wq,
1091 &info->hpdet_work,
1092 msecs_to_jiffies(HPDET_DEBOUNCE));
1093
1094 if (cancelled_mic) {
1095 int micd_timeout = info->micd_timeout;
1096
1097 queue_delayed_work(system_power_efficient_wq,
1098 &info->micd_timeout_work,
1099 msecs_to_jiffies(micd_timeout));
1100 }
1101
1102 goto out;
1103 }
1104 info->last_jackdet = val;
1105
1106 if (info->last_jackdet == present) {
1107 dev_dbg(arizona->dev, "Detected jack\n");
1108 ret = extcon_set_cable_state_(info->edev,
1109 EXTCON_MECHANICAL, true);
1110
1111 if (ret != 0)
1112 dev_err(arizona->dev, "Mechanical report failed: %d\n",
1113 ret);
1114
1115 if (!arizona->pdata.hpdet_acc_id) {
1116 info->detecting = true;
1117 info->mic = false;
1118 info->jack_flips = 0;
1119
1120 arizona_start_mic(info);
1121 } else {
1122 queue_delayed_work(system_power_efficient_wq,
1123 &info->hpdet_work,
1124 msecs_to_jiffies(HPDET_DEBOUNCE));
1125 }
1126
1127 if (info->micd_clamp || !arizona->pdata.jd_invert)
1128 regmap_update_bits(arizona->regmap,
1129 ARIZONA_JACK_DETECT_DEBOUNCE,
1130 ARIZONA_MICD_CLAMP_DB |
1131 ARIZONA_JD1_DB, 0);
1132 } else {
1133 dev_dbg(arizona->dev, "Detected jack removal\n");
1134
1135 arizona_stop_mic(info);
1136
1137 info->num_hpdet_res = 0;
1138 for (i = 0; i < ARRAY_SIZE(info->hpdet_res); i++)
1139 info->hpdet_res[i] = 0;
1140 info->mic = false;
1141 info->hpdet_done = false;
1142 info->hpdet_retried = false;
1143
1144 for (i = 0; i < info->num_micd_ranges; i++)
1145 input_report_key(info->input,
1146 info->micd_ranges[i].key, 0);
1147 input_sync(info->input);
1148
1149 ret = extcon_update_state(info->edev, 0xffffffff, 0);
1150 if (ret != 0)
1151 dev_err(arizona->dev, "Removal report failed: %d\n",
1152 ret);
1153
1154 regmap_update_bits(arizona->regmap,
1155 ARIZONA_JACK_DETECT_DEBOUNCE,
1156 ARIZONA_MICD_CLAMP_DB | ARIZONA_JD1_DB,
1157 ARIZONA_MICD_CLAMP_DB | ARIZONA_JD1_DB);
1158 }
1159
1160 if (arizona->pdata.micd_timeout)
1161 info->micd_timeout = arizona->pdata.micd_timeout;
1162 else
1163 info->micd_timeout = DEFAULT_MICD_TIMEOUT;
1164
1165 out:
1166 /* Clear trig_sts to make sure DCVDD is not forced up */
1167 regmap_write(arizona->regmap, ARIZONA_AOD_WKUP_AND_TRIG,
1168 ARIZONA_MICD_CLAMP_FALL_TRIG_STS |
1169 ARIZONA_MICD_CLAMP_RISE_TRIG_STS |
1170 ARIZONA_JD1_FALL_TRIG_STS |
1171 ARIZONA_JD1_RISE_TRIG_STS);
1172
1173 mutex_unlock(&info->lock);
1174
1175 pm_runtime_mark_last_busy(info->dev);
1176 pm_runtime_put_autosuspend(info->dev);
1177
1178 return IRQ_HANDLED;
1179 }
1180
1181 /* Map a level onto a slot in the register bank */
1182 static void arizona_micd_set_level(struct arizona *arizona, int index,
1183 unsigned int level)
1184 {
1185 int reg;
1186 unsigned int mask;
1187
1188 reg = ARIZONA_MIC_DETECT_LEVEL_4 - (index / 2);
1189
1190 if (!(index % 2)) {
1191 mask = 0x3f00;
1192 level <<= 8;
1193 } else {
1194 mask = 0x3f;
1195 }
1196
1197 /* Program the level itself */
1198 regmap_update_bits(arizona->regmap, reg, mask, level);
1199 }
1200
1201 static int arizona_extcon_device_get_pdata(struct arizona *arizona)
1202 {
1203 struct arizona_pdata *pdata = &arizona->pdata;
1204 unsigned int val = ARIZONA_ACCDET_MODE_HPL;
1205
1206 device_property_read_u32(arizona->dev, "wlf,hpdet-channel", &val);
1207 switch (val) {
1208 case ARIZONA_ACCDET_MODE_HPL:
1209 case ARIZONA_ACCDET_MODE_HPR:
1210 pdata->hpdet_channel = val;
1211 break;
1212 default:
1213 dev_err(arizona->dev,
1214 "Wrong wlf,hpdet-channel DT value %d\n", val);
1215 pdata->hpdet_channel = ARIZONA_ACCDET_MODE_HPL;
1216 }
1217
1218 device_property_read_u32(arizona->dev, "wlf,micd-detect-debounce",
1219 &pdata->micd_detect_debounce);
1220
1221 device_property_read_u32(arizona->dev, "wlf,micd-bias-start-time",
1222 &pdata->micd_bias_start_time);
1223
1224 device_property_read_u32(arizona->dev, "wlf,micd-rate",
1225 &pdata->micd_rate);
1226
1227 device_property_read_u32(arizona->dev, "wlf,micd-dbtime",
1228 &pdata->micd_dbtime);
1229
1230 device_property_read_u32(arizona->dev, "wlf,micd-timeout",
1231 &pdata->micd_timeout);
1232
1233 pdata->micd_force_micbias = device_property_read_bool(arizona->dev,
1234 "wlf,micd-force-micbias");
1235
1236 return 0;
1237 }
1238
1239 static int arizona_extcon_probe(struct platform_device *pdev)
1240 {
1241 struct arizona *arizona = dev_get_drvdata(pdev->dev.parent);
1242 struct arizona_pdata *pdata = &arizona->pdata;
1243 struct arizona_extcon_info *info;
1244 unsigned int val;
1245 unsigned int clamp_mode;
1246 int jack_irq_fall, jack_irq_rise;
1247 int ret, mode, i, j;
1248
1249 if (!arizona->dapm || !arizona->dapm->card)
1250 return -EPROBE_DEFER;
1251
1252 info = devm_kzalloc(&pdev->dev, sizeof(*info), GFP_KERNEL);
1253 if (!info)
1254 return -ENOMEM;
1255
1256 if (!dev_get_platdata(arizona->dev))
1257 arizona_extcon_device_get_pdata(arizona);
1258
1259 info->micvdd = devm_regulator_get(&pdev->dev, "MICVDD");
1260 if (IS_ERR(info->micvdd)) {
1261 ret = PTR_ERR(info->micvdd);
1262 dev_err(arizona->dev, "Failed to get MICVDD: %d\n", ret);
1263 return ret;
1264 }
1265
1266 mutex_init(&info->lock);
1267 info->arizona = arizona;
1268 info->dev = &pdev->dev;
1269 info->last_jackdet = ~(ARIZONA_MICD_CLAMP_STS | ARIZONA_JD1_STS);
1270 INIT_DELAYED_WORK(&info->hpdet_work, arizona_hpdet_work);
1271 INIT_DELAYED_WORK(&info->micd_detect_work, arizona_micd_detect);
1272 INIT_DELAYED_WORK(&info->micd_timeout_work, arizona_micd_timeout_work);
1273 platform_set_drvdata(pdev, info);
1274
1275 switch (arizona->type) {
1276 case WM5102:
1277 switch (arizona->rev) {
1278 case 0:
1279 info->micd_reva = true;
1280 break;
1281 default:
1282 info->micd_clamp = true;
1283 info->hpdet_ip_version = 1;
1284 break;
1285 }
1286 break;
1287 case WM5110:
1288 case WM8280:
1289 switch (arizona->rev) {
1290 case 0 ... 2:
1291 break;
1292 default:
1293 info->micd_clamp = true;
1294 info->hpdet_ip_version = 2;
1295 break;
1296 }
1297 break;
1298 case WM8998:
1299 case WM1814:
1300 info->micd_clamp = true;
1301 info->hpdet_ip_version = 2;
1302 break;
1303 default:
1304 break;
1305 }
1306
1307 info->edev = devm_extcon_dev_allocate(&pdev->dev, arizona_cable);
1308 if (IS_ERR(info->edev)) {
1309 dev_err(&pdev->dev, "failed to allocate extcon device\n");
1310 return -ENOMEM;
1311 }
1312
1313 ret = devm_extcon_dev_register(&pdev->dev, info->edev);
1314 if (ret < 0) {
1315 dev_err(arizona->dev, "extcon_dev_register() failed: %d\n",
1316 ret);
1317 return ret;
1318 }
1319
1320 info->input = devm_input_allocate_device(&pdev->dev);
1321 if (!info->input) {
1322 dev_err(arizona->dev, "Can't allocate input dev\n");
1323 ret = -ENOMEM;
1324 goto err_register;
1325 }
1326
1327 info->input->name = "Headset";
1328 info->input->phys = "arizona/extcon";
1329
1330 if (pdata->num_micd_configs) {
1331 info->micd_modes = pdata->micd_configs;
1332 info->micd_num_modes = pdata->num_micd_configs;
1333 } else {
1334 info->micd_modes = micd_default_modes;
1335 info->micd_num_modes = ARRAY_SIZE(micd_default_modes);
1336 }
1337
1338 if (arizona->pdata.gpsw > 0)
1339 regmap_update_bits(arizona->regmap, ARIZONA_GP_SWITCH_1,
1340 ARIZONA_SW1_MODE_MASK, arizona->pdata.gpsw);
1341
1342 if (arizona->pdata.micd_pol_gpio > 0) {
1343 if (info->micd_modes[0].gpio)
1344 mode = GPIOF_OUT_INIT_HIGH;
1345 else
1346 mode = GPIOF_OUT_INIT_LOW;
1347
1348 ret = devm_gpio_request_one(&pdev->dev,
1349 arizona->pdata.micd_pol_gpio,
1350 mode,
1351 "MICD polarity");
1352 if (ret != 0) {
1353 dev_err(arizona->dev, "Failed to request GPIO%d: %d\n",
1354 arizona->pdata.micd_pol_gpio, ret);
1355 goto err_register;
1356 }
1357 } else {
1358 if (info->micd_modes[0].gpio)
1359 mode = GPIOD_OUT_HIGH;
1360 else
1361 mode = GPIOD_OUT_LOW;
1362
1363 /* We can't use devm here because we need to do the get
1364 * against the MFD device, as that is where the of_node
1365 * will reside, but if we devm against that the GPIO
1366 * will not be freed if the extcon driver is unloaded.
1367 */
1368 info->micd_pol_gpio = gpiod_get_optional(arizona->dev,
1369 "wlf,micd-pol",
1370 GPIOD_OUT_LOW);
1371 if (IS_ERR(info->micd_pol_gpio)) {
1372 ret = PTR_ERR(info->micd_pol_gpio);
1373 dev_err(arizona->dev,
1374 "Failed to get microphone polarity GPIO: %d\n",
1375 ret);
1376 goto err_register;
1377 }
1378 }
1379
1380 if (arizona->pdata.hpdet_id_gpio > 0) {
1381 ret = devm_gpio_request_one(&pdev->dev,
1382 arizona->pdata.hpdet_id_gpio,
1383 GPIOF_OUT_INIT_LOW,
1384 "HPDET");
1385 if (ret != 0) {
1386 dev_err(arizona->dev, "Failed to request GPIO%d: %d\n",
1387 arizona->pdata.hpdet_id_gpio, ret);
1388 goto err_gpio;
1389 }
1390 }
1391
1392 if (arizona->pdata.micd_bias_start_time)
1393 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_1,
1394 ARIZONA_MICD_BIAS_STARTTIME_MASK,
1395 arizona->pdata.micd_bias_start_time
1396 << ARIZONA_MICD_BIAS_STARTTIME_SHIFT);
1397
1398 if (arizona->pdata.micd_rate)
1399 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_1,
1400 ARIZONA_MICD_RATE_MASK,
1401 arizona->pdata.micd_rate
1402 << ARIZONA_MICD_RATE_SHIFT);
1403
1404 switch (arizona->pdata.micd_dbtime) {
1405 case MICD_DBTIME_FOUR_READINGS:
1406 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_1,
1407 ARIZONA_MICD_DBTIME_MASK,
1408 ARIZONA_MICD_DBTIME);
1409 break;
1410 case MICD_DBTIME_TWO_READINGS:
1411 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_1,
1412 ARIZONA_MICD_DBTIME_MASK, 0);
1413 break;
1414 default:
1415 break;
1416 }
1417
1418 BUILD_BUG_ON(ARRAY_SIZE(arizona_micd_levels) <
1419 ARIZONA_NUM_MICD_BUTTON_LEVELS);
1420
1421 if (arizona->pdata.num_micd_ranges) {
1422 info->micd_ranges = pdata->micd_ranges;
1423 info->num_micd_ranges = pdata->num_micd_ranges;
1424 } else {
1425 info->micd_ranges = micd_default_ranges;
1426 info->num_micd_ranges = ARRAY_SIZE(micd_default_ranges);
1427 }
1428
1429 if (arizona->pdata.num_micd_ranges > ARIZONA_MAX_MICD_RANGE) {
1430 dev_err(arizona->dev, "Too many MICD ranges: %d\n",
1431 arizona->pdata.num_micd_ranges);
1432 }
1433
1434 if (info->num_micd_ranges > 1) {
1435 for (i = 1; i < info->num_micd_ranges; i++) {
1436 if (info->micd_ranges[i - 1].max >
1437 info->micd_ranges[i].max) {
1438 dev_err(arizona->dev,
1439 "MICD ranges must be sorted\n");
1440 ret = -EINVAL;
1441 goto err_gpio;
1442 }
1443 }
1444 }
1445
1446 /* Disable all buttons by default */
1447 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_2,
1448 ARIZONA_MICD_LVL_SEL_MASK, 0x81);
1449
1450 /* Set up all the buttons the user specified */
1451 for (i = 0; i < info->num_micd_ranges; i++) {
1452 for (j = 0; j < ARIZONA_NUM_MICD_BUTTON_LEVELS; j++)
1453 if (arizona_micd_levels[j] >= info->micd_ranges[i].max)
1454 break;
1455
1456 if (j == ARIZONA_NUM_MICD_BUTTON_LEVELS) {
1457 dev_err(arizona->dev, "Unsupported MICD level %d\n",
1458 info->micd_ranges[i].max);
1459 ret = -EINVAL;
1460 goto err_gpio;
1461 }
1462
1463 dev_dbg(arizona->dev, "%d ohms for MICD threshold %d\n",
1464 arizona_micd_levels[j], i);
1465
1466 arizona_micd_set_level(arizona, i, j);
1467 input_set_capability(info->input, EV_KEY,
1468 info->micd_ranges[i].key);
1469
1470 /* Enable reporting of that range */
1471 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_2,
1472 1 << i, 1 << i);
1473 }
1474
1475 /* Set all the remaining keys to a maximum */
1476 for (; i < ARIZONA_MAX_MICD_RANGE; i++)
1477 arizona_micd_set_level(arizona, i, 0x3f);
1478
1479 /*
1480 * If we have a clamp use it, activating in conjunction with
1481 * GPIO5 if that is connected for jack detect operation.
1482 */
1483 if (info->micd_clamp) {
1484 if (arizona->pdata.jd_gpio5) {
1485 /* Put the GPIO into input mode with optional pull */
1486 val = 0xc101;
1487 if (arizona->pdata.jd_gpio5_nopull)
1488 val &= ~ARIZONA_GPN_PU;
1489
1490 regmap_write(arizona->regmap, ARIZONA_GPIO5_CTRL,
1491 val);
1492
1493 if (arizona->pdata.jd_invert)
1494 clamp_mode = ARIZONA_MICD_CLAMP_MODE_JDH_GP5H;
1495 else
1496 clamp_mode = ARIZONA_MICD_CLAMP_MODE_JDL_GP5H;
1497 } else {
1498 if (arizona->pdata.jd_invert)
1499 clamp_mode = ARIZONA_MICD_CLAMP_MODE_JDH;
1500 else
1501 clamp_mode = ARIZONA_MICD_CLAMP_MODE_JDL;
1502 }
1503
1504 regmap_update_bits(arizona->regmap,
1505 ARIZONA_MICD_CLAMP_CONTROL,
1506 ARIZONA_MICD_CLAMP_MODE_MASK, clamp_mode);
1507
1508 regmap_update_bits(arizona->regmap,
1509 ARIZONA_JACK_DETECT_DEBOUNCE,
1510 ARIZONA_MICD_CLAMP_DB,
1511 ARIZONA_MICD_CLAMP_DB);
1512 }
1513
1514 arizona_extcon_set_mode(info, 0);
1515
1516 pm_runtime_enable(&pdev->dev);
1517 pm_runtime_idle(&pdev->dev);
1518 pm_runtime_get_sync(&pdev->dev);
1519
1520 if (info->micd_clamp) {
1521 jack_irq_rise = ARIZONA_IRQ_MICD_CLAMP_RISE;
1522 jack_irq_fall = ARIZONA_IRQ_MICD_CLAMP_FALL;
1523 } else {
1524 jack_irq_rise = ARIZONA_IRQ_JD_RISE;
1525 jack_irq_fall = ARIZONA_IRQ_JD_FALL;
1526 }
1527
1528 ret = arizona_request_irq(arizona, jack_irq_rise,
1529 "JACKDET rise", arizona_jackdet, info);
1530 if (ret != 0) {
1531 dev_err(&pdev->dev, "Failed to get JACKDET rise IRQ: %d\n",
1532 ret);
1533 goto err_gpio;
1534 }
1535
1536 ret = arizona_set_irq_wake(arizona, jack_irq_rise, 1);
1537 if (ret != 0) {
1538 dev_err(&pdev->dev, "Failed to set JD rise IRQ wake: %d\n",
1539 ret);
1540 goto err_rise;
1541 }
1542
1543 ret = arizona_request_irq(arizona, jack_irq_fall,
1544 "JACKDET fall", arizona_jackdet, info);
1545 if (ret != 0) {
1546 dev_err(&pdev->dev, "Failed to get JD fall IRQ: %d\n", ret);
1547 goto err_rise_wake;
1548 }
1549
1550 ret = arizona_set_irq_wake(arizona, jack_irq_fall, 1);
1551 if (ret != 0) {
1552 dev_err(&pdev->dev, "Failed to set JD fall IRQ wake: %d\n",
1553 ret);
1554 goto err_fall;
1555 }
1556
1557 ret = arizona_request_irq(arizona, ARIZONA_IRQ_MICDET,
1558 "MICDET", arizona_micdet, info);
1559 if (ret != 0) {
1560 dev_err(&pdev->dev, "Failed to get MICDET IRQ: %d\n", ret);
1561 goto err_fall_wake;
1562 }
1563
1564 ret = arizona_request_irq(arizona, ARIZONA_IRQ_HPDET,
1565 "HPDET", arizona_hpdet_irq, info);
1566 if (ret != 0) {
1567 dev_err(&pdev->dev, "Failed to get HPDET IRQ: %d\n", ret);
1568 goto err_micdet;
1569 }
1570
1571 arizona_clk32k_enable(arizona);
1572 regmap_update_bits(arizona->regmap, ARIZONA_JACK_DETECT_DEBOUNCE,
1573 ARIZONA_JD1_DB, ARIZONA_JD1_DB);
1574 regmap_update_bits(arizona->regmap, ARIZONA_JACK_DETECT_ANALOGUE,
1575 ARIZONA_JD1_ENA, ARIZONA_JD1_ENA);
1576
1577 ret = regulator_allow_bypass(info->micvdd, true);
1578 if (ret != 0)
1579 dev_warn(arizona->dev, "Failed to set MICVDD to bypass: %d\n",
1580 ret);
1581
1582 pm_runtime_put(&pdev->dev);
1583
1584 ret = input_register_device(info->input);
1585 if (ret) {
1586 dev_err(&pdev->dev, "Can't register input device: %d\n", ret);
1587 goto err_hpdet;
1588 }
1589
1590 return 0;
1591
1592 err_hpdet:
1593 arizona_free_irq(arizona, ARIZONA_IRQ_HPDET, info);
1594 err_micdet:
1595 arizona_free_irq(arizona, ARIZONA_IRQ_MICDET, info);
1596 err_fall_wake:
1597 arizona_set_irq_wake(arizona, jack_irq_fall, 0);
1598 err_fall:
1599 arizona_free_irq(arizona, jack_irq_fall, info);
1600 err_rise_wake:
1601 arizona_set_irq_wake(arizona, jack_irq_rise, 0);
1602 err_rise:
1603 arizona_free_irq(arizona, jack_irq_rise, info);
1604 err_gpio:
1605 gpiod_put(info->micd_pol_gpio);
1606 err_register:
1607 pm_runtime_disable(&pdev->dev);
1608 return ret;
1609 }
1610
1611 static int arizona_extcon_remove(struct platform_device *pdev)
1612 {
1613 struct arizona_extcon_info *info = platform_get_drvdata(pdev);
1614 struct arizona *arizona = info->arizona;
1615 int jack_irq_rise, jack_irq_fall;
1616
1617 gpiod_put(info->micd_pol_gpio);
1618
1619 pm_runtime_disable(&pdev->dev);
1620
1621 regmap_update_bits(arizona->regmap,
1622 ARIZONA_MICD_CLAMP_CONTROL,
1623 ARIZONA_MICD_CLAMP_MODE_MASK, 0);
1624
1625 if (info->micd_clamp) {
1626 jack_irq_rise = ARIZONA_IRQ_MICD_CLAMP_RISE;
1627 jack_irq_fall = ARIZONA_IRQ_MICD_CLAMP_FALL;
1628 } else {
1629 jack_irq_rise = ARIZONA_IRQ_JD_RISE;
1630 jack_irq_fall = ARIZONA_IRQ_JD_FALL;
1631 }
1632
1633 arizona_set_irq_wake(arizona, jack_irq_rise, 0);
1634 arizona_set_irq_wake(arizona, jack_irq_fall, 0);
1635 arizona_free_irq(arizona, ARIZONA_IRQ_HPDET, info);
1636 arizona_free_irq(arizona, ARIZONA_IRQ_MICDET, info);
1637 arizona_free_irq(arizona, jack_irq_rise, info);
1638 arizona_free_irq(arizona, jack_irq_fall, info);
1639 cancel_delayed_work_sync(&info->hpdet_work);
1640 regmap_update_bits(arizona->regmap, ARIZONA_JACK_DETECT_ANALOGUE,
1641 ARIZONA_JD1_ENA, 0);
1642 arizona_clk32k_disable(arizona);
1643
1644 return 0;
1645 }
1646
1647 static struct platform_driver arizona_extcon_driver = {
1648 .driver = {
1649 .name = "arizona-extcon",
1650 },
1651 .probe = arizona_extcon_probe,
1652 .remove = arizona_extcon_remove,
1653 };
1654
1655 module_platform_driver(arizona_extcon_driver);
1656
1657 MODULE_DESCRIPTION("Arizona Extcon driver");
1658 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
1659 MODULE_LICENSE("GPL");
1660 MODULE_ALIAS("platform:extcon-arizona");
Linux kernel - Deliverables
This page took 0.085835 seconds and 4 git commands to generate.