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