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


a1ab0a56b798da5686cd04c7726eb9d7682c72a7
[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 case 2:
481 if (!(val & ARIZONA_HP_DONE_B)) {
482 dev_err(arizona->dev, "HPDET did not complete: %x\n",
483 val);
484 return -EAGAIN;
485 }
486
487 val &= ARIZONA_HP_LVL_B_MASK;
488 /* Convert to ohms, the value is in 0.5 ohm increments */
489 val /= 2;
490
491 regmap_read(arizona->regmap, ARIZONA_HEADPHONE_DETECT_1,
492 &range);
493 range = (range & ARIZONA_HP_IMPEDANCE_RANGE_MASK)
494 >> ARIZONA_HP_IMPEDANCE_RANGE_SHIFT;
495
496 /* Skip up a range, or report? */
497 if (range < ARRAY_SIZE(arizona_hpdet_c_ranges) - 1 &&
498 (val >= arizona_hpdet_c_ranges[range].max)) {
499 range++;
500 dev_dbg(arizona->dev, "Moving to HPDET range %d-%d\n",
501 arizona_hpdet_c_ranges[range].min,
502 arizona_hpdet_c_ranges[range].max);
503 regmap_update_bits(arizona->regmap,
504 ARIZONA_HEADPHONE_DETECT_1,
505 ARIZONA_HP_IMPEDANCE_RANGE_MASK,
506 range <<
507 ARIZONA_HP_IMPEDANCE_RANGE_SHIFT);
508 return -EAGAIN;
509 }
510
511 if (range && (val < arizona_hpdet_c_ranges[range].min)) {
512 dev_dbg(arizona->dev, "Reporting range boundary %d\n",
513 arizona_hpdet_c_ranges[range].min);
514 val = arizona_hpdet_c_ranges[range].min;
515 }
516 break;
517
518 default:
519 dev_warn(arizona->dev, "Unknown HPDET IP revision %d\n",
520 info->hpdet_ip_version);
521 return -EINVAL;
522 }
523
524 dev_dbg(arizona->dev, "HP impedance %d ohms\n", val);
525 return val;
526 }
527
528 static int arizona_hpdet_do_id(struct arizona_extcon_info *info, int *reading,
529 bool *mic)
530 {
531 struct arizona *arizona = info->arizona;
532 int id_gpio = arizona->pdata.hpdet_id_gpio;
533
534 /*
535 * If we're using HPDET for accessory identification we need
536 * to take multiple measurements, step through them in sequence.
537 */
538 if (arizona->pdata.hpdet_acc_id) {
539 info->hpdet_res[info->num_hpdet_res++] = *reading;
540
541 /* Only check the mic directly if we didn't already ID it */
542 if (id_gpio && info->num_hpdet_res == 1) {
543 dev_dbg(arizona->dev, "Measuring mic\n");
544
545 regmap_update_bits(arizona->regmap,
546 ARIZONA_ACCESSORY_DETECT_MODE_1,
547 ARIZONA_ACCDET_MODE_MASK |
548 ARIZONA_ACCDET_SRC,
549 ARIZONA_ACCDET_MODE_HPR |
550 info->micd_modes[0].src);
551
552 gpio_set_value_cansleep(id_gpio, 1);
553
554 regmap_update_bits(arizona->regmap,
555 ARIZONA_HEADPHONE_DETECT_1,
556 ARIZONA_HP_POLL, ARIZONA_HP_POLL);
557 return -EAGAIN;
558 }
559
560 /* OK, got both. Now, compare... */
561 dev_dbg(arizona->dev, "HPDET measured %d %d\n",
562 info->hpdet_res[0], info->hpdet_res[1]);
563
564 /* Take the headphone impedance for the main report */
565 *reading = info->hpdet_res[0];
566
567 /* Sometimes we get false readings due to slow insert */
568 if (*reading >= ARIZONA_HPDET_MAX && !info->hpdet_retried) {
569 dev_dbg(arizona->dev, "Retrying high impedance\n");
570 info->num_hpdet_res = 0;
571 info->hpdet_retried = true;
572 arizona_start_hpdet_acc_id(info);
573 pm_runtime_put(info->dev);
574 return -EAGAIN;
575 }
576
577 /*
578 * If we measure the mic as high impedance
579 */
580 if (!id_gpio || info->hpdet_res[1] > 50) {
581 dev_dbg(arizona->dev, "Detected mic\n");
582 *mic = true;
583 info->detecting = true;
584 } else {
585 dev_dbg(arizona->dev, "Detected headphone\n");
586 }
587
588 /* Make sure everything is reset back to the real polarity */
589 regmap_update_bits(arizona->regmap,
590 ARIZONA_ACCESSORY_DETECT_MODE_1,
591 ARIZONA_ACCDET_SRC,
592 info->micd_modes[0].src);
593 }
594
595 return 0;
596 }
597
598 static irqreturn_t arizona_hpdet_irq(int irq, void *data)
599 {
600 struct arizona_extcon_info *info = data;
601 struct arizona *arizona = info->arizona;
602 int id_gpio = arizona->pdata.hpdet_id_gpio;
603 unsigned int report = EXTCON_HEADPHONE;
604 int ret, reading;
605 bool mic = false;
606
607 mutex_lock(&info->lock);
608
609 /* If we got a spurious IRQ for some reason then ignore it */
610 if (!info->hpdet_active) {
611 dev_warn(arizona->dev, "Spurious HPDET IRQ\n");
612 mutex_unlock(&info->lock);
613 return IRQ_NONE;
614 }
615
616 /* If the cable was removed while measuring ignore the result */
617 ret = extcon_get_cable_state_(info->edev, EXTCON_MECHANICAL);
618 if (ret < 0) {
619 dev_err(arizona->dev, "Failed to check cable state: %d\n",
620 ret);
621 goto out;
622 } else if (!ret) {
623 dev_dbg(arizona->dev, "Ignoring HPDET for removed cable\n");
624 goto done;
625 }
626
627 ret = arizona_hpdet_read(info);
628 if (ret == -EAGAIN)
629 goto out;
630 else if (ret < 0)
631 goto done;
632 reading = ret;
633
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,
638 0);
639
640 ret = arizona_hpdet_do_id(info, &reading, &mic);
641 if (ret == -EAGAIN)
642 goto out;
643 else if (ret < 0)
644 goto done;
645
646 /* Report high impedence cables as line outputs */
647 if (reading >= 5000)
648 report = EXTCON_LINE_OUT;
649 else
650 report = EXTCON_HEADPHONE;
651
652 ret = extcon_set_cable_state_(info->edev, report, true);
653 if (ret != 0)
654 dev_err(arizona->dev, "Failed to report HP/line: %d\n",
655 ret);
656
657 done:
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,
662 0);
663
664 arizona_extcon_hp_clamp(info, false);
665
666 if (id_gpio)
667 gpio_set_value_cansleep(id_gpio, 0);
668
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);
673
674 /* If we have a mic then reenable MICDET */
675 if (mic || info->mic)
676 arizona_start_mic(info);
677
678 if (info->hpdet_active) {
679 pm_runtime_put_autosuspend(info->dev);
680 info->hpdet_active = false;
681 }
682
683 info->hpdet_done = true;
684
685 out:
686 mutex_unlock(&info->lock);
687
688 return IRQ_HANDLED;
689 }
690
691 static void arizona_identify_headphone(struct arizona_extcon_info *info)
692 {
693 struct arizona *arizona = info->arizona;
694 int ret;
695
696 if (info->hpdet_done)
697 return;
698
699 dev_dbg(arizona->dev, "Starting HPDET\n");
700
701 /* Make sure we keep the device enabled during the measurement */
702 pm_runtime_get(info->dev);
703
704 info->hpdet_active = true;
705
706 if (info->mic)
707 arizona_stop_mic(info);
708
709 arizona_extcon_hp_clamp(info, true);
710
711 ret = regmap_update_bits(arizona->regmap,
712 ARIZONA_ACCESSORY_DETECT_MODE_1,
713 ARIZONA_ACCDET_MODE_MASK,
714 arizona->pdata.hpdet_channel);
715 if (ret != 0) {
716 dev_err(arizona->dev, "Failed to set HPDET mode: %d\n", ret);
717 goto err;
718 }
719
720 ret = regmap_update_bits(arizona->regmap, ARIZONA_HEADPHONE_DETECT_1,
721 ARIZONA_HP_POLL, ARIZONA_HP_POLL);
722 if (ret != 0) {
723 dev_err(arizona->dev, "Can't start HPDETL measurement: %d\n",
724 ret);
725 goto err;
726 }
727
728 return;
729
730 err:
731 regmap_update_bits(arizona->regmap, ARIZONA_ACCESSORY_DETECT_MODE_1,
732 ARIZONA_ACCDET_MODE_MASK, ARIZONA_ACCDET_MODE_MIC);
733
734 /* Just report headphone */
735 ret = extcon_set_cable_state_(info->edev, EXTCON_HEADPHONE, true);
736 if (ret != 0)
737 dev_err(arizona->dev, "Failed to report headphone: %d\n", ret);
738
739 if (info->mic)
740 arizona_start_mic(info);
741
742 info->hpdet_active = false;
743 }
744
745 static void arizona_start_hpdet_acc_id(struct arizona_extcon_info *info)
746 {
747 struct arizona *arizona = info->arizona;
748 int hp_reading = 32;
749 bool mic;
750 int ret;
751
752 dev_dbg(arizona->dev, "Starting identification via HPDET\n");
753
754 /* Make sure we keep the device enabled during the measurement */
755 pm_runtime_get_sync(info->dev);
756
757 info->hpdet_active = true;
758
759 arizona_extcon_hp_clamp(info, true);
760
761 ret = regmap_update_bits(arizona->regmap,
762 ARIZONA_ACCESSORY_DETECT_MODE_1,
763 ARIZONA_ACCDET_SRC | ARIZONA_ACCDET_MODE_MASK,
764 info->micd_modes[0].src |
765 arizona->pdata.hpdet_channel);
766 if (ret != 0) {
767 dev_err(arizona->dev, "Failed to set HPDET mode: %d\n", ret);
768 goto err;
769 }
770
771 if (arizona->pdata.hpdet_acc_id_line) {
772 ret = regmap_update_bits(arizona->regmap,
773 ARIZONA_HEADPHONE_DETECT_1,
774 ARIZONA_HP_POLL, ARIZONA_HP_POLL);
775 if (ret != 0) {
776 dev_err(arizona->dev,
777 "Can't start HPDETL measurement: %d\n",
778 ret);
779 goto err;
780 }
781 } else {
782 arizona_hpdet_do_id(info, &hp_reading, &mic);
783 }
784
785 return;
786
787 err:
788 regmap_update_bits(arizona->regmap, ARIZONA_ACCESSORY_DETECT_MODE_1,
789 ARIZONA_ACCDET_MODE_MASK, ARIZONA_ACCDET_MODE_MIC);
790
791 /* Just report headphone */
792 ret = extcon_set_cable_state_(info->edev, EXTCON_HEADPHONE, true);
793 if (ret != 0)
794 dev_err(arizona->dev, "Failed to report headphone: %d\n", ret);
795
796 info->hpdet_active = false;
797 }
798
799 static void arizona_micd_timeout_work(struct work_struct *work)
800 {
801 struct arizona_extcon_info *info = container_of(work,
802 struct arizona_extcon_info,
803 micd_timeout_work.work);
804
805 mutex_lock(&info->lock);
806
807 dev_dbg(info->arizona->dev, "MICD timed out, reporting HP\n");
808
809 info->detecting = false;
810
811 arizona_identify_headphone(info);
812
813 arizona_stop_mic(info);
814
815 mutex_unlock(&info->lock);
816 }
817
818 static void arizona_micd_detect(struct work_struct *work)
819 {
820 struct arizona_extcon_info *info = container_of(work,
821 struct arizona_extcon_info,
822 micd_detect_work.work);
823 struct arizona *arizona = info->arizona;
824 unsigned int val = 0, lvl;
825 int ret, i, key;
826
827 cancel_delayed_work_sync(&info->micd_timeout_work);
828
829 mutex_lock(&info->lock);
830
831 /* If the cable was removed while measuring ignore the result */
832 ret = extcon_get_cable_state_(info->edev, EXTCON_MECHANICAL);
833 if (ret < 0) {
834 dev_err(arizona->dev, "Failed to check cable state: %d\n",
835 ret);
836 mutex_unlock(&info->lock);
837 return;
838 } else if (!ret) {
839 dev_dbg(arizona->dev, "Ignoring MICDET for removed cable\n");
840 mutex_unlock(&info->lock);
841 return;
842 }
843
844 if (info->detecting && arizona->pdata.micd_software_compare) {
845 /* Must disable MICD before we read the ADCVAL */
846 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_1,
847 ARIZONA_MICD_ENA, 0);
848 ret = regmap_read(arizona->regmap, ARIZONA_MIC_DETECT_4, &val);
849 if (ret != 0) {
850 dev_err(arizona->dev,
851 "Failed to read MICDET_ADCVAL: %d\n",
852 ret);
853 mutex_unlock(&info->lock);
854 return;
855 }
856
857 dev_dbg(arizona->dev, "MICDET_ADCVAL: %x\n", val);
858
859 val &= ARIZONA_MICDET_ADCVAL_MASK;
860 if (val < ARRAY_SIZE(arizona_micd_levels))
861 val = arizona_micd_levels[val];
862 else
863 val = INT_MAX;
864
865 if (val <= QUICK_HEADPHONE_MAX_OHM)
866 val = ARIZONA_MICD_STS | ARIZONA_MICD_LVL_0;
867 else if (val <= MICROPHONE_MIN_OHM)
868 val = ARIZONA_MICD_STS | ARIZONA_MICD_LVL_1;
869 else if (val <= MICROPHONE_MAX_OHM)
870 val = ARIZONA_MICD_STS | ARIZONA_MICD_LVL_8;
871 else
872 val = ARIZONA_MICD_LVL_8;
873 }
874
875 for (i = 0; i < 10 && !(val & MICD_LVL_0_TO_8); i++) {
876 ret = regmap_read(arizona->regmap, ARIZONA_MIC_DETECT_3, &val);
877 if (ret != 0) {
878 dev_err(arizona->dev,
879 "Failed to read MICDET: %d\n", ret);
880 mutex_unlock(&info->lock);
881 return;
882 }
883
884 dev_dbg(arizona->dev, "MICDET: %x\n", val);
885
886 if (!(val & ARIZONA_MICD_VALID)) {
887 dev_warn(arizona->dev,
888 "Microphone detection state invalid\n");
889 mutex_unlock(&info->lock);
890 return;
891 }
892 }
893
894 if (i == 10 && !(val & MICD_LVL_0_TO_8)) {
895 dev_err(arizona->dev, "Failed to get valid MICDET value\n");
896 mutex_unlock(&info->lock);
897 return;
898 }
899
900 /* Due to jack detect this should never happen */
901 if (!(val & ARIZONA_MICD_STS)) {
902 dev_warn(arizona->dev, "Detected open circuit\n");
903 info->mic = false;
904 arizona_stop_mic(info);
905 info->detecting = false;
906 arizona_identify_headphone(info);
907 goto handled;
908 }
909
910 /* If we got a high impedence we should have a headset, report it. */
911 if (info->detecting && (val & ARIZONA_MICD_LVL_8)) {
912 info->mic = true;
913 info->detecting = false;
914
915 arizona_identify_headphone(info);
916
917 ret = extcon_set_cable_state_(info->edev,
918 EXTCON_MICROPHONE, true);
919 if (ret != 0)
920 dev_err(arizona->dev, "Headset report failed: %d\n",
921 ret);
922
923 /* Don't need to regulate for button detection */
924 ret = regulator_allow_bypass(info->micvdd, true);
925 if (ret != 0) {
926 dev_err(arizona->dev, "Failed to bypass MICVDD: %d\n",
927 ret);
928 }
929
930 goto handled;
931 }
932
933 /* If we detected a lower impedence during initial startup
934 * then we probably have the wrong polarity, flip it. Don't
935 * do this for the lowest impedences to speed up detection of
936 * plain headphones. If both polarities report a low
937 * impedence then give up and report headphones.
938 */
939 if (info->detecting && (val & MICD_LVL_1_TO_7)) {
940 if (info->jack_flips >= info->micd_num_modes * 10) {
941 dev_dbg(arizona->dev, "Detected HP/line\n");
942
943 info->detecting = false;
944
945 arizona_identify_headphone(info);
946
947 arizona_stop_mic(info);
948 } else {
949 info->micd_mode++;
950 if (info->micd_mode == info->micd_num_modes)
951 info->micd_mode = 0;
952 arizona_extcon_set_mode(info, info->micd_mode);
953
954 info->jack_flips++;
955 }
956
957 goto handled;
958 }
959
960 /*
961 * If we're still detecting and we detect a short then we've
962 * got a headphone. Otherwise it's a button press.
963 */
964 if (val & MICD_LVL_0_TO_7) {
965 if (info->mic) {
966 dev_dbg(arizona->dev, "Mic button detected\n");
967
968 lvl = val & ARIZONA_MICD_LVL_MASK;
969 lvl >>= ARIZONA_MICD_LVL_SHIFT;
970
971 for (i = 0; i < info->num_micd_ranges; i++)
972 input_report_key(info->input,
973 info->micd_ranges[i].key, 0);
974
975 WARN_ON(!lvl);
976 WARN_ON(ffs(lvl) - 1 >= info->num_micd_ranges);
977 if (lvl && ffs(lvl) - 1 < info->num_micd_ranges) {
978 key = info->micd_ranges[ffs(lvl) - 1].key;
979 input_report_key(info->input, key, 1);
980 input_sync(info->input);
981 }
982
983 } else if (info->detecting) {
984 dev_dbg(arizona->dev, "Headphone detected\n");
985 info->detecting = false;
986 arizona_stop_mic(info);
987
988 arizona_identify_headphone(info);
989 } else {
990 dev_warn(arizona->dev, "Button with no mic: %x\n",
991 val);
992 }
993 } else {
994 dev_dbg(arizona->dev, "Mic button released\n");
995 for (i = 0; i < info->num_micd_ranges; i++)
996 input_report_key(info->input,
997 info->micd_ranges[i].key, 0);
998 input_sync(info->input);
999 arizona_extcon_pulse_micbias(info);
1000 }
1001
1002 handled:
1003 if (info->detecting) {
1004 if (arizona->pdata.micd_software_compare)
1005 regmap_update_bits(arizona->regmap,
1006 ARIZONA_MIC_DETECT_1,
1007 ARIZONA_MICD_ENA,
1008 ARIZONA_MICD_ENA);
1009
1010 queue_delayed_work(system_power_efficient_wq,
1011 &info->micd_timeout_work,
1012 msecs_to_jiffies(info->micd_timeout));
1013 }
1014
1015 pm_runtime_mark_last_busy(info->dev);
1016 mutex_unlock(&info->lock);
1017 }
1018
1019 static irqreturn_t arizona_micdet(int irq, void *data)
1020 {
1021 struct arizona_extcon_info *info = data;
1022 struct arizona *arizona = info->arizona;
1023 int debounce = arizona->pdata.micd_detect_debounce;
1024
1025 cancel_delayed_work_sync(&info->micd_detect_work);
1026 cancel_delayed_work_sync(&info->micd_timeout_work);
1027
1028 mutex_lock(&info->lock);
1029 if (!info->detecting)
1030 debounce = 0;
1031 mutex_unlock(&info->lock);
1032
1033 if (debounce)
1034 queue_delayed_work(system_power_efficient_wq,
1035 &info->micd_detect_work,
1036 msecs_to_jiffies(debounce));
1037 else
1038 arizona_micd_detect(&info->micd_detect_work.work);
1039
1040 return IRQ_HANDLED;
1041 }
1042
1043 static void arizona_hpdet_work(struct work_struct *work)
1044 {
1045 struct arizona_extcon_info *info = container_of(work,
1046 struct arizona_extcon_info,
1047 hpdet_work.work);
1048
1049 mutex_lock(&info->lock);
1050 arizona_start_hpdet_acc_id(info);
1051 mutex_unlock(&info->lock);
1052 }
1053
1054 static irqreturn_t arizona_jackdet(int irq, void *data)
1055 {
1056 struct arizona_extcon_info *info = data;
1057 struct arizona *arizona = info->arizona;
1058 unsigned int val, present, mask;
1059 bool cancelled_hp, cancelled_mic;
1060 int ret, i;
1061
1062 cancelled_hp = cancel_delayed_work_sync(&info->hpdet_work);
1063 cancelled_mic = cancel_delayed_work_sync(&info->micd_timeout_work);
1064
1065 pm_runtime_get_sync(info->dev);
1066
1067 mutex_lock(&info->lock);
1068
1069 if (info->micd_clamp) {
1070 mask = ARIZONA_MICD_CLAMP_STS;
1071 present = 0;
1072 } else {
1073 mask = ARIZONA_JD1_STS;
1074 if (arizona->pdata.jd_invert)
1075 present = 0;
1076 else
1077 present = ARIZONA_JD1_STS;
1078 }
1079
1080 ret = regmap_read(arizona->regmap, ARIZONA_AOD_IRQ_RAW_STATUS, &val);
1081 if (ret != 0) {
1082 dev_err(arizona->dev, "Failed to read jackdet status: %d\n",
1083 ret);
1084 mutex_unlock(&info->lock);
1085 pm_runtime_put_autosuspend(info->dev);
1086 return IRQ_NONE;
1087 }
1088
1089 val &= mask;
1090 if (val == info->last_jackdet) {
1091 dev_dbg(arizona->dev, "Suppressing duplicate JACKDET\n");
1092 if (cancelled_hp)
1093 queue_delayed_work(system_power_efficient_wq,
1094 &info->hpdet_work,
1095 msecs_to_jiffies(HPDET_DEBOUNCE));
1096
1097 if (cancelled_mic) {
1098 int micd_timeout = info->micd_timeout;
1099
1100 queue_delayed_work(system_power_efficient_wq,
1101 &info->micd_timeout_work,
1102 msecs_to_jiffies(micd_timeout));
1103 }
1104
1105 goto out;
1106 }
1107 info->last_jackdet = val;
1108
1109 if (info->last_jackdet == present) {
1110 dev_dbg(arizona->dev, "Detected jack\n");
1111 ret = extcon_set_cable_state_(info->edev,
1112 EXTCON_MECHANICAL, true);
1113
1114 if (ret != 0)
1115 dev_err(arizona->dev, "Mechanical report failed: %d\n",
1116 ret);
1117
1118 if (!arizona->pdata.hpdet_acc_id) {
1119 info->detecting = true;
1120 info->mic = false;
1121 info->jack_flips = 0;
1122
1123 arizona_start_mic(info);
1124 } else {
1125 queue_delayed_work(system_power_efficient_wq,
1126 &info->hpdet_work,
1127 msecs_to_jiffies(HPDET_DEBOUNCE));
1128 }
1129
1130 if (info->micd_clamp || !arizona->pdata.jd_invert)
1131 regmap_update_bits(arizona->regmap,
1132 ARIZONA_JACK_DETECT_DEBOUNCE,
1133 ARIZONA_MICD_CLAMP_DB |
1134 ARIZONA_JD1_DB, 0);
1135 } else {
1136 dev_dbg(arizona->dev, "Detected jack removal\n");
1137
1138 arizona_stop_mic(info);
1139
1140 info->num_hpdet_res = 0;
1141 for (i = 0; i < ARRAY_SIZE(info->hpdet_res); i++)
1142 info->hpdet_res[i] = 0;
1143 info->mic = false;
1144 info->hpdet_done = false;
1145 info->hpdet_retried = false;
1146
1147 for (i = 0; i < info->num_micd_ranges; i++)
1148 input_report_key(info->input,
1149 info->micd_ranges[i].key, 0);
1150 input_sync(info->input);
1151
1152 ret = extcon_update_state(info->edev, 0xffffffff, 0);
1153 if (ret != 0)
1154 dev_err(arizona->dev, "Removal report failed: %d\n",
1155 ret);
1156
1157 regmap_update_bits(arizona->regmap,
1158 ARIZONA_JACK_DETECT_DEBOUNCE,
1159 ARIZONA_MICD_CLAMP_DB | ARIZONA_JD1_DB,
1160 ARIZONA_MICD_CLAMP_DB | ARIZONA_JD1_DB);
1161 }
1162
1163 if (arizona->pdata.micd_timeout)
1164 info->micd_timeout = arizona->pdata.micd_timeout;
1165 else
1166 info->micd_timeout = DEFAULT_MICD_TIMEOUT;
1167
1168 out:
1169 /* Clear trig_sts to make sure DCVDD is not forced up */
1170 regmap_write(arizona->regmap, ARIZONA_AOD_WKUP_AND_TRIG,
1171 ARIZONA_MICD_CLAMP_FALL_TRIG_STS |
1172 ARIZONA_MICD_CLAMP_RISE_TRIG_STS |
1173 ARIZONA_JD1_FALL_TRIG_STS |
1174 ARIZONA_JD1_RISE_TRIG_STS);
1175
1176 mutex_unlock(&info->lock);
1177
1178 pm_runtime_mark_last_busy(info->dev);
1179 pm_runtime_put_autosuspend(info->dev);
1180
1181 return IRQ_HANDLED;
1182 }
1183
1184 /* Map a level onto a slot in the register bank */
1185 static void arizona_micd_set_level(struct arizona *arizona, int index,
1186 unsigned int level)
1187 {
1188 int reg;
1189 unsigned int mask;
1190
1191 reg = ARIZONA_MIC_DETECT_LEVEL_4 - (index / 2);
1192
1193 if (!(index % 2)) {
1194 mask = 0x3f00;
1195 level <<= 8;
1196 } else {
1197 mask = 0x3f;
1198 }
1199
1200 /* Program the level itself */
1201 regmap_update_bits(arizona->regmap, reg, mask, level);
1202 }
1203
1204 static int arizona_extcon_device_get_pdata(struct arizona *arizona)
1205 {
1206 struct arizona_pdata *pdata = &arizona->pdata;
1207 unsigned int val = ARIZONA_ACCDET_MODE_HPL;
1208
1209 device_property_read_u32(arizona->dev, "wlf,hpdet-channel", &val);
1210 switch (val) {
1211 case ARIZONA_ACCDET_MODE_HPL:
1212 case ARIZONA_ACCDET_MODE_HPR:
1213 pdata->hpdet_channel = val;
1214 break;
1215 default:
1216 dev_err(arizona->dev,
1217 "Wrong wlf,hpdet-channel DT value %d\n", val);
1218 pdata->hpdet_channel = ARIZONA_ACCDET_MODE_HPL;
1219 }
1220
1221 device_property_read_u32(arizona->dev, "wlf,micd-detect-debounce",
1222 &pdata->micd_detect_debounce);
1223
1224 device_property_read_u32(arizona->dev, "wlf,micd-bias-start-time",
1225 &pdata->micd_bias_start_time);
1226
1227 device_property_read_u32(arizona->dev, "wlf,micd-rate",
1228 &pdata->micd_rate);
1229
1230 device_property_read_u32(arizona->dev, "wlf,micd-dbtime",
1231 &pdata->micd_dbtime);
1232
1233 device_property_read_u32(arizona->dev, "wlf,micd-timeout",
1234 &pdata->micd_timeout);
1235
1236 pdata->micd_force_micbias = device_property_read_bool(arizona->dev,
1237 "wlf,micd-force-micbias");
1238
1239 return 0;
1240 }
1241
1242 static int arizona_extcon_probe(struct platform_device *pdev)
1243 {
1244 struct arizona *arizona = dev_get_drvdata(pdev->dev.parent);
1245 struct arizona_pdata *pdata = &arizona->pdata;
1246 struct arizona_extcon_info *info;
1247 unsigned int val;
1248 unsigned int clamp_mode;
1249 int jack_irq_fall, jack_irq_rise;
1250 int ret, mode, i, j;
1251
1252 if (!arizona->dapm || !arizona->dapm->card)
1253 return -EPROBE_DEFER;
1254
1255 info = devm_kzalloc(&pdev->dev, sizeof(*info), GFP_KERNEL);
1256 if (!info)
1257 return -ENOMEM;
1258
1259 if (!dev_get_platdata(arizona->dev))
1260 arizona_extcon_device_get_pdata(arizona);
1261
1262 info->micvdd = devm_regulator_get(&pdev->dev, "MICVDD");
1263 if (IS_ERR(info->micvdd)) {
1264 ret = PTR_ERR(info->micvdd);
1265 dev_err(arizona->dev, "Failed to get MICVDD: %d\n", ret);
1266 return ret;
1267 }
1268
1269 mutex_init(&info->lock);
1270 info->arizona = arizona;
1271 info->dev = &pdev->dev;
1272 info->last_jackdet = ~(ARIZONA_MICD_CLAMP_STS | ARIZONA_JD1_STS);
1273 INIT_DELAYED_WORK(&info->hpdet_work, arizona_hpdet_work);
1274 INIT_DELAYED_WORK(&info->micd_detect_work, arizona_micd_detect);
1275 INIT_DELAYED_WORK(&info->micd_timeout_work, arizona_micd_timeout_work);
1276 platform_set_drvdata(pdev, info);
1277
1278 switch (arizona->type) {
1279 case WM5102:
1280 switch (arizona->rev) {
1281 case 0:
1282 info->micd_reva = true;
1283 break;
1284 default:
1285 info->micd_clamp = true;
1286 info->hpdet_ip_version = 1;
1287 break;
1288 }
1289 break;
1290 case WM5110:
1291 case WM8280:
1292 switch (arizona->rev) {
1293 case 0 ... 2:
1294 break;
1295 default:
1296 info->micd_clamp = true;
1297 info->hpdet_ip_version = 2;
1298 break;
1299 }
1300 break;
1301 case WM8998:
1302 case WM1814:
1303 info->micd_clamp = true;
1304 info->hpdet_ip_version = 2;
1305 break;
1306 default:
1307 break;
1308 }
1309
1310 info->edev = devm_extcon_dev_allocate(&pdev->dev, arizona_cable);
1311 if (IS_ERR(info->edev)) {
1312 dev_err(&pdev->dev, "failed to allocate extcon device\n");
1313 return -ENOMEM;
1314 }
1315
1316 ret = devm_extcon_dev_register(&pdev->dev, info->edev);
1317 if (ret < 0) {
1318 dev_err(arizona->dev, "extcon_dev_register() failed: %d\n",
1319 ret);
1320 return ret;
1321 }
1322
1323 info->input = devm_input_allocate_device(&pdev->dev);
1324 if (!info->input) {
1325 dev_err(arizona->dev, "Can't allocate input dev\n");
1326 ret = -ENOMEM;
1327 goto err_register;
1328 }
1329
1330 info->input->name = "Headset";
1331 info->input->phys = "arizona/extcon";
1332
1333 if (pdata->num_micd_configs) {
1334 info->micd_modes = pdata->micd_configs;
1335 info->micd_num_modes = pdata->num_micd_configs;
1336 } else {
1337 info->micd_modes = micd_default_modes;
1338 info->micd_num_modes = ARRAY_SIZE(micd_default_modes);
1339 }
1340
1341 if (arizona->pdata.gpsw > 0)
1342 regmap_update_bits(arizona->regmap, ARIZONA_GP_SWITCH_1,
1343 ARIZONA_SW1_MODE_MASK, arizona->pdata.gpsw);
1344
1345 if (arizona->pdata.micd_pol_gpio > 0) {
1346 if (info->micd_modes[0].gpio)
1347 mode = GPIOF_OUT_INIT_HIGH;
1348 else
1349 mode = GPIOF_OUT_INIT_LOW;
1350
1351 ret = devm_gpio_request_one(&pdev->dev,
1352 arizona->pdata.micd_pol_gpio,
1353 mode,
1354 "MICD polarity");
1355 if (ret != 0) {
1356 dev_err(arizona->dev, "Failed to request GPIO%d: %d\n",
1357 arizona->pdata.micd_pol_gpio, ret);
1358 goto err_register;
1359 }
1360 } else {
1361 if (info->micd_modes[0].gpio)
1362 mode = GPIOD_OUT_HIGH;
1363 else
1364 mode = GPIOD_OUT_LOW;
1365
1366 /* We can't use devm here because we need to do the get
1367 * against the MFD device, as that is where the of_node
1368 * will reside, but if we devm against that the GPIO
1369 * will not be freed if the extcon driver is unloaded.
1370 */
1371 info->micd_pol_gpio = gpiod_get_optional(arizona->dev,
1372 "wlf,micd-pol",
1373 GPIOD_OUT_LOW);
1374 if (IS_ERR(info->micd_pol_gpio)) {
1375 ret = PTR_ERR(info->micd_pol_gpio);
1376 dev_err(arizona->dev,
1377 "Failed to get microphone polarity GPIO: %d\n",
1378 ret);
1379 goto err_register;
1380 }
1381 }
1382
1383 if (arizona->pdata.hpdet_id_gpio > 0) {
1384 ret = devm_gpio_request_one(&pdev->dev,
1385 arizona->pdata.hpdet_id_gpio,
1386 GPIOF_OUT_INIT_LOW,
1387 "HPDET");
1388 if (ret != 0) {
1389 dev_err(arizona->dev, "Failed to request GPIO%d: %d\n",
1390 arizona->pdata.hpdet_id_gpio, ret);
1391 goto err_gpio;
1392 }
1393 }
1394
1395 if (arizona->pdata.micd_bias_start_time)
1396 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_1,
1397 ARIZONA_MICD_BIAS_STARTTIME_MASK,
1398 arizona->pdata.micd_bias_start_time
1399 << ARIZONA_MICD_BIAS_STARTTIME_SHIFT);
1400
1401 if (arizona->pdata.micd_rate)
1402 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_1,
1403 ARIZONA_MICD_RATE_MASK,
1404 arizona->pdata.micd_rate
1405 << ARIZONA_MICD_RATE_SHIFT);
1406
1407 switch (arizona->pdata.micd_dbtime) {
1408 case MICD_DBTIME_FOUR_READINGS:
1409 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_1,
1410 ARIZONA_MICD_DBTIME_MASK,
1411 ARIZONA_MICD_DBTIME);
1412 break;
1413 case MICD_DBTIME_TWO_READINGS:
1414 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_1,
1415 ARIZONA_MICD_DBTIME_MASK, 0);
1416 break;
1417 default:
1418 break;
1419 }
1420
1421 BUILD_BUG_ON(ARRAY_SIZE(arizona_micd_levels) <
1422 ARIZONA_NUM_MICD_BUTTON_LEVELS);
1423
1424 if (arizona->pdata.num_micd_ranges) {
1425 info->micd_ranges = pdata->micd_ranges;
1426 info->num_micd_ranges = pdata->num_micd_ranges;
1427 } else {
1428 info->micd_ranges = micd_default_ranges;
1429 info->num_micd_ranges = ARRAY_SIZE(micd_default_ranges);
1430 }
1431
1432 if (arizona->pdata.num_micd_ranges > ARIZONA_MAX_MICD_RANGE) {
1433 dev_err(arizona->dev, "Too many MICD ranges: %d\n",
1434 arizona->pdata.num_micd_ranges);
1435 }
1436
1437 if (info->num_micd_ranges > 1) {
1438 for (i = 1; i < info->num_micd_ranges; i++) {
1439 if (info->micd_ranges[i - 1].max >
1440 info->micd_ranges[i].max) {
1441 dev_err(arizona->dev,
1442 "MICD ranges must be sorted\n");
1443 ret = -EINVAL;
1444 goto err_gpio;
1445 }
1446 }
1447 }
1448
1449 /* Disable all buttons by default */
1450 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_2,
1451 ARIZONA_MICD_LVL_SEL_MASK, 0x81);
1452
1453 /* Set up all the buttons the user specified */
1454 for (i = 0; i < info->num_micd_ranges; i++) {
1455 for (j = 0; j < ARIZONA_NUM_MICD_BUTTON_LEVELS; j++)
1456 if (arizona_micd_levels[j] >= info->micd_ranges[i].max)
1457 break;
1458
1459 if (j == ARIZONA_NUM_MICD_BUTTON_LEVELS) {
1460 dev_err(arizona->dev, "Unsupported MICD level %d\n",
1461 info->micd_ranges[i].max);
1462 ret = -EINVAL;
1463 goto err_gpio;
1464 }
1465
1466 dev_dbg(arizona->dev, "%d ohms for MICD threshold %d\n",
1467 arizona_micd_levels[j], i);
1468
1469 arizona_micd_set_level(arizona, i, j);
1470 input_set_capability(info->input, EV_KEY,
1471 info->micd_ranges[i].key);
1472
1473 /* Enable reporting of that range */
1474 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_2,
1475 1 << i, 1 << i);
1476 }
1477
1478 /* Set all the remaining keys to a maximum */
1479 for (; i < ARIZONA_MAX_MICD_RANGE; i++)
1480 arizona_micd_set_level(arizona, i, 0x3f);
1481
1482 /*
1483 * If we have a clamp use it, activating in conjunction with
1484 * GPIO5 if that is connected for jack detect operation.
1485 */
1486 if (info->micd_clamp) {
1487 if (arizona->pdata.jd_gpio5) {
1488 /* Put the GPIO into input mode with optional pull */
1489 val = 0xc101;
1490 if (arizona->pdata.jd_gpio5_nopull)
1491 val &= ~ARIZONA_GPN_PU;
1492
1493 regmap_write(arizona->regmap, ARIZONA_GPIO5_CTRL,
1494 val);
1495
1496 if (arizona->pdata.jd_invert)
1497 clamp_mode = ARIZONA_MICD_CLAMP_MODE_JDH_GP5H;
1498 else
1499 clamp_mode = ARIZONA_MICD_CLAMP_MODE_JDL_GP5H;
1500 } else {
1501 if (arizona->pdata.jd_invert)
1502 clamp_mode = ARIZONA_MICD_CLAMP_MODE_JDH;
1503 else
1504 clamp_mode = ARIZONA_MICD_CLAMP_MODE_JDL;
1505 }
1506
1507 regmap_update_bits(arizona->regmap,
1508 ARIZONA_MICD_CLAMP_CONTROL,
1509 ARIZONA_MICD_CLAMP_MODE_MASK, clamp_mode);
1510
1511 regmap_update_bits(arizona->regmap,
1512 ARIZONA_JACK_DETECT_DEBOUNCE,
1513 ARIZONA_MICD_CLAMP_DB,
1514 ARIZONA_MICD_CLAMP_DB);
1515 }
1516
1517 arizona_extcon_set_mode(info, 0);
1518
1519 pm_runtime_enable(&pdev->dev);
1520 pm_runtime_idle(&pdev->dev);
1521 pm_runtime_get_sync(&pdev->dev);
1522
1523 if (info->micd_clamp) {
1524 jack_irq_rise = ARIZONA_IRQ_MICD_CLAMP_RISE;
1525 jack_irq_fall = ARIZONA_IRQ_MICD_CLAMP_FALL;
1526 } else {
1527 jack_irq_rise = ARIZONA_IRQ_JD_RISE;
1528 jack_irq_fall = ARIZONA_IRQ_JD_FALL;
1529 }
1530
1531 ret = arizona_request_irq(arizona, jack_irq_rise,
1532 "JACKDET rise", arizona_jackdet, info);
1533 if (ret != 0) {
1534 dev_err(&pdev->dev, "Failed to get JACKDET rise IRQ: %d\n",
1535 ret);
1536 goto err_gpio;
1537 }
1538
1539 ret = arizona_set_irq_wake(arizona, jack_irq_rise, 1);
1540 if (ret != 0) {
1541 dev_err(&pdev->dev, "Failed to set JD rise IRQ wake: %d\n",
1542 ret);
1543 goto err_rise;
1544 }
1545
1546 ret = arizona_request_irq(arizona, jack_irq_fall,
1547 "JACKDET fall", arizona_jackdet, info);
1548 if (ret != 0) {
1549 dev_err(&pdev->dev, "Failed to get JD fall IRQ: %d\n", ret);
1550 goto err_rise_wake;
1551 }
1552
1553 ret = arizona_set_irq_wake(arizona, jack_irq_fall, 1);
1554 if (ret != 0) {
1555 dev_err(&pdev->dev, "Failed to set JD fall IRQ wake: %d\n",
1556 ret);
1557 goto err_fall;
1558 }
1559
1560 ret = arizona_request_irq(arizona, ARIZONA_IRQ_MICDET,
1561 "MICDET", arizona_micdet, info);
1562 if (ret != 0) {
1563 dev_err(&pdev->dev, "Failed to get MICDET IRQ: %d\n", ret);
1564 goto err_fall_wake;
1565 }
1566
1567 ret = arizona_request_irq(arizona, ARIZONA_IRQ_HPDET,
1568 "HPDET", arizona_hpdet_irq, info);
1569 if (ret != 0) {
1570 dev_err(&pdev->dev, "Failed to get HPDET IRQ: %d\n", ret);
1571 goto err_micdet;
1572 }
1573
1574 arizona_clk32k_enable(arizona);
1575 regmap_update_bits(arizona->regmap, ARIZONA_JACK_DETECT_DEBOUNCE,
1576 ARIZONA_JD1_DB, ARIZONA_JD1_DB);
1577 regmap_update_bits(arizona->regmap, ARIZONA_JACK_DETECT_ANALOGUE,
1578 ARIZONA_JD1_ENA, ARIZONA_JD1_ENA);
1579
1580 ret = regulator_allow_bypass(info->micvdd, true);
1581 if (ret != 0)
1582 dev_warn(arizona->dev, "Failed to set MICVDD to bypass: %d\n",
1583 ret);
1584
1585 pm_runtime_put(&pdev->dev);
1586
1587 ret = input_register_device(info->input);
1588 if (ret) {
1589 dev_err(&pdev->dev, "Can't register input device: %d\n", ret);
1590 goto err_hpdet;
1591 }
1592
1593 return 0;
1594
1595 err_hpdet:
1596 arizona_free_irq(arizona, ARIZONA_IRQ_HPDET, info);
1597 err_micdet:
1598 arizona_free_irq(arizona, ARIZONA_IRQ_MICDET, info);
1599 err_fall_wake:
1600 arizona_set_irq_wake(arizona, jack_irq_fall, 0);
1601 err_fall:
1602 arizona_free_irq(arizona, jack_irq_fall, info);
1603 err_rise_wake:
1604 arizona_set_irq_wake(arizona, jack_irq_rise, 0);
1605 err_rise:
1606 arizona_free_irq(arizona, jack_irq_rise, info);
1607 err_gpio:
1608 gpiod_put(info->micd_pol_gpio);
1609 err_register:
1610 pm_runtime_disable(&pdev->dev);
1611 return ret;
1612 }
1613
1614 static int arizona_extcon_remove(struct platform_device *pdev)
1615 {
1616 struct arizona_extcon_info *info = platform_get_drvdata(pdev);
1617 struct arizona *arizona = info->arizona;
1618 int jack_irq_rise, jack_irq_fall;
1619
1620 gpiod_put(info->micd_pol_gpio);
1621
1622 pm_runtime_disable(&pdev->dev);
1623
1624 regmap_update_bits(arizona->regmap,
1625 ARIZONA_MICD_CLAMP_CONTROL,
1626 ARIZONA_MICD_CLAMP_MODE_MASK, 0);
1627
1628 if (info->micd_clamp) {
1629 jack_irq_rise = ARIZONA_IRQ_MICD_CLAMP_RISE;
1630 jack_irq_fall = ARIZONA_IRQ_MICD_CLAMP_FALL;
1631 } else {
1632 jack_irq_rise = ARIZONA_IRQ_JD_RISE;
1633 jack_irq_fall = ARIZONA_IRQ_JD_FALL;
1634 }
1635
1636 arizona_set_irq_wake(arizona, jack_irq_rise, 0);
1637 arizona_set_irq_wake(arizona, jack_irq_fall, 0);
1638 arizona_free_irq(arizona, ARIZONA_IRQ_HPDET, info);
1639 arizona_free_irq(arizona, ARIZONA_IRQ_MICDET, info);
1640 arizona_free_irq(arizona, jack_irq_rise, info);
1641 arizona_free_irq(arizona, jack_irq_fall, info);
1642 cancel_delayed_work_sync(&info->hpdet_work);
1643 regmap_update_bits(arizona->regmap, ARIZONA_JACK_DETECT_ANALOGUE,
1644 ARIZONA_JD1_ENA, 0);
1645 arizona_clk32k_disable(arizona);
1646
1647 return 0;
1648 }
1649
1650 static struct platform_driver arizona_extcon_driver = {
1651 .driver = {
1652 .name = "arizona-extcon",
1653 },
1654 .probe = arizona_extcon_probe,
1655 .remove = arizona_extcon_remove,
1656 };
1657
1658 module_platform_driver(arizona_extcon_driver);
1659
1660 MODULE_DESCRIPTION("Arizona Extcon driver");
1661 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
1662 MODULE_LICENSE("GPL");
1663 MODULE_ALIAS("platform:extcon-arizona");
Linux kernel - Deliverables
This page took 0.074075 seconds and 4 git commands to generate.