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