2 * Retu/Vilma headset detection
4 * Copyright (C) 2006 Nokia Corporation
6 * Written by Juha Yrjölä
8 * This file is subject to the terms and conditions of the GNU General
9 * Public License. See the file "COPYING" in the main directory of this
10 * archive for more details.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #include <linux/module.h>
23 #include <linux/init.h>
24 #include <linux/kernel.h>
25 #include <linux/delay.h>
26 #include <linux/input.h>
27 #include <linux/platform_device.h>
31 #define RETU_ADC_CHANNEL_HOOKDET 0x05
33 #define RETU_HEADSET_KEY KEY_PHONE
35 #define STATE_DISABLE_DET 1
36 #define STATE_ENABLE_DET 2
39 struct platform_device *pdev;
40 struct input_dev *idev;
41 unsigned bias_enabled:1;
43 unsigned detection_enabled:1, pressed:1;
45 struct timer_list enable_timer, detect_timer;
49 static void retu_headset_set_bias(int enable)
52 retu_set_clear_reg_bits(RETU_REG_AUDTXR,
53 (1 << 0) | (1 << 1), 0);
55 retu_set_clear_reg_bits(RETU_REG_AUDTXR, 1 << 3, 0);
57 retu_set_clear_reg_bits(RETU_REG_AUDTXR, 0,
58 (1 << 0) | (1 << 1) | (1 << 3));
62 static void retu_headset_enable(struct retu_headset *hs)
67 retu_headset_set_bias(1);
70 static void retu_headset_disable(struct retu_headset *hs)
72 if (!hs->bias_enabled)
75 retu_headset_set_bias(0);
78 static void retu_headset_det_enable(struct retu_headset *hs)
80 if (hs->detection_enabled)
82 hs->detection_enabled = 1;
83 retu_set_clear_reg_bits(RETU_REG_CC1, (1 << 10) | (1 << 8), 0);
84 retu_enable_irq(RETU_INT_HOOK);
87 static void retu_headset_det_disable(struct retu_headset *hs)
89 if (!hs->detection_enabled)
91 hs->detection_enabled = 0;
92 retu_disable_irq(RETU_INT_HOOK);
93 del_timer_sync(&hs->enable_timer);
94 del_timer_sync(&hs->detect_timer);
96 input_report_key(hs->idev, RETU_HEADSET_KEY, 0);
97 retu_set_clear_reg_bits(RETU_REG_CC1, 0, (1 << 10) | (1 << 8));
100 static ssize_t retu_headset_hookdet_show(struct device *dev,
101 struct device_attribute *attr,
106 val = retu_read_adc(RETU_ADC_CHANNEL_HOOKDET);
107 return sprintf(buf, "%d\n", val);
110 static DEVICE_ATTR(hookdet, S_IRUGO, retu_headset_hookdet_show, NULL);
112 static ssize_t retu_headset_enable_show(struct device *dev,
113 struct device_attribute *attr,
116 struct retu_headset *hs = dev_get_drvdata(dev);
118 return sprintf(buf, "%u\n", hs->bias_enabled);
121 static ssize_t retu_headset_enable_store(struct device *dev,
122 struct device_attribute *attr,
123 const char *buf, size_t count)
125 struct retu_headset *hs = dev_get_drvdata(dev);
128 if (sscanf(buf, "%u", &enable) != 1)
131 retu_headset_enable(hs);
133 retu_headset_disable(hs);
137 static DEVICE_ATTR(enable, S_IRUGO | S_IWUSR | S_IWGRP,
138 retu_headset_enable_show, retu_headset_enable_store);
140 static ssize_t retu_headset_enable_det_show(struct device *dev,
141 struct device_attribute *attr,
144 struct retu_headset *hs = dev_get_drvdata(dev);
146 return sprintf(buf, "%u\n", hs->detection_enabled);
149 static ssize_t retu_headset_enable_det_store(struct device *dev,
150 struct device_attribute *attr,
151 const char *buf, size_t count)
153 struct retu_headset *hs = dev_get_drvdata(dev);
156 if (sscanf(buf, "%u", &enable) != 1)
159 retu_headset_det_enable(hs);
161 retu_headset_det_disable(hs);
165 static DEVICE_ATTR(enable_det, S_IRUGO | S_IWUSR | S_IWGRP,
166 retu_headset_enable_det_show,
167 retu_headset_enable_det_store);
169 static void retu_headset_hook_interrupt(unsigned long arg)
171 struct retu_headset *hs = (struct retu_headset *) arg;
175 retu_ack_irq(RETU_INT_HOOK);
176 spin_lock_irqsave(&hs->lock, flags);
178 /* Headset button was just pressed down. */
180 input_report_key(hs->idev, RETU_HEADSET_KEY, 1);
183 spin_unlock_irqrestore(&hs->lock, flags);
185 dev_info(&hs->pdev->dev, "button pressed\n");
186 retu_set_clear_reg_bits(RETU_REG_CC1, 0, (1 << 10) | (1 << 8));
187 mod_timer(&hs->enable_timer, jiffies + msecs_to_jiffies(50));
190 static void retu_headset_enable_timer(unsigned long arg)
192 struct retu_headset *hs = (struct retu_headset *) arg;
194 retu_set_clear_reg_bits(RETU_REG_CC1, (1 << 10) | (1 << 8), 0);
195 mod_timer(&hs->detect_timer, jiffies + msecs_to_jiffies(350));
198 static void retu_headset_detect_timer(unsigned long arg)
200 struct retu_headset *hs = (struct retu_headset *) arg;
203 spin_lock_irqsave(&hs->lock, flags);
204 BUG_ON(!hs->pressed);
205 input_report_key(hs->idev, RETU_HEADSET_KEY, 0);
207 spin_unlock_irqrestore(&hs->lock, flags);
208 dev_info(&hs->pdev->dev, "button released\n");
211 static int __init retu_headset_probe(struct platform_device *pdev)
213 struct retu_headset *hs;
216 hs = kzalloc(sizeof(*hs), GFP_KERNEL);
222 hs->idev = input_allocate_device();
223 if (hs->idev == NULL) {
227 hs->idev->name = "retu-headset";
228 hs->idev->cdev.dev = &pdev->dev;
229 hs->idev->private = hs;
230 set_bit(EV_KEY, hs->idev->evbit);
231 set_bit(RETU_HEADSET_KEY, hs->idev->keybit);
232 r = input_register_device(hs->idev);
236 r = device_create_file(&pdev->dev, &dev_attr_hookdet);
239 r = device_create_file(&pdev->dev, &dev_attr_enable);
242 r = device_create_file(&pdev->dev, &dev_attr_enable_det);
245 platform_set_drvdata(pdev, hs);
247 spin_lock_init(&hs->lock);
248 setup_timer(&hs->enable_timer, retu_headset_enable_timer,
250 setup_timer(&hs->detect_timer, retu_headset_detect_timer,
253 r = retu_request_irq(RETU_INT_HOOK, retu_headset_hook_interrupt,
254 (unsigned long) hs, "hookdet");
256 dev_err(&pdev->dev, "hookdet IRQ not available\n");
259 retu_disable_irq(RETU_INT_HOOK);
262 device_remove_file(&pdev->dev, &dev_attr_enable_det);
264 device_remove_file(&pdev->dev, &dev_attr_enable);
266 device_remove_file(&pdev->dev, &dev_attr_hookdet);
268 input_unregister_device(hs->idev);
270 input_free_device(hs->idev);
276 static int retu_headset_remove(struct platform_device *pdev)
278 struct retu_headset *hs = platform_get_drvdata(pdev);
280 device_remove_file(&pdev->dev, &dev_attr_hookdet);
281 device_remove_file(&pdev->dev, &dev_attr_enable);
282 device_remove_file(&pdev->dev, &dev_attr_enable_det);
283 retu_headset_disable(hs);
284 retu_headset_det_disable(hs);
285 retu_free_irq(RETU_INT_HOOK);
286 input_unregister_device(hs->idev);
287 input_free_device(hs->idev);
291 static int retu_headset_suspend(struct platform_device *pdev, pm_message_t mesg)
296 static int retu_headset_resume(struct platform_device *pdev)
302 static struct platform_driver retu_headset_driver = {
303 .probe = retu_headset_probe,
304 .remove = retu_headset_remove,
305 .suspend = retu_headset_suspend,
306 .resume = retu_headset_resume,
308 .name = "retu-headset",
312 static int __init retu_headset_init(void)
316 printk(KERN_INFO "Retu/Vilma headset driver initializing\n");
318 r = platform_driver_register(&retu_headset_driver);
325 static void __exit retu_headset_exit(void)
327 platform_driver_unregister(&retu_headset_driver);
330 module_init(retu_headset_init);
331 module_exit(retu_headset_exit);
333 MODULE_DESCRIPTION("Retu/Vilma headset detection");
334 MODULE_LICENSE("GPL");
335 MODULE_AUTHOR("Juha Yrjölä");