drivers/input/keyboard/rk29_keys.c

   1 /*
   2  * Driver for keys on GPIO lines capable of generating interrupts.
   3  *
   4  * Copyright 2005 Phil Blundell
   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 #include <linux/module.h>
  12
  13 #include <linux/init.h>
  14 #include <linux/fs.h>
  15 #include <linux/interrupt.h>
  16 #include <linux/irq.h>
  17 #include <linux/sched.h>
  18 #include <linux/pm.h>
  19 #include <linux/sysctl.h>
  20 #include <linux/proc_fs.h>
  21 #include <linux/delay.h>
  22 #include <linux/platform_device.h>
  23 #include <linux/input.h>
  24 #include <linux/adc.h>
  25
  26 #include <asm/gpio.h>
  27 #include <mach/board.h>
  28 #include <plat/key.h>
  29
  30 #define EMPTY_ADVALUE                                   950
  31 #define DRIFT_ADVALUE                                   70
  32 #define INVALID_ADVALUE                                 -1
  33 #define EV_MENU                                 KEY_F1
  34
  35
  36 #if 0
  37 #define key_dbg(bdata, format, arg...)          \
  38         dev_printk(KERN_INFO , &bdata->input->dev , format , ## arg)
  39 #else
  40 #define key_dbg(bdata, format, arg...)
  41 #endif
  42
  43 struct rk29_button_data {
  44         int state;
  45         int long_press_count;
  46         struct rk29_keys_button *button;
  47         struct input_dev *input;
  48         struct timer_list timer;
  49         struct rk29_keys_drvdata *ddata;
  50 };
  51
  52 struct rk29_keys_drvdata {
  53         int nbuttons;
  54         int result;
  55         bool in_suspend;        /* Flag to indicate if we're suspending/resuming */
  56         struct input_dev *input;
  57         struct adc_client *client;
  58         struct timer_list timer;
  59         struct rk29_button_data data[0];
  60 };
  61
  62 static struct input_dev *input_dev;
  63 struct rk29_keys_Arrary {
  64         char keyArrary[20];
  65 };
  66
  67 static ssize_t rk29key_set(struct device *dev,
  68                 struct device_attribute *attr, const char *buf, size_t count)
  69 {
  70         struct rk29_keys_platform_data *pdata = dev_get_platdata(dev);
  71         int i,j,start,end;
  72         char rk29keyArrary[400];
  73         struct rk29_keys_Arrary Arrary[]={
  74                 {
  75                         .keyArrary = {"menu"},
  76                 },
  77                 {
  78                         .keyArrary = {"home"},
  79                 },
  80                 {
  81                         .keyArrary = {"esc"},
  82                 },
  83                 {
  84                         .keyArrary = {"sensor"},
  85                 },
  86                 {
  87                         .keyArrary = {"play"},
  88                 },
  89                 {
  90                         .keyArrary = {"vol+"},
  91                 },
  92                 {
  93                         .keyArrary = {"vol-"},
  94                 },
  95         };
  96         char *p;
  97
  98         for(i=0;i<7;i++)
  99         {
 100
 101                 p = strstr(buf,Arrary[i].keyArrary);
 102                 if(p==0)
 103               {
 104                    dev_dbg(dev," rk29key_set p == 0 error ...............\n");
 105                    continue;
 106               }
 107                 start = strcspn(p,":");
 108
 109                 if(i<6)
 110                         end = strcspn(p,",");
 111                 else
 112                         end = strcspn(p,"}");
 113
 114                 memset(rk29keyArrary,0,sizeof(rk29keyArrary));
 115
 116                 strncpy(rk29keyArrary,p+start+1,end-start-1);
 117
 118                 for(j=0;j<7;j++)
 119                 {
 120                         if(strcmp(pdata->buttons[j].desc,Arrary[i].keyArrary)==0)
 121                         {
 122                                 if(strcmp(rk29keyArrary,"MENU")==0)
 123                                         pdata->buttons[j].code = EV_MENU;
 124                                 else if(strcmp(rk29keyArrary,"HOME")==0)
 125                                         pdata->buttons[j].code = KEY_HOME;
 126                                 else if(strcmp(rk29keyArrary,"ESC")==0)
 127                                         pdata->buttons[j].code = KEY_BACK;
 128                                 else if(strcmp(rk29keyArrary,"sensor")==0)
 129                                         pdata->buttons[j].code = KEY_CAMERA;
 130                                 else if(strcmp(rk29keyArrary,"PLAY")==0)
 131                                         pdata->buttons[j].code = KEY_POWER;
 132                                 else if(strcmp(rk29keyArrary,"VOLUP")==0)
 133                                         pdata->buttons[j].code = KEY_VOLUMEUP;
 134                                 else if(strcmp(rk29keyArrary,"VOLDOWN")==0)
 135                                         pdata->buttons[j].code = KEY_VOLUMEDOWN;
 136                                 else
 137                                      continue;
 138                         }
 139
 140                 }
 141
 142         }
 143
 144         for(i=0;i<7;i++)
 145                 dev_dbg(dev, "desc=%s, code=%d\n",pdata->buttons[i].desc,pdata->buttons[i].code);
 146         return 0;
 147
 148 }
 149
 150 static DEVICE_ATTR(rk29key,0660, NULL, rk29key_set);
 151
 152 void rk29_send_power_key(int state)
 153 {
 154         if (!input_dev)
 155                 return;
 156         if(state)
 157         {
 158                 input_report_key(input_dev, KEY_POWER, 1);
 159                 input_sync(input_dev);
 160         }
 161         else
 162         {
 163                 input_report_key(input_dev, KEY_POWER, 0);
 164                 input_sync(input_dev);
 165         }
 166 }
 167
 168 void rk28_send_wakeup_key(void)
 169 {
 170         if (!input_dev)
 171                 return;
 172
 173         input_report_key(input_dev, KEY_WAKEUP, 1);
 174         input_sync(input_dev);
 175         input_report_key(input_dev, KEY_WAKEUP, 0);
 176         input_sync(input_dev);
 177 }
 178
 179 static void keys_long_press_timer(unsigned long _data)
 180 {
 181         int state;
 182         struct rk29_button_data *bdata = (struct rk29_button_data *)_data;
 183         struct rk29_keys_button *button = bdata->button;
 184         struct input_dev *input = bdata->input;
 185         unsigned int type = EV_KEY;
 186         if(button->gpio != INVALID_GPIO )
 187                 state = !!((gpio_get_value(button->gpio) ? 1 : 0) ^ button->active_low);
 188         else
 189                 state = !!button->adc_state;
 190         if(state) {
 191                 if(bdata->long_press_count != 0) {
 192                         if(bdata->long_press_count % (LONG_PRESS_COUNT+ONE_SEC_COUNT) == 0){
 193                                 key_dbg(bdata, "%skey[%s]: report ev[%d] state[0]\n",
 194                                         (button->gpio == INVALID_GPIO)?"ad":"io", button->desc, button->code_long_press);
 195                                 input_event(input, type, button->code_long_press, 0);
 196                                 input_sync(input);
 197                         }
 198                         else if(bdata->long_press_count%LONG_PRESS_COUNT == 0) {
 199                                 key_dbg(bdata, "%skey[%s]: report ev[%d] state[1]\n",
 200                                         (button->gpio == INVALID_GPIO)?"ad":"io", button->desc, button->code_long_press);
 201                                 input_event(input, type, button->code_long_press, 1);
 202                                 input_sync(input);
 203                         }
 204                 }
 205                 bdata->long_press_count++;
 206                 mod_timer(&bdata->timer,
 207                                 jiffies + msecs_to_jiffies(DEFAULT_DEBOUNCE_INTERVAL));
 208         }
 209         else {
 210                 if(bdata->long_press_count <= LONG_PRESS_COUNT) {
 211                         bdata->long_press_count = 0;
 212                         key_dbg(bdata, "%skey[%s]: report ev[%d] state[1], report ev[%d] state[0]\n",
 213                                         (button->gpio == INVALID_GPIO)?"ad":"io", button->desc, button->code, button->code);
 214                         input_event(input, type, button->code, 1);
 215                         input_sync(input);
 216                         input_event(input, type, button->code, 0);
 217                         input_sync(input);
 218                 }
 219                 else if(bdata->state != state) {
 220                         key_dbg(bdata, "%skey[%s]: report ev[%d] state[0]\n",
 221                         (button->gpio == INVALID_GPIO)?"ad":"io", button->desc, button->code_long_press);
 222                         input_event(input, type, button->code_long_press, 0);
 223                         input_sync(input);
 224                 }
 225         }
 226         bdata->state = state;
 227 }
 228 static void keys_timer(unsigned long _data)
 229 {
 230         int state;
 231         struct rk29_button_data *bdata = (struct rk29_button_data *)_data;
 232         struct rk29_keys_button *button = bdata->button;
 233         struct input_dev *input = bdata->input;
 234         unsigned int type = EV_KEY;
 235
 236         if(button->gpio != INVALID_GPIO)
 237                 state = !!((gpio_get_value(button->gpio) ? 1 : 0) ^ button->active_low);
 238         else
 239                 state = !!button->adc_state;
 240         if(bdata->state != state) {
 241                 bdata->state = state;
 242                 key_dbg(bdata, "%skey[%s]: report ev[%d] state[%d]\n",
 243                         (button->gpio == INVALID_GPIO)?"ad":"io", button->desc, button->code, bdata->state);
 244                 input_event(input, type, button->code, bdata->state);
 245                 input_sync(input);
 246         }
 247         if(state)
 248                 mod_timer(&bdata->timer,
 249                         jiffies + msecs_to_jiffies(DEFAULT_DEBOUNCE_INTERVAL));
 250 }
 251
 252 static irqreturn_t keys_isr(int irq, void *dev_id)
 253 {
 254         struct rk29_button_data *bdata = dev_id;
 255         struct rk29_keys_button *button = bdata->button;
 256         struct input_dev *input = bdata->input;
 257         unsigned int type = EV_KEY;
 258         BUG_ON(irq != gpio_to_irq(button->gpio));
 259
 260         if(button->wakeup == 1 && bdata->ddata->in_suspend == true){
 261                 bdata->state = 1;
 262                 key_dbg(bdata, "wakeup: %skey[%s]: report ev[%d] state[%d]\n",
 263                         (button->gpio == INVALID_GPIO)?"ad":"io", button->desc, button->code, bdata->state);
 264                 input_event(input, type, button->code, bdata->state);
 265                 input_sync(input);
 266         }
 267         bdata->long_press_count = 0;
 268         mod_timer(&bdata->timer,
 269                                 jiffies + msecs_to_jiffies(DEFAULT_DEBOUNCE_INTERVAL));
 270         return IRQ_HANDLED;
 271 }
 272
 273 static void keys_adc_callback(struct adc_client *client, void *client_param, int result)
 274 {
 275         struct rk29_keys_drvdata *ddata = (struct rk29_keys_drvdata *)client_param;
 276         int i;
 277         if(result > INVALID_ADVALUE && result < EMPTY_ADVALUE)
 278                 ddata->result = result;
 279         for (i = 0; i < ddata->nbuttons; i++) {
 280                 struct rk29_button_data *bdata = &ddata->data[i];
 281                 struct rk29_keys_button *button = bdata->button;
 282                 if(!button->adc_value)
 283                         continue;
 284                 if(result < button->adc_value + DRIFT_ADVALUE &&
 285                         result > button->adc_value - DRIFT_ADVALUE)
 286                         button->adc_state = 1;
 287                 else
 288                         button->adc_state = 0;
 289                 if(bdata->state != button->adc_state)
 290                         mod_timer(&bdata->timer,
 291                                 jiffies + msecs_to_jiffies(DEFAULT_DEBOUNCE_INTERVAL));
 292         }
 293         return;
 294 }
 295
 296 static void keys_adc_timer(unsigned long _data)
 297 {
 298         struct rk29_keys_drvdata *ddata = (struct rk29_keys_drvdata *)_data;
 299
 300         if (!ddata->in_suspend)
 301                 adc_async_read(ddata->client);
 302         mod_timer(&ddata->timer, jiffies + msecs_to_jiffies(ADC_SAMPLE_TIME));
 303 }
 304
 305 static ssize_t adc_value_show(struct device *dev, struct device_attribute *attr, char *buf)
 306 {
 307         struct rk29_keys_drvdata *ddata = dev_get_drvdata(dev);
 308
 309         return sprintf(buf, "adc_value: %d\n", ddata->result);
 310 }
 311
 312 static DEVICE_ATTR(get_adc_value, S_IRUGO | S_IWUSR, adc_value_show, NULL);
 313
 314 static int __devinit keys_probe(struct platform_device *pdev)
 315 {
 316         struct device *dev = &pdev->dev;
 317         struct rk29_keys_platform_data *pdata = dev_get_platdata(dev);
 318         struct rk29_keys_drvdata *ddata;
 319         struct input_dev *input;
 320         int i, error = 0;
 321         int wakeup = 0;
 322
 323         if(!pdata)
 324                 return -EINVAL;
 325
 326         ddata = kzalloc(sizeof(struct rk29_keys_drvdata) +
 327                         pdata->nbuttons * sizeof(struct rk29_button_data),
 328                         GFP_KERNEL);
 329         input = input_allocate_device();
 330         if (!ddata || !input) {
 331                 error = -ENOMEM;
 332                 goto fail0;
 333         }
 334
 335         platform_set_drvdata(pdev, ddata);
 336
 337         input->name = pdev->name;
 338         input->phys = "gpio-keys/input0";
 339         input->dev.parent = dev;
 340
 341         input->id.bustype = BUS_HOST;
 342         input->id.vendor = 0x0001;
 343         input->id.product = 0x0001;
 344         input->id.version = 0x0100;
 345
 346         /* Enable auto repeat feature of Linux input subsystem */
 347         if (pdata->rep)
 348                 __set_bit(EV_REP, input->evbit);
 349         ddata->nbuttons = pdata->nbuttons;
 350         ddata->input = input;
 351
 352         for (i = 0; i < pdata->nbuttons; i++) {
 353                 struct rk29_keys_button *button = &pdata->buttons[i];
 354                 struct rk29_button_data *bdata = &ddata->data[i];
 355
 356                 bdata->input = input;
 357                 bdata->button = button;
 358                 bdata->ddata = ddata;
 359
 360                 if (button->code_long_press)
 361                         setup_timer(&bdata->timer,
 362                                 keys_long_press_timer, (unsigned long)bdata);
 363                 else if (button->code)
 364                         setup_timer(&bdata->timer,
 365                                 keys_timer, (unsigned long)bdata);
 366
 367                 if (button->wakeup)
 368                         wakeup = 1;
 369
 370                 input_set_capability(input, EV_KEY, button->code);
 371         };
 372
 373         if (pdata->chn >= 0) {
 374                 setup_timer(&ddata->timer, keys_adc_timer, (unsigned long)ddata);
 375                 ddata->client = adc_register(pdata->chn, keys_adc_callback, (void *)ddata);
 376                 if (!ddata->client) {
 377                         error = -EINVAL;
 378                         goto fail1;
 379                 }
 380                 mod_timer(&ddata->timer, jiffies + msecs_to_jiffies(100));
 381         }
 382
 383         for (i = 0; i < pdata->nbuttons; i++) {
 384                 struct rk29_keys_button *button = &pdata->buttons[i];
 385                 struct rk29_button_data *bdata = &ddata->data[i];
 386                 int irq;
 387
 388                 if(button->gpio != INVALID_GPIO) {
 389                         error = gpio_request(button->gpio, button->desc ?: "keys");
 390                         if (error < 0) {
 391                                 pr_err("gpio-keys: failed to request GPIO %d,"
 392                                         " error %d\n", button->gpio, error);
 393                                 goto fail2;
 394                         }
 395
 396                         error = gpio_direction_input(button->gpio);
 397                         if (error < 0) {
 398                                 pr_err("gpio-keys: failed to configure input"
 399                                         " direction for GPIO %d, error %d\n",
 400                                         button->gpio, error);
 401                                 gpio_free(button->gpio);
 402                                 goto fail2;
 403                         }
 404
 405                         irq = gpio_to_irq(button->gpio);
 406                         if (irq < 0) {
 407                                 error = irq;
 408                                 pr_err("gpio-keys: Unable to get irq number"
 409                                         " for GPIO %d, error %d\n",
 410                                         button->gpio, error);
 411                                 gpio_free(button->gpio);
 412                                 goto fail2;
 413                         }
 414
 415                         error = request_irq(irq, keys_isr,
 416                                             (button->active_low)?IRQF_TRIGGER_FALLING : IRQF_TRIGGER_RISING,
 417                                             button->desc ? button->desc : "keys",
 418                                             bdata);
 419                         if (error) {
 420                                 pr_err("gpio-keys: Unable to claim irq %d; error %d\n",
 421                                         irq, error);
 422                                 gpio_free(button->gpio);
 423                                 goto fail2;
 424                         }
 425                 }
 426         }
 427
 428         input_set_capability(input, EV_KEY, KEY_WAKEUP);
 429
 430         error = input_register_device(input);
 431         if (error) {
 432                 pr_err("gpio-keys: Unable to register input device, "
 433                         "error: %d\n", error);
 434                 goto fail2;
 435         }
 436
 437         device_init_wakeup(dev, wakeup);
 438         error = device_create_file(dev, &dev_attr_get_adc_value);
 439
 440         error = device_create_file(dev, &dev_attr_rk29key);
 441         if(error )
 442         {
 443                 pr_err("failed to create key file error: %d\n", error);
 444         }
 445
 446
 447         input_dev = input;
 448         return error;
 449
 450  fail2:
 451         while (--i >= 0) {
 452                 free_irq(gpio_to_irq(pdata->buttons[i].gpio), &ddata->data[i]);
 453                 del_timer_sync(&ddata->data[i].timer);
 454                 gpio_free(pdata->buttons[i].gpio);
 455         }
 456         if(pdata->chn >= 0 && ddata->client);
 457                 adc_unregister(ddata->client);
 458         if(pdata->chn >= 0)
 459                 del_timer_sync(&ddata->timer);
 460  fail1:
 461         platform_set_drvdata(pdev, NULL);
 462  fail0:
 463         input_free_device(input);
 464         kfree(ddata);
 465
 466         return error;
 467 }
 468
 469 static int __devexit keys_remove(struct platform_device *pdev)
 470 {
 471         struct device *dev = &pdev->dev;
 472         struct rk29_keys_platform_data *pdata = dev_get_platdata(dev);
 473         struct rk29_keys_drvdata *ddata = dev_get_drvdata(dev);
 474         struct input_dev *input = ddata->input;
 475         int i;
 476
 477         input_dev = NULL;
 478         device_init_wakeup(dev, 0);
 479
 480         for (i = 0; i < pdata->nbuttons; i++) {
 481                 int irq = gpio_to_irq(pdata->buttons[i].gpio);
 482                 free_irq(irq, &ddata->data[i]);
 483                 del_timer_sync(&ddata->data[i].timer);
 484                 gpio_free(pdata->buttons[i].gpio);
 485         }
 486         if(pdata->chn >= 0 && ddata->client);
 487                 adc_unregister(ddata->client);
 488         input_unregister_device(input);
 489
 490         return 0;
 491 }
 492
 493
 494 #ifdef CONFIG_PM
 495 static int keys_suspend(struct device *dev)
 496 {
 497         struct rk29_keys_platform_data *pdata = dev_get_platdata(dev);
 498         struct rk29_keys_drvdata *ddata = dev_get_drvdata(dev);
 499         int i;
 500
 501         ddata->in_suspend = true;
 502
 503         if (device_may_wakeup(dev)) {
 504                 for (i = 0; i < pdata->nbuttons; i++) {
 505                         struct rk29_keys_button *button = &pdata->buttons[i];
 506                         if (button->wakeup) {
 507                                 int irq = gpio_to_irq(button->gpio);
 508                                 enable_irq_wake(irq);
 509                         }
 510                 }
 511         }
 512
 513         return 0;
 514 }
 515
 516 static int keys_resume(struct device *dev)
 517 {
 518         struct rk29_keys_platform_data *pdata = dev_get_platdata(dev);
 519         struct rk29_keys_drvdata *ddata = dev_get_drvdata(dev);
 520         int i;
 521
 522         if (device_may_wakeup(dev)) {
 523                 for (i = 0; i < pdata->nbuttons; i++) {
 524                         struct rk29_keys_button *button = &pdata->buttons[i];
 525                         if (button->wakeup) {
 526                                 int irq = gpio_to_irq(button->gpio);
 527                                 disable_irq_wake(irq);
 528                         }
 529                 }
 530                 preempt_disable();
 531                 if (local_softirq_pending())
 532                         do_softirq(); // for call resend_irqs, which may call keys_isr
 533                 preempt_enable_no_resched();
 534         }
 535
 536         ddata->in_suspend = false;
 537
 538         return 0;
 539 }
 540
 541 static const struct dev_pm_ops keys_pm_ops = {
 542         .suspend        = keys_suspend,
 543         .resume         = keys_resume,
 544 };
 545 #endif
 546
 547 static struct platform_driver keys_device_driver = {
 548         .probe          = keys_probe,
 549         .remove         = __devexit_p(keys_remove),
 550         .driver         = {
 551                 .name   = "rk29-keypad",
 552                 .owner  = THIS_MODULE,
 553 #ifdef CONFIG_PM
 554                 .pm     = &keys_pm_ops,
 555 #endif
 556         }
 557 };
 558
 559 static int __init keys_init(void)
 560 {
 561         return platform_driver_register(&keys_device_driver);
 562 }
 563
 564 static void __exit keys_exit(void)
 565 {
 566         platform_driver_unregister(&keys_device_driver);
 567 }
 568
 569 module_init(keys_init);
 570 module_exit(keys_exit);
 571
 572 MODULE_LICENSE("GPL");
 573 MODULE_AUTHOR("Phil Blundell <pb@handhelds.org>");
 574 MODULE_DESCRIPTION("Keyboard driver for CPU GPIOs");
 575 MODULE_ALIAS("platform:gpio-keys");