[qemu.git] / usb-bsd.c

/*
 * 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.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 int 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;
        return 0;
    } 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
            return USB_RET_STALL;
        }

        return 0;
    } 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
            return USB_RET_STALL;
        }

        return 0;
    } 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
            return USB_RET_NAK; // STALL
        } else {
            return req.ucr_actlen;
        }
    }
}

static int 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);
        return USB_RET_NODEV;
    }

    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:
            return USB_RET_NAK;
        default:
            return USB_RET_STALL;
        }
    } else {
        return 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)
{
    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 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)
{
    usb_host_scan(mon, usb_host_info_device);
}

/* XXX add this */
int usb_host_device_close(const char *devname)
{
    return 0;
}
Commit	Line	Data
68063649 BS	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"
0b8a988c	28	#include "monitor.h"
68063649 BS	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>
c5e97233	37	#ifndef __DragonFly__
68063649	38	#include <dev/usb/usb.h>
c5e97233 BS	39	#else
	40	#include <bus/usb/usb.h>
	41	#endif
68063649 BS	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) {
c5e97233	74	#if defined(__FreeBSD__) \|\| defined(__DragonFly__)
68063649 BS	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,
007fd62f	125	USBPacket *p,
68063649 BS	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);
00766a4e	185	#if defined(__NetBSD__) \|\| defined(__OpenBSD__)
68063649 BS	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;
079d0b7f	217	uint8_t devep = p->ep->nr;
68063649 BS	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)
4f4321c1	256	ret = readv(fd, p->iov.iov, p->iov.niov);
68063649	257	else
4f4321c1	258	ret = writev(fd, p->iov.iov, p->iov.niov);
68063649 BS	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
7267c094	293	g_free(s);
68063649 BS	294	}
68063649 BS	295
620150dc BS	296	static int usb_host_initfn(USBDevice *dev)
	297	{
	298	return 0;
	299	}
	300
3741715c	301	USBDevice usb_host_device_open(USBBus guest_bus, const char *devname)
68063649 BS	302	{
68063649 BS	303	struct usb_device_info bus_info, dev_info;
fa57ee8e GH	304	USBDevice d = NULL, ret = NULL;
fa57ee8e GH	305	USBHostDevice *dev;
68063649 BS	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
1a20a032 BS	311	if (usb_host_find_device(&bus, &address, devname) < 0) {
	312	goto fail;
	313	}
68063649 BS	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
1a20a032	323	goto fail;
68063649 BS	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
1a20a032	332	goto fail_bfd;
68063649 BS	333	}
68063649 BS	334
a167ba50	335	#if defined(__FreeBSD__) \|\| defined(__FreeBSD_kernel__) \|\| defined(__DragonFly__)
68063649 BS	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	}
1a20a032	350	goto fail_dfd;
68063649 BS	351	}
68063649 BS	352
1a20a032	353	if (ioctl(dfd, USB_GET_DEVICEINFO, &dev_info) < 0) {
68063649	354	#ifdef DEBUG
1a20a032 BS	355	printf("usb_host_device_open: failed to grab device info - %s\n",
1a20a032 BS	356	strerror(errno));
68063649	357	#endif
1a20a032 BS	358	goto fail_dfd;
1a20a032 BS	359	}
68063649	360
3741715c	361	d = usb_create(guest_bus, "usb-host");
1a20a032	362	dev = DO_UPCAST(USBHostDevice, dev, d);
620150dc	363
1a20a032 BS	364	if (dev_info.udi_speed == 1) {
1a20a032 BS	365	dev->dev.speed = USB_SPEED_LOW - 1;
ba3f9bfb	366	dev->dev.speedmask = USB_SPEED_MASK_LOW;
1a20a032 BS	367	} else {
1a20a032 BS	368	dev->dev.speed = USB_SPEED_FULL - 1;
ba3f9bfb	369	dev->dev.speedmask = USB_SPEED_MASK_FULL;
1a20a032	370	}
68063649	371
1a20a032 BS	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	}
68063649	379
1a20a032 BS	380	pstrcpy(dev->devpath, sizeof(dev->devpath), "/dev/");
1a20a032 BS	381	pstrcat(dev->devpath, sizeof(dev->devpath), dev_info.udi_devnames[0]);
68063649	382
1a20a032 BS	383	/* Mark the endpoints as not yet open */
	384	for (i = 0; i < USB_MAX_ENDPOINTS; i++) {
	385	dev->ep_fd[i] = -1;
	386	}
68063649	387
1a20a032	388	ioctl(dfd, USB_SETDEBUG, &ugendebug);
68063649	389
1a20a032	390	ret = (USBDevice *)dev;
68063649	391
1a20a032 BS	392	fail_dfd:
	393	close(dfd);
	394	fail_bfd:
	395	close(bfd);
