1 /* 2 * The input core 3 * 4 * Copyright (c) 1999-2002 Vojtech Pavlik 5 */ 6 7 /* 8 * This program is free software; you can redistribute it and/or modify it 9 * under the terms of the GNU General Public License version 2 as published by 10 * the Free Software Foundation. 11 */ 12 13 #include <linux/init.h> 14 #include <linux/sched.h> 15 #include <linux/smp_lock.h> 16 #include <linux/input.h> 17 #include <linux/module.h> 18 #include <linux/random.h> 19 #include <linux/major.h> 20 #include <linux/proc_fs.h> 21 #include <linux/seq_file.h> 22 #include <linux/interrupt.h> 23 #include <linux/poll.h> 24 #include <linux/device.h> 25 #include <linux/mutex.h> 26 27 MODULE_AUTHOR("Vojtech Pavlik <vojtech@suse.cz>"); 28 MODULE_DESCRIPTION("Input core"); 29 MODULE_LICENSE("GPL"); 30 31 EXPORT_SYMBOL(input_allocate_device); 32 EXPORT_SYMBOL(input_register_device); 33 EXPORT_SYMBOL(input_unregister_device); 34 EXPORT_SYMBOL(input_register_handler); 35 EXPORT_SYMBOL(input_unregister_handler); 36 EXPORT_SYMBOL(input_grab_device); 37 EXPORT_SYMBOL(input_release_device); 38 EXPORT_SYMBOL(input_open_device); 39 EXPORT_SYMBOL(input_close_device); 40 EXPORT_SYMBOL(input_accept_process); 41 EXPORT_SYMBOL(input_flush_device); 42 EXPORT_SYMBOL(input_event); 43 EXPORT_SYMBOL_GPL(input_class); 44 45 #define INPUT_DEVICES 256 46 47 static LIST_HEAD(input_dev_list); 48 static LIST_HEAD(input_handler_list); 49 50 static struct input_handler *input_table[8]; 51 52 void input_event(struct input_dev *dev, unsigned int type, unsigned int code, int value) 53 { 54 struct input_handle *handle; 55 56 if (type > EV_MAX || !test_bit(type, dev->evbit)) 57 return; 58 59 add_input_randomness(type, code, value); 60 61 switch (type) { 62 63 case EV_SYN: 64 switch (code) { 65 case SYN_CONFIG: 66 if (dev->event) dev->event(dev, type, code, value); 67 break; 68 69 case SYN_REPORT: 70 if (dev->sync) return; 71 dev->sync = 1; 72 break; 73 } 74 break; 75 76 case EV_KEY: 77 78 if (code > KEY_MAX || !test_bit(code, dev->keybit) || !!test_bit(code, dev->key) == value) 79 return; 80 81 if (value == 2) 82 break; 83 84 change_bit(code, dev->key); 85 86 if (test_bit(EV_REP, dev->evbit) && dev->rep[REP_PERIOD] && dev->rep[REP_DELAY] && dev->timer.data && value) { 87 dev->repeat_key = code; 88 mod_timer(&dev->timer, jiffies + msecs_to_jiffies(dev->rep[REP_DELAY])); 89 } 90 91 break; 92 93 case EV_SW: 94 95 if (code > SW_MAX || !test_bit(code, dev->swbit) || !!test_bit(code, dev->sw) == value) 96 return; 97 98 change_bit(code, dev->sw); 99 100 break; 101 102 case EV_ABS: 103 104 if (code > ABS_MAX || !test_bit(code, dev->absbit)) 105 return; 106 107 if (dev->absfuzz[code]) { 108 if ((value > dev->abs[code] - (dev->absfuzz[code] >> 1)) && 109 (value < dev->abs[code] + (dev->absfuzz[code] >> 1))) 110 return; 111 112 if ((value > dev->abs[code] - dev->absfuzz[code]) && 113 (value < dev->abs[code] + dev->absfuzz[code])) 114 value = (dev->abs[code] * 3 + value) >> 2; 115 116 if ((value > dev->abs[code] - (dev->absfuzz[code] << 1)) && 117 (value < dev->abs[code] + (dev->absfuzz[code] << 1))) 118 value = (dev->abs[code] + value) >> 1; 119 } 120 121 if (dev->abs[code] == value) 122 return; 123 124 dev->abs[code] = value; 125 break; 126 127 case EV_REL: 128 129 if (code > REL_MAX || !test_bit(code, dev->relbit) || (value == 0)) 130 return; 131 132 break; 133 134 case EV_MSC: 135 136 if (code > MSC_MAX || !test_bit(code, dev->mscbit)) 137 return; 138 139 if (dev->event) dev->event(dev, type, code, value); 140 141 break; 142 143 case EV_LED: 144 145 if (code > LED_MAX || !test_bit(code, dev->ledbit) || !!test_bit(code, dev->led) == value) 146 return; 147 148 change_bit(code, dev->led); 149 if (dev->event) dev->event(dev, type, code, value); 150 151 break; 152 153 case EV_SND: 154 155 if (code > SND_MAX || !test_bit(code, dev->sndbit)) 156 return; 157 158 if (!!test_bit(code, dev->snd) != !!value) 159 change_bit(code, dev->snd); 160 161 if (dev->event) dev->event(dev, type, code, value); 162 163 break; 164 165 case EV_REP: 166 167 if (code > REP_MAX || value < 0 || dev->rep[code] == value) return; 168 169 dev->rep[code] = value; 170 if (dev->event) dev->event(dev, type, code, value); 171 172 break; 173 174 case EV_FF: 175 if (dev->event) dev->event(dev, type, code, value); 176 break; 177 } 178 179 if (type != EV_SYN) 180 dev->sync = 0; 181 182 if (dev->grab) 183 dev->grab->handler->event(dev->grab, type, code, value); 184 else 185 list_for_each_entry(handle, &dev->h_list, d_node) 186 if (handle->open) 187 handle->handler->event(handle, type, code, value); 188 } 189 190 static void input_repeat_key(unsigned long data) 191 { 192 struct input_dev *dev = (void *) data; 193 194 if (!test_bit(dev->repeat_key, dev->key)) 195 return; 196 197 input_event(dev, EV_KEY, dev->repeat_key, 2); 198 input_sync(dev); 199 200 if (dev->rep[REP_PERIOD]) 201 mod_timer(&dev->timer, jiffies + msecs_to_jiffies(dev->rep[REP_PERIOD])); 202 } 203 204 int input_accept_process(struct input_handle *handle, struct file *file) 205 { 206 if (handle->dev->accept) 207 return handle->dev->accept(handle->dev, file); 208 209 return 0; 210 } 211 212 int input_grab_device(struct input_handle *handle) 213 { 214 if (handle->dev->grab) 215 return -EBUSY; 216 217 handle->dev->grab = handle; 218 return 0; 219 } 220 221 void input_release_device(struct input_handle *handle) 222 { 223 if (handle->dev->grab == handle) 224 handle->dev->grab = NULL; 225 } 226 227 int input_open_device(struct input_handle *handle) 228 { 229 struct input_dev *dev = handle->dev; 230 int err; 231 232 err = mutex_lock_interruptible(&dev->mutex); 233 if (err) 234 return err; 235 236 handle->open++; 237 238 if (!dev->users++ && dev->open) 239 err = dev->open(dev); 240 241 if (err) 242 handle->open--; 243 244 mutex_unlock(&dev->mutex); 245 246 return err; 247 } 248 249 int input_flush_device(struct input_handle* handle, struct file* file) 250 { 251 if (handle->dev->flush) 252 return handle->dev->flush(handle->dev, file); 253 254 return 0; 255 } 256 257 void input_close_device(struct input_handle *handle) 258 { 259 struct input_dev *dev = handle->dev; 260 261 input_release_device(handle); 262 263 mutex_lock(&dev->mutex); 264 265 if (!--dev->users && dev->close) 266 dev->close(dev); 267 handle->open--; 268 269 mutex_unlock(&dev->mutex); 270 } 271 272 static void input_link_handle(struct input_handle *handle) 273 { 274 list_add_tail(&handle->d_node, &handle->dev->h_list); 275 list_add_tail(&handle->h_node, &handle->handler->h_list); 276 } 277 278 #define MATCH_BIT(bit, max) \ 279 for (i = 0; i < NBITS(max); i++) \ 280 if ((id->bit[i] & dev->bit[i]) != id->bit[i]) \ 281 break; \ 282 if (i != NBITS(max)) \ 283 continue; 284 285 static struct input_device_id *input_match_device(struct input_device_id *id, struct input_dev *dev) 286 { 287 int i; 288 289 for (; id->flags || id->driver_info; id++) { 290 291 if (id->flags & INPUT_DEVICE_ID_MATCH_BUS) 292 if (id->bustype != dev->id.bustype) 293 continue; 294 295 if (id->flags & INPUT_DEVICE_ID_MATCH_VENDOR) 296 if (id->vendor != dev->id.vendor) 297 continue; 298 299 if (id->flags & INPUT_DEVICE_ID_MATCH_PRODUCT) 300 if (id->product != dev->id.product) 301 continue; 302 303 if (id->flags & INPUT_DEVICE_ID_MATCH_VERSION) 304 if (id->version != dev->id.version) 305 continue; 306 307 MATCH_BIT(evbit, EV_MAX); 308 MATCH_BIT(keybit, KEY_MAX); 309 MATCH_BIT(relbit, REL_MAX); 310 MATCH_BIT(absbit, ABS_MAX); 311 MATCH_BIT(mscbit, MSC_MAX); 312 MATCH_BIT(ledbit, LED_MAX); 313 MATCH_BIT(sndbit, SND_MAX); 314 MATCH_BIT(ffbit, FF_MAX); 315 MATCH_BIT(swbit, SW_MAX); 316 317 return id; 318 } 319 320 return NULL; 321 } 322 323 #ifdef CONFIG_PROC_FS 324 325 static struct proc_dir_entry *proc_bus_input_dir; 326 static DECLARE_WAIT_QUEUE_HEAD(input_devices_poll_wait); 327 static int input_devices_state; 328 329 static inline void input_wakeup_procfs_readers(void) 330 { 331 input_devices_state++; 332 wake_up(&input_devices_poll_wait); 333 } 334 335 static unsigned int input_proc_devices_poll(struct file *file, poll_table *wait) 336 { 337 int state = input_devices_state; 338 poll_wait(file, &input_devices_poll_wait, wait); 339 if (state != input_devices_state) 340 return POLLIN | POLLRDNORM; 341 return 0; 342 } 343 344 static struct list_head *list_get_nth_element(struct list_head *list, loff_t *pos) 345 { 346 struct list_head *node; 347 loff_t i = 0; 348 349 list_for_each(node, list) 350 if (i++ == *pos) 351 return node; 352 353 return NULL; 354 } 355 356 static struct list_head *list_get_next_element(struct list_head *list, struct list_head *element, loff_t *pos) 357 { 358 if (element->next == list) 359 return NULL; 360 361 ++(*pos); 362 return element->next; 363 } 364 365 static void *input_devices_seq_start(struct seq_file *seq, loff_t *pos) 366 { 367 /* acquire lock here ... Yes, we do need locking, I knowi, I know... */ 368 369 return list_get_nth_element(&input_dev_list, pos); 370 } 371 372 static void *input_devices_seq_next(struct seq_file *seq, void *v, loff_t *pos) 373 { 374 return list_get_next_element(&input_dev_list, v, pos); 375 } 376 377 static void input_devices_seq_stop(struct seq_file *seq, void *v) 378 { 379 /* release lock here */ 380 } 381 382 static void input_seq_print_bitmap(struct seq_file *seq, const char *name, 383 unsigned long *bitmap, int max) 384 { 385 int i; 386 387 for (i = NBITS(max) - 1; i > 0; i--) 388 if (bitmap[i]) 389 break; 390 391 seq_printf(seq, "B: %s=", name); 392 for (; i >= 0; i--) 393 seq_printf(seq, "%lx%s", bitmap[i], i > 0 ? " " : ""); 394 seq_putc(seq, '\n'); 395 } 396 397 static int input_devices_seq_show(struct seq_file *seq, void *v) 398 { 399 struct input_dev *dev = container_of(v, struct input_dev, node); 400 const char *path = kobject_get_path(&dev->cdev.kobj, GFP_KERNEL); 401 struct input_handle *handle; 402 403 seq_printf(seq, "I: Bus=%04x Vendor=%04x Product=%04x Version=%04x\n", 404 dev->id.bustype, dev->id.vendor, dev->id.product, dev->id.version); 405 406 seq_printf(seq, "N: Name=\"%s\"\n", dev->name ? dev->name : ""); 407 seq_printf(seq, "P: Phys=%s\n", dev->phys ? dev->phys : ""); 408 seq_printf(seq, "S: Sysfs=%s\n", path ? path : ""); 409 seq_printf(seq, "H: Handlers="); 410 411 list_for_each_entry(handle, &dev->h_list, d_node) 412 seq_printf(seq, "%s ", handle->name); 413 seq_putc(seq, '\n'); 414 415 input_seq_print_bitmap(seq, "EV", dev->evbit, EV_MAX); 416 if (test_bit(EV_KEY, dev->evbit)) 417 input_seq_print_bitmap(seq, "KEY", dev->keybit, KEY_MAX); 418 if (test_bit(EV_REL, dev->evbit)) 419 input_seq_print_bitmap(seq, "REL", dev->relbit, REL_MAX); 420 if (test_bit(EV_ABS, dev->evbit)) 421 input_seq_print_bitmap(seq, "ABS", dev->absbit, ABS_MAX); 422 if (test_bit(EV_MSC, dev->evbit)) 423 input_seq_print_bitmap(seq, "MSC", dev->mscbit, MSC_MAX); 424 if (test_bit(EV_LED, dev->evbit)) 425 input_seq_print_bitmap(seq, "LED", dev->ledbit, LED_MAX); 426 if (test_bit(EV_SND, dev->evbit)) 427 input_seq_print_bitmap(seq, "SND", dev->sndbit, SND_MAX); 428 if (test_bit(EV_FF, dev->evbit)) 429 input_seq_print_bitmap(seq, "FF", dev->ffbit, FF_MAX); 430 if (test_bit(EV_SW, dev->evbit)) 431 input_seq_print_bitmap(seq, "SW", dev->swbit, SW_MAX); 432 433 seq_putc(seq, '\n'); 434 435 kfree(path); 436 return 0; 437 } 438 439 static struct seq_operations input_devices_seq_ops = { 440 .start = input_devices_seq_start, 441 .next = input_devices_seq_next, 442 .stop = input_devices_seq_stop, 443 .show = input_devices_seq_show, 444 }; 445 446 static int input_proc_devices_open(struct inode *inode, struct file *file) 447 { 448 return seq_open(file, &input_devices_seq_ops); 449 } 450 451 static struct file_operations input_devices_fileops = { 452 .owner = THIS_MODULE, 453 .open = input_proc_devices_open, 454 .poll = input_proc_devices_poll, 455 .read = seq_read, 456 .llseek = seq_lseek, 457 .release = seq_release, 458 }; 459 460 static void *input_handlers_seq_start(struct seq_file *seq, loff_t *pos) 461 { 462 /* acquire lock here ... Yes, we do need locking, I knowi, I know... */ 463 seq->private = (void *)(unsigned long)*pos; 464 return list_get_nth_element(&input_handler_list, pos); 465 } 466 467 static void *input_handlers_seq_next(struct seq_file *seq, void *v, loff_t *pos) 468 { 469 seq->private = (void *)(unsigned long)(*pos + 1); 470 return list_get_next_element(&input_handler_list, v, pos); 471 } 472 473 static void input_handlers_seq_stop(struct seq_file *seq, void *v) 474 { 475 /* release lock here */ 476 } 477 478 static int input_handlers_seq_show(struct seq_file *seq, void *v) 479 { 480 struct input_handler *handler = container_of(v, struct input_handler, node); 481 482 seq_printf(seq, "N: Number=%ld Name=%s", 483 (unsigned long)seq->private, handler->name); 484 if (handler->fops) 485 seq_printf(seq, " Minor=%d", handler->minor); 486 seq_putc(seq, '\n'); 487 488 return 0; 489 } 490 static struct seq_operations input_handlers_seq_ops = { 491 .start = input_handlers_seq_start, 492 .next = input_handlers_seq_next, 493 .stop = input_handlers_seq_stop, 494 .show = input_handlers_seq_show, 495 }; 496 497 static int input_proc_handlers_open(struct inode *inode, struct file *file) 498 { 499 return seq_open(file, &input_handlers_seq_ops); 500 } 501 502 static struct file_operations input_handlers_fileops = { 503 .owner = THIS_MODULE, 504 .open = input_proc_handlers_open, 505 .read = seq_read, 506 .llseek = seq_lseek, 507 .release = seq_release, 508 }; 509 510 static int __init input_proc_init(void) 511 { 512 struct proc_dir_entry *entry; 513 514 proc_bus_input_dir = proc_mkdir("input", proc_bus); 515 if (!proc_bus_input_dir) 516 return -ENOMEM; 517 518 proc_bus_input_dir->owner = THIS_MODULE; 519 520 entry = create_proc_entry("devices", 0, proc_bus_input_dir); 521 if (!entry) 522 goto fail1; 523 524 entry->owner = THIS_MODULE; 525 entry->proc_fops = &input_devices_fileops; 526 527 entry = create_proc_entry("handlers", 0, proc_bus_input_dir); 528 if (!entry) 529 goto fail2; 530 531 entry->owner = THIS_MODULE; 532 entry->proc_fops = &input_handlers_fileops; 533 534 return 0; 535 536 fail2: remove_proc_entry("devices", proc_bus_input_dir); 537 fail1: remove_proc_entry("input", proc_bus); 538 return -ENOMEM; 539 } 540 541 static void input_proc_exit(void) 542 { 543 remove_proc_entry("devices", proc_bus_input_dir); 544 remove_proc_entry("handlers", proc_bus_input_dir); 545 remove_proc_entry("input", proc_bus); 546 } 547 548 #else /* !CONFIG_PROC_FS */ 549 static inline void input_wakeup_procfs_readers(void) { } 550 static inline int input_proc_init(void) { return 0; } 551 static inline void input_proc_exit(void) { } 552 #endif 553 554 #define INPUT_DEV_STRING_ATTR_SHOW(name) \ 555 static ssize_t input_dev_show_##name(struct class_device *dev, char *buf) \ 556 { \ 557 struct input_dev *input_dev = to_input_dev(dev); \ 558 int retval; \ 559 \ 560 retval = mutex_lock_interruptible(&input_dev->mutex); \ 561 if (retval) \ 562 return retval; \ 563 \ 564 retval = scnprintf(buf, PAGE_SIZE, \ 565 "%s\n", input_dev->name ? input_dev->name : ""); \ 566 \ 567 mutex_unlock(&input_dev->mutex); \ 568 \ 569 return retval; \ 570 } \ 571 static CLASS_DEVICE_ATTR(name, S_IRUGO, input_dev_show_##name, NULL); 572 573 INPUT_DEV_STRING_ATTR_SHOW(name); 574 INPUT_DEV_STRING_ATTR_SHOW(phys); 575 INPUT_DEV_STRING_ATTR_SHOW(uniq); 576 577 static int input_print_modalias_bits(char *buf, int size, 578 char name, unsigned long *bm, 579 unsigned int min_bit, unsigned int max_bit) 580 { 581 int len = 0, i; 582 583 len += snprintf(buf, max(size, 0), "%c", name); 584 for (i = min_bit; i < max_bit; i++) 585 if (bm[LONG(i)] & BIT(i)) 586 len += snprintf(buf + len, max(size - len, 0), "%X,", i); 587 return len; 588 } 589 590 static int input_print_modalias(char *buf, int size, struct input_dev *id, 591 int add_cr) 592 { 593 int len; 594 595 len = snprintf(buf, max(size, 0), 596 "input:b%04Xv%04Xp%04Xe%04X-", 597 id->id.bustype, id->id.vendor, 598 id->id.product, id->id.version); 599 600 len += input_print_modalias_bits(buf + len, size - len, 601 'e', id->evbit, 0, EV_MAX); 602 len += input_print_modalias_bits(buf + len, size - len, 603 'k', id->keybit, KEY_MIN_INTERESTING, KEY_MAX); 604 len += input_print_modalias_bits(buf + len, size - len, 605 'r', id->relbit, 0, REL_MAX); 606 len += input_print_modalias_bits(buf + len, size - len, 607 'a', id->absbit, 0, ABS_MAX); 608 len += input_print_modalias_bits(buf + len, size - len, 609 'm', id->mscbit, 0, MSC_MAX); 610 len += input_print_modalias_bits(buf + len, size - len, 611 'l', id->ledbit, 0, LED_MAX); 612 len += input_print_modalias_bits(buf + len, size - len, 613 's', id->sndbit, 0, SND_MAX); 614 len += input_print_modalias_bits(buf + len, size - len, 615 'f', id->ffbit, 0, FF_MAX); 616 len += input_print_modalias_bits(buf + len, size - len, 617 'w', id->swbit, 0, SW_MAX); 618 619 if (add_cr) 620 len += snprintf(buf + len, max(size - len, 0), "\n"); 621 622 return len; 623 } 624 625 static ssize_t input_dev_show_modalias(struct class_device *dev, char *buf) 626 { 627 struct input_dev *id = to_input_dev(dev); 628 ssize_t len; 629 630 len = input_print_modalias(buf, PAGE_SIZE, id, 1); 631 632 return max_t(int, len, PAGE_SIZE); 633 } 634 static CLASS_DEVICE_ATTR(modalias, S_IRUGO, input_dev_show_modalias, NULL); 635 636 static struct attribute *input_dev_attrs[] = { 637 &class_device_attr_name.attr, 638 &class_device_attr_phys.attr, 639 &class_device_attr_uniq.attr, 640 &class_device_attr_modalias.attr, 641 NULL 642 }; 643 644 static struct attribute_group input_dev_attr_group = { 645 .attrs = input_dev_attrs, 646 }; 647 648 #define INPUT_DEV_ID_ATTR(name) \ 649 static ssize_t input_dev_show_id_##name(struct class_device *dev, char *buf) \ 650 { \ 651 struct input_dev *input_dev = to_input_dev(dev); \ 652 return scnprintf(buf, PAGE_SIZE, "%04x\n", input_dev->id.name); \ 653 } \ 654 static CLASS_DEVICE_ATTR(name, S_IRUGO, input_dev_show_id_##name, NULL); 655 656 INPUT_DEV_ID_ATTR(bustype); 657 INPUT_DEV_ID_ATTR(vendor); 658 INPUT_DEV_ID_ATTR(product); 659 INPUT_DEV_ID_ATTR(version); 660 661 static struct attribute *input_dev_id_attrs[] = { 662 &class_device_attr_bustype.attr, 663 &class_device_attr_vendor.attr, 664 &class_device_attr_product.attr, 665 &class_device_attr_version.attr, 666 NULL 667 }; 668 669 static struct attribute_group input_dev_id_attr_group = { 670 .name = "id", 671 .attrs = input_dev_id_attrs, 672 }; 673 674 static int input_print_bitmap(char *buf, int buf_size, unsigned long *bitmap, 675 int max, int add_cr) 676 { 677 int i; 678 int len = 0; 679 680 for (i = NBITS(max) - 1; i > 0; i--) 681 if (bitmap[i]) 682 break; 683 684 for (; i >= 0; i--) 685 len += snprintf(buf + len, max(buf_size - len, 0), 686 "%lx%s", bitmap[i], i > 0 ? " " : ""); 687 688 if (add_cr) 689 len += snprintf(buf + len, max(buf_size - len, 0), "\n"); 690 691 return len; 692 } 693 694 #define INPUT_DEV_CAP_ATTR(ev, bm) \ 695 static ssize_t input_dev_show_cap_##bm(struct class_device *dev, char *buf) \ 696 { \ 697 struct input_dev *input_dev = to_input_dev(dev); \ 698 int len = input_print_bitmap(buf, PAGE_SIZE, \ 699 input_dev->bm##bit, ev##_MAX, 1); \ 700 return min_t(int, len, PAGE_SIZE); \ 701 } \ 702 static CLASS_DEVICE_ATTR(bm, S_IRUGO, input_dev_show_cap_##bm, NULL); 703 704 INPUT_DEV_CAP_ATTR(EV, ev); 705 INPUT_DEV_CAP_ATTR(KEY, key); 706 INPUT_DEV_CAP_ATTR(REL, rel); 707 INPUT_DEV_CAP_ATTR(ABS, abs); 708 INPUT_DEV_CAP_ATTR(MSC, msc); 709 INPUT_DEV_CAP_ATTR(LED, led); 710 INPUT_DEV_CAP_ATTR(SND, snd); 711 INPUT_DEV_CAP_ATTR(FF, ff); 712 INPUT_DEV_CAP_ATTR(SW, sw); 713 714 static struct attribute *input_dev_caps_attrs[] = { 715 &class_device_attr_ev.attr, 716 &class_device_attr_key.attr, 717 &class_device_attr_rel.attr, 718 &class_device_attr_abs.attr, 719 &class_device_attr_msc.attr, 720 &class_device_attr_led.attr, 721 &class_device_attr_snd.attr, 722 &class_device_attr_ff.attr, 723 &class_device_attr_sw.attr, 724 NULL 725 }; 726 727 static struct attribute_group input_dev_caps_attr_group = { 728 .name = "capabilities", 729 .attrs = input_dev_caps_attrs, 730 }; 731 732 static void input_dev_release(struct class_device *class_dev) 733 { 734 struct input_dev *dev = to_input_dev(class_dev); 735 736 kfree(dev); 737 module_put(THIS_MODULE); 738 } 739 740 /* 741 * Input uevent interface - loading event handlers based on 742 * device bitfields. 743 */ 744 static int input_add_uevent_bm_var(char **envp, int num_envp, int *cur_index, 745 char *buffer, int buffer_size, int *cur_len, 746 const char *name, unsigned long *bitmap, int max) 747 { 748 if (*cur_index >= num_envp - 1) 749 return -ENOMEM; 750 751 envp[*cur_index] = buffer + *cur_len; 752 753 *cur_len += snprintf(buffer + *cur_len, max(buffer_size - *cur_len, 0), name); 754 if (*cur_len >= buffer_size) 755 return -ENOMEM; 756 757 *cur_len += input_print_bitmap(buffer + *cur_len, 758 max(buffer_size - *cur_len, 0), 759 bitmap, max, 0) + 1; 760 if (*cur_len > buffer_size) 761 return -ENOMEM; 762 763 (*cur_index)++; 764 return 0; 765 } 766 767 static int input_add_uevent_modalias_var(char **envp, int num_envp, int *cur_index, 768 char *buffer, int buffer_size, int *cur_len, 769 struct input_dev *dev) 770 { 771 if (*cur_index >= num_envp - 1) 772 return -ENOMEM; 773 774 envp[*cur_index] = buffer + *cur_len; 775 776 *cur_len += snprintf(buffer + *cur_len, max(buffer_size - *cur_len, 0), 777 "MODALIAS="); 778 if (*cur_len >= buffer_size) 779 return -ENOMEM; 780 781 *cur_len += input_print_modalias(buffer + *cur_len, 782 max(buffer_size - *cur_len, 0), 783 dev, 0) + 1; 784 if (*cur_len > buffer_size) 785 return -ENOMEM; 786 787 (*cur_index)++; 788 return 0; 789 } 790 791 #define INPUT_ADD_HOTPLUG_VAR(fmt, val...) \ 792 do { \ 793 int err = add_uevent_var(envp, num_envp, &i, \ 794 buffer, buffer_size, &len, \ 795 fmt, val); \ 796 if (err) \ 797 return err; \ 798 } while (0) 799 800 #define INPUT_ADD_HOTPLUG_BM_VAR(name, bm, max) \ 801 do { \ 802 int err = input_add_uevent_bm_var(envp, num_envp, &i, \ 803 buffer, buffer_size, &len, \ 804 name, bm, max); \ 805 if (err) \ 806 return err; \ 807 } while (0) 808 809 #define INPUT_ADD_HOTPLUG_MODALIAS_VAR(dev) \ 810 do { \ 811 int err = input_add_uevent_modalias_var(envp, \ 812 num_envp, &i, \ 813 buffer, buffer_size, &len, \ 814 dev); \ 815 if (err) \ 816 return err; \ 817 } while (0) 818 819 static int input_dev_uevent(struct class_device *cdev, char **envp, 820 int num_envp, char *buffer, int buffer_size) 821 { 822 struct input_dev *dev = to_input_dev(cdev); 823 int i = 0; 824 int len = 0; 825 826 INPUT_ADD_HOTPLUG_VAR("PRODUCT=%x/%x/%x/%x", 827 dev->id.bustype, dev->id.vendor, 828 dev->id.product, dev->id.version); 829 if (dev->name) 830 INPUT_ADD_HOTPLUG_VAR("NAME=\"%s\"", dev->name); 831 if (dev->phys) 832 INPUT_ADD_HOTPLUG_VAR("PHYS=\"%s\"", dev->phys); 833 if (dev->uniq) 834 INPUT_ADD_HOTPLUG_VAR("UNIQ=\"%s\"", dev->uniq); 835 836 INPUT_ADD_HOTPLUG_BM_VAR("EV=", dev->evbit, EV_MAX); 837 if (test_bit(EV_KEY, dev->evbit)) 838 INPUT_ADD_HOTPLUG_BM_VAR("KEY=", dev->keybit, KEY_MAX); 839 if (test_bit(EV_REL, dev->evbit)) 840 INPUT_ADD_HOTPLUG_BM_VAR("REL=", dev->relbit, REL_MAX); 841 if (test_bit(EV_ABS, dev->evbit)) 842 INPUT_ADD_HOTPLUG_BM_VAR("ABS=", dev->absbit, ABS_MAX); 843 if (test_bit(EV_MSC, dev->evbit)) 844 INPUT_ADD_HOTPLUG_BM_VAR("MSC=", dev->mscbit, MSC_MAX); 845 if (test_bit(EV_LED, dev->evbit)) 846 INPUT_ADD_HOTPLUG_BM_VAR("LED=", dev->ledbit, LED_MAX); 847 if (test_bit(EV_SND, dev->evbit)) 848 INPUT_ADD_HOTPLUG_BM_VAR("SND=", dev->sndbit, SND_MAX); 849 if (test_bit(EV_FF, dev->evbit)) 850 INPUT_ADD_HOTPLUG_BM_VAR("FF=", dev->ffbit, FF_MAX); 851 if (test_bit(EV_SW, dev->evbit)) 852 INPUT_ADD_HOTPLUG_BM_VAR("SW=", dev->swbit, SW_MAX); 853 854 INPUT_ADD_HOTPLUG_MODALIAS_VAR(dev); 855 856 envp[i] = NULL; 857 return 0; 858 } 859 860 struct class input_class = { 861 .name = "input", 862 .release = input_dev_release, 863 .uevent = input_dev_uevent, 864 }; 865 866 struct input_dev *input_allocate_device(void) 867 { 868 struct input_dev *dev; 869 870 dev = kzalloc(sizeof(struct input_dev), GFP_KERNEL); 871 if (dev) { 872 dev->dynalloc = 1; 873 dev->cdev.class = &input_class; 874 class_device_initialize(&dev->cdev); 875 INIT_LIST_HEAD(&dev->h_list); 876 INIT_LIST_HEAD(&dev->node); 877 } 878 879 return dev; 880 } 881 882 int input_register_device(struct input_dev *dev) 883 { 884 static atomic_t input_no = ATOMIC_INIT(0); 885 struct input_handle *handle; 886 struct input_handler *handler; 887 struct input_device_id *id; 888 const char *path; 889 int error; 890 891 if (!dev->dynalloc) { 892 printk(KERN_WARNING "input: device %s is statically allocated, will not register\n" 893 "Please convert to input_allocate_device() or contact dtor_core@ameritech.net\n", 894 dev->name ? dev->name : "<Unknown>"); 895 return -EINVAL; 896 } 897 898 mutex_init(&dev->mutex); 899 set_bit(EV_SYN, dev->evbit); 900 901 /* 902 * If delay and period are pre-set by the driver, then autorepeating 903 * is handled by the driver itself and we don't do it in input.c. 904 */ 905 906 init_timer(&dev->timer); 907 if (!dev->rep[REP_DELAY] && !dev->rep[REP_PERIOD]) { 908 dev->timer.data = (long) dev; 909 dev->timer.function = input_repeat_key; 910 dev->rep[REP_DELAY] = 250; 911 dev->rep[REP_PERIOD] = 33; 912 } 913 914 INIT_LIST_HEAD(&dev->h_list); 915 list_add_tail(&dev->node, &input_dev_list); 916 917 dev->cdev.class = &input_class; 918 snprintf(dev->cdev.class_id, sizeof(dev->cdev.class_id), 919 "input%ld", (unsigned long) atomic_inc_return(&input_no) - 1); 920 921 error = class_device_add(&dev->cdev); 922 if (error) 923 return error; 924 925 error = sysfs_create_group(&dev->cdev.kobj, &input_dev_attr_group); 926 if (error) 927 goto fail1; 928 929 error = sysfs_create_group(&dev->cdev.kobj, &input_dev_id_attr_group); 930 if (error) 931 goto fail2; 932 933 error = sysfs_create_group(&dev->cdev.kobj, &input_dev_caps_attr_group); 934 if (error) 935 goto fail3; 936 937 __module_get(THIS_MODULE); 938 939 path = kobject_get_path(&dev->cdev.kobj, GFP_KERNEL); 940 printk(KERN_INFO "input: %s as %s\n", 941 dev->name ? dev->name : "Unspecified device", path ? path : "N/A"); 942 kfree(path); 943 944 list_for_each_entry(handler, &input_handler_list, node) 945 if (!handler->blacklist || !input_match_device(handler->blacklist, dev)) 946 if ((id = input_match_device(handler->id_table, dev))) 947 if ((handle = handler->connect(handler, dev, id))) 948 input_link_handle(handle); 949 950 input_wakeup_procfs_readers(); 951 952 return 0; 953 954 fail3: sysfs_remove_group(&dev->cdev.kobj, &input_dev_id_attr_group); 955 fail2: sysfs_remove_group(&dev->cdev.kobj, &input_dev_attr_group); 956 fail1: class_device_del(&dev->cdev); 957 return error; 958 } 959 960 void input_unregister_device(struct input_dev *dev) 961 { 962 struct list_head * node, * next; 963 964 if (!dev) return; 965 966 del_timer_sync(&dev->timer); 967 968 list_for_each_safe(node, next, &dev->h_list) { 969 struct input_handle * handle = to_handle(node); 970 list_del_init(&handle->d_node); 971 list_del_init(&handle->h_node); 972 handle->handler->disconnect(handle); 973 } 974 975 list_del_init(&dev->node); 976 977 sysfs_remove_group(&dev->cdev.kobj, &input_dev_caps_attr_group); 978 sysfs_remove_group(&dev->cdev.kobj, &input_dev_id_attr_group); 979 sysfs_remove_group(&dev->cdev.kobj, &input_dev_attr_group); 980 class_device_unregister(&dev->cdev); 981 982 input_wakeup_procfs_readers(); 983 } 984 985 void input_register_handler(struct input_handler *handler) 986 { 987 struct input_dev *dev; 988 struct input_handle *handle; 989 struct input_device_id *id; 990 991 if (!handler) return; 992 993 INIT_LIST_HEAD(&handler->h_list); 994 995 if (handler->fops != NULL) 996 input_table[handler->minor >> 5] = handler; 997 998 list_add_tail(&handler->node, &input_handler_list); 999 1000 list_for_each_entry(dev, &input_dev_list, node) 1001 if (!handler->blacklist || !input_match_device(handler->blacklist, dev)) 1002 if ((id = input_match_device(handler->id_table, dev))) 1003 if ((handle = handler->connect(handler, dev, id))) 1004 input_link_handle(handle); 1005 1006 input_wakeup_procfs_readers(); 1007 } 1008 1009 void input_unregister_handler(struct input_handler *handler) 1010 { 1011 struct list_head * node, * next; 1012 1013 list_for_each_safe(node, next, &handler->h_list) { 1014 struct input_handle * handle = to_handle_h(node); 1015 list_del_init(&handle->h_node); 1016 list_del_init(&handle->d_node); 1017 handler->disconnect(handle); 1018 } 1019 1020 list_del_init(&handler->node); 1021 1022 if (handler->fops != NULL) 1023 input_table[handler->minor >> 5] = NULL; 1024 1025 input_wakeup_procfs_readers(); 1026 } 1027 1028 static int input_open_file(struct inode *inode, struct file *file) 1029 { 1030 struct input_handler *handler = input_table[iminor(inode) >> 5]; 1031 const struct file_operations *old_fops, *new_fops = NULL; 1032 int err; 1033 1034 /* No load-on-demand here? */ 1035 if (!handler || !(new_fops = fops_get(handler->fops))) 1036 return -ENODEV; 1037 1038 /* 1039 * That's _really_ odd. Usually NULL ->open means "nothing special", 1040 * not "no device". Oh, well... 1041 */ 1042 if (!new_fops->open) { 1043 fops_put(new_fops); 1044 return -ENODEV; 1045 } 1046 old_fops = file->f_op; 1047 file->f_op = new_fops; 1048 1049 err = new_fops->open(inode, file); 1050 1051 if (err) { 1052 fops_put(file->f_op); 1053 file->f_op = fops_get(old_fops); 1054 } 1055 fops_put(old_fops); 1056 return err; 1057 } 1058 1059 static struct file_operations input_fops = { 1060 .owner = THIS_MODULE, 1061 .open = input_open_file, 1062 }; 1063 1064 static int __init input_init(void) 1065 { 1066 int err; 1067 1068 err = class_register(&input_class); 1069 if (err) { 1070 printk(KERN_ERR "input: unable to register input_dev class\n"); 1071 return err; 1072 } 1073 1074 err = input_proc_init(); 1075 if (err) 1076 goto fail1; 1077 1078 err = register_chrdev(INPUT_MAJOR, "input", &input_fops); 1079 if (err) { 1080 printk(KERN_ERR "input: unable to register char major %d", INPUT_MAJOR); 1081 goto fail2; 1082 } 1083 1084 return 0; 1085 1086 fail2: input_proc_exit(); 1087 fail1: class_unregister(&input_class); 1088 return err; 1089 } 1090 1091 static void __exit input_exit(void) 1092 { 1093 input_proc_exit(); 1094 unregister_chrdev(INPUT_MAJOR, "input"); 1095 class_unregister(&input_class); 1096 } 1097 1098 subsys_initcall(input_init); 1099 module_exit(input_exit); 1100