Commit ce63e9c2 authored by Anthony Liguori's avatar Anthony Liguori
Browse files

Merge remote-tracking branch 'kraxel/usb.90' into staging 

# By Hans de Goede (6) and Gerd Hoffmann (1)
# Via Gerd Hoffmann
* kraxel/usb.90:
  usb: Fix iovec memleak on combined-packet free
  usb: Also reset max_packet_size on ep_reset
  xhci: Fix memory leak on xhci_disable_ep
  xhci: Add xhci_epid_to_usbep helper function
  xhci: Init a transfers xhci, slotid and epid member on epctx alloc
  xhci: Fix number of streams allocated when using streams
  usb: remove old usb-host code

Message-id: 1379583298-7524-1-git-send-email-kraxel@redhat.com
parents f54c49e2 0ca6db4f

configure

+4 −22
Original line number Diff line number Diff line
@@ -562,7 +562,6 @@ Haiku) 
  audio_possible_drivers="oss alsa sdl esd pa"

  linux="yes"

  linux_user="yes"

  usb="linux"

  kvm="yes"

  vhost_net="yes"

  vhost_scsi="yes"
@@ -575,9 +574,6 @@ esac 


if [ "$bsd" = "yes" ] ; then

  if [ "$darwin" != "yes" ] ; then

    if [ "$targetos" != "FreeBSD" ]; then

      usb="bsd"

    fi

    bsd_user="yes"

  fi

fi
@@ -3126,7 +3122,6 @@ fi 
if test "$libusb" != "no" ; then

    if $pkg_config --atleast-version=1.0.13 libusb-1.0; then

        libusb="yes"

	usb="libusb"

        libusb_cflags=$($pkg_config --cflags libusb-1.0)

        libusb_libs=$($pkg_config --libs libusb-1.0)

        QEMU_CFLAGS="$QEMU_CFLAGS $libusb_cflags"
@@ -4166,24 +4161,11 @@ if test "$virtio_blk_data_plane" = "yes" ; then 
fi



# USB host support

case "$usb" in

linux)

  echo "HOST_USB=linux legacy" >> $config_host_mak

;;

bsd)

  echo "HOST_USB=bsd" >> $config_host_mak

;;

libusb)

  if test "$linux" = "yes"; then

    echo "HOST_USB=libusb linux legacy" >> $config_host_mak

  else

if test "$libusb" = "yes"; then

  echo "HOST_USB=libusb legacy" >> $config_host_mak

  fi

;;

*)

else

  echo "HOST_USB=stub" >> $config_host_mak

;;

esac

fi



# TPM passthrough support?

if test "$tpm" = "yes"; then

hw/usb/combined-packet.c

+1 −0
Original line number Diff line number Diff line
@@ -39,6 +39,7 @@ static void usb_combined_packet_remove(USBCombinedPacket *combined, 
    p->combined = NULL;

    QTAILQ_REMOVE(&combined->packets, p, combined_entry);

    if (QTAILQ_EMPTY(&combined->packets)) {

        qemu_iovec_destroy(&combined->iov);

        g_free(combined);

    }

}

hw/usb/core.c

