drivers/input/keyboard/gpio_keys.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Driver for keys on GPIO lines capable of generating interrupts.
   4  *
   5  * Copyright 2005 Phil Blundell
   6  * Copyright 2010, 2011 David Jander <david@protonic.nl>
   7  */
   8
   9 #include <linux/module.h>
  10
  11 #include <linux/hrtimer.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/slab.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/gpio_keys.h>
  25 #include <linux/workqueue.h>
  26 #include <linux/gpio.h>
  27 #include <linux/gpio/consumer.h>
  28 #include <linux/of.h>
  29 #include <linux/of_irq.h>
  30 #include <linux/spinlock.h>
  31 #include <dt-bindings/input/gpio-keys.h>
  32
  33 struct gpio_button_data {
  34         const struct gpio_keys_button *button;
  35         struct input_dev *input;
  36         struct gpio_desc *gpiod;
  37
  38         unsigned short *code;
  39
  40         struct hrtimer release_timer;
  41         unsigned int release_delay;     /* in msecs, for IRQ-only buttons */
  42
  43         struct delayed_work work;
  44         struct hrtimer debounce_timer;
  45         unsigned int software_debounce; /* in msecs, for GPIO-driven buttons */
  46
  47         unsigned int irq;
  48         unsigned int wakeirq;
  49         unsigned int wakeup_trigger_type;
  50
  51         spinlock_t lock;
  52         bool disabled;
  53         bool key_pressed;
  54         bool suspended;
  55         bool debounce_use_hrtimer;
  56 };
  57
  58 struct gpio_keys_drvdata {
  59         const struct gpio_keys_platform_data *pdata;
  60         struct input_dev *input;
  61         struct mutex disable_lock;
  62         unsigned short *keymap;
  63         struct gpio_button_data data[];
  64 };
  65
  66 /*
  67  * SYSFS interface for enabling/disabling keys and switches:
  68  *
  69  * There are 4 attributes under /sys/devices/platform/gpio-keys/
  70  *      keys [ro]              - bitmap of keys (EV_KEY) which can be
  71  *                               disabled
  72  *      switches [ro]          - bitmap of switches (EV_SW) which can be
  73  *                               disabled
  74  *      disabled_keys [rw]     - bitmap of keys currently disabled
  75  *      disabled_switches [rw] - bitmap of switches currently disabled
  76  *
  77  * Userland can change these values and hence disable event generation
  78  * for each key (or switch). Disabling a key means its interrupt line
  79  * is disabled.
  80  *
  81  * For example, if we have following switches set up as gpio-keys:
  82  *      SW_DOCK = 5
  83  *      SW_CAMERA_LENS_COVER = 9
  84  *      SW_KEYPAD_SLIDE = 10
  85  *      SW_FRONT_PROXIMITY = 11
  86  * This is read from switches:
  87  *      11-9,5
  88  * Next we want to disable proximity (11) and dock (5), we write:
  89  *      11,5
  90  * to file disabled_switches. Now proximity and dock IRQs are disabled.
  91  * This can be verified by reading the file disabled_switches:
  92  *      11,5
  93  * If we now want to enable proximity (11) switch we write:
  94  *      5
  95  * to disabled_switches.
  96  *
  97  * We can disable only those keys which don't allow sharing the irq.
  98  */
  99
 100 /**
 101  * get_n_events_by_type() - returns maximum number of events per @type
 102  * @type: type of button (%EV_KEY, %EV_SW)
 103  *
 104  * Return value of this function can be used to allocate bitmap
 105  * large enough to hold all bits for given type.
 106  */
 107 static int get_n_events_by_type(int type)
 108 {
 109         BUG_ON(type != EV_SW && type != EV_KEY);
 110
 111         return (type == EV_KEY) ? KEY_CNT : SW_CNT;
 112 }
 113
 114 /**
 115  * get_bm_events_by_type() - returns bitmap of supported events per @type
 116  * @dev: input device from which bitmap is retrieved
 117  * @type: type of button (%EV_KEY, %EV_SW)
 118  *
 119  * Return value of this function can be used to allocate bitmap
 120  * large enough to hold all bits for given type.
 121  */
 122 static const unsigned long *get_bm_events_by_type(struct input_dev *dev,
 123                                                   int type)
 124 {
 125         BUG_ON(type != EV_SW && type != EV_KEY);
 126
 127         return (type == EV_KEY) ? dev->keybit : dev->swbit;
 128 }
 129
 130 static void gpio_keys_quiesce_key(void *data)
 131 {
 132         struct gpio_button_data *bdata = data;
 133
 134         if (!bdata->gpiod)
 135                 hrtimer_cancel(&bdata->release_timer);
 136         else if (bdata->debounce_use_hrtimer)
 137                 hrtimer_cancel(&bdata->debounce_timer);
 138         else
 139                 cancel_delayed_work_sync(&bdata->work);
 140 }
 141
 142 /**
 143  * gpio_keys_disable_button() - disables given GPIO button
 144  * @bdata: button data for button to be disabled
 145  *
 146  * Disables button pointed by @bdata. This is done by masking
 147  * IRQ line. After this function is called, button won't generate
 148  * input events anymore. Note that one can only disable buttons
 149  * that don't share IRQs.
 150  *
 151  * Make sure that @bdata->disable_lock is locked when entering
 152  * this function to avoid races when concurrent threads are
 153  * disabling buttons at the same time.
 154  */
 155 static void gpio_keys_disable_button(struct gpio_button_data *bdata)
 156 {
 157         if (!bdata->disabled) {
 158                 /*
 159                  * Disable IRQ and associated timer/work structure.
 160                  */
 161                 disable_irq(bdata->irq);
 162                 gpio_keys_quiesce_key(bdata);
 163                 bdata->disabled = true;
 164         }
 165 }
 166
 167 /**
 168  * gpio_keys_enable_button() - enables given GPIO button
 169  * @bdata: button data for button to be disabled
 170  *
 171  * Enables given button pointed by @bdata.
 172  *
 173  * Make sure that @bdata->disable_lock is locked when entering
 174  * this function to avoid races with concurrent threads trying
 175  * to enable the same button at the same time.
 176  */
 177 static void gpio_keys_enable_button(struct gpio_button_data *bdata)
 178 {
 179         if (bdata->disabled) {
 180                 enable_irq(bdata->irq);
 181                 bdata->disabled = false;
 182         }
 183 }
 184
 185 /**
 186  * gpio_keys_attr_show_helper() - fill in stringified bitmap of buttons
 187  * @ddata: pointer to drvdata
 188  * @buf: buffer where stringified bitmap is written
 189  * @type: button type (%EV_KEY, %EV_SW)
 190  * @only_disabled: does caller want only those buttons that are
 191  *                 currently disabled or all buttons that can be
 192  *                 disabled
 193  *
 194  * This function writes buttons that can be disabled to @buf. If
 195  * @only_disabled is true, then @buf contains only those buttons
 196  * that are currently disabled. Returns 0 on success or negative
 197  * errno on failure.
 198  */
 199 static ssize_t gpio_keys_attr_show_helper(struct gpio_keys_drvdata *ddata,
 200                                           char *buf, unsigned int type,
 201                                           bool only_disabled)
 202 {
 203         int n_events = get_n_events_by_type(type);
 204         unsigned long *bits;
 205         ssize_t ret;
 206         int i;
 207
 208         bits = bitmap_zalloc(n_events, GFP_KERNEL);
 209         if (!bits)
 210                 return -ENOMEM;
 211
 212         for (i = 0; i < ddata->pdata->nbuttons; i++) {
 213                 struct gpio_button_data *bdata = &ddata->data[i];
 214
 215                 if (bdata->button->type != type)
 216                         continue;
 217
 218                 if (only_disabled && !bdata->disabled)
 219                         continue;
 220
 221                 __set_bit(*bdata->code, bits);
 222         }
 223
 224         ret = scnprintf(buf, PAGE_SIZE - 1, "%*pbl", n_events, bits);
 225         buf[ret++] = '\n';
 226         buf[ret] = '\0';
 227
 228         bitmap_free(bits);
 229
 230         return ret;
 231 }
 232
 233 /**
 234  * gpio_keys_attr_store_helper() - enable/disable buttons based on given bitmap
 235  * @ddata: pointer to drvdata
 236  * @buf: buffer from userspace that contains stringified bitmap
 237  * @type: button type (%EV_KEY, %EV_SW)
 238  *
 239  * This function parses stringified bitmap from @buf and disables/enables
 240  * GPIO buttons accordingly. Returns 0 on success and negative error
 241  * on failure.
 242  */
 243 static ssize_t gpio_keys_attr_store_helper(struct gpio_keys_drvdata *ddata,
 244                                            const char *buf, unsigned int type)
 245 {
 246         int n_events = get_n_events_by_type(type);
 247         const unsigned long *bitmap = get_bm_events_by_type(ddata->input, type);
 248         unsigned long *bits;
 249         ssize_t error;
 250         int i;
 251
 252         bits = bitmap_alloc(n_events, GFP_KERNEL);
 253         if (!bits)
 254                 return -ENOMEM;
 255
 256         error = bitmap_parselist(buf, bits, n_events);
 257         if (error)
 258                 goto out;
 259
 260         /* First validate */
 261         if (!bitmap_subset(bits, bitmap, n_events)) {
 262                 error = -EINVAL;
 263                 goto out;
 264         }
 265
 266         for (i = 0; i < ddata->pdata->nbuttons; i++) {
 267                 struct gpio_button_data *bdata = &ddata->data[i];
 268
 269                 if (bdata->button->type != type)
 270                         continue;
 271
 272                 if (test_bit(*bdata->code, bits) &&
 273                     !bdata->button->can_disable) {
 274                         error = -EINVAL;
 275                         goto out;
 276                 }
 277         }
 278
 279         mutex_lock(&ddata->disable_lock);
 280
 281         for (i = 0; i < ddata->pdata->nbuttons; i++) {
 282                 struct gpio_button_data *bdata = &ddata->data[i];
 283
 284                 if (bdata->button->type != type)
 285                         continue;
 286
 287                 if (test_bit(*bdata->code, bits))
 288                         gpio_keys_disable_button(bdata);
 289                 else
 290                         gpio_keys_enable_button(bdata);
 291         }
 292
 293         mutex_unlock(&ddata->disable_lock);
 294
 295 out:
 296         bitmap_free(bits);
 297         return error;
 298 }
 299
 300 #define ATTR_SHOW_FN(name, type, only_disabled)                         \
 301 static ssize_t gpio_keys_show_##name(struct device *dev,                \
 302                                      struct device_attribute *attr,     \
 303                                      char *buf)                         \
 304 {                                                                       \
 305         struct platform_device *pdev = to_platform_device(dev);         \
 306         struct gpio_keys_drvdata *ddata = platform_get_drvdata(pdev);   \
 307                                                                         \
 308         return gpio_keys_attr_show_helper(ddata, buf,                   \
 309                                           type, only_disabled);         \
 310 }
 311
 312 ATTR_SHOW_FN(keys, EV_KEY, false);
 313 ATTR_SHOW_FN(switches, EV_SW, false);
 314 ATTR_SHOW_FN(disabled_keys, EV_KEY, true);
 315 ATTR_SHOW_FN(disabled_switches, EV_SW, true);
 316
 317 /*
 318  * ATTRIBUTES:
 319  *
 320  * /sys/devices/platform/gpio-keys/keys [ro]
 321  * /sys/devices/platform/gpio-keys/switches [ro]
 322  */
 323 static DEVICE_ATTR(keys, S_IRUGO, gpio_keys_show_keys, NULL);
 324 static DEVICE_ATTR(switches, S_IRUGO, gpio_keys_show_switches, NULL);
 325
 326 #define ATTR_STORE_FN(name, type)                                       \
 327 static ssize_t gpio_keys_store_##name(struct device *dev,               \
 328                                       struct device_attribute *attr,    \
 329                                       const char *buf,                  \
 330                                       size_t count)                     \
 331 {                                                                       \
 332         struct platform_device *pdev = to_platform_device(dev);         \
 333         struct gpio_keys_drvdata *ddata = platform_get_drvdata(pdev);   \
 334         ssize_t error;                                                  \
 335                                                                         \
 336         error = gpio_keys_attr_store_helper(ddata, buf, type);          \
 337         if (error)                                                      \
 338                 return error;                                           \
 339                                                                         \
 340         return count;                                                   \
 341 }
 342
 343 ATTR_STORE_FN(disabled_keys, EV_KEY);
 344 ATTR_STORE_FN(disabled_switches, EV_SW);
 345
 346 /*
 347  * ATTRIBUTES:
 348  *
 349  * /sys/devices/platform/gpio-keys/disabled_keys [rw]
 350  * /sys/devices/platform/gpio-keys/disables_switches [rw]
 351  */
 352 static DEVICE_ATTR(disabled_keys, S_IWUSR | S_IRUGO,
 353                    gpio_keys_show_disabled_keys,
 354                    gpio_keys_store_disabled_keys);
 355 static DEVICE_ATTR(disabled_switches, S_IWUSR | S_IRUGO,
 356                    gpio_keys_show_disabled_switches,
 357                    gpio_keys_store_disabled_switches);
 358
 359 static struct attribute *gpio_keys_attrs[] = {
 360         &dev_attr_keys.attr,
 361         &dev_attr_switches.attr,
 362         &dev_attr_disabled_keys.attr,
 363         &dev_attr_disabled_switches.attr,
 364         NULL,
 365 };
 366 ATTRIBUTE_GROUPS(gpio_keys);
 367
 368 static void gpio_keys_gpio_report_event(struct gpio_button_data *bdata)
 369 {
 370         const struct gpio_keys_button *button = bdata->button;
 371         struct input_dev *input = bdata->input;
 372         unsigned int type = button->type ?: EV_KEY;
 373         int state;
 374
 375         state = bdata->debounce_use_hrtimer ?
 376                         gpiod_get_value(bdata->gpiod) :
 377                         gpiod_get_value_cansleep(bdata->gpiod);
 378         if (state < 0) {
 379                 dev_err(input->dev.parent,
 380                         "failed to get gpio state: %d\n", state);
 381                 return;
 382         }
 383
 384         if (type == EV_ABS) {
 385                 if (state)
 386                         input_event(input, type, button->code, button->value);
 387         } else {
 388                 input_event(input, type, *bdata->code, state);
 389         }
 390 }
 391
 392 static void gpio_keys_debounce_event(struct gpio_button_data *bdata)
 393 {
 394         gpio_keys_gpio_report_event(bdata);
 395         input_sync(bdata->input);
 396
 397         if (bdata->button->wakeup)
 398                 pm_relax(bdata->input->dev.parent);
 399 }
 400
 401 static void gpio_keys_gpio_work_func(struct work_struct *work)
 402 {
 403         struct gpio_button_data *bdata =
 404                 container_of(work, struct gpio_button_data, work.work);
 405
 406         gpio_keys_debounce_event(bdata);
 407 }
 408
 409 static enum hrtimer_restart gpio_keys_debounce_timer(struct hrtimer *t)
 410 {
 411         struct gpio_button_data *bdata =
 412                 container_of(t, struct gpio_button_data, debounce_timer);
 413
 414         gpio_keys_debounce_event(bdata);
 415
 416         return HRTIMER_NORESTART;
 417 }
 418
 419 static irqreturn_t gpio_keys_gpio_isr(int irq, void *dev_id)
 420 {
 421         struct gpio_button_data *bdata = dev_id;
 422
 423         BUG_ON(irq != bdata->irq);
 424
 425         if (bdata->button->wakeup) {
 426                 const struct gpio_keys_button *button = bdata->button;
 427
 428                 pm_stay_awake(bdata->input->dev.parent);
 429                 if (bdata->suspended  &&
 430                     (button->type == 0 || button->type == EV_KEY)) {
 431                         /*
 432                          * Simulate wakeup key press in case the key has
 433                          * already released by the time we got interrupt
 434                          * handler to run.
 435                          */
 436                         input_report_key(bdata->input, button->code, 1);
 437                 }
 438         }
 439
 440         if (bdata->debounce_use_hrtimer) {
 441                 hrtimer_start(&bdata->debounce_timer,
 442                               ms_to_ktime(bdata->software_debounce),
 443                               HRTIMER_MODE_REL);
 444         } else {
 445                 mod_delayed_work(system_wq,
 446                                  &bdata->work,
 447                                  msecs_to_jiffies(bdata->software_debounce));
 448         }
 449
 450         return IRQ_HANDLED;
 451 }
 452
 453 static enum hrtimer_restart gpio_keys_irq_timer(struct hrtimer *t)
 454 {
 455         struct gpio_button_data *bdata = container_of(t,
 456                                                       struct gpio_button_data,
 457                                                       release_timer);
 458         struct input_dev *input = bdata->input;
 459
 460         if (bdata->key_pressed) {
 461                 input_report_key(input, *bdata->code, 0);
 462                 input_sync(input);
 463                 bdata->key_pressed = false;
 464         }
 465
 466         return HRTIMER_NORESTART;
 467 }
 468
 469 static irqreturn_t gpio_keys_irq_isr(int irq, void *dev_id)
 470 {
 471         struct gpio_button_data *bdata = dev_id;
 472         struct input_dev *input = bdata->input;
 473         unsigned long flags;
 474
 475         BUG_ON(irq != bdata->irq);
 476
 477         spin_lock_irqsave(&bdata->lock, flags);
 478
 479         if (!bdata->key_pressed) {
 480                 if (bdata->button->wakeup)
 481                         pm_wakeup_event(bdata->input->dev.parent, 0);
 482
 483                 input_report_key(input, *bdata->code, 1);
 484                 input_sync(input);
 485
 486                 if (!bdata->release_delay) {
 487                         input_report_key(input, *bdata->code, 0);
 488                         input_sync(input);
 489                         goto out;
 490                 }
 491
 492                 bdata->key_pressed = true;
 493         }
 494
 495         if (bdata->release_delay)
 496                 hrtimer_start(&bdata->release_timer,
 497                               ms_to_ktime(bdata->release_delay),
 498                               HRTIMER_MODE_REL_HARD);
 499 out:
 500         spin_unlock_irqrestore(&bdata->lock, flags);
 501         return IRQ_HANDLED;
 502 }
 503
 504 static int gpio_keys_setup_key(struct platform_device *pdev,
 505                                 struct input_dev *input,
 506                                 struct gpio_keys_drvdata *ddata,
 507                                 const struct gpio_keys_button *button,
 508                                 int idx,
 509                                 struct fwnode_handle *child)
 510 {
 511         const char *desc = button->desc ? button->desc : "gpio_keys";
 512         struct device *dev = &pdev->dev;
 513         struct gpio_button_data *bdata = &ddata->data[idx];
 514         irq_handler_t isr;
 515         unsigned long irqflags;
 516         const char *wakedesc;
 517         int irq;
 518         int error;
 519
 520         bdata->input = input;
 521         bdata->button = button;
 522         spin_lock_init(&bdata->lock);
 523
 524         if (child) {
 525                 bdata->gpiod = devm_fwnode_gpiod_get(dev, child,
 526                                                      NULL, GPIOD_IN, desc);
 527                 if (IS_ERR(bdata->gpiod)) {
 528                         error = PTR_ERR(bdata->gpiod);
 529                         if (error != -ENOENT)
 530                                 return dev_err_probe(dev, error,
 531                                                      "failed to get gpio\n");
 532
 533                         /*
 534                          * GPIO is optional, we may be dealing with
 535                          * purely interrupt-driven setup.
 536                          */
 537                         bdata->gpiod = NULL;
 538                 }
 539         } else if (gpio_is_valid(button->gpio)) {
 540                 /*
 541                  * Legacy GPIO number, so request the GPIO here and
 542                  * convert it to descriptor.
 543                  */
 544                 unsigned flags = GPIOF_IN;
 545
 546                 if (button->active_low)
 547                         flags |= GPIOF_ACTIVE_LOW;
 548
 549                 error = devm_gpio_request_one(dev, button->gpio, flags, desc);
 550                 if (error < 0) {
 551                         dev_err(dev, "Failed to request GPIO %d, error %d\n",
 552                                 button->gpio, error);
 553                         return error;
 554                 }
 555
 556                 bdata->gpiod = gpio_to_desc(button->gpio);
 557                 if (!bdata->gpiod)
 558                         return -EINVAL;
 559         }
 560
 561         if (bdata->gpiod) {
 562                 bool active_low = gpiod_is_active_low(bdata->gpiod);
 563
 564                 if (button->debounce_interval) {
 565                         error = gpiod_set_debounce(bdata->gpiod,
 566                                         button->debounce_interval * 1000);
 567                         /* use timer if gpiolib doesn't provide debounce */
 568                         if (error < 0)
 569                                 bdata->software_debounce =
 570                                                 button->debounce_interval;
 571
 572                         /*
 573                          * If reading the GPIO won't sleep, we can use a
 574                          * hrtimer instead of a standard timer for the software
 575                          * debounce, to reduce the latency as much as possible.
 576                          */
 577                         bdata->debounce_use_hrtimer =
 578                                         !gpiod_cansleep(bdata->gpiod);
 579                 }
 580
 581                 /*
 582                  * If an interrupt was specified, use it instead of the gpio
 583                  * interrupt and use the gpio for reading the state. A separate
 584                  * interrupt may be used as the main button interrupt for
 585                  * runtime PM to detect events also in deeper idle states. If a
 586                  * dedicated wakeirq is used for system suspend only, see below
 587                  * for bdata->wakeirq setup.
 588                  */
 589                 if (button->irq) {
 590                         bdata->irq = button->irq;
 591                 } else {
 592                         irq = gpiod_to_irq(bdata->gpiod);
 593                         if (irq < 0) {
 594                                 error = irq;
 595                                 dev_err_probe(dev, error,
 596                                               "Unable to get irq number for GPIO %d\n",
 597                                               button->gpio);
 598                                 return error;
 599                         }
 600                         bdata->irq = irq;
 601                 }
 602
 603                 INIT_DELAYED_WORK(&bdata->work, gpio_keys_gpio_work_func);
 604
 605                 hrtimer_init(&bdata->debounce_timer,
 606                              CLOCK_REALTIME, HRTIMER_MODE_REL);
 607                 bdata->debounce_timer.function = gpio_keys_debounce_timer;
 608
 609                 isr = gpio_keys_gpio_isr;
 610                 irqflags = IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING;
 611
 612                 switch (button->wakeup_event_action) {
 613                 case EV_ACT_ASSERTED:
 614                         bdata->wakeup_trigger_type = active_low ?
 615                                 IRQ_TYPE_EDGE_FALLING : IRQ_TYPE_EDGE_RISING;
 616                         break;
 617                 case EV_ACT_DEASSERTED:
 618                         bdata->wakeup_trigger_type = active_low ?
 619                                 IRQ_TYPE_EDGE_RISING : IRQ_TYPE_EDGE_FALLING;
 620                         break;
 621                 case EV_ACT_ANY:
 622                 default:
 623                         /*
 624                          * For other cases, we are OK letting suspend/resume
 625                          * not reconfigure the trigger type.
 626                          */
 627                         break;
 628                 }
 629         } else {
 630                 if (!button->irq) {
 631                         dev_err(dev, "Found button without gpio or irq\n");
 632                         return -EINVAL;
 633                 }
 634
 635                 bdata->irq = button->irq;
 636
 637                 if (button->type && button->type != EV_KEY) {
 638                         dev_err(dev, "Only EV_KEY allowed for IRQ buttons.\n");
 639                         return -EINVAL;
 640                 }
 641
 642                 bdata->release_delay = button->debounce_interval;
 643                 hrtimer_init(&bdata->release_timer,
 644                              CLOCK_REALTIME, HRTIMER_MODE_REL_HARD);
 645                 bdata->release_timer.function = gpio_keys_irq_timer;
 646
 647                 isr = gpio_keys_irq_isr;
 648                 irqflags = 0;
 649
 650                 /*
 651                  * For IRQ buttons, there is no interrupt for release.
 652                  * So we don't need to reconfigure the trigger type for wakeup.
 653                  */
 654         }
 655
 656         bdata->code = &ddata->keymap[idx];
 657         *bdata->code = button->code;
 658         input_set_capability(input, button->type ?: EV_KEY, *bdata->code);
 659
 660         /*
 661          * Install custom action to cancel release timer and
 662          * workqueue item.
 663          */
 664         error = devm_add_action(dev, gpio_keys_quiesce_key, bdata);
 665         if (error) {
 666                 dev_err(dev, "failed to register quiesce action, error: %d\n",
 667                         error);
 668                 return error;
 669         }
 670
 671         /*
 672          * If platform has specified that the button can be disabled,
 673          * we don't want it to share the interrupt line.
 674          */
 675         if (!button->can_disable)
 676                 irqflags |= IRQF_SHARED;
 677
 678         error = devm_request_any_context_irq(dev, bdata->irq, isr, irqflags,
 679                                              desc, bdata);
 680         if (error < 0) {
 681                 dev_err(dev, "Unable to claim irq %d; error %d\n",
 682                         bdata->irq, error);
 683                 return error;
 684         }
 685
 686         if (!button->wakeirq)
 687                 return 0;
 688
 689         /* Use :wakeup suffix like drivers/base/power/wakeirq.c does */
 690         wakedesc = devm_kasprintf(dev, GFP_KERNEL, "%s:wakeup", desc);
 691         if (!wakedesc)
 692                 return -ENOMEM;
 693
 694         bdata->wakeirq = button->wakeirq;
 695         irqflags |= IRQF_NO_SUSPEND;
 696
 697         /*
 698          * Wakeirq shares the handler with the main interrupt, it's only
 699          * active during system suspend. See gpio_keys_button_enable_wakeup()
 700          * and gpio_keys_button_disable_wakeup().
 701          */
 702         error = devm_request_any_context_irq(dev, bdata->wakeirq, isr,
 703                                              irqflags, wakedesc, bdata);
 704         if (error < 0) {
 705                 dev_err(dev, "Unable to claim wakeirq %d; error %d\n",
 706                         bdata->irq, error);
 707                 return error;
 708         }
 709
 710         /*
 711          * Disable wakeirq until suspend. IRQF_NO_AUTOEN won't work if
 712          * IRQF_SHARED was set based on !button->can_disable.
 713          */
 714         disable_irq(bdata->wakeirq);
 715
 716         return 0;
 717 }
 718
 719 static void gpio_keys_report_state(struct gpio_keys_drvdata *ddata)
 720 {
 721         struct input_dev *input = ddata->input;
 722         int i;
 723
 724         for (i = 0; i < ddata->pdata->nbuttons; i++) {
 725                 struct gpio_button_data *bdata = &ddata->data[i];
 726                 if (bdata->gpiod)
 727                         gpio_keys_gpio_report_event(bdata);
 728         }
 729         input_sync(input);
 730 }
 731
 732 static int gpio_keys_open(struct input_dev *input)
 733 {
 734         struct gpio_keys_drvdata *ddata = input_get_drvdata(input);
 735         const struct gpio_keys_platform_data *pdata = ddata->pdata;
 736         int error;
 737
 738         if (pdata->enable) {
 739                 error = pdata->enable(input->dev.parent);
 740                 if (error)
 741                         return error;
 742         }
 743
 744         /* Report current state of buttons that are connected to GPIOs */
 745         gpio_keys_report_state(ddata);
 746
 747         return 0;
 748 }
 749
 750 static void gpio_keys_close(struct input_dev *input)
 751 {
 752         struct gpio_keys_drvdata *ddata = input_get_drvdata(input);
 753         const struct gpio_keys_platform_data *pdata = ddata->pdata;
 754
 755         if (pdata->disable)
 756                 pdata->disable(input->dev.parent);
 757 }
 758
 759 /*
 760  * Handlers for alternative sources of platform_data
 761  */
 762
 763 /*
 764  * Translate properties into platform_data
 765  */
 766 static struct gpio_keys_platform_data *
 767 gpio_keys_get_devtree_pdata(struct device *dev)
 768 {
 769         struct gpio_keys_platform_data *pdata;
 770         struct gpio_keys_button *button;
 771         struct fwnode_handle *child;
 772         int nbuttons, irq;
 773
 774         nbuttons = device_get_child_node_count(dev);
 775         if (nbuttons == 0)
 776                 return ERR_PTR(-ENODEV);
 777
 778         pdata = devm_kzalloc(dev,
 779                              sizeof(*pdata) + nbuttons * sizeof(*button),
 780                              GFP_KERNEL);
 781         if (!pdata)
 782                 return ERR_PTR(-ENOMEM);
 783
 784         button = (struct gpio_keys_button *)(pdata + 1);
 785
 786         pdata->buttons = button;
 787         pdata->nbuttons = nbuttons;
 788
 789         pdata->rep = device_property_read_bool(dev, "autorepeat");
 790
 791         device_property_read_string(dev, "label", &pdata->name);
 792
 793         device_for_each_child_node(dev, child) {
 794                 if (is_of_node(child)) {
 795                         irq = of_irq_get_byname(to_of_node(child), "irq");
 796                         if (irq > 0)
 797                                 button->irq = irq;
 798
 799                         irq = of_irq_get_byname(to_of_node(child), "wakeup");
 800                         if (irq > 0)
 801                                 button->wakeirq = irq;
 802
 803                         if (!button->irq && !button->wakeirq)
 804                                 button->irq =
 805                                         irq_of_parse_and_map(to_of_node(child), 0);
 806                 }
 807
 808                 if (fwnode_property_read_u32(child, "linux,code",
 809                                              &button->code)) {
 810                         dev_err(dev, "Button without keycode\n");
 811                         fwnode_handle_put(child);
 812                         return ERR_PTR(-EINVAL);
 813                 }
 814
 815                 fwnode_property_read_string(child, "label", &button->desc);
 816
 817                 if (fwnode_property_read_u32(child, "linux,input-type",
 818                                              &button->type))
 819                         button->type = EV_KEY;
 820
 821                 fwnode_property_read_u32(child, "linux,input-value",
 822                                          (u32 *)&button->value);
 823
 824                 button->wakeup =
 825                         fwnode_property_read_bool(child, "wakeup-source") ||
 826                         /* legacy name */
 827                         fwnode_property_read_bool(child, "gpio-key,wakeup");
 828
 829                 fwnode_property_read_u32(child, "wakeup-event-action",
 830                                          &button->wakeup_event_action);
 831
 832                 button->can_disable =
 833                         fwnode_property_read_bool(child, "linux,can-disable");
 834
 835                 if (fwnode_property_read_u32(child, "debounce-interval",
 836                                          &button->debounce_interval))
 837                         button->debounce_interval = 5;
 838
 839                 button++;
 840         }
 841
 842         return pdata;
 843 }
 844
 845 static const struct of_device_id gpio_keys_of_match[] = {
 846         { .compatible = "gpio-keys", },
 847         { },
 848 };
 849 MODULE_DEVICE_TABLE(of, gpio_keys_of_match);
 850
 851 static int gpio_keys_probe(struct platform_device *pdev)
 852 {
 853         struct device *dev = &pdev->dev;
 854         const struct gpio_keys_platform_data *pdata = dev_get_platdata(dev);
 855         struct fwnode_handle *child = NULL;
 856         struct gpio_keys_drvdata *ddata;
 857         struct input_dev *input;
 858         int i, error;
 859         int wakeup = 0;
 860
 861         if (!pdata) {
 862                 pdata = gpio_keys_get_devtree_pdata(dev);
 863                 if (IS_ERR(pdata))
 864                         return PTR_ERR(pdata);
 865         }
 866
 867         ddata = devm_kzalloc(dev, struct_size(ddata, data, pdata->nbuttons),
 868                              GFP_KERNEL);
 869         if (!ddata) {
 870                 dev_err(dev, "failed to allocate state\n");
 871                 return -ENOMEM;
 872         }
 873
 874         ddata->keymap = devm_kcalloc(dev,
 875                                      pdata->nbuttons, sizeof(ddata->keymap[0]),
 876                                      GFP_KERNEL);
 877         if (!ddata->keymap)
 878                 return -ENOMEM;
 879
 880         input = devm_input_allocate_device(dev);
 881         if (!input) {
 882                 dev_err(dev, "failed to allocate input device\n");
 883                 return -ENOMEM;
 884         }
 885
 886         ddata->pdata = pdata;
 887         ddata->input = input;
 888         mutex_init(&ddata->disable_lock);
 889
 890         platform_set_drvdata(pdev, ddata);
 891         input_set_drvdata(input, ddata);
 892
 893         input->name = pdata->name ? : pdev->name;
 894         input->phys = "gpio-keys/input0";
 895         input->dev.parent = dev;
 896         input->open = gpio_keys_open;
 897         input->close = gpio_keys_close;
 898
 899         input->id.bustype = BUS_HOST;
 900         input->id.vendor = 0x0001;
 901         input->id.product = 0x0001;
 902         input->id.version = 0x0100;
 903
 904         input->keycode = ddata->keymap;
 905         input->keycodesize = sizeof(ddata->keymap[0]);
 906         input->keycodemax = pdata->nbuttons;
 907
 908         /* Enable auto repeat feature of Linux input subsystem */
 909         if (pdata->rep)
 910                 __set_bit(EV_REP, input->evbit);
 911
 912         for (i = 0; i < pdata->nbuttons; i++) {
 913                 const struct gpio_keys_button *button = &pdata->buttons[i];
 914
 915                 if (!dev_get_platdata(dev)) {
 916                         child = device_get_next_child_node(dev, child);
 917                         if (!child) {
 918                                 dev_err(dev,
 919                                         "missing child device node for entry %d\n",
 920                                         i);
 921                                 return -EINVAL;
 922                         }
 923                 }
 924
 925                 error = gpio_keys_setup_key(pdev, input, ddata,
 926                                             button, i, child);
 927                 if (error) {
 928                         fwnode_handle_put(child);
 929                         return error;
 930                 }
 931
 932                 if (button->wakeup)
 933                         wakeup = 1;
 934         }
 935
 936         fwnode_handle_put(child);
 937
 938         error = input_register_device(input);
 939         if (error) {
 940                 dev_err(dev, "Unable to register input device, error: %d\n",
 941                         error);
 942                 return error;
 943         }
 944
 945         device_init_wakeup(dev, wakeup);
 946
 947         return 0;
 948 }
 949
 950 static int __maybe_unused
 951 gpio_keys_button_enable_wakeup(struct gpio_button_data *bdata)
 952 {
 953         int error;
 954
 955         error = enable_irq_wake(bdata->irq);
 956         if (error) {
 957                 dev_err(bdata->input->dev.parent,
 958                         "failed to configure IRQ %d as wakeup source: %d\n",
 959                         bdata->irq, error);
 960                 return error;
 961         }
 962
 963         if (bdata->wakeup_trigger_type) {
 964                 error = irq_set_irq_type(bdata->irq,
 965                                          bdata->wakeup_trigger_type);
 966                 if (error) {
 967                         dev_err(bdata->input->dev.parent,
 968                                 "failed to set wakeup trigger %08x for IRQ %d: %d\n",
 969                                 bdata->wakeup_trigger_type, bdata->irq, error);
 970                         disable_irq_wake(bdata->irq);
 971                         return error;
 972                 }
 973         }
 974
 975         if (bdata->wakeirq) {
 976                 enable_irq(bdata->wakeirq);
 977                 disable_irq(bdata->irq);
 978         }
 979
 980         return 0;
 981 }
 982
 983 static void __maybe_unused
 984 gpio_keys_button_disable_wakeup(struct gpio_button_data *bdata)
 985 {
 986         int error;
 987
 988         if (bdata->wakeirq) {
 989                 enable_irq(bdata->irq);
 990                 disable_irq(bdata->wakeirq);
 991         }
 992
 993         /*
 994          * The trigger type is always both edges for gpio-based keys and we do
 995          * not support changing wakeup trigger for interrupt-based keys.
 996          */
 997         if (bdata->wakeup_trigger_type) {
 998                 error = irq_set_irq_type(bdata->irq, IRQ_TYPE_EDGE_BOTH);
 999                 if (error)
1000                         dev_warn(bdata->input->dev.parent,
1001                                  "failed to restore interrupt trigger for IRQ %d: %d\n",
1002                                  bdata->irq, error);
1003         }
1004
1005         error = disable_irq_wake(bdata->irq);
1006         if (error)
1007                 dev_warn(bdata->input->dev.parent,
1008                          "failed to disable IRQ %d as wake source: %d\n",
1009                          bdata->irq, error);
1010 }
1011
1012 static int __maybe_unused
1013 gpio_keys_enable_wakeup(struct gpio_keys_drvdata *ddata)
1014 {
1015         struct gpio_button_data *bdata;
1016         int error;
1017         int i;
1018
1019         for (i = 0; i < ddata->pdata->nbuttons; i++) {
1020                 bdata = &ddata->data[i];
1021                 if (bdata->button->wakeup) {
1022                         error = gpio_keys_button_enable_wakeup(bdata);
1023                         if (error)
1024                                 goto err_out;
1025                 }
1026                 bdata->suspended = true;
1027         }
1028
1029         return 0;
1030
1031 err_out:
1032         while (i--) {
1033                 bdata = &ddata->data[i];
1034                 if (bdata->button->wakeup)
1035                         gpio_keys_button_disable_wakeup(bdata);
1036                 bdata->suspended = false;
1037         }
1038
1039         return error;
1040 }
1041
1042 static void __maybe_unused
1043 gpio_keys_disable_wakeup(struct gpio_keys_drvdata *ddata)
1044 {
1045         struct gpio_button_data *bdata;
1046         int i;
1047
1048         for (i = 0; i < ddata->pdata->nbuttons; i++) {
1049                 bdata = &ddata->data[i];
1050                 bdata->suspended = false;
1051                 if (irqd_is_wakeup_set(irq_get_irq_data(bdata->irq)))
1052                         gpio_keys_button_disable_wakeup(bdata);
1053         }
1054 }
1055
1056 static int gpio_keys_suspend(struct device *dev)
1057 {
1058         struct gpio_keys_drvdata *ddata = dev_get_drvdata(dev);
1059         struct input_dev *input = ddata->input;
1060         int error;
1061
1062         if (device_may_wakeup(dev)) {
1063                 error = gpio_keys_enable_wakeup(ddata);
1064                 if (error)
1065                         return error;
1066         } else {
1067                 mutex_lock(&input->mutex);
1068                 if (input_device_enabled(input))
1069                         gpio_keys_close(input);
1070                 mutex_unlock(&input->mutex);
1071         }
1072
1073         return 0;
1074 }
1075
1076 static int gpio_keys_resume(struct device *dev)
1077 {
1078         struct gpio_keys_drvdata *ddata = dev_get_drvdata(dev);
1079         struct input_dev *input = ddata->input;
1080         int error = 0;
1081
1082         if (device_may_wakeup(dev)) {
1083                 gpio_keys_disable_wakeup(ddata);
1084         } else {
1085                 mutex_lock(&input->mutex);
1086                 if (input_device_enabled(input))
1087                         error = gpio_keys_open(input);
1088                 mutex_unlock(&input->mutex);
1089         }
1090
1091         if (error)
1092                 return error;
1093
1094         gpio_keys_report_state(ddata);
1095         return 0;
1096 }
1097
1098 static DEFINE_SIMPLE_DEV_PM_OPS(gpio_keys_pm_ops, gpio_keys_suspend, gpio_keys_resume);
1099
1100 static void gpio_keys_shutdown(struct platform_device *pdev)
1101 {
1102         int ret;
1103
1104         ret = gpio_keys_suspend(&pdev->dev);
1105         if (ret)
1106                 dev_err(&pdev->dev, "failed to shutdown\n");
1107 }
1108
1109 static struct platform_driver gpio_keys_device_driver = {
1110         .probe          = gpio_keys_probe,
1111         .shutdown       = gpio_keys_shutdown,
1112         .driver         = {
1113                 .name   = "gpio-keys",
1114                 .pm     = pm_sleep_ptr(&gpio_keys_pm_ops),
1115                 .of_match_table = gpio_keys_of_match,
1116                 .dev_groups     = gpio_keys_groups,
1117         }
1118 };
1119
1120 static int __init gpio_keys_init(void)
1121 {
1122         return platform_driver_register(&gpio_keys_device_driver);
1123 }
1124
1125 static void __exit gpio_keys_exit(void)
1126 {
1127         platform_driver_unregister(&gpio_keys_device_driver);
1128 }
1129
1130 late_initcall(gpio_keys_init);
1131 module_exit(gpio_keys_exit);
1132
1133 MODULE_LICENSE("GPL");
1134 MODULE_AUTHOR("Phil Blundell <pb@handhelds.org>");
1135 MODULE_DESCRIPTION("Keyboard driver for GPIOs");
1136 MODULE_ALIAS("platform:gpio-keys");