1 /* 2 * Driver for keys on GPIO lines capable of generating interrupts. 3 * 4 * Copyright 2005 Phil Blundell 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License version 2 as 8 * published by the Free Software Foundation. 9 */ 10 11 #include <linux/module.h> 12 13 #include <linux/init.h> 14 #include <linux/fs.h> 15 #include <linux/interrupt.h> 16 #include <linux/irq.h> 17 #include <linux/sched.h> 18 #include <linux/pm.h> 19 #include <linux/slab.h> 20 #include <linux/sysctl.h> 21 #include <linux/proc_fs.h> 22 #include <linux/delay.h> 23 #include <linux/platform_device.h> 24 #include <linux/input.h> 25 #include <linux/gpio_keys.h> 26 #include <linux/workqueue.h> 27 #include <linux/gpio.h> 28 29 struct gpio_button_data { 30 struct gpio_keys_button *button; 31 struct input_dev *input; 32 struct timer_list timer; 33 struct work_struct work; 34 int timer_debounce; /* in msecs */ 35 bool disabled; 36 }; 37 38 struct gpio_keys_drvdata { 39 struct input_dev *input; 40 struct mutex disable_lock; 41 unsigned int n_buttons; 42 int (*enable)(struct device *dev); 43 void (*disable)(struct device *dev); 44 struct gpio_button_data data[0]; 45 }; 46 47 /* 48 * SYSFS interface for enabling/disabling keys and switches: 49 * 50 * There are 4 attributes under /sys/devices/platform/gpio-keys/ 51 * keys [ro] - bitmap of keys (EV_KEY) which can be 52 * disabled 53 * switches [ro] - bitmap of switches (EV_SW) which can be 54 * disabled 55 * disabled_keys [rw] - bitmap of keys currently disabled 56 * disabled_switches [rw] - bitmap of switches currently disabled 57 * 58 * Userland can change these values and hence disable event generation 59 * for each key (or switch). Disabling a key means its interrupt line 60 * is disabled. 61 * 62 * For example, if we have following switches set up as gpio-keys: 63 * SW_DOCK = 5 64 * SW_CAMERA_LENS_COVER = 9 65 * SW_KEYPAD_SLIDE = 10 66 * SW_FRONT_PROXIMITY = 11 67 * This is read from switches: 68 * 11-9,5 69 * Next we want to disable proximity (11) and dock (5), we write: 70 * 11,5 71 * to file disabled_switches. Now proximity and dock IRQs are disabled. 72 * This can be verified by reading the file disabled_switches: 73 * 11,5 74 * If we now want to enable proximity (11) switch we write: 75 * 5 76 * to disabled_switches. 77 * 78 * We can disable only those keys which don't allow sharing the irq. 79 */ 80 81 /** 82 * get_n_events_by_type() - returns maximum number of events per @type 83 * @type: type of button (%EV_KEY, %EV_SW) 84 * 85 * Return value of this function can be used to allocate bitmap 86 * large enough to hold all bits for given type. 87 */ 88 static inline int get_n_events_by_type(int type) 89 { 90 BUG_ON(type != EV_SW && type != EV_KEY); 91 92 return (type == EV_KEY) ? KEY_CNT : SW_CNT; 93 } 94 95 /** 96 * gpio_keys_disable_button() - disables given GPIO button 97 * @bdata: button data for button to be disabled 98 * 99 * Disables button pointed by @bdata. This is done by masking 100 * IRQ line. After this function is called, button won't generate 101 * input events anymore. Note that one can only disable buttons 102 * that don't share IRQs. 103 * 104 * Make sure that @bdata->disable_lock is locked when entering 105 * this function to avoid races when concurrent threads are 106 * disabling buttons at the same time. 107 */ 108 static void gpio_keys_disable_button(struct gpio_button_data *bdata) 109 { 110 if (!bdata->disabled) { 111 /* 112 * Disable IRQ and possible debouncing timer. 113 */ 114 disable_irq(gpio_to_irq(bdata->button->gpio)); 115 if (bdata->timer_debounce) 116 del_timer_sync(&bdata->timer); 117 118 bdata->disabled = true; 119 } 120 } 121 122 /** 123 * gpio_keys_enable_button() - enables given GPIO button 124 * @bdata: button data for button to be disabled 125 * 126 * Enables given button pointed by @bdata. 127 * 128 * Make sure that @bdata->disable_lock is locked when entering 129 * this function to avoid races with concurrent threads trying 130 * to enable the same button at the same time. 131 */ 132 static void gpio_keys_enable_button(struct gpio_button_data *bdata) 133 { 134 if (bdata->disabled) { 135 enable_irq(gpio_to_irq(bdata->button->gpio)); 136 bdata->disabled = false; 137 } 138 } 139 140 /** 141 * gpio_keys_attr_show_helper() - fill in stringified bitmap of buttons 142 * @ddata: pointer to drvdata 143 * @buf: buffer where stringified bitmap is written 144 * @type: button type (%EV_KEY, %EV_SW) 145 * @only_disabled: does caller want only those buttons that are 146 * currently disabled or all buttons that can be 147 * disabled 148 * 149 * This function writes buttons that can be disabled to @buf. If 150 * @only_disabled is true, then @buf contains only those buttons 151 * that are currently disabled. Returns 0 on success or negative 152 * errno on failure. 153 */ 154 static ssize_t gpio_keys_attr_show_helper(struct gpio_keys_drvdata *ddata, 155 char *buf, unsigned int type, 156 bool only_disabled) 157 { 158 int n_events = get_n_events_by_type(type); 159 unsigned long *bits; 160 ssize_t ret; 161 int i; 162 163 bits = kcalloc(BITS_TO_LONGS(n_events), sizeof(*bits), GFP_KERNEL); 164 if (!bits) 165 return -ENOMEM; 166 167 for (i = 0; i < ddata->n_buttons; i++) { 168 struct gpio_button_data *bdata = &ddata->data[i]; 169 170 if (bdata->button->type != type) 171 continue; 172 173 if (only_disabled && !bdata->disabled) 174 continue; 175 176 __set_bit(bdata->button->code, bits); 177 } 178 179 ret = bitmap_scnlistprintf(buf, PAGE_SIZE - 2, bits, n_events); 180 buf[ret++] = '\n'; 181 buf[ret] = '\0'; 182 183 kfree(bits); 184 185 return ret; 186 } 187 188 /** 189 * gpio_keys_attr_store_helper() - enable/disable buttons based on given bitmap 190 * @ddata: pointer to drvdata 191 * @buf: buffer from userspace that contains stringified bitmap 192 * @type: button type (%EV_KEY, %EV_SW) 193 * 194 * This function parses stringified bitmap from @buf and disables/enables 195 * GPIO buttons accordinly. Returns 0 on success and negative error 196 * on failure. 197 */ 198 static ssize_t gpio_keys_attr_store_helper(struct gpio_keys_drvdata *ddata, 199 const char *buf, unsigned int type) 200 { 201 int n_events = get_n_events_by_type(type); 202 unsigned long *bits; 203 ssize_t error; 204 int i; 205 206 bits = kcalloc(BITS_TO_LONGS(n_events), sizeof(*bits), GFP_KERNEL); 207 if (!bits) 208 return -ENOMEM; 209 210 error = bitmap_parselist(buf, bits, n_events); 211 if (error) 212 goto out; 213 214 /* First validate */ 215 for (i = 0; i < ddata->n_buttons; i++) { 216 struct gpio_button_data *bdata = &ddata->data[i]; 217 218 if (bdata->button->type != type) 219 continue; 220 221 if (test_bit(bdata->button->code, bits) && 222 !bdata->button->can_disable) { 223 error = -EINVAL; 224 goto out; 225 } 226 } 227 228 mutex_lock(&ddata->disable_lock); 229 230 for (i = 0; i < ddata->n_buttons; i++) { 231 struct gpio_button_data *bdata = &ddata->data[i]; 232 233 if (bdata->button->type != type) 234 continue; 235 236 if (test_bit(bdata->button->code, bits)) 237 gpio_keys_disable_button(bdata); 238 else 239 gpio_keys_enable_button(bdata); 240 } 241 242 mutex_unlock(&ddata->disable_lock); 243 244 out: 245 kfree(bits); 246 return error; 247 } 248 249 #define ATTR_SHOW_FN(name, type, only_disabled) \ 250 static ssize_t gpio_keys_show_##name(struct device *dev, \ 251 struct device_attribute *attr, \ 252 char *buf) \ 253 { \ 254 struct platform_device *pdev = to_platform_device(dev); \ 255 struct gpio_keys_drvdata *ddata = platform_get_drvdata(pdev); \ 256 \ 257 return gpio_keys_attr_show_helper(ddata, buf, \ 258 type, only_disabled); \ 259 } 260 261 ATTR_SHOW_FN(keys, EV_KEY, false); 262 ATTR_SHOW_FN(switches, EV_SW, false); 263 ATTR_SHOW_FN(disabled_keys, EV_KEY, true); 264 ATTR_SHOW_FN(disabled_switches, EV_SW, true); 265 266 /* 267 * ATTRIBUTES: 268 * 269 * /sys/devices/platform/gpio-keys/keys [ro] 270 * /sys/devices/platform/gpio-keys/switches [ro] 271 */ 272 static DEVICE_ATTR(keys, S_IRUGO, gpio_keys_show_keys, NULL); 273 static DEVICE_ATTR(switches, S_IRUGO, gpio_keys_show_switches, NULL); 274 275 #define ATTR_STORE_FN(name, type) \ 276 static ssize_t gpio_keys_store_##name(struct device *dev, \ 277 struct device_attribute *attr, \ 278 const char *buf, \ 279 size_t count) \ 280 { \ 281 struct platform_device *pdev = to_platform_device(dev); \ 282 struct gpio_keys_drvdata *ddata = platform_get_drvdata(pdev); \ 283 ssize_t error; \ 284 \ 285 error = gpio_keys_attr_store_helper(ddata, buf, type); \ 286 if (error) \ 287 return error; \ 288 \ 289 return count; \ 290 } 291 292 ATTR_STORE_FN(disabled_keys, EV_KEY); 293 ATTR_STORE_FN(disabled_switches, EV_SW); 294 295 /* 296 * ATTRIBUTES: 297 * 298 * /sys/devices/platform/gpio-keys/disabled_keys [rw] 299 * /sys/devices/platform/gpio-keys/disables_switches [rw] 300 */ 301 static DEVICE_ATTR(disabled_keys, S_IWUSR | S_IRUGO, 302 gpio_keys_show_disabled_keys, 303 gpio_keys_store_disabled_keys); 304 static DEVICE_ATTR(disabled_switches, S_IWUSR | S_IRUGO, 305 gpio_keys_show_disabled_switches, 306 gpio_keys_store_disabled_switches); 307 308 static struct attribute *gpio_keys_attrs[] = { 309 &dev_attr_keys.attr, 310 &dev_attr_switches.attr, 311 &dev_attr_disabled_keys.attr, 312 &dev_attr_disabled_switches.attr, 313 NULL, 314 }; 315 316 static struct attribute_group gpio_keys_attr_group = { 317 .attrs = gpio_keys_attrs, 318 }; 319 320 static void gpio_keys_report_event(struct gpio_button_data *bdata) 321 { 322 struct gpio_keys_button *button = bdata->button; 323 struct input_dev *input = bdata->input; 324 unsigned int type = button->type ?: EV_KEY; 325 int state = (gpio_get_value_cansleep(button->gpio) ? 1 : 0) ^ button->active_low; 326 327 if (type == EV_ABS) { 328 if (state) 329 input_event(input, type, button->code, button->value); 330 } else { 331 input_event(input, type, button->code, !!state); 332 } 333 input_sync(input); 334 } 335 336 static void gpio_keys_work_func(struct work_struct *work) 337 { 338 struct gpio_button_data *bdata = 339 container_of(work, struct gpio_button_data, work); 340 341 gpio_keys_report_event(bdata); 342 } 343 344 static void gpio_keys_timer(unsigned long _data) 345 { 346 struct gpio_button_data *data = (struct gpio_button_data *)_data; 347 348 schedule_work(&data->work); 349 } 350 351 static irqreturn_t gpio_keys_isr(int irq, void *dev_id) 352 { 353 struct gpio_button_data *bdata = dev_id; 354 struct gpio_keys_button *button = bdata->button; 355 356 BUG_ON(irq != gpio_to_irq(button->gpio)); 357 358 if (bdata->timer_debounce) 359 mod_timer(&bdata->timer, 360 jiffies + msecs_to_jiffies(bdata->timer_debounce)); 361 else 362 schedule_work(&bdata->work); 363 364 return IRQ_HANDLED; 365 } 366 367 static int __devinit gpio_keys_setup_key(struct platform_device *pdev, 368 struct gpio_button_data *bdata, 369 struct gpio_keys_button *button) 370 { 371 const char *desc = button->desc ? button->desc : "gpio_keys"; 372 struct device *dev = &pdev->dev; 373 unsigned long irqflags; 374 int irq, error; 375 376 setup_timer(&bdata->timer, gpio_keys_timer, (unsigned long)bdata); 377 INIT_WORK(&bdata->work, gpio_keys_work_func); 378 379 error = gpio_request(button->gpio, desc); 380 if (error < 0) { 381 dev_err(dev, "failed to request GPIO %d, error %d\n", 382 button->gpio, error); 383 goto fail2; 384 } 385 386 error = gpio_direction_input(button->gpio); 387 if (error < 0) { 388 dev_err(dev, "failed to configure" 389 " direction for GPIO %d, error %d\n", 390 button->gpio, error); 391 goto fail3; 392 } 393 394 if (button->debounce_interval) { 395 error = gpio_set_debounce(button->gpio, 396 button->debounce_interval * 1000); 397 /* use timer if gpiolib doesn't provide debounce */ 398 if (error < 0) 399 bdata->timer_debounce = button->debounce_interval; 400 } 401 402 irq = gpio_to_irq(button->gpio); 403 if (irq < 0) { 404 error = irq; 405 dev_err(dev, "Unable to get irq number for GPIO %d, error %d\n", 406 button->gpio, error); 407 goto fail3; 408 } 409 410 irqflags = IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING; 411 /* 412 * If platform has specified that the button can be disabled, 413 * we don't want it to share the interrupt line. 414 */ 415 if (!button->can_disable) 416 irqflags |= IRQF_SHARED; 417 418 error = request_any_context_irq(irq, gpio_keys_isr, irqflags, desc, bdata); 419 if (error < 0) { 420 dev_err(dev, "Unable to claim irq %d; error %d\n", 421 irq, error); 422 goto fail3; 423 } 424 425 return 0; 426 427 fail3: 428 gpio_free(button->gpio); 429 fail2: 430 return error; 431 } 432 433 static int gpio_keys_open(struct input_dev *input) 434 { 435 struct gpio_keys_drvdata *ddata = input_get_drvdata(input); 436 437 return ddata->enable ? ddata->enable(input->dev.parent) : 0; 438 } 439 440 static void gpio_keys_close(struct input_dev *input) 441 { 442 struct gpio_keys_drvdata *ddata = input_get_drvdata(input); 443 444 if (ddata->disable) 445 ddata->disable(input->dev.parent); 446 } 447 448 static int __devinit gpio_keys_probe(struct platform_device *pdev) 449 { 450 struct gpio_keys_platform_data *pdata = pdev->dev.platform_data; 451 struct gpio_keys_drvdata *ddata; 452 struct device *dev = &pdev->dev; 453 struct input_dev *input; 454 int i, error; 455 int wakeup = 0; 456 457 ddata = kzalloc(sizeof(struct gpio_keys_drvdata) + 458 pdata->nbuttons * sizeof(struct gpio_button_data), 459 GFP_KERNEL); 460 input = input_allocate_device(); 461 if (!ddata || !input) { 462 dev_err(dev, "failed to allocate state\n"); 463 error = -ENOMEM; 464 goto fail1; 465 } 466 467 ddata->input = input; 468 ddata->n_buttons = pdata->nbuttons; 469 ddata->enable = pdata->enable; 470 ddata->disable = pdata->disable; 471 mutex_init(&ddata->disable_lock); 472 473 platform_set_drvdata(pdev, ddata); 474 input_set_drvdata(input, ddata); 475 476 input->name = pdata->name ? : pdev->name; 477 input->phys = "gpio-keys/input0"; 478 input->dev.parent = &pdev->dev; 479 input->open = gpio_keys_open; 480 input->close = gpio_keys_close; 481 482 input->id.bustype = BUS_HOST; 483 input->id.vendor = 0x0001; 484 input->id.product = 0x0001; 485 input->id.version = 0x0100; 486 487 /* Enable auto repeat feature of Linux input subsystem */ 488 if (pdata->rep) 489 __set_bit(EV_REP, input->evbit); 490 491 for (i = 0; i < pdata->nbuttons; i++) { 492 struct gpio_keys_button *button = &pdata->buttons[i]; 493 struct gpio_button_data *bdata = &ddata->data[i]; 494 unsigned int type = button->type ?: EV_KEY; 495 496 bdata->input = input; 497 bdata->button = button; 498 499 error = gpio_keys_setup_key(pdev, bdata, button); 500 if (error) 501 goto fail2; 502 503 if (button->wakeup) 504 wakeup = 1; 505 506 input_set_capability(input, type, button->code); 507 } 508 509 error = sysfs_create_group(&pdev->dev.kobj, &gpio_keys_attr_group); 510 if (error) { 511 dev_err(dev, "Unable to export keys/switches, error: %d\n", 512 error); 513 goto fail2; 514 } 515 516 error = input_register_device(input); 517 if (error) { 518 dev_err(dev, "Unable to register input device, error: %d\n", 519 error); 520 goto fail3; 521 } 522 523 /* get current state of buttons */ 524 for (i = 0; i < pdata->nbuttons; i++) 525 gpio_keys_report_event(&ddata->data[i]); 526 input_sync(input); 527 528 device_init_wakeup(&pdev->dev, wakeup); 529 530 return 0; 531 532 fail3: 533 sysfs_remove_group(&pdev->dev.kobj, &gpio_keys_attr_group); 534 fail2: 535 while (--i >= 0) { 536 free_irq(gpio_to_irq(pdata->buttons[i].gpio), &ddata->data[i]); 537 if (ddata->data[i].timer_debounce) 538 del_timer_sync(&ddata->data[i].timer); 539 cancel_work_sync(&ddata->data[i].work); 540 gpio_free(pdata->buttons[i].gpio); 541 } 542 543 platform_set_drvdata(pdev, NULL); 544 fail1: 545 input_free_device(input); 546 kfree(ddata); 547 548 return error; 549 } 550 551 static int __devexit gpio_keys_remove(struct platform_device *pdev) 552 { 553 struct gpio_keys_platform_data *pdata = pdev->dev.platform_data; 554 struct gpio_keys_drvdata *ddata = platform_get_drvdata(pdev); 555 struct input_dev *input = ddata->input; 556 int i; 557 558 sysfs_remove_group(&pdev->dev.kobj, &gpio_keys_attr_group); 559 560 device_init_wakeup(&pdev->dev, 0); 561 562 for (i = 0; i < pdata->nbuttons; i++) { 563 int irq = gpio_to_irq(pdata->buttons[i].gpio); 564 free_irq(irq, &ddata->data[i]); 565 if (ddata->data[i].timer_debounce) 566 del_timer_sync(&ddata->data[i].timer); 567 cancel_work_sync(&ddata->data[i].work); 568 gpio_free(pdata->buttons[i].gpio); 569 } 570 571 input_unregister_device(input); 572 573 return 0; 574 } 575 576 577 #ifdef CONFIG_PM 578 static int gpio_keys_suspend(struct device *dev) 579 { 580 struct platform_device *pdev = to_platform_device(dev); 581 struct gpio_keys_platform_data *pdata = pdev->dev.platform_data; 582 int i; 583 584 if (device_may_wakeup(&pdev->dev)) { 585 for (i = 0; i < pdata->nbuttons; i++) { 586 struct gpio_keys_button *button = &pdata->buttons[i]; 587 if (button->wakeup) { 588 int irq = gpio_to_irq(button->gpio); 589 enable_irq_wake(irq); 590 } 591 } 592 } 593 594 return 0; 595 } 596 597 static int gpio_keys_resume(struct device *dev) 598 { 599 struct platform_device *pdev = to_platform_device(dev); 600 struct gpio_keys_drvdata *ddata = platform_get_drvdata(pdev); 601 struct gpio_keys_platform_data *pdata = pdev->dev.platform_data; 602 int i; 603 604 for (i = 0; i < pdata->nbuttons; i++) { 605 606 struct gpio_keys_button *button = &pdata->buttons[i]; 607 if (button->wakeup && device_may_wakeup(&pdev->dev)) { 608 int irq = gpio_to_irq(button->gpio); 609 disable_irq_wake(irq); 610 } 611 612 gpio_keys_report_event(&ddata->data[i]); 613 } 614 input_sync(ddata->input); 615 616 return 0; 617 } 618 619 static const struct dev_pm_ops gpio_keys_pm_ops = { 620 .suspend = gpio_keys_suspend, 621 .resume = gpio_keys_resume, 622 }; 623 #endif 624 625 static struct platform_driver gpio_keys_device_driver = { 626 .probe = gpio_keys_probe, 627 .remove = __devexit_p(gpio_keys_remove), 628 .driver = { 629 .name = "gpio-keys", 630 .owner = THIS_MODULE, 631 #ifdef CONFIG_PM 632 .pm = &gpio_keys_pm_ops, 633 #endif 634 } 635 }; 636 637 static int __init gpio_keys_init(void) 638 { 639 return platform_driver_register(&gpio_keys_device_driver); 640 } 641 642 static void __exit gpio_keys_exit(void) 643 { 644 platform_driver_unregister(&gpio_keys_device_driver); 645 } 646 647 module_init(gpio_keys_init); 648 module_exit(gpio_keys_exit); 649 650 MODULE_LICENSE("GPL"); 651 MODULE_AUTHOR("Phil Blundell <pb@handhelds.org>"); 652 MODULE_DESCRIPTION("Keyboard driver for CPU GPIOs"); 653 MODULE_ALIAS("platform:gpio-keys"); 654