68063649	396	fail:
1a20a032	397	return ret;
68063649 BS	398	}
68063649 BS	399
62aed765 AL	400	static void usb_host_class_initfn(ObjectClass klass, void data)
	401	{
	402	USBDeviceClass *uc = USB_DEVICE_CLASS(klass);
	403
	404	uc->product_desc = "USB Host Device";
	405	uc->init = usb_host_initfn;
62aed765 AL	406	uc->handle_reset = usb_host_handle_reset;
	407	uc->handle_control = usb_host_handle_control;
	408	uc->handle_data = usb_host_handle_data;
	409	uc->handle_destroy = usb_host_handle_destroy;
	410	}
	411
d217d208 AL	412	static TypeInfo usb_host_dev_info = {
	413	.name = "usb-host",
	414	.parent = TYPE_USB_DEVICE,
	415	.instance_size = sizeof(USBHostDevice),
53a19a30	416	.class_init = usb_host_class_initfn,
620150dc BS	417	};
620150dc BS	418
83f7d43a	419	static void usb_host_register_types(void)
620150dc	420	{
d217d208	421	type_register_static(&usb_host_dev_info);
620150dc	422	}
83f7d43a AF	423
83f7d43a AF	424	type_init(usb_host_register_types)
620150dc	425
68063649 BS	426	static int usb_host_scan(void opaque, USBScanFunc func)
	427	{
	428	struct usb_device_info bus_info;
	429	struct usb_device_info dev_info;
	430	uint16_t vendor_id, product_id, class_id, speed;
	431	int bfd, dfd, bus, address;
	432	char busbuf[20], devbuf[20], product_name[256];
	433	int ret = 0;
	434
	435	for (bus = 0; bus < 10; bus++) {
	436
	437	snprintf(busbuf, sizeof(busbuf) - 1, "/dev/usb%d", bus);
	438	bfd = open(busbuf, O_RDWR);
	439	if (bfd < 0)
	440	continue;
	441
	442	for (address = 1; address < 127; address++) {
	443
	444	bus_info.udi_addr = address;
	445	if (ioctl(bfd, USB_DEVICEINFO, &bus_info) < 0)
	446	continue;
	447
	448	/* only list devices that can be used by generic layer */
	449	if (strncmp(bus_info.udi_devnames[0], "ugen", 4) != 0)
	450	continue;
	451
a167ba50	452	#if defined(__FreeBSD__) \|\| defined(__FreeBSD_kernel__) \|\| defined(__DragonFly__)
68063649 BS	453	snprintf(devbuf, sizeof(devbuf) - 1, "/dev/%s", bus_info.udi_devnames[0]);
	454	#else
	455	snprintf(devbuf, sizeof(devbuf) - 1, "/dev/%s.00", bus_info.udi_devnames[0]);
	456	#endif
	457
	458	dfd = open(devbuf, O_RDONLY);
	459	if (dfd < 0) {
	460	#ifdef DEBUG
	461	printf("usb_host_scan: couldn't open device %s - %s\n", devbuf,
	462	strerror(errno));
	463	#endif
	464	continue;
	465	}
	466
	467	if (ioctl(dfd, USB_GET_DEVICEINFO, &dev_info) < 0)
	468	printf("usb_host_scan: couldn't get device information for %s - %s\n",
	469	devbuf, strerror(errno));
	470
4ff9786c	471	/* XXX: might need to fixup endianness of word values before copying over */
68063649 BS	472
	473	vendor_id = dev_info.udi_vendorNo;
	474	product_id = dev_info.udi_productNo;
	475	class_id = dev_info.udi_class;
	476	speed = dev_info.udi_speed;
	477
	478	if (strncmp(dev_info.udi_product, "product", 7) != 0)
	479	pstrcpy(product_name, sizeof(product_name),
	480	dev_info.udi_product);
	481	else
	482	product_name[0] = '\0';
	483
	484	ret = func(opaque, bus, address, class_id, vendor_id,
	485	product_id, product_name, speed);
	486
	487	close(dfd);
	488
	489	if (ret)
	490	goto the_end;
	491	}
	492
	493	close(bfd);
	494	}
	495
	496	the_end:
	497	return ret;
	498	}
	499
	500	typedef struct FindDeviceState {
	501	int vendor_id;
	502	int product_id;
	503	int bus_num;
	504	int addr;
	505	} FindDeviceState;
	506
	507	static int usb_host_find_device_scan(void *opaque, int bus_num, int addr,
	508	int class_id,
	509	int vendor_id, int product_id,
	510	const char *product_name, int speed)
	511	{
	512	FindDeviceState *s = opaque;
	513	if (vendor_id == s->vendor_id &&
	514	product_id == s->product_id) {
	515	s->bus_num = bus_num;
	516	s->addr = addr;
	517	return 1;
	518	} else {
	519	return 0;
	520	}
	521	}
	522
	523
	524	/* the syntax is :
	525	'bus.addr' (decimal numbers) or
	526	'vendor_id:product_id' (hexa numbers) */
	527	static int usb_host_find_device(int pbus_num, int paddr,
	528	const char *devname)
	529	{
	530	const char *p;
	531	int ret;
	532	FindDeviceState fs;
	533
	534	p = strchr(devname, '.');
	535	if (p) {
536	*pbus_num = strtoul(devname, NULL, 0);
537	*paddr = strtoul(p + 1, NULL, 0);
538	return 0;
539	}
540	p = strchr(devname, ':');
541	if (p) {
542	fs.vendor_id = strtoul(devname, NULL, 16);
543	fs.product_id = strtoul(p + 1, NULL, 16);
544	ret = usb_host_scan(&fs, usb_host_find_device_scan);
545	if (ret) {
546	*pbus_num = fs.bus_num;
547	*paddr = fs.addr;
548	return 0;
549	}
550	}
551	return -1;
552	}
553
554	/**********************/
555	/* USB host device info */
556
557	struct usb_class_info {
558	int class;
559	const char *class_name;
560	};
561
562	static const struct usb_class_info usb_class_info[] = {
563	{ USB_CLASS_AUDIO, "Audio"},
564	{ USB_CLASS_COMM, "Communication"},
565	{ USB_CLASS_HID, "HID"},
566	{ USB_CLASS_HUB, "Hub" },
567	{ USB_CLASS_PHYSICAL, "Physical" },
568	{ USB_CLASS_PRINTER, "Printer" },
569	{ USB_CLASS_MASS_STORAGE, "Storage" },
570	{ USB_CLASS_CDC_DATA, "Data" },
571	{ USB_CLASS_APP_SPEC, "Application Specific" },
572	{ USB_CLASS_VENDOR_SPEC, "Vendor Specific" },
573	{ USB_CLASS_STILL_IMAGE, "Still Image" },
574	{ USB_CLASS_CSCID, "Smart Card" },
575	{ USB_CLASS_CONTENT_SEC, "Content Security" },
576	{ -1, NULL }
577	};
578
579	static const char *usb_class_str(uint8_t class)
580	{
581	const struct usb_class_info *p;
582	for (p = usb_class_info; p->class != -1; p++) {
583	if (p->class == class)
584	break;
585	}
586	return p->class_name;
587	}
588
179da8af	589	static void usb_info_device(Monitor *mon, int bus_num, int addr, int class_id,
00766a4e BS	590	int vendor_id, int product_id,
	591	const char *product_name,
	592	int speed)
