Archipelago » qemu

/*

 * Linux host USB redirector

 *

 * Copyright (c) 2005 Fabrice Bellard

 *

 * Copyright (c) 2008 Max Krasnyansky

 *      Support for host device auto connect & disconnect

 *      Major rewrite to support fully async operation

 *

 * Copyright 2008 TJ <linux@tjworld.net>

 *      Added flexible support for /dev/bus/usb /sys/bus/usb/devices in addition

 *      to the legacy /proc/bus/usb USB device discovery and handling

 *

 * 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 "qemu-timer.h"

#include "monitor.h"

#include "sysemu.h"

#include <dirent.h>

#include <sys/ioctl.h>

#include <signal.h>

#include <linux/usbdevice_fs.h>

#include <linux/version.h>

#include "hw/usb.h"

/* We redefine it to avoid version problems */

struct usb_ctrltransfer {

    uint8_t  bRequestType;

    uint8_t  bRequest;

    uint16_t wValue;

    uint16_t wIndex;

    uint16_t wLength;

    uint32_t timeout;

    void *data;

};

struct usb_ctrlrequest {

    uint8_t bRequestType;

    uint8_t bRequest;

    uint16_t wValue;

    uint16_t wIndex;

    uint16_t wLength;

};

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

                        int class_id, int vendor_id, int product_id,

                        const char *product_name, int speed);

//#define DEBUG

#ifdef DEBUG

#define DPRINTF printf

#else

#define DPRINTF(...)

#endif

#define USBDBG_DEVOPENED "husb: opened %s/devices\n"

#define USBPROCBUS_PATH "/proc/bus/usb"

#define PRODUCT_NAME_SZ 32

#define MAX_ENDPOINTS 16

#define USBDEVBUS_PATH "/dev/bus/usb"

#define USBSYSBUS_PATH "/sys/bus/usb"

static char *usb_host_device_path;

#define USB_FS_NONE 0

#define USB_FS_PROC 1

#define USB_FS_DEV 2

#define USB_FS_SYS 3

static int usb_fs_type;

/* endpoint association data */

struct endp_data {

    uint8_t type;

    uint8_t halted;

};

enum {

    CTRL_STATE_IDLE = 0,

    CTRL_STATE_SETUP,

    CTRL_STATE_DATA,

    CTRL_STATE_ACK

};

/*

 * Control transfer state.

 * Note that 'buffer' _must_ follow 'req' field because

 * we need contigious buffer when we submit control URB.

 */

struct ctrl_struct {

    uint16_t len;

    uint16_t offset;

    uint8_t  state;

    struct   usb_ctrlrequest req;

    uint8_t  buffer[8192];

};

struct USBAutoFilter {

    uint32_t bus_num;

    uint32_t addr;

    uint32_t vendor_id;

    uint32_t product_id;

};

typedef struct USBHostDevice {

    USBDevice dev;

    int       fd;

    uint8_t   descr[1024];

    int       descr_len;

    int       configuration;

    int       ninterfaces;

    int       closing;

    Notifier  exit;

    struct ctrl_struct ctrl;

    struct endp_data endp_table[MAX_ENDPOINTS];

    /* Host side address */

    int bus_num;

    int addr;

    int devpath;

    struct USBAutoFilter match;

    QTAILQ_ENTRY(USBHostDevice) next;

} USBHostDevice;

static QTAILQ_HEAD(, USBHostDevice) hostdevs = QTAILQ_HEAD_INITIALIZER(hostdevs);

static int usb_host_close(USBHostDevice *dev);

static int parse_filter(const char *spec, struct USBAutoFilter *f);

static void usb_host_auto_check(void *unused);

static int is_isoc(USBHostDevice *s, int ep)

{

    return s->endp_table[ep - 1].type == USBDEVFS_URB_TYPE_ISO;

}

static int is_halted(USBHostDevice *s, int ep)

{

    return s->endp_table[ep - 1].halted;

}

static void clear_halt(USBHostDevice *s, int ep)

{

    s->endp_table[ep - 1].halted = 0;

}

static void set_halt(USBHostDevice *s, int ep)

{

    s->endp_table[ep - 1].halted = 1;

}

