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

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

嵌入式Linux

开发平台：

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.         urb_t 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. extern 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(iso_packet_descriptor_t);
  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. extern __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. extern __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. extern __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. extern __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(purb_t 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 claiming
  290.  */
  292. static void *driver_probe(struct usb_device *dev, unsigned int intf,
  293.   const struct usb_device_id *id)
  294. {
  295. return NULL;
  296. }
  298. static void driver_disconnect(struct usb_device *dev, void *context)
  299. {
  300. struct dev_state *ps = (struct dev_state *)context;
  302. ps->ifclaimed = 0;
  303. }
  305. struct usb_driver usbdevfs_driver = {
  306. name: "usbdevfs",
  307. probe: driver_probe,
  308. disconnect: driver_disconnect,
  309. };
  311. static int claimintf(struct dev_state *ps, unsigned int intf)
  312. {
  313. struct usb_device *dev = ps->dev;
  314. struct usb_interface *iface;
  315. int err;
  317. if (intf >= 8*sizeof(ps->ifclaimed) || !dev || intf >= dev->actconfig->bNumInterfaces)
  318. return -EINVAL;
  319. /* already claimed */
  320. if (test_bit(intf, &ps->ifclaimed))
  321. return 0;
  322. iface = &dev->actconfig->interface[intf];
  323. err = -EBUSY;
  324. lock_kernel();
  325. if (!usb_interface_claimed(iface)) {
  326. usb_driver_claim_interface(&usbdevfs_driver, iface, ps);
  327. set_bit(intf, &ps->ifclaimed);
  328. err = 0;
  329. }
  330. unlock_kernel();
  331. return err;
  332. }
  334. static int releaseintf(struct dev_state *ps, unsigned int intf)
  335. {
  336. struct usb_device *dev;
  337. struct usb_interface *iface;
  338. int err;
  340. if (intf >= 8*sizeof(ps->ifclaimed))
  341. return -EINVAL;
  342. err = -EINVAL;
  343. lock_kernel();
  344. dev = ps->dev;
  345. if (dev && test_and_clear_bit(intf, &ps->ifclaimed)) {
  346. iface = &dev->actconfig->interface[intf];
  347. usb_driver_release_interface(&usbdevfs_driver, iface);
  348. err = 0;
  349. }
  350. unlock_kernel();
  351. return err;
  352. }
  354. static int checkintf(struct dev_state *ps, unsigned int intf)
  355. {
  356. if (intf >= 8*sizeof(ps->ifclaimed))
  357. return -EINVAL;
  358. if (test_bit(intf, &ps->ifclaimed))
  359. return 0;
  360. /* if not yet claimed, claim it for the driver */
  361. printk(KERN_WARNING "usbdevfs: process %d (%s) did not claim interface %u before usen",
  362.        current->pid, current->comm, intf);
  363. return claimintf(ps, intf);
  364. }
  366. static int findintfep(struct usb_device *dev, unsigned int ep)
  367. {
  368. unsigned int i, j, e;
  369.         struct usb_interface *iface;
  370. struct usb_interface_descriptor *alts;
  371. struct usb_endpoint_descriptor *endpt;
  373. if (ep & ~(USB_DIR_IN|0xf))
  374. return -EINVAL;
  375. for (i = 0; i < dev->actconfig->bNumInterfaces; i++) {
  376. iface = &dev->actconfig->interface[i];
  377. for (j = 0; j < iface->num_altsetting; j++) {
  378.                         alts = &iface->altsetting[j];
  379. for (e = 0; e < alts->bNumEndpoints; e++) {
  380. endpt = &alts->endpoint[e];
  381. if (endpt->bEndpointAddress == ep)
  382. return i;
  383. }
  384. }
  385. }
  386. return -ENOENT; 
  387. }
  389. static int findintfif(struct usb_device *dev, unsigned int ifn)
  390. {
  391. unsigned int i, j;
  392.         struct usb_interface *iface;
  393. struct usb_interface_descriptor *alts;
  395. if (ifn & ~0xff)
  396. return -EINVAL;
  397. for (i = 0; i < dev->actconfig->bNumInterfaces; i++) {
  398. iface = &dev->actconfig->interface[i];
  399. for (j = 0; j < iface->num_altsetting; j++) {
  400.                         alts = &iface->altsetting[j];
  401. if (alts->bInterfaceNumber == ifn)
  402. return i;
  403. }
  404. }
  405. return -ENOENT; 
  406. }
  408. extern struct list_head usb_driver_list;
  410. #if 0
  411. static int finddriver(struct usb_driver **driver, char *name)
  412. {
  413. struct list_head *tmp;
  415. tmp = usb_driver_list.next;
  416. while (tmp != &usb_driver_list) {
  417. struct usb_driver *d = list_entry(tmp, struct usb_driver,
  418. driver_list);
  420. if (!strcmp(d->name, name)) {
  421. *driver = d;
  422. return 0;
  423. }
  425. tmp = tmp->next;
  426. }
  428. return -EINVAL;
  429. }
  430. #endif
  432. static int check_ctrlrecip(struct dev_state *ps, unsigned int requesttype, unsigned int index)
  433. {
  434. int ret;
  436. if (USB_TYPE_VENDOR == (USB_TYPE_MASK & requesttype))
  437. return 0;
  439. switch (requesttype & USB_RECIP_MASK) {
  440. case USB_RECIP_ENDPOINT:
  441. if ((ret = findintfep(ps->dev, index & 0xff)) < 0)
  442. return ret;
  443. if ((ret = checkintf(ps, ret)))
  444. return ret;
  445. break;
  447. case USB_RECIP_INTERFACE:
  448. if ((ret = findintfif(ps->dev, index & 0xff)) < 0)
  449. return ret;
  450. if ((ret = checkintf(ps, ret)))
  451. return ret;
  452. break;
  453. }
  454. return 0;
  455. }
  457. /*
  458.  * file operations
  459.  */
  460. static int usbdev_open(struct inode *inode, struct file *file)
  461. {
  462. struct usb_device *dev;
  463. struct dev_state *ps;
  464. int ret;
  466. /* 
  467.  * no locking necessary here, as both sys_open (actually filp_open)
  468.  * and the hub thread have the kernel lock
  469.  * (still acquire the kernel lock for safety)
  470.  */
  471. lock_kernel();
  472. ret = -ENOENT;
  473. if (ITYPE(inode->i_ino) != IDEVICE)
  474. goto out;
  475. dev = inode->u.usbdev_i.p.dev;
  476. if (!dev)
  477. goto out;
  478. ret = -ENOMEM;
  479. if (!(ps = kmalloc(sizeof(struct dev_state), GFP_KERNEL)))
  480. goto out;
  481. ret = 0;
  482. ps->dev = dev;
  483. ps->file = file;
  484. spin_lock_init(&ps->lock);
  485. INIT_LIST_HEAD(&ps->async_pending);
  486. INIT_LIST_HEAD(&ps->async_completed);
  487. init_waitqueue_head(&ps->wait);
  488. init_rwsem(&ps->devsem);
  489. ps->discsignr = 0;
  490. ps->disctask = current;
  491. ps->disccontext = NULL;
  492. ps->ifclaimed = 0;
  493. wmb();
  494. list_add_tail(&ps->list, &dev->filelist);
  495. file->private_data = ps;
  496.  out:
  497. unlock_kernel();
  498.         return ret;
  499. }
  501. static int usbdev_release(struct inode *inode, struct file *file)
  502. {
  503. struct dev_state *ps = (struct dev_state *)file->private_data;
  504. unsigned int i;
  506. lock_kernel();
  507. list_del(&ps->list);
  508. INIT_LIST_HEAD(&ps->list);
  509. if (ps->dev) {
  510. for (i = 0; ps->ifclaimed && i < 8*sizeof(ps->ifclaimed); i++)
  511. if (test_bit(i, &ps->ifclaimed))
  512. releaseintf(ps, i);
  513. }
  514. unlock_kernel();
  515. destroy_all_async(ps);
  516. kfree(ps);
  517.         return 0;
  518. }
  520. static int proc_control(struct dev_state *ps, void *arg)
  521. {
  522. struct usb_device *dev = ps->dev;
  523. struct usbdevfs_ctrltransfer ctrl;
  524. unsigned int tmo;
  525. unsigned char *tbuf;
  526. int i, ret;
  528. if (copy_from_user(&ctrl, (void *)arg, sizeof(ctrl)))
  529. return -EFAULT;
  530. if ((ret = check_ctrlrecip(ps, ctrl.requesttype, ctrl.index)))
  531. return ret;
  532. if (ctrl.length > PAGE_SIZE)
  533. return -EINVAL;
  534. if (!(tbuf = (unsigned char *)__get_free_page(GFP_KERNEL)))
  535. return -ENOMEM;
  536. tmo = (ctrl.timeout * HZ + 999) / 1000;
  537. if (ctrl.requesttype & 0x80) {
  538. if (ctrl.length && !access_ok(VERIFY_WRITE, ctrl.data, ctrl.length)) {
  539. free_page((unsigned long)tbuf);
  540. return -EINVAL;
  541. }
  542. i = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), ctrl.request, ctrl.requesttype,
  543.        ctrl.value, ctrl.index, tbuf, ctrl.length, tmo);
  544. if ((i > 0) && ctrl.length) {
  545. if (copy_to_user(ctrl.data, tbuf, ctrl.length)) {
  546. free_page((unsigned long)tbuf);
  547. return -EFAULT;
  548. }
  549. }
  550. } else {
  551. if (ctrl.length) {
  552. if (copy_from_user(tbuf, ctrl.data, ctrl.length)) {
  553. free_page((unsigned long)tbuf);
  554. return -EFAULT;
  555. }
  556. }
  557. i = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), ctrl.request, ctrl.requesttype,
  558.        ctrl.value, ctrl.index, tbuf, ctrl.length, tmo);
  559. }
  560. free_page((unsigned long)tbuf);
  561. if (i<0) {
  562. printk(KERN_DEBUG "usbdevfs: USBDEVFS_CONTROL failed dev %d rqt %u rq %u len %u ret %dn", 
  563.        dev->devnum, ctrl.requesttype, ctrl.request, ctrl.length, i);
  564. }
  565. return i;
  566. }
  568. static int proc_bulk(struct dev_state *ps, void *arg)
  569. {
  570. struct usb_device *dev = ps->dev;
  571. struct usbdevfs_bulktransfer bulk;
  572. unsigned int tmo, len1, pipe;
  573. int len2;
  574. unsigned char *tbuf;
  575. int i, ret;
  577. if (copy_from_user(&bulk, (void *)arg, sizeof(bulk)))
  578. return -EFAULT;
  579. if ((ret = findintfep(ps->dev, bulk.ep)) < 0)
  580. return ret;
  581. if ((ret = checkintf(ps, ret)))
  582. return ret;
  583. if (bulk.ep & USB_DIR_IN)
  584. pipe = usb_rcvbulkpipe(dev, bulk.ep & 0x7f);
  585. else
  586. pipe = usb_sndbulkpipe(dev, bulk.ep & 0x7f);
  587. if (!usb_maxpacket(dev, pipe, !(bulk.ep & USB_DIR_IN)))
  588. return -EINVAL;
  589. len1 = bulk.len;
  590. if (len1 > PAGE_SIZE)
  591. return -EINVAL;
  592. if (!(tbuf = (unsigned char *)__get_free_page(GFP_KERNEL)))
  593. return -ENOMEM;
  594. tmo = (bulk.timeout * HZ + 999) / 1000;
  595. if (bulk.ep & 0x80) {
  596. if (len1 && !access_ok(VERIFY_WRITE, bulk.data, len1)) {
  597. free_page((unsigned long)tbuf);
  598. return -EINVAL;
  599. }
  600. i = usb_bulk_msg(dev, pipe, tbuf, len1, &len2, tmo);
  601. if (!i && len2) {
  602. if (copy_to_user(bulk.data, tbuf, len2)) {
  603. free_page((unsigned long)tbuf);
  604. return -EFAULT;
  605. }
  606. }
  607. } else {
  608. if (len1) {
  609. if (copy_from_user(tbuf, bulk.data, len1)) {
  610. free_page((unsigned long)tbuf);
  611. return -EFAULT;
  612. }
  613. }
  614. i = usb_bulk_msg(dev, pipe, tbuf, len1, &len2, tmo);
  615. }
  616. free_page((unsigned long)tbuf);
  617. if (i < 0) {
  618. printk(KERN_WARNING "usbdevfs: USBDEVFS_BULK failed dev %d ep 0x%x len %u ret %dn", 
  619.        dev->devnum, bulk.ep, bulk.len, i);
  620. return i;
  621. }
  622. return len2;
  623. }
  625. static int proc_resetep(struct dev_state *ps, void *arg)
  626. {
  627. unsigned int ep;
  628. int ret;
  630. if (get_user(ep, (unsigned int *)arg))
  631. return -EFAULT;
  632. if ((ret = findintfep(ps->dev, ep)) < 0)
  633. return ret;
  634. if ((ret = checkintf(ps, ret)))
  635. return ret;
  636. usb_settoggle(ps->dev, ep & 0xf, !(ep & USB_DIR_IN), 0);
  637. return 0;
  638. }
  640. static int proc_clearhalt(struct dev_state *ps, void *arg)
  641. {
  642. unsigned int ep;
  643. int pipe;
  644. int ret;
  646. if (get_user(ep, (unsigned int *)arg))
  647. return -EFAULT;
  648. if ((ret = findintfep(ps->dev, ep)) < 0)
  649. return ret;
  650. if ((ret = checkintf(ps, ret)))
  651. return ret;
  652. if (ep & USB_DIR_IN)
  653.                 pipe = usb_rcvbulkpipe(ps->dev, ep & 0x7f);
  654.         else
  655.                 pipe = usb_sndbulkpipe(ps->dev, ep & 0x7f);
  657. return usb_clear_halt(ps->dev, pipe);
  658. }
  661. static int proc_getdriver(struct dev_state *ps, void *arg)
  662. {
  663. struct usbdevfs_getdriver gd;
  664. struct usb_interface *interface;
  665. int ret;
  667. if (copy_from_user(&gd, arg, sizeof(gd)))
  668. return -EFAULT;
  669. if ((ret = findintfif(ps->dev, gd.interface)) < 0)
  670. return ret;
  671. interface = usb_ifnum_to_if(ps->dev, gd.interface);
  672. if (!interface)
  673. return -EINVAL;
  674. if (!interface->driver)
  675. return -ENODATA;
  676. strcpy(gd.driver, interface->driver->name);
  677. if (copy_to_user(arg, &gd, sizeof(gd)))
  678. return -EFAULT;
  679. return 0;
  680. }
  682. static int proc_connectinfo(struct dev_state *ps, void *arg)
  683. {
  684. struct usbdevfs_connectinfo ci;
  686. ci.devnum = ps->dev->devnum;
  687. ci.slow = ps->dev->speed == USB_SPEED_LOW;
  688. if (copy_to_user(arg, &ci, sizeof(ci)))
  689. return -EFAULT;
  690. return 0;
  691. }
  693. static int proc_resetdevice(struct dev_state *ps)
  694. {
  695. int i, ret;
  697. ret = usb_reset_device(ps->dev);
  698. if (ret < 0)
  699. return ret;
  701. for (i = 0; i < ps->dev->actconfig->bNumInterfaces; i++) {
  702. struct usb_interface *intf = &ps->dev->actconfig->interface[i];
  704. /* Don't simulate interfaces we've claimed */
  705. if (test_bit(i, &ps->ifclaimed))
  706. continue;
  708. if (intf->driver) {
  709. const struct usb_device_id *id;
  710. down(&intf->driver->serialize);
  711. intf->driver->disconnect(ps->dev, intf->private_data);
  712. id = usb_match_id(ps->dev,intf,intf->driver->id_table);
  713. intf->driver->probe(ps->dev, i, id);
  714. up(&intf->driver->serialize);
  715. }
  716. }
  718. return 0;
  719. }
  721. static int proc_setintf(struct dev_state *ps, void *arg)
  722. {
  723. struct usbdevfs_setinterface setintf;
  724. struct usb_interface *interface;
  725. int ret;
  727. if (copy_from_user(&setintf, arg, sizeof(setintf)))
  728. return -EFAULT;
  729. if ((ret = findintfif(ps->dev, setintf.interface)) < 0)
  730. return ret;
  731. interface = usb_ifnum_to_if(ps->dev, setintf.interface);
  732. if (!interface)
  733. return -EINVAL;
  734. if (interface->driver) {
  735. if ((ret = checkintf(ps, ret)))
  736. return ret;
  737. }
  738. if (usb_set_interface(ps->dev, setintf.interface, setintf.altsetting))
  739. return -EINVAL;
  740. return 0;
  741. }
  743. static int proc_setconfig(struct dev_state *ps, void *arg)
  744. {
  745. unsigned int u;
  747. if (get_user(u, (unsigned int *)arg))
  748. return -EFAULT;
  749. if (usb_set_configuration(ps->dev, u) < 0)
  750. return -EINVAL;
  751. return 0;
  752. }
  754. static int proc_submiturb(struct dev_state *ps, void *arg)
  755. {
  756. struct usbdevfs_urb uurb;
  757. struct usbdevfs_iso_packet_desc *isopkt = NULL;
  758. struct usb_endpoint_descriptor *ep_desc;
  759. struct async *as;
  760. devrequest *dr = NULL;
  761. unsigned int u, totlen, isofrmlen;
  762. int ret;
  764. if (copy_from_user(&uurb, arg, sizeof(uurb)))
  765. return -EFAULT;
  766. if (uurb.flags & ~(USBDEVFS_URB_ISO_ASAP|USBDEVFS_URB_DISABLE_SPD|USBDEVFS_URB_QUEUE_BULK|
  767.    USB_NO_FSBR|USB_ZERO_PACKET))
  768. return -EINVAL;
  769. if (!uurb.buffer)
  770. return -EINVAL;
  771. if (uurb.signr != 0 && (uurb.signr < SIGRTMIN || uurb.signr > SIGRTMAX))
  772. return -EINVAL;
  773. if (!(uurb.type == USBDEVFS_URB_TYPE_CONTROL && (uurb.endpoint & ~USB_ENDPOINT_DIR_MASK) == 0)) {
  774. if ((ret = findintfep(ps->dev, uurb.endpoint)) < 0)
  775. return ret;
  776. if ((ret = checkintf(ps, ret)))
  777. return ret;
  778. }
  779. switch(uurb.type) {
  780. case USBDEVFS_URB_TYPE_CONTROL:
  781. if ((uurb.endpoint & ~USB_ENDPOINT_DIR_MASK) != 0) {
  782. if (!(ep_desc = usb_epnum_to_ep_desc(ps->dev, uurb.endpoint)))
  783. return -ENOENT;
  784. if ((ep_desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) != USB_ENDPOINT_XFER_CONTROL)
  785. return -EINVAL;
  786. }
  787. /* min 8 byte setup packet, max arbitrary */
  788. if (uurb.buffer_length < 8 || uurb.buffer_length > PAGE_SIZE)
  789. return -EINVAL;
  790. if (!(dr = kmalloc(sizeof(devrequest), GFP_KERNEL)))
  791. return -ENOMEM;
  792. if (copy_from_user(dr, (unsigned char*)uurb.buffer, 8)) {
  793. kfree(dr);
  794. return -EFAULT;
  795. }
  796. if (uurb.buffer_length < (le16_to_cpup(&dr->length) + 8)) {
  797. kfree(dr);
  798. return -EINVAL;
  799. }
  800. if ((ret = check_ctrlrecip(ps, dr->requesttype, le16_to_cpup(&dr->index)))) {
  801. kfree(dr);
  802. return ret;
  803. }
  804. uurb.endpoint = (uurb.endpoint & ~USB_ENDPOINT_DIR_MASK) | (dr->requesttype & USB_ENDPOINT_DIR_MASK);
  805. uurb.number_of_packets = 0;
  806. uurb.buffer_length = le16_to_cpup(&dr->length);
  807. uurb.buffer += 8;
  808. if (!access_ok((uurb.endpoint & USB_DIR_IN) ?  VERIFY_WRITE : VERIFY_READ, uurb.buffer, uurb.buffer_length)) {
  809. kfree(dr);
  810. return -EFAULT;
  811. }
  812. break;
  814. case USBDEVFS_URB_TYPE_BULK:
  815. uurb.number_of_packets = 0;
  816. if (uurb.buffer_length > 16384)
  817. return -EINVAL;
  818. if (!access_ok((uurb.endpoint & USB_DIR_IN) ? VERIFY_WRITE : VERIFY_READ, uurb.buffer, uurb.buffer_length))
  819. return -EFAULT;
  820. break;
  822. case USBDEVFS_URB_TYPE_ISO:
  823. /* arbitrary limit */
  824. if (uurb.number_of_packets < 1 || uurb.number_of_packets > 128)
  825. return -EINVAL;
  826. isofrmlen = sizeof(struct usbdevfs_iso_packet_desc) * uurb.number_of_packets;
  827. if (!(isopkt = kmalloc(isofrmlen, GFP_KERNEL)))
  828. return -ENOMEM;
  829. if (copy_from_user(isopkt, &((struct usbdevfs_urb *)arg)->iso_frame_desc, isofrmlen)) {
  830. kfree(isopkt);
  831. return -EFAULT;
  832. }
  833. for (totlen = u = 0; u < uurb.number_of_packets; u++) {
  834. if (isopkt[u].length > 1023) {
  835. kfree(isopkt);
  836. return -EINVAL;
  837. }
  838. totlen += isopkt[u].length;
  839. }
  840. if (totlen > 32768) {
  841. kfree(isopkt);
  842. return -EINVAL;
  843. }
  844. uurb.buffer_length = totlen;
  845. break;
  847. case USBDEVFS_URB_TYPE_INTERRUPT:
  848. uurb.number_of_packets = 0;
  849. if (uurb.buffer_length > 16384)
  850. return -EINVAL;
  851. if (!access_ok((uurb.endpoint & USB_DIR_IN) ? VERIFY_WRITE : VERIFY_READ, uurb.buffer, uurb.buffer_length))
  852. return -EFAULT;   
  853. break;
  855. default:
  856. return -EINVAL;
  857. }
  858. if (!(as = alloc_async(uurb.number_of_packets))) {
  859. if (isopkt)
  860. kfree(isopkt);
  861. if (dr)
  862. kfree(dr);
  863. return -ENOMEM;
  864. }
  865. if (!(as->urb.transfer_buffer = kmalloc(uurb.buffer_length, GFP_KERNEL))) {
  866. if (isopkt)
  867. kfree(isopkt);
  868. if (dr)
  869. kfree(dr);
  870. free_async(as);
  871. return -ENOMEM;
  872. }
  873.         as->urb.next = NULL;
  874.         as->urb.dev = ps->dev;
  875.         as->urb.pipe = (uurb.type << 30) | __create_pipe(ps->dev, uurb.endpoint & 0xf) | (uurb.endpoint & USB_DIR_IN);
  876.         as->urb.transfer_flags = uurb.flags;
  877. as->urb.transfer_buffer_length = uurb.buffer_length;
  878. as->urb.setup_packet = (unsigned char*)dr;
  879. as->urb.start_frame = uurb.start_frame;
  880. as->urb.number_of_packets = uurb.number_of_packets;
  881.         as->urb.context = as;
  882.         as->urb.complete = async_completed;
  883. for (totlen = u = 0; u < uurb.number_of_packets; u++) {
  884. as->urb.iso_frame_desc[u].offset = totlen;
  885. as->urb.iso_frame_desc[u].length = isopkt[u].length;
  886. totlen += isopkt[u].length;
  887. }
  888. if (isopkt)
  889. kfree(isopkt);
  890. as->ps = ps;
  891.         as->userurb = arg;
  892. if (uurb.endpoint & USB_DIR_IN)
  893. as->userbuffer = uurb.buffer;
  894. else
  895. as->userbuffer = NULL;
  896. as->signr = uurb.signr;
  897. as->task = current;
  898. if (!(uurb.endpoint & USB_DIR_IN)) {
  899. if (copy_from_user(as->urb.transfer_buffer, uurb.buffer, as->urb.transfer_buffer_length)) {
  900. free_async(as);
  901. return -EFAULT;
  902. }
  903. }
  904.         async_newpending(as);
  905.         if ((ret = usb_submit_urb(&as->urb))) {
  906. printk(KERN_DEBUG "usbdevfs: usb_submit_urb returned %dn", ret);
  907.                 async_removepending(as);
  908.                 free_async(as);
  909.                 return ret;
  910.         }
  911.         return 0;
  912. }
  914. static int proc_unlinkurb(struct dev_state *ps, void *arg)
  915. {
  916. struct async *as;
  918. as = async_getpending(ps, arg);
  919. if (!as)
  920. return -EINVAL;
  921. usb_unlink_urb(&as->urb);
  922. return 0;
  923. }
  925. static int processcompl(struct async *as)
  926. {
  927. unsigned int i;
  929. if (as->userbuffer)
  930. if (copy_to_user(as->userbuffer, as->urb.transfer_buffer, as->urb.transfer_buffer_length))
  931. return -EFAULT;
  932. if (put_user(as->urb.status,
  933.      &((struct usbdevfs_urb *)as->userurb)->status))
  934. return -EFAULT;
  935. if (put_user(as->urb.actual_length,
  936.      &((struct usbdevfs_urb *)as->userurb)->actual_length))
  937. return -EFAULT;
  938. if (put_user(as->urb.error_count,
  939.      &((struct usbdevfs_urb *)as->userurb)->error_count))
  940. return -EFAULT;
  942. if (!(usb_pipeisoc(as->urb.pipe)))
  943. return 0;
  944. for (i = 0; i < as->urb.number_of_packets; i++) {
  945. if (put_user(as->urb.iso_frame_desc[i].actual_length, 
  946.      &((struct usbdevfs_urb *)as->userurb)->iso_frame_desc[i].actual_length))
  947. return -EFAULT;
  948. if (put_user(as->urb.iso_frame_desc[i].status, 
  949.      &((struct usbdevfs_urb *)as->userurb)->iso_frame_desc[i].status))
  950. return -EFAULT;
  951. }
  952. return 0;
  953. }
  955. static int proc_reapurb(struct dev_state *ps, void *arg)
  956. {
  957.         DECLARE_WAITQUEUE(wait, current);
  958. struct async *as = NULL;
  959. void *addr;
  960. int ret;
  962. add_wait_queue(&ps->wait, &wait);
  963. while (ps->dev) {
  964. __set_current_state(TASK_INTERRUPTIBLE);
  965. if ((as = async_getcompleted(ps)))
  966. break;
  967. if (signal_pending(current))
  968. break;
  969. up_read(&ps->devsem);
  970. schedule();
  971. down_read(&ps->devsem);
  972. }
  973. remove_wait_queue(&ps->wait, &wait);
  974. set_current_state(TASK_RUNNING);
  975. if (as) {
  976. ret = processcompl(as);
  977. addr = as->userurb;
  978. free_async(as);
  979. if (ret)
  980. return ret;
  981. if (put_user(addr, (void **)arg))
  982. return -EFAULT;
  983. return 0;
  984. }
  985. if (signal_pending(current))
  986. return -EINTR;
  987. return -EIO;
  988. }
  990. static int proc_reapurbnonblock(struct dev_state *ps, void *arg)
  991. {
  992. struct async *as;
  993. void *addr;
  994. int ret;
  996. if (!(as = async_getcompleted(ps)))
  997. return -EAGAIN;
  998. ret = processcompl(as);
  999. addr = as->userurb;
  1000. free_async(as);
  1001. if (ret)
  1002. return ret;
  1003. if (put_user(addr, (void **)arg))
  1004. return -EFAULT;
  1005. return 0;
  1006. }
  1008. static int proc_disconnectsignal(struct dev_state *ps, void *arg)
  1009. {
  1010. struct usbdevfs_disconnectsignal ds;
  1012. if (copy_from_user(&ds, arg, sizeof(ds)))
  1013. return -EFAULT;
  1014. if (ds.signr != 0 && (ds.signr < SIGRTMIN || ds.signr > SIGRTMAX))
  1015. return -EINVAL;
  1016. ps->discsignr = ds.signr;
  1017. ps->disccontext = ds.context;
  1018. return 0;
  1019. }
  1021. static int proc_claiminterface(struct dev_state *ps, void *arg)
  1022. {
  1023. unsigned int intf;
  1024. int ret;
  1026. if (get_user(intf, (unsigned int *)arg))
  1027. return -EFAULT;
  1028. if ((ret = findintfif(ps->dev, intf)) < 0)
  1029. return ret;
  1030. return claimintf(ps, ret);
  1031. }
  1033. static int proc_releaseinterface(struct dev_state *ps, void *arg)
  1034. {
  1035. unsigned int intf;
  1036. int ret;
  1038. if (get_user(intf, (unsigned int *)arg))
  1039. return -EFAULT;
  1040. if ((ret = findintfif(ps->dev, intf)) < 0)
  1041. return ret;
  1042. return releaseintf(ps, intf);
  1043. }
  1045. static int proc_ioctl (struct dev_state *ps, void *arg)
  1046. {
  1047. struct usbdevfs_ioctl ctrl;
  1048. int size;
  1049. void *buf = 0;
  1050. int retval = 0;
  1052. /* get input parameters and alloc buffer */
  1053. if (copy_from_user(&ctrl, (void *) arg, sizeof (ctrl)))
  1054. return -EFAULT;
  1055. if ((size = _IOC_SIZE (ctrl.ioctl_code)) > 0) {
  1056. if ((buf = kmalloc (size, GFP_KERNEL)) == 0)
  1057. return -ENOMEM;
  1058. if ((_IOC_DIR(ctrl.ioctl_code) & _IOC_WRITE)) {
  1059. if (copy_from_user (buf, ctrl.data, size)) {
  1060. kfree (buf);
  1061. return -EFAULT;
  1062. }
  1063. } else {
  1064. memset (buf, 0, size);
  1065. }
  1066. }
  1068. /* ioctl to device */
  1069. if (ctrl.ifno < 0) {
  1070. switch (ctrl.ioctl_code) {
  1071. /* access/release token for issuing control messages
  1072.  * ask a particular driver to bind/unbind, ... etc
  1073.  */
  1074. }
  1075. retval = -ENOSYS;
  1077. /* ioctl to the driver which has claimed a given interface */
  1078. } else {
  1079. struct usb_interface *ifp = 0;
  1080. if (!ps->dev)
  1081. retval = -ENODEV;
  1082. else if (ctrl.ifno >= ps->dev->actconfig->bNumInterfaces)
  1083. retval = -EINVAL;
  1084. else {
  1085. if (!(ifp = usb_ifnum_to_if (ps->dev, ctrl.ifno)))
  1086. retval = -EINVAL;
  1087. else if (ifp->driver == 0 || ifp->driver->ioctl == 0)
  1088. retval = -ENOSYS;
  1089. }
  1090. if (retval == 0)
  1091. /* ifno might usefully be passed ... */
  1092. retval = ifp->driver->ioctl (ps->dev, ctrl.ioctl_code, buf);
  1093. /* size = min_t(int, size, retval)? */
  1094. }
  1096. /* cleanup and return */
  1097. if (retval >= 0
  1098. && (_IOC_DIR (ctrl.ioctl_code) & _IOC_READ) != 0
  1099. && size > 0
  1100. && copy_to_user (ctrl.data, buf, size) != 0)
  1101. retval = -EFAULT;
  1102. if (buf != 0)
  1103. kfree (buf);
  1104. return retval;
  1105. }
  1107. static int usbdev_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
  1108. {
  1109. struct dev_state *ps = (struct dev_state *)file->private_data;
  1110. int ret = -ENOIOCTLCMD;
  1112. if (!(file->f_mode & FMODE_WRITE))
  1113. return -EPERM;
  1114. down_read(&ps->devsem);
  1115. if (!ps->dev) {
  1116. up_read(&ps->devsem);
  1117. return -ENODEV;
  1118. }
  1119. switch (cmd) {
  1120. case USBDEVFS_CONTROL:
  1121. ret = proc_control(ps, (void *)arg);
  1122. if (ret >= 0)
  1123. inode->i_mtime = CURRENT_TIME;
  1124. break;
  1126. case USBDEVFS_BULK:
  1127. ret = proc_bulk(ps, (void *)arg);
  1128. if (ret >= 0)
  1129. inode->i_mtime = CURRENT_TIME;
  1130. break;
  1132. case USBDEVFS_RESETEP:
  1133. ret = proc_resetep(ps, (void *)arg);
  1134. if (ret >= 0)
  1135. inode->i_mtime = CURRENT_TIME;
  1136. break;
  1138. case USBDEVFS_RESET:
  1139. ret = proc_resetdevice(ps);
  1140. break;
  1142. case USBDEVFS_CLEAR_HALT:
  1143. ret = proc_clearhalt(ps, (void *)arg);
  1144. if (ret >= 0)
  1145. inode->i_mtime = CURRENT_TIME;
  1146. break;
  1148. case USBDEVFS_GETDRIVER:
  1149. ret = proc_getdriver(ps, (void *)arg);
  1150. break;
  1152. case USBDEVFS_CONNECTINFO:
  1153. ret = proc_connectinfo(ps, (void *)arg);
  1154. break;
  1156. case USBDEVFS_SETINTERFACE:
  1157. ret = proc_setintf(ps, (void *)arg);
  1158. break;
  1160. case USBDEVFS_SETCONFIGURATION:
  1161. ret = proc_setconfig(ps, (void *)arg);
  1162. break;
  1164. case USBDEVFS_SUBMITURB:
  1165. ret = proc_submiturb(ps, (void *)arg);
  1166. if (ret >= 0)
  1167. inode->i_mtime = CURRENT_TIME;
  1168. break;
  1170. case USBDEVFS_DISCARDURB:
  1171. ret = proc_unlinkurb(ps, (void *)arg);
  1172. break;
  1174. case USBDEVFS_REAPURB:
  1175. ret = proc_reapurb(ps, (void *)arg);
  1176. break;
  1178. case USBDEVFS_REAPURBNDELAY:
  1179. ret = proc_reapurbnonblock(ps, (void *)arg);
  1180. break;
  1182. case USBDEVFS_DISCSIGNAL:
  1183. ret = proc_disconnectsignal(ps, (void *)arg);
  1184. break;
  1186. case USBDEVFS_CLAIMINTERFACE:
  1187. ret = proc_claiminterface(ps, (void *)arg);
  1188. break;
  1190. case USBDEVFS_RELEASEINTERFACE:
  1191. ret = proc_releaseinterface(ps, (void *)arg);
  1192. break;
  1194. case USBDEVFS_IOCTL:
  1195. ret = proc_ioctl(ps, (void *) arg);
  1196. break;
  1197. }
  1198. up_read(&ps->devsem);
  1199. if (ret >= 0)
  1200. inode->i_atime = CURRENT_TIME;
  1201. return ret;
  1202. }
  1204. /* No kernel lock - fine */
  1205. static unsigned int usbdev_poll(struct file *file, struct poll_table_struct *wait)
  1206. {
  1207. struct dev_state *ps = (struct dev_state *)file->private_data;
  1208.         unsigned int mask = 0;
  1210. poll_wait(file, &ps->wait, wait);
  1211. if (file->f_mode & FMODE_WRITE && !list_empty(&ps->async_completed))
  1212. mask |= POLLOUT | POLLWRNORM;
  1213. if (!ps->dev)
  1214. mask |= POLLERR | POLLHUP;
  1215. return mask;
  1216. }
  1218. struct file_operations usbdevfs_device_file_operations = {
  1219. llseek: usbdev_lseek,
  1220. read: usbdev_read,
  1221. poll: usbdev_poll,
  1222. ioctl: usbdev_ioctl,
  1223. open: usbdev_open,
  1224. release: usbdev_release,
  1225. };