drivers/input/keyboard/rk_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 #include <linux/init.h>
  13 #include <linux/fs.h>
  14 #include <linux/interrupt.h>
  15 #include <linux/irq.h>
  16 #include <linux/sched.h>
  17 #include <linux/pm.h>
  18 #include <linux/sysctl.h>
  19 #include <linux/proc_fs.h>
  20 #include <linux/delay.h>
  21 #include <linux/platform_device.h>
  22 #include <linux/input.h>
  23 #include <linux/adc.h>
  24 #include <linux/slab.h>
  25
  26 #include <linux/iio/iio.h>
  27 #include <linux/iio/machine.h>
  28 #include <linux/iio/driver.h>
  29 #include <linux/iio/consumer.h>
  30
  31 #include <linux/gpio.h>
  32 #include <linux/of.h>
  33 #include <linux/of_irq.h>
  34 #include <linux/of_gpio.h>
  35 #include <linux/of_platform.h>
  36
  37 #define EMPTY_ADVALUE                                   950
  38 #define DRIFT_ADVALUE                                   70
  39 #define INVALID_ADVALUE                                 -1
  40 #define EV_ENCALL                       KEY_F4
  41 #define EV_MENU                         KEY_F1
  42
  43
  44 #if 0
  45 #define key_dbg(bdata, format, arg...)          \
  46         dev_printk(KERN_INFO , &bdata->input->dev , format , ## arg)
  47 #else
  48 #define key_dbg(bdata, format, arg...)
  49 #endif
  50
  51 #define DEFAULT_DEBOUNCE_INTERVAL       10  //10ms
  52 #define ADC_SAMPLE_TIME                  100
  53
  54 enum  rk_key_type{
  55        TYPE_GPIO = 1,
  56            TYPE_ADC
  57 };
  58
  59 struct rk_keys_button {
  60         u32 type;  //TYPE_GPIO, TYPE_ADC
  61     u32 code;  // key code
  62     const char *desc;//key label
  63         u32 state; //key up & down state
  64     int gpio;  //gpio only
  65     int adc_value; //adc only
  66     int adc_state; //adc only
  67     int active_low;//gpio only
  68     int wakeup;    //gpio only
  69         struct timer_list timer;
  70 };
  71
  72 struct rk_keys_drvdata {
  73         int nbuttons;
  74         bool in_suspend;        /* Flag to indicate if we're suspending/resuming */
  75         int result;
  76     int rep;
  77         struct input_dev *input;
  78         struct delayed_work adc_poll_work;
  79     struct iio_channel *chan;
  80         struct rk_keys_button button[0];
  81 };
  82
  83 static struct input_dev *sinput_dev = NULL;
  84 static struct rk_keys_drvdata *spdata = NULL;
  85 static void * rk_key_get_drvdata(void)
  86 {
  87      BUG_ON(!spdata);
  88          return spdata;
  89 }
  90
  91 void rk_send_power_key(int state)
  92 {
  93         if (!sinput_dev)
  94                 return;
  95         if(state)
  96         {
  97                 input_report_key(sinput_dev, KEY_POWER, 1);
  98                 input_sync(sinput_dev);
  99         }
 100         else
 101         {
 102                 input_report_key(sinput_dev, KEY_POWER, 0);
 103                 input_sync(sinput_dev);
 104         }
 105 }
 106 EXPORT_SYMBOL(rk_send_power_key);
 107
 108 void rk_send_wakeup_key(void)
 109 {
 110         if (!sinput_dev)
 111                 return;
 112
 113         input_report_key(sinput_dev, KEY_WAKEUP, 1);
 114         input_sync(sinput_dev);
 115         input_report_key(sinput_dev, KEY_WAKEUP, 0);
 116         input_sync(sinput_dev);
 117 }
 118 EXPORT_SYMBOL(rk_send_wakeup_key);
 119
 120 static void keys_timer(unsigned long _data)
 121 {
 122     struct rk_keys_drvdata *pdata = rk_key_get_drvdata();
 123         struct rk_keys_button *button = (struct rk_keys_button *)_data;
 124         struct input_dev *input = pdata->input;
 125         int state;
 126
 127         if(button->type == TYPE_GPIO)
 128                 state = !!((gpio_get_value(button->gpio) ? 1 : 0) ^ button->active_low);
 129         else
 130                 state = !!button->adc_state;
 131
 132         if(button->state != state) {
 133                 button->state = state;
 134                 input_event(input, EV_KEY, button->code, button->state);
 135                 key_dbg(pdata, "%skey[%s]: report event[%d] state[%d]\n",
 136                         (button->type == TYPE_ADC)?"adc":"gpio", button->desc, button->code, button->state);
 137                 input_event(input, EV_KEY, button->code, button->state);
 138                 input_sync(input);
 139         }
 140
 141         if(state)
 142                 mod_timer(&button->timer,
 143                         jiffies + msecs_to_jiffies(DEFAULT_DEBOUNCE_INTERVAL));
 144
 145 }
 146
 147 static irqreturn_t keys_isr(int irq, void *dev_id)
 148 {
 149     struct rk_keys_drvdata *pdata = rk_key_get_drvdata();
 150         struct rk_keys_button *button = (struct rk_keys_button *)dev_id;
 151         struct input_dev *input = pdata->input;
 152         BUG_ON(irq != gpio_to_irq(button->gpio));
 153
 154     if(button->wakeup == 1 && pdata->in_suspend == true){
 155                 button->state = 1;
 156                 key_dbg(pdata, "wakeup: %skey[%s]: report event[%d] state[%d]\n",
 157                         (button->type == TYPE_ADC)?"adc":"gpio", button->desc, button->code, button->state);
 158                 input_event(input, EV_KEY, button->code, button->state);
 159                 input_sync(input);
 160     }
 161         mod_timer(&button->timer,
 162                                 jiffies + msecs_to_jiffies(DEFAULT_DEBOUNCE_INTERVAL));
 163         return IRQ_HANDLED;
 164 }
 165
 166 #if 0
 167 static ssize_t adc_value_show(struct device *dev, struct device_attribute *attr, char *buf)
 168 {
 169         struct rk_keys_drvdata *ddata = dev_get_drvdata(dev);
 170         return sprintf(buf, "adc_value: %d\n", ddata->result);
 171 }
 172 static DEVICE_ATTR(get_adc_value, S_IRUGO | S_IWUSR, adc_value_show, NULL);
 173 #endif
 174
 175 static const struct of_device_id rk_key_match[] = {
 176         { .compatible = "rockchip,key", .data = NULL},
 177         {},
 178 };
 179 MODULE_DEVICE_TABLE(of, rk_key_match);
 180
 181 static int rk_key_adc_iio_read(struct rk_keys_drvdata *data)
 182 {
 183         struct iio_channel *channel = data->chan;
 184         int val, ret;
 185
 186         if (!channel)
 187                 return INVALID_ADVALUE;
 188         ret = iio_read_channel_raw(channel, &val);
 189         if (ret < 0) {
 190                 pr_err("read channel() error: %d\n", ret);
 191                 return ret;
 192         }
 193         return val;
 194 }
 195
 196 static void adc_key_poll(struct work_struct *work)
 197 {
 198     struct rk_keys_drvdata *ddata;
 199     int i, result = -1;
 200
 201     ddata = container_of(work, struct rk_keys_drvdata, adc_poll_work.work);
 202     if (!ddata->in_suspend)
 203     {
 204         result = rk_key_adc_iio_read(ddata);
 205         if(result > INVALID_ADVALUE && result < EMPTY_ADVALUE)
 206             ddata->result = result;
 207         for (i = 0; i < ddata->nbuttons; i++)
 208         {
 209             struct rk_keys_button *button = &ddata->button[i];
 210             if(!button->adc_value)
 211                 continue;
 212             if(result < button->adc_value + DRIFT_ADVALUE &&
 213                 result > button->adc_value - DRIFT_ADVALUE)
 214                 button->adc_state = 1;
 215             else
 216                 button->adc_state = 0;
 217             if(button->state != button->adc_state)
 218                 mod_timer(&button->timer,
 219                     jiffies + msecs_to_jiffies(DEFAULT_DEBOUNCE_INTERVAL));
 220         }
 221     }
 222
 223     schedule_delayed_work(&ddata->adc_poll_work,
 224         msecs_to_jiffies(ADC_SAMPLE_TIME));
 225 }
 226
 227 static int rk_key_type_get(struct device_node *node, struct rk_keys_button *button)
 228 {
 229         u32 adc_value;
 230
 231         if (!of_property_read_u32(node, "rockchip,adc_value", &adc_value))
 232             return TYPE_ADC;
 233         else if(of_get_gpio(node, 0) >= 0)
 234             return TYPE_GPIO;
 235         else
 236             return -1;
 237 }
 238
 239 static int rk_keys_parse_dt(struct rk_keys_drvdata *pdata,
 240                              struct platform_device *pdev)
 241 {
 242     struct device_node *node = pdev->dev.of_node;
 243     struct device_node *child_node;
 244     struct iio_channel *chan;
 245     int ret, gpio, i =0;
 246         u32 code, adc_value, flags;;
 247
 248         chan = iio_channel_get(&pdev->dev, NULL);
 249         if (IS_ERR(chan)) {
 250                 dev_info(&pdev->dev, "no io-channels defined\n");
 251                 chan = NULL;
 252         }
 253     pdata->chan = chan;
 254
 255         for_each_child_of_node(node, child_node) {
 256                 if(of_property_read_u32(child_node, "linux,code", &code)) {
 257                         dev_err(&pdev->dev, "Missing linux,code property in the DT.\n");
 258                         ret = -EINVAL;
 259                         goto error_ret;
 260                 }
 261         pdata->button[i].code = code;
 262                 pdata->button[i].desc = of_get_property(child_node, "label", NULL);
 263                 pdata->button[i].type = rk_key_type_get(child_node, &pdata->button[i]);
 264                 switch(pdata->button[i].type)
 265                 {
 266                     case TYPE_GPIO:
 267                                 gpio = of_get_gpio_flags(child_node, 0, &flags);
 268                                 if (gpio < 0) {
 269                                         ret = gpio;
 270                                         if (ret != -EPROBE_DEFER)
 271                                                 dev_err(&pdev->dev,"Failed to get gpio flags, error: %d\n",
 272                                                         ret);
 273                                         goto error_ret;
 274                                 }
 275
 276                                 pdata->button[i].gpio = gpio;
 277                         pdata->button[i].active_low = flags & OF_GPIO_ACTIVE_LOW;
 278                                 pdata->button[i].wakeup = !!of_get_property(child_node, "gpio-key,wakeup", NULL);
 279                                 break;
 280
 281                         case TYPE_ADC:
 282                             if (of_property_read_u32(child_node, "rockchip,adc_value", &adc_value)) {
 283                                     dev_err(&pdev->dev, "Missing rockchip,adc_value property in the DT.\n");
 284                                     ret = -EINVAL;
 285                                     goto error_ret;
 286                             }
 287                                 pdata->button[i].adc_value = adc_value;
 288                                 break;
 289
 290                         default:
 291                                 dev_err(&pdev->dev, "Error rockchip,type property in the DT.\n");
 292                             ret = -EINVAL;
 293                             goto error_ret;
 294                 }
 295             i++;
 296         }
 297
 298         return 0;
 299
 300 error_ret:
 301                 return ret;
 302
 303 }
 304
 305 static int  keys_probe(struct platform_device *pdev)
 306 {
 307         struct device *dev = &pdev->dev;
 308         struct device_node *np = pdev->dev.of_node;
 309         struct rk_keys_drvdata *ddata = NULL;
 310         struct input_dev *input = NULL;
 311         int i, error = 0;
 312         int wakeup, key_num = 0;
 313
 314         key_num = of_get_child_count(np);
 315         if (key_num == 0)
 316                 dev_info(&pdev->dev, "no key defined\n");
 317
 318     ddata = devm_kzalloc(dev, sizeof(struct rk_keys_drvdata) +
 319             key_num * sizeof(struct rk_keys_button),
 320                 GFP_KERNEL);
 321
 322         input = devm_input_allocate_device(dev);
 323         if (!ddata || !input) {
 324                 error = -ENOMEM;
 325                 return error;
 326         }
 327         platform_set_drvdata(pdev, ddata);
 328
 329         input->name = "rk29-keypad";//pdev->name;
 330         input->phys = "gpio-keys/input0";
 331         input->dev.parent = dev;
 332
 333         input->id.bustype = BUS_HOST;
 334         input->id.vendor = 0x0001;
 335         input->id.product = 0x0001;
 336         input->id.version = 0x0100;
 337         ddata->input = input;
 338
 339         //parse info from dt
 340         ddata->nbuttons = key_num;
 341         error = rk_keys_parse_dt(ddata, pdev);
 342         if(error)
 343             goto fail0;
 344
 345         /* Enable auto repeat feature of Linux input subsystem */
 346         if (ddata->rep)
 347                 __set_bit(EV_REP, input->evbit);
 348
 349         for (i = 0; i < ddata->nbuttons; i++) {
 350                 struct rk_keys_button *button = &ddata->button[i];
 351
 352                 if (button->code){
 353                         setup_timer(&button->timer,
 354                                 keys_timer, (unsigned long)button);}
 355
 356                 if (button->wakeup)
 357                         wakeup = 1;
 358
 359                 input_set_capability(input, EV_KEY, button->code);
 360         }
 361
 362         for (i = 0; i < ddata->nbuttons; i++) {
 363                 struct rk_keys_button *button = &ddata->button[i];
 364
 365                 if(button->type == TYPE_GPIO) {
 366                         int irq;
 367
 368                         error = devm_gpio_request(dev, button->gpio, button->desc ?: "keys");
 369                         if (error < 0) {
 370                                 pr_err("gpio-keys: failed to request GPIO %d,"
 371                                         " error %d\n", button->gpio, error);
 372                                 goto fail1;
 373                         }
 374
 375                         error = gpio_direction_input(button->gpio);
 376                         if (error < 0) {
 377                                 pr_err("gpio-keys: failed to configure input"
 378                                         " direction for GPIO %d, error %d\n",
 379                                         button->gpio, error);
 380                                 gpio_free(button->gpio);
 381                                 goto fail1;
 382                         }
 383
 384                         irq = gpio_to_irq(button->gpio);
 385                         if (irq < 0) {
 386                                 error = irq;
 387                                 pr_err("gpio-keys: Unable to get irq number"
 388                                         " for GPIO %d, error %d\n",
 389                                         button->gpio, error);
 390                                 gpio_free(button->gpio);
 391                                 goto fail1;
 392                         }
 393
 394                         error = devm_request_irq(dev, irq, keys_isr,
 395                                             (button->active_low)?IRQF_TRIGGER_FALLING : IRQF_TRIGGER_RISING,
 396                                             button->desc ? button->desc : "keys",
 397                                             button);
 398                         if (error) {
 399                                 pr_err("gpio-keys: Unable to claim irq %d; error %d\n",
 400                                         irq, error);
 401                                 gpio_free(button->gpio);
 402                                 goto fail1;
 403                         }
 404                 }
 405         }
 406
 407         input_set_capability(input, EV_KEY, KEY_WAKEUP);
 408         device_init_wakeup(dev, wakeup);
 409
 410         error = input_register_device(input);
 411         if (error) {
 412                 pr_err("gpio-keys: Unable to register input device, "
 413                         "error: %d\n", error);
 414                 goto fail2;
 415         }
 416
 417         //adc polling work
 418         if (ddata->chan) {
 419                 INIT_DELAYED_WORK(&ddata->adc_poll_work, adc_key_poll);
 420                 schedule_delayed_work(&ddata->adc_poll_work,
 421                                       msecs_to_jiffies(ADC_SAMPLE_TIME));
 422         }
 423
 424     spdata = ddata;
 425         sinput_dev = input;
 426         return error;
 427
 428  fail2:
 429         device_init_wakeup(dev, 0);
 430  fail1:
 431         while (--i >= 0) {
 432                 del_timer_sync(&ddata->button[i].timer);
 433         }
 434  fail0:
 435         platform_set_drvdata(pdev, NULL);
 436
 437         return error;
 438 }
 439
 440 static int keys_remove(struct platform_device *pdev)
 441 {
 442         struct device *dev = &pdev->dev;
 443         struct rk_keys_drvdata *ddata = dev_get_drvdata(dev);
 444         struct input_dev *input = ddata->input;
 445         int i;
 446
 447         device_init_wakeup(dev, 0);
 448         for (i = 0; i < ddata->nbuttons; i++) {
 449                 del_timer_sync(&ddata->button[i].timer);
 450         }
 451         if (ddata->chan)
 452                 cancel_delayed_work_sync(&ddata->adc_poll_work);
 453         input_unregister_device(input);
 454
 455         sinput_dev = NULL;
 456         spdata = NULL;
 457
 458         return 0;
 459 }
 460
 461
 462 #ifdef CONFIG_PM
 463 static int keys_suspend(struct device *dev)
 464 {
 465         struct rk_keys_drvdata *ddata = dev_get_drvdata(dev);
 466         int i;
 467
 468         ddata->in_suspend = true;
 469         if (device_may_wakeup(dev)) {
 470                 for (i = 0; i < ddata->nbuttons; i++) {
 471                         struct rk_keys_button *button = ddata->button + i;
 472                         if (button->wakeup) {
 473                                 int irq = gpio_to_irq(button->gpio);
 474                                 enable_irq_wake(irq);
 475                         }
 476                 }
 477         }
 478
 479         return 0;
 480 }
 481
 482 static int keys_resume(struct device *dev)
 483 {
 484         struct rk_keys_drvdata *ddata = dev_get_drvdata(dev);
 485         int i;
 486
 487         if (device_may_wakeup(dev)) {
 488                 for (i = 0; i < ddata->nbuttons; i++) {
 489                         struct rk_keys_button *button = ddata->button + i;
 490                         if (button->wakeup) {
 491                                 int irq = gpio_to_irq(button->gpio);
 492                                 disable_irq_wake(irq);
 493                         }
 494                 }
 495                 preempt_disable();
 496                 if (local_softirq_pending())
 497                         do_softirq(); // for call resend_irqs, which may call keys_isr
 498                 preempt_enable_no_resched();
 499         }
 500
 501         ddata->in_suspend = false;
 502
 503         return 0;
 504 }
 505
 506 static const struct dev_pm_ops keys_pm_ops = {
 507         .suspend        = keys_suspend,
 508         .resume         = keys_resume,
 509 };
 510 #endif
 511
 512 static struct platform_driver keys_device_driver = {
 513         .probe          = keys_probe,
 514         .remove         = keys_remove,
 515         .driver         = {
 516                 .name   = "rk-keypad",
 517                 .owner  = THIS_MODULE,
 518                 .of_match_table = rk_key_match,
 519 #ifdef CONFIG_PM
 520                 .pm     = &keys_pm_ops,
 521 #endif
 522         }
 523 };
 524
 525 module_platform_driver(keys_device_driver);
 526