/*

 * Async URB state.

 * We always allocate one isoc descriptor even for bulk transfers

 * to simplify allocation and casts.

 */

typedef struct AsyncURB

{

    struct usbdevfs_urb urb;

    struct usbdevfs_iso_packet_desc isocpd;

    USBPacket     *packet;

    USBHostDevice *hdev;

} AsyncURB;

static AsyncURB *async_alloc(void)

{

    return (AsyncURB *) qemu_mallocz(sizeof(AsyncURB));

}

static void async_free(AsyncURB *aurb)

{

    qemu_free(aurb);

}

static void async_complete_ctrl(USBHostDevice *s, USBPacket *p)

{

    switch(s->ctrl.state) {

    case CTRL_STATE_SETUP:

        if (p->len < s->ctrl.len)

            s->ctrl.len = p->len;

        s->ctrl.state = CTRL_STATE_DATA;

        p->len = 8;

        break;

    case CTRL_STATE_ACK:

        s->ctrl.state = CTRL_STATE_IDLE;

        p->len = 0;

        break;

    default:

        break;

    }

}

static void async_complete(void *opaque)

{

    USBHostDevice *s = opaque;

    AsyncURB *aurb;

    while (1) {

        USBPacket *p;

        int r = ioctl(s->fd, USBDEVFS_REAPURBNDELAY, &aurb);

        if (r < 0) {

            if (errno == EAGAIN) {

                return;

            }

            if (errno == ENODEV && !s->closing) {

                printf("husb: device %d.%d disconnected\n",

                       s->bus_num, s->addr);

                usb_host_close(s);

                usb_host_auto_check(NULL);

                return;

            }

            DPRINTF("husb: async. reap urb failed errno %d\n", errno);

            return;

        }

        p = aurb->packet;

        DPRINTF("husb: async completed. aurb %p status %d alen %d\n",

                aurb, aurb->urb.status, aurb->urb.actual_length);

        if (p) {

            switch (aurb->urb.status) {

            case 0:

                p->len = aurb->urb.actual_length;

                if (aurb->urb.type == USBDEVFS_URB_TYPE_CONTROL) {

                    async_complete_ctrl(s, p);

                }

                break;

            case -EPIPE:

                set_halt(s, p->devep);

                p->len = USB_RET_STALL;

                break;

            default:

                p->len = USB_RET_NAK;

                break;

            }

            usb_packet_complete(p);

        }

        async_free(aurb);

    }

}

static void async_cancel(USBPacket *unused, void *opaque)

{

    AsyncURB *aurb = opaque;

    USBHostDevice *s = aurb->hdev;

    DPRINTF("husb: async cancel. aurb %p\n", aurb);

    /* Mark it as dead (see async_complete above) */

    aurb->packet = NULL;

    int r = ioctl(s->fd, USBDEVFS_DISCARDURB, aurb);

    if (r < 0) {

        DPRINTF("husb: async. discard urb failed errno %d\n", errno);

    }

}

static int usb_host_claim_interfaces(USBHostDevice *dev, int configuration)

{

    int dev_descr_len, config_descr_len;

    int interface, nb_interfaces;

    int ret, i;

    if (configuration == 0) /* address state - ignore */

        return 1;

    DPRINTF("husb: claiming interfaces. config %d\n", configuration);

    i = 0;

    dev_descr_len = dev->descr[0];

    if (dev_descr_len > dev->descr_len) {

        goto fail;

    }

    i += dev_descr_len;

    while (i < dev->descr_len) {

        DPRINTF("husb: i is %d, descr_len is %d, dl %d, dt %d\n",

                i, dev->descr_len,

               dev->descr[i], dev->descr[i+1]);

        if (dev->descr[i+1] != USB_DT_CONFIG) {

            i += dev->descr[i];

            continue;

        }

        config_descr_len = dev->descr[i];

        printf("husb: config #%d need %d\n", dev->descr[i + 5], configuration);

        if (configuration < 0 || configuration == dev->descr[i + 5]) {

            configuration = dev->descr[i + 5];

            break;

        }

        i += config_descr_len;

    }

    if (i >= dev->descr_len) {

        fprintf(stderr,

                "husb: update iface failed. no matching configuration\n");

        goto fail;

    }

    nb_interfaces = dev->descr[i + 4];

#ifdef USBDEVFS_DISCONNECT

    /* earlier Linux 2.4 do not support that */

    {

        struct usbdevfs_ioctl ctrl;

        for (interface = 0; interface < nb_interfaces; interface++) {

            ctrl.ioctl_code = USBDEVFS_DISCONNECT;

            ctrl.ifno = interface;

            ret = ioctl(dev->fd, USBDEVFS_IOCTL, &ctrl);

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

                perror("USBDEVFS_DISCONNECT");

                goto fail;

            }

        }

    }