+3 −0
Original line number Diff line number Diff line
@@ -622,6 +622,7 @@ void usb_ep_reset(USBDevice *dev) 
    dev->ep_ctl.nr = 0;

    dev->ep_ctl.type = USB_ENDPOINT_XFER_CONTROL;

    dev->ep_ctl.ifnum = 0;

    dev->ep_ctl.max_packet_size = 64;

    dev->ep_ctl.dev = dev;

    dev->ep_ctl.pipeline = false;

    for (ep = 0; ep < USB_MAX_ENDPOINTS; ep++) {
@@ -633,6 +634,8 @@ void usb_ep_reset(USBDevice *dev) 
        dev->ep_out[ep].type = USB_ENDPOINT_XFER_INVALID;

        dev->ep_in[ep].ifnum = USB_INTERFACE_INVALID;

        dev->ep_out[ep].ifnum = USB_INTERFACE_INVALID;

        dev->ep_in[ep].max_packet_size = 0;

        dev->ep_out[ep].max_packet_size = 0;

        dev->ep_in[ep].dev = dev;

        dev->ep_out[ep].dev = dev;

        dev->ep_in[ep].pipeline = false;

hw/usb/hcd-xhci.c

+31 −14
Original line number Diff line number Diff line
@@ -509,6 +509,8 @@ static TRBCCode xhci_disable_ep(XHCIState *xhci, unsigned int slotid, 
                                unsigned int epid);

static void xhci_event(XHCIState *xhci, XHCIEvent *event, int v);

static void xhci_write_event(XHCIState *xhci, XHCIEvent *event, int v);

static USBEndpoint *xhci_epid_to_usbep(XHCIState *xhci,

                                       unsigned int slotid, unsigned int epid);



static const char *TRBType_names[] = {

    [TRB_RESERVED]                     = "TRB_RESERVED",
@@ -1138,7 +1140,7 @@ static void xhci_reset_streams(XHCIEPContext *epctx) 
static void xhci_alloc_streams(XHCIEPContext *epctx, dma_addr_t base)

{

    assert(epctx->pstreams == NULL);

    epctx->nr_pstreams = 2 << epctx->max_pstreams;

    epctx->nr_pstreams = 2 << (epctx->max_pstreams + 1);

    epctx->pstreams = xhci_alloc_stream_contexts(epctx->nr_pstreams, base);

}
@@ -1245,6 +1247,9 @@ static XHCIEPContext *xhci_alloc_epctx(XHCIState *xhci, 
    epctx->epid = epid;



    for (i = 0; i < ARRAY_SIZE(epctx->transfers); i++) {

        epctx->transfers[i].xhci = xhci;

        epctx->transfers[i].slotid = slotid;

        epctx->transfers[i].epid = epid;

        usb_packet_init(&epctx->transfers[i].packet);

    }

    epctx->kick_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL, xhci_ep_kick_timer, epctx);
@@ -1358,13 +1363,12 @@ static int xhci_ep_nuke_xfers(XHCIState *xhci, unsigned int slotid, 


    xferi = epctx->next_xfer;

    for (i = 0; i < TD_QUEUE; i++) {

        if (epctx->transfers[xferi].packet.ep) {

            ep = epctx->transfers[xferi].packet.ep;

        }

        killed += xhci_ep_nuke_one_xfer(&epctx->transfers[xferi]);

        epctx->transfers[xferi].packet.ep = NULL;

        xferi = (xferi + 1) % TD_QUEUE;

    }



    ep = xhci_epid_to_usbep(xhci, slotid, epid);

    if (ep) {

        usb_device_ep_stopped(ep->dev, ep);

    }
@@ -1376,6 +1380,7 @@ static TRBCCode xhci_disable_ep(XHCIState *xhci, unsigned int slotid, 
{

    XHCISlot *slot;

    XHCIEPContext *epctx;

    int i;



    trace_usb_xhci_ep_disable(slotid, epid);

    assert(slotid >= 1 && slotid <= xhci->numslots);
@@ -1396,6 +1401,10 @@ static TRBCCode xhci_disable_ep(XHCIState *xhci, unsigned int slotid, 
        xhci_free_streams(epctx);

    }



    for (i = 0; i < ARRAY_SIZE(epctx->transfers); i++) {

        usb_packet_cleanup(&epctx->transfers[i].packet);

    }



    xhci_set_ep_state(xhci, epctx, NULL, EP_DISABLED);



    timer_free(epctx->kick_timer);
@@ -1696,7 +1705,6 @@ static int xhci_submit(XHCIState *xhci, XHCITransfer *xfer, 
static int xhci_setup_packet(XHCITransfer *xfer)

{

    XHCIState *xhci = xfer->xhci;

    USBDevice *dev;

    USBEndpoint *ep;

    int dir;
@@ -1704,15 +1712,13 @@ static int xhci_setup_packet(XHCITransfer *xfer) 


    if (xfer->packet.ep) {

        ep = xfer->packet.ep;

        dev = ep->dev;

    } else {

        if (!xhci->slots[xfer->slotid-1].uport) {

        ep = xhci_epid_to_usbep(xhci, xfer->slotid, xfer->epid);

        if (!ep) {

            fprintf(stderr, "xhci: slot %d has no device\n",

                    xfer->slotid);

            return -1;

        }

        dev = xhci->slots[xfer->slotid-1].uport->dev;

        ep = usb_ep_get(dev, dir, xfer->epid >> 1);

    }



    xhci_xfer_create_sgl(xfer, dir == USB_TOKEN_IN); /* Also sets int_req */
@@ -1720,7 +1726,7 @@ static int xhci_setup_packet(XHCITransfer *xfer) 
                     xfer->trbs[0].addr, false, xfer->int_req);

    usb_packet_map(&xfer->packet, &xfer->sgl);

    DPRINTF("xhci: setup packet pid 0x%x addr %d ep %d\n",

            xfer->packet.pid, dev->addr, ep->nr);

            xfer->packet.pid, ep->dev->addr, ep->nr);

    return 0;

}
@@ -2060,9 +2066,6 @@ static void xhci_kick_ep(XHCIState *xhci, unsigned int slotid, 
        for (i = 0; i < length; i++) {

            assert(xhci_ring_fetch(xhci, ring, &xfer->trbs[i], NULL));

        }

        xfer->xhci = xhci;

        xfer->epid = epid;

        xfer->slotid = slotid;

        xfer->streamid = streamid;



        if (epid == 1) {
@@ -2075,7 +2078,6 @@ static void xhci_kick_ep(XHCIState *xhci, unsigned int slotid, 
        } else {

            if (xhci_fire_transfer(xhci, xfer, epctx) >= 0) {

                epctx->next_xfer = (epctx->next_xfer + 1) % TD_QUEUE;

                ep = xfer->packet.ep;

            } else {

                if (!xfer->timed_xfer) {

                    fprintf(stderr, "xhci: error firing data transfer\n");
@@ -2092,6 +2094,8 @@ static void xhci_kick_ep(XHCIState *xhci, unsigned int slotid, 
            break;

        }

    }



    ep = xhci_epid_to_usbep(xhci, slotid, epid);

    if (ep) {

        usb_device_flush_ep_queue(ep->dev, ep);

    }
@@ -3321,6 +3325,19 @@ static int xhci_find_epid(USBEndpoint *ep) 
    }

}



static USBEndpoint *xhci_epid_to_usbep(XHCIState *xhci,

                                       unsigned int slotid, unsigned int epid)

{

    assert(slotid >= 1 && slotid <= xhci->numslots);



    if (!xhci->slots[slotid - 1].uport) {

        return NULL;

    }



    return usb_ep_get(xhci->slots[slotid - 1].uport->dev,

                      (epid & 1) ? USB_TOKEN_IN : USB_TOKEN_OUT, epid >> 1);

}



static void xhci_wakeup_endpoint(USBBus *bus, USBEndpoint *ep,

                                 unsigned int stream)

{

hw/usb/host-bsd.c

deleted100644 → 0
+0 −639
Original line number Diff line number Diff line 
/*

 * BSD host USB redirector

 *

 * Copyright (c) 2006 Lonnie Mendez

 * Portions of code and concepts borrowed from

 * usb-linux.c and libusb's bsd.c and are copyright their respective owners.

 *

 * Permission is hereby granted, free of charge, to any person obtaining a copy

 * of this software and associated documentation files (the "Software"), to deal

 * in the Software without restriction, including without limitation the rights

 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

 * copies of the Software, and to permit persons to whom the Software is

 * furnished to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be included in

 * all copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

 * THE SOFTWARE.

 */



#include "qemu-common.h"

#include "monitor/monitor.h"

#include "hw/usb.h"



/* usb.h declares these */

#undef USB_SPEED_HIGH

#undef USB_SPEED_FULL

#undef USB_SPEED_LOW



#include <sys/ioctl.h>

#ifndef __DragonFly__

#include <dev/usb/usb.h>

#else

#include <bus/usb/usb.h>

#endif



/* This value has maximum potential at 16.

 * You should also set hw.usb.debug to gain

 * more detailed view.

 */

//#define DEBUG

#define UGEN_DEBUG_LEVEL 0





typedef int USBScanFunc(void *opaque, int bus_num, int addr, int class_id,

                        int vendor_id, int product_id,

                        const char *product_name, int speed);

static int usb_host_find_device(int *pbus_num, int *paddr,

                                const char *devname);



typedef struct USBHostDevice {

    USBDevice dev;

    int ep_fd[USB_MAX_ENDPOINTS];

    int devfd;

    char devpath[32];

} USBHostDevice;





static int ensure_ep_open(USBHostDevice *dev, int ep, int mode)

{

    char buf[32];

    int fd;



    /* Get the address for this endpoint */

    ep = UE_GET_ADDR(ep);



    if (dev->ep_fd[ep] < 0) {

#if defined(__FreeBSD__) || defined(__DragonFly__)

        snprintf(buf, sizeof(buf) - 1, "%s.%d", dev->devpath, ep);

#else

        snprintf(buf, sizeof(buf) - 1, "%s.%02d", dev->devpath, ep);

#endif

        /* Try to open it O_RDWR first for those devices which have in and out

         * endpoints with the same address (eg 0x02 and 0x82)

         */

        fd = open(buf, O_RDWR);

        if (fd < 0 && errno == ENXIO)

            fd = open(buf, mode);

        if (fd < 0) {

#ifdef DEBUG

            printf("ensure_ep_open: failed to open device endpoint %s: %s\n",

                   buf, strerror(errno));

#endif

        }

        dev->ep_fd[ep] = fd;

    }



    return dev->ep_fd[ep];

}



static void ensure_eps_closed(USBHostDevice *dev)

{

    int epnum = 1;



    if (!dev)

        return;



    while (epnum < USB_MAX_ENDPOINTS) {

        if (dev->ep_fd[epnum] >= 0) {

            close(dev->ep_fd[epnum]);

            dev->ep_fd[epnum] = -1;

        }

        epnum++;

    }

}



static void usb_host_handle_reset(USBDevice *dev)

{

#if 0

    USBHostDevice *s = (USBHostDevice *)dev;

#endif

}



/* XXX:

 * -check device states against transfer requests

 *  and return appropriate response

 */

static void usb_host_handle_control(USBDevice *dev,

                                   USBPacket *p,

                                   int request,

                                   int value,

                                   int index,

                                   int length,

                                   uint8_t *data)

{

    USBHostDevice *s = (USBHostDevice *)dev;

    struct usb_ctl_request req;

    struct usb_alt_interface aiface;

    int ret, timeout = 50;



    if ((request >> 8) == UT_WRITE_DEVICE &&

        (request & 0xff) == UR_SET_ADDRESS) {



        /* specific SET_ADDRESS support */

        dev->addr = value;

    } else if ((request >> 8) == UT_WRITE_DEVICE &&

               (request & 0xff) == UR_SET_CONFIG) {



        ensure_eps_closed(s); /* can't do this without all eps closed */



        ret = ioctl(s->devfd, USB_SET_CONFIG, &value);

        if (ret < 0) {

#ifdef DEBUG

            printf("handle_control: failed to set configuration - %s\n",

                   strerror(errno));

#endif

            p->status = USB_RET_STALL;

        }

    } else if ((request >> 8) == UT_WRITE_INTERFACE &&

               (request & 0xff) == UR_SET_INTERFACE) {



        aiface.uai_interface_index = index;

        aiface.uai_alt_no = value;



        ensure_eps_closed(s); /* can't do this without all eps closed */

        ret = ioctl(s->devfd, USB_SET_ALTINTERFACE, &aiface);

        if (ret < 0) {

#ifdef DEBUG

            printf("handle_control: failed to set alternate interface - %s\n",

                   strerror(errno));

#endif

            p->status = USB_RET_STALL;

        }

    } else {

        req.ucr_request.bmRequestType = request >> 8;

        req.ucr_request.bRequest = request & 0xff;

        USETW(req.ucr_request.wValue, value);

        USETW(req.ucr_request.wIndex, index);

        USETW(req.ucr_request.wLength, length);

        req.ucr_data = data;

        req.ucr_flags = USBD_SHORT_XFER_OK;



        ret = ioctl(s->devfd, USB_SET_TIMEOUT, &timeout);

#if defined(__NetBSD__) || defined(__OpenBSD__)

        if (ret < 0 && errno != EINVAL) {

#else

        if (ret < 0) {

#endif

#ifdef DEBUG

            printf("handle_control: setting timeout failed - %s\n",

                   strerror(errno));

#endif

        }



        ret = ioctl(s->devfd, USB_DO_REQUEST, &req);

        /* ugen returns EIO for usbd_do_request_ no matter what

         * happens with the transfer */

        if (ret < 0) {

#ifdef DEBUG

            printf("handle_control: error after request - %s\n",

                   strerror(errno));

#endif

            p->status = USB_RET_NAK; /* STALL */

        } else {

            p->actual_length = req.ucr_actlen;

        }

    }

}



static void usb_host_handle_data(USBDevice *dev, USBPacket *p)

{

    USBHostDevice *s = (USBHostDevice *)dev;

    int ret, fd, mode;

    int one = 1, shortpacket = 0, timeout = 50;

    sigset_t new_mask, old_mask;

    uint8_t devep = p->ep->nr;



    /* protect data transfers from SIGALRM signal */

    sigemptyset(&new_mask);

    sigaddset(&new_mask, SIGALRM);

    sigprocmask(SIG_BLOCK, &new_mask, &old_mask);



    if (p->pid == USB_TOKEN_IN) {

        devep |= 0x80;

        mode = O_RDONLY;

        shortpacket = 1;

    } else {

        mode = O_WRONLY;

    }



    fd = ensure_ep_open(s, devep, mode);

    if (fd < 0) {

        sigprocmask(SIG_SETMASK, &old_mask, NULL);

        p->status = USB_RET_NODEV;

        return;

    }



    if (ioctl(fd, USB_SET_TIMEOUT, &timeout) < 0) {

#ifdef DEBUG

        printf("handle_data: failed to set timeout - %s\n",

               strerror(errno));

#endif

    }



    if (shortpacket) {

        if (ioctl(fd, USB_SET_SHORT_XFER, &one) < 0) {

#ifdef DEBUG

            printf("handle_data: failed to set short xfer mode - %s\n",

                   strerror(errno));

#endif

            sigprocmask(SIG_SETMASK, &old_mask, NULL);

        }

    }



    if (p->pid == USB_TOKEN_IN)

        ret = readv(fd, p->iov.iov, p->iov.niov);

    else

        ret = writev(fd, p->iov.iov, p->iov.niov);



    sigprocmask(SIG_SETMASK, &old_mask, NULL);



    if (ret < 0) {

#ifdef DEBUG

        printf("handle_data: error after %s data - %s\n",

               pid == USB_TOKEN_IN ? "reading" : "writing", strerror(errno));

#endif

        switch(errno) {

        case ETIMEDOUT:

        case EINTR:

            p->status = USB_RET_NAK;

            break;

        default:

            p->status = USB_RET_STALL;

        }

    } else {

        p->actual_length = ret;

    }

}



static void usb_host_handle_destroy(USBDevice *opaque)

{

    USBHostDevice *s = (USBHostDevice *)opaque;

    int i;



    for (i = 0; i < USB_MAX_ENDPOINTS; i++)

        if (s->ep_fd[i] >= 0)

            close(s->ep_fd[i]);



    if (s->devfd < 0)

        return;



    close(s->devfd);



    g_free(s);

}



static int usb_host_initfn(USBDevice *dev)

{

    dev->flags |= (1 << USB_DEV_FLAG_IS_HOST);

    return 0;

}



USBDevice *usb_host_device_open(USBBus *guest_bus, const char *devname)

{

    struct usb_device_info bus_info, dev_info;

    USBDevice *d = NULL, *ret = NULL;

    USBHostDevice *dev;

    char ctlpath[PATH_MAX + 1];

    char buspath[PATH_MAX + 1];

    int bfd, dfd, bus, address, i;

    int ugendebug = UGEN_DEBUG_LEVEL;



    if (usb_host_find_device(&bus, &address, devname) < 0) {

        goto fail;

    }



    snprintf(buspath, PATH_MAX, "/dev/usb%d", bus);



    bfd = open(buspath, O_RDWR);

    if (bfd < 0) {

#ifdef DEBUG

        printf("usb_host_device_open: failed to open usb bus - %s\n",

               strerror(errno));

#endif

        goto fail;

    }



    bus_info.udi_addr = address;

    if (ioctl(bfd, USB_DEVICEINFO, &bus_info) < 0) {

#ifdef DEBUG

        printf("usb_host_device_open: failed to grab bus information - %s\n",

               strerror(errno));

#endif

        goto fail_bfd;

    }



#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)

    snprintf(ctlpath, PATH_MAX, "/dev/%s", bus_info.udi_devnames[0]);

#else

    snprintf(ctlpath, PATH_MAX, "/dev/%s.00", bus_info.udi_devnames[0]);

#endif



    dfd  = open(ctlpath, O_RDWR);

    if (dfd < 0) {

        dfd = open(ctlpath, O_RDONLY);

        if (dfd < 0) {

#ifdef DEBUG

            printf("usb_host_device_open: failed to open usb device %s - %s\n",

                   ctlpath, strerror(errno));

#endif

        }

        goto fail_dfd;

    }



    if (ioctl(dfd, USB_GET_DEVICEINFO, &dev_info) < 0) {

#ifdef DEBUG

        printf("usb_host_device_open: failed to grab device info - %s\n",

               strerror(errno));

#endif

        goto fail_dfd;

    }



    d = usb_create(guest_bus, "usb-host");

    dev = DO_UPCAST(USBHostDevice, dev, d);



    if (dev_info.udi_speed == 1) {

        dev->dev.speed = USB_SPEED_LOW - 1;

        dev->dev.speedmask = USB_SPEED_MASK_LOW;

    } else {

        dev->dev.speed = USB_SPEED_FULL - 1;

        dev->dev.speedmask = USB_SPEED_MASK_FULL;

    }



    if (strncmp(dev_info.udi_product, "product", 7) != 0) {

        pstrcpy(dev->dev.product_desc, sizeof(dev->dev.product_desc),

                dev_info.udi_product);

    } else {

        snprintf(dev->dev.product_desc, sizeof(dev->dev.product_desc),

                 "host:%s", devname);

    }



    pstrcpy(dev->devpath, sizeof(dev->devpath), "/dev/");

    pstrcat(dev->devpath, sizeof(dev->devpath), dev_info.udi_devnames[0]);



    /* Mark the endpoints as not yet open */

    for (i = 0; i < USB_MAX_ENDPOINTS; i++) {

        dev->ep_fd[i] = -1;

    }



    ioctl(dfd, USB_SETDEBUG, &ugendebug);



    ret = (USBDevice *)dev;



fail_dfd:

    close(dfd);

fail_bfd:

    close(bfd);

fail:

    return ret;

}



static void usb_host_class_initfn(ObjectClass *klass, void *data)

{

    USBDeviceClass *uc = USB_DEVICE_CLASS(klass);



    uc->product_desc   = "USB Host Device";

    uc->init           = usb_host_initfn;

    uc->handle_reset   = usb_host_handle_reset;

    uc->handle_control = usb_host_handle_control;

    uc->handle_data    = usb_host_handle_data;

    uc->handle_destroy = usb_host_handle_destroy;

}



static const TypeInfo usb_host_dev_info = {

    .name          = "usb-host",

    .parent        = TYPE_USB_DEVICE,

    .instance_size = sizeof(USBHostDevice),

    .class_init    = usb_host_class_initfn,

};



static void usb_host_register_types(void)

{

    type_register_static(&usb_host_dev_info);

}



type_init(usb_host_register_types)



static int usb_host_scan(void *opaque, USBScanFunc *func)

{

    struct usb_device_info bus_info;

    struct usb_device_info dev_info;

    uint16_t vendor_id, product_id, class_id, speed;

    int bfd, dfd, bus, address;

    char busbuf[20], devbuf[20], product_name[256];

    int ret = 0;



    for (bus = 0; bus < 10; bus++) {



        snprintf(busbuf, sizeof(busbuf) - 1, "/dev/usb%d", bus);

        bfd = open(busbuf, O_RDWR);

        if (bfd < 0)

	    continue;



        for (address = 1; address < 127; address++) {



            bus_info.udi_addr = address;

            if (ioctl(bfd, USB_DEVICEINFO, &bus_info) < 0)

                continue;



            /* only list devices that can be used by generic layer */

            if (strncmp(bus_info.udi_devnames[0], "ugen", 4) != 0)

                continue;



#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)

            snprintf(devbuf, sizeof(devbuf) - 1, "/dev/%s", bus_info.udi_devnames[0]);

#else

            snprintf(devbuf, sizeof(devbuf) - 1, "/dev/%s.00", bus_info.udi_devnames[0]);

#endif



            dfd = open(devbuf, O_RDONLY);

            if (dfd < 0) {

#ifdef DEBUG

                printf("usb_host_scan: couldn't open device %s - %s\n", devbuf,

                       strerror(errno));

#endif

                continue;

            }



            if (ioctl(dfd, USB_GET_DEVICEINFO, &dev_info) < 0)

                printf("usb_host_scan: couldn't get device information for %s - %s\n",

                       devbuf, strerror(errno));



            /* XXX: might need to fixup endianness of word values before copying over */



            vendor_id = dev_info.udi_vendorNo;

            product_id = dev_info.udi_productNo;

            class_id = dev_info.udi_class;

            speed = dev_info.udi_speed;



            if (strncmp(dev_info.udi_product, "product", 7) != 0)

                pstrcpy(product_name, sizeof(product_name),

                        dev_info.udi_product);

            else

                product_name[0] = '\0';



            ret = func(opaque, bus, address, class_id, vendor_id,

                       product_id, product_name, speed);



            close(dfd);



            if (ret)

                goto the_end;

        }



        close(bfd);

    }



the_end:

    return ret;

}



typedef struct FindDeviceState {

    int vendor_id;

    int product_id;

    int bus_num;

    int addr;

} FindDeviceState;



static int usb_host_find_device_scan(void *opaque, int bus_num, int addr,

                                     int class_id,

                                     int vendor_id, int product_id,

                                     const char *product_name, int speed)

{

    FindDeviceState *s = opaque;

    if (vendor_id == s->vendor_id &&

        product_id == s->product_id) {

        s->bus_num = bus_num;

        s->addr = addr;

        return 1;

     } else {

        return 0;

     }

}





/* the syntax is :

   'bus.addr' (decimal numbers) or

   'vendor_id:product_id' (hexa numbers) */

static int usb_host_find_device(int *pbus_num, int *paddr,

                                const char *devname)

{

    const char *p;

    int ret;

    FindDeviceState fs;



    p = strchr(devname, '.');

    if (p) {

        *pbus_num = strtoul(devname, NULL, 0);

        *paddr = strtoul(p + 1, NULL, 0);

        return 0;

    }

    p = strchr(devname, ':');

    if (p) {

        fs.vendor_id = strtoul(devname, NULL, 16);

        fs.product_id = strtoul(p + 1, NULL, 16);

        ret = usb_host_scan(&fs, usb_host_find_device_scan);

        if (ret) {

            *pbus_num = fs.bus_num;

            *paddr = fs.addr;

            return 0;

        }

     }

     return -1;

}



/**********************/

/* USB host device info */



struct usb_class_info {

    int class;

    const char *class_name;

};



static const struct usb_class_info usb_class_info[] = {

    { USB_CLASS_AUDIO, "Audio"},

    { USB_CLASS_COMM, "Communication"},

    { USB_CLASS_HID, "HID"},

    { USB_CLASS_HUB, "Hub" },

    { USB_CLASS_PHYSICAL, "Physical" },

    { USB_CLASS_PRINTER, "Printer" },

    { USB_CLASS_MASS_STORAGE, "Storage" },

    { USB_CLASS_CDC_DATA, "Data" },

    { USB_CLASS_APP_SPEC, "Application Specific" },

    { USB_CLASS_VENDOR_SPEC, "Vendor Specific" },

    { USB_CLASS_STILL_IMAGE, "Still Image" },

    { USB_CLASS_CSCID, "Smart Card" },

    { USB_CLASS_CONTENT_SEC, "Content Security" },

    { -1, NULL }

};



static const char *usb_class_str(uint8_t class)

{

    const struct usb_class_info *p;

    for (p = usb_class_info; p->class != -1; p++) {

        if (p->class == class)

            break;

    }

    return p->class_name;

}



static void usb_info_device(Monitor *mon, int bus_num, int addr, int class_id,

                            int vendor_id, int product_id,

                            const char *product_name,

                            int speed)

{

    const char *class_str, *speed_str;



    switch(speed) {

    case USB_SPEED_LOW:

        speed_str = "1.5";

        break;

    case USB_SPEED_FULL:

        speed_str = "12";

        break;

    case USB_SPEED_HIGH:

        speed_str = "480";

        break;

    default:

        speed_str = "?";

        break;

    }



    monitor_printf(mon, "  Device %d.%d, speed %s Mb/s\n",

                   bus_num, addr, speed_str);

    class_str = usb_class_str(class_id);

    if (class_str)

        monitor_printf(mon, "    %s:", class_str);

    else

        monitor_printf(mon, "    Class %02x:", class_id);

    monitor_printf(mon, " USB device %04x:%04x", vendor_id, product_id);

    if (product_name[0] != '\0')

        monitor_printf(mon, ", %s", product_name);

    monitor_printf(mon, "\n");

}



static int usb_host_info_device(void *opaque,

                                int bus_num, int addr,

                                int class_id,

                                int vendor_id, int product_id,

                                const char *product_name,

                                int speed)

{

    Monitor *mon = opaque;



    usb_info_device(mon, bus_num, addr, class_id, vendor_id, product_id,

                    product_name, speed);

    return 0;

}



void usb_host_info(Monitor *mon, const QDict *qdict)

{

    usb_host_scan(mon, usb_host_info_device);

}