drivers/usb/core/devio.c

   1 /*****************************************************************************/
   2
   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  */
  34
  35 /*****************************************************************************/
  36
  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/module.h>
  44 #include <linux/usb.h>
  45 #include <linux/usbdevice_fs.h>
  46 #include <asm/uaccess.h>
  47 #include <asm/byteorder.h>
  48 #include <linux/moduleparam.h>
  49
  50 #include "hcd.h"        /* for usbcore internals */
  51 #include "usb.h"
  52
  53 struct async {
  54         struct list_head asynclist;
  55         struct dev_state *ps;
  56         struct task_struct *task;
  57         unsigned int signr;
  58         unsigned int ifnum;
  59         void __user *userbuffer;
  60         void __user *userurb;
  61         struct urb *urb;
  62 };
  63
  64 static int usbfs_snoop = 0;
  65 module_param (usbfs_snoop, bool, S_IRUGO | S_IWUSR);
  66 MODULE_PARM_DESC (usbfs_snoop, "true to log all usbfs traffic");
  67
  68 #define snoop(dev, format, arg...)                              \
  69         do {                                                    \
  70                 if (usbfs_snoop)                                \
  71                         dev_info( dev , format , ## arg);       \
  72         } while (0)
  73
  74
  75 static inline int connected (struct usb_device *dev)
  76 {
  77         return dev->state != USB_STATE_NOTATTACHED;
  78 }
  79
  80 static loff_t usbdev_lseek(struct file *file, loff_t offset, int orig)
  81 {
  82         loff_t ret;
  83
  84         lock_kernel();
  85
  86         switch (orig) {
  87         case 0:
  88                 file->f_pos = offset;
  89                 ret = file->f_pos;
  90                 break;
  91         case 1:
  92                 file->f_pos += offset;
  93                 ret = file->f_pos;
  94                 break;
  95         case 2:
  96         default:
  97                 ret = -EINVAL;
  98         }
  99
 100         unlock_kernel();
 101         return ret;
 102 }
 103
 104 static ssize_t usbdev_read(struct file *file, char __user *buf, size_t nbytes, loff_t *ppos)
 105 {
 106         struct dev_state *ps = (struct dev_state *)file->private_data;
 107         struct usb_device *dev = ps->dev;
 108         ssize_t ret = 0;
 109         unsigned len;
 110         loff_t pos;
 111         int i;
 112
 113         pos = *ppos;
 114         down(&dev->serialize);
 115         if (!connected(dev)) {
 116                 ret = -ENODEV;
 117                 goto err;
 118         } else if (pos < 0) {
 119                 ret = -EINVAL;
 120                 goto err;
 121         }
 122
 123         if (pos < sizeof(struct usb_device_descriptor)) {
 124                 len = sizeof(struct usb_device_descriptor) - pos;
 125                 if (len > nbytes)
 126                         len = nbytes;
 127                 if (copy_to_user(buf, ((char *)&dev->descriptor) + pos, len)) {
 128                         ret = -EFAULT;
 129                         goto err;
 130                 }
 131
 132                 *ppos += len;
 133                 buf += len;
 134                 nbytes -= len;
 135                 ret += len;
 136         }
 137
 138         pos = sizeof(struct usb_device_descriptor);
 139         for (i = 0; nbytes && i < dev->descriptor.bNumConfigurations; i++) {
 140                 struct usb_config_descriptor *config =
 141                         (struct usb_config_descriptor *)dev->rawdescriptors[i];
 142                 unsigned int length = le16_to_cpu(config->wTotalLength);
 143
 144                 if (*ppos < pos + length) {
 145
 146                         /* The descriptor may claim to be longer than it
 147                          * really is.  Here is the actual allocated length. */
 148                         unsigned alloclen =
 149                                 dev->config[i].desc.wTotalLength;
 150
 151                         len = length - (*ppos - pos);
 152                         if (len > nbytes)
 153                                 len = nbytes;
 154
 155                         /* Simply don't write (skip over) unallocated parts */
 156                         if (alloclen > (*ppos - pos)) {
 157                                 alloclen -= (*ppos - pos);
 158                                 if (copy_to_user(buf,
 159                                     dev->rawdescriptors[i] + (*ppos - pos),
 160                                     min(len, alloclen))) {
 161                                         ret = -EFAULT;
 162                                         goto err;
 163                                 }
 164                         }
 165
 166                         *ppos += len;
 167                         buf += len;
 168                         nbytes -= len;
 169                         ret += len;
 170                 }
 171
 172                 pos += length;
 173         }
 174
 175 err:
 176         up(&dev->serialize);
 177         return ret;
 178 }
 179
 180 /*
 181  * async list handling
 182  */
 183
 184 static struct async *alloc_async(unsigned int numisoframes)
 185 {
 186         unsigned int assize = sizeof(struct async) + numisoframes * sizeof(struct usb_iso_packet_descriptor);
 187         struct async *as = kmalloc(assize, GFP_KERNEL);
 188         if (!as)
 189                 return NULL;
 190         memset(as, 0, assize);
 191         as->urb = usb_alloc_urb(numisoframes, GFP_KERNEL);
 192         if (!as->urb) {
 193                 kfree(as);
 194                 return NULL;
 195         }
 196         return as;
 197 }
 198
 199 static void free_async(struct async *as)
 200 {
 201         if (as->urb->transfer_buffer)
 202                 kfree(as->urb->transfer_buffer);
 203         if (as->urb->setup_packet)
 204                 kfree(as->urb->setup_packet);
 205         usb_free_urb(as->urb);
 206         kfree(as);
 207 }
 208
 209 static inline void async_newpending(struct async *as)
 210 {
 211         struct dev_state *ps = as->ps;
 212         unsigned long flags;
 213
 214         spin_lock_irqsave(&ps->lock, flags);
 215         list_add_tail(&as->asynclist, &ps->async_pending);
 216         spin_unlock_irqrestore(&ps->lock, flags);
 217 }
 218
 219 static inline void async_removepending(struct async *as)
 220 {
 221         struct dev_state *ps = as->ps;
 222         unsigned long flags;
 223
 224         spin_lock_irqsave(&ps->lock, flags);
 225         list_del_init(&as->asynclist);
 226         spin_unlock_irqrestore(&ps->lock, flags);
 227 }
 228
 229 static inline struct async *async_getcompleted(struct dev_state *ps)
 230 {
 231         unsigned long flags;
 232         struct async *as = NULL;
 233
 234         spin_lock_irqsave(&ps->lock, flags);
 235         if (!list_empty(&ps->async_completed)) {
 236                 as = list_entry(ps->async_completed.next, struct async, asynclist);
 237                 list_del_init(&as->asynclist);
 238         }
 239         spin_unlock_irqrestore(&ps->lock, flags);
 240         return as;
 241 }
 242
 243 static inline struct async *async_getpending(struct dev_state *ps, void __user *userurb)
 244 {
 245         unsigned long flags;
 246         struct async *as;
 247
 248         spin_lock_irqsave(&ps->lock, flags);
 249         list_for_each_entry(as, &ps->async_pending, asynclist)
 250                 if (as->userurb == userurb) {
 251                         list_del_init(&as->asynclist);
 252                         spin_unlock_irqrestore(&ps->lock, flags);
 253                         return as;
 254                 }
 255         spin_unlock_irqrestore(&ps->lock, flags);
 256         return NULL;
 257 }
 258
 259 static void async_completed(struct urb *urb, struct pt_regs *regs)
 260 {
 261         struct async *as = (struct async *)urb->context;
 262         struct dev_state *ps = as->ps;
 263         struct siginfo sinfo;
 264
 265         spin_lock(&ps->lock);
 266         list_move_tail(&as->asynclist, &ps->async_completed);
 267         spin_unlock(&ps->lock);
 268         if (as->signr) {
 269                 sinfo.si_signo = as->signr;
 270                 sinfo.si_errno = as->urb->status;
 271                 sinfo.si_code = SI_ASYNCIO;
 272                 sinfo.si_addr = as->userurb;
 273                 send_sig_info(as->signr, &sinfo, as->task);
 274         }
 275         wake_up(&ps->wait);
 276 }
 277
 278 static void destroy_async (struct dev_state *ps, struct list_head *list)
 279 {
 280         struct async *as;
 281         unsigned long flags;
 282
 283         spin_lock_irqsave(&ps->lock, flags);
 284         while (!list_empty(list)) {
 285                 as = list_entry(list->next, struct async, asynclist);
 286                 list_del_init(&as->asynclist);
 287                 spin_unlock_irqrestore(&ps->lock, flags);
 288                 /* usb_unlink_urb calls the completion handler with status == -ENOENT */
 289                 usb_unlink_urb(as->urb);
 290                 spin_lock_irqsave(&ps->lock, flags);
 291         }
 292         spin_unlock_irqrestore(&ps->lock, flags);
 293         as = async_getcompleted(ps);
 294         while (as) {
 295                 free_async(as);
 296                 as = async_getcompleted(ps);
 297         }
 298 }
 299
 300 static void destroy_async_on_interface (struct dev_state *ps, unsigned int ifnum)
 301 {
 302         struct list_head *p, *q, hitlist;
 303         unsigned long flags;
 304
 305         INIT_LIST_HEAD(&hitlist);
 306         spin_lock_irqsave(&ps->lock, flags);
 307         list_for_each_safe(p, q, &ps->async_pending)
 308                 if (ifnum == list_entry(p, struct async, asynclist)->ifnum)
 309                         list_move_tail(p, &hitlist);
 310         spin_unlock_irqrestore(&ps->lock, flags);
 311         destroy_async(ps, &hitlist);
 312 }
 313
 314 static inline void destroy_all_async(struct dev_state *ps)
 315 {
 316                 destroy_async(ps, &ps->async_pending);
 317 }
 318
 319 /*
 320  * interface claims are made only at the request of user level code,
 321  * which can also release them (explicitly or by closing files).
 322  * they're also undone when devices disconnect.
 323  */
 324
 325 static int driver_probe (struct usb_interface *intf,
 326                          const struct usb_device_id *id)
 327 {
 328         return -ENODEV;
 329 }
 330
 331 static void driver_disconnect(struct usb_interface *intf)
 332 {
 333         struct dev_state *ps = usb_get_intfdata (intf);
 334         unsigned int ifnum = intf->altsetting->desc.bInterfaceNumber;
 335
 336         if (!ps)
 337                 return;
 338
 339         /* NOTE:  this relies on usbcore having canceled and completed
 340          * all pending I/O requests; 2.6 does that.
 341          */
 342
 343         if (likely(ifnum < 8*sizeof(ps->ifclaimed)))
 344                 clear_bit(ifnum, &ps->ifclaimed);
 345         else
 346                 warn("interface number %u out of range", ifnum);
 347
 348         usb_set_intfdata (intf, NULL);
 349
 350         /* force async requests to complete */
 351         destroy_async_on_interface(ps, ifnum);
 352 }
 353
 354 struct usb_driver usbdevfs_driver = {
 355         .owner =        THIS_MODULE,
 356         .name =         "usbfs",
 357         .probe =        driver_probe,
 358         .disconnect =   driver_disconnect,
 359 };
 360
 361 static int claimintf(struct dev_state *ps, unsigned int ifnum)
 362 {
 363         struct usb_device *dev = ps->dev;
 364         struct usb_interface *intf;
 365         int err;
 366
 367         if (ifnum >= 8*sizeof(ps->ifclaimed))
 368                 return -EINVAL;
 369         /* already claimed */
 370         if (test_bit(ifnum, &ps->ifclaimed))
 371                 return 0;
 372
 373         /* lock against other changes to driver bindings */
 374         down_write(&usb_bus_type.subsys.rwsem);
 375         intf = usb_ifnum_to_if(dev, ifnum);
 376         if (!intf)
 377                 err = -ENOENT;
 378         else
 379                 err = usb_driver_claim_interface(&usbdevfs_driver, intf, ps);
 380         up_write(&usb_bus_type.subsys.rwsem);
 381         if (err == 0)
 382                 set_bit(ifnum, &ps->ifclaimed);
 383         return err;
 384 }
 385
 386 static int releaseintf(struct dev_state *ps, unsigned int ifnum)
 387 {
 388         struct usb_device *dev;
 389         struct usb_interface *intf;
 390         int err;
 391
 392         err = -EINVAL;
 393         if (ifnum >= 8*sizeof(ps->ifclaimed))
 394                 return err;
 395         dev = ps->dev;
 396         /* lock against other changes to driver bindings */
 397         down_write(&usb_bus_type.subsys.rwsem);
 398         intf = usb_ifnum_to_if(dev, ifnum);
 399         if (!intf)
 400                 err = -ENOENT;
 401         else if (test_and_clear_bit(ifnum, &ps->ifclaimed)) {
 402                 usb_driver_release_interface(&usbdevfs_driver, intf);
 403                 err = 0;
 404         }
 405         up_write(&usb_bus_type.subsys.rwsem);
 406         return err;
 407 }
 408
 409 static int checkintf(struct dev_state *ps, unsigned int ifnum)
 410 {
 411         if (ifnum >= 8*sizeof(ps->ifclaimed))
 412                 return -EINVAL;
 413         if (test_bit(ifnum, &ps->ifclaimed))
 414                 return 0;
 415         /* if not yet claimed, claim it for the driver */
 416         dev_warn(&ps->dev->dev, "usbfs: process %d (%s) did not claim interface %u before use\n",
 417                current->pid, current->comm, ifnum);
 418         return claimintf(ps, ifnum);
 419 }
 420
 421 static int findintfep(struct usb_device *dev, unsigned int ep)
 422 {
 423         unsigned int i, j, e;
 424         struct usb_interface *intf;
 425         struct usb_host_interface *alts;
 426         struct usb_endpoint_descriptor *endpt;
 427
 428         if (ep & ~(USB_DIR_IN|0xf))
 429                 return -EINVAL;
 430         if (!dev->actconfig)
 431                 return -ESRCH;
 432         for (i = 0; i < dev->actconfig->desc.bNumInterfaces; i++) {
 433                 intf = dev->actconfig->interface[i];
 434                 for (j = 0; j < intf->num_altsetting; j++) {
 435                         alts = &intf->altsetting[j];
 436                         for (e = 0; e < alts->desc.bNumEndpoints; e++) {
 437                                 endpt = &alts->endpoint[e].desc;
 438                                 if (endpt->bEndpointAddress == ep)
 439                                         return alts->desc.bInterfaceNumber;
 440                         }
 441                 }
 442         }
 443         return -ENOENT;
 444 }
 445
 446 static int check_ctrlrecip(struct dev_state *ps, unsigned int requesttype, unsigned int index)
 447 {
 448         int ret = 0;
 449
 450         if (USB_TYPE_VENDOR == (USB_TYPE_MASK & requesttype))
 451                 return 0;
 452
 453         index &= 0xff;
 454         switch (requesttype & USB_RECIP_MASK) {
 455         case USB_RECIP_ENDPOINT:
 456                 if ((ret = findintfep(ps->dev, index)) >= 0)
 457                         ret = checkintf(ps, ret);
 458                 break;
 459
 460         case USB_RECIP_INTERFACE:
 461                 ret = checkintf(ps, index);
 462                 break;
 463         }
 464         return ret;
 465 }
 466
 467 /*
 468  * file operations
 469  */
 470 static int usbdev_open(struct inode *inode, struct file *file)
 471 {
 472         struct usb_device *dev;
 473         struct dev_state *ps;
 474         int ret;
 475
 476         /*
 477          * no locking necessary here, as chrdev_open has the kernel lock
 478          * (still acquire the kernel lock for safety)
 479          */
 480         ret = -ENOMEM;
 481         if (!(ps = kmalloc(sizeof(struct dev_state), GFP_KERNEL)))
 482                 goto out_nolock;
 483
 484         lock_kernel();
 485         ret = -ENOENT;
 486         dev = usb_get_dev(inode->u.generic_ip);
 487         if (!dev) {
 488                 kfree(ps);
 489                 goto out;
 490         }
 491         ret = 0;
 492         ps->dev = dev;
 493         ps->file = file;
 494         spin_lock_init(&ps->lock);
 495         INIT_LIST_HEAD(&ps->async_pending);
 496         INIT_LIST_HEAD(&ps->async_completed);
 497         init_waitqueue_head(&ps->wait);
 498         ps->discsignr = 0;
 499         ps->disctask = current;
 500         ps->disccontext = NULL;
 501         ps->ifclaimed = 0;
 502         wmb();
 503         list_add_tail(&ps->list, &dev->filelist);
 504         file->private_data = ps;
 505  out:
 506         unlock_kernel();
 507  out_nolock:
 508         return ret;
 509 }
 510
 511 static int usbdev_release(struct inode *inode, struct file *file)
 512 {
 513         struct dev_state *ps = (struct dev_state *)file->private_data;
 514         struct usb_device *dev = ps->dev;
 515         unsigned int ifnum;
 516
 517         down(&dev->serialize);
 518         list_del_init(&ps->list);
 519
 520         if (connected(dev)) {
 521                 for (ifnum = 0; ps->ifclaimed && ifnum < 8*sizeof(ps->ifclaimed); ifnum++)
 522                         if (test_bit(ifnum, &ps->ifclaimed))
 523                                 releaseintf(ps, ifnum);
 524                 destroy_all_async(ps);
 525         }
 526         up(&dev->serialize);
 527         usb_put_dev(dev);
 528         ps->dev = NULL;
 529         kfree(ps);
 530         return 0;
 531 }
 532
 533 static int proc_control(struct dev_state *ps, void __user *arg)
 534 {
 535         struct usb_device *dev = ps->dev;
 536         struct usbdevfs_ctrltransfer ctrl;
 537         unsigned int tmo;
 538         unsigned char *tbuf;
 539         int i, j, ret;
 540
 541         if (copy_from_user(&ctrl, arg, sizeof(ctrl)))
 542                 return -EFAULT;
 543         if ((ret = check_ctrlrecip(ps, ctrl.bRequestType, ctrl.wIndex)))
 544                 return ret;
 545         if (ctrl.wLength > PAGE_SIZE)
 546                 return -EINVAL;
 547         if (!(tbuf = (unsigned char *)__get_free_page(GFP_KERNEL)))
 548                 return -ENOMEM;
 549         tmo = (ctrl.timeout * HZ + 999) / 1000;
 550         if (ctrl.bRequestType & 0x80) {
 551                 if (ctrl.wLength && !access_ok(VERIFY_WRITE, ctrl.data, ctrl.wLength)) {
 552                         free_page((unsigned long)tbuf);
 553                         return -EINVAL;
 554                 }
 555                 snoop(&dev->dev, "control read: bRequest=%02x bRrequestType=%02x wValue=%04x wIndex=%04x\n",
 556                         ctrl.bRequest, ctrl.bRequestType, ctrl.wValue, ctrl.wIndex);
 557
 558                 i = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), ctrl.bRequest, ctrl.bRequestType,
 559                                        ctrl.wValue, ctrl.wIndex, tbuf, ctrl.wLength, tmo);
 560                 if ((i > 0) && ctrl.wLength) {
 561                         if (usbfs_snoop) {
 562                                 dev_info(&dev->dev, "control read: data ");
 563                                 for (j = 0; j < ctrl.wLength; ++j)
 564                                         printk ("%02x ", (unsigned char)(tbuf)[j]);
 565                                 printk("\n");
 566                         }
 567                         if (copy_to_user(ctrl.data, tbuf, ctrl.wLength)) {
 568                                 free_page((unsigned long)tbuf);
 569                                 return -EFAULT;
 570                         }
 571                 }
 572         } else {
 573                 if (ctrl.wLength) {
 574                         if (copy_from_user(tbuf, ctrl.data, ctrl.wLength)) {
 575                                 free_page((unsigned long)tbuf);
 576                                 return -EFAULT;
 577                         }
 578                 }
 579                 snoop(&dev->dev, "control write: bRequest=%02x bRrequestType=%02x wValue=%04x wIndex=%04x\n",
 580                         ctrl.bRequest, ctrl.bRequestType, ctrl.wValue, ctrl.wIndex);
 581                 if (usbfs_snoop) {
 582                         dev_info(&dev->dev, "control write: data: ");
 583                         for (j = 0; j < ctrl.wLength; ++j)
 584                                 printk ("%02x ", (unsigned char)(tbuf)[j]);
 585                         printk("\n");
 586                 }
 587                 i = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), ctrl.bRequest, ctrl.bRequestType,
 588                                        ctrl.wValue, ctrl.wIndex, tbuf, ctrl.wLength, tmo);
 589         }
 590         free_page((unsigned long)tbuf);
 591         if (i<0) {
 592                 dev_printk(KERN_DEBUG, &dev->dev, "usbfs: USBDEVFS_CONTROL "
 593                            "failed cmd %s rqt %u rq %u len %u ret %d\n",
 594                            current->comm, ctrl.bRequestType, ctrl.bRequest,
 595                            ctrl.wLength, i);
 596         }
 597         return i;
 598 }
 599
 600 static int proc_bulk(struct dev_state *ps, void __user *arg)
 601 {
 602         struct usb_device *dev = ps->dev;
 603         struct usbdevfs_bulktransfer bulk;
 604         unsigned int tmo, len1, pipe;
 605         int len2;
 606         unsigned char *tbuf;
 607         int i, ret;
 608
 609         if (copy_from_user(&bulk, arg, sizeof(bulk)))
 610                 return -EFAULT;
 611         if ((ret = findintfep(ps->dev, bulk.ep)) < 0)
 612                 return ret;
 613         if ((ret = checkintf(ps, ret)))
 614                 return ret;
 615         if (bulk.ep & USB_DIR_IN)
 616                 pipe = usb_rcvbulkpipe(dev, bulk.ep & 0x7f);
 617         else
 618                 pipe = usb_sndbulkpipe(dev, bulk.ep & 0x7f);
 619         if (!usb_maxpacket(dev, pipe, !(bulk.ep & USB_DIR_IN)))
 620                 return -EINVAL;
 621         len1 = bulk.len;
 622         if (!(tbuf = kmalloc(len1, GFP_KERNEL)))
 623                 return -ENOMEM;
 624         tmo = (bulk.timeout * HZ + 999) / 1000;
 625         if (bulk.ep & 0x80) {
 626                 if (len1 && !access_ok(VERIFY_WRITE, bulk.data, len1)) {
 627                         kfree(tbuf);
 628                         return -EINVAL;
 629                 }
 630                 i = usb_bulk_msg(dev, pipe, tbuf, len1, &len2, tmo);
 631                 if (!i && len2) {
 632                         if (copy_to_user(bulk.data, tbuf, len2)) {
 633                                 kfree(tbuf);
 634                                 return -EFAULT;
 635                         }
 636                 }
 637         } else {
 638                 if (len1) {
 639                         if (copy_from_user(tbuf, bulk.data, len1)) {
 640                                 kfree(tbuf);
 641                                 return -EFAULT;
 642                         }
 643                 }
 644                 i = usb_bulk_msg(dev, pipe, tbuf, len1, &len2, tmo);
 645         }
 646         kfree(tbuf);
 647         if (i < 0) {
 648                 dev_warn(&dev->dev, "usbfs: USBDEVFS_BULK failed "
 649                          "ep 0x%x len %u ret %d\n", bulk.ep, bulk.len, i);
 650                 return i;
 651         }
 652         return len2;
 653 }
 654
 655 static int proc_resetep(struct dev_state *ps, void __user *arg)
 656 {
 657         unsigned int ep;
 658         int ret;
 659
 660         if (get_user(ep, (unsigned int __user *)arg))
 661                 return -EFAULT;
 662         if ((ret = findintfep(ps->dev, ep)) < 0)
 663                 return ret;
 664         if ((ret = checkintf(ps, ret)))
 665                 return ret;
 666         usb_settoggle(ps->dev, ep & 0xf, !(ep & USB_DIR_IN), 0);
 667         return 0;
 668 }
 669
 670 static int proc_clearhalt(struct dev_state *ps, void __user *arg)
 671 {
 672         unsigned int ep;
 673         int pipe;
 674         int ret;
 675
 676         if (get_user(ep, (unsigned int __user *)arg))
 677                 return -EFAULT;
 678         if ((ret = findintfep(ps->dev, ep)) < 0)
 679                 return ret;
 680         if ((ret = checkintf(ps, ret)))
 681                 return ret;
 682         if (ep & USB_DIR_IN)
 683                 pipe = usb_rcvbulkpipe(ps->dev, ep & 0x7f);
 684         else
 685                 pipe = usb_sndbulkpipe(ps->dev, ep & 0x7f);
 686
 687         return usb_clear_halt(ps->dev, pipe);
 688 }
 689
 690
 691 static int proc_getdriver(struct dev_state *ps, void __user *arg)
 692 {
 693         struct usbdevfs_getdriver gd;
 694         struct usb_interface *intf;
 695         int ret;
 696
 697         if (copy_from_user(&gd, arg, sizeof(gd)))
 698                 return -EFAULT;
 699         down_read(&usb_bus_type.subsys.rwsem);
 700         intf = usb_ifnum_to_if(ps->dev, gd.interface);
 701         if (!intf || !intf->dev.driver)
 702                 ret = -ENODATA;
 703         else {
 704                 strncpy(gd.driver, intf->dev.driver->name,
 705                                 sizeof(gd.driver));
 706                 ret = (copy_to_user(arg, &gd, sizeof(gd)) ? -EFAULT : 0);
 707         }
 708         up_read(&usb_bus_type.subsys.rwsem);
 709         return ret;
 710 }
 711
 712 static int proc_connectinfo(struct dev_state *ps, void __user *arg)
 713 {
 714         struct usbdevfs_connectinfo ci;
 715
 716         ci.devnum = ps->dev->devnum;
 717         ci.slow = ps->dev->speed == USB_SPEED_LOW;
 718         if (copy_to_user(arg, &ci, sizeof(ci)))
 719                 return -EFAULT;
 720         return 0;
 721 }
 722
 723 static int proc_resetdevice(struct dev_state *ps)
 724 {
 725         return __usb_reset_device(ps->dev);
 726
 727 }
 728
 729 static int proc_setintf(struct dev_state *ps, void __user *arg)
 730 {
 731         struct usbdevfs_setinterface setintf;
 732         int ret;
 733
 734         if (copy_from_user(&setintf, arg, sizeof(setintf)))
 735                 return -EFAULT;
 736         if ((ret = checkintf(ps, setintf.interface)))
 737                 return ret;
 738         return usb_set_interface(ps->dev, setintf.interface,
 739                         setintf.altsetting);
 740 }
 741
 742 static int proc_setconfig(struct dev_state *ps, void __user *arg)
 743 {
 744         unsigned int u;
 745         int status = 0;
 746         struct usb_host_config *actconfig;
 747
 748         if (get_user(u, (unsigned int __user *)arg))
 749                 return -EFAULT;
 750
 751         actconfig = ps->dev->actconfig;
 752
 753         /* Don't touch the device if any interfaces are claimed.
 754          * It could interfere with other drivers' operations, and if
 755          * an interface is claimed by usbfs it could easily deadlock.
 756          */
 757         if (actconfig) {
 758                 int i;
 759
 760                 for (i = 0; i < actconfig->desc.bNumInterfaces; ++i) {
 761                         if (usb_interface_claimed(actconfig->interface[i])) {
 762                                 dev_warn (&ps->dev->dev,
 763                                         "usbfs: interface %d claimed "
 764                                         "while '%s' sets config #%d\n",
 765                                         actconfig->interface[i]
 766                                                 ->cur_altsetting
 767                                                 ->desc.bInterfaceNumber,
 768                                         current->comm, u);
 769 #if 0   /* FIXME:  enable in 2.6.10 or so */
 770                                 status = -EBUSY;
 771                                 break;
 772 #endif
 773                         }
 774                 }
 775         }
 776
 777         /* SET_CONFIGURATION is often abused as a "cheap" driver reset,
 778          * so avoid usb_set_configuration()'s kick to sysfs
 779          */
 780         if (status == 0) {
 781                 if (actconfig && actconfig->desc.bConfigurationValue == u)
 782                         status = usb_reset_configuration(ps->dev);
 783                 else
 784                         status = usb_set_configuration(ps->dev, u);
 785         }
 786
 787         return status;
 788 }
 789
 790 static int proc_submiturb(struct dev_state *ps, void __user *arg)
 791 {
 792         struct usbdevfs_urb uurb;
 793         struct usbdevfs_iso_packet_desc *isopkt = NULL;
 794         struct usb_endpoint_descriptor *ep_desc;
 795         struct async *as;
 796         struct usb_ctrlrequest *dr = NULL;
 797         unsigned int u, totlen, isofrmlen;
 798         int ret, interval = 0, ifnum = -1;
 799
 800         if (copy_from_user(&uurb, arg, sizeof(uurb)))
 801                 return -EFAULT;
 802         if (uurb.flags & ~(USBDEVFS_URB_ISO_ASAP|USBDEVFS_URB_SHORT_NOT_OK|
 803                            URB_NO_FSBR|URB_ZERO_PACKET))
 804                 return -EINVAL;
 805         if (!uurb.buffer)
 806                 return -EINVAL;
 807         if (uurb.signr != 0 && (uurb.signr < SIGRTMIN || uurb.signr > SIGRTMAX))
 808                 return -EINVAL;
 809         if (!(uurb.type == USBDEVFS_URB_TYPE_CONTROL && (uurb.endpoint & ~USB_ENDPOINT_DIR_MASK) == 0)) {
 810                 if ((ifnum = findintfep(ps->dev, uurb.endpoint)) < 0)
 811                         return ifnum;
 812                 if ((ret = checkintf(ps, ifnum)))
 813                         return ret;
 814         }
 815         switch(uurb.type) {
 816         case USBDEVFS_URB_TYPE_CONTROL:
 817                 if ((uurb.endpoint & ~USB_ENDPOINT_DIR_MASK) != 0) {
 818                         if (!(ep_desc = usb_epnum_to_ep_desc(ps->dev, uurb.endpoint)))
 819                                 return -ENOENT;
 820                         if ((ep_desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) != USB_ENDPOINT_XFER_CONTROL)
 821                                 return -EINVAL;
 822                 }
 823                 /* min 8 byte setup packet, max arbitrary */
 824                 if (uurb.buffer_length < 8 || uurb.buffer_length > PAGE_SIZE)
 825                         return -EINVAL;
 826                 if (!(dr = kmalloc(sizeof(struct usb_ctrlrequest), GFP_KERNEL)))
 827                         return -ENOMEM;
 828                 if (copy_from_user(dr, uurb.buffer, 8)) {
 829                         kfree(dr);
 830                         return -EFAULT;
 831                 }
 832                 if (uurb.buffer_length < (le16_to_cpup(&dr->wLength) + 8)) {
 833                         kfree(dr);
 834                         return -EINVAL;
 835                 }
 836                 if ((ret = check_ctrlrecip(ps, dr->bRequestType, le16_to_cpup(&dr->wIndex)))) {
 837                         kfree(dr);
 838                         return ret;
 839                 }
 840                 uurb.endpoint = (uurb.endpoint & ~USB_ENDPOINT_DIR_MASK) | (dr->bRequestType & USB_ENDPOINT_DIR_MASK);
 841                 uurb.number_of_packets = 0;
 842                 uurb.buffer_length = le16_to_cpup(&dr->wLength);
 843                 uurb.buffer += 8;
 844                 if (!access_ok((uurb.endpoint & USB_DIR_IN) ?  VERIFY_WRITE : VERIFY_READ, uurb.buffer, uurb.buffer_length)) {
 845                         kfree(dr);
 846                         return -EFAULT;
 847                 }
 848                 break;
 849
 850         case USBDEVFS_URB_TYPE_BULK:
 851                 uurb.number_of_packets = 0;
 852                 if (uurb.buffer_length > 16384)
 853                         return -EINVAL;
 854                 if (!access_ok((uurb.endpoint & USB_DIR_IN) ? VERIFY_WRITE : VERIFY_READ, uurb.buffer, uurb.buffer_length))
 855                         return -EFAULT;
 856                 break;
 857
 858         case USBDEVFS_URB_TYPE_ISO:
 859                 /* arbitrary limit */
 860                 if (uurb.number_of_packets < 1 || uurb.number_of_packets > 128)
 861                         return -EINVAL;
 862                 if (!(ep_desc = usb_epnum_to_ep_desc(ps->dev, uurb.endpoint)))
 863                         return -ENOENT;
 864                 interval = 1 << min (15, ep_desc->bInterval - 1);
 865                 isofrmlen = sizeof(struct usbdevfs_iso_packet_desc) * uurb.number_of_packets;
 866                 if (!(isopkt = kmalloc(isofrmlen, GFP_KERNEL)))
 867                         return -ENOMEM;
 868                 if (copy_from_user(isopkt, &((struct usbdevfs_urb __user *)arg)->iso_frame_desc, isofrmlen)) {
 869                         kfree(isopkt);
 870                         return -EFAULT;
 871                 }
 872                 for (totlen = u = 0; u < uurb.number_of_packets; u++) {
 873                         if (isopkt[u].length > 1023) {
 874                                 kfree(isopkt);
 875                                 return -EINVAL;
 876                         }
 877                         totlen += isopkt[u].length;
 878                 }
 879                 if (totlen > 32768) {
 880                         kfree(isopkt);
 881                         return -EINVAL;
 882                 }
 883                 uurb.buffer_length = totlen;
 884                 break;
 885
 886         case USBDEVFS_URB_TYPE_INTERRUPT:
 887                 uurb.number_of_packets = 0;
 888                 if (!(ep_desc = usb_epnum_to_ep_desc(ps->dev, uurb.endpoint)))
 889                         return -ENOENT;
 890                 if (ps->dev->speed == USB_SPEED_HIGH)
 891                         interval = 1 << min (15, ep_desc->bInterval - 1);
 892                 else
 893                         interval = ep_desc->bInterval;
 894                 if (uurb.buffer_length > 16384)
 895                         return -EINVAL;
 896                 if (!access_ok((uurb.endpoint & USB_DIR_IN) ? VERIFY_WRITE : VERIFY_READ, uurb.buffer, uurb.buffer_length))
 897                         return -EFAULT;
 898                 break;
 899
 900         default:
 901                 return -EINVAL;
 902         }
 903         if (!(as = alloc_async(uurb.number_of_packets))) {
 904                 if (isopkt)
 905                         kfree(isopkt);
 906                 if (dr)
 907                         kfree(dr);
 908                 return -ENOMEM;
 909         }
 910         if (!(as->urb->transfer_buffer = kmalloc(uurb.buffer_length, GFP_KERNEL))) {
 911                 if (isopkt)
 912                         kfree(isopkt);
 913                 if (dr)
 914                         kfree(dr);
 915                 free_async(as);
 916                 return -ENOMEM;
 917         }
 918         as->urb->dev = ps->dev;
 919         as->urb->pipe = (uurb.type << 30) | __create_pipe(ps->dev, uurb.endpoint & 0xf) | (uurb.endpoint & USB_DIR_IN);
 920         as->urb->transfer_flags = uurb.flags;
 921         as->urb->transfer_buffer_length = uurb.buffer_length;
 922         as->urb->setup_packet = (unsigned char*)dr;
 923         as->urb->start_frame = uurb.start_frame;
 924         as->urb->number_of_packets = uurb.number_of_packets;
 925         as->urb->interval = interval;
 926         as->urb->context = as;
 927         as->urb->complete = async_completed;
 928         for (totlen = u = 0; u < uurb.number_of_packets; u++) {
 929                 as->urb->iso_frame_desc[u].offset = totlen;
 930                 as->urb->iso_frame_desc[u].length = isopkt[u].length;
 931                 totlen += isopkt[u].length;
 932         }
 933         if (isopkt)
 934                 kfree(isopkt);
 935         as->ps = ps;
 936         as->userurb = arg;
 937         if (uurb.endpoint & USB_DIR_IN)
 938                 as->userbuffer = uurb.buffer;
 939         else
 940                 as->userbuffer = NULL;
 941         as->signr = uurb.signr;
 942         as->ifnum = ifnum;
 943         as->task = current;
 944         if (!(uurb.endpoint & USB_DIR_IN)) {
 945                 if (copy_from_user(as->urb->transfer_buffer, uurb.buffer, as->urb->transfer_buffer_length)) {
 946                         free_async(as);
 947                         return -EFAULT;
 948                 }
 949         }
 950         async_newpending(as);
 951         if ((ret = usb_submit_urb(as->urb, GFP_KERNEL))) {
 952                 dev_printk(KERN_DEBUG, &ps->dev->dev, "usbfs: usb_submit_urb returned %d\n", ret);
 953                 async_removepending(as);
 954                 free_async(as);
 955                 return ret;
 956         }
 957         return 0;
 958 }
 959
 960 static int proc_unlinkurb(struct dev_state *ps, void __user *arg)
 961 {
 962         struct async *as;
 963
 964         as = async_getpending(ps, arg);
 965         if (!as)
 966                 return -EINVAL;
 967         usb_unlink_urb(as->urb);
 968         return 0;
 969 }
 970
 971 static int processcompl(struct async *as)
 972 {
 973         struct urb *urb = as->urb;
 974         struct usbdevfs_urb __user *userurb = as->userurb;
 975         unsigned int i;
 976
 977         if (as->userbuffer)
 978                 if (copy_to_user(as->userbuffer, urb->transfer_buffer, urb->transfer_buffer_length))
 979                         return -EFAULT;
 980         if (put_user(urb->status, &userurb->status))
 981                 return -EFAULT;
 982         if (put_user(urb->actual_length, &userurb->actual_length))
 983                 return -EFAULT;
 984         if (put_user(urb->error_count, &userurb->error_count))
 985                 return -EFAULT;
 986
 987         if (!(usb_pipeisoc(urb->pipe)))
 988                 return 0;
 989         for (i = 0; i < urb->number_of_packets; i++) {
 990                 if (put_user(urb->iso_frame_desc[i].actual_length,
 991                              &userurb->iso_frame_desc[i].actual_length))
 992                         return -EFAULT;
 993                 if (put_user(urb->iso_frame_desc[i].status,
 994                              &userurb->iso_frame_desc[i].status))
 995                         return -EFAULT;
 996         }
 997         return 0;
 998 }
 999
1000 static int proc_reapurb(struct dev_state *ps, void __user *arg)
1001 {
1002         DECLARE_WAITQUEUE(wait, current);
1003         struct async *as = NULL;
1004         void __user *addr;
1005         struct usb_device *dev = ps->dev;
1006         int ret;
1007
1008         add_wait_queue(&ps->wait, &wait);
1009         while (connected(dev)) {
1010                 __set_current_state(TASK_INTERRUPTIBLE);
1011                 if ((as = async_getcompleted(ps)))
1012                         break;
1013                 if (signal_pending(current))
1014                         break;
1015                 up(&dev->serialize);
1016                 schedule();
1017                 down(&dev->serialize);
1018         }
1019         remove_wait_queue(&ps->wait, &wait);
1020         set_current_state(TASK_RUNNING);
1021         if (as) {
1022                 ret = processcompl(as);
1023                 addr = as->userurb;
1024                 free_async(as);
1025                 if (ret)
1026                         return ret;
1027                 if (put_user(addr, (void __user * __user *)arg))
1028                         return -EFAULT;
1029                 return 0;
1030         }
1031         if (signal_pending(current))
1032                 return -EINTR;
1033         return -EIO;
1034 }
1035
1036 static int proc_reapurbnonblock(struct dev_state *ps, void __user *arg)
1037 {
1038         struct async *as;
1039         void __user *addr;
1040         int ret;
1041
1042         if (!(as = async_getcompleted(ps)))
1043                 return -EAGAIN;
1044         ret = processcompl(as);
1045         addr = as->userurb;
1046         free_async(as);
1047         if (ret)
1048                 return ret;
1049         if (put_user(addr, (void __user * __user *)arg))
1050                 return -EFAULT;
1051         return 0;
1052 }
1053
1054 static int proc_disconnectsignal(struct dev_state *ps, void __user *arg)
1055 {
1056         struct usbdevfs_disconnectsignal ds;
1057
1058         if (copy_from_user(&ds, arg, sizeof(ds)))
1059                 return -EFAULT;
1060         if (ds.signr != 0 && (ds.signr < SIGRTMIN || ds.signr > SIGRTMAX))
1061                 return -EINVAL;
1062         ps->discsignr = ds.signr;
1063         ps->disccontext = ds.context;
1064         return 0;
1065 }
1066
1067 static int proc_claiminterface(struct dev_state *ps, void __user *arg)
1068 {
1069         unsigned int ifnum;
1070
1071         if (get_user(ifnum, (unsigned int __user *)arg))
1072                 return -EFAULT;
1073         return claimintf(ps, ifnum);
1074 }
1075
1076 static int proc_releaseinterface(struct dev_state *ps, void __user *arg)
1077 {
1078         unsigned int ifnum;
1079         int ret;
1080
1081         if (get_user(ifnum, (unsigned int __user *)arg))
1082                 return -EFAULT;
1083         if ((ret = releaseintf(ps, ifnum)) < 0)
1084                 return ret;
1085         destroy_async_on_interface (ps, ifnum);
1086         return 0;
1087 }
1088
1089 static int proc_ioctl (struct dev_state *ps, void __user *arg)
1090 {
1091         struct usbdevfs_ioctl   ctrl;
1092         int                     size;
1093         void                    *buf = NULL;
1094         int                     retval = 0;
1095         struct usb_interface    *intf = NULL;
1096         struct usb_driver       *driver = NULL;
1097
1098         /* get input parameters and alloc buffer */
1099         if (copy_from_user(&ctrl, arg, sizeof (ctrl)))
1100                 return -EFAULT;
1101         if ((size = _IOC_SIZE (ctrl.ioctl_code)) > 0) {
1102                 if ((buf = kmalloc (size, GFP_KERNEL)) == 0)
1103                         return -ENOMEM;
1104                 if ((_IOC_DIR(ctrl.ioctl_code) & _IOC_WRITE)) {
1105                         if (copy_from_user (buf, ctrl.data, size)) {
1106                                 kfree (buf);
1107                                 return -EFAULT;
1108                         }
1109                 } else {
1110                         memset (buf, 0, size);
1111                 }
1112         }
1113
1114         if (!connected(ps->dev)) {
1115                 if (buf)
1116                         kfree(buf);
1117                 return -ENODEV;
1118         }
1119
1120         if (ps->dev->state != USB_STATE_CONFIGURED)
1121                 retval = -ENODEV;
1122         else if (!(intf = usb_ifnum_to_if (ps->dev, ctrl.ifno)))
1123                retval = -EINVAL;
1124         else switch (ctrl.ioctl_code) {
1125
1126         /* disconnect kernel driver from interface */
1127         case USBDEVFS_DISCONNECT:
1128                 down_write(&usb_bus_type.subsys.rwsem);
1129                 if (intf->dev.driver) {
1130                         driver = to_usb_driver(intf->dev.driver);
1131                         dev_dbg (&intf->dev, "disconnect by usbfs\n");
1132                         usb_driver_release_interface(driver, intf);
1133                 } else
1134                         retval = -ENODATA;
1135                 up_write(&usb_bus_type.subsys.rwsem);
1136                 break;
1137
1138         /* let kernel drivers try to (re)bind to the interface */
1139         case USBDEVFS_CONNECT:
1140                 bus_rescan_devices(intf->dev.bus);
1141                 break;
1142
1143         /* talk directly to the interface's driver */
1144         default:
1145                 down_read(&usb_bus_type.subsys.rwsem);
1146                 if (intf->dev.driver)
1147                         driver = to_usb_driver(intf->dev.driver);
1148                 if (driver == 0 || driver->ioctl == 0) {
1149                         retval = -ENOTTY;
1150                 } else {
1151                         retval = driver->ioctl (intf, ctrl.ioctl_code, buf);
1152                         if (retval == -ENOIOCTLCMD)
1153                                 retval = -ENOTTY;
1154                 }
1155                 up_read(&usb_bus_type.subsys.rwsem);
1156         }
1157
1158         /* cleanup and return */
1159         if (retval >= 0
1160                         && (_IOC_DIR (ctrl.ioctl_code) & _IOC_READ) != 0
1161                         && size > 0
1162                         && copy_to_user (ctrl.data, buf, size) != 0)
1163                 retval = -EFAULT;
1164         if (buf != 0)
1165                 kfree (buf);
1166         return retval;
1167 }
1168
1169 /*
1170  * NOTE:  All requests here that have interface numbers as parameters
1171  * are assuming that somehow the configuration has been prevented from
1172  * changing.  But there's no mechanism to ensure that...
1173  */
1174 static int usbdev_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
1175 {
1176         struct dev_state *ps = (struct dev_state *)file->private_data;
1177         struct usb_device *dev = ps->dev;
1178         void __user *p = (void __user *)arg;
1179         int ret = -ENOTTY;
1180
1181         if (!(file->f_mode & FMODE_WRITE))
1182                 return -EPERM;
1183         down(&dev->serialize);
1184         if (!connected(dev)) {
1185                 up(&dev->serialize);
1186                 return -ENODEV;
1187         }
1188
1189         switch (cmd) {
1190         case USBDEVFS_CONTROL:
1191                 snoop(&dev->dev, "%s: CONTROL\n", __FUNCTION__);
1192                 ret = proc_control(ps, p);
1193                 if (ret >= 0)
1194                         inode->i_mtime = CURRENT_TIME;
1195                 break;
1196
1197         case USBDEVFS_BULK:
1198                 snoop(&dev->dev, "%s: BULK\n", __FUNCTION__);
1199                 ret = proc_bulk(ps, p);
1200                 if (ret >= 0)
1201                         inode->i_mtime = CURRENT_TIME;
1202                 break;
1203
1204         case USBDEVFS_RESETEP:
1205                 snoop(&dev->dev, "%s: RESETEP\n", __FUNCTION__);
1206                 ret = proc_resetep(ps, p);
1207                 if (ret >= 0)
1208                         inode->i_mtime = CURRENT_TIME;
1209                 break;
1210
1211         case USBDEVFS_RESET:
1212                 snoop(&dev->dev, "%s: RESET\n", __FUNCTION__);
1213                 ret = proc_resetdevice(ps);
1214                 break;
1215
1216         case USBDEVFS_CLEAR_HALT:
1217                 snoop(&dev->dev, "%s: CLEAR_HALT\n", __FUNCTION__);
1218                 ret = proc_clearhalt(ps, p);
1219                 if (ret >= 0)
1220                         inode->i_mtime = CURRENT_TIME;
1221                 break;
1222
1223         case USBDEVFS_GETDRIVER:
1224                 snoop(&dev->dev, "%s: GETDRIVER\n", __FUNCTION__);
1225                 ret = proc_getdriver(ps, p);
1226                 break;
1227
1228         case USBDEVFS_CONNECTINFO:
1229                 snoop(&dev->dev, "%s: CONNECTINFO\n", __FUNCTION__);
1230                 ret = proc_connectinfo(ps, p);
1231                 break;
1232
1233         case USBDEVFS_SETINTERFACE:
1234                 snoop(&dev->dev, "%s: SETINTERFACE\n", __FUNCTION__);
1235                 ret = proc_setintf(ps, p);
1236                 break;
1237
1238         case USBDEVFS_SETCONFIGURATION:
1239                 snoop(&dev->dev, "%s: SETCONFIGURATION\n", __FUNCTION__);
1240                 ret = proc_setconfig(ps, p);
1241                 break;
1242
1243         case USBDEVFS_SUBMITURB:
1244                 snoop(&dev->dev, "%s: SUBMITURB\n", __FUNCTION__);
1245                 ret = proc_submiturb(ps, p);
1246                 if (ret >= 0)
1247                         inode->i_mtime = CURRENT_TIME;
1248                 break;
1249
1250         case USBDEVFS_DISCARDURB:
1251                 snoop(&dev->dev, "%s: DISCARDURB\n", __FUNCTION__);
1252                 ret = proc_unlinkurb(ps, p);
1253                 break;
1254
1255         case USBDEVFS_REAPURB:
1256                 snoop(&dev->dev, "%s: REAPURB\n", __FUNCTION__);
1257                 ret = proc_reapurb(ps, p);
1258                 break;
1259
1260         case USBDEVFS_REAPURBNDELAY:
1261                 snoop(&dev->dev, "%s: REAPURBDELAY\n", __FUNCTION__);
1262                 ret = proc_reapurbnonblock(ps, p);
1263                 break;
1264
1265         case USBDEVFS_DISCSIGNAL:
1266                 snoop(&dev->dev, "%s: DISCSIGNAL\n", __FUNCTION__);
1267                 ret = proc_disconnectsignal(ps, p);
1268                 break;
1269
1270         case USBDEVFS_CLAIMINTERFACE:
1271                 snoop(&dev->dev, "%s: CLAIMINTERFACE\n", __FUNCTION__);
1272                 ret = proc_claiminterface(ps, p);
1273                 break;
1274
1275         case USBDEVFS_RELEASEINTERFACE:
1276                 snoop(&dev->dev, "%s: RELEASEINTERFACE\n", __FUNCTION__);
1277                 ret = proc_releaseinterface(ps, p);
1278                 break;
1279
1280         case USBDEVFS_IOCTL:
1281                 snoop(&dev->dev, "%s: IOCTL\n", __FUNCTION__);
1282                 ret = proc_ioctl(ps, p);
1283                 break;
1284         }
1285         up(&dev->serialize);
1286         if (ret >= 0)
1287                 inode->i_atime = CURRENT_TIME;
1288         return ret;
1289 }
1290
1291 /* No kernel lock - fine */
1292 static unsigned int usbdev_poll(struct file *file, struct poll_table_struct *wait)
1293 {
1294         struct dev_state *ps = (struct dev_state *)file->private_data;
1295         unsigned int mask = 0;
1296
1297         poll_wait(file, &ps->wait, wait);
1298         if (file->f_mode & FMODE_WRITE && !list_empty(&ps->async_completed))
1299                 mask |= POLLOUT | POLLWRNORM;
1300         if (!connected(ps->dev))
1301                 mask |= POLLERR | POLLHUP;
1302         return mask;
1303 }
1304
1305 struct file_operations usbdevfs_device_file_operations = {
1306         .llseek =       usbdev_lseek,
1307         .read =         usbdev_read,
1308         .poll =         usbdev_poll,
1309         .ioctl =        usbdev_ioctl,
1310         .open =         usbdev_open,
1311         .release =      usbdev_release,
1312 };