#endif

    /* XXX: only grab if all interfaces are free */

    for (interface = 0; interface < nb_interfaces; interface++) {

        ret = ioctl(dev->fd, USBDEVFS_CLAIMINTERFACE, &interface);

        if (ret < 0) {

            if (errno == EBUSY) {

                printf("husb: update iface. device already grabbed\n");

            } else {

                perror("husb: failed to claim interface");

            }

        fail:

            return 0;

        }

    }

    printf("husb: %d interfaces claimed for configuration %d\n",

           nb_interfaces, configuration);

    dev->ninterfaces   = nb_interfaces;

    dev->configuration = configuration;

    return 1;

}

static int usb_host_release_interfaces(USBHostDevice *s)

{

    int ret, i;

    DPRINTF("husb: releasing interfaces\n");

    for (i = 0; i < s->ninterfaces; i++) {

        ret = ioctl(s->fd, USBDEVFS_RELEASEINTERFACE, &i);

        if (ret < 0) {

            perror("husb: failed to release interface");

            return 0;

        }

    }

    return 1;

}

static void usb_host_handle_reset(USBDevice *dev)

{

    USBHostDevice *s = DO_UPCAST(USBHostDevice, dev, dev);

    DPRINTF("husb: reset device %u.%u\n", s->bus_num, s->addr);

    ioctl(s->fd, USBDEVFS_RESET);

    usb_host_claim_interfaces(s, s->configuration);

}

static void usb_host_handle_destroy(USBDevice *dev)

{

    USBHostDevice *s = (USBHostDevice *)dev;

    usb_host_close(s);

    QTAILQ_REMOVE(&hostdevs, s, next);

    qemu_remove_exit_notifier(&s->exit);

}

static int usb_linux_update_endp_table(USBHostDevice *s);

static int usb_host_handle_data(USBHostDevice *s, USBPacket *p)

{

    struct usbdevfs_urb *urb;

    AsyncURB *aurb;

    int ret;

    aurb = async_alloc();

    aurb->hdev   = s;

    aurb->packet = p;

    urb = &aurb->urb;

    if (p->pid == USB_TOKEN_IN) {

        urb->endpoint = p->devep | 0x80;

    } else {

        urb->endpoint = p->devep;

    }

    if (is_halted(s, p->devep)) {

        ret = ioctl(s->fd, USBDEVFS_CLEAR_HALT, &urb->endpoint);

        if (ret < 0) {

            DPRINTF("husb: failed to clear halt. ep 0x%x errno %d\n",

                   urb->endpoint, errno);

            return USB_RET_NAK;

        }

        clear_halt(s, p->devep);

    }

    urb->buffer        = p->data;

    urb->buffer_length = p->len;

    if (is_isoc(s, p->devep)) {

        /* Setup ISOC transfer */

        urb->type     = USBDEVFS_URB_TYPE_ISO;

        urb->flags    = USBDEVFS_URB_ISO_ASAP;

        urb->number_of_packets = 1;

        urb->iso_frame_desc[0].length = p->len;

    } else {

        /* Setup bulk transfer */

        urb->type     = USBDEVFS_URB_TYPE_BULK;

    }

    urb->usercontext = s;

    ret = ioctl(s->fd, USBDEVFS_SUBMITURB, urb);

    DPRINTF("husb: data submit. ep 0x%x len %u aurb %p\n",

            urb->endpoint, p->len, aurb);

    if (ret < 0) {

        DPRINTF("husb: submit failed. errno %d\n", errno);

        async_free(aurb);

        switch(errno) {

        case ETIMEDOUT:

            return USB_RET_NAK;

        case EPIPE:

        default:

            return USB_RET_STALL;

        }

    }

    usb_defer_packet(p, async_cancel, aurb);

    return USB_RET_ASYNC;

}

