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