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 <[email protected]>
   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         ssize_t error;
 249         int i;
 250
 251         unsigned long *bits __free(bitmap) = bitmap_alloc(n_events, GFP_KERNEL);
 252         if (!bits)
 253                 return -ENOMEM;
 254
 255         error = bitmap_parselist(buf, bits, n_events);
 256         if (error)
 257                 return error;
 258
 259         /* First validate */
 260         if (!bitmap_subset(bits, bitmap, n_events))
 261                 return -EINVAL;
 262
 263         for (i = 0; i < ddata->pdata->nbuttons; i++) {
 264                 struct gpio_button_data *bdata = &ddata->data[i];
 265
 266                 if (bdata->button->type != type)
 267                         continue;
 268
 269                 if (test_bit(*bdata->code, bits) &&
 270                     !bdata->button->can_disable) {
 271                         return -EINVAL;
 272                 }
 273         }
 274
 275         guard(mutex)(&ddata->disable_lock);
 276
 277         for (i = 0; i < ddata->pdata->nbuttons; i++) {
 278                 struct gpio_button_data *bdata = &ddata->data[i];
 279
 280                 if (bdata->button->type != type)
 281                         continue;
 282
 283                 if (test_bit(*bdata->code, bits))
 284                         gpio_keys_disable_button(bdata);
 285                 else
 286                         gpio_keys_enable_button(bdata);
 287         }
 288
 289         return 0;
 290 }
 291
 292 #define ATTR_SHOW_FN(name, type, only_disabled)                         \
 293 static ssize_t gpio_keys_show_##name(struct device *dev,                \
 294                                      struct device_attribute *attr,     \
 295                                      char *buf)                         \
 296 {                                                                       \
 297         struct platform_device *pdev = to_platform_device(dev);         \
 298         struct gpio_keys_drvdata *ddata = platform_get_drvdata(pdev);   \
 299                                                                         \
 300         return gpio_keys_attr_show_helper(ddata, buf,                   \
 301                                           type, only_disabled);         \
 302 }
 303
 304 ATTR_SHOW_FN(keys, EV_KEY, false);
 305 ATTR_SHOW_FN(switches, EV_SW, false);
 306 ATTR_SHOW_FN(disabled_keys, EV_KEY, true);
 307 ATTR_SHOW_FN(disabled_switches, EV_SW, true);
 308
 309 /*
 310  * ATTRIBUTES:
 311  *
 312  * /sys/devices/platform/gpio-keys/keys [ro]
 313  * /sys/devices/platform/gpio-keys/switches [ro]
 314  */
 315 static DEVICE_ATTR(keys, S_IRUGO, gpio_keys_show_keys, NULL);
 316 static DEVICE_ATTR(switches, S_IRUGO, gpio_keys_show_switches, NULL);
 317
 318 #define ATTR_STORE_FN(name, type)                                       \
 319 static ssize_t gpio_keys_store_##name(struct device *dev,               \
 320                                       struct device_attribute *attr,    \
 321                                       const char *buf,                  \
 322                                       size_t count)                     \
 323 {                                                                       \
 324         struct platform_device *pdev = to_platform_device(dev);         \
 325         struct gpio_keys_drvdata *ddata = platform_get_drvdata(pdev);   \
 326         ssize_t error;                                                  \
 327                                                                         \
 328         error = gpio_keys_attr_store_helper(ddata, buf, type);          \
 329         if (error)                                                      \
 330                 return error;                                           \
 331                                                                         \
 332         return count;                                                   \
 333 }
 334
 335 ATTR_STORE_FN(disabled_keys, EV_KEY);
 336 ATTR_STORE_FN(disabled_switches, EV_SW);
 337
 338 /*
 339  * ATTRIBUTES:
 340  *
 341  * /sys/devices/platform/gpio-keys/disabled_keys [rw]
 342  * /sys/devices/platform/gpio-keys/disables_switches [rw]
 343  */
 344 static DEVICE_ATTR(disabled_keys, S_IWUSR | S_IRUGO,
 345                    gpio_keys_show_disabled_keys,
 346                    gpio_keys_store_disabled_keys);
 347 static DEVICE_ATTR(disabled_switches, S_IWUSR | S_IRUGO,
 348                    gpio_keys_show_disabled_switches,
 349                    gpio_keys_store_disabled_switches);
 350
 351 static struct attribute *gpio_keys_attrs[] = {
 352         &dev_attr_keys.attr,
 353         &dev_attr_switches.attr,
 354         &dev_attr_disabled_keys.attr,
 355         &dev_attr_disabled_switches.attr,
 356         NULL,
 357 };
 358 ATTRIBUTE_GROUPS(gpio_keys);
 359
 360 static void gpio_keys_gpio_report_event(struct gpio_button_data *bdata)
 361 {
 362         const struct gpio_keys_button *button = bdata->button;
 363         struct input_dev *input = bdata->input;
 364         unsigned int type = button->type ?: EV_KEY;
 365         int state;
 366
 367         state = bdata->debounce_use_hrtimer ?
 368                         gpiod_get_value(bdata->gpiod) :
 369                         gpiod_get_value_cansleep(bdata->gpiod);
 370         if (state < 0) {
 371                 dev_err(input->dev.parent,
 372                         "failed to get gpio state: %d\n", state);
 373                 return;
 374         }
 375
 376         if (type == EV_ABS) {
 377                 if (state)
 378                         input_event(input, type, button->code, button->value);
 379         } else {
 380                 input_event(input, type, *bdata->code, state);
 381         }
 382 }
 383
 384 static void gpio_keys_debounce_event(struct gpio_button_data *bdata)
 385 {
 386         gpio_keys_gpio_report_event(bdata);
 387         input_sync(bdata->input);
 388
 389         if (bdata->button->wakeup)
 390                 pm_relax(bdata->input->dev.parent);
 391 }
 392
 393 static void gpio_keys_gpio_work_func(struct work_struct *work)
 394 {
 395         struct gpio_button_data *bdata =
 396                 container_of(work, struct gpio_button_data, work.work);
 397
 398         gpio_keys_debounce_event(bdata);
 399 }
 400
 401 static enum hrtimer_restart gpio_keys_debounce_timer(struct hrtimer *t)
 402 {
 403         struct gpio_button_data *bdata =
 404                 container_of(t, struct gpio_button_data, debounce_timer);
 405
 406         gpio_keys_debounce_event(bdata);
 407
 408         return HRTIMER_NORESTART;
 409 }
 410
 411 static irqreturn_t gpio_keys_gpio_isr(int irq, void *dev_id)
 412 {
 413         struct gpio_button_data *bdata = dev_id;
 414
 415         BUG_ON(irq != bdata->irq);
 416
 417         if (bdata->button->wakeup) {
 418                 const struct gpio_keys_button *button = bdata->button;
 419
 420                 pm_stay_awake(bdata->input->dev.parent);
 421                 if (bdata->suspended  &&
 422                     (button->type == 0 || button->type == EV_KEY)) {
 423                         /*
 424                          * Simulate wakeup key press in case the key has
 425                          * already released by the time we got interrupt
 426                          * handler to run.
 427                          */
 428                         input_report_key(bdata->input, button->code, 1);
 429                 }
 430         }
 431
 432         if (bdata->debounce_use_hrtimer) {
 433                 hrtimer_start(&bdata->debounce_timer,
 434                               ms_to_ktime(bdata->software_debounce),
 435                               HRTIMER_MODE_REL);
 436         } else {
 437                 mod_delayed_work(system_wq,
 438                                  &bdata->work,
 439                                  msecs_to_jiffies(bdata->software_debounce));
 440         }
 441
 442         return IRQ_HANDLED;
 443 }
 444
 445 static enum hrtimer_restart gpio_keys_irq_timer(struct hrtimer *t)
 446 {
 447         struct gpio_button_data *bdata = container_of(t,
 448                                                       struct gpio_button_data,
 449                                                       release_timer);
 450         struct input_dev *input = bdata->input;
 451
 452         if (bdata->key_pressed) {
 453                 input_report_key(input, *bdata->code, 0);
 454                 input_sync(input);
 455                 bdata->key_pressed = false;
 456         }
 457
 458         return HRTIMER_NORESTART;
 459 }
 460
 461 static irqreturn_t gpio_keys_irq_isr(int irq, void *dev_id)
 462 {
 463         struct gpio_button_data *bdata = dev_id;
 464         struct input_dev *input = bdata->input;
 465
 466         BUG_ON(irq != bdata->irq);
 467
 468         guard(spinlock_irqsave)(&bdata->lock);
 469
 470         if (!bdata->key_pressed) {
 471                 if (bdata->button->wakeup)
 472                         pm_wakeup_event(bdata->input->dev.parent, 0);
 473
 474                 input_report_key(input, *bdata->code, 1);
 475                 input_sync(input);
 476
 477                 if (!bdata->release_delay) {
 478                         input_report_key(input, *bdata->code, 0);
 479                         input_sync(input);
 480                         goto out;
 481                 }
 482
 483                 bdata->key_pressed = true;
 484         }
 485
 486         if (bdata->release_delay)
 487                 hrtimer_start(&bdata->release_timer,
 488                               ms_to_ktime(bdata->release_delay),
 489                               HRTIMER_MODE_REL_HARD);
 490 out:
 491         return IRQ_HANDLED;
 492 }
 493
 494 static int gpio_keys_setup_key(struct platform_device *pdev,
 495                                 struct input_dev *input,
 496                                 struct gpio_keys_drvdata *ddata,
 497                                 const struct gpio_keys_button *button,
 498                                 int idx,
 499                                 struct fwnode_handle *child)
 500 {
 501         const char *desc = button->desc ? button->desc : "gpio_keys";
 502         struct device *dev = &pdev->dev;
 503         struct gpio_button_data *bdata = &ddata->data[idx];
 504         irq_handler_t isr;
 505         unsigned long irqflags;
 506         const char *wakedesc;
 507         int irq;
 508         int error;
 509
 510         bdata->input = input;
 511         bdata->button = button;
 512         spin_lock_init(&bdata->lock);
 513
 514         if (child) {
 515                 bdata->gpiod = devm_fwnode_gpiod_get(dev, child,
 516                                                      NULL, GPIOD_IN, desc);
 517                 if (IS_ERR(bdata->gpiod)) {
 518                         error = PTR_ERR(bdata->gpiod);
 519                         if (error != -ENOENT)
 520                                 return dev_err_probe(dev, error,
 521                                                      "failed to get gpio\n");
 522
 523                         /*
 524                          * GPIO is optional, we may be dealing with
 525                          * purely interrupt-driven setup.
 526                          */
 527                         bdata->gpiod = NULL;
 528                 }
 529         } else if (gpio_is_valid(button->gpio)) {
 530                 /*
 531                  * Legacy GPIO number, so request the GPIO here and
 532                  * convert it to descriptor.
 533                  */
 534                 unsigned flags = GPIOF_IN;
 535
 536                 if (button->active_low)
 537                         flags |= GPIOF_ACTIVE_LOW;
 538
 539                 error = devm_gpio_request_one(dev, button->gpio, flags, desc);
 540                 if (error < 0) {
 541                         dev_err(dev, "Failed to request GPIO %d, error %d\n",
 542                                 button->gpio, error);
 543                         return error;
 544                 }
 545
 546                 bdata->gpiod = gpio_to_desc(button->gpio);
 547                 if (!bdata->gpiod)
 548                         return -EINVAL;
 549         }
 550
 551         if (bdata->gpiod) {
 552                 bool active_low = gpiod_is_active_low(bdata->gpiod);
 553
 554                 if (button->debounce_interval) {
 555                         error = gpiod_set_debounce(bdata->gpiod,
 556                                         button->debounce_interval * 1000);
 557                         /* use timer if gpiolib doesn't provide debounce */
 558                         if (error < 0)
 559                                 bdata->software_debounce =
 560                                                 button->debounce_interval;
 561
 562                         /*
 563                          * If reading the GPIO won't sleep, we can use a
 564                          * hrtimer instead of a standard timer for the software
 565                          * debounce, to reduce the latency as much as possible.
 566                          */
 567                         bdata->debounce_use_hrtimer =
 568                                         !gpiod_cansleep(bdata->gpiod);
 569                 }
 570
 571                 /*
 572                  * If an interrupt was specified, use it instead of the gpio
 573                  * interrupt and use the gpio for reading the state. A separate
 574                  * interrupt may be used as the main button interrupt for
 575                  * runtime PM to detect events also in deeper idle states. If a
 576                  * dedicated wakeirq is used for system suspend only, see below
 577                  * for bdata->wakeirq setup.
 578                  */
 579                 if (button->irq) {
 580                         bdata->irq = button->irq;
 581                 } else {
 582                         irq = gpiod_to_irq(bdata->gpiod);
 583                         if (irq < 0) {
 584                                 error = irq;
 585                                 dev_err_probe(dev, error,
 586                                               "Unable to get irq number for GPIO %d\n",
 587                                               button->gpio);
 588                                 return error;
 589                         }
 590                         bdata->irq = irq;
 591                 }
 592
 593                 INIT_DELAYED_WORK(&bdata->work, gpio_keys_gpio_work_func);
 594
 595                 hrtimer_init(&bdata->debounce_timer,
 596                              CLOCK_REALTIME, HRTIMER_MODE_REL);
 597                 bdata->debounce_timer.function = gpio_keys_debounce_timer;
 598
 599                 isr = gpio_keys_gpio_isr;
 600                 irqflags = IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING;
 601
 602                 switch (button->wakeup_event_action) {
 603                 case EV_ACT_ASSERTED:
 604                         bdata->wakeup_trigger_type = active_low ?
 605                                 IRQ_TYPE_EDGE_FALLING : IRQ_TYPE_EDGE_RISING;
 606                         break;
 607                 case EV_ACT_DEASSERTED:
 608                         bdata->wakeup_trigger_type = active_low ?
 609                                 IRQ_TYPE_EDGE_RISING : IRQ_TYPE_EDGE_FALLING;
 610                         break;
 611                 case EV_ACT_ANY:
 612                 default:
 613                         /*
 614                          * For other cases, we are OK letting suspend/resume
 615                          * not reconfigure the trigger type.
 616                          */
 617                         break;
 618                 }
 619         } else {
 620                 if (!button->irq) {
 621                         dev_err(dev, "Found button without gpio or irq\n");
 622                         return -EINVAL;
 623                 }
 624
 625                 bdata->irq = button->irq;
 626
 627                 if (button->type && button->type != EV_KEY) {
 628                         dev_err(dev, "Only EV_KEY allowed for IRQ buttons.\n");
 629                         return -EINVAL;
 630                 }
 631
 632                 bdata->release_delay = button->debounce_interval;
 633                 hrtimer_init(&bdata->release_timer,
 634                              CLOCK_REALTIME, HRTIMER_MODE_REL_HARD);
 635                 bdata->release_timer.function = gpio_keys_irq_timer;
 636
 637                 isr = gpio_keys_irq_isr;
 638                 irqflags = 0;
 639
 640                 /*
 641                  * For IRQ buttons, there is no interrupt for release.
 642                  * So we don't need to reconfigure the trigger type for wakeup.
 643                  */
 644         }
 645
 646         bdata->code = &ddata->keymap[idx];
 647         *bdata->code = button->code;
 648         input_set_capability(input, button->type ?: EV_KEY, *bdata->code);
 649
 650         /*
 651          * Install custom action to cancel release timer and
 652          * workqueue item.
 653          */
 654         error = devm_add_action(dev, gpio_keys_quiesce_key, bdata);
 655         if (error) {
 656                 dev_err(dev, "failed to register quiesce action, error: %d\n",
 657                         error);
 658                 return error;
 659         }
 660
 661         /*
 662          * If platform has specified that the button can be disabled,
 663          * we don't want it to share the interrupt line.
 664          */
 665         if (!button->can_disable)
 666                 irqflags |= IRQF_SHARED;
 667
 668         error = devm_request_any_context_irq(dev, bdata->irq, isr, irqflags,
 669                                              desc, bdata);
 670         if (error < 0) {
 671                 dev_err(dev, "Unable to claim irq %d; error %d\n",
 672                         bdata->irq, error);
 673                 return error;
 674         }
 675
 676         if (!button->wakeirq)
 677                 return 0;
 678
 679         /* Use :wakeup suffix like drivers/base/power/wakeirq.c does */
 680         wakedesc = devm_kasprintf(dev, GFP_KERNEL, "%s:wakeup", desc);
 681         if (!wakedesc)
 682                 return -ENOMEM;
 683
 684         bdata->wakeirq = button->wakeirq;
 685         irqflags |= IRQF_NO_SUSPEND;
 686
 687         /*
 688          * Wakeirq shares the handler with the main interrupt, it's only
 689          * active during system suspend. See gpio_keys_button_enable_wakeup()
 690          * and gpio_keys_button_disable_wakeup().
 691          */
 692         error = devm_request_any_context_irq(dev, bdata->wakeirq, isr,
 693                                              irqflags, wakedesc, bdata);
 694         if (error < 0) {
 695                 dev_err(dev, "Unable to claim wakeirq %d; error %d\n",
 696                         bdata->irq, error);
 697                 return error;
 698         }
 699
 700         /*
 701          * Disable wakeirq until suspend. IRQF_NO_AUTOEN won't work if
 702          * IRQF_SHARED was set based on !button->can_disable.
 703          */
 704         disable_irq(bdata->wakeirq);
 705
 706         return 0;
 707 }
 708
 709 static void gpio_keys_report_state(struct gpio_keys_drvdata *ddata)
 710 {
 711         struct input_dev *input = ddata->input;
 712         int i;
 713
 714         for (i = 0; i < ddata->pdata->nbuttons; i++) {
 715                 struct gpio_button_data *bdata = &ddata->data[i];
 716                 if (bdata->gpiod)
 717                         gpio_keys_gpio_report_event(bdata);
 718         }
 719         input_sync(input);
 720 }
 721
 722 static int gpio_keys_open(struct input_dev *input)
 723 {
 724         struct gpio_keys_drvdata *ddata = input_get_drvdata(input);
 725         const struct gpio_keys_platform_data *pdata = ddata->pdata;
 726         int error;
 727
 728         if (pdata->enable) {
 729                 error = pdata->enable(input->dev.parent);
 730                 if (error)
 731                         return error;
 732         }
 733
 734         /* Report current state of buttons that are connected to GPIOs */
 735         gpio_keys_report_state(ddata);
 736
 737         return 0;
 738 }
 739
 740 static void gpio_keys_close(struct input_dev *input)
 741 {
 742         struct gpio_keys_drvdata *ddata = input_get_drvdata(input);
 743         const struct gpio_keys_platform_data *pdata = ddata->pdata;
 744
 745         if (pdata->disable)
 746                 pdata->disable(input->dev.parent);
 747 }
 748
 749 /*
 750  * Handlers for alternative sources of platform_data
 751  */
 752
 753 /*
 754  * Translate properties into platform_data
 755  */
 756 static struct gpio_keys_platform_data *
 757 gpio_keys_get_devtree_pdata(struct device *dev)
 758 {
 759         struct gpio_keys_platform_data *pdata;
 760         struct gpio_keys_button *button;
 761         int nbuttons, irq;
 762
 763         nbuttons = device_get_child_node_count(dev);
 764         if (nbuttons == 0)
 765                 return ERR_PTR(-ENODEV);
 766
 767         pdata = devm_kzalloc(dev,
 768                              sizeof(*pdata) + nbuttons * sizeof(*button),
 769                              GFP_KERNEL);
 770         if (!pdata)
 771                 return ERR_PTR(-ENOMEM);
 772
 773         button = (struct gpio_keys_button *)(pdata + 1);
 774
 775         pdata->buttons = button;
 776         pdata->nbuttons = nbuttons;
 777
 778         pdata->rep = device_property_read_bool(dev, "autorepeat");
 779
 780         device_property_read_string(dev, "label", &pdata->name);
 781
 782         device_for_each_child_node_scoped(dev, child) {
 783                 if (is_of_node(child)) {
 784                         irq = of_irq_get_byname(to_of_node(child), "irq");
 785                         if (irq > 0)
 786                                 button->irq = irq;
 787
 788                         irq = of_irq_get_byname(to_of_node(child), "wakeup");
 789                         if (irq > 0)
 790                                 button->wakeirq = irq;
 791
 792                         if (!button->irq && !button->wakeirq)
 793                                 button->irq =
 794                                         irq_of_parse_and_map(to_of_node(child), 0);
 795                 }
 796
 797                 if (fwnode_property_read_u32(child, "linux,code",
 798                                              &button->code)) {
 799                         dev_err(dev, "Button without keycode\n");
 800                         return ERR_PTR(-EINVAL);
 801                 }
 802
 803                 fwnode_property_read_string(child, "label", &button->desc);
 804
 805                 if (fwnode_property_read_u32(child, "linux,input-type",
 806                                              &button->type))
 807                         button->type = EV_KEY;
 808
 809                 fwnode_property_read_u32(child, "linux,input-value",
 810                                          (u32 *)&button->value);
 811
 812                 button->wakeup =
 813                         fwnode_property_read_bool(child, "wakeup-source") ||
 814                         /* legacy name */
 815                         fwnode_property_read_bool(child, "gpio-key,wakeup");
 816
 817                 fwnode_property_read_u32(child, "wakeup-event-action",
 818                                          &button->wakeup_event_action);
 819
 820                 button->can_disable =
 821                         fwnode_property_read_bool(child, "linux,can-disable");
 822
 823                 if (fwnode_property_read_u32(child, "debounce-interval",
 824                                          &button->debounce_interval))
 825                         button->debounce_interval = 5;
 826
 827                 button++;
 828         }
 829
 830         return pdata;
 831 }
 832
 833 static const struct of_device_id gpio_keys_of_match[] = {
 834         { .compatible = "gpio-keys", },
 835         { },
 836 };
 837 MODULE_DEVICE_TABLE(of, gpio_keys_of_match);
 838
 839 static int gpio_keys_probe(struct platform_device *pdev)
 840 {
 841         struct device *dev = &pdev->dev;
 842         const struct gpio_keys_platform_data *pdata = dev_get_platdata(dev);
 843         struct fwnode_handle *child = NULL;
 844         struct gpio_keys_drvdata *ddata;
 845         struct input_dev *input;
 846         int i, error;
 847         int wakeup = 0;
 848
 849         if (!pdata) {
 850                 pdata = gpio_keys_get_devtree_pdata(dev);
 851                 if (IS_ERR(pdata))
 852                         return PTR_ERR(pdata);
 853         }
 854
 855         ddata = devm_kzalloc(dev, struct_size(ddata, data, pdata->nbuttons),
 856                              GFP_KERNEL);
 857         if (!ddata) {
 858                 dev_err(dev, "failed to allocate state\n");
 859                 return -ENOMEM;
 860         }
 861
 862         ddata->keymap = devm_kcalloc(dev,
 863                                      pdata->nbuttons, sizeof(ddata->keymap[0]),
 864                                      GFP_KERNEL);
 865         if (!ddata->keymap)
 866                 return -ENOMEM;
 867
 868         input = devm_input_allocate_device(dev);
 869         if (!input) {
 870                 dev_err(dev, "failed to allocate input device\n");
 871                 return -ENOMEM;
 872         }
 873
 874         ddata->pdata = pdata;
 875         ddata->input = input;
 876         mutex_init(&ddata->disable_lock);
 877
 878         platform_set_drvdata(pdev, ddata);
 879         input_set_drvdata(input, ddata);
 880
 881         input->name = pdata->name ? : pdev->name;
 882         input->phys = "gpio-keys/input0";
 883         input->dev.parent = dev;
 884         input->open = gpio_keys_open;
 885         input->close = gpio_keys_close;
 886
 887         input->id.bustype = BUS_HOST;
 888         input->id.vendor = 0x0001;
 889         input->id.product = 0x0001;
 890         input->id.version = 0x0100;
 891
 892         input->keycode = ddata->keymap;
 893         input->keycodesize = sizeof(ddata->keymap[0]);
 894         input->keycodemax = pdata->nbuttons;
 895
 896         /* Enable auto repeat feature of Linux input subsystem */
 897         if (pdata->rep)
 898                 __set_bit(EV_REP, input->evbit);
 899
 900         for (i = 0; i < pdata->nbuttons; i++) {
 901                 const struct gpio_keys_button *button = &pdata->buttons[i];
 902
 903                 if (!dev_get_platdata(dev)) {
 904                         child = device_get_next_child_node(dev, child);
 905                         if (!child) {
 906                                 dev_err(dev,
 907                                         "missing child device node for entry %d\n",
 908                                         i);
 909                                 return -EINVAL;
 910                         }
 911                 }
 912
 913                 error = gpio_keys_setup_key(pdev, input, ddata,
 914                                             button, i, child);
 915                 if (error) {
 916                         fwnode_handle_put(child);
 917                         return error;
 918                 }
 919
 920                 if (button->wakeup)
 921                         wakeup = 1;
 922         }
 923
 924         fwnode_handle_put(child);
 925
 926         error = input_register_device(input);
 927         if (error) {
 928                 dev_err(dev, "Unable to register input device, error: %d\n",
 929                         error);
 930                 return error;
 931         }
 932
 933         device_init_wakeup(dev, wakeup);
 934
 935         return 0;
 936 }
 937
 938 static int __maybe_unused
 939 gpio_keys_button_enable_wakeup(struct gpio_button_data *bdata)
 940 {
 941         int error;
 942
 943         error = enable_irq_wake(bdata->irq);
 944         if (error) {
 945                 dev_err(bdata->input->dev.parent,
 946                         "failed to configure IRQ %d as wakeup source: %d\n",
 947                         bdata->irq, error);
 948                 return error;
 949         }
 950
 951         if (bdata->wakeup_trigger_type) {
 952                 error = irq_set_irq_type(bdata->irq,
 953                                          bdata->wakeup_trigger_type);
 954                 if (error) {
 955                         dev_err(bdata->input->dev.parent,
 956                                 "failed to set wakeup trigger %08x for IRQ %d: %d\n",
 957                                 bdata->wakeup_trigger_type, bdata->irq, error);
 958                         disable_irq_wake(bdata->irq);
 959                         return error;
 960                 }
 961         }
 962
 963         if (bdata->wakeirq) {
 964                 enable_irq(bdata->wakeirq);
 965                 disable_irq(bdata->irq);
 966         }
 967
 968         return 0;
 969 }
 970
 971 static void __maybe_unused
 972 gpio_keys_button_disable_wakeup(struct gpio_button_data *bdata)
 973 {
 974         int error;
 975
 976         if (bdata->wakeirq) {
 977                 enable_irq(bdata->irq);
 978                 disable_irq(bdata->wakeirq);
 979         }
 980
 981         /*
 982          * The trigger type is always both edges for gpio-based keys and we do
 983          * not support changing wakeup trigger for interrupt-based keys.
 984          */
 985         if (bdata->wakeup_trigger_type) {
 986                 error = irq_set_irq_type(bdata->irq, IRQ_TYPE_EDGE_BOTH);
 987                 if (error)
 988                         dev_warn(bdata->input->dev.parent,
 989                                  "failed to restore interrupt trigger for IRQ %d: %d\n",
 990                                  bdata->irq, error);
 991         }
 992
 993         error = disable_irq_wake(bdata->irq);
 994         if (error)
 995                 dev_warn(bdata->input->dev.parent,
 996                          "failed to disable IRQ %d as wake source: %d\n",
 997                          bdata->irq, error);
 998 }
 999
