drivers/input/keyboard/rk2818_adckey.c

   1 /*
   2  * linux/drivers/input/keyboard/rk28_adckey.c
   3  *
   4  * This driver program support to AD key which use for rk28 chip
   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 version 2 as
   8  * published by the Free Software Foundation.
   9  */
  10
  11
  12 #include <linux/kernel.h>
  13 #include <linux/module.h>
  14 #include <linux/init.h>
  15 #include <linux/interrupt.h>
  16 #include <linux/input.h>
  17 #include <linux/device.h>
  18 #include <linux/platform_device.h>
  19 #include <linux/clk.h>
  20 #include <linux/err.h>
  21 #include <linux/delay.h>
  22
  23 #include <asm/mach-types.h>
  24 #include <asm/mach/arch.h>
  25 #include <asm/mach/map.h>
  26 #include <mach/gpio.h>
  27 #include <mach/adc.h>
  28 #include <mach/board.h>
  29
  30 extern struct adc_key_data rk2818_adc_key;
  31
  32 #if 0
  33 #define DBG(x...)   printk(x)
  34 #else
  35 #define DBG(x...)
  36 #endif
  37
  38 #define KEY_PHYS_NAME   "rk2818_adckey/input0"
  39
  40 volatile int gADSampleTimes = 0;
  41 volatile int gStatePlaykey = 0;
  42 volatile unsigned int gCodeCount = 0;
  43 volatile unsigned int gThisCode = 0;
  44 volatile unsigned int gLastCode = 0;
  45 volatile unsigned int gFlagShortPlay = 0;
  46 volatile unsigned int gFlagLongPlay = 0;
  47 volatile unsigned int gPlayCount = 0;
  48
  49 //key code tab
  50 struct rk28_adckey
  51 {
  52         struct semaphore        lock;
  53         struct rk28_adc_client  *client;
  54         struct input_dev *input_dev;
  55         struct timer_list timer;
  56         unsigned char * keycodes;
  57         void __iomem *mmio_base;
  58 };
  59
  60 struct rk28_adckey *pRk28AdcKey;
  61
  62 unsigned int rk28_get_keycode(unsigned int advalue,pADC_keyst ptab)
  63 {
  64         while(ptab->adc_value != 0)
  65         {
  66                 if((advalue > ptab->adc_value - rk2818_adc_key.adc_drift) && (advalue < ptab->adc_value + rk2818_adc_key.adc_drift))
  67                     return ptab->adc_keycode;
  68                 ptab++;
  69         }
  70
  71         return 0;
  72 }
  73
  74 static irqreturn_t rk28_playkey_irq(int irq, void *handle)
  75 {
  76
  77         //gFlagPlay = 1;
  78         //DBG("Enter::%s,LINE=%d,KEY_PLAY_SHORT_PRESS=%d\n",__FUNCTION__,__LINE__,KEY_PLAY_SHORT_PRESS);
  79
  80         return IRQ_HANDLED;
  81 }
  82
  83 void rk28_send_wakeup_key( void )
  84 {
  85     input_report_key(pRk28AdcKey->input_dev,KEY_WAKEUP,1);
  86     input_sync(pRk28AdcKey->input_dev);
  87     input_report_key(pRk28AdcKey->input_dev,KEY_WAKEUP,0);
  88     input_sync(pRk28AdcKey->input_dev);
  89         DBG("Wake up system\n");
  90 }
  91
  92 static int rk28_adckey_open(struct input_dev *dev)
  93 {
  94         //struct rk28_adckey *adckey = input_get_drvdata(dev);
  95
  96         return 0;
  97 }
  98
  99 static void rk28_adckey_close(struct input_dev *dev)
 100 {
 101         //struct rk28_adckey *adckey = input_get_drvdata(dev);
 102 //
 103 }
 104
 105 #ifdef CONFIG_PM
 106 static int rk28_adckey_suspend(struct platform_device *pdev, pm_message_t state)
 107 {
 108         //struct rk28_adckey *adckey = platform_get_drvdata(pdev);
 109
 110         return 0;
 111 }
 112
 113 static int rk28_adckey_resume(struct platform_device *pdev)
 114 {
 115         //struct rk28_adckey *adckey = platform_get_drvdata(pdev);
 116         //struct input_dev *input_dev = adckey->input_dev;
 117 #if 0
 118         mutex_lock(&input_dev->mutex);
 119
 120         mutex_unlock(&input_dev->mutex);
 121 #endif
 122         return 0;
 123 }
 124 #else
 125 #define rk28_adckey_suspend     NULL
 126 #define rk28_adckey_resume      NULL
 127 #endif
 128 static void rk28_adkeyscan_timer(unsigned long data)
 129 {
 130         unsigned int adcvalue = -1, code;
 131
 132         pRk28AdcKey->timer.expires  = jiffies + msecs_to_jiffies(10);
 133         add_timer(&pRk28AdcKey->timer);
 134
 135         /*handle long press of play key*/
 136         if(gpio_get_value(rk2818_adc_key.pin_playon) == rk2818_adc_key.playon_level)
 137         {
 138                 if(++gPlayCount > 20000)
 139                         gPlayCount = 101;
 140                 if((2 == gPlayCount) && (0 == gFlagShortPlay))
 141                 {
 142                         gFlagShortPlay = 1;
 143                 }
 144                 else if((100 == gPlayCount) && (0 == gFlagLongPlay))
 145                 {
 146                         gFlagLongPlay = 1;
 147                         gFlagShortPlay = 0;
 148                         input_report_key(pRk28AdcKey->input_dev,KEY_PLAY_LONG_PRESS,1);
 149                         input_sync(pRk28AdcKey->input_dev);
 150                         DBG("Enter::%s,LINE=%d,KEY_PLAY_LONG_PRESS=%d,1\n",__FUNCTION__,__LINE__,KEY_PLAY_LONG_PRESS);
 151                 }
 152         }
 153         else
 154         {
 155                 if (1 == gFlagShortPlay)
 156                 {
 157                         input_report_key(pRk28AdcKey->input_dev,ENDCALL,1);
 158                     input_sync(pRk28AdcKey->input_dev);
 159                     input_report_key(pRk28AdcKey->input_dev,ENDCALL,0);
 160                     input_sync(pRk28AdcKey->input_dev);
 161                         DBG("Wake up system,ENDCALL=%d\n",ENDCALL);
 162
 163                         input_report_key(pRk28AdcKey->input_dev,KEY_PLAY_SHORT_PRESS,1);
 164                         input_sync(pRk28AdcKey->input_dev);
 165                         DBG("Enter::%s,LINE=%d,KEY_PLAY_SHORT_PRESS=%d,1\n",__FUNCTION__,__LINE__,KEY_PLAY_SHORT_PRESS);
 166                         input_report_key(pRk28AdcKey->input_dev,KEY_PLAY_SHORT_PRESS,0);
 167                         input_sync(pRk28AdcKey->input_dev);
 168                         DBG("Enter::%s,LINE=%d,KEY_PLAY_SHORT_PRESS=%d,0\n",__FUNCTION__,__LINE__,KEY_PLAY_SHORT_PRESS);
 169                 }
 170                 else if(1 == gFlagLongPlay)
 171                 {
 172                         input_report_key(pRk28AdcKey->input_dev,KEY_PLAY_LONG_PRESS,0);
 173                         input_sync(pRk28AdcKey->input_dev);
 174                         DBG("Enter::%s,LINE=%d,KEY_PLAY_LONG_PRESS=%d,0\n",__FUNCTION__,__LINE__,KEY_PLAY_LONG_PRESS);
 175                 }
 176
 177                 gFlagShortPlay = 0;
 178                 gFlagLongPlay = 0;
 179                 gPlayCount = 0;
 180         }
 181
 182         /*handle long press of adc key*/
 183         if (gADSampleTimes < 4)
 184         {
 185                 gADSampleTimes ++;
 186                 return;
 187         }
 188
 189         gADSampleTimes = 0;
 190
 191         //rk28_read_adc(pRk28AdcKey);
 192         adcvalue = gAdcValue[rk2818_adc_key.adc_chn];
 193         //DBG("=========== adcvalue=0x%x ===========\n",adcvalue);
 194
 195         if((adcvalue > rk2818_adc_key.adc_empty) || (adcvalue < rk2818_adc_key.adc_invalid))
 196         {
 197             //DBG("adcvalue invalid !!!\n");
 198                 if(gLastCode == 0) {
 199                         return;
 200                 }
 201                 else
 202                 {
 203                         if(gLastCode == KEYMENU)
 204                         {
 205                                 if(gCodeCount > 31)
 206                                 {
 207                                         input_report_key(pRk28AdcKey->input_dev,ENDCALL,0);
 208                                         input_sync(pRk28AdcKey->input_dev);
 209                                         DBG("Enter::%s,LINE=%d,code=%d,ENDCALL,0\n",__FUNCTION__,__LINE__,gLastCode);
 210                                 }
 211                                 input_report_key(pRk28AdcKey->input_dev,gLastCode,1);
 212                                 input_sync(pRk28AdcKey->input_dev);
 213                                 DBG("Enter::%s,LINE=%d,code=%d,1\n",__FUNCTION__,__LINE__,gLastCode);
 214                         }
 215
 216                         input_report_key(pRk28AdcKey->input_dev,gLastCode,0);
 217                         input_sync(pRk28AdcKey->input_dev);
 218                         DBG("Enter::%s,LINE=%d,code=%d,0\n",__FUNCTION__,__LINE__,gLastCode);
 219                         gLastCode = 0;
 220                         gCodeCount = 0;
 221                         return;
 222                 }
 223         }
 224
 225         //DBG("adcvalue=0x%x\n",adcvalue);
 226
 227         code=rk28_get_keycode(adcvalue,rk2818_adc_key.adc_key_table);
 228         if(code)
 229         {
 230                 if(code == KEYMENU)
 231                 {
 232                         gLastCode = code;
 233                         if(++gCodeCount == 31)//40ms * 30 =1.2s
 234                         {
 235                                 input_report_key(pRk28AdcKey->input_dev,ENDCALL,1);
 236                         input_sync(pRk28AdcKey->input_dev);
 237                                 DBG("Enter::%s,LINE=%d,code=%d,ENDCALL,1\n",__FUNCTION__,__LINE__,code);
 238                         }
 239                 }
 240                 else
 241                 {
 242                         gLastCode = code;
 243                         if(++gCodeCount == 2)//only one event once one touch
 244                         {
 245                                 input_report_key(pRk28AdcKey->input_dev,code,1);
 246                                 input_sync(pRk28AdcKey->input_dev);
 247                                 DBG("Enter::%s,LINE=%d,code=%d,1\n",__FUNCTION__,__LINE__,code);
 248                         }
 249                 }
 250
 251         }
 252
 253 }
 254
 255
 256 static int __devinit rk28_adckey_probe(struct platform_device *pdev)
 257 {
 258         struct rk28_adckey *adckey;
 259         struct input_dev *input_dev;
 260         int error,i;
 261
 262         adckey = kzalloc(sizeof(struct rk28_adckey), GFP_KERNEL);
 263         if (adckey == NULL) {
 264                 dev_err(&pdev->dev, "failed to allocate driver data\n");
 265                 return -ENOMEM;
 266         }
 267
 268         //memcpy(adckey->keycodes, gInitKeyCode, sizeof(adckey->keycodes));
 269         adckey->keycodes = rk2818_adc_key.initKeyCode;
 270
 271         /* Create and register the input driver. */
 272         input_dev = input_allocate_device();
 273         if (!input_dev) {
 274                 dev_err(&pdev->dev, "failed to allocate input device\n");
 275                 error = -ENOMEM;
 276                 goto failed_free;
 277         }
 278
 279         input_dev->name = pdev->name;
 280         //input_dev->id.bustype = BUS_HOST;
 281         input_dev->open = rk28_adckey_open;
 282         input_dev->close = rk28_adckey_close;
 283         input_dev->dev.parent = &pdev->dev;
 284         input_dev->phys = KEY_PHYS_NAME;
 285         input_dev->id.vendor = 0x0001;
 286         input_dev->id.product = 0x0001;
 287         input_dev->id.version = 0x0100;
 288
 289         input_dev->keycode = adckey->keycodes;
 290         input_dev->keycodesize = sizeof(unsigned char);
 291         input_dev->keycodemax = rk2818_adc_key.adc_key_cnt;
 292         for (i = 0; i < rk2818_adc_key.adc_key_cnt; i++)
 293                 set_bit(rk2818_adc_key.initKeyCode[i], input_dev->keybit);
 294         clear_bit(0, input_dev->keybit);
 295
 296         adckey->input_dev = input_dev;
 297         input_set_drvdata(input_dev, adckey);
 298
 299         input_dev->evbit[0] = BIT_MASK(EV_KEY);
 300
 301 //      rk28_adckey_build_keycode(adckey);
 302         platform_set_drvdata(pdev, adckey);
 303
 304         pRk28AdcKey = adckey;
 305
 306         /* Register the input device */
 307         error = input_register_device(input_dev);
 308         if (error) {
 309                 dev_err(&pdev->dev, "failed to register input device\n");
 310                 goto failed_free_dev;
 311         }
 312
 313         error = gpio_request(rk2818_adc_key.pin_playon, "play key gpio");
 314         if (error) {
 315                 dev_err(&pdev->dev, "failed to request play key gpio\n");
 316                 goto free_gpio;
 317         }
 318     if(rk2818_adc_key.playon_level)
 319     {
 320         gpio_pull_updown(rk2818_adc_key.pin_playon,GPIOPullDown);
 321         error = request_irq(gpio_to_irq(rk2818_adc_key.pin_playon),rk28_playkey_irq,IRQF_TRIGGER_RISING,NULL,NULL);
 322         if(error)
 323         {
 324                 printk("unable to request play key irq\n");
 325                 goto free_gpio_irq;
 326         }
 327     }
 328     else
 329     {
 330         gpio_pull_updown(rk2818_adc_key.pin_playon,GPIOPullUp);
 331         error = request_irq(gpio_to_irq(rk2818_adc_key.pin_playon),rk28_playkey_irq,IRQF_TRIGGER_FALLING,NULL,NULL);
 332         if(error)
 333         {
 334                 printk("unable to request play key irq\n");
 335                 goto free_gpio_irq;
 336         }
 337     }
 338
 339         enable_irq_wake(gpio_to_irq(rk2818_adc_key.pin_playon)); // so play/wakeup key can wake up system
 340 #if 0
 341         error = gpio_direction_input(rk2818_adc_key.pin_playon);
 342         if (error)
 343         {
 344                 printk("failed to set gpio rk2818_adc_key.pin_playon input\n");
 345                 goto free_gpio_irq;
 346         }
 347 #endif
 348         setup_timer(&adckey->timer, rk28_adkeyscan_timer, (unsigned long)adckey);
 349         adckey->timer.expires  = jiffies+50;
 350         add_timer(&adckey->timer);
 351         printk(KERN_INFO "rk2818_adckey: driver initialized\n");
 352         return 0;
 353
 354 free_gpio_irq:
 355         free_irq(gpio_to_irq(rk2818_adc_key.pin_playon),NULL);
 356 free_gpio:
 357         gpio_free(rk2818_adc_key.pin_playon);
 358 failed_free_dev:
 359         platform_set_drvdata(pdev, NULL);
 360         input_free_device(input_dev);
 361 failed_free:
 362         kfree(adckey);
 363         return error;
 364 }
 365
 366 static int __devexit rk28_adckey_remove(struct platform_device *pdev)
 367 {
 368         struct rk28_adckey *adckey = platform_get_drvdata(pdev);
 369
 370         input_unregister_device(adckey->input_dev);
 371         input_free_device(adckey->input_dev);
 372         platform_set_drvdata(pdev, NULL);
 373         kfree(adckey);
 374         free_irq(gpio_to_irq(rk2818_adc_key.pin_playon),NULL);
 375         gpio_free(rk2818_adc_key.pin_playon);
 376         return 0;
 377 }
 378
 379 static struct platform_driver rk28_adckey_driver =
 380 {
 381         .probe          = rk28_adckey_probe,
 382         .remove         = __devexit_p(rk28_adckey_remove),
 383         .suspend        = rk28_adckey_suspend,
 384         .resume         = rk28_adckey_resume,
 385         .driver         = {
 386                 .name   = "rk2818-adckey",
 387                 .owner  = THIS_MODULE,
 388         },
 389 };
 390
 391  int __init rk28_adckey_init(void)
 392 {
 393         return platform_driver_register(&rk28_adckey_driver);
 394 }
 395
 396 static void __exit rk28_adckey_exit(void)
 397 {
 398         platform_driver_unregister(&rk28_adckey_driver);
 399 }
 400
 401 module_init(rk28_adckey_init);
 402 module_exit(rk28_adckey_exit);
 403
 404 MODULE_DESCRIPTION("rk2818 adc Key Controller Driver");
 405 MODULE_AUTHOR("luowei lw@rock-chips.com");
 406 MODULE_LICENSE("GPL");
 407