static int ctrl_error(void)

{

    if (errno == ETIMEDOUT) {

        return USB_RET_NAK;

    } else {

        return USB_RET_STALL;

    }

}

static int usb_host_set_address(USBHostDevice *s, int addr)

{

    DPRINTF("husb: ctrl set addr %u\n", addr);

    s->dev.addr = addr;

    return 0;

}

static int usb_host_set_config(USBHostDevice *s, int config)

{

    usb_host_release_interfaces(s);

    int ret = ioctl(s->fd, USBDEVFS_SETCONFIGURATION, &config);

    DPRINTF("husb: ctrl set config %d ret %d errno %d\n", config, ret, errno);

    if (ret < 0) {

        return ctrl_error();

    }

    usb_host_claim_interfaces(s, config);

    return 0;

}

static int usb_host_set_interface(USBHostDevice *s, int iface, int alt)

{

    struct usbdevfs_setinterface si;

    int ret;

    si.interface  = iface;

    si.altsetting = alt;

    ret = ioctl(s->fd, USBDEVFS_SETINTERFACE, &si);

    DPRINTF("husb: ctrl set iface %d altset %d ret %d errno %d\n",

            iface, alt, ret, errno);

    if (ret < 0) {

        return ctrl_error();

    }

    usb_linux_update_endp_table(s);

    return 0;

}

static int usb_host_handle_control(USBHostDevice *s, USBPacket *p)

{

    struct usbdevfs_urb *urb;

    AsyncURB *aurb;

    int ret, value, index;

    int buffer_len;

    /*

     * Process certain standard device requests.

     * These are infrequent and are processed synchronously.

     */

    value = le16_to_cpu(s->ctrl.req.wValue);

    index = le16_to_cpu(s->ctrl.req.wIndex);

    DPRINTF("husb: ctrl type 0x%x req 0x%x val 0x%x index %u len %u\n",

            s->ctrl.req.bRequestType, s->ctrl.req.bRequest, value, index,

            s->ctrl.len);

    if (s->ctrl.req.bRequestType == 0) {

        switch (s->ctrl.req.bRequest) {

        case USB_REQ_SET_ADDRESS:

            return usb_host_set_address(s, value);

        case USB_REQ_SET_CONFIGURATION:

            return usb_host_set_config(s, value & 0xff);

        }

    }

    if (s->ctrl.req.bRequestType == 1 &&

                  s->ctrl.req.bRequest == USB_REQ_SET_INTERFACE) {

        return usb_host_set_interface(s, index, value);

    }

    /* The rest are asynchronous */

    buffer_len = 8 + s->ctrl.len;

    if (buffer_len > sizeof(s->ctrl.buffer)) {

        fprintf(stderr, "husb: ctrl buffer too small (%u > %zu)\n",

                buffer_len, sizeof(s->ctrl.buffer));

        return USB_RET_STALL;

    }

    aurb = async_alloc();

    aurb->hdev   = s;

    aurb->packet = p;

    /*

     * Setup ctrl transfer.

     *

     * s->ctrl is layed out such that data buffer immediately follows

     * 'req' struct which is exactly what usbdevfs expects.

     */

    urb = &aurb->urb;

    urb->type     = USBDEVFS_URB_TYPE_CONTROL;

    urb->endpoint = p->devep;

    urb->buffer        = &s->ctrl.req;

    urb->buffer_length = buffer_len;

    urb->usercontext = s;

    ret = ioctl(s->fd, USBDEVFS_SUBMITURB, urb);

    DPRINTF("husb: submit ctrl. len %u aurb %p\n", urb->buffer_length, aurb);

    if (ret < 0) {

        DPRINTF("husb: submit failed. errno %d\n", errno);

        async_free(aurb);

        switch(errno) {

        case ETIMEDOUT:

            return USB_RET_NAK;

        case EPIPE:

        default:

            return USB_RET_STALL;

        }

    }

    usb_defer_packet(p, async_cancel, aurb);

    return USB_RET_ASYNC;

}

