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