636 lines
17 KiB
C
636 lines
17 KiB
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
|
|
#include <signal.h>
|
|
|
|
/* 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;
|
|
|
|
|
|
#if 0
|
|
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++;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
static void usb_host_handle_reset(USBDevice *dev)
|
|
{
|
|
#if 0
|
|
USBHostDevice *s = (USBHostDevice *)dev;
|
|
#endif
|
|
}
|
|
|
|
#if 0
|
|
/* XXX:
|
|
* -check device states against transfer requests
|
|
* and return appropriate response
|
|
*/
|
|
static int usb_host_handle_control(USBDevice *dev,
|
|
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->devep;
|
|
|
|
/* 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 = read(fd, p->data, p->len);
|
|
else
|
|
ret = write(fd, p->data, p->len);
|
|
|
|
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;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
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);
|
|
|
|
qemu_free(s);
|
|
}
|
|
|
|
static int usb_host_initfn(USBDevice *dev)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
USBDevice *usb_host_device_open(const char *devname)
|
|
{
|
|
struct usb_device_info bus_info, dev_info;
|
|
USBDevice *d = 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)
|
|
return NULL;
|
|
|
|
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
|
|
return NULL;
|
|
}
|
|
|
|
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
|
|
return NULL;
|
|
}
|
|
|
|
#if defined(__FreeBSD__) || 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
|
|
}
|
|
}
|
|
|
|
if (dfd >= 0) {
|
|
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;
|
|
}
|
|
|
|
d = usb_create(NULL /* FIXME */, "USB Host Device");
|
|
dev = DO_UPCAST(USBHostDevice, dev, d);
|
|
|
|
if (dev_info.udi_speed == 1)
|
|
dev->dev.speed = USB_SPEED_LOW - 1;
|
|
else
|
|
dev->dev.speed = USB_SPEED_FULL - 1;
|
|
|
|
if (strncmp(dev_info.udi_product, "product", 7) != 0)
|
|
pstrcpy(dev->dev.devname, sizeof(dev->dev.devname),
|
|
dev_info.udi_product);
|
|
else
|
|
snprintf(dev->dev.devname, sizeof(dev->dev.devname),
|
|
"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);
|
|
|
|
return (USBDevice *)dev;
|
|
}
|
|
|
|
fail:
|
|
return NULL;
|
|
}
|
|
|
|
static struct USBDeviceInfo usb_host_dev_info = {
|
|
.qdev.name = "USB Host Device",
|
|
.qdev.size = sizeof(USBHostDevice),
|
|
.init = usb_host_initfn,
|
|
.handle_packet = usb_generic_handle_packet,
|
|
.handle_reset = usb_host_handle_reset,
|
|
#if 0
|
|
.handle_control = usb_host_handle_control,
|
|
.handle_data = usb_host_handle_data,
|
|
#endif
|
|
.handle_destroy = usb_host_handle_destroy,
|
|
};
|
|
|
|
static void usb_host_register_devices(void)
|
|
{
|
|
usb_qdev_register(&usb_host_dev_info);
|
|
}
|
|
device_init(usb_host_register_devices)
|
|
|
|
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(__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 endianess 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;
|
|
}
|