2 * extcon-arizona.c - Extcon driver Wolfson Arizona devices
4 * Copyright (C) 2012 Wolfson Microelectronics plc
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
17 #include <linux/kernel.h>
18 #include <linux/module.h>
19 #include <linux/i2c.h>
20 #include <linux/slab.h>
21 #include <linux/interrupt.h>
22 #include <linux/err.h>
23 #include <linux/gpio.h>
24 #include <linux/platform_device.h>
25 #include <linux/pm_runtime.h>
26 #include <linux/regulator/consumer.h>
27 #include <linux/extcon.h>
29 #include <linux/mfd/arizona/core.h>
30 #include <linux/mfd/arizona/pdata.h>
31 #include <linux/mfd/arizona/registers.h>
33 struct arizona_extcon_info {
35 struct arizona *arizona;
37 struct regulator *micvdd;
40 const struct arizona_micd_config *micd_modes;
49 struct extcon_dev edev;
52 static const struct arizona_micd_config micd_default_modes[] = {
53 { ARIZONA_ACCDET_SRC, 1 << ARIZONA_MICD_BIAS_SRC_SHIFT, 0 },
54 { 0, 2 << ARIZONA_MICD_BIAS_SRC_SHIFT, 1 },
57 #define ARIZONA_CABLE_MECHANICAL 0
58 #define ARIZONA_CABLE_MICROPHONE 1
59 #define ARIZONA_CABLE_HEADPHONE 2
61 static const char *arizona_cable[] = {
68 static void arizona_extcon_set_mode(struct arizona_extcon_info *info, int mode)
70 struct arizona *arizona = info->arizona;
72 gpio_set_value_cansleep(arizona->pdata.micd_pol_gpio,
73 info->micd_modes[mode].gpio);
74 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_1,
75 ARIZONA_MICD_BIAS_SRC_MASK,
76 info->micd_modes[mode].bias);
77 regmap_update_bits(arizona->regmap, ARIZONA_ACCESSORY_DETECT_MODE_1,
78 ARIZONA_ACCDET_SRC, info->micd_modes[mode].src);
80 info->micd_mode = mode;
82 dev_dbg(arizona->dev, "Set jack polarity to %d\n", mode);
85 static void arizona_start_mic(struct arizona_extcon_info *info)
87 struct arizona *arizona = info->arizona;
91 info->detecting = true;
95 /* Microphone detection can't use idle mode */
96 pm_runtime_get(info->dev);
98 ret = regulator_enable(info->micvdd);
100 dev_err(arizona->dev, "Failed to enable MICVDD: %d\n",
104 if (info->micd_reva) {
105 regmap_write(arizona->regmap, 0x80, 0x3);
106 regmap_write(arizona->regmap, 0x294, 0);
107 regmap_write(arizona->regmap, 0x80, 0x0);
110 regmap_update_bits_check(arizona->regmap, ARIZONA_MIC_DETECT_1,
111 ARIZONA_MICD_ENA, ARIZONA_MICD_ENA,
114 regulator_disable(info->micvdd);
115 pm_runtime_put_autosuspend(info->dev);
119 static void arizona_stop_mic(struct arizona_extcon_info *info)
121 struct arizona *arizona = info->arizona;
124 regmap_update_bits_check(arizona->regmap, ARIZONA_MIC_DETECT_1,
128 if (info->micd_reva) {
129 regmap_write(arizona->regmap, 0x80, 0x3);
130 regmap_write(arizona->regmap, 0x294, 2);
131 regmap_write(arizona->regmap, 0x80, 0x0);
135 regulator_disable(info->micvdd);
136 pm_runtime_put_autosuspend(info->dev);
140 static irqreturn_t arizona_micdet(int irq, void *data)
142 struct arizona_extcon_info *info = data;
143 struct arizona *arizona = info->arizona;
147 mutex_lock(&info->lock);
149 ret = regmap_read(arizona->regmap, ARIZONA_MIC_DETECT_3, &val);
151 dev_err(arizona->dev, "Failed to read MICDET: %d\n", ret);
155 dev_dbg(arizona->dev, "MICDET: %x\n", val);
157 if (!(val & ARIZONA_MICD_VALID)) {
158 dev_warn(arizona->dev, "Microphone detection state invalid\n");
159 mutex_unlock(&info->lock);
163 /* Due to jack detect this should never happen */
164 if (!(val & ARIZONA_MICD_STS)) {
165 dev_warn(arizona->dev, "Detected open circuit\n");
166 info->detecting = false;
170 /* If we got a high impedence we should have a headset, report it. */
171 if (info->detecting && (val & 0x400)) {
172 ret = extcon_update_state(&info->edev,
173 1 << ARIZONA_CABLE_MICROPHONE |
174 1 << ARIZONA_CABLE_HEADPHONE,
175 1 << ARIZONA_CABLE_MICROPHONE |
176 1 << ARIZONA_CABLE_HEADPHONE);
179 dev_err(arizona->dev, "Headset report failed: %d\n",
183 info->detecting = false;
187 /* If we detected a lower impedence during initial startup
188 * then we probably have the wrong polarity, flip it. Don't
189 * do this for the lowest impedences to speed up detection of
190 * plain headphones. If both polarities report a low
191 * impedence then give up and report headphones.
193 if (info->detecting && (val & 0x3f8)) {
196 if (info->jack_flips >= info->micd_num_modes) {
197 dev_dbg(arizona->dev, "Detected headphone\n");
198 info->detecting = false;
199 ret = extcon_set_cable_state_(&info->edev,
200 ARIZONA_CABLE_HEADPHONE,
203 dev_err(arizona->dev,
204 "Headphone report failed: %d\n",
208 if (info->micd_mode == info->micd_num_modes)
210 arizona_extcon_set_mode(info, info->micd_mode);
219 * If we're still detecting and we detect a short then we've
220 * got a headphone. Otherwise it's a button press, the
221 * button reporting is stubbed out for now.
225 dev_dbg(arizona->dev, "Mic button detected\n");
227 } else if (info->detecting) {
228 dev_dbg(arizona->dev, "Headphone detected\n");
229 info->detecting = false;
230 arizona_stop_mic(info);
232 ret = extcon_set_cable_state_(&info->edev,
233 ARIZONA_CABLE_HEADPHONE,
236 dev_err(arizona->dev,
237 "Headphone report failed: %d\n",
240 dev_warn(arizona->dev, "Button with no mic: %x\n",
244 dev_dbg(arizona->dev, "Mic button released\n");
248 pm_runtime_mark_last_busy(info->dev);
249 mutex_unlock(&info->lock);
254 static irqreturn_t arizona_jackdet(int irq, void *data)
256 struct arizona_extcon_info *info = data;
257 struct arizona *arizona = info->arizona;
261 pm_runtime_get_sync(info->dev);
263 mutex_lock(&info->lock);
265 ret = regmap_read(arizona->regmap, ARIZONA_AOD_IRQ_RAW_STATUS, &val);
267 dev_err(arizona->dev, "Failed to read jackdet status: %d\n",
269 mutex_unlock(&info->lock);
270 pm_runtime_put_autosuspend(info->dev);
274 if (val & ARIZONA_JD1_STS) {
275 dev_dbg(arizona->dev, "Detected jack\n");
276 ret = extcon_set_cable_state_(&info->edev,
277 ARIZONA_CABLE_MECHANICAL, true);
280 dev_err(arizona->dev, "Mechanical report failed: %d\n",
283 arizona_start_mic(info);
285 dev_dbg(arizona->dev, "Detected jack removal\n");
287 arizona_stop_mic(info);
289 ret = extcon_update_state(&info->edev, 0xffffffff, 0);
291 dev_err(arizona->dev, "Removal report failed: %d\n",
295 mutex_unlock(&info->lock);
297 pm_runtime_mark_last_busy(info->dev);
298 pm_runtime_put_autosuspend(info->dev);
303 static int __devinit arizona_extcon_probe(struct platform_device *pdev)
305 struct arizona *arizona = dev_get_drvdata(pdev->dev.parent);
306 struct arizona_pdata *pdata;
307 struct arizona_extcon_info *info;
310 pdata = dev_get_platdata(arizona->dev);
312 info = devm_kzalloc(&pdev->dev, sizeof(*info), GFP_KERNEL);
314 dev_err(&pdev->dev, "failed to allocate memory\n");
319 info->micvdd = devm_regulator_get(arizona->dev, "MICVDD");
320 if (IS_ERR(info->micvdd)) {
321 ret = PTR_ERR(info->micvdd);
322 dev_err(arizona->dev, "Failed to get MICVDD: %d\n", ret);
326 mutex_init(&info->lock);
327 info->arizona = arizona;
328 info->dev = &pdev->dev;
329 info->detecting = true;
330 platform_set_drvdata(pdev, info);
332 switch (arizona->type) {
334 switch (arizona->rev) {
336 info->micd_reva = true;
346 info->edev.name = "Headset Jack";
347 info->edev.supported_cable = arizona_cable;
349 ret = extcon_dev_register(&info->edev, arizona->dev);
351 dev_err(arizona->dev, "extcon_dev_regster() failed: %d\n",
356 if (pdata->num_micd_configs) {
357 info->micd_modes = pdata->micd_configs;
358 info->micd_num_modes = pdata->num_micd_configs;
360 info->micd_modes = micd_default_modes;
361 info->micd_num_modes = ARRAY_SIZE(micd_default_modes);
364 if (arizona->pdata.micd_pol_gpio > 0) {
365 if (info->micd_modes[0].gpio)
366 mode = GPIOF_OUT_INIT_HIGH;
368 mode = GPIOF_OUT_INIT_LOW;
370 ret = devm_gpio_request_one(&pdev->dev,
371 arizona->pdata.micd_pol_gpio,
375 dev_err(arizona->dev, "Failed to request GPIO%d: %d\n",
376 arizona->pdata.micd_pol_gpio, ret);
381 arizona_extcon_set_mode(info, 0);
383 pm_runtime_enable(&pdev->dev);
384 pm_runtime_idle(&pdev->dev);
385 pm_runtime_get_sync(&pdev->dev);
387 ret = arizona_request_irq(arizona, ARIZONA_IRQ_JD_RISE,
388 "JACKDET rise", arizona_jackdet, info);
390 dev_err(&pdev->dev, "Failed to get JACKDET rise IRQ: %d\n",
395 ret = arizona_set_irq_wake(arizona, ARIZONA_IRQ_JD_RISE, 1);
397 dev_err(&pdev->dev, "Failed to set JD rise IRQ wake: %d\n",
402 ret = arizona_request_irq(arizona, ARIZONA_IRQ_JD_FALL,
403 "JACKDET fall", arizona_jackdet, info);
405 dev_err(&pdev->dev, "Failed to get JD fall IRQ: %d\n", ret);
409 ret = arizona_set_irq_wake(arizona, ARIZONA_IRQ_JD_FALL, 1);
411 dev_err(&pdev->dev, "Failed to set JD fall IRQ wake: %d\n",
416 ret = arizona_request_irq(arizona, ARIZONA_IRQ_MICDET,
417 "MICDET", arizona_micdet, info);
419 dev_err(&pdev->dev, "Failed to get MICDET IRQ: %d\n", ret);
423 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_1,
424 ARIZONA_MICD_BIAS_STARTTIME_MASK |
425 ARIZONA_MICD_RATE_MASK,
426 7 << ARIZONA_MICD_BIAS_STARTTIME_SHIFT |
427 8 << ARIZONA_MICD_RATE_SHIFT);
429 arizona_clk32k_enable(arizona);
430 regmap_update_bits(arizona->regmap, ARIZONA_JACK_DETECT_DEBOUNCE,
431 ARIZONA_JD1_DB, ARIZONA_JD1_DB);
432 regmap_update_bits(arizona->regmap, ARIZONA_JACK_DETECT_ANALOGUE,
433 ARIZONA_JD1_ENA, ARIZONA_JD1_ENA);
435 pm_runtime_put(&pdev->dev);
440 arizona_set_irq_wake(arizona, ARIZONA_IRQ_JD_FALL, 0);
442 arizona_free_irq(arizona, ARIZONA_IRQ_JD_FALL, info);
444 arizona_set_irq_wake(arizona, ARIZONA_IRQ_JD_RISE, 0);
446 arizona_free_irq(arizona, ARIZONA_IRQ_JD_RISE, info);
448 pm_runtime_disable(&pdev->dev);
449 extcon_dev_unregister(&info->edev);
454 static int __devexit arizona_extcon_remove(struct platform_device *pdev)
456 struct arizona_extcon_info *info = platform_get_drvdata(pdev);
457 struct arizona *arizona = info->arizona;
459 pm_runtime_disable(&pdev->dev);
461 arizona_set_irq_wake(arizona, ARIZONA_IRQ_JD_RISE, 0);
462 arizona_set_irq_wake(arizona, ARIZONA_IRQ_JD_FALL, 0);
463 arizona_free_irq(arizona, ARIZONA_IRQ_MICDET, info);
464 arizona_free_irq(arizona, ARIZONA_IRQ_JD_RISE, info);
465 arizona_free_irq(arizona, ARIZONA_IRQ_JD_FALL, info);
466 regmap_update_bits(arizona->regmap, ARIZONA_JACK_DETECT_ANALOGUE,
468 arizona_clk32k_disable(arizona);
469 extcon_dev_unregister(&info->edev);
474 static struct platform_driver arizona_extcon_driver = {
476 .name = "arizona-extcon",
477 .owner = THIS_MODULE,
479 .probe = arizona_extcon_probe,
480 .remove = __devexit_p(arizona_extcon_remove),
483 module_platform_driver(arizona_extcon_driver);
485 MODULE_DESCRIPTION("Arizona Extcon driver");
486 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
487 MODULE_LICENSE("GPL");
488 MODULE_ALIAS("platform:extcon-arizona");