static int do_token_setup(USBDevice *dev, USBPacket *p)

{

    USBHostDevice *s = (USBHostDevice *) dev;

    int ret = 0;

    if (p->len != 8) {

        return USB_RET_STALL;

    }

    memcpy(&s->ctrl.req, p->data, 8);

    s->ctrl.len    = le16_to_cpu(s->ctrl.req.wLength);

    s->ctrl.offset = 0;

    s->ctrl.state  = CTRL_STATE_SETUP;

    if (s->ctrl.req.bRequestType & USB_DIR_IN) {

        ret = usb_host_handle_control(s, p);

        if (ret < 0) {

            return ret;

        }

        if (ret < s->ctrl.len) {

            s->ctrl.len = ret;

        }

        s->ctrl.state = CTRL_STATE_DATA;

    } else {

        if (s->ctrl.len == 0) {

            s->ctrl.state = CTRL_STATE_ACK;

        } else {

            s->ctrl.state = CTRL_STATE_DATA;

        }

    }

    return ret;

}

static int do_token_in(USBDevice *dev, USBPacket *p)

{

    USBHostDevice *s = (USBHostDevice *) dev;

    int ret = 0;

    if (p->devep != 0) {

        return usb_host_handle_data(s, p);

    }

    switch(s->ctrl.state) {

    case CTRL_STATE_ACK:

        if (!(s->ctrl.req.bRequestType & USB_DIR_IN)) {

            ret = usb_host_handle_control(s, p);

            if (ret == USB_RET_ASYNC) {

                return USB_RET_ASYNC;

            }

            s->ctrl.state = CTRL_STATE_IDLE;

            return ret > 0 ? 0 : ret;

        }

        return 0;

    case CTRL_STATE_DATA:

        if (s->ctrl.req.bRequestType & USB_DIR_IN) {

            int len = s->ctrl.len - s->ctrl.offset;

            if (len > p->len) {

                len = p->len;

            }

            memcpy(p->data, s->ctrl.buffer + s->ctrl.offset, len);

            s->ctrl.offset += len;

            if (s->ctrl.offset >= s->ctrl.len) {

                s->ctrl.state = CTRL_STATE_ACK;

            }

            return len;

        }

        s->ctrl.state = CTRL_STATE_IDLE;

        return USB_RET_STALL;

    default:

        return USB_RET_STALL;

    }

}

static int do_token_out(USBDevice *dev, USBPacket *p)

{

    USBHostDevice *s = (USBHostDevice *) dev;

    if (p->devep != 0) {

        return usb_host_handle_data(s, p);

    }

    switch(s->ctrl.state) {

    case CTRL_STATE_ACK:

        if (s->ctrl.req.bRequestType & USB_DIR_IN) {

            s->ctrl.state = CTRL_STATE_IDLE;

            /* transfer OK */

        } else {

            /* ignore additional output */

        }

        return 0;

    case CTRL_STATE_DATA:

        if (!(s->ctrl.req.bRequestType & USB_DIR_IN)) {

            int len = s->ctrl.len - s->ctrl.offset;

            if (len > p->len) {

                len = p->len;

            }

            memcpy(s->ctrl.buffer + s->ctrl.offset, p->data, len);

            s->ctrl.offset += len;

            if (s->ctrl.offset >= s->ctrl.len) {

                s->ctrl.state = CTRL_STATE_ACK;

            }

            return len;

        }

        s->ctrl.state = CTRL_STATE_IDLE;

        return USB_RET_STALL;

    default:

        return USB_RET_STALL;

    }

}

/*

 * Packet handler.

 * Called by the HC (host controller).

 *

 * Returns length of the transaction or one of the USB_RET_XXX codes.

 */

static int usb_host_handle_packet(USBDevice *s, USBPacket *p)

