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