drivers/input/keyboard/gpio_keys.c

   1 /*
   2  * Driver for keys on GPIO lines capable of generating interrupts.
   3  *
   4  * Copyright 2005 Phil Blundell
   5  * Copyright 2010, 2011 David Jander <david@protonic.nl>
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License version 2 as
   9  * published by the Free Software Foundation.
  10  */
  11
  12 #include <linux/module.h>
  13
  14 #include <linux/init.h>
  15 #include <linux/fs.h>
  16 #include <linux/interrupt.h>
  17 #include <linux/irq.h>
  18 #include <linux/sched.h>
  19 #include <linux/pm.h>
  20 #include <linux/slab.h>
  21 #include <linux/sysctl.h>
  22 #include <linux/proc_fs.h>
  23 #include <linux/delay.h>
  24 #include <linux/platform_device.h>
  25 #include <linux/input.h>
  26 #include <linux/gpio_keys.h>
  27 #include <linux/workqueue.h>
  28 #include <linux/gpio.h>
  29 #include <linux/of.h>
  30 #include <linux/of_platform.h>
  31 #include <linux/of_gpio.h>
  32 #include <linux/spinlock.h>
  33
  34 struct gpio_button_data {
  35         const struct gpio_keys_button *button;
  36         struct input_dev *input;
  37         struct timer_list timer;
  38         struct work_struct work;
  39         unsigned int timer_debounce;    /* in msecs */
  40         unsigned int irq;
  41         spinlock_t lock;
  42         bool disabled;
  43         bool key_pressed;
  44 };
  45
  46 struct gpio_keys_drvdata {
  47         const struct gpio_keys_platform_data *pdata;
  48         struct input_dev *input;
  49         struct mutex disable_lock;
  50         struct gpio_button_data data[0];
  51 };
  52
  53 /*
  54  * SYSFS interface for enabling/disabling keys and switches:
  55  *
  56  * There are 4 attributes under /sys/devices/platform/gpio-keys/
  57  *      keys [ro]              - bitmap of keys (EV_KEY) which can be
  58  *                               disabled
  59  *      switches [ro]          - bitmap of switches (EV_SW) which can be
  60  *                               disabled
  61  *      disabled_keys [rw]     - bitmap of keys currently disabled
  62  *      disabled_switches [rw] - bitmap of switches currently disabled
  63  *
  64  * Userland can change these values and hence disable event generation
  65  * for each key (or switch). Disabling a key means its interrupt line
  66  * is disabled.
  67  *
  68  * For example, if we have following switches set up as gpio-keys:
  69  *      SW_DOCK = 5
  70  *      SW_CAMERA_LENS_COVER = 9
  71  *      SW_KEYPAD_SLIDE = 10
  72  *      SW_FRONT_PROXIMITY = 11
  73  * This is read from switches:
  74  *      11-9,5
  75  * Next we want to disable proximity (11) and dock (5), we write:
  76  *      11,5
  77  * to file disabled_switches. Now proximity and dock IRQs are disabled.
  78  * This can be verified by reading the file disabled_switches:
  79  *      11,5
  80  * If we now want to enable proximity (11) switch we write:
  81  *      5
  82  * to disabled_switches.
  83  *
  84  * We can disable only those keys which don't allow sharing the irq.
  85  */
  86
  87 /**
  88  * get_n_events_by_type() - returns maximum number of events per @type
  89  * @type: type of button (%EV_KEY, %EV_SW)
  90  *
  91  * Return value of this function can be used to allocate bitmap
  92  * large enough to hold all bits for given type.
  93  */
  94 static inline int get_n_events_by_type(int type)
  95 {
  96         BUG_ON(type != EV_SW && type != EV_KEY);
  97
  98         return (type == EV_KEY) ? KEY_CNT : SW_CNT;
  99 }
 100
 101 /**
 102  * gpio_keys_disable_button() - disables given GPIO button
 103  * @bdata: button data for button to be disabled
 104  *
 105  * Disables button pointed by @bdata. This is done by masking
 106  * IRQ line. After this function is called, button won't generate
 107  * input events anymore. Note that one can only disable buttons
 108  * that don't share IRQs.
 109  *
 110  * Make sure that @bdata->disable_lock is locked when entering
 111  * this function to avoid races when concurrent threads are
 112  * disabling buttons at the same time.
 113  */
 114 static void gpio_keys_disable_button(struct gpio_button_data *bdata)
 115 {
 116         if (!bdata->disabled) {
 117                 /*
 118                  * Disable IRQ and possible debouncing timer.
 119                  */
 120                 disable_irq(bdata->irq);
 121                 if (bdata->timer_debounce)
 122                         del_timer_sync(&bdata->timer);
 123
 124                 bdata->disabled = true;
 125         }
 126 }
 127
 128 /**
 129  * gpio_keys_enable_button() - enables given GPIO button
 130  * @bdata: button data for button to be disabled
 131  *
 132  * Enables given button pointed by @bdata.
 133  *
 134  * Make sure that @bdata->disable_lock is locked when entering
 135  * this function to avoid races with concurrent threads trying
 136  * to enable the same button at the same time.
 137  */
 138 static void gpio_keys_enable_button(struct gpio_button_data *bdata)
 139 {
 140         if (bdata->disabled) {
 141                 enable_irq(bdata->irq);
 142                 bdata->disabled = false;
 143         }
 144 }
 145
 146 /**
 147  * gpio_keys_attr_show_helper() - fill in stringified bitmap of buttons
 148  * @ddata: pointer to drvdata
 149  * @buf: buffer where stringified bitmap is written
 150  * @type: button type (%EV_KEY, %EV_SW)
 151  * @only_disabled: does caller want only those buttons that are
 152  *                 currently disabled or all buttons that can be
 153  *                 disabled
 154  *
 155  * This function writes buttons that can be disabled to @buf. If
 156  * @only_disabled is true, then @buf contains only those buttons
 157  * that are currently disabled. Returns 0 on success or negative
 158  * errno on failure.
 159  */
 160 static ssize_t gpio_keys_attr_show_helper(struct gpio_keys_drvdata *ddata,
 161                                           char *buf, unsigned int type,
 162                                           bool only_disabled)
 163 {
 164         int n_events = get_n_events_by_type(type);
 165         unsigned long *bits;
 166         ssize_t ret;
 167         int i;
 168
 169         bits = kcalloc(BITS_TO_LONGS(n_events), sizeof(*bits), GFP_KERNEL);
 170         if (!bits)
 171                 return -ENOMEM;
 172
 173         for (i = 0; i < ddata->pdata->nbuttons; i++) {
 174                 struct gpio_button_data *bdata = &ddata->data[i];
 175
 176                 if (bdata->button->type != type)
 177                         continue;
 178
 179                 if (only_disabled && !bdata->disabled)
 180                         continue;
 181
 182                 __set_bit(bdata->button->code, bits);
 183         }
 184
 185         ret = bitmap_scnlistprintf(buf, PAGE_SIZE - 2, bits, n_events);
 186         buf[ret++] = '\n';
 187         buf[ret] = '\0';
 188
 189         kfree(bits);
 190
 191         return ret;
 192 }
 193
 194 /**
 195  * gpio_keys_attr_store_helper() - enable/disable buttons based on given bitmap
 196  * @ddata: pointer to drvdata
 197  * @buf: buffer from userspace that contains stringified bitmap
 198  * @type: button type (%EV_KEY, %EV_SW)
 199  *
 200  * This function parses stringified bitmap from @buf and disables/enables
 201  * GPIO buttons accordingly. Returns 0 on success and negative error
 202  * on failure.
 203  */
 204 static ssize_t gpio_keys_attr_store_helper(struct gpio_keys_drvdata *ddata,
 205                                            const char *buf, unsigned int type)
 206 {
 207         int n_events = get_n_events_by_type(type);
 208         unsigned long *bits;
 209         ssize_t error;
 210         int i;
 211
 212         bits = kcalloc(BITS_TO_LONGS(n_events), sizeof(*bits), GFP_KERNEL);
 213         if (!bits)
 214                 return -ENOMEM;
 215
 216         error = bitmap_parselist(buf, bits, n_events);
 217         if (error)
 218                 goto out;
 219
 220         /* First validate */
 221         for (i = 0; i < ddata->pdata->nbuttons; i++) {
 222                 struct gpio_button_data *bdata = &ddata->data[i];
 223
 224                 if (bdata->button->type != type)
 225                         continue;
 226
 227                 if (test_bit(bdata->button->code, bits) &&
 228                     !bdata->button->can_disable) {
 229                         error = -EINVAL;
 230                         goto out;
 231                 }
 232         }
 233
 234         mutex_lock(&ddata->disable_lock);
 235
 236         for (i = 0; i < ddata->pdata->nbuttons; i++) {
 237                 struct gpio_button_data *bdata = &ddata->data[i];
 238
 239                 if (bdata->button->type != type)
 240                         continue;
 241
 242                 if (test_bit(bdata->button->code, bits))
 243                         gpio_keys_disable_button(bdata);
 244                 else
 245                         gpio_keys_enable_button(bdata);
 246         }
 247
 248         mutex_unlock(&ddata->disable_lock);
 249
 250 out:
 251         kfree(bits);
 252         return error;
 253 }
 254
 255 #define ATTR_SHOW_FN(name, type, only_disabled)                         \
 256 static ssize_t gpio_keys_show_##name(struct device *dev,                \
 257                                      struct device_attribute *attr,     \
 258                                      char *buf)                         \
 259 {                                                                       \
 260         struct platform_device *pdev = to_platform_device(dev);         \
 261         struct gpio_keys_drvdata *ddata = platform_get_drvdata(pdev);   \
 262                                                                         \
 263         return gpio_keys_attr_show_helper(ddata, buf,                   \
 264                                           type, only_disabled);         \
 265 }
 266
 267 ATTR_SHOW_FN(keys, EV_KEY, false);
 268 ATTR_SHOW_FN(switches, EV_SW, false);
 269 ATTR_SHOW_FN(disabled_keys, EV_KEY, true);
 270 ATTR_SHOW_FN(disabled_switches, EV_SW, true);
 271
 272 /*
 273  * ATTRIBUTES:
 274  *
 275  * /sys/devices/platform/gpio-keys/keys [ro]
 276  * /sys/devices/platform/gpio-keys/switches [ro]
 277  */
 278 static DEVICE_ATTR(keys, S_IRUGO, gpio_keys_show_keys, NULL);
 279 static DEVICE_ATTR(switches, S_IRUGO, gpio_keys_show_switches, NULL);
 280
 281 #define ATTR_STORE_FN(name, type)                                       \
 282 static ssize_t gpio_keys_store_##name(struct device *dev,               \
 283                                       struct device_attribute *attr,    \
 284                                       const char *buf,                  \
 285                                       size_t count)                     \
 286 {                                                                       \
 287         struct platform_device *pdev = to_platform_device(dev);         \
 288         struct gpio_keys_drvdata *ddata = platform_get_drvdata(pdev);   \
 289         ssize_t error;                                                  \
 290                                                                         \
 291         error = gpio_keys_attr_store_helper(ddata, buf, type);          \
 292         if (error)                                                      \
 293                 return error;                                           \
 294                                                                         \
 295         return count;                                                   \
 296 }
 297
 298 ATTR_STORE_FN(disabled_keys, EV_KEY);
 299 ATTR_STORE_FN(disabled_switches, EV_SW);
 300
 301 /*
 302  * ATTRIBUTES:
 303  *
 304  * /sys/devices/platform/gpio-keys/disabled_keys [rw]
 305  * /sys/devices/platform/gpio-keys/disables_switches [rw]
 306  */
 307 static DEVICE_ATTR(disabled_keys, S_IWUSR | S_IRUGO,
 308                    gpio_keys_show_disabled_keys,
 309                    gpio_keys_store_disabled_keys);
 310 static DEVICE_ATTR(disabled_switches, S_IWUSR | S_IRUGO,
 311                    gpio_keys_show_disabled_switches,
 312                    gpio_keys_store_disabled_switches);
 313
 314 static struct attribute *gpio_keys_attrs[] = {
 315         &dev_attr_keys.attr,
 316         &dev_attr_switches.attr,
 317         &dev_attr_disabled_keys.attr,
 318         &dev_attr_disabled_switches.attr,
 319         NULL,
 320 };
 321
 322 static struct attribute_group gpio_keys_attr_group = {
 323         .attrs = gpio_keys_attrs,
 324 };
 325
 326 static void gpio_keys_gpio_report_event(struct gpio_button_data *bdata)
 327 {
 328         const struct gpio_keys_button *button = bdata->button;
 329         struct input_dev *input = bdata->input;
 330         unsigned int type = button->type ?: EV_KEY;
 331         int state = (gpio_get_value_cansleep(button->gpio) ? 1 : 0) ^ button->active_low;
 332
 333         if (type == EV_ABS) {
 334                 if (state)
 335                         input_event(input, type, button->code, button->value);
 336         } else {
 337                 input_event(input, type, button->code, !!state);
 338         }
 339         input_sync(input);
 340 }
 341
 342 static void gpio_keys_gpio_work_func(struct work_struct *work)
 343 {
 344         struct gpio_button_data *bdata =
 345                 container_of(work, struct gpio_button_data, work);
 346
 347         gpio_keys_gpio_report_event(bdata);
 348
 349         if (bdata->button->wakeup)
 350                 pm_relax(bdata->input->dev.parent);
 351 }
 352
 353 static void gpio_keys_gpio_timer(unsigned long _data)
 354 {
 355         struct gpio_button_data *bdata = (struct gpio_button_data *)_data;
 356
 357         schedule_work(&bdata->work);
 358 }
 359
 360 static irqreturn_t gpio_keys_gpio_isr(int irq, void *dev_id)
 361 {
 362         struct gpio_button_data *bdata = dev_id;
 363
 364         BUG_ON(irq != bdata->irq);
 365
 366         if (bdata->button->wakeup)
 367                 pm_stay_awake(bdata->input->dev.parent);
 368         if (bdata->timer_debounce)
 369                 mod_timer(&bdata->timer,
 370                         jiffies + msecs_to_jiffies(bdata->timer_debounce));
 371         else
 372                 schedule_work(&bdata->work);
 373
 374         return IRQ_HANDLED;
 375 }
 376
 377 static void gpio_keys_irq_timer(unsigned long _data)
 378 {
 379         struct gpio_button_data *bdata = (struct gpio_button_data *)_data;
 380         struct input_dev *input = bdata->input;
 381         unsigned long flags;
 382
 383         spin_lock_irqsave(&bdata->lock, flags);
 384         if (bdata->key_pressed) {
 385                 input_event(input, EV_KEY, bdata->button->code, 0);
 386                 input_sync(input);
 387                 bdata->key_pressed = false;
 388         }
 389         spin_unlock_irqrestore(&bdata->lock, flags);
 390 }
 391
 392 static irqreturn_t gpio_keys_irq_isr(int irq, void *dev_id)
 393 {
 394         struct gpio_button_data *bdata = dev_id;
 395         const struct gpio_keys_button *button = bdata->button;
 396         struct input_dev *input = bdata->input;
 397         unsigned long flags;
 398
 399         BUG_ON(irq != bdata->irq);
 400
 401         spin_lock_irqsave(&bdata->lock, flags);
 402
 403         if (!bdata->key_pressed) {
 404                 if (bdata->button->wakeup)
 405                         pm_wakeup_event(bdata->input->dev.parent, 0);
 406
 407                 input_event(input, EV_KEY, button->code, 1);
 408                 input_sync(input);
 409
 410                 if (!bdata->timer_debounce) {
 411                         input_event(input, EV_KEY, button->code, 0);
 412                         input_sync(input);
 413                         goto out;
 414                 }
 415
 416                 bdata->key_pressed = true;
 417         }
 418
 419         if (bdata->timer_debounce)
 420                 mod_timer(&bdata->timer,
 421                         jiffies + msecs_to_jiffies(bdata->timer_debounce));
 422 out:
 423         spin_unlock_irqrestore(&bdata->lock, flags);
 424         return IRQ_HANDLED;
 425 }
 426
 427 static void gpio_keys_quiesce_key(void *data)
 428 {
 429         struct gpio_button_data *bdata = data;
 430
 431         if (bdata->timer_debounce)
 432                 del_timer_sync(&bdata->timer);
 433
 434         cancel_work_sync(&bdata->work);
 435 }
 436
 437 static int gpio_keys_setup_key(struct platform_device *pdev,
 438                                 struct input_dev *input,
 439                                 struct gpio_button_data *bdata,
 440                                 const struct gpio_keys_button *button)
 441 {
 442         const char *desc = button->desc ? button->desc : "gpio_keys";
 443         struct device *dev = &pdev->dev;
 444         irq_handler_t isr;
 445         unsigned long irqflags;
 446         int irq;
 447         int error;
 448
 449         bdata->input = input;
 450         bdata->button = button;
 451         spin_lock_init(&bdata->lock);
 452
 453         if (gpio_is_valid(button->gpio)) {
 454
 455                 error = devm_gpio_request_one(&pdev->dev, button->gpio,
 456                                               GPIOF_IN, desc);
 457                 if (error < 0) {
 458                         dev_err(dev, "Failed to request GPIO %d, error %d\n",
 459                                 button->gpio, error);
 460                         return error;
 461                 }
 462
 463                 if (button->debounce_interval) {
 464                         error = gpio_set_debounce(button->gpio,
 465                                         button->debounce_interval * 1000);
 466                         /* use timer if gpiolib doesn't provide debounce */
 467                         if (error < 0)
 468                                 bdata->timer_debounce =
 469                                                 button->debounce_interval;
 470                 }
 471
 472                 irq = gpio_to_irq(button->gpio);
 473                 if (irq < 0) {
 474                         error = irq;
 475                         dev_err(dev,
 476                                 "Unable to get irq number for GPIO %d, error %d\n",
 477                                 button->gpio, error);
 478                         return error;
 479                 }
 480                 bdata->irq = irq;
 481
 482                 INIT_WORK(&bdata->work, gpio_keys_gpio_work_func);
 483                 setup_timer(&bdata->timer,
 484                             gpio_keys_gpio_timer, (unsigned long)bdata);
 485
 486                 isr = gpio_keys_gpio_isr;
 487                 irqflags = IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING;
 488
 489         } else {
 490                 if (!button->irq) {
 491                         dev_err(dev, "No IRQ specified\n");
 492                         return -EINVAL;
 493                 }
 494                 bdata->irq = button->irq;
 495
 496                 if (button->type && button->type != EV_KEY) {
 497                         dev_err(dev, "Only EV_KEY allowed for IRQ buttons.\n");
 498                         return -EINVAL;
 499                 }
 500
 501                 bdata->timer_debounce = button->debounce_interval;
 502                 setup_timer(&bdata->timer,
 503                             gpio_keys_irq_timer, (unsigned long)bdata);
 504
 505                 isr = gpio_keys_irq_isr;
 506                 irqflags = 0;
 507         }
 508
 509         input_set_capability(input, button->type ?: EV_KEY, button->code);
 510
 511         /*
 512          * Install custom action to cancel debounce timer and
 513          * workqueue item.
 514          */
 515         error = devm_add_action(&pdev->dev, gpio_keys_quiesce_key, bdata);
 516         if (error) {
 517                 dev_err(&pdev->dev,
 518                         "failed to register quiesce action, error: %d\n",
 519                         error);
 520                 return error;
 521         }
 522
 523         /*
 524          * If platform has specified that the button can be disabled,
 525          * we don't want it to share the interrupt line.
 526          */
 527         if (!button->can_disable)
 528                 irqflags |= IRQF_SHARED;
 529
 530         error = devm_request_any_context_irq(&pdev->dev, bdata->irq,
 531                                              isr, irqflags, desc, bdata);
 532         if (error < 0) {
 533                 dev_err(dev, "Unable to claim irq %d; error %d\n",
 534                         bdata->irq, error);
 535                 return error;
 536         }
 537
 538         return 0;
 539 }
 540
 541 static void gpio_keys_report_state(struct gpio_keys_drvdata *ddata)
 542 {
 543         struct input_dev *input = ddata->input;
 544         int i;
 545
 546         for (i = 0; i < ddata->pdata->nbuttons; i++) {
 547                 struct gpio_button_data *bdata = &ddata->data[i];
 548                 if (gpio_is_valid(bdata->button->gpio))
 549                         gpio_keys_gpio_report_event(bdata);
 550         }
 551         input_sync(input);
 552 }
 553
 554 static int gpio_keys_open(struct input_dev *input)
 555 {
 556         struct gpio_keys_drvdata *ddata = input_get_drvdata(input);
 557         const struct gpio_keys_platform_data *pdata = ddata->pdata;
 558         int error;
 559
 560         if (pdata->enable) {
 561                 error = pdata->enable(input->dev.parent);
 562                 if (error)
 563                         return error;
 564         }
 565
 566         /* Report current state of buttons that are connected to GPIOs */
 567         gpio_keys_report_state(ddata);
 568
 569         return 0;
 570 }
 571
 572 static void gpio_keys_close(struct input_dev *input)
 573 {
 574         struct gpio_keys_drvdata *ddata = input_get_drvdata(input);
 575         const struct gpio_keys_platform_data *pdata = ddata->pdata;
 576
 577         if (pdata->disable)
 578                 pdata->disable(input->dev.parent);
 579 }
 580
 581 /*
 582  * Handlers for alternative sources of platform_data
 583  */
 584
 585 #ifdef CONFIG_OF
 586 /*
 587  * Translate OpenFirmware node properties into platform_data
 588  */
 589 static struct gpio_keys_platform_data *
 590 gpio_keys_get_devtree_pdata(struct device *dev)
 591 {
 592         struct device_node *node, *pp;
 593         struct gpio_keys_platform_data *pdata;
 594         struct gpio_keys_button *button;
 595         int error;
 596         int nbuttons;
 597         int i;
 598
 599         node = dev->of_node;
 600         if (!node)
 601                 return ERR_PTR(-ENODEV);
 602
 603         nbuttons = of_get_child_count(node);
 604         if (nbuttons == 0)
 605                 return ERR_PTR(-ENODEV);
 606
 607         pdata = devm_kzalloc(dev,
 608                              sizeof(*pdata) + nbuttons * sizeof(*button),
 609                              GFP_KERNEL);
 610         if (!pdata)
 611                 return ERR_PTR(-ENOMEM);
 612
 613         pdata->buttons = (struct gpio_keys_button *)(pdata + 1);
 614         pdata->nbuttons = nbuttons;
 615
 616         pdata->rep = !!of_get_property(node, "autorepeat", NULL);
 617
 618         i = 0;
 619         for_each_child_of_node(node, pp) {
 620                 int gpio;
 621                 enum of_gpio_flags flags;
 622
 623                 if (!of_find_property(pp, "gpios", NULL)) {
 624                         pdata->nbuttons--;
 625                         dev_warn(dev, "Found button without gpios\n");
 626                         continue;
 627                 }
 628
 629                 gpio = of_get_gpio_flags(pp, 0, &flags);
 630                 if (gpio < 0) {
 631                         error = gpio;
 632                         if (error != -EPROBE_DEFER)
 633                                 dev_err(dev,
 634                                         "Failed to get gpio flags, error: %d\n",
 635                                         error);
 636                         return ERR_PTR(error);
 637                 }
 638
 639                 button = &pdata->buttons[i++];
 640
 641                 button->gpio = gpio;
 642                 button->active_low = flags & OF_GPIO_ACTIVE_LOW;
 643
 644                 if (of_property_read_u32(pp, "linux,code", &button->code)) {
 645                         dev_err(dev, "Button without keycode: 0x%x\n",
 646                                 button->gpio);
 647                         return ERR_PTR(-EINVAL);
 648                 }
 649
 650                 button->desc = of_get_property(pp, "label", NULL);
 651
 652                 if (of_property_read_u32(pp, "linux,input-type", &button->type))
 653                         button->type = EV_KEY;
 654
 655                 button->wakeup = !!of_get_property(pp, "gpio-key,wakeup", NULL);
 656
 657                 if (of_property_read_u32(pp, "debounce-interval",
 658                                          &button->debounce_interval))
 659                         button->debounce_interval = 5;
 660         }
 661
 662         if (pdata->nbuttons == 0)
 663                 return ERR_PTR(-EINVAL);
 664
 665         return pdata;
 666 }
 667
 668 static const struct of_device_id gpio_keys_of_match[] = {
 669         { .compatible = "gpio-keys", },
 670         { },
 671 };
 672 MODULE_DEVICE_TABLE(of, gpio_keys_of_match);
 673
 674 #else
 675
 676 static inline struct gpio_keys_platform_data *
 677 gpio_keys_get_devtree_pdata(struct device *dev)
 678 {
 679         return ERR_PTR(-ENODEV);
 680 }
 681
 682 #endif
 683
 684 static int gpio_keys_probe(struct platform_device *pdev)
 685 {
 686         struct device *dev = &pdev->dev;
 687         const struct gpio_keys_platform_data *pdata = dev_get_platdata(dev);
 688         struct gpio_keys_drvdata *ddata;
 689         struct input_dev *input;
 690         size_t size;
 691         int i, error;
 692         int wakeup = 0;
 693
 694         if (!pdata) {
 695                 pdata = gpio_keys_get_devtree_pdata(dev);
 696                 if (IS_ERR(pdata))
 697                         return PTR_ERR(pdata);
 698         }
 699
 700         size = sizeof(struct gpio_keys_drvdata) +
 701                         pdata->nbuttons * sizeof(struct gpio_button_data);
 702         ddata = devm_kzalloc(dev, size, GFP_KERNEL);
 703         if (!ddata) {
 704                 dev_err(dev, "failed to allocate state\n");
 705                 return -ENOMEM;
 706         }
 707
 708         input = devm_input_allocate_device(dev);
 709         if (!input) {
 710                 dev_err(dev, "failed to allocate input device\n");
 711                 return -ENOMEM;
 712         }
 713
 714         ddata->pdata = pdata;
 715         ddata->input = input;
 716         mutex_init(&ddata->disable_lock);
 717
 718         platform_set_drvdata(pdev, ddata);
 719         input_set_drvdata(input, ddata);
 720
 721         input->name = pdata->name ? : pdev->name;
 722         input->phys = "gpio-keys/input0";
 723         input->dev.parent = &pdev->dev;
 724         input->open = gpio_keys_open;
 725         input->close = gpio_keys_close;
 726
 727         input->id.bustype = BUS_HOST;
 728         input->id.vendor = 0x0001;
 729         input->id.product = 0x0001;
 730         input->id.version = 0x0100;
 731
 732         /* Enable auto repeat feature of Linux input subsystem */
 733         if (pdata->rep)
 734                 __set_bit(EV_REP, input->evbit);
 735
 736         for (i = 0; i < pdata->nbuttons; i++) {
 737                 const struct gpio_keys_button *button = &pdata->buttons[i];
 738                 struct gpio_button_data *bdata = &ddata->data[i];
 739
 740                 error = gpio_keys_setup_key(pdev, input, bdata, button);
 741                 if (error)
 742                         return error;
 743
 744                 if (button->wakeup)
 745                         wakeup = 1;
 746         }
 747
 748         error = sysfs_create_group(&pdev->dev.kobj, &gpio_keys_attr_group);
 749         if (error) {
 750                 dev_err(dev, "Unable to export keys/switches, error: %d\n",
 751                         error);
 752                 return error;
 753         }
 754
 755         error = input_register_device(input);
 756         if (error) {
 757                 dev_err(dev, "Unable to register input device, error: %d\n",
 758                         error);
 759                 goto err_remove_group;
 760         }
 761
 762         device_init_wakeup(&pdev->dev, wakeup);
 763
 764         return 0;
 765
 766 err_remove_group:
 767         sysfs_remove_group(&pdev->dev.kobj, &gpio_keys_attr_group);
 768         return error;
 769 }
 770
 771 static int gpio_keys_remove(struct platform_device *pdev)
 772 {
 773         sysfs_remove_group(&pdev->dev.kobj, &gpio_keys_attr_group);
 774
 775         device_init_wakeup(&pdev->dev, 0);
 776
 777         return 0;
 778 }
 779
 780 #ifdef CONFIG_PM_SLEEP
 781 static int gpio_keys_suspend(struct device *dev)
 782 {
 783         struct gpio_keys_drvdata *ddata = dev_get_drvdata(dev);
 784         struct input_dev *input = ddata->input;
 785         int i;
 786
 787         if (device_may_wakeup(dev)) {
 788                 for (i = 0; i < ddata->pdata->nbuttons; i++) {
 789                         struct gpio_button_data *bdata = &ddata->data[i];
 790                         if (bdata->button->wakeup)
 791                                 enable_irq_wake(bdata->irq);
 792                 }
 793         } else {
 794                 mutex_lock(&input->mutex);
 795                 if (input->users)
 796                         gpio_keys_close(input);
 797                 mutex_unlock(&input->mutex);
 798         }
 799
 800         return 0;
 801 }
 802
 803 static int gpio_keys_resume(struct device *dev)
 804 {
 805         struct gpio_keys_drvdata *ddata = dev_get_drvdata(dev);
 806         struct input_dev *input = ddata->input;
 807         int error = 0;
 808         int i;
 809
 810         if (device_may_wakeup(dev)) {
 811                 for (i = 0; i < ddata->pdata->nbuttons; i++) {
 812                         struct gpio_button_data *bdata = &ddata->data[i];
 813                         if (bdata->button->wakeup)
 814                                 disable_irq_wake(bdata->irq);
 815                 }
 816         } else {
 817                 mutex_lock(&input->mutex);
 818                 if (input->users)
 819                         error = gpio_keys_open(input);
 820                 mutex_unlock(&input->mutex);
 821         }
 822
 823         if (error)
 824                 return error;
 825
 826         gpio_keys_report_state(ddata);
 827         return 0;
 828 }
 829 #endif
 830
 831 static SIMPLE_DEV_PM_OPS(gpio_keys_pm_ops, gpio_keys_suspend, gpio_keys_resume);
 832
 833 static struct platform_driver gpio_keys_device_driver = {
 834         .probe          = gpio_keys_probe,
 835         .remove         = gpio_keys_remove,
 836         .driver         = {
 837                 .name   = "gpio-keys",
 838                 .owner  = THIS_MODULE,
 839                 .pm     = &gpio_keys_pm_ops,
 840                 .of_match_table = of_match_ptr(gpio_keys_of_match),
 841         }
 842 };
 843
 844 static int __init gpio_keys_init(void)
 845 {
 846         return platform_driver_register(&gpio_keys_device_driver);
 847 }
 848
 849 static void __exit gpio_keys_exit(void)
 850 {
 851         platform_driver_unregister(&gpio_keys_device_driver);
 852 }
 853
 854 late_initcall(gpio_keys_init);
 855 module_exit(gpio_keys_exit);
 856
 857 MODULE_LICENSE("GPL");
 858 MODULE_AUTHOR("Phil Blundell <pb@handhelds.org>");
 859 MODULE_DESCRIPTION("Keyboard driver for GPIOs");
 860 MODULE_ALIAS("platform:gpio-keys");