{

    switch(p->pid) {

    case USB_MSG_ATTACH:

        s->state = USB_STATE_ATTACHED;

        return 0;

    case USB_MSG_DETACH:

        s->state = USB_STATE_NOTATTACHED;

        return 0;

    case USB_MSG_RESET:

        s->remote_wakeup = 0;

        s->addr = 0;

        s->state = USB_STATE_DEFAULT;

        s->info->handle_reset(s);

        return 0;

    }

    /* Rest of the PIDs must match our address */

    if (s->state < USB_STATE_DEFAULT || p->devaddr != s->addr) {

        return USB_RET_NODEV;

    }

    switch (p->pid) {

    case USB_TOKEN_SETUP:

        return do_token_setup(s, p);

    case USB_TOKEN_IN:

        return do_token_in(s, p);

    case USB_TOKEN_OUT:

        return do_token_out(s, p);

    default:

        return USB_RET_STALL;

    }

}

/* returns 1 on problem encountered or 0 for success */

static int usb_linux_update_endp_table(USBHostDevice *s)

{

    uint8_t *descriptors;

    uint8_t devep, type, configuration, alt_interface;

    struct usb_ctrltransfer ct;

    int interface, ret, length, i;

    ct.bRequestType = USB_DIR_IN;

    ct.bRequest = USB_REQ_GET_CONFIGURATION;

    ct.wValue = 0;

    ct.wIndex = 0;

    ct.wLength = 1;

    ct.data = &configuration;

    ct.timeout = 50;

    ret = ioctl(s->fd, USBDEVFS_CONTROL, &ct);

    if (ret < 0) {

        perror("usb_linux_update_endp_table");

        return 1;

    }

    /* in address state */

    if (configuration == 0) {

        return 1;

    }

    /* get the desired configuration, interface, and endpoint descriptors

     * from device description */

    descriptors = &s->descr[18];

    length = s->descr_len - 18;

    i = 0;

    if (descriptors[i + 1] != USB_DT_CONFIG ||

        descriptors[i + 5] != configuration) {

        DPRINTF("invalid descriptor data - configuration\n");

        return 1;

    }

    i += descriptors[i];

    while (i < length) {

        if (descriptors[i + 1] != USB_DT_INTERFACE ||

            (descriptors[i + 1] == USB_DT_INTERFACE &&

             descriptors[i + 4] == 0)) {

            i += descriptors[i];

            continue;

        }

        interface = descriptors[i + 2];

        ct.bRequestType = USB_DIR_IN | USB_RECIP_INTERFACE;

        ct.bRequest = USB_REQ_GET_INTERFACE;

        ct.wValue = 0;

        ct.wIndex = interface;

        ct.wLength = 1;

        ct.data = &alt_interface;

        ct.timeout = 50;

        ret = ioctl(s->fd, USBDEVFS_CONTROL, &ct);

        if (ret < 0) {

            alt_interface = interface;

        }

        /* the current interface descriptor is the active interface

         * and has endpoints */

        if (descriptors[i + 3] != alt_interface) {

            i += descriptors[i];

            continue;

        }

        /* advance to the endpoints */

        while (i < length && descriptors[i +1] != USB_DT_ENDPOINT) {

            i += descriptors[i];

        }

        if (i >= length)

            break;

        while (i < length) {

            if (descriptors[i + 1] != USB_DT_ENDPOINT) {

                break;

            }

            devep = descriptors[i + 2];

            switch (descriptors[i + 3] & 0x3) {

            case 0x00:

                type = USBDEVFS_URB_TYPE_CONTROL;

                break;

            case 0x01:

                type = USBDEVFS_URB_TYPE_ISO;

                break;

            case 0x02:

                type = USBDEVFS_URB_TYPE_BULK;

                break;

            case 0x03:

                type = USBDEVFS_URB_TYPE_INTERRUPT;

                break;

            default:

                DPRINTF("usb_host: malformed endpoint type\n");

                type = USBDEVFS_URB_TYPE_BULK;

            }

            s->endp_table[(devep & 0xf) - 1].type = type;

            s->endp_table[(devep & 0xf) - 1].halted = 0;

            i += descriptors[i];

        }

    }

    return 0;

}

static int usb_host_open(USBHostDevice *dev, int bus_num,

                         int addr, int devpath, const char *prod_name)

{

    int fd = -1, ret;

    struct usbdevfs_connectinfo ci;

    char buf[1024];

    if (dev->fd != -1) {

        goto fail;

    }

    printf("husb: open device %d.%d\n", bus_num, addr);