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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
devio.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：31k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

devio.c：源码内容
  1. /*****************************************************************************/
  3. /*
  4.  *      devio.c  --  User space communication with USB devices.
  5.  *
  6.  *      Copyright (C) 1999-2000  Thomas Sailer (sailer@ife.ee.ethz.ch)
  7.  *
  8.  *      This program is free software; you can redistribute it and/or modify
  9.  *      it under the terms of the GNU General Public License as published by
  10.  *      the Free Software Foundation; either version 2 of the License, or
  11.  *      (at your option) any later version.
  12.  *
  13.  *      This program is distributed in the hope that it will be useful,
  14.  *      but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16.  *      GNU General Public License for more details.
  17.  *
  18.  *      You should have received a copy of the GNU General Public License
  19.  *      along with this program; if not, write to the Free Software
  20.  *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21.  *
  22.  *  $Id: devio.c,v 1.7 2000/02/01 17:28:48 fliegl Exp $
  23.  *
  24.  *  This file implements the usbdevfs/x/y files, where
  25.  *  x is the bus number and y the device number.
  26.  *
  27.  *  It allows user space programs/"drivers" to communicate directly
  28.  *  with USB devices without intervening kernel driver.
  29.  *
  30.  *  Revision history
  31.  *    22.12.1999   0.1   Initial release (split from proc_usb.c)
  32.  *    04.01.2000   0.2   Turned into its own filesystem
  33.  */
  35. /*****************************************************************************/
  37. #include <linux/fs.h>
  38. #include <linux/mm.h>
  39. #include <linux/slab.h>
  40. #include <linux/smp_lock.h>
  41. #include <linux/signal.h>
  42. #include <linux/poll.h>
  43. #include <linux/usb.h>
  44. #include <linux/usbdevice_fs.h>
  45. #include <asm/uaccess.h>
  48. struct async {
  49.         struct list_head asynclist;
  50.         struct dev_state *ps;
  51. struct task_struct *task;
  52. unsigned int signr;
  53. void *userbuffer;
  54.         void *userurb;
  55.         struct urb urb;
  56. };
  58. static loff_t usbdev_lseek(struct file *file, loff_t offset, int orig)
  59. {
  60. switch (orig) {
  61. case 0:
  62. file->f_pos = offset;
  63. return file->f_pos;
  65. case 1:
  66. file->f_pos += offset;
  67. return file->f_pos;
  69. case 2:
  70. return -EINVAL;
  72. default:
  73. return -EINVAL;
  74. }
  75. }
  77. static ssize_t usbdev_read(struct file *file, char * buf, size_t nbytes, loff_t *ppos)
  78. {
  79. struct dev_state *ps = (struct dev_state *)file->private_data;
  80. ssize_t ret = 0;
  81. unsigned len;
  82. loff_t pos;
  83. int i;
  85. pos = *ppos;
  86. down_read(&ps->devsem);
  87. if (!ps->dev) {
  88. ret = -ENODEV;
  89. goto err;
  90. } else if (pos < 0) {
  91. ret = -EINVAL;
  92. goto err;
  93. }
  95. if (pos < sizeof(struct usb_device_descriptor)) {
  96. len = sizeof(struct usb_device_descriptor) - pos;
  97. if (len > nbytes)
  98. len = nbytes;
  99. if (copy_to_user(buf, ((char *)&ps->dev->descriptor) + pos, len)) {
  100. ret = -EFAULT;
  101. goto err;
  102. }
  104. *ppos += len;
  105. buf += len;
  106. nbytes -= len;
  107. ret += len;
  108. }
  110. pos = sizeof(struct usb_device_descriptor);
  111. for (i = 0; nbytes && i < ps->dev->descriptor.bNumConfigurations; i++) {
  112. struct usb_config_descriptor *config =
  113. (struct usb_config_descriptor *)ps->dev->rawdescriptors[i];
  114. unsigned int length = le16_to_cpu(config->wTotalLength);
  116. if (*ppos < pos + length) {
  117. len = length - (*ppos - pos);
  118. if (len > nbytes)
  119. len = nbytes;
  121. if (copy_to_user(buf,
  122.     ps->dev->rawdescriptors[i] + (*ppos - pos), len)) {
  123. ret = -EFAULT;
  124. goto err;
  125. }
  127. *ppos += len;
  128. buf += len;
  129. nbytes -= len;
  130. ret += len;
  131. }
  133. pos += length;
  134. }
  136. err:
  137. up_read(&ps->devsem);
  138. return ret;
  139. }
  141. static inline unsigned int ld2(unsigned int x)
  142. {
  143.         unsigned int r = 0;
  144.         
  145.         if (x >= 0x10000) {
  146.                 x >>= 16;
  147.                 r += 16;
  148.         }
  149.         if (x >= 0x100) {
  150.                 x >>= 8;
  151.                 r += 8;
  152.         }
  153.         if (x >= 0x10) {
  154.                 x >>= 4;
  155.                 r += 4;
  156.         }
  157.         if (x >= 4) {
  158.                 x >>= 2;
  159.                 r += 2;
  160.         }
  161.         if (x >= 2)
  162.                 r++;
  163.         return r;
  164. }
  166. /*
  167.  * async list handling
  168.  */
  170. static struct async *alloc_async(unsigned int numisoframes)
  171. {
  172.         unsigned int assize = sizeof(struct async) + numisoframes * sizeof(struct iso_packet_descriptor);
  173.         struct async *as = kmalloc(assize, GFP_KERNEL);
  174.         if (!as)
  175.                 return NULL;
  176.         memset(as, 0, assize);
  177.         as->urb.number_of_packets = numisoframes;
  178.         spin_lock_init(&as->urb.lock);
  179.         return as;
  180. }
  182. static void free_async(struct async *as)
  183. {
  184.         if (as->urb.transfer_buffer)
  185.                 kfree(as->urb.transfer_buffer);
  186.         if (as->urb.setup_packet)
  187.                 kfree(as->urb.setup_packet);
  188.         kfree(as);
  189. }
  191. static inline void async_newpending(struct async *as)
  192. {
  193.         struct dev_state *ps = as->ps;
  194.         unsigned long flags;
  195.         
  196.         spin_lock_irqsave(&ps->lock, flags);
  197.         list_add_tail(&as->asynclist, &ps->async_pending);
  198.         spin_unlock_irqrestore(&ps->lock, flags);
  199. }
  201. static inline void async_removepending(struct async *as)
  202. {
  203.         struct dev_state *ps = as->ps;
  204.         unsigned long flags;
  205.         
  206.         spin_lock_irqsave(&ps->lock, flags);
  207.         list_del(&as->asynclist);
  208.         INIT_LIST_HEAD(&as->asynclist);
  209.         spin_unlock_irqrestore(&ps->lock, flags);
  210. }
  212. static inline struct async *async_getcompleted(struct dev_state *ps)
  213. {
  214.         unsigned long flags;
  215.         struct async *as = NULL;
  217.         spin_lock_irqsave(&ps->lock, flags);
  218.         if (!list_empty(&ps->async_completed)) {
  219.                 as = list_entry(ps->async_completed.next, struct async, asynclist);
  220.                 list_del(&as->asynclist);
  221.                 INIT_LIST_HEAD(&as->asynclist);
  222.         }
  223.         spin_unlock_irqrestore(&ps->lock, flags);
  224.         return as;
  225. }
  227. static inline struct async *async_getpending(struct dev_state *ps, void *userurb)
  228. {
  229.         unsigned long flags;
  230.         struct async *as;
  231.         struct list_head *p;
  233.         spin_lock_irqsave(&ps->lock, flags);
  234.         for (p = ps->async_pending.next; p != &ps->async_pending; ) {
  235.                 as = list_entry(p, struct async, asynclist);
  236.                 p = p->next;
  237.                 if (as->userurb != userurb)
  238.                         continue;
  239.                 list_del(&as->asynclist);
  240.                 INIT_LIST_HEAD(&as->asynclist);
  241.                 spin_unlock_irqrestore(&ps->lock, flags);
  242.                 return as;
  243.         }
  244.         spin_unlock_irqrestore(&ps->lock, flags);
  245.         return NULL;
  246. }
  248. static void async_completed(struct urb *urb)
  249. {
  250.         struct async *as = (struct async *)urb->context;
  251.         struct dev_state *ps = as->ps;
  252. struct siginfo sinfo;
  254.         spin_lock(&ps->lock);
  255.         list_del(&as->asynclist);
  256.         list_add_tail(&as->asynclist, &ps->async_completed);
  257.         spin_unlock(&ps->lock);
  258.         wake_up(&ps->wait);
  259. if (as->signr) {
  260. sinfo.si_signo = as->signr;
  261. sinfo.si_errno = as->urb.status;
  262. sinfo.si_code = SI_ASYNCIO;
  263. sinfo.si_addr = as->userurb;
  264. send_sig_info(as->signr, &sinfo, as->task);
  265. }
  266. }
  268. static void destroy_all_async(struct dev_state *ps)
  269. {
  270.         struct async *as;
  271.         unsigned long flags;
  273.         spin_lock_irqsave(&ps->lock, flags);
  274.         while (!list_empty(&ps->async_pending)) {
  275.                 as = list_entry(ps->async_pending.next, struct async, asynclist);
  276.                 list_del(&as->asynclist);
  277.                 INIT_LIST_HEAD(&as->asynclist);
  278.                 spin_unlock_irqrestore(&ps->lock, flags);
  279.                 /* usb_unlink_urb calls the completion handler with status == USB_ST_URB_KILLED */
  280.                 usb_unlink_urb(&as->urb);
  281.                 spin_lock_irqsave(&ps->lock, flags);
  282.         }
  283.         spin_unlock_irqrestore(&ps->lock, flags);
  284.         while ((as = async_getcompleted(ps)))
  285.                 free_async(as);
  286. }
  288. /*
  289.  * interface claims are made only at the request of user level code,
  290.  * which can also release them (explicitly or by closing files).
  291.  * they're also undone when devices disconnect.
  292.  */
  294. static void *driver_probe(struct usb_device *dev, unsigned int intf,
  295.   const struct usb_device_id *id)
  296. {
  297. return NULL;
  298. }
  300. static void driver_disconnect(struct usb_device *dev, void *context)
  301. {
  302. struct dev_state *ps = (struct dev_state *)context;
  304. if (!ps)
  305. return;
  307. /* this waits till synchronous requests complete */
  308. down_write (&ps->devsem);
  310. /* prevent new I/O requests */
  311. ps->dev = 0;
  312. ps->ifclaimed = 0;
  314. /* force async requests to complete */
  315. destroy_all_async (ps);
  317. up_write (&ps->devsem);
  318. }
  320. struct usb_driver usbdevfs_driver = {
  321. name: "usbdevfs",
  322. probe: driver_probe,
  323. disconnect: driver_disconnect,
  324. };
  326. static int claimintf(struct dev_state *ps, unsigned int intf)
  327. {
  328. struct usb_device *dev = ps->dev;
  329. struct usb_interface *iface;
  330. int err;
  332. if (intf >= 8*sizeof(ps->ifclaimed) || !dev || intf >= dev->actconfig->bNumInterfaces)
  333. return -EINVAL;
  334. /* already claimed */
  335. if (test_bit(intf, &ps->ifclaimed))
  336. return 0;
  337. iface = &dev->actconfig->interface[intf];
  338. err = -EBUSY;
  339. lock_kernel();
  340. if (!usb_interface_claimed(iface)) {
  341. usb_driver_claim_interface(&usbdevfs_driver, iface, ps);
  342. set_bit(intf, &ps->ifclaimed);
  343. err = 0;
  344. }
  345. unlock_kernel();
  346. return err;
  347. }
  349. static int releaseintf(struct dev_state *ps, unsigned int intf)
  350. {
  351. struct usb_device *dev;
  352. struct usb_interface *iface;
  353. int err;
  355. if (intf >= 8*sizeof(ps->ifclaimed))
  356. return -EINVAL;
  357. err = -EINVAL;
  358. lock_kernel();
  359. dev = ps->dev;
  360. if (dev && test_and_clear_bit(intf, &ps->ifclaimed)) {
  361. iface = &dev->actconfig->interface[intf];
  362. usb_driver_release_interface(&usbdevfs_driver, iface);
  363. err = 0;
  364. }
  365. unlock_kernel();
  366. return err;
  367. }
  369. static int checkintf(struct dev_state *ps, unsigned int intf)
  370. {
  371. if (intf >= 8*sizeof(ps->ifclaimed))
  372. return -EINVAL;
  373. if (test_bit(intf, &ps->ifclaimed))
  374. return 0;
  375. /* if not yet claimed, claim it for the driver */
  376. printk(KERN_WARNING "usbdevfs: process %d (%s) did not claim interface %u before usen",
  377.        current->pid, current->comm, intf);
  378. return claimintf(ps, intf);
  379. }
  381. static int findintfep(struct usb_device *dev, unsigned int ep)
  382. {
  383. unsigned int i, j, e;
  384.         struct usb_interface *iface;
  385. struct usb_interface_descriptor *alts;
  386. struct usb_endpoint_descriptor *endpt;
  388. if (ep & ~(USB_DIR_IN|0xf))
  389. return -EINVAL;
  390. for (i = 0; i < dev->actconfig->bNumInterfaces; i++) {
  391. iface = &dev->actconfig->interface[i];
  392. for (j = 0; j < iface->num_altsetting; j++) {
  393.                         alts = &iface->altsetting[j];
  394. for (e = 0; e < alts->bNumEndpoints; e++) {
  395. endpt = &alts->endpoint[e];
  396. if (endpt->bEndpointAddress == ep)
  397. return i;
  398. }
  399. }
  400. }
  401. return -ENOENT; 
  402. }
  404. static int findintfif(struct usb_device *dev, unsigned int ifn)
  405. {
  406. unsigned int i, j;
  407.         struct usb_interface *iface;
  408. struct usb_interface_descriptor *alts;
  410. if (ifn & ~0xff)
  411. return -EINVAL;
  412. for (i = 0; i < dev->actconfig->bNumInterfaces; i++) {
  413. iface = &dev->actconfig->interface[i];
  414. for (j = 0; j < iface->num_altsetting; j++) {
  415.                         alts = &iface->altsetting[j];
  416. if (alts->bInterfaceNumber == ifn)
  417. return i;
  418. }
  419. }
  420. return -ENOENT; 
  421. }
  423. extern struct list_head usb_driver_list;
  425. #if 0
  426. static int finddriver(struct usb_driver **driver, char *name)
  427. {
  428. struct list_head *tmp;
  430. tmp = usb_driver_list.next;
  431. while (tmp != &usb_driver_list) {
  432. struct usb_driver *d = list_entry(tmp, struct usb_driver,
  433. driver_list);
  435. if (!strcmp(d->name, name)) {
  436. *driver = d;
  437. return 0;
  438. }
  440. tmp = tmp->next;
  441. }
  443. return -EINVAL;
  444. }
  445. #endif
  447. static int check_ctrlrecip(struct dev_state *ps, unsigned int requesttype, unsigned int index)
  448. {
  449. int ret;
  451. if (USB_TYPE_VENDOR == (USB_TYPE_MASK & requesttype))
  452. return 0;
  454. switch (requesttype & USB_RECIP_MASK) {
  455. case USB_RECIP_ENDPOINT:
  456. if ((ret = findintfep(ps->dev, index & 0xff)) < 0)
  457. return ret;
  458. if ((ret = checkintf(ps, ret)))
  459. return ret;
  460. break;
  462. case USB_RECIP_INTERFACE:
  463. if ((ret = findintfif(ps->dev, index & 0xff)) < 0)
  464. return ret;
  465. if ((ret = checkintf(ps, ret)))
  466. return ret;
  467. break;
  468. }
  469. return 0;
  470. }
  472. /*
  473.  * file operations
  474.  */
  475. static int usbdev_open(struct inode *inode, struct file *file)
  476. {
  477. struct usb_device *dev;
  478. struct dev_state *ps;
  479. int ret;
  481. /* 
  482.  * no locking necessary here, as both sys_open (actually filp_open)
  483.  * and the hub thread have the kernel lock
  484.  * (still acquire the kernel lock for safety)
  485.  */
  486. lock_kernel();
  487. ret = -ENOENT;
  488. if (ITYPE(inode->i_ino) != IDEVICE)
  489. goto out;
  490. dev = inode->u.usbdev_i.p.dev;
  491. if (!dev)
  492. goto out;
  493. ret = -ENOMEM;
  494. if (!(ps = kmalloc(sizeof(struct dev_state), GFP_KERNEL)))
  495. goto out;
  496. ret = 0;
  497. ps->dev = dev;
  498. ps->file = file;
  499. spin_lock_init(&ps->lock);
  500. INIT_LIST_HEAD(&ps->async_pending);
  501. INIT_LIST_HEAD(&ps->async_completed);
  502. init_waitqueue_head(&ps->wait);
  503. init_rwsem(&ps->devsem);
  504. ps->discsignr = 0;
  505. ps->disctask = current;
  506. ps->disccontext = NULL;
  507. ps->ifclaimed = 0;
  508. wmb();
  509. list_add_tail(&ps->list, &dev->filelist);
  510. file->private_data = ps;
  511.  out:
  512. unlock_kernel();
  513.         return ret;
  514. }
  516. static int usbdev_release(struct inode *inode, struct file *file)
  517. {
  518. struct dev_state *ps = (struct dev_state *)file->private_data;
  519. unsigned int i;
  521. lock_kernel();
  522. list_del(&ps->list);
  523. INIT_LIST_HEAD(&ps->list);
  524. if (ps->dev) {
  525. for (i = 0; ps->ifclaimed && i < 8*sizeof(ps->ifclaimed); i++)
  526. if (test_bit(i, &ps->ifclaimed))
  527. releaseintf(ps, i);
  528. }
  529. unlock_kernel();
  530. destroy_all_async(ps);
  531. kfree(ps);
  532.         return 0;
  533. }
  535. static int proc_control(struct dev_state *ps, void *arg)
  536. {
  537. struct usb_device *dev = ps->dev;
  538. struct usbdevfs_ctrltransfer ctrl;
  539. unsigned int tmo;
  540. unsigned char *tbuf;
  541. int i, ret;
  543. if (copy_from_user(&ctrl, (void *)arg, sizeof(ctrl)))
  544. return -EFAULT;
  545. if ((ret = check_ctrlrecip(ps, ctrl.requesttype, ctrl.index)))
  546. return ret;
  547. if (ctrl.length > PAGE_SIZE)
  548. return -EINVAL;
  549. if (!(tbuf = (unsigned char *)__get_free_page(GFP_KERNEL)))
  550. return -ENOMEM;
  551. tmo = (ctrl.timeout * HZ + 999) / 1000;
  552. if (ctrl.requesttype & 0x80) {
  553. if (ctrl.length && !access_ok(VERIFY_WRITE, ctrl.data, ctrl.length)) {
  554. free_page((unsigned long)tbuf);
  555. return -EINVAL;
  556. }
  557. i = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), ctrl.request, ctrl.requesttype,
  558.        ctrl.value, ctrl.index, tbuf, ctrl.length, tmo);
  559. if ((i > 0) && ctrl.length) {
  560. if (copy_to_user(ctrl.data, tbuf, ctrl.length)) {
  561. free_page((unsigned long)tbuf);
  562. return -EFAULT;
  563. }
  564. }
  565. } else {
  566. if (ctrl.length) {
  567. if (copy_from_user(tbuf, ctrl.data, ctrl.length)) {
  568. free_page((unsigned long)tbuf);
  569. return -EFAULT;
  570. }
  571. }
  572. i = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), ctrl.request, ctrl.requesttype,
  573.        ctrl.value, ctrl.index, tbuf, ctrl.length, tmo);
  574. }
  575. free_page((unsigned long)tbuf);
  576. if (i<0) {
  577. printk(KERN_DEBUG "usbdevfs: USBDEVFS_CONTROL failed dev %d rqt %u rq %u len %u ret %dn", 
  578.        dev->devnum, ctrl.requesttype, ctrl.request, ctrl.length, i);
  579. }
  580. return i;
  581. }
  583. static int proc_bulk(struct dev_state *ps, void *arg)
  584. {
  585. struct usb_device *dev = ps->dev;
  586. struct usbdevfs_bulktransfer bulk;
  587. unsigned int tmo, len1, pipe;
  588. int len2;
  589. unsigned char *tbuf;
  590. int i, ret;
  592. if (copy_from_user(&bulk, (void *)arg, sizeof(bulk)))
  593. return -EFAULT;
  594. if ((ret = findintfep(ps->dev, bulk.ep)) < 0)
  595. return ret;
  596. if ((ret = checkintf(ps, ret)))
  597. return ret;
  598. if (bulk.ep & USB_DIR_IN)
  599. pipe = usb_rcvbulkpipe(dev, bulk.ep & 0x7f);
  600. else
  601. pipe = usb_sndbulkpipe(dev, bulk.ep & 0x7f);
  602. if (!usb_maxpacket(dev, pipe, !(bulk.ep & USB_DIR_IN)))
  603. return -EINVAL;
  604. len1 = bulk.len;
  605. if (len1 > PAGE_SIZE)
  606. return -EINVAL;
  607. if (!(tbuf = (unsigned char *)__get_free_page(GFP_KERNEL)))
  608. return -ENOMEM;
  609. tmo = (bulk.timeout * HZ + 999) / 1000;
  610. if (bulk.ep & 0x80) {
  611. if (len1 && !access_ok(VERIFY_WRITE, bulk.data, len1)) {
  612. free_page((unsigned long)tbuf);
  613. return -EINVAL;
  614. }
  615. i = usb_bulk_msg(dev, pipe, tbuf, len1, &len2, tmo);
  616. if (!i && len2) {
  617. if (copy_to_user(bulk.data, tbuf, len2)) {
  618. free_page((unsigned long)tbuf);
  619. return -EFAULT;
  620. }
  621. }
  622. } else {
  623. if (len1) {
  624. if (copy_from_user(tbuf, bulk.data, len1)) {
  625. free_page((unsigned long)tbuf);
  626. return -EFAULT;
  627. }
  628. }
  629. i = usb_bulk_msg(dev, pipe, tbuf, len1, &len2, tmo);
  630. }
  631. free_page((unsigned long)tbuf);
  632. if (i < 0) {
  633. printk(KERN_WARNING "usbdevfs: USBDEVFS_BULK failed dev %d ep 0x%x len %u ret %dn", 
  634.        dev->devnum, bulk.ep, bulk.len, i);
  635. return i;
  636. }
  637. return len2;
  638. }
  640. static int proc_resetep(struct dev_state *ps, void *arg)
  641. {
  642. unsigned int ep;
  643. int ret;
  645. if (get_user(ep, (unsigned int *)arg))
  646. return -EFAULT;
  647. if ((ret = findintfep(ps->dev, ep)) < 0)
  648. return ret;
  649. if ((ret = checkintf(ps, ret)))
  650. return ret;
  651. usb_settoggle(ps->dev, ep & 0xf, !(ep & USB_DIR_IN), 0);
  652. return 0;
  653. }
  655. static int proc_clearhalt(struct dev_state *ps, void *arg)
  656. {
  657. unsigned int ep;
  658. int pipe;
  659. int ret;
  661. if (get_user(ep, (unsigned int *)arg))
  662. return -EFAULT;
  663. if ((ret = findintfep(ps->dev, ep)) < 0)
  664. return ret;
  665. if ((ret = checkintf(ps, ret)))
  666. return ret;
  667. if (ep & USB_DIR_IN)
  668.                 pipe = usb_rcvbulkpipe(ps->dev, ep & 0x7f);
  669.         else
  670.                 pipe = usb_sndbulkpipe(ps->dev, ep & 0x7f);
  672. return usb_clear_halt(ps->dev, pipe);
  673. }
  676. static int proc_getdriver(struct dev_state *ps, void *arg)
  677. {
  678. struct usbdevfs_getdriver gd;
  679. struct usb_interface *interface;
  680. int ret;
  682. if (copy_from_user(&gd, arg, sizeof(gd)))
  683. return -EFAULT;
  684. if ((ret = findintfif(ps->dev, gd.interface)) < 0)
  685. return ret;
  686. interface = usb_ifnum_to_if(ps->dev, gd.interface);
  687. if (!interface)
  688. return -EINVAL;
  689. if (!interface->driver)
  690. return -ENODATA;
  691. strcpy(gd.driver, interface->driver->name);
  692. if (copy_to_user(arg, &gd, sizeof(gd)))
  693. return -EFAULT;
  694. return 0;
  695. }
  697. static int proc_connectinfo(struct dev_state *ps, void *arg)
  698. {
  699. struct usbdevfs_connectinfo ci;
  701. ci.devnum = ps->dev->devnum;
  702. ci.slow = ps->dev->speed == USB_SPEED_LOW;
  703. if (copy_to_user(arg, &ci, sizeof(ci)))
  704. return -EFAULT;
  705. return 0;
  706. }
  708. static int proc_resetdevice(struct dev_state *ps)
  709. {
  710. int i, ret;
  712. ret = usb_reset_device(ps->dev);
  713. if (ret < 0)
  714. return ret;
  716. for (i = 0; i < ps->dev->actconfig->bNumInterfaces; i++) {
  717. struct usb_interface *intf = &ps->dev->actconfig->interface[i];
  719. /* Don't simulate interfaces we've claimed */
  720. if (test_bit(i, &ps->ifclaimed))
  721. continue;
  723. if (intf->driver) {
  724. const struct usb_device_id *id;
  725. down(&intf->driver->serialize);
  726. intf->driver->disconnect(ps->dev, intf->private_data);
  727. id = usb_match_id(ps->dev,intf,intf->driver->id_table);
  728. intf->driver->probe(ps->dev, i, id);
  729. up(&intf->driver->serialize);
  730. }
  731. }
  733. return 0;
  734. }
  736. static int proc_setintf(struct dev_state *ps, void *arg)
  737. {
  738. struct usbdevfs_setinterface setintf;
  739. struct usb_interface *interface;
  740. int ret;
  742. if (copy_from_user(&setintf, arg, sizeof(setintf)))
  743. return -EFAULT;
  744. if ((ret = findintfif(ps->dev, setintf.interface)) < 0)
  745. return ret;
  746. interface = usb_ifnum_to_if(ps->dev, setintf.interface);
  747. if (!interface)
  748. return -EINVAL;
  749. if (interface->driver) {
  750. if ((ret = checkintf(ps, ret)))
  751. return ret;
  752. }
  753. if (usb_set_interface(ps->dev, setintf.interface, setintf.altsetting))
  754. return -EINVAL;
  755. return 0;
  756. }
  758. static int proc_setconfig(struct dev_state *ps, void *arg)
  759. {
  760. unsigned int u;
  762. if (get_user(u, (unsigned int *)arg))
  763. return -EFAULT;
  764. if (usb_set_configuration(ps->dev, u) < 0)
  765. return -EINVAL;
  766. return 0;
  767. }
  769. static int proc_submiturb(struct dev_state *ps, void *arg)
  770. {
  771. struct usbdevfs_urb uurb;
  772. struct usbdevfs_iso_packet_desc *isopkt = NULL;
  773. struct usb_endpoint_descriptor *ep_desc;
  774. struct async *as;
  775. struct usb_ctrlrequest *dr = NULL;
  776. unsigned int u, totlen, isofrmlen;
  777. int ret;
  779. if (copy_from_user(&uurb, arg, sizeof(uurb)))
  780. return -EFAULT;
  781. if (uurb.flags & ~(USBDEVFS_URB_ISO_ASAP|USBDEVFS_URB_DISABLE_SPD|USBDEVFS_URB_QUEUE_BULK|
  782.    USB_NO_FSBR|USB_ZERO_PACKET))
  783. return -EINVAL;
  784. if (!uurb.buffer)
  785. return -EINVAL;
  786. if (uurb.signr != 0 && (uurb.signr < SIGRTMIN || uurb.signr > SIGRTMAX))
  787. return -EINVAL;
  788. if (!(uurb.type == USBDEVFS_URB_TYPE_CONTROL && (uurb.endpoint & ~USB_ENDPOINT_DIR_MASK) == 0)) {
  789. if ((ret = findintfep(ps->dev, uurb.endpoint)) < 0)
  790. return ret;
  791. if ((ret = checkintf(ps, ret)))
  792. return ret;
  793. }
  794. switch(uurb.type) {
  795. case USBDEVFS_URB_TYPE_CONTROL:
  796. if ((uurb.endpoint & ~USB_ENDPOINT_DIR_MASK) != 0) {
  797. if (!(ep_desc = usb_epnum_to_ep_desc(ps->dev, uurb.endpoint)))
  798. return -ENOENT;
  799. if ((ep_desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) != USB_ENDPOINT_XFER_CONTROL)
  800. return -EINVAL;
  801. }
  802. /* min 8 byte setup packet, max arbitrary */
  803. if (uurb.buffer_length < 8 || uurb.buffer_length > PAGE_SIZE)
  804. return -EINVAL;
  805. if (!(dr = kmalloc(sizeof(struct usb_ctrlrequest), GFP_KERNEL)))
  806. return -ENOMEM;
  807. if (copy_from_user(dr, (unsigned char*)uurb.buffer, 8)) {
  808. kfree(dr);
  809. return -EFAULT;
  810. }
  811. if (uurb.buffer_length < (le16_to_cpup(&dr->wLength) + 8)) {
  812. kfree(dr);
  813. return -EINVAL;
  814. }
  815. if ((ret = check_ctrlrecip(ps, dr->bRequestType, le16_to_cpup(&dr->wIndex)))) {
  816. kfree(dr);
  817. return ret;
  818. }
  819. uurb.endpoint = (uurb.endpoint & ~USB_ENDPOINT_DIR_MASK) | (dr->bRequestType & USB_ENDPOINT_DIR_MASK);
  820. uurb.number_of_packets = 0;
  821. uurb.buffer_length = le16_to_cpup(&dr->wLength);
  822. uurb.buffer += 8;
  823. if (!access_ok((uurb.endpoint & USB_DIR_IN) ?  VERIFY_WRITE : VERIFY_READ, uurb.buffer, uurb.buffer_length)) {
  824. kfree(dr);
  825. return -EFAULT;
  826. }
  827. break;
  829. case USBDEVFS_URB_TYPE_BULK:
  830. uurb.number_of_packets = 0;
  831. if (uurb.buffer_length > 16384)
  832. return -EINVAL;
  833. if (!access_ok((uurb.endpoint & USB_DIR_IN) ? VERIFY_WRITE : VERIFY_READ, uurb.buffer, uurb.buffer_length))
  834. return -EFAULT;
  835. break;
  837. case USBDEVFS_URB_TYPE_ISO:
  838. /* arbitrary limit */
  839. if (uurb.number_of_packets < 1 || uurb.number_of_packets > 128)
  840. return -EINVAL;
  841. isofrmlen = sizeof(struct usbdevfs_iso_packet_desc) * uurb.number_of_packets;
  842. if (!(isopkt = kmalloc(isofrmlen, GFP_KERNEL)))
  843. return -ENOMEM;
  844. if (copy_from_user(isopkt, &((struct usbdevfs_urb *)arg)->iso_frame_desc, isofrmlen)) {
  845. kfree(isopkt);
  846. return -EFAULT;
  847. }
  848. for (totlen = u = 0; u < uurb.number_of_packets; u++) {
  849. if (isopkt[u].length > 1023) {
  850. kfree(isopkt);
  851. return -EINVAL;
  852. }
  853. totlen += isopkt[u].length;
  854. }
  855. if (totlen > 32768) {
  856. kfree(isopkt);
  857. return -EINVAL;
  858. }
  859. uurb.buffer_length = totlen;
  860. break;
  862. case USBDEVFS_URB_TYPE_INTERRUPT:
  863. uurb.number_of_packets = 0;
  864. if (uurb.buffer_length > 16384)
  865. return -EINVAL;
  866. if (!access_ok((uurb.endpoint & USB_DIR_IN) ? VERIFY_WRITE : VERIFY_READ, uurb.buffer, uurb.buffer_length))
  867. return -EFAULT;   
  868. break;
  870. default:
  871. return -EINVAL;
  872. }
  873. if (!(as = alloc_async(uurb.number_of_packets))) {
  874. if (isopkt)
  875. kfree(isopkt);
  876. if (dr)
  877. kfree(dr);
  878. return -ENOMEM;
  879. }
  880. if (!(as->urb.transfer_buffer = kmalloc(uurb.buffer_length, GFP_KERNEL))) {
  881. if (isopkt)
  882. kfree(isopkt);
  883. if (dr)
  884. kfree(dr);
  885. free_async(as);
  886. return -ENOMEM;
  887. }
  888.         as->urb.next = NULL;
  889.         as->urb.dev = ps->dev;
  890.         as->urb.pipe = (uurb.type << 30) | __create_pipe(ps->dev, uurb.endpoint & 0xf) | (uurb.endpoint & USB_DIR_IN);
  891.         as->urb.transfer_flags = uurb.flags;
  892. as->urb.transfer_buffer_length = uurb.buffer_length;
  893. as->urb.setup_packet = (unsigned char*)dr;
  894. as->urb.start_frame = uurb.start_frame;
  895. as->urb.number_of_packets = uurb.number_of_packets;
  896.         as->urb.context = as;
  897.         as->urb.complete = async_completed;
  898. for (totlen = u = 0; u < uurb.number_of_packets; u++) {
  899. as->urb.iso_frame_desc[u].offset = totlen;
  900. as->urb.iso_frame_desc[u].length = isopkt[u].length;
  901. totlen += isopkt[u].length;
  902. }
  903. if (isopkt)
  904. kfree(isopkt);
  905. as->ps = ps;
  906.         as->userurb = arg;
  907. if (uurb.endpoint & USB_DIR_IN)
  908. as->userbuffer = uurb.buffer;
  909. else
  910. as->userbuffer = NULL;
  911. as->signr = uurb.signr;
  912. as->task = current;
  913. if (!(uurb.endpoint & USB_DIR_IN)) {
  914. if (copy_from_user(as->urb.transfer_buffer, uurb.buffer, as->urb.transfer_buffer_length)) {
  915. free_async(as);
  916. return -EFAULT;
  917. }
  918. }
  919.         async_newpending(as);
  920.         if ((ret = usb_submit_urb(&as->urb))) {
  921. printk(KERN_DEBUG "usbdevfs: usb_submit_urb returned %dn", ret);
  922.                 async_removepending(as);
  923.                 free_async(as);
  924.                 return ret;
  925.         }
  926.         return 0;
  927. }
  929. static int proc_unlinkurb(struct dev_state *ps, void *arg)
  930. {
  931. struct async *as;
  933. as = async_getpending(ps, arg);
  934. if (!as)
  935. return -EINVAL;
  936. usb_unlink_urb(&as->urb);
  937. return 0;
  938. }
  940. static int processcompl(struct async *as)
  941. {
  942. unsigned int i;
  944. if (as->userbuffer)
  945. if (copy_to_user(as->userbuffer, as->urb.transfer_buffer, as->urb.transfer_buffer_length))
  946. return -EFAULT;
  947. if (put_user(as->urb.status,
  948.      &((struct usbdevfs_urb *)as->userurb)->status))
  949. return -EFAULT;
  950. if (put_user(as->urb.actual_length,
  951.      &((struct usbdevfs_urb *)as->userurb)->actual_length))
  952. return -EFAULT;
  953. if (put_user(as->urb.error_count,
  954.      &((struct usbdevfs_urb *)as->userurb)->error_count))
  955. return -EFAULT;
  957. if (!(usb_pipeisoc(as->urb.pipe)))
  958. return 0;
  959. for (i = 0; i < as->urb.number_of_packets; i++) {
  960. if (put_user(as->urb.iso_frame_desc[i].actual_length, 
  961.      &((struct usbdevfs_urb *)as->userurb)->iso_frame_desc[i].actual_length))
  962. return -EFAULT;
  963. if (put_user(as->urb.iso_frame_desc[i].status, 
  964.      &((struct usbdevfs_urb *)as->userurb)->iso_frame_desc[i].status))
  965. return -EFAULT;
  966. }
  967. return 0;
  968. }
  970. static int proc_reapurb(struct dev_state *ps, void *arg)
  971. {
  972.         DECLARE_WAITQUEUE(wait, current);
  973. struct async *as = NULL;
  974. void *addr;
  975. int ret;
  977. add_wait_queue(&ps->wait, &wait);
  978. while (ps->dev) {
  979. __set_current_state(TASK_INTERRUPTIBLE);
  980. if ((as = async_getcompleted(ps)))
  981. break;
  982. if (signal_pending(current))
  983. break;
  984. up_read(&ps->devsem);
  985. schedule();
  986. down_read(&ps->devsem);
  987. }
  988. remove_wait_queue(&ps->wait, &wait);
  989. set_current_state(TASK_RUNNING);
  990. if (as) {
  991. ret = processcompl(as);
  992. addr = as->userurb;
  993. free_async(as);
  994. if (ret)
  995. return ret;
  996. if (put_user(addr, (void **)arg))
  997. return -EFAULT;
  998. return 0;
  999. }
  1000. if (signal_pending(current))
  1001. return -EINTR;
  1002. return -EIO;
  1003. }
  1005. static int proc_reapurbnonblock(struct dev_state *ps, void *arg)
  1006. {
  1007. struct async *as;
  1008. void *addr;
  1009. int ret;
  1011. if (!(as = async_getcompleted(ps)))
  1012. return -EAGAIN;
  1013. ret = processcompl(as);
  1014. addr = as->userurb;
  1015. free_async(as);
  1016. if (ret)
  1017. return ret;
  1018. if (put_user(addr, (void **)arg))
  1019. return -EFAULT;
  1020. return 0;
  1021. }
  1023. static int proc_disconnectsignal(struct dev_state *ps, void *arg)
  1024. {
  1025. struct usbdevfs_disconnectsignal ds;
  1027. if (copy_from_user(&ds, arg, sizeof(ds)))
  1028. return -EFAULT;
  1029. if (ds.signr != 0 && (ds.signr < SIGRTMIN || ds.signr > SIGRTMAX))
  1030. return -EINVAL;
  1031. ps->discsignr = ds.signr;
  1032. ps->disccontext = ds.context;
  1033. return 0;
  1034. }
  1036. static int proc_claiminterface(struct dev_state *ps, void *arg)
  1037. {
  1038. unsigned int intf;
  1039. int ret;
  1041. if (get_user(intf, (unsigned int *)arg))
  1042. return -EFAULT;
  1043. if ((ret = findintfif(ps->dev, intf)) < 0)
  1044. return ret;
  1045. return claimintf(ps, ret);
  1046. }
  1048. static int proc_releaseinterface(struct dev_state *ps, void *arg)
  1049. {
  1050. unsigned int intf;
  1051. int ret;
  1053. if (get_user(intf, (unsigned int *)arg))
  1054. return -EFAULT;
  1055. if ((ret = findintfif(ps->dev, intf)) < 0)
  1056. return ret;
  1057. return releaseintf(ps, intf);
  1058. }
  1060. static int proc_ioctl (struct dev_state *ps, void *arg)
  1061. {
  1062. struct usbdevfs_ioctl ctrl;
  1063. int size;
  1064. void *buf = 0;
  1065. int retval = 0;
  1067. /* get input parameters and alloc buffer */
  1068. if (copy_from_user(&ctrl, (void *) arg, sizeof (ctrl)))
  1069. return -EFAULT;
  1070. if ((size = _IOC_SIZE (ctrl.ioctl_code)) > 0) {
  1071. if ((buf = kmalloc (size, GFP_KERNEL)) == 0)
  1072. return -ENOMEM;
  1073. if ((_IOC_DIR(ctrl.ioctl_code) & _IOC_WRITE)) {
  1074. if (copy_from_user (buf, ctrl.data, size)) {
  1075. kfree (buf);
  1076. return -EFAULT;
  1077. }
  1078. } else {
  1079. memset (buf, 0, size);
  1080. }
  1081. }
  1083. /* ioctl to device */
  1084. if (ctrl.ifno < 0) {
  1085. switch (ctrl.ioctl_code) {
  1086. /* access/release token for issuing control messages
  1087.  * ask a particular driver to bind/unbind, ... etc
  1088.  */
  1089. }
  1090. retval = -ENOSYS;
  1092. /* ioctl to the driver which has claimed a given interface */
  1093. } else {
  1094. struct usb_interface *ifp = 0;
  1095. if (!ps->dev)
  1096. retval = -ENODEV;
  1097. else if (ctrl.ifno >= ps->dev->actconfig->bNumInterfaces)
  1098. retval = -EINVAL;
  1099. else {
  1100. if (!(ifp = usb_ifnum_to_if (ps->dev, ctrl.ifno)))
  1101. retval = -EINVAL;
  1102. else if (ifp->driver == 0 || ifp->driver->ioctl == 0)
  1103. retval = -ENOSYS;
  1104. }
  1105. if (retval == 0)
  1106. /* ifno might usefully be passed ... */
  1107. retval = ifp->driver->ioctl (ps->dev, ctrl.ioctl_code, buf);
  1108. /* size = min_t(int, size, retval)? */
  1109. }
  1111. /* cleanup and return */
  1112. if (retval >= 0
  1113. && (_IOC_DIR (ctrl.ioctl_code) & _IOC_READ) != 0
  1114. && size > 0
  1115. && copy_to_user (ctrl.data, buf, size) != 0)
  1116. retval = -EFAULT;
  1117. if (buf != 0)
  1118. kfree (buf);
  1119. return retval;
  1120. }
  1122. static int usbdev_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
  1123. {
  1124. struct dev_state *ps = (struct dev_state *)file->private_data;
  1125. int ret = -ENOIOCTLCMD;
  1127. if (!(file->f_mode & FMODE_WRITE))
  1128. return -EPERM;
  1129. down_read(&ps->devsem);
  1130. if (!ps->dev) {
  1131. up_read(&ps->devsem);
  1132. return -ENODEV;
  1133. }
  1134. switch (cmd) {
  1135. case USBDEVFS_CONTROL:
  1136. ret = proc_control(ps, (void *)arg);
  1137. if (ret >= 0)
  1138. inode->i_mtime = CURRENT_TIME;
  1139. break;
  1141. case USBDEVFS_BULK:
  1142. ret = proc_bulk(ps, (void *)arg);
  1143. if (ret >= 0)
  1144. inode->i_mtime = CURRENT_TIME;
  1145. break;
  1147. case USBDEVFS_RESETEP:
  1148. ret = proc_resetep(ps, (void *)arg);
  1149. if (ret >= 0)
  1150. inode->i_mtime = CURRENT_TIME;
  1151. break;
  1153. case USBDEVFS_RESET:
  1154. ret = proc_resetdevice(ps);
  1155. break;
  1157. case USBDEVFS_CLEAR_HALT:
  1158. ret = proc_clearhalt(ps, (void *)arg);
  1159. if (ret >= 0)
  1160. inode->i_mtime = CURRENT_TIME;
  1161. break;
  1163. case USBDEVFS_GETDRIVER:
  1164. ret = proc_getdriver(ps, (void *)arg);
  1165. break;
  1167. case USBDEVFS_CONNECTINFO:
  1168. ret = proc_connectinfo(ps, (void *)arg);
  1169. break;
  1171. case USBDEVFS_SETINTERFACE:
  1172. ret = proc_setintf(ps, (void *)arg);
  1173. break;
  1175. case USBDEVFS_SETCONFIGURATION:
  1176. ret = proc_setconfig(ps, (void *)arg);
  1177. break;
  1179. case USBDEVFS_SUBMITURB:
  1180. ret = proc_submiturb(ps, (void *)arg);
  1181. if (ret >= 0)
  1182. inode->i_mtime = CURRENT_TIME;
  1183. break;
  1185. case USBDEVFS_DISCARDURB:
  1186. ret = proc_unlinkurb(ps, (void *)arg);
  1187. break;
  1189. case USBDEVFS_REAPURB:
  1190. ret = proc_reapurb(ps, (void *)arg);
  1191. break;
  1193. case USBDEVFS_REAPURBNDELAY:
  1194. ret = proc_reapurbnonblock(ps, (void *)arg);
  1195. break;
  1197. case USBDEVFS_DISCSIGNAL:
  1198. ret = proc_disconnectsignal(ps, (void *)arg);
  1199. break;
  1201. case USBDEVFS_CLAIMINTERFACE:
  1202. ret = proc_claiminterface(ps, (void *)arg);
  1203. break;
  1205. case USBDEVFS_RELEASEINTERFACE:
  1206. ret = proc_releaseinterface(ps, (void *)arg);
  1207. break;
  1209. case USBDEVFS_IOCTL:
  1210. ret = proc_ioctl(ps, (void *) arg);
  1211. break;
  1212. }
  1213. up_read(&ps->devsem);
  1214. if (ret >= 0)
  1215. inode->i_atime = CURRENT_TIME;
  1216. return ret;
  1217. }
  1219. /* No kernel lock - fine */
  1220. static unsigned int usbdev_poll(struct file *file, struct poll_table_struct *wait)
  1221. {
  1222. struct dev_state *ps = (struct dev_state *)file->private_data;
  1223.         unsigned int mask = 0;
  1225. poll_wait(file, &ps->wait, wait);
  1226. if (file->f_mode & FMODE_WRITE && !list_empty(&ps->async_completed))
  1227. mask |= POLLOUT | POLLWRNORM;
  1228. if (!ps->dev)
  1229. mask |= POLLERR | POLLHUP;
  1230. return mask;
  1231. }
  1233. struct file_operations usbdevfs_device_file_operations = {
  1234. llseek: usbdev_lseek,
  1235. read: usbdev_read,
  1236. poll: usbdev_poll,
  1237. ioctl: usbdev_ioctl,
  1238. open: usbdev_open,
  1239. release: usbdev_release,
  1240. };