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 33struct 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 58struct 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 */ 107static 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 */ 122static 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 130static 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 */ 155static 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 */ 177static 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 */ 199static 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 */ 243static 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 295out: 296 bitmap_free(bits); 297 return error; 298} 299 300#define ATTR_SHOW_FN(name, type, only_disabled) \ 301static 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 312ATTR_SHOW_FN(keys, EV_KEY, false); 313ATTR_SHOW_FN(switches, EV_SW, false); 314ATTR_SHOW_FN(disabled_keys, EV_KEY, true); 315ATTR_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 */ 323static DEVICE_ATTR(keys, S_IRUGO, gpio_keys_show_keys, NULL); 324static DEVICE_ATTR(switches, S_IRUGO, gpio_keys_show_switches, NULL); 325 326#define ATTR_STORE_FN(name, type) \ 327static 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 343ATTR_STORE_FN(disabled_keys, EV_KEY); 344ATTR_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 */ 352static DEVICE_ATTR(disabled_keys, S_IWUSR | S_IRUGO, 353 gpio_keys_show_disabled_keys, 354 gpio_keys_store_disabled_keys); 355static DEVICE_ATTR(disabled_switches, S_IWUSR | S_IRUGO, 356 gpio_keys_show_disabled_switches, 357 gpio_keys_store_disabled_switches); 358 359static 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}; 366ATTRIBUTE_GROUPS(gpio_keys); 367 368static 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 392static 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 401static 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 409static 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 419static 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 453static 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 469static 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); 499out: 500 spin_unlock_irqrestore(&bdata->lock, flags); 501 return IRQ_HANDLED; 502} 503 504static 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 719static 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 732static 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 750static 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 */ 766static struct gpio_keys_platform_data * 767gpio_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 845static const struct of_device_id gpio_keys_of_match[] = { 846 { .compatible = "gpio-keys", }, 847 { }, 848}; 849MODULE_DEVICE_TABLE(of, gpio_keys_of_match); 850 851static 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 950static int __maybe_unused 951gpio_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 983static void __maybe_unused 984gpio_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 1012static int __maybe_unused 1013gpio_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 1031err_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 1042static void __maybe_unused 1043gpio_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 1056static 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 1076static 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 1098static DEFINE_SIMPLE_DEV_PM_OPS(gpio_keys_pm_ops, gpio_keys_suspend, gpio_keys_resume); 1099 1100static 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 1109static 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 1120static int __init gpio_keys_init(void) 1121{ 1122 return platform_driver_register(&gpio_keys_device_driver); 1123} 1124 1125static void __exit gpio_keys_exit(void) 1126{ 1127 platform_driver_unregister(&gpio_keys_device_driver); 1128} 1129 1130late_initcall(gpio_keys_init); 1131module_exit(gpio_keys_exit); 1132 1133MODULE_LICENSE("GPL"); 1134MODULE_AUTHOR("Phil Blundell <pb@handhelds.org>"); 1135MODULE_DESCRIPTION("Keyboard driver for GPIOs"); 1136MODULE_ALIAS("platform:gpio-keys"); 1137