drivers/cbus/retu-headset.c

   1 /**
   2  * Retu/Vilma headset detection
   3  *
   4  * Copyright (C) 2006 Nokia Corporation
   5  *
   6  * Written by Juha Yrjölä
   7  *
   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.
  11  *
  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.
  16  *
  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
  20  */
  21
  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>
  28
  29 #include "retu.h"
  30
  31 #define RETU_ADC_CHANNEL_HOOKDET        0x05
  32
  33 #define RETU_HEADSET_KEY                KEY_PHONE
  34
  35 struct retu_headset {
  36         spinlock_t                      lock;
  37         struct mutex                    mutex;
  38         struct platform_device          *pdev;
  39         struct input_dev                *idev;
  40         unsigned                        bias_enabled;
  41         unsigned                        detection_enabled;
  42         unsigned                        pressed;
  43         struct timer_list               enable_timer;
  44         struct timer_list               detect_timer;
  45 };
  46
  47 static void retu_headset_set_bias(int enable)
  48 {
  49         if (enable) {
  50                 retu_set_clear_reg_bits(RETU_REG_AUDTXR,
  51                                         (1 << 0) | (1 << 1), 0);
  52                 msleep(2);
  53                 retu_set_clear_reg_bits(RETU_REG_AUDTXR, 1 << 3, 0);
  54         } else {
  55                 retu_set_clear_reg_bits(RETU_REG_AUDTXR, 0,
  56                                         (1 << 0) | (1 << 1) | (1 << 3));
  57         }
  58 }
  59
  60 static void retu_headset_enable(struct retu_headset *hs)
  61 {
  62         mutex_lock(&hs->mutex);
  63         if (!hs->bias_enabled) {
  64                 hs->bias_enabled = 1;
  65                 retu_headset_set_bias(1);
  66         }
  67         mutex_unlock(&hs->mutex);
  68 }
  69
  70 static void retu_headset_disable(struct retu_headset *hs)
  71 {
  72         mutex_lock(&hs->mutex);
  73         if (hs->bias_enabled) {
  74                 hs->bias_enabled = 0;
  75                 retu_headset_set_bias(0);
  76         }
  77         mutex_unlock(&hs->mutex);
  78 }
  79
  80 static void retu_headset_det_enable(struct retu_headset *hs)
  81 {
  82         mutex_lock(&hs->mutex);
  83         if (!hs->detection_enabled) {
  84                 hs->detection_enabled = 1;
  85                 retu_set_clear_reg_bits(RETU_REG_CC1, (1 << 10) | (1 << 8), 0);
  86                 retu_enable_irq(RETU_INT_HOOK);
  87         }
  88         mutex_unlock(&hs->mutex);
  89 }
  90
  91 static void retu_headset_det_disable(struct retu_headset *hs)
  92 {
  93         unsigned long flags;
  94
  95         mutex_lock(&hs->mutex);
  96         if (hs->detection_enabled) {
  97                 hs->detection_enabled = 0;
  98                 retu_disable_irq(RETU_INT_HOOK);
  99                 del_timer_sync(&hs->enable_timer);
 100                 del_timer_sync(&hs->detect_timer);
 101                 spin_lock_irqsave(&hs->lock, flags);
 102                 if (hs->pressed)
 103                         input_report_key(hs->idev, RETU_HEADSET_KEY, 0);
 104                 spin_unlock_irqrestore(&hs->lock, flags);
 105                 retu_set_clear_reg_bits(RETU_REG_CC1, 0, (1 << 10) | (1 << 8));
 106         }
 107         mutex_unlock(&hs->mutex);
 108 }
 109
 110 static ssize_t retu_headset_hookdet_show(struct device *dev,
 111                                          struct device_attribute *attr,
 112                                          char *buf)
 113 {
 114         int val;
 115
 116         val = retu_read_adc(RETU_ADC_CHANNEL_HOOKDET);
 117         return sprintf(buf, "%d\n", val);
 118 }
 119
 120 static DEVICE_ATTR(hookdet, S_IRUGO, retu_headset_hookdet_show, NULL);
 121
 122 static ssize_t retu_headset_enable_show(struct device *dev,
 123                                         struct device_attribute *attr,
 124                                         char *buf)
 125 {
 126         struct retu_headset *hs = dev_get_drvdata(dev);
 127
 128         return sprintf(buf, "%u\n", hs->bias_enabled);
 129 }
 130
 131 static ssize_t retu_headset_enable_store(struct device *dev,
 132                                          struct device_attribute *attr,
 133                                          const char *buf, size_t count)
 134 {
 135         struct retu_headset *hs = dev_get_drvdata(dev);
 136         int enable;
 137
 138         if (sscanf(buf, "%u", &enable) != 1)
 139                 return -EINVAL;
 140         if (enable)
 141                 retu_headset_enable(hs);
 142         else
 143                 retu_headset_disable(hs);
 144         return count;
 145 }
 146
 147 static DEVICE_ATTR(enable, S_IRUGO | S_IWUSR | S_IWGRP,
 148                    retu_headset_enable_show, retu_headset_enable_store);
 149
 150 static ssize_t retu_headset_enable_det_show(struct device *dev,
 151                                             struct device_attribute *attr,
 152                                             char *buf)
 153 {
 154         struct retu_headset *hs = dev_get_drvdata(dev);
 155
 156         return sprintf(buf, "%u\n", hs->detection_enabled);
 157 }
 158
 159 static ssize_t retu_headset_enable_det_store(struct device *dev,
 160                                              struct device_attribute *attr,
 161                                              const char *buf, size_t count)
 162 {
 163         struct retu_headset *hs = dev_get_drvdata(dev);
 164         int enable;
 165
 166         if (sscanf(buf, "%u", &enable) != 1)
 167                 return -EINVAL;
 168         if (enable)
 169                 retu_headset_det_enable(hs);
 170         else
 171                 retu_headset_det_disable(hs);
 172         return count;
 173 }
 174
 175 static DEVICE_ATTR(enable_det, S_IRUGO | S_IWUSR | S_IWGRP,
 176                    retu_headset_enable_det_show,
 177                    retu_headset_enable_det_store);
 178
 179 static void retu_headset_hook_interrupt(unsigned long arg)
 180 {
 181         struct retu_headset *hs = (struct retu_headset *) arg;
 182         unsigned long flags;
 183
 184         retu_ack_irq(RETU_INT_HOOK);
 185         spin_lock_irqsave(&hs->lock, flags);
 186         if (!hs->pressed) {
 187                 /* Headset button was just pressed down. */
 188                 hs->pressed = 1;
 189                 input_report_key(hs->idev, RETU_HEADSET_KEY, 1);
 190         }
 191         spin_unlock_irqrestore(&hs->lock, flags);
 192         retu_set_clear_reg_bits(RETU_REG_CC1, 0, (1 << 10) | (1 << 8));
 193         mod_timer(&hs->enable_timer, jiffies + msecs_to_jiffies(50));
 194 }
 195
 196 static void retu_headset_enable_timer(unsigned long arg)
 197 {
 198         struct retu_headset *hs = (struct retu_headset *) arg;
 199
 200         retu_set_clear_reg_bits(RETU_REG_CC1, (1 << 10) | (1 << 8), 0);
 201         mod_timer(&hs->detect_timer, jiffies + msecs_to_jiffies(350));
 202 }
 203
 204 static void retu_headset_detect_timer(unsigned long arg)
 205 {
 206         struct retu_headset *hs = (struct retu_headset *) arg;
 207         unsigned long flags;
 208
 209         spin_lock_irqsave(&hs->lock, flags);
 210         if (hs->pressed) {
 211                 hs->pressed = 0;
 212                 input_report_key(hs->idev, RETU_HEADSET_KEY, 0);
 213         }
 214         spin_unlock_irqrestore(&hs->lock, flags);
 215 }
 216
 217 static int __init retu_headset_probe(struct platform_device *pdev)
 218 {
 219         struct retu_headset *hs;
 220         int r;
 221
 222         hs = kzalloc(sizeof(*hs), GFP_KERNEL);
 223         if (hs == NULL)
 224                 return -ENOMEM;
 225
 226         hs->pdev = pdev;
 227
 228         hs->idev = input_allocate_device();
 229         if (hs->idev == NULL) {
 230                 r = -ENOMEM;
 231                 goto err1;
 232         }
 233         hs->idev->name = "retu-headset";
 234         hs->idev->dev.parent = &pdev->dev;
 235         hs->idev->private = hs;
 236         set_bit(EV_KEY, hs->idev->evbit);
 237         set_bit(RETU_HEADSET_KEY, hs->idev->keybit);
 238         r = input_register_device(hs->idev);
 239         if (r < 0)
 240                 goto err2;
 241
 242         r = device_create_file(&pdev->dev, &dev_attr_hookdet);
 243         if (r < 0)
 244                 goto err3;
 245         r = device_create_file(&pdev->dev, &dev_attr_enable);
 246         if (r < 0)
 247                 goto err4;
 248         r = device_create_file(&pdev->dev, &dev_attr_enable_det);
 249         if (r < 0)
 250                 goto err5;
 251         platform_set_drvdata(pdev, hs);
 252
 253         spin_lock_init(&hs->lock);
 254         mutex_init(&hs->mutex);
 255         setup_timer(&hs->enable_timer, retu_headset_enable_timer,
 256                     (unsigned long) hs);
 257         setup_timer(&hs->detect_timer, retu_headset_detect_timer,
 258                     (unsigned long) hs);
 259
 260         r = retu_request_irq(RETU_INT_HOOK, retu_headset_hook_interrupt,
 261                              (unsigned long) hs, "hookdet");
 262         if (r != 0) {
 263                 dev_err(&pdev->dev, "hookdet IRQ not available\n");
 264                 goto err6;
 265         }
 266         retu_disable_irq(RETU_INT_HOOK);
 267         return 0;
 268 err6:
 269         device_remove_file(&pdev->dev, &dev_attr_enable_det);
 270 err5:
 271         device_remove_file(&pdev->dev, &dev_attr_enable);
 272 err4:
 273         device_remove_file(&pdev->dev, &dev_attr_hookdet);
 274 err3:
 275         input_unregister_device(hs->idev);
 276 err2:
 277         input_free_device(hs->idev);
 278 err1:
 279         kfree(hs);
 280         return r;
 281 }
 282
 283 static int retu_headset_remove(struct platform_device *pdev)
 284 {
 285         struct retu_headset *hs = platform_get_drvdata(pdev);
 286
 287         device_remove_file(&pdev->dev, &dev_attr_hookdet);
 288         device_remove_file(&pdev->dev, &dev_attr_enable);
 289         device_remove_file(&pdev->dev, &dev_attr_enable_det);
 290         retu_headset_disable(hs);
 291         retu_headset_det_disable(hs);
 292         retu_free_irq(RETU_INT_HOOK);
 293         input_unregister_device(hs->idev);
 294         input_free_device(hs->idev);
 295         return 0;
 296 }
 297
 298 static int retu_headset_suspend(struct platform_device *pdev,
 299                                 pm_message_t mesg)
 300 {
 301         struct retu_headset *hs = platform_get_drvdata(pdev);
 302
 303         mutex_lock(&hs->mutex);
 304         if (hs->bias_enabled)
 305                 retu_headset_set_bias(0);
 306         mutex_unlock(&hs->mutex);
 307
 308         return 0;
 309 }
 310
 311 static int retu_headset_resume(struct platform_device *pdev)
 312 {
 313         struct retu_headset *hs = platform_get_drvdata(pdev);
 314
 315         mutex_lock(&hs->mutex);
 316         if (hs->bias_enabled)
 317                 retu_headset_set_bias(1);
 318         mutex_unlock(&hs->mutex);
 319
 320         return 0;
 321 }
 322
 323 static struct platform_driver retu_headset_driver = {
 324         .probe          = retu_headset_probe,
 325         .remove         = retu_headset_remove,
 326         .suspend        = retu_headset_suspend,
 327         .resume         = retu_headset_resume,
 328         .driver         = {
 329                 .name   = "retu-headset",
 330         },
 331 };
 332
 333 static int __init retu_headset_init(void)
 334 {
 335         int r;
 336
 337         printk(KERN_INFO "Retu/Vilma headset driver initializing\n");
 338
 339         r = platform_driver_register(&retu_headset_driver);
 340         if (r < 0)
 341                 return r;
 342
 343         return 0;
 344 }
 345
 346 static void __exit retu_headset_exit(void)
 347 {
 348         platform_driver_unregister(&retu_headset_driver);
 349 }
 350
 351 module_init(retu_headset_init);
 352 module_exit(retu_headset_exit);
 353
 354 MODULE_DESCRIPTION("Retu/Vilma headset detection");
 355 MODULE_LICENSE("GPL");
 356 MODULE_AUTHOR("Juha Yrjölä");