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