开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
hiddev.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：16k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

hiddev.c：源码内容
  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.  */
  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.  */
  28. #define HIDDEV_MINOR_BASE 96
  29. #define HIDDEV_MINORS 16
  30. #define HIDDEV_BUFFER_SIZE 64
  32. #include <linux/poll.h>
  33. #include <linux/slab.h>
  34. #include <linux/module.h>
  35. #include <linux/init.h>
  36. #include <linux/smp_lock.h>
  37. #include <linux/input.h>
  38. #include <linux/usb.h>
  39. #include "hid.h"
  40. #include <linux/hiddev.h>
  42. struct hiddev {
  43. int exist;
  44. int open;
  45. int minor;
  46. wait_queue_head_t wait;
  47. devfs_handle_t devfs;
  48. struct hid_device *hid;
  49. struct hiddev_list *list;
  50. };
  52. struct hiddev_list {
  53. struct hiddev_event buffer[HIDDEV_BUFFER_SIZE];
  54. int head;
  55. int tail;
  56. struct fasync_struct *fasync;
  57. struct hiddev *hiddev;
  58. struct hiddev_list *next;
  59. };
  61. static struct hiddev *hiddev_table[HIDDEV_MINORS];
  62. static devfs_handle_t hiddev_devfs_handle;
  64. /*
  65.  * Find a report, given the report's type and ID.  The ID can be specified
  66.  * indirectly by REPORT_ID_FIRST (which returns the first report of the given
  67.  * type) or by (REPORT_ID_NEXT | old_id), which returns the next report of the
  68.  * given type which follows old_id.
  69.  */
  70. static struct hid_report *
  71. hiddev_lookup_report(struct hid_device *hid, struct hiddev_report_info *rinfo)
  72. {
  73. struct hid_report_enum *report_enum;
  74. struct list_head *list;
  76. if (rinfo->report_type < HID_REPORT_TYPE_MIN ||
  77.     rinfo->report_type > HID_REPORT_TYPE_MAX) return NULL;
  79. report_enum = hid->report_enum +
  80. (rinfo->report_type - HID_REPORT_TYPE_MIN);
  81. if ((rinfo->report_id & ~HID_REPORT_ID_MASK) != 0) {
  82. switch (rinfo->report_id & ~HID_REPORT_ID_MASK) {
  83. case HID_REPORT_ID_FIRST:
  84. list = report_enum->report_list.next;
  85. if (list == &report_enum->report_list) return NULL;
  86. rinfo->report_id = ((struct hid_report *) list)->id;
  87. break;
  89. case HID_REPORT_ID_NEXT:
  90. list = (struct list_head *)
  91. report_enum->report_id_hash[rinfo->report_id &
  92.    HID_REPORT_ID_MASK];
  93. if (list == NULL) return NULL;
  94. list = list->next;
  95. if (list == &report_enum->report_list) return NULL;
  96. rinfo->report_id = ((struct hid_report *) list)->id;
  97. break;
  99. default:
  100. return NULL;
  101. }
  102. }
  104. return report_enum->report_id_hash[rinfo->report_id];
  105. }
  107. /*
  108.  * Perform an exhaustive search of the report table for a usage, given its
  109.  * type and usage id.
  110.  */
  111. static struct hid_field *
  112. hiddev_lookup_usage(struct hid_device *hid, struct hiddev_usage_ref *uref)
  113. {
  114. int i, j;
  115. struct hid_report *report;
  116. struct hid_report_enum *report_enum;
  117. struct list_head *list;
  118. struct hid_field *field;
  120. if (uref->report_type < HID_REPORT_TYPE_MIN ||
  121.     uref->report_type > HID_REPORT_TYPE_MAX) return NULL;
  123. report_enum = hid->report_enum +
  124. (uref->report_type - HID_REPORT_TYPE_MIN);
  125. list = report_enum->report_list.next;
  126. while (list != &report_enum->report_list) {
  127. report = (struct hid_report *) list;
  128. for (i = 0; i < report->maxfield; i++) {
  129. field = report->field[i];
  130. for (j = 0; j < field->maxusage; j++) {
  131. if (field->usage[j].hid == uref->usage_code) {
  132. uref->report_id = report->id;
  133. uref->field_index = i;
  134. uref->usage_index = j;
  135. return field;
  136. }
  137. }
  138. }
  139. list = list->next;
  140. }
  142. return NULL;
  143. }
  145. /*
  146.  * This is where hid.c calls into hiddev to pass an event that occurred over
  147.  * the interrupt pipe
  148.  */
  149. void hiddev_hid_event(struct hid_device *hid, unsigned int usage, int value)
  150. {
  151. struct hiddev *hiddev = hid->hiddev;
  152. struct hiddev_list *list = hiddev->list;
  154. while (list) {
  155. list->buffer[list->head].hid = usage;
  156. list->buffer[list->head].value = value;
  157. list->head = (list->head + 1) & (HIDDEV_BUFFER_SIZE - 1);
  159. kill_fasync(&list->fasync, SIGIO, POLL_IN);
  161. list = list->next;
  162. }
  164. wake_up_interruptible(&hiddev->wait);
  165. }
  167. /*
  168.  * fasync file op
  169.  */
  170. static int hiddev_fasync(int fd, struct file *file, int on)
  171. {
  172. int retval;
  173. struct hiddev_list *list = file->private_data;
  174. retval = fasync_helper(fd, file, on, &list->fasync);
  175. return retval < 0 ? retval : 0;
  176. }
  178. /*
  179.  * De-allocate a hiddev structure
  180.  */
  181. static void hiddev_cleanup(struct hiddev *hiddev)
  182. {
  183. devfs_unregister(hiddev->devfs);
  184. hiddev_table[hiddev->minor] = NULL;
  185. kfree(hiddev);
  186. }
  188. /*
  189.  * release file op
  190.  */
  191. static int hiddev_release(struct inode * inode, struct file * file)
  192. {
  193. struct hiddev_list *list = file->private_data;
  194. struct hiddev_list **listptr;
  196. lock_kernel();
  197. listptr = &list->hiddev->list;
  198. hiddev_fasync(-1, file, 0);
  200. while (*listptr && (*listptr != list))
  201. listptr = &((*listptr)->next);
  202. *listptr = (*listptr)->next;
  204. if (!--list->hiddev->open) {
  205. if (list->hiddev->exist) 
  206. hid_close(list->hiddev->hid);
  207. else
  208. hiddev_cleanup(list->hiddev);
  209. }
  211. kfree(list);
  212. unlock_kernel();
  214. return 0;
  215. }
  217. /*
  218.  * open file op
  219.  */
  220. static int hiddev_open(struct inode * inode, struct file * file) {
  221. struct hiddev_list *list;
  223. int i = MINOR(inode->i_rdev) - HIDDEV_MINOR_BASE;
  225. if (i >= HIDDEV_MINORS || !hiddev_table[i])
  226. return -ENODEV;
  228. if (!(list = kmalloc(sizeof(struct hiddev_list), GFP_KERNEL)))
  229. return -ENOMEM;
  230. memset(list, 0, sizeof(struct hiddev_list));
  232. list->hiddev = hiddev_table[i];
  233. list->next = hiddev_table[i]->list;
  234. hiddev_table[i]->list = list;
  236. file->private_data = list;
  238. if (!list->hiddev->open++)
  239. if (list->hiddev->exist)
  240. hid_open(hiddev_table[i]->hid);
  242. return 0;
  243. }
  245. /*
  246.  * "write" file op
  247.  */
  248. static ssize_t hiddev_write(struct file * file, const char * buffer,
  249.     size_t count, loff_t *ppos)
  250. {
  251. return -EINVAL;
  252. }
  254. /*
  255.  * "read" file op
  256.  */
  257. static ssize_t hiddev_read(struct file * file, char * buffer, size_t count,
  258.    loff_t *ppos)
  259. {
  260. DECLARE_WAITQUEUE(wait, current);
  261. struct hiddev_list *list = file->private_data;
  262. int retval = 0;
  264. if (list->head == list->tail) {
  266. add_wait_queue(&list->hiddev->wait, &wait);
  267. set_current_state(TASK_INTERRUPTIBLE);
  269. while (list->head == list->tail) {
  271. if (file->f_flags & O_NONBLOCK) {
  272. retval = -EAGAIN;
  273. break;
  274. }
  275. if (signal_pending(current)) {
  276. retval = -ERESTARTSYS;
  277. break;
  278. }
  279. if (!list->hiddev->exist) {
  280. retval = -EIO;
  281. break;
  282. }
  284. schedule();
  285. }
  287. set_current_state(TASK_RUNNING);
  288. remove_wait_queue(&list->hiddev->wait, &wait);
  289. }
  291. if (retval)
  292. return retval;
  294. while (list->head != list->tail && retval + sizeof(struct hiddev_event) <= count) {
  295. if (copy_to_user(buffer + retval, list->buffer + list->tail,
  296.  sizeof(struct hiddev_event))) return -EFAULT;
  297. list->tail = (list->tail + 1) & (HIDDEV_BUFFER_SIZE - 1);
  298. retval += sizeof(struct hiddev_event);
  299. }
  301. return retval;
  302. }
  304. /*
  305.  * "poll" file op
  306.  * No kernel lock - fine
  307.  */
  308. static unsigned int hiddev_poll(struct file *file, poll_table *wait)
  309. {
  310. struct hiddev_list *list = file->private_data;
  311. poll_wait(file, &list->hiddev->wait, wait);
  312. if (list->head != list->tail)
  313. return POLLIN | POLLRDNORM;
  314. if (!list->hiddev->exist)
  315. return POLLERR | POLLHUP;
  316. return 0;
  317. }
  319. #define GET_TIMEOUT 3
  320. #define SET_TIMEOUT 3
  322. /*
  323.  * "ioctl" file op
  324.  */
  325. static int hiddev_ioctl(struct inode *inode, struct file *file,
  326. unsigned int cmd, unsigned long arg)
  327. {
  328. struct hiddev_list *list = file->private_data;
  329. struct hiddev *hiddev = list->hiddev;
  330. struct hid_device *hid = hiddev->hid;
  331. struct usb_device *dev = hid->dev;
  332. struct hiddev_report_info rinfo;
  333. struct hiddev_usage_ref uref;
  334. struct hid_report *report;
  335. struct hid_field *field;
  337. if (!hiddev->exist) return -EIO;
  339. switch (cmd) {
  341. case HIDIOCGVERSION:
  342. return put_user(HID_VERSION, (int *) arg);
  344. case HIDIOCAPPLICATION:
  345. if (arg < 0 || arg >= hid->maxapplication)
  346. return -EINVAL;
  347. return hid->application[arg];
  349. case HIDIOCGDEVINFO:
  350. {
  351. struct hiddev_devinfo dinfo;
  352. dinfo.bustype = BUS_USB;
  353. dinfo.busnum = dev->bus->busnum;
  354. dinfo.devnum = dev->devnum;
  355. dinfo.ifnum = hid->ifnum;
  356. dinfo.vendor = dev->descriptor.idVendor;
  357. dinfo.product = dev->descriptor.idProduct;
  358. dinfo.version = dev->descriptor.bcdDevice;
  359. dinfo.num_applications = hid->maxapplication;
  360. return copy_to_user((void *) arg, &dinfo, sizeof(dinfo));
  361. }
  363. case HIDIOCGSTRING:
  364. {
  365. int idx, len;
  366. char *buf;
  368. if (get_user(idx, (int *) arg))
  369. return -EFAULT;
  371. if ((buf = kmalloc(HID_STRING_SIZE, GFP_KERNEL)) == NULL)
  372. return -ENOMEM;
  374. if ((len = usb_string(dev, idx, buf, HID_STRING_SIZE-1)) < 0) {
  375. kfree(buf);
  376. return -EINVAL;
  377. }
  379. if (copy_to_user((void *) (arg+sizeof(int)), buf, len+1)) {
  380. kfree(buf);
  381. return -EFAULT;
  382. }
  384. kfree(buf);
  386. return len;
  387. }
  389. case HIDIOCINITREPORT:
  391. hid_init_reports(hid);
  393. return 0;
  395. case HIDIOCGREPORT:
  396. if (copy_from_user(&rinfo, (void *) arg, sizeof(rinfo)))
  397. return -EFAULT;
  399. if (rinfo.report_type == HID_REPORT_TYPE_OUTPUT)
  400. return -EINVAL;
  402. if ((report = hiddev_lookup_report(hid, &rinfo)) == NULL)
  403. return -EINVAL;
  405. hid_read_report(hid, report);
  407. return 0;
  409. case HIDIOCSREPORT:
  410. if (copy_from_user(&rinfo, (void *) arg, sizeof(rinfo)))
  411. return -EFAULT;
  413. if (rinfo.report_type == HID_REPORT_TYPE_INPUT)
  414. return -EINVAL;
  416. if ((report = hiddev_lookup_report(hid, &rinfo)) == NULL)
  417. return -EINVAL;
  419. hid_write_report(hid, report);
  421. return 0;
  423. case HIDIOCGREPORTINFO:
  424. if (copy_from_user(&rinfo, (void *) arg, sizeof(rinfo)))
  425. return -EFAULT;
  427. if ((report = hiddev_lookup_report(hid, &rinfo)) == NULL)
  428. return -EINVAL;
  430. rinfo.num_fields = report->maxfield;
  432. return copy_to_user((void *) arg, &rinfo, sizeof(rinfo));
  434. case HIDIOCGFIELDINFO:
  435. {
  436. struct hiddev_field_info finfo;
  437. if (copy_from_user(&finfo, (void *) arg, sizeof(finfo)))
  438. return -EFAULT;
  439. rinfo.report_type = finfo.report_type;
  440. rinfo.report_id = finfo.report_id;
  441. if ((report = hiddev_lookup_report(hid, &rinfo)) == NULL)
  442. return -EINVAL;
  444. if (finfo.field_index >= report->maxfield)
  445. return -EINVAL;
  447. field = report->field[finfo.field_index];
  448. memset(&finfo, 0, sizeof(finfo));
  449. finfo.report_type = rinfo.report_type;
  450. finfo.report_id = rinfo.report_id;
  451. finfo.field_index = field->report_count - 1;
  452. finfo.maxusage = field->maxusage;
  453. finfo.flags = field->flags;
  454. finfo.physical = field->physical;
  455. finfo.logical = field->logical;
  456. finfo.application = field->application;
  457. finfo.logical_minimum = field->logical_minimum;
  458. finfo.logical_maximum = field->logical_maximum;
  459. finfo.physical_minimum = field->physical_minimum;
  460. finfo.physical_maximum = field->physical_maximum;
  461. finfo.unit_exponent = field->unit_exponent;
  462. finfo.unit = field->unit;
  464. return copy_to_user((void *) arg, &finfo, sizeof(finfo));
  465. }
  467. case HIDIOCGUCODE:
  468. if (copy_from_user(&uref, (void *) arg, sizeof(uref)))
  469. return -EFAULT;
  471. rinfo.report_type = uref.report_type;
  472. rinfo.report_id = uref.report_id;
  473. if ((report = hiddev_lookup_report(hid, &rinfo)) == NULL)
  474. return -EINVAL;
  476. if (uref.field_index >= report->maxfield)
  477. return -EINVAL;
  479. field = report->field[uref.field_index];
  480. if (uref.usage_index >= field->maxusage)
  481. return -EINVAL;
  483. uref.usage_code = field->usage[uref.usage_index].hid;
  485. return copy_to_user((void *) arg, &uref, sizeof(uref));
  487. case HIDIOCGUSAGE:
  488. if (copy_from_user(&uref, (void *) arg, sizeof(uref)))
  489. return -EFAULT;
  491. if (uref.report_id == HID_REPORT_ID_UNKNOWN) {
  492. field = hiddev_lookup_usage(hid, &uref);
  493. if (field == NULL)
  494. return -EINVAL;
  495. } else {
  496. rinfo.report_type = uref.report_type;
  497. rinfo.report_id = uref.report_id;
  498. if ((report = hiddev_lookup_report(hid, &rinfo)) == NULL)
  499. return -EINVAL;
  501. if (uref.field_index >= report->maxfield)
  502. return -EINVAL;
  504. field = report->field[uref.field_index];
  505. if (uref.usage_index >= field->maxusage)
  506. return -EINVAL;
  507. }
  509. uref.value = field->value[uref.usage_index];
  511. return copy_to_user((void *) arg, &uref, sizeof(uref));
  513. case HIDIOCSUSAGE:
  514. if (copy_from_user(&uref, (void *) arg, sizeof(uref)))
  515. return -EFAULT;
  517. if (uref.report_type == HID_REPORT_TYPE_INPUT)
  518. return -EINVAL;
  520. if (uref.report_id == HID_REPORT_ID_UNKNOWN) {
  521. field = hiddev_lookup_usage(hid, &uref);
  522. if (field == NULL)
  523. return -EINVAL;
  524. } else {
  525. rinfo.report_type = uref.report_type;
  526. rinfo.report_id = uref.report_id;
  527. if ((report = hiddev_lookup_report(hid, &rinfo)) == NULL)
  528. return -EINVAL;
  530. if (uref.field_index >= report->maxfield)
  531. return -EINVAL;
  533. field = report->field[uref.field_index];
  534. if (uref.usage_index >= field->maxusage)
  535. return -EINVAL;
  536. }
  538. field->value[uref.usage_index] = uref.value;
  540. return 0;
  542. default:
  544. if (_IOC_TYPE(cmd) != 'H' || _IOC_DIR(cmd) != _IOC_READ)
  545. return -EINVAL;
  547. if (_IOC_NR(cmd) == _IOC_NR(HIDIOCGNAME(0))) {
  548. int len;
  549. if (!hid->name) return 0;
  550. len = strlen(hid->name) + 1;
  551. if (len > _IOC_SIZE(cmd)) len = _IOC_SIZE(cmd);
  552. return copy_to_user((char *) arg, hid->name, len) ?
  553. -EFAULT : len;
  554. }
  555. }
  556. return -EINVAL;
  557. }
  559. static struct file_operations hiddev_fops = {
  560. owner: THIS_MODULE,
  561. read: hiddev_read,
  562. write: hiddev_write,
  563. poll: hiddev_poll,
  564. open: hiddev_open,
  565. release: hiddev_release,
  566. ioctl: hiddev_ioctl,
  567. fasync: hiddev_fasync,
  568. };
  570. /*
  571.  * This is where hid.c calls us to connect a hid device to the hiddev driver
  572.  */
  573. int hiddev_connect(struct hid_device *hid)
  574. {
  575. struct hiddev *hiddev;
  576. int minor, i;
  577. char devfs_name[16];
  579. for (i = 0; i < hid->maxapplication; i++)
  580. if (!IS_INPUT_APPLICATION(hid->application[i]))
  581. break;
  583. if (i == hid->maxapplication)
  584. return -1;
  586. for (minor = 0; minor < HIDDEV_MINORS && hiddev_table[minor]; minor++);
  587. if (minor == HIDDEV_MINORS) {
  588. printk(KERN_ERR "hiddev: no more free hiddev devicesn");
  589. return -1;
  590. }
  592. if (!(hiddev = kmalloc(sizeof(struct hiddev), GFP_KERNEL)))
  593. return -1;
  594. memset(hiddev, 0, sizeof(struct hiddev));
  596. init_waitqueue_head(&hiddev->wait);
  598. hiddev->minor = minor;
  599. hiddev_table[minor] = hiddev;
  601. hiddev->hid = hid;
  602. hiddev->exist = 1;
  604. sprintf(devfs_name, "hiddev%d", minor);
  605. hiddev->devfs = devfs_register(hiddev_devfs_handle, devfs_name,
  606.        DEVFS_FL_DEFAULT, USB_MAJOR,
  607.        minor + HIDDEV_MINOR_BASE,
  608.        S_IFCHR | S_IRUGO | S_IWUSR,
  609.        &hiddev_fops, NULL);
  610. hid->minor = minor;
  611. hid->hiddev = hiddev;
  613. return 0;
  614. }
  616. /*
  617.  * This is where hid.c calls us to disconnect a hiddev device from the
  618.  * corresponding hid device (usually because the usb device has disconnected)
  619.  */
  620. void hiddev_disconnect(struct hid_device *hid)
  621. {
  622. struct hiddev *hiddev = hid->hiddev;
  624. hiddev->exist = 0;
  626. if (hiddev->open) {
  627. hid_close(hiddev->hid);
  628. wake_up_interruptible(&hiddev->wait);
  629. } else {
  630. hiddev_cleanup(hiddev);
  631. }
  632. }
  634. /* Currently this driver is a USB driver.  It's not a conventional one in
  635.  * the sense that it doesn't probe at the USB level.  Instead it waits to
  636.  * be connected by HID through the hiddev_connect / hiddev_disconnect
  637.  * routines.  The reason to register as a USB device is to gain part of the
  638.  * minor number space from the USB major.
  639.  *
  640.  * In theory, should the HID code be generalized to more than one physical
  641.  * medium (say, IEEE 1384), this driver will probably need to register its
  642.  * own major number, and in doing so, no longer need to register with USB.
  643.  * At that point the probe routine and hiddev_driver struct below will no
  644.  * longer be useful.
  645.  */
  648. /* We never attach in this manner, and rely on HID to connect us.  This
  649.  * is why there is no disconnect routine defined in the usb_driver either.
  650.  */
  651. static void *hiddev_usbd_probe(struct usb_device *dev, unsigned int ifnum,
  652.   const struct usb_device_id *hiddev_info)
  653. {
  654. return NULL;
  655. }
  658. static /* const */ struct usb_driver hiddev_driver = {
  659. name: "hiddev",
  660. probe: hiddev_usbd_probe,
  661. fops: &hiddev_fops,
  662. minor: HIDDEV_MINOR_BASE
  663. };
  665. int __init hiddev_init(void)
  666. {
  667. hiddev_devfs_handle =
  668. devfs_mk_dir(devfs_find_handle(NULL, "usb", 0, 0, 0, 0), "hid", NULL);
  669. usb_register(&hiddev_driver);
  670. return 0;
  671. }
  673. void __exit hiddev_exit(void)
  674. {
  675. devfs_unregister(hiddev_devfs_handle);
  676. usb_deregister(&hiddev_driver);
  677. }