ShuriZma
/
xemu
mirror of https://github.com/xemu-project/xemu.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

usb-host: use qdev for -usbdevice + rework. 

Changes:

 * We don't create/delete devices, we attach/detach them instead.
 * The separate autofilter list is gone, we simply walk the list
   of devices directly instead.
 * Autofiltering is done unconditionally now.  Non-auto device scan
   code got dropped.
 * Autofiltering turns off the timer if there is nothing to do, it
   runs only in case there are unattached host devices.

Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
This commit is contained in:
Gerd Hoffmann 2009-10-26 15:56:50 +01:00 committed by Anthony Liguori
parent b3e461d3d6
commit 26a9e82ac4
1 changed files with 144 additions and 266 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

410
usb-linux.c
View File

@ -64,10 +64,8 @@ struct usb_ctrlrequest {
typedef int USBScanFunc(void *opaque, int bus_num, int addr, int class_id, typedef int USBScanFunc(void *opaque, int bus_num, int addr, int class_id,
int vendor_id, int product_id, int vendor_id, int product_id,
const char *product_name, int speed); const char *product_name, int speed);
static int usb_host_find_device(int *pbus_num, int *paddr,
char *product_name, int product_name_size, #define DEBUG
const char *devname);
//#define DEBUG
#ifdef DEBUG #ifdef DEBUG
#define dprintf printf #define dprintf printf
@ -118,6 +116,13 @@ struct ctrl_struct {
uint8_t buffer[2048]; uint8_t buffer[2048];
}; };
struct USBAutoFilter {
uint32_t bus_num;
uint32_t addr;
uint32_t vendor_id;
uint32_t product_id;
};
typedef struct USBHostDevice { typedef struct USBHostDevice {
USBDevice dev; USBDevice dev;
int fd; int fd;
@ -134,10 +139,17 @@ typedef struct USBHostDevice {
/* Host side address */ /* Host side address */
int bus_num; int bus_num;
int addr; int addr;
struct USBAutoFilter match;
struct USBHostDevice *next; QTAILQ_ENTRY(USBHostDevice) next;
} USBHostDevice; } 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) static int is_isoc(USBHostDevice *s, int ep)
{ {
return s->endp_table[ep - 1].type == USBDEVFS_URB_TYPE_ISO; return s->endp_table[ep - 1].type == USBDEVFS_URB_TYPE_ISO;
@ -158,41 +170,6 @@ static void set_halt(USBHostDevice *s, int ep)
s->endp_table[ep - 1].halted = 1; s->endp_table[ep - 1].halted = 1;
} }
static USBHostDevice *hostdev_list;
static void hostdev_link(USBHostDevice *dev)
{
dev->next = hostdev_list;
hostdev_list = dev;
}
static void hostdev_unlink(USBHostDevice *dev)
{
USBHostDevice *pdev = hostdev_list;
USBHostDevice **prev = &hostdev_list;
while (pdev) {
if (pdev == dev) {
*prev = dev->next;
return;
}
prev = &pdev->next;
pdev = pdev->next;
}
}
static USBHostDevice *hostdev_find(int bus_num, int addr)
{
USBHostDevice *s = hostdev_list;
while (s) {
if (s->bus_num == bus_num && s->addr == addr)
return s;
s = s->next;
}
return NULL;
}
/* /*
* Async URB state. * Async URB state.
* We always allocate one isoc descriptor even for bulk transfers * We always allocate one isoc descriptor even for bulk transfers
@ -252,7 +229,8 @@ static void async_complete(void *opaque)
if (errno == ENODEV && !s->closing) { if (errno == ENODEV && !s->closing) {
printf("husb: device %d.%d disconnected\n", s->bus_num, s->addr); printf("husb: device %d.%d disconnected\n", s->bus_num, s->addr);
usb_device_delete_addr(s->bus_num, s->dev.addr); usb_host_close(s);
usb_host_auto_check(NULL);
return; return;
} }
@ -407,7 +385,7 @@ static int usb_host_release_interfaces(USBHostDevice *s)
static void usb_host_handle_reset(USBDevice *dev) static void usb_host_handle_reset(USBDevice *dev)
{ {
USBHostDevice *s = (USBHostDevice *) dev; USBHostDevice *s = DO_UPCAST(USBHostDevice, dev, dev);
dprintf("husb: reset device %u.%u\n", s->bus_num, s->addr); dprintf("husb: reset device %u.%u\n", s->bus_num, s->addr);
@ -420,18 +398,8 @@ static void usb_host_handle_destroy(USBDevice *dev)
{ {
USBHostDevice *s = (USBHostDevice *)dev; USBHostDevice *s = (USBHostDevice *)dev;
s->closing = 1; usb_host_close(s);
QTAILQ_REMOVE(&hostdevs, s, next);
qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
hostdev_unlink(s);
async_complete(s);
if (s->fd >= 0)
close(s->fd);
qemu_free(s);
} }
static int usb_linux_update_endp_table(USBHostDevice *s); static int usb_linux_update_endp_table(USBHostDevice *s);
@ -891,19 +859,16 @@ static int usb_linux_update_endp_table(USBHostDevice *s)
return 0; return 0;
} }
static int usb_host_initfn(USBDevice *dev) static int usb_host_open(USBHostDevice *dev, int bus_num,
{ int addr, const char *prod_name)
return 0;
}
static USBDevice *usb_host_device_open_addr(int bus_num, int addr, const char *prod_name)
{ {
int fd = -1, ret; int fd = -1, ret;
USBDevice *d = NULL;
USBHostDevice *dev;
struct usbdevfs_connectinfo ci; struct usbdevfs_connectinfo ci;
char buf[1024]; char buf[1024];
if (dev->fd != -1)
goto fail;
printf("husb: open device %d.%d\n", bus_num, addr); printf("husb: open device %d.%d\n", bus_num, addr);
if (!usb_host_device_path) { if (!usb_host_device_path) {
@ -919,9 +884,6 @@ static USBDevice *usb_host_device_open_addr(int bus_num, int addr, const char *p
} }
dprintf("husb: opened %s\n", buf); dprintf("husb: opened %s\n", buf);
d = usb_create(NULL /* FIXME */, "USB Host Device");
dev = DO_UPCAST(USBHostDevice, dev, d);
dev->bus_num = bus_num; dev->bus_num = bus_num;
dev->addr = addr; dev->addr = addr;
dev->fd = fd; dev->fd = fd;
@ -980,32 +942,59 @@ static USBDevice *usb_host_device_open_addr(int bus_num, int addr, const char *p
/* USB devio uses 'write' flag to check for async completions */ /* USB devio uses 'write' flag to check for async completions */
qemu_set_fd_handler(dev->fd, NULL, async_complete, dev); qemu_set_fd_handler(dev->fd, NULL, async_complete, dev);
hostdev_link(dev); usb_device_attach(&dev->dev);
return 0;
if (qdev_init(&d->qdev) < 0)
goto fail_no_qdev;
return (USBDevice *) dev;
fail: fail:
if (d) dev->fd = -1;
qdev_free(&d->qdev);
fail_no_qdev:
if (fd != -1) if (fd != -1)
close(fd); close(fd);
return NULL; return -1;
}
static int usb_host_close(USBHostDevice *dev)
{
if (dev->fd == -1)
return -1;
qemu_set_fd_handler(dev->fd, NULL, NULL, NULL);
dev->closing = 1;
async_complete(dev);
dev->closing = 0;
usb_device_detach(&dev->dev);
close(dev->fd);
dev->fd = -1;
return 0;
}
static int usb_host_initfn(USBDevice *dev)
{
USBHostDevice *s = DO_UPCAST(USBHostDevice, dev, dev);
dev->auto_attach = 0;
s->fd = -1;
QTAILQ_INSERT_TAIL(&hostdevs, s, next);
usb_host_auto_check(NULL);
return 0;
} }
static struct USBDeviceInfo usb_host_dev_info = { static struct USBDeviceInfo usb_host_dev_info = {
.qdev.name = "USB Host Device", .qdev.name = "USB Host Device",
.qdev.alias = "usb-host",
.qdev.size = sizeof(USBHostDevice), .qdev.size = sizeof(USBHostDevice),
.init = usb_host_initfn, .init = usb_host_initfn,
.handle_packet = usb_host_handle_packet, .handle_packet = usb_host_handle_packet,
.handle_reset = usb_host_handle_reset, .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, .handle_destroy = usb_host_handle_destroy,
.usbdevice_name = "host",
.usbdevice_init = usb_host_device_open,
.qdev.props = (Property[]) {
DEFINE_PROP_UINT32("hostbus", USBHostDevice, match.bus_num, 0),
DEFINE_PROP_UINT32("hostaddr", USBHostDevice, match.addr, 0),
DEFINE_PROP_HEX32("vendorid", USBHostDevice, match.vendor_id, 0),
DEFINE_PROP_HEX32("productid", USBHostDevice, match.product_id, 0),
DEFINE_PROP_END_OF_LIST(),
},
}; };
static void usb_host_register_devices(void) static void usb_host_register_devices(void)
@ -1014,35 +1003,46 @@ static void usb_host_register_devices(void)
} }
device_init(usb_host_register_devices) device_init(usb_host_register_devices)
static int usb_host_auto_add(const char *spec);
static int usb_host_auto_del(const char *spec);
USBDevice *usb_host_device_open(const char *devname) USBDevice *usb_host_device_open(const char *devname)
{ {
Monitor *mon = cur_mon; struct USBAutoFilter filter = { 0, 0, 0, 0 };
int bus_num, addr; USBDevice *dev;
char product_name[PRODUCT_NAME_SZ]; USBHostDevice *s;
char *p;
dev = usb_create(NULL /* FIXME */, "USB Host Device");
s = DO_UPCAST(USBHostDevice, dev, dev);
if (strstr(devname, "auto:")) { if (strstr(devname, "auto:")) {
usb_host_auto_add(devname); if (parse_filter(devname+5, &filter) < 0)
return NULL; goto fail;
} else {
if ((p = strchr(devname, '.'))) {
filter.bus_num = strtoul(devname, NULL, 0);
filter.addr = strtoul(devname, NULL, 0);
} else if ((p = strchr(devname, ':'))) {
filter.vendor_id = strtoul(devname, NULL, 16);
filter.product_id = strtoul(devname, NULL, 16);
} else {
goto fail;
}
} }
if (usb_host_find_device(&bus_num, &addr, product_name, sizeof(product_name), qdev_prop_set_uint32(&dev->qdev, "bus", filter.bus_num);
devname) < 0) qdev_prop_set_uint32(&dev->qdev, "addr", filter.addr);
return NULL; qdev_prop_set_uint32(&dev->qdev, "vendorid", filter.vendor_id);
qdev_prop_set_uint32(&dev->qdev, "productid", filter.product_id);
qdev_init(&dev->qdev);
return dev;
if (hostdev_find(bus_num, addr)) { fail:
monitor_printf(mon, "husb: host usb device %d.%d is already open\n", qdev_free(&dev->qdev);
bus_num, addr); return NULL;
return NULL;
}
return usb_host_device_open_addr(bus_num, addr, product_name);
} }
int usb_host_device_close(const char *devname) int usb_host_device_close(const char *devname)
{ {
#if 0
char product_name[PRODUCT_NAME_SZ]; char product_name[PRODUCT_NAME_SZ];
int bus_num, addr; int bus_num, addr;
USBHostDevice *s; USBHostDevice *s;
@ -1059,6 +1059,7 @@ int usb_host_device_close(const char *devname)
usb_device_delete_addr(s->bus_num, s->dev.addr); usb_device_delete_addr(s->bus_num, s->dev.addr);
return 0; return 0;
} }
#endif
return -1; return -1;
} }
@ -1185,7 +1186,9 @@ static int usb_host_scan_dev(void *opaque, USBScanFunc *func)
*/ */
static int usb_host_read_file(char *line, size_t line_size, const char *device_file, const char *device_name) static int usb_host_read_file(char *line, size_t line_size, const char *device_file, const char *device_name)
{ {
#if 0
Monitor *mon = cur_mon; Monitor *mon = cur_mon;
#endif
FILE *f; FILE *f;
int ret = 0; int ret = 0;
char filename[PATH_MAX]; char filename[PATH_MAX];
@ -1197,8 +1200,10 @@ static int usb_host_read_file(char *line, size_t line_size, const char *device_f
fgets(line, line_size, f); fgets(line, line_size, f);
fclose(f); fclose(f);
ret = 1; ret = 1;
#if 0
} else { } else {
monitor_printf(mon, "husb: could not open %s\n", filename); monitor_printf(mon, "husb: could not open %s\n", filename);
#endif
} }
return ret; return ret;
@ -1356,58 +1361,72 @@ static int usb_host_scan(void *opaque, USBScanFunc *func)
return ret; return ret;
} }
struct USBAutoFilter {
struct USBAutoFilter *next;
int bus_num;
int addr;
int vendor_id;
int product_id;
};
static QEMUTimer *usb_auto_timer; static QEMUTimer *usb_auto_timer;
static struct USBAutoFilter *usb_auto_filter;
static int usb_host_auto_scan(void *opaque, int bus_num, int addr, static int usb_host_auto_scan(void *opaque, int bus_num, int addr,
int class_id, int vendor_id, int product_id, int class_id, int vendor_id, int product_id,
const char *product_name, int speed) const char *product_name, int speed)
{ {
struct USBAutoFilter *f; struct USBAutoFilter *f;
struct USBDevice *dev; struct USBHostDevice *s;
/* Ignore hubs */ /* Ignore hubs */
if (class_id == 9) if (class_id == 9)
return 0; return 0;
for (f = usb_auto_filter; f; f = f->next) { QTAILQ_FOREACH(s, &hostdevs, next) {
if (f->bus_num >= 0 && f->bus_num != bus_num) f = &s->match;
if (f->bus_num > 0 && f->bus_num != bus_num)
continue; continue;
if (f->addr >= 0 && f->addr != addr) if (f->addr > 0 && f->addr != addr)
continue; continue;
if (f->vendor_id >= 0 && f->vendor_id != vendor_id) if (f->vendor_id > 0 && f->vendor_id != vendor_id)
continue; continue;
if (f->product_id >= 0 && f->product_id != product_id) if (f->product_id > 0 && f->product_id != product_id)
continue; continue;
/* We got a match */ /* We got a match */
/* Already attached ? */ /* Already attached ? */
if (hostdev_find(bus_num, addr)) if (s->fd != -1)
return 0; return 0;
dprintf("husb: auto open: bus_num %d addr %d\n", bus_num, addr); dprintf("husb: auto open: bus_num %d addr %d\n", bus_num, addr);
dev = usb_host_device_open_addr(bus_num, addr, product_name); usb_host_open(s, bus_num, addr, product_name);
} }
return 0; return 0;
} }
static void usb_host_auto_timer(void *unused) static void usb_host_auto_check(void *unused)
{ {
struct USBHostDevice *s;
int unconnected = 0;
usb_host_scan(NULL, usb_host_auto_scan); usb_host_scan(NULL, usb_host_auto_scan);
QTAILQ_FOREACH(s, &hostdevs, next) {
if (s->fd == -1)
unconnected++;
}
if (unconnected == 0) {
/* nothing to watch */
if (usb_auto_timer)
qemu_del_timer(usb_auto_timer);
return;
}
if (!usb_auto_timer) {
usb_auto_timer = qemu_new_timer(rt_clock, usb_host_auto_check, NULL);
if (!usb_auto_timer)
return;
}
qemu_mod_timer(usb_auto_timer, qemu_get_clock(rt_clock) + 2000); qemu_mod_timer(usb_auto_timer, qemu_get_clock(rt_clock) + 2000);
} }
@ -1459,150 +1478,6 @@ static int parse_filter(const char *spec, struct USBAutoFilter *f)
return 0; return 0;
} }
static int match_filter(const struct USBAutoFilter *f1,
const struct USBAutoFilter *f2)
{
return f1->bus_num == f2->bus_num &&
f1->addr == f2->addr &&
f1->vendor_id == f2->vendor_id &&
f1->product_id == f2->product_id;
}
static int usb_host_auto_add(const char *spec)
{
struct USBAutoFilter filter, *f;
if (parse_filter(spec, &filter) < 0)
return -1;
f = qemu_mallocz(sizeof(*f));
*f = filter;
if (!usb_auto_filter) {
/*
* First entry. Init and start the monitor.
* Right now we're using timer to check for new devices.
* If this turns out to be too expensive we can move that into a
* separate thread.
*/
usb_auto_timer = qemu_new_timer(rt_clock, usb_host_auto_timer, NULL);
if (!usb_auto_timer) {
fprintf(stderr, "husb: failed to allocate auto scan timer\n");
qemu_free(f);
return -1;
}
/* Check for new devices every two seconds */
qemu_mod_timer(usb_auto_timer, qemu_get_clock(rt_clock) + 2000);
}
dprintf("husb: added auto filter: bus_num %d addr %d vid %d pid %d\n",
f->bus_num, f->addr, f->vendor_id, f->product_id);
f->next = usb_auto_filter;
usb_auto_filter = f;
return 0;
}
static int usb_host_auto_del(const char *spec)
{
struct USBAutoFilter *pf = usb_auto_filter;
struct USBAutoFilter **prev = &usb_auto_filter;
struct USBAutoFilter filter;
if (parse_filter(spec, &filter) < 0)
return -1;
while (pf) {
if (match_filter(pf, &filter)) {
dprintf("husb: removed auto filter: bus_num %d addr %d vid %d pid %d\n",
pf->bus_num, pf->addr, pf->vendor_id, pf->product_id);
*prev = pf->next;
if (!usb_auto_filter) {
/* No more filters. Stop scanning. */
qemu_del_timer(usb_auto_timer);
qemu_free_timer(usb_auto_timer);
}
return 0;
}
prev = &pf->next;
pf = pf->next;
}
return -1;
}
typedef struct FindDeviceState {
int vendor_id;
int product_id;
int bus_num;
int addr;
char product_name[PRODUCT_NAME_SZ];
} 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) ||
(bus_num == s->bus_num &&
addr == s->addr)) {
pstrcpy(s->product_name, PRODUCT_NAME_SZ, product_name);
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,
char *product_name, int product_name_size,
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);
fs.bus_num = *pbus_num;
fs.addr = *paddr;
ret = usb_host_scan(&fs, usb_host_find_device_scan);
if (ret)
pstrcpy(product_name, product_name_size, fs.product_name);
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;
pstrcpy(product_name, product_name_size, fs.product_name);
return 0;
}
}
return -1;
}
/**********************/ /**********************/
/* USB host device info */ /* USB host device info */
@ -1688,7 +1563,7 @@ static int usb_host_info_device(void *opaque, int bus_num, int addr,
static void dec2str(int val, char *str, size_t size) static void dec2str(int val, char *str, size_t size)
{ {
if (val == -1) if (val == 0)
snprintf(str, size, "*"); snprintf(str, size, "*");
else else
snprintf(str, size, "%d", val); snprintf(str, size, "%d", val);
@ -1696,22 +1571,25 @@ static void dec2str(int val, char *str, size_t size)
static void hex2str(int val, char *str, size_t size) static void hex2str(int val, char *str, size_t size)
{ {
if (val == -1) if (val == 0)
snprintf(str, size, "*"); snprintf(str, size, "*");
else else
snprintf(str, size, "%x", val); snprintf(str, size, "%04x", val);
} }
void usb_host_info(Monitor *mon) void usb_host_info(Monitor *mon)
{ {
struct USBAutoFilter *f; struct USBAutoFilter *f;
struct USBHostDevice *s;
usb_host_scan(mon, usb_host_info_device); usb_host_scan(mon, usb_host_info_device);
if (usb_auto_filter) if (QTAILQ_EMPTY(&hostdevs))
monitor_printf(mon, " Auto filters:\n"); return;
for (f = usb_auto_filter; f; f = f->next) { monitor_printf(mon, " Auto filters:\n");
QTAILQ_FOREACH(s, &hostdevs, next) {
char bus[10], addr[10], vid[10], pid[10]; char bus[10], addr[10], vid[10], pid[10];
f = &s->match;
dec2str(f->bus_num, bus, sizeof(bus)); dec2str(f->bus_num, bus, sizeof(bus));
dec2str(f->addr, addr, sizeof(addr)); dec2str(f->addr, addr, sizeof(addr));
hex2str(f->vendor_id, vid, sizeof(vid)); hex2str(f->vendor_id, vid, sizeof(vid));