1000 static int __maybe_unused
1001 gpio_keys_enable_wakeup(struct gpio_keys_drvdata *ddata)
1002 {
1003         struct gpio_button_data *bdata;
1004         int error;
1005         int i;
1006
1007         for (i = 0; i < ddata->pdata->nbuttons; i++) {
1008                 bdata = &ddata->data[i];
1009                 if (bdata->button->wakeup) {
1010                         error = gpio_keys_button_enable_wakeup(bdata);
1011                         if (error)
1012                                 goto err_out;
1013                 }
1014                 bdata->suspended = true;
1015         }
1016
1017         return 0;
1018
1019 err_out:
1020         while (i--) {
1021                 bdata = &ddata->data[i];
1022                 if (bdata->button->wakeup)
1023                         gpio_keys_button_disable_wakeup(bdata);
1024                 bdata->suspended = false;
1025         }
1026
1027         return error;
1028 }
1029
1030 static void __maybe_unused
1031 gpio_keys_disable_wakeup(struct gpio_keys_drvdata *ddata)
1032 {
1033         struct gpio_button_data *bdata;
1034         int i;
1035
1036         for (i = 0; i < ddata->pdata->nbuttons; i++) {
1037                 bdata = &ddata->data[i];
1038                 bdata->suspended = false;
1039                 if (irqd_is_wakeup_set(irq_get_irq_data(bdata->irq)))
1040                         gpio_keys_button_disable_wakeup(bdata);
1041         }
1042 }
1043
1044 static int gpio_keys_suspend(struct device *dev)
1045 {
1046         struct gpio_keys_drvdata *ddata = dev_get_drvdata(dev);
1047         struct input_dev *input = ddata->input;
1048         int error;
1049
1050         if (device_may_wakeup(dev)) {
1051                 error = gpio_keys_enable_wakeup(ddata);
1052                 if (error)
1053                         return error;
1054         } else {
1055                 guard(mutex)(&input->mutex);
1056
1057                 if (input_device_enabled(input))
1058                         gpio_keys_close(input);
1059         }
1060
1061         return 0;
1062 }
1063
1064 static int gpio_keys_resume(struct device *dev)
1065 {
1066         struct gpio_keys_drvdata *ddata = dev_get_drvdata(dev);
1067         struct input_dev *input = ddata->input;
1068         int error;
1069
1070         if (device_may_wakeup(dev)) {
1071                 gpio_keys_disable_wakeup(ddata);
1072         } else {
1073                 guard(mutex)(&input->mutex);
1074
1075                 if (input_device_enabled(input)) {
1076                         error = gpio_keys_open(input);
1077                         if (error)
1078                                 return error;
1079                 }
1080         }
1081
1082         gpio_keys_report_state(ddata);
1083         return 0;
1084 }
1085
1086 static DEFINE_SIMPLE_DEV_PM_OPS(gpio_keys_pm_ops, gpio_keys_suspend, gpio_keys_resume);
1087
1088 static void gpio_keys_shutdown(struct platform_device *pdev)
1089 {
1090         int ret;
1091
1092         ret = gpio_keys_suspend(&pdev->dev);
1093         if (ret)
1094                 dev_err(&pdev->dev, "failed to shutdown\n");
1095 }
1096
1097 static struct platform_driver gpio_keys_device_driver = {
1098         .probe          = gpio_keys_probe,
1099         .shutdown       = gpio_keys_shutdown,
1100         .driver         = {
1101                 .name   = "gpio-keys",
1102                 .pm     = pm_sleep_ptr(&gpio_keys_pm_ops),
1103                 .of_match_table = gpio_keys_of_match,
1104                 .dev_groups     = gpio_keys_groups,
1105         }
1106 };
1107
1108 static int __init gpio_keys_init(void)
1109 {
1110         return platform_driver_register(&gpio_keys_device_driver);
1111 }
1112
1113 static void __exit gpio_keys_exit(void)
1114 {
1115         platform_driver_unregister(&gpio_keys_device_driver);
1116 }
1117
1118 late_initcall(gpio_keys_init);
1119 module_exit(gpio_keys_exit);
1120
1121 MODULE_LICENSE("GPL");
1122 MODULE_AUTHOR("Phil Blundell <[email protected]>");
1123 MODULE_DESCRIPTION("Keyboard driver for GPIOs");
1124 MODULE_ALIAS("platform:gpio-keys");