68063649 BS	593	{
	594	const char class_str, speed_str;
	595
	596	switch(speed) {
	597	case USB_SPEED_LOW:
	598	speed_str = "1.5";
	599	break;
	600	case USB_SPEED_FULL:
	601	speed_str = "12";
	602	break;
	603	case USB_SPEED_HIGH:
	604	speed_str = "480";
	605	break;
	606	default:
	607	speed_str = "?";
	608	break;
	609	}
	610
376253ec AL	611	monitor_printf(mon, " Device %d.%d, speed %s Mb/s\n",
376253ec AL	612	bus_num, addr, speed_str);
68063649 BS	613	class_str = usb_class_str(class_id);
68063649 BS	614	if (class_str)
376253ec	615	monitor_printf(mon, " %s:", class_str);
68063649	616	else
376253ec AL	617	monitor_printf(mon, " Class %02x:", class_id);
376253ec AL	618	monitor_printf(mon, " USB device %04x:%04x", vendor_id, product_id);
68063649	619	if (product_name[0] != '\0')
376253ec AL	620	monitor_printf(mon, ", %s", product_name);
376253ec AL	621	monitor_printf(mon, "\n");
68063649 BS	622	}
68063649 BS	623
376253ec AL	624	static int usb_host_info_device(void *opaque,
376253ec AL	625	int bus_num, int addr,
68063649 BS	626	int class_id,
	627	int vendor_id, int product_id,
	628	const char *product_name,
	629	int speed)
	630	{
179da8af BS	631	Monitor *mon = opaque;
	632
	633	usb_info_device(mon, bus_num, addr, class_id, vendor_id, product_id,
68063649 BS	634	product_name, speed);
	635	return 0;
	636	}
	637
376253ec	638	void usb_host_info(Monitor *mon)
68063649	639	{
179da8af	640	usb_host_scan(mon, usb_host_info_device);
68063649 BS	641	}
	642
	643	/* XXX add this */
	644	int usb_host_device_close(const char *devname)
	645	{
	646	return 0;
	647	}