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