File:  [Qemu by Fabrice Bellard] / qemu / usb-bsd.c
Revision 1.1.1.6 (vendor branch): download - view: text, annotated - select for diffs
Tue Apr 24 19:17:09 2018 UTC (3 years, 1 month ago) by root
Branches: qemu, MAIN
CVS tags: qemu1001, HEAD
qemu 1.0.1

    1: /*
    2:  * BSD host USB redirector
    3:  *
    4:  * Copyright (c) 2006 Lonnie Mendez
    5:  * Portions of code and concepts borrowed from
    6:  * usb-linux.c and libusb's bsd.c and are copyright their respective owners.
    7:  *
    8:  * Permission is hereby granted, free of charge, to any person obtaining a copy
    9:  * of this software and associated documentation files (the "Software"), to deal
   10:  * in the Software without restriction, including without limitation the rights
   11:  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   12:  * copies of the Software, and to permit persons to whom the Software is
   13:  * furnished to do so, subject to the following conditions:
   14:  *
   15:  * The above copyright notice and this permission notice shall be included in
   16:  * all copies or substantial portions of the Software.
   17:  *
   18:  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
   19:  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
   20:  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
   21:  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
   22:  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
   23:  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
   24:  * THE SOFTWARE.
   25:  */
   26: 
   27: #include "qemu-common.h"
   28: #include "monitor.h"
   29: #include "hw/usb.h"
   30: 
   31: /* usb.h declares these */
   32: #undef USB_SPEED_HIGH
   33: #undef USB_SPEED_FULL
   34: #undef USB_SPEED_LOW
   35: 
   36: #include <sys/ioctl.h>
   37: #ifndef __DragonFly__
   38: #include <dev/usb/usb.h>
   39: #else
   40: #include <bus/usb/usb.h>
   41: #endif
   42: 
   43: /* This value has maximum potential at 16.
   44:  * You should also set hw.usb.debug to gain
   45:  * more detailed view.
   46:  */
   47: //#define DEBUG
   48: #define UGEN_DEBUG_LEVEL 0
   49: 
   50: 
   51: typedef int USBScanFunc(void *opaque, int bus_num, int addr, int class_id,
   52:                         int vendor_id, int product_id,
   53:                         const char *product_name, int speed);
   54: static int usb_host_find_device(int *pbus_num, int *paddr,
   55:                                 const char *devname);
   56: 
   57: typedef struct USBHostDevice {
   58:     USBDevice dev;
   59:     int ep_fd[USB_MAX_ENDPOINTS];
   60:     int devfd;
   61:     char devpath[32];
   62: } USBHostDevice;
   63: 
   64: 
   65: static int ensure_ep_open(USBHostDevice *dev, int ep, int mode)
   66: {
   67:     char buf[32];
   68:     int fd;
   69: 
   70:     /* Get the address for this endpoint */
   71:     ep = UE_GET_ADDR(ep);
   72: 
   73:     if (dev->ep_fd[ep] < 0) {
   74: #if defined(__FreeBSD__) || defined(__DragonFly__)
   75:         snprintf(buf, sizeof(buf) - 1, "%s.%d", dev->devpath, ep);
   76: #else
   77:         snprintf(buf, sizeof(buf) - 1, "%s.%02d", dev->devpath, ep);
   78: #endif
   79:         /* Try to open it O_RDWR first for those devices which have in and out
   80:          * endpoints with the same address (eg 0x02 and 0x82)
   81:          */
   82:         fd = open(buf, O_RDWR);
   83:         if (fd < 0 && errno == ENXIO)
   84:             fd = open(buf, mode);
   85:         if (fd < 0) {
   86: #ifdef DEBUG
   87:             printf("ensure_ep_open: failed to open device endpoint %s: %s\n",
   88:                    buf, strerror(errno));
   89: #endif
   90:         }
   91:         dev->ep_fd[ep] = fd;
   92:     }
   93: 
   94:     return dev->ep_fd[ep];
   95: }
   96: 
   97: static void ensure_eps_closed(USBHostDevice *dev)
   98: {
   99:     int epnum = 1;
  100: 
  101:     if (!dev)
  102:         return;
  103: 
  104:     while (epnum < USB_MAX_ENDPOINTS) {
  105:         if (dev->ep_fd[epnum] >= 0) {
  106:             close(dev->ep_fd[epnum]);
  107:             dev->ep_fd[epnum] = -1;
  108:         }
  109:         epnum++;
  110:     }
  111: }
  112: 
  113: static void usb_host_handle_reset(USBDevice *dev)
  114: {
  115: #if 0
  116:     USBHostDevice *s = (USBHostDevice *)dev;
  117: #endif
  118: }
  119: 
  120: /* XXX:
  121:  * -check device states against transfer requests
  122:  *  and return appropriate response
  123:  */
  124: static int usb_host_handle_control(USBDevice *dev,
  125:                                    USBPacket *p,
  126:                                    int request,
  127:                                    int value,
  128:                                    int index,
  129:                                    int length,
  130:                                    uint8_t *data)
  131: {
  132:     USBHostDevice *s = (USBHostDevice *)dev;
  133:     struct usb_ctl_request req;
  134:     struct usb_alt_interface aiface;
  135:     int ret, timeout = 50;
  136: 
  137:     if ((request >> 8) == UT_WRITE_DEVICE &&
  138:         (request & 0xff) == UR_SET_ADDRESS) {
  139: 
  140:         /* specific SET_ADDRESS support */
  141:         dev->addr = value;
  142:         return 0;
  143:     } else if ((request >> 8) == UT_WRITE_DEVICE &&
  144:                (request & 0xff) == UR_SET_CONFIG) {
  145: 
  146:         ensure_eps_closed(s); /* can't do this without all eps closed */
  147: 
  148:         ret = ioctl(s->devfd, USB_SET_CONFIG, &value);
  149:         if (ret < 0) {
  150: #ifdef DEBUG
  151:             printf("handle_control: failed to set configuration - %s\n",
  152:                    strerror(errno));
  153: #endif
  154:             return USB_RET_STALL;
  155:         }
  156: 
  157:         return 0;
  158:     } else if ((request >> 8) == UT_WRITE_INTERFACE &&
  159:                (request & 0xff) == UR_SET_INTERFACE) {
  160: 
  161:         aiface.uai_interface_index = index;
  162:         aiface.uai_alt_no = value;
  163: 
  164:         ensure_eps_closed(s); /* can't do this without all eps closed */
  165:         ret = ioctl(s->devfd, USB_SET_ALTINTERFACE, &aiface);
  166:         if (ret < 0) {
  167: #ifdef DEBUG
  168:             printf("handle_control: failed to set alternate interface - %s\n",
  169:                    strerror(errno));
  170: #endif
  171:             return USB_RET_STALL;
  172:         }
  173: 
  174:         return 0;
  175:     } else {
  176:         req.ucr_request.bmRequestType = request >> 8;
  177:         req.ucr_request.bRequest = request & 0xff;
  178:         USETW(req.ucr_request.wValue, value);
  179:         USETW(req.ucr_request.wIndex, index);
  180:         USETW(req.ucr_request.wLength, length);
  181:         req.ucr_data = data;
  182:         req.ucr_flags = USBD_SHORT_XFER_OK;
  183: 
  184:         ret = ioctl(s->devfd, USB_SET_TIMEOUT, &timeout);
  185: #if defined(__NetBSD__) || defined(__OpenBSD__)
  186:         if (ret < 0 && errno != EINVAL) {
  187: #else
  188:         if (ret < 0) {
  189: #endif
  190: #ifdef DEBUG
  191:             printf("handle_control: setting timeout failed - %s\n",
  192:                    strerror(errno));
  193: #endif
  194:         }
  195: 
  196:         ret = ioctl(s->devfd, USB_DO_REQUEST, &req);
  197:         /* ugen returns EIO for usbd_do_request_ no matter what
  198:          * happens with the transfer */
  199:         if (ret < 0) {
  200: #ifdef DEBUG
  201:             printf("handle_control: error after request - %s\n",
  202:                    strerror(errno));
  203: #endif
  204:             return USB_RET_NAK; // STALL
  205:         } else {
  206:             return req.ucr_actlen;
  207:         }
  208:     }
  209: }
  210: 
  211: static int usb_host_handle_data(USBDevice *dev, USBPacket *p)
  212: {
  213:     USBHostDevice *s = (USBHostDevice *)dev;
  214:     int ret, fd, mode;
  215:     int one = 1, shortpacket = 0, timeout = 50;
  216:     sigset_t new_mask, old_mask;
  217:     uint8_t devep = p->devep;
  218: 
  219:     /* protect data transfers from SIGALRM signal */
  220:     sigemptyset(&new_mask);
  221:     sigaddset(&new_mask, SIGALRM);
  222:     sigprocmask(SIG_BLOCK, &new_mask, &old_mask);
  223: 
  224:     if (p->pid == USB_TOKEN_IN) {
  225:         devep |= 0x80;
  226:         mode = O_RDONLY;
  227:         shortpacket = 1;
  228:     } else {
  229:         mode = O_WRONLY;
  230:     }
  231: 
  232:     fd = ensure_ep_open(s, devep, mode);
  233:     if (fd < 0) {
  234:         sigprocmask(SIG_SETMASK, &old_mask, NULL);
  235:         return USB_RET_NODEV;
  236:     }
  237: 
  238:     if (ioctl(fd, USB_SET_TIMEOUT, &timeout) < 0) {
  239: #ifdef DEBUG
  240:         printf("handle_data: failed to set timeout - %s\n",
  241:                strerror(errno));
  242: #endif
  243:     }
  244: 
  245:     if (shortpacket) {
  246:         if (ioctl(fd, USB_SET_SHORT_XFER, &one) < 0) {
  247: #ifdef DEBUG
  248:             printf("handle_data: failed to set short xfer mode - %s\n",
  249:                    strerror(errno));
  250: #endif
  251:             sigprocmask(SIG_SETMASK, &old_mask, NULL);
  252:         }
  253:     }
  254: 
  255:     if (p->pid == USB_TOKEN_IN)
  256:         ret = readv(fd, p->iov.iov, p->iov.niov);
  257:     else
  258:         ret = writev(fd, p->iov.iov, p->iov.niov);
  259: 
  260:     sigprocmask(SIG_SETMASK, &old_mask, NULL);
  261: 
  262:     if (ret < 0) {
  263: #ifdef DEBUG
  264:         printf("handle_data: error after %s data - %s\n",
  265:                pid == USB_TOKEN_IN ? "reading" : "writing", strerror(errno));
  266: #endif
  267:         switch(errno) {
  268:         case ETIMEDOUT:
  269:         case EINTR:
  270:             return USB_RET_NAK;
  271:         default:
  272:             return USB_RET_STALL;
  273:         }
  274:     } else {
  275:         return ret;
  276:     }
  277: }
  278: 
  279: static void usb_host_handle_destroy(USBDevice *opaque)
  280: {
  281:     USBHostDevice *s = (USBHostDevice *)opaque;
  282:     int i;
  283: 
  284:     for (i = 0; i < USB_MAX_ENDPOINTS; i++)
  285:         if (s->ep_fd[i] >= 0)
  286:             close(s->ep_fd[i]);
  287: 
  288:     if (s->devfd < 0)
  289:         return;
  290: 
  291:     close(s->devfd);
  292: 
  293:     g_free(s);
  294: }
  295: 
  296: static int usb_host_initfn(USBDevice *dev)
  297: {
  298:     return 0;
  299: }
  300: 
  301: USBDevice *usb_host_device_open(const char *devname)
  302: {
  303:     struct usb_device_info bus_info, dev_info;
  304:     USBDevice *d = NULL, *ret = NULL;
  305:     USBHostDevice *dev;
  306:     char ctlpath[PATH_MAX + 1];
  307:     char buspath[PATH_MAX + 1];
  308:     int bfd, dfd, bus, address, i;
  309:     int ugendebug = UGEN_DEBUG_LEVEL;
  310: 
  311:     if (usb_host_find_device(&bus, &address, devname) < 0) {
  312:         goto fail;
  313:     }
  314: 
  315:     snprintf(buspath, PATH_MAX, "/dev/usb%d", bus);
  316: 
  317:     bfd = open(buspath, O_RDWR);
  318:     if (bfd < 0) {
  319: #ifdef DEBUG
  320:         printf("usb_host_device_open: failed to open usb bus - %s\n",
  321:                strerror(errno));
  322: #endif
  323:         goto fail;
  324:     }
  325: 
  326:     bus_info.udi_addr = address;
  327:     if (ioctl(bfd, USB_DEVICEINFO, &bus_info) < 0) {
  328: #ifdef DEBUG
  329:         printf("usb_host_device_open: failed to grab bus information - %s\n",
  330:                strerror(errno));
  331: #endif
  332:         goto fail_bfd;
  333:     }
  334: 
  335: #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)
  336:     snprintf(ctlpath, PATH_MAX, "/dev/%s", bus_info.udi_devnames[0]);
  337: #else
  338:     snprintf(ctlpath, PATH_MAX, "/dev/%s.00", bus_info.udi_devnames[0]);
  339: #endif
  340: 
  341:     dfd  = open(ctlpath, O_RDWR);
  342:     if (dfd < 0) {
  343:         dfd = open(ctlpath, O_RDONLY);
  344:         if (dfd < 0) {
  345: #ifdef DEBUG
  346:             printf("usb_host_device_open: failed to open usb device %s - %s\n",
  347:                    ctlpath, strerror(errno));
  348: #endif
  349:         }
  350:         goto fail_dfd;
  351:     }
  352: 
  353:     if (ioctl(dfd, USB_GET_DEVICEINFO, &dev_info) < 0) {
  354: #ifdef DEBUG
  355:         printf("usb_host_device_open: failed to grab device info - %s\n",
  356:                strerror(errno));
  357: #endif
  358:         goto fail_dfd;
  359:     }
  360: 
  361:     d = usb_create(NULL /* FIXME */, "usb-host");
  362:     dev = DO_UPCAST(USBHostDevice, dev, d);
  363: 
  364:     if (dev_info.udi_speed == 1) {
  365:         dev->dev.speed = USB_SPEED_LOW - 1;
  366:         dev->dev.speedmask = USB_SPEED_MASK_LOW;
  367:     } else {
  368:         dev->dev.speed = USB_SPEED_FULL - 1;
  369:         dev->dev.speedmask = USB_SPEED_MASK_FULL;
  370:     }
  371: 
  372:     if (strncmp(dev_info.udi_product, "product", 7) != 0) {
  373:         pstrcpy(dev->dev.product_desc, sizeof(dev->dev.product_desc),
  374:                 dev_info.udi_product);
  375:     } else {
  376:         snprintf(dev->dev.product_desc, sizeof(dev->dev.product_desc),
  377:                  "host:%s", devname);
  378:     }
  379: 
  380:     pstrcpy(dev->devpath, sizeof(dev->devpath), "/dev/");
  381:     pstrcat(dev->devpath, sizeof(dev->devpath), dev_info.udi_devnames[0]);
  382: 
  383:     /* Mark the endpoints as not yet open */
  384:     for (i = 0; i < USB_MAX_ENDPOINTS; i++) {
  385:         dev->ep_fd[i] = -1;
  386:     }
  387: 
  388:     ioctl(dfd, USB_SETDEBUG, &ugendebug);
  389: 
  390:     ret = (USBDevice *)dev;
  391: 
  392: fail_dfd:
  393:     close(dfd);
  394: fail_bfd:
  395:     close(bfd);
  396: fail:
  397:     return ret;
  398: }
  399: 
  400: static struct USBDeviceInfo usb_host_dev_info = {
  401:     .product_desc   = "USB Host Device",
  402:     .qdev.name      = "usb-host",
  403:     .qdev.size      = sizeof(USBHostDevice),
  404:     .init           = usb_host_initfn,
  405:     .handle_packet  = usb_generic_handle_packet,
  406:     .handle_reset   = usb_host_handle_reset,
  407:     .handle_control = usb_host_handle_control,
  408:     .handle_data    = usb_host_handle_data,
  409:     .handle_destroy = usb_host_handle_destroy,
  410: };
  411: 
  412: static void usb_host_register_devices(void)
  413: {
  414:     usb_qdev_register(&usb_host_dev_info);
  415: }
  416: device_init(usb_host_register_devices)
  417: 
  418: static int usb_host_scan(void *opaque, USBScanFunc *func)
  419: {
  420:     struct usb_device_info bus_info;
  421:     struct usb_device_info dev_info;
  422:     uint16_t vendor_id, product_id, class_id, speed;
  423:     int bfd, dfd, bus, address;
  424:     char busbuf[20], devbuf[20], product_name[256];
  425:     int ret = 0;
  426: 
  427:     for (bus = 0; bus < 10; bus++) {
  428: 
  429:         snprintf(busbuf, sizeof(busbuf) - 1, "/dev/usb%d", bus);
  430:         bfd = open(busbuf, O_RDWR);
  431:         if (bfd < 0)
  432: 	    continue;
  433: 
  434:         for (address = 1; address < 127; address++) {
  435: 
  436:             bus_info.udi_addr = address;
  437:             if (ioctl(bfd, USB_DEVICEINFO, &bus_info) < 0)
  438:                 continue;
  439: 
  440:             /* only list devices that can be used by generic layer */
  441:             if (strncmp(bus_info.udi_devnames[0], "ugen", 4) != 0)
  442:                 continue;
  443: 
  444: #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)
  445:             snprintf(devbuf, sizeof(devbuf) - 1, "/dev/%s", bus_info.udi_devnames[0]);
  446: #else
  447:             snprintf(devbuf, sizeof(devbuf) - 1, "/dev/%s.00", bus_info.udi_devnames[0]);
  448: #endif
  449: 
  450:             dfd = open(devbuf, O_RDONLY);
  451:             if (dfd < 0) {
  452: #ifdef DEBUG
  453:                 printf("usb_host_scan: couldn't open device %s - %s\n", devbuf,
  454:                        strerror(errno));
  455: #endif
  456:                 continue;
  457:             }
  458: 
  459:             if (ioctl(dfd, USB_GET_DEVICEINFO, &dev_info) < 0)
  460:                 printf("usb_host_scan: couldn't get device information for %s - %s\n",
  461:                        devbuf, strerror(errno));
  462: 
  463:             /* XXX: might need to fixup endianness of word values before copying over */
  464: 
  465:             vendor_id = dev_info.udi_vendorNo;
  466:             product_id = dev_info.udi_productNo;
  467:             class_id = dev_info.udi_class;
  468:             speed = dev_info.udi_speed;
  469: 
  470:             if (strncmp(dev_info.udi_product, "product", 7) != 0)
  471:                 pstrcpy(product_name, sizeof(product_name),
  472:                         dev_info.udi_product);
  473:             else
  474:                 product_name[0] = '\0';
  475: 
  476:             ret = func(opaque, bus, address, class_id, vendor_id,
  477:                        product_id, product_name, speed);
  478: 
  479:             close(dfd);
  480: 
  481:             if (ret)
  482:                 goto the_end;
  483:         }
  484: 
  485:         close(bfd);
  486:     }
  487: 
  488: the_end:
  489:     return ret;
  490: }
  491: 
  492: typedef struct FindDeviceState {
  493:     int vendor_id;
  494:     int product_id;
  495:     int bus_num;
  496:     int addr;
  497: } FindDeviceState;
  498: 
  499: static int usb_host_find_device_scan(void *opaque, int bus_num, int addr,
  500:                                      int class_id,
  501:                                      int vendor_id, int product_id,
  502:                                      const char *product_name, int speed)
  503: {
  504:     FindDeviceState *s = opaque;
  505:     if (vendor_id == s->vendor_id &&
  506:         product_id == s->product_id) {
  507:         s->bus_num = bus_num;
  508:         s->addr = addr;
  509:         return 1;
  510:      } else {
  511:         return 0;
  512:      }
  513: }
  514: 
  515: 
  516: /* the syntax is :
  517:    'bus.addr' (decimal numbers) or
  518:    'vendor_id:product_id' (hexa numbers) */
  519: static int usb_host_find_device(int *pbus_num, int *paddr,
  520:                                 const char *devname)
  521: {
  522:     const char *p;
  523:     int ret;
  524:     FindDeviceState fs;
  525: 
  526:     p = strchr(devname, '.');
  527:     if (p) {
  528:         *pbus_num = strtoul(devname, NULL, 0);
  529:         *paddr = strtoul(p + 1, NULL, 0);
  530:         return 0;
  531:     }
  532:     p = strchr(devname, ':');
  533:     if (p) {
  534:         fs.vendor_id = strtoul(devname, NULL, 16);
  535:         fs.product_id = strtoul(p + 1, NULL, 16);
  536:         ret = usb_host_scan(&fs, usb_host_find_device_scan);
  537:         if (ret) {
  538:             *pbus_num = fs.bus_num;
  539:             *paddr = fs.addr;
  540:             return 0;
  541:         }
  542:      }
  543:      return -1;
  544: }
  545: 
  546: /**********************/
  547: /* USB host device info */
  548: 
  549: struct usb_class_info {
  550:     int class;
  551:     const char *class_name;
  552: };
  553: 
  554: static const struct usb_class_info usb_class_info[] = {
  555:     { USB_CLASS_AUDIO, "Audio"},
  556:     { USB_CLASS_COMM, "Communication"},
  557:     { USB_CLASS_HID, "HID"},
  558:     { USB_CLASS_HUB, "Hub" },
  559:     { USB_CLASS_PHYSICAL, "Physical" },
  560:     { USB_CLASS_PRINTER, "Printer" },
  561:     { USB_CLASS_MASS_STORAGE, "Storage" },
  562:     { USB_CLASS_CDC_DATA, "Data" },
  563:     { USB_CLASS_APP_SPEC, "Application Specific" },
  564:     { USB_CLASS_VENDOR_SPEC, "Vendor Specific" },
  565:     { USB_CLASS_STILL_IMAGE, "Still Image" },
  566:     { USB_CLASS_CSCID, "Smart Card" },
  567:     { USB_CLASS_CONTENT_SEC, "Content Security" },
  568:     { -1, NULL }
  569: };
  570: 
  571: static const char *usb_class_str(uint8_t class)
  572: {
  573:     const struct usb_class_info *p;
  574:     for (p = usb_class_info; p->class != -1; p++) {
  575:         if (p->class == class)
  576:             break;
  577:     }
  578:     return p->class_name;
  579: }
  580: 
  581: static void usb_info_device(Monitor *mon, int bus_num, int addr, int class_id,
  582:                             int vendor_id, int product_id,
  583:                             const char *product_name,
  584:                             int speed)
  585: {
  586:     const char *class_str, *speed_str;
  587: 
  588:     switch(speed) {
  589:     case USB_SPEED_LOW:
  590:         speed_str = "1.5";
  591:         break;
  592:     case USB_SPEED_FULL:
  593:         speed_str = "12";
  594:         break;
  595:     case USB_SPEED_HIGH:
  596:         speed_str = "480";
  597:         break;
  598:     default:
  599:         speed_str = "?";
  600:         break;
  601:     }
  602: 
  603:     monitor_printf(mon, "  Device %d.%d, speed %s Mb/s\n",
  604:                    bus_num, addr, speed_str);
  605:     class_str = usb_class_str(class_id);
  606:     if (class_str)
  607:         monitor_printf(mon, "    %s:", class_str);
  608:     else
  609:         monitor_printf(mon, "    Class %02x:", class_id);
  610:     monitor_printf(mon, " USB device %04x:%04x", vendor_id, product_id);
  611:     if (product_name[0] != '\0')
  612:         monitor_printf(mon, ", %s", product_name);
  613:     monitor_printf(mon, "\n");
  614: }
  615: 
  616: static int usb_host_info_device(void *opaque,
  617:                                 int bus_num, int addr,
  618:                                 int class_id,
  619:                                 int vendor_id, int product_id,
  620:                                 const char *product_name,
  621:                                 int speed)
  622: {
  623:     Monitor *mon = opaque;
  624: 
  625:     usb_info_device(mon, bus_num, addr, class_id, vendor_id, product_id,
  626:                     product_name, speed);
  627:     return 0;
  628: }
  629: 
  630: void usb_host_info(Monitor *mon)
  631: {
  632:     usb_host_scan(mon, usb_host_info_device);
  633: }
  634: 
  635: /* XXX add this */
  636: int usb_host_device_close(const char *devname)
  637: {
  638:     return 0;
  639: }

unix.superglobalmegacorp.com