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