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