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