hiddev.c revision 6db3dfefa28739e7c9c60809c3a5aef7cc088b97
1/* 2 * Copyright (c) 2001 Paul Stewart 3 * Copyright (c) 2001 Vojtech Pavlik 4 * 5 * HID char devices, giving access to raw HID device events. 6 * 7 */ 8 9/* 10 * This program is free software; you can redistribute it and/or modify 11 * it under the terms of the GNU General Public License as published by 12 * the Free Software Foundation; either version 2 of the License, or 13 * (at your option) any later version. 14 * 15 * This program is distributed in the hope that it will be useful, 16 * but WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 * GNU General Public License for more details. 19 * 20 * You should have received a copy of the GNU General Public License 21 * along with this program; if not, write to the Free Software 22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 23 * 24 * Should you need to contact me, the author, you can do so either by 25 * e-mail - mail your message to Paul Stewart <stewart@wetlogic.net> 26 */ 27 28#include <linux/poll.h> 29#include <linux/slab.h> 30#include <linux/module.h> 31#include <linux/init.h> 32#include <linux/smp_lock.h> 33#include <linux/input.h> 34#include <linux/usb.h> 35#include <linux/hid.h> 36#include <linux/hiddev.h> 37#include "usbhid.h" 38 39#ifdef CONFIG_USB_DYNAMIC_MINORS 40#define HIDDEV_MINOR_BASE 0 41#define HIDDEV_MINORS 256 42#else 43#define HIDDEV_MINOR_BASE 96 44#define HIDDEV_MINORS 16 45#endif 46#define HIDDEV_BUFFER_SIZE 64 47 48struct hiddev { 49 int exist; 50 int open; 51 wait_queue_head_t wait; 52 struct hid_device *hid; 53 struct list_head list; 54}; 55 56struct hiddev_list { 57 struct hiddev_usage_ref buffer[HIDDEV_BUFFER_SIZE]; 58 int head; 59 int tail; 60 unsigned flags; 61 struct fasync_struct *fasync; 62 struct hiddev *hiddev; 63 struct list_head node; 64}; 65 66static struct hiddev *hiddev_table[HIDDEV_MINORS]; 67 68/* 69 * Find a report, given the report's type and ID. The ID can be specified 70 * indirectly by REPORT_ID_FIRST (which returns the first report of the given 71 * type) or by (REPORT_ID_NEXT | old_id), which returns the next report of the 72 * given type which follows old_id. 73 */ 74static struct hid_report * 75hiddev_lookup_report(struct hid_device *hid, struct hiddev_report_info *rinfo) 76{ 77 unsigned int flags = rinfo->report_id & ~HID_REPORT_ID_MASK; 78 unsigned int rid = rinfo->report_id & HID_REPORT_ID_MASK; 79 struct hid_report_enum *report_enum; 80 struct hid_report *report; 81 struct list_head *list; 82 83 if (rinfo->report_type < HID_REPORT_TYPE_MIN || 84 rinfo->report_type > HID_REPORT_TYPE_MAX) 85 return NULL; 86 87 report_enum = hid->report_enum + 88 (rinfo->report_type - HID_REPORT_TYPE_MIN); 89 90 switch (flags) { 91 case 0: /* Nothing to do -- report_id is already set correctly */ 92 break; 93 94 case HID_REPORT_ID_FIRST: 95 if (list_empty(&report_enum->report_list)) 96 return NULL; 97 98 list = report_enum->report_list.next; 99 report = list_entry(list, struct hid_report, list); 100 rinfo->report_id = report->id; 101 break; 102 103 case HID_REPORT_ID_NEXT: 104 report = report_enum->report_id_hash[rid]; 105 if (!report) 106 return NULL; 107 108 list = report->list.next; 109 if (list == &report_enum->report_list) 110 return NULL; 111 112 report = list_entry(list, struct hid_report, list); 113 rinfo->report_id = report->id; 114 break; 115 116 default: 117 return NULL; 118 } 119 120 return report_enum->report_id_hash[rinfo->report_id]; 121} 122 123/* 124 * Perform an exhaustive search of the report table for a usage, given its 125 * type and usage id. 126 */ 127static struct hid_field * 128hiddev_lookup_usage(struct hid_device *hid, struct hiddev_usage_ref *uref) 129{ 130 int i, j; 131 struct hid_report *report; 132 struct hid_report_enum *report_enum; 133 struct hid_field *field; 134 135 if (uref->report_type < HID_REPORT_TYPE_MIN || 136 uref->report_type > HID_REPORT_TYPE_MAX) 137 return NULL; 138 139 report_enum = hid->report_enum + 140 (uref->report_type - HID_REPORT_TYPE_MIN); 141 142 list_for_each_entry(report, &report_enum->report_list, list) { 143 for (i = 0; i < report->maxfield; i++) { 144 field = report->field[i]; 145 for (j = 0; j < field->maxusage; j++) { 146 if (field->usage[j].hid == uref->usage_code) { 147 uref->report_id = report->id; 148 uref->field_index = i; 149 uref->usage_index = j; 150 return field; 151 } 152 } 153 } 154 } 155 156 return NULL; 157} 158 159static void hiddev_send_event(struct hid_device *hid, 160 struct hiddev_usage_ref *uref) 161{ 162 struct hiddev *hiddev = hid->hiddev; 163 struct hiddev_list *list; 164 165 list_for_each_entry(list, &hiddev->list, node) { 166 if (uref->field_index != HID_FIELD_INDEX_NONE || 167 (list->flags & HIDDEV_FLAG_REPORT) != 0) { 168 list->buffer[list->head] = *uref; 169 list->head = (list->head + 1) & 170 (HIDDEV_BUFFER_SIZE - 1); 171 kill_fasync(&list->fasync, SIGIO, POLL_IN); 172 } 173 } 174 175 wake_up_interruptible(&hiddev->wait); 176} 177 178/* 179 * This is where hid.c calls into hiddev to pass an event that occurred over 180 * the interrupt pipe 181 */ 182void hiddev_hid_event(struct hid_device *hid, struct hid_field *field, 183 struct hid_usage *usage, __s32 value) 184{ 185 unsigned type = field->report_type; 186 struct hiddev_usage_ref uref; 187 188 uref.report_type = 189 (type == HID_INPUT_REPORT) ? HID_REPORT_TYPE_INPUT : 190 ((type == HID_OUTPUT_REPORT) ? HID_REPORT_TYPE_OUTPUT : 191 ((type == HID_FEATURE_REPORT) ? HID_REPORT_TYPE_FEATURE : 0)); 192 uref.report_id = field->report->id; 193 uref.field_index = field->index; 194 uref.usage_index = (usage - field->usage); 195 uref.usage_code = usage->hid; 196 uref.value = value; 197 198 hiddev_send_event(hid, &uref); 199} 200EXPORT_SYMBOL_GPL(hiddev_hid_event); 201 202void hiddev_report_event(struct hid_device *hid, struct hid_report *report) 203{ 204 unsigned type = report->type; 205 struct hiddev_usage_ref uref; 206 207 memset(&uref, 0, sizeof(uref)); 208 uref.report_type = 209 (type == HID_INPUT_REPORT) ? HID_REPORT_TYPE_INPUT : 210 ((type == HID_OUTPUT_REPORT) ? HID_REPORT_TYPE_OUTPUT : 211 ((type == HID_FEATURE_REPORT) ? HID_REPORT_TYPE_FEATURE : 0)); 212 uref.report_id = report->id; 213 uref.field_index = HID_FIELD_INDEX_NONE; 214 215 hiddev_send_event(hid, &uref); 216} 217 218/* 219 * fasync file op 220 */ 221static int hiddev_fasync(int fd, struct file *file, int on) 222{ 223 int retval; 224 struct hiddev_list *list = file->private_data; 225 226 retval = fasync_helper(fd, file, on, &list->fasync); 227 228 return retval < 0 ? retval : 0; 229} 230 231 232/* 233 * release file op 234 */ 235static int hiddev_release(struct inode * inode, struct file * file) 236{ 237 struct hiddev_list *list = file->private_data; 238 239 hiddev_fasync(-1, file, 0); 240 list_del(&list->node); 241 242 if (!--list->hiddev->open) { 243 if (list->hiddev->exist) 244 usbhid_close(list->hiddev->hid); 245 else 246 kfree(list->hiddev); 247 } 248 249 kfree(list); 250 251 return 0; 252} 253 254/* 255 * open file op 256 */ 257static int hiddev_open(struct inode *inode, struct file *file) 258{ 259 struct hiddev_list *list; 260 261 int i = iminor(inode) - HIDDEV_MINOR_BASE; 262 263 if (i >= HIDDEV_MINORS || !hiddev_table[i]) 264 return -ENODEV; 265 266 if (!(list = kzalloc(sizeof(struct hiddev_list), GFP_KERNEL))) 267 return -ENOMEM; 268 269 list->hiddev = hiddev_table[i]; 270 list_add_tail(&list->node, &hiddev_table[i]->list); 271 file->private_data = list; 272 273 if (!list->hiddev->open++) 274 if (list->hiddev->exist) 275 usbhid_open(hiddev_table[i]->hid); 276 277 return 0; 278} 279 280/* 281 * "write" file op 282 */ 283static ssize_t hiddev_write(struct file * file, const char __user * buffer, size_t count, loff_t *ppos) 284{ 285 return -EINVAL; 286} 287 288/* 289 * "read" file op 290 */ 291static ssize_t hiddev_read(struct file * file, char __user * buffer, size_t count, loff_t *ppos) 292{ 293 DECLARE_WAITQUEUE(wait, current); 294 struct hiddev_list *list = file->private_data; 295 int event_size; 296 int retval = 0; 297 298 event_size = ((list->flags & HIDDEV_FLAG_UREF) != 0) ? 299 sizeof(struct hiddev_usage_ref) : sizeof(struct hiddev_event); 300 301 if (count < event_size) 302 return 0; 303 304 while (retval == 0) { 305 if (list->head == list->tail) { 306 add_wait_queue(&list->hiddev->wait, &wait); 307 set_current_state(TASK_INTERRUPTIBLE); 308 309 while (list->head == list->tail) { 310 if (file->f_flags & O_NONBLOCK) { 311 retval = -EAGAIN; 312 break; 313 } 314 if (signal_pending(current)) { 315 retval = -ERESTARTSYS; 316 break; 317 } 318 if (!list->hiddev->exist) { 319 retval = -EIO; 320 break; 321 } 322 323 schedule(); 324 set_current_state(TASK_INTERRUPTIBLE); 325 } 326 327 set_current_state(TASK_RUNNING); 328 remove_wait_queue(&list->hiddev->wait, &wait); 329 } 330 331 if (retval) 332 return retval; 333 334 335 while (list->head != list->tail && 336 retval + event_size <= count) { 337 if ((list->flags & HIDDEV_FLAG_UREF) == 0) { 338 if (list->buffer[list->tail].field_index != 339 HID_FIELD_INDEX_NONE) { 340 struct hiddev_event event; 341 event.hid = list->buffer[list->tail].usage_code; 342 event.value = list->buffer[list->tail].value; 343 if (copy_to_user(buffer + retval, &event, sizeof(struct hiddev_event))) 344 return -EFAULT; 345 retval += sizeof(struct hiddev_event); 346 } 347 } else { 348 if (list->buffer[list->tail].field_index != HID_FIELD_INDEX_NONE || 349 (list->flags & HIDDEV_FLAG_REPORT) != 0) { 350 if (copy_to_user(buffer + retval, list->buffer + list->tail, sizeof(struct hiddev_usage_ref))) 351 return -EFAULT; 352 retval += sizeof(struct hiddev_usage_ref); 353 } 354 } 355 list->tail = (list->tail + 1) & (HIDDEV_BUFFER_SIZE - 1); 356 } 357 358 } 359 360 return retval; 361} 362 363/* 364 * "poll" file op 365 * No kernel lock - fine 366 */ 367static unsigned int hiddev_poll(struct file *file, poll_table *wait) 368{ 369 struct hiddev_list *list = file->private_data; 370 371 poll_wait(file, &list->hiddev->wait, wait); 372 if (list->head != list->tail) 373 return POLLIN | POLLRDNORM; 374 if (!list->hiddev->exist) 375 return POLLERR | POLLHUP; 376 return 0; 377} 378 379/* 380 * "ioctl" file op 381 */ 382static int hiddev_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg) 383{ 384 struct hiddev_list *list = file->private_data; 385 struct hiddev *hiddev = list->hiddev; 386 struct hid_device *hid = hiddev->hid; 387 struct usb_device *dev = hid_to_usb_dev(hid); 388 struct hiddev_collection_info cinfo; 389 struct hiddev_report_info rinfo; 390 struct hiddev_field_info finfo; 391 struct hiddev_usage_ref_multi *uref_multi = NULL; 392 struct hiddev_usage_ref *uref; 393 struct hiddev_devinfo dinfo; 394 struct hid_report *report; 395 struct hid_field *field; 396 struct usbhid_device *usbhid = hid->driver_data; 397 void __user *user_arg = (void __user *)arg; 398 int i; 399 400 if (!hiddev->exist) 401 return -EIO; 402 403 switch (cmd) { 404 405 case HIDIOCGVERSION: 406 return put_user(HID_VERSION, (int __user *)arg); 407 408 case HIDIOCAPPLICATION: 409 if (arg < 0 || arg >= hid->maxapplication) 410 return -EINVAL; 411 412 for (i = 0; i < hid->maxcollection; i++) 413 if (hid->collection[i].type == 414 HID_COLLECTION_APPLICATION && arg-- == 0) 415 break; 416 417 if (i == hid->maxcollection) 418 return -EINVAL; 419 420 return hid->collection[i].usage; 421 422 case HIDIOCGDEVINFO: 423 dinfo.bustype = BUS_USB; 424 dinfo.busnum = dev->bus->busnum; 425 dinfo.devnum = dev->devnum; 426 dinfo.ifnum = usbhid->ifnum; 427 dinfo.vendor = le16_to_cpu(dev->descriptor.idVendor); 428 dinfo.product = le16_to_cpu(dev->descriptor.idProduct); 429 dinfo.version = le16_to_cpu(dev->descriptor.bcdDevice); 430 dinfo.num_applications = hid->maxapplication; 431 if (copy_to_user(user_arg, &dinfo, sizeof(dinfo))) 432 return -EFAULT; 433 434 return 0; 435 436 case HIDIOCGFLAG: 437 if (put_user(list->flags, (int __user *)arg)) 438 return -EFAULT; 439 440 return 0; 441 442 case HIDIOCSFLAG: 443 { 444 int newflags; 445 if (get_user(newflags, (int __user *)arg)) 446 return -EFAULT; 447 448 if ((newflags & ~HIDDEV_FLAGS) != 0 || 449 ((newflags & HIDDEV_FLAG_REPORT) != 0 && 450 (newflags & HIDDEV_FLAG_UREF) == 0)) 451 return -EINVAL; 452 453 list->flags = newflags; 454 455 return 0; 456 } 457 458 case HIDIOCGSTRING: 459 { 460 int idx, len; 461 char *buf; 462 463 if (get_user(idx, (int __user *)arg)) 464 return -EFAULT; 465 466 if ((buf = kmalloc(HID_STRING_SIZE, GFP_KERNEL)) == NULL) 467 return -ENOMEM; 468 469 if ((len = usb_string(dev, idx, buf, HID_STRING_SIZE-1)) < 0) { 470 kfree(buf); 471 return -EINVAL; 472 } 473 474 if (copy_to_user(user_arg+sizeof(int), buf, len+1)) { 475 kfree(buf); 476 return -EFAULT; 477 } 478 479 kfree(buf); 480 481 return len; 482 } 483 484 case HIDIOCINITREPORT: 485 usbhid_init_reports(hid); 486 487 return 0; 488 489 case HIDIOCGREPORT: 490 if (copy_from_user(&rinfo, user_arg, sizeof(rinfo))) 491 return -EFAULT; 492 493 if (rinfo.report_type == HID_REPORT_TYPE_OUTPUT) 494 return -EINVAL; 495 496 if ((report = hiddev_lookup_report(hid, &rinfo)) == NULL) 497 return -EINVAL; 498 499 usbhid_submit_report(hid, report, USB_DIR_IN); 500 usbhid_wait_io(hid); 501 502 return 0; 503 504 case HIDIOCSREPORT: 505 if (copy_from_user(&rinfo, user_arg, sizeof(rinfo))) 506 return -EFAULT; 507 508 if (rinfo.report_type == HID_REPORT_TYPE_INPUT) 509 return -EINVAL; 510 511 if ((report = hiddev_lookup_report(hid, &rinfo)) == NULL) 512 return -EINVAL; 513 514 usbhid_submit_report(hid, report, USB_DIR_OUT); 515 usbhid_wait_io(hid); 516 517 return 0; 518 519 case HIDIOCGREPORTINFO: 520 if (copy_from_user(&rinfo, user_arg, sizeof(rinfo))) 521 return -EFAULT; 522 523 if ((report = hiddev_lookup_report(hid, &rinfo)) == NULL) 524 return -EINVAL; 525 526 rinfo.num_fields = report->maxfield; 527 528 if (copy_to_user(user_arg, &rinfo, sizeof(rinfo))) 529 return -EFAULT; 530 531 return 0; 532 533 case HIDIOCGFIELDINFO: 534 if (copy_from_user(&finfo, user_arg, sizeof(finfo))) 535 return -EFAULT; 536 rinfo.report_type = finfo.report_type; 537 rinfo.report_id = finfo.report_id; 538 if ((report = hiddev_lookup_report(hid, &rinfo)) == NULL) 539 return -EINVAL; 540 541 if (finfo.field_index >= report->maxfield) 542 return -EINVAL; 543 544 field = report->field[finfo.field_index]; 545 memset(&finfo, 0, sizeof(finfo)); 546 finfo.report_type = rinfo.report_type; 547 finfo.report_id = rinfo.report_id; 548 finfo.field_index = field->report_count - 1; 549 finfo.maxusage = field->maxusage; 550 finfo.flags = field->flags; 551 finfo.physical = field->physical; 552 finfo.logical = field->logical; 553 finfo.application = field->application; 554 finfo.logical_minimum = field->logical_minimum; 555 finfo.logical_maximum = field->logical_maximum; 556 finfo.physical_minimum = field->physical_minimum; 557 finfo.physical_maximum = field->physical_maximum; 558 finfo.unit_exponent = field->unit_exponent; 559 finfo.unit = field->unit; 560 561 if (copy_to_user(user_arg, &finfo, sizeof(finfo))) 562 return -EFAULT; 563 564 return 0; 565 566 case HIDIOCGUCODE: 567 uref_multi = kmalloc(sizeof(struct hiddev_usage_ref_multi), GFP_KERNEL); 568 if (!uref_multi) 569 return -ENOMEM; 570 uref = &uref_multi->uref; 571 if (copy_from_user(uref, user_arg, sizeof(*uref))) 572 goto fault; 573 574 rinfo.report_type = uref->report_type; 575 rinfo.report_id = uref->report_id; 576 if ((report = hiddev_lookup_report(hid, &rinfo)) == NULL) 577 goto inval; 578 579 if (uref->field_index >= report->maxfield) 580 goto inval; 581 582 field = report->field[uref->field_index]; 583 if (uref->usage_index >= field->maxusage) 584 goto inval; 585 586 uref->usage_code = field->usage[uref->usage_index].hid; 587 588 if (copy_to_user(user_arg, uref, sizeof(*uref))) 589 goto fault; 590 591 kfree(uref_multi); 592 return 0; 593 594 case HIDIOCGUSAGE: 595 case HIDIOCSUSAGE: 596 case HIDIOCGUSAGES: 597 case HIDIOCSUSAGES: 598 case HIDIOCGCOLLECTIONINDEX: 599 uref_multi = kmalloc(sizeof(struct hiddev_usage_ref_multi), GFP_KERNEL); 600 if (!uref_multi) 601 return -ENOMEM; 602 uref = &uref_multi->uref; 603 if (cmd == HIDIOCGUSAGES || cmd == HIDIOCSUSAGES) { 604 if (copy_from_user(uref_multi, user_arg, 605 sizeof(*uref_multi))) 606 goto fault; 607 } else { 608 if (copy_from_user(uref, user_arg, sizeof(*uref))) 609 goto fault; 610 } 611 612 if (cmd != HIDIOCGUSAGE && 613 cmd != HIDIOCGUSAGES && 614 uref->report_type == HID_REPORT_TYPE_INPUT) 615 goto inval; 616 617 if (uref->report_id == HID_REPORT_ID_UNKNOWN) { 618 field = hiddev_lookup_usage(hid, uref); 619 if (field == NULL) 620 goto inval; 621 } else { 622 rinfo.report_type = uref->report_type; 623 rinfo.report_id = uref->report_id; 624 if ((report = hiddev_lookup_report(hid, &rinfo)) == NULL) 625 goto inval; 626 627 if (uref->field_index >= report->maxfield) 628 goto inval; 629 630 field = report->field[uref->field_index]; 631 632 if (cmd == HIDIOCGCOLLECTIONINDEX) { 633 if (uref->usage_index >= field->maxusage) 634 goto inval; 635 } else if (uref->usage_index >= field->report_count) 636 goto inval; 637 638 else if ((cmd == HIDIOCGUSAGES || cmd == HIDIOCSUSAGES) && 639 (uref_multi->num_values > HID_MAX_MULTI_USAGES || 640 uref->usage_index + uref_multi->num_values > field->report_count)) 641 goto inval; 642 } 643 644 switch (cmd) { 645 case HIDIOCGUSAGE: 646 uref->value = field->value[uref->usage_index]; 647 if (copy_to_user(user_arg, uref, sizeof(*uref))) 648 goto fault; 649 goto goodreturn; 650 651 case HIDIOCSUSAGE: 652 field->value[uref->usage_index] = uref->value; 653 goto goodreturn; 654 655 case HIDIOCGCOLLECTIONINDEX: 656 kfree(uref_multi); 657 return field->usage[uref->usage_index].collection_index; 658 case HIDIOCGUSAGES: 659 for (i = 0; i < uref_multi->num_values; i++) 660 uref_multi->values[i] = 661 field->value[uref->usage_index + i]; 662 if (copy_to_user(user_arg, uref_multi, 663 sizeof(*uref_multi))) 664 goto fault; 665 goto goodreturn; 666 case HIDIOCSUSAGES: 667 for (i = 0; i < uref_multi->num_values; i++) 668 field->value[uref->usage_index + i] = 669 uref_multi->values[i]; 670 goto goodreturn; 671 } 672 673goodreturn: 674 kfree(uref_multi); 675 return 0; 676fault: 677 kfree(uref_multi); 678 return -EFAULT; 679inval: 680 kfree(uref_multi); 681 return -EINVAL; 682 683 case HIDIOCGCOLLECTIONINFO: 684 if (copy_from_user(&cinfo, user_arg, sizeof(cinfo))) 685 return -EFAULT; 686 687 if (cinfo.index >= hid->maxcollection) 688 return -EINVAL; 689 690 cinfo.type = hid->collection[cinfo.index].type; 691 cinfo.usage = hid->collection[cinfo.index].usage; 692 cinfo.level = hid->collection[cinfo.index].level; 693 694 if (copy_to_user(user_arg, &cinfo, sizeof(cinfo))) 695 return -EFAULT; 696 return 0; 697 698 default: 699 700 if (_IOC_TYPE(cmd) != 'H' || _IOC_DIR(cmd) != _IOC_READ) 701 return -EINVAL; 702 703 if (_IOC_NR(cmd) == _IOC_NR(HIDIOCGNAME(0))) { 704 int len; 705 if (!hid->name) 706 return 0; 707 len = strlen(hid->name) + 1; 708 if (len > _IOC_SIZE(cmd)) 709 len = _IOC_SIZE(cmd); 710 return copy_to_user(user_arg, hid->name, len) ? 711 -EFAULT : len; 712 } 713 714 if (_IOC_NR(cmd) == _IOC_NR(HIDIOCGPHYS(0))) { 715 int len; 716 if (!hid->phys) 717 return 0; 718 len = strlen(hid->phys) + 1; 719 if (len > _IOC_SIZE(cmd)) 720 len = _IOC_SIZE(cmd); 721 return copy_to_user(user_arg, hid->phys, len) ? 722 -EFAULT : len; 723 } 724 } 725 return -EINVAL; 726} 727 728static const struct file_operations hiddev_fops = { 729 .owner = THIS_MODULE, 730 .read = hiddev_read, 731 .write = hiddev_write, 732 .poll = hiddev_poll, 733 .open = hiddev_open, 734 .release = hiddev_release, 735 .ioctl = hiddev_ioctl, 736 .fasync = hiddev_fasync, 737}; 738 739static struct usb_class_driver hiddev_class = { 740 .name = "hiddev%d", 741 .fops = &hiddev_fops, 742 .minor_base = HIDDEV_MINOR_BASE, 743}; 744 745/* 746 * This is where hid.c calls us to connect a hid device to the hiddev driver 747 */ 748int hiddev_connect(struct hid_device *hid) 749{ 750 struct hiddev *hiddev; 751 struct usbhid_device *usbhid = hid->driver_data; 752 int i; 753 int retval; 754 755 for (i = 0; i < hid->maxcollection; i++) 756 if (hid->collection[i].type == 757 HID_COLLECTION_APPLICATION && 758 !IS_INPUT_APPLICATION(hid->collection[i].usage)) 759 break; 760 761 if (i == hid->maxcollection && (hid->quirks & HID_QUIRK_HIDDEV) == 0) 762 return -1; 763 764 if (!(hiddev = kzalloc(sizeof(struct hiddev), GFP_KERNEL))) 765 return -1; 766 767 retval = usb_register_dev(usbhid->intf, &hiddev_class); 768 if (retval) { 769 err("Not able to get a minor for this device."); 770 kfree(hiddev); 771 return -1; 772 } 773 774 init_waitqueue_head(&hiddev->wait); 775 INIT_LIST_HEAD(&hiddev->list); 776 hiddev->hid = hid; 777 hiddev->exist = 1; 778 779 hid->minor = usbhid->intf->minor; 780 hid->hiddev = hiddev; 781 782 hiddev_table[usbhid->intf->minor - HIDDEV_MINOR_BASE] = hiddev; 783 784 return 0; 785} 786 787/* 788 * This is where hid.c calls us to disconnect a hiddev device from the 789 * corresponding hid device (usually because the usb device has disconnected) 790 */ 791static struct usb_class_driver hiddev_class; 792void hiddev_disconnect(struct hid_device *hid) 793{ 794 struct hiddev *hiddev = hid->hiddev; 795 struct usbhid_device *usbhid = hid->driver_data; 796 797 hiddev->exist = 0; 798 799 hiddev_table[hiddev->hid->minor - HIDDEV_MINOR_BASE] = NULL; 800 usb_deregister_dev(usbhid->intf, &hiddev_class); 801 802 if (hiddev->open) { 803 usbhid_close(hiddev->hid); 804 wake_up_interruptible(&hiddev->wait); 805 } else { 806 kfree(hiddev); 807 } 808} 809 810/* Currently this driver is a USB driver. It's not a conventional one in 811 * the sense that it doesn't probe at the USB level. Instead it waits to 812 * be connected by HID through the hiddev_connect / hiddev_disconnect 813 * routines. The reason to register as a USB device is to gain part of the 814 * minor number space from the USB major. 815 * 816 * In theory, should the HID code be generalized to more than one physical 817 * medium (say, IEEE 1384), this driver will probably need to register its 818 * own major number, and in doing so, no longer need to register with USB. 819 * At that point the probe routine and hiddev_driver struct below will no 820 * longer be useful. 821 */ 822 823 824/* We never attach in this manner, and rely on HID to connect us. This 825 * is why there is no disconnect routine defined in the usb_driver either. 826 */ 827static int hiddev_usbd_probe(struct usb_interface *intf, 828 const struct usb_device_id *hiddev_info) 829{ 830 return -ENODEV; 831} 832 833 834static /* const */ struct usb_driver hiddev_driver = { 835 .name = "hiddev", 836 .probe = hiddev_usbd_probe, 837}; 838 839int __init hiddev_init(void) 840{ 841 return usb_register(&hiddev_driver); 842} 843 844void hiddev_exit(void) 845{ 846 usb_deregister(&hiddev_driver); 847} 848