Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
branch: release-201303…
Fetching contributors…

Cannot retrieve contributors at this time

644 lines (550 sloc) 17.828 kb
/*
* 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, *ret = NULL;
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(NULL /* FIXME */, "usb-host");
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.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 struct USBDeviceInfo usb_host_dev_info = {
.product_desc = "USB Host Device",
.qdev.name = "usb-host",
.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(__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 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;
}
Jump to Line
Something went wrong with that request. Please try again.