openkylin
/
qemu
mirror of https://gitee.com/openkylin/qemu.git
9
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge remote-tracking branch 'kraxel/usb.26' into staging

This commit is contained in:
Anthony Liguori 2011-09-08 08:57:33 -05:00
parent 63236c15e9 5b1cdb4ead
commit a60fce0bcc
13 changed files with 561 additions and 456 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
hw/tusb6010.c
View File

@ -771,13 +771,12 @@ static void tusb6010_reset(DeviceState *dev)
for (i = 0; i < 15; i++) {
s->rx_config[i] = s->tx_config[i] = 0;
}
musb_reset(s->musb);
}
static int tusb6010_init(SysBusDevice *dev)
{
TUSBState *s = FROM_SYSBUS(TUSBState, dev);
qemu_irq *musb_irqs;
int i;
s->otg_timer = qemu_new_timer_ns(vm_clock, tusb_otg_tick, s);
s->pwr_timer = qemu_new_timer_ns(vm_clock, tusb_power_tick, s);
memory_region_init_io(&s->iomem[1], &tusb_async_ops, s, "tusb-async",
@ -785,12 +784,8 @@ static int tusb6010_init(SysBusDevice *dev)
sysbus_init_mmio_region(dev, &s->iomem[0]);
sysbus_init_mmio_region(dev, &s->iomem[1]);
sysbus_init_irq(dev, &s->irq);
qdev_init_gpio_in(&dev->qdev, tusb6010_irq, __musb_irq_max + 1);
musb_irqs = g_new0(qemu_irq, __musb_irq_max);
for (i = 0; i < __musb_irq_max; i++) {
musb_irqs[i] = qdev_get_gpio_in(&dev->qdev, i + 1);
}
s->musb = musb_init(musb_irqs);
qdev_init_gpio_in(&dev->qdev, tusb6010_irq, musb_irq_max + 1);
s->musb = musb_init(&dev->qdev, 1);
return 0;
}

112
hw/usb-bus.c
View File

@ -3,6 +3,7 @@
#include "qdev.h"
#include "sysemu.h"
#include "monitor.h"
#include "trace.h"
static void usb_bus_dev_print(Monitor *mon, DeviceState *qdev, int indent);
@ -73,9 +74,13 @@ static int usb_qdev_init(DeviceState *qdev, DeviceInfo *base)
dev->info = info;
dev->auto_attach = 1;
QLIST_INIT(&dev->strings);
rc = dev->info->init(dev);
if (rc == 0 && dev->auto_attach)
rc = usb_claim_port(dev);
if (rc == 0) {
rc = dev->info->init(dev);
}
if (rc == 0 && dev->auto_attach) {
rc = usb_device_attach(dev);
}
return rc;
}
@ -89,6 +94,9 @@ static int usb_qdev_exit(DeviceState *qdev)
if (dev->info->handle_destroy) {
dev->info->handle_destroy(dev);
}
if (dev->port) {
usb_release_port(dev);
}
return 0;
}
@ -205,21 +213,13 @@ void usb_unregister_port(USBBus *bus, USBPort *port)
bus->nfree--;
}
static int do_attach(USBDevice *dev)
int usb_claim_port(USBDevice *dev)
{
USBBus *bus = usb_bus_from_device(dev);
USBPort *port;
if (dev->attached) {
error_report("Error: tried to attach usb device %s twice\n",
dev->product_desc);
return -1;
}
if (bus->nfree == 0) {
error_report("Error: tried to attach usb device %s to a bus with no free ports\n",
dev->product_desc);
return -1;
}
assert(dev->port == NULL);
if (dev->port_path) {
QTAILQ_FOREACH(port, &bus->free, next) {
if (strcmp(port->path, dev->port_path) == 0) {
@ -227,68 +227,86 @@ static int do_attach(USBDevice *dev)
}
}
if (port == NULL) {
error_report("Error: usb port %s (bus %s) not found\n",
dev->port_path, bus->qbus.name);
error_report("Error: usb port %s (bus %s) not found (in use?)\n",
dev->port_path, bus->qbus.name);
return -1;
}
} else {
if (bus->nfree == 1 && strcmp(dev->qdev.info->name, "usb-hub") != 0) {
/* Create a new hub and chain it on */
usb_create_simple(bus, "usb-hub");
}
if (bus->nfree == 0) {
error_report("Error: tried to attach usb device %s to a bus "
"with no free ports\n", dev->product_desc);
return -1;
}
port = QTAILQ_FIRST(&bus->free);
}
if (!(port->speedmask & dev->speedmask)) {
error_report("Warning: speed mismatch trying to attach usb device %s to bus %s\n",
dev->product_desc, bus->qbus.name);
return -1;
}
trace_usb_port_claim(bus->busnr, port->path);
dev->attached++;
QTAILQ_REMOVE(&bus->free, port, next);
bus->nfree--;
usb_attach(port, dev);
dev->port = port;
port->dev = dev;
QTAILQ_INSERT_TAIL(&bus->used, port, next);
bus->nused++;
return 0;
}
void usb_release_port(USBDevice *dev)
{
USBBus *bus = usb_bus_from_device(dev);
USBPort *port = dev->port;
assert(port != NULL);
trace_usb_port_release(bus->busnr, port->path);
QTAILQ_REMOVE(&bus->used, port, next);
bus->nused--;
dev->port = NULL;
port->dev = NULL;
QTAILQ_INSERT_TAIL(&bus->free, port, next);
bus->nfree++;
}
int usb_device_attach(USBDevice *dev)
{
USBBus *bus = usb_bus_from_device(dev);
USBPort *port = dev->port;
if (bus->nfree == 1 && dev->port_path == NULL) {
/* Create a new hub and chain it on
(unless a physical port location is specified). */
usb_create_simple(bus, "usb-hub");
assert(port != NULL);
assert(!dev->attached);
trace_usb_port_attach(bus->busnr, port->path);
if (!(port->speedmask & dev->speedmask)) {
error_report("Warning: speed mismatch trying to attach "
"usb device %s to bus %s\n",
dev->product_desc, bus->qbus.name);
return -1;
}
return do_attach(dev);
dev->attached++;
usb_attach(port);
return 0;
}
int usb_device_detach(USBDevice *dev)
{
USBBus *bus = usb_bus_from_device(dev);
USBPort *port;
USBPort *port = dev->port;
if (!dev->attached) {
error_report("Error: tried to detach unattached usb device %s\n",
dev->product_desc);
return -1;
}
dev->attached--;
QTAILQ_FOREACH(port, &bus->used, next) {
if (port->dev == dev)
break;
}
assert(port != NULL);
assert(dev->attached);
trace_usb_port_detach(bus->busnr, port->path);
QTAILQ_REMOVE(&bus->used, port, next);
bus->nused--;
usb_attach(port, NULL);
QTAILQ_INSERT_TAIL(&bus->free, port, next);
bus->nfree++;
usb_detach(port);
dev->attached--;
return 0;
}

244
hw/usb-ccid.c
View File

@ -37,6 +37,7 @@
#include "qemu-common.h"
#include "qemu-error.h"
#include "usb.h"
#include "usb-desc.h"
#include "monitor.h"
#include "hw/ccid.h"
@ -306,56 +307,7 @@ typedef struct USBCCIDState {
* 0dc3:1004 Athena Smartcard Solutions, Inc.
*/
static const uint8_t qemu_ccid_dev_descriptor[] = {
0x12, /* u8 bLength; */
USB_DT_DEVICE, /* u8 bDescriptorType; Device */
0x10, 0x01, /* u16 bcdUSB; v1.1 */
0x00, /* u8 bDeviceClass; */
0x00, /* u8 bDeviceSubClass; */
0x00, /* u8 bDeviceProtocol; [ low/full speeds only ] */
0x40, /* u8 bMaxPacketSize0; 8 Bytes (valid: 8,16,32,64) */
/* Vendor and product id are arbitrary. */
/* u16 idVendor */
CCID_VENDOR_ID & 0xff, CCID_VENDOR_ID >> 8,
/* u16 idProduct */
CCID_PRODUCT_ID & 0xff, CCID_PRODUCT_ID >> 8,
/* u16 bcdDevice */
CCID_DEVICE_VERSION & 0xff, CCID_DEVICE_VERSION >> 8,
0x01, /* u8 iManufacturer; */
0x02, /* u8 iProduct; */
0x03, /* u8 iSerialNumber; */
0x01, /* u8 bNumConfigurations; */
};
static const uint8_t qemu_ccid_config_descriptor[] = {
/* one configuration */
0x09, /* u8 bLength; */
USB_DT_CONFIG, /* u8 bDescriptorType; Configuration */
0x5d, 0x00, /* u16 wTotalLength; 9+9+54+7+7+7 */
0x01, /* u8 bNumInterfaces; (1) */
0x01, /* u8 bConfigurationValue; */
0x00, /* u8 iConfiguration; */
0xe0, /* u8 bmAttributes;
Bit 7: must be set,
6: Self-powered,
5: Remote wakeup,
4..0: resvd */
100/2, /* u8 MaxPower; 50 == 100mA */
/* one interface */
0x09, /* u8 if_bLength; */
USB_DT_INTERFACE, /* u8 if_bDescriptorType; Interface */
0x00, /* u8 if_bInterfaceNumber; */
0x00, /* u8 if_bAlternateSetting; */
0x03, /* u8 if_bNumEndpoints; */
0x0b, /* u8 if_bInterfaceClass; Smart Card Device Class */
0x00, /* u8 if_bInterfaceSubClass; Subclass code */
0x00, /* u8 if_bInterfaceProtocol; Protocol code */
0x04, /* u8 if_iInterface; Index of string descriptor */
static const uint8_t qemu_ccid_descriptor[] = {
/* Smart Card Device Class Descriptor */
0x36, /* u8 bLength; */
0x21, /* u8 bDescriptorType; Functional */
@ -439,38 +391,81 @@ static const uint8_t qemu_ccid_config_descriptor[] = {
* 02h PIN Modification
*/
0x01, /* u8 bMaxCCIDBusySlots; */
};
/* Interrupt-IN endpoint */
0x07, /* u8 ep_bLength; */
/* u8 ep_bDescriptorType; Endpoint */
USB_DT_ENDPOINT,
/* u8 ep_bEndpointAddress; IN Endpoint 1 */
0x80 | CCID_INT_IN_EP,
0x03, /* u8 ep_bmAttributes; Interrupt */
/* u16 ep_wMaxPacketSize; */
CCID_MAX_PACKET_SIZE & 0xff, (CCID_MAX_PACKET_SIZE >> 8),
0xff, /* u8 ep_bInterval; */
enum {
STR_MANUFACTURER = 1,
STR_PRODUCT,
STR_SERIALNUMBER,
STR_INTERFACE,
};
/* Bulk-In endpoint */
0x07, /* u8 ep_bLength; */
/* u8 ep_bDescriptorType; Endpoint */
USB_DT_ENDPOINT,
/* u8 ep_bEndpointAddress; IN Endpoint 2 */
0x80 | CCID_BULK_IN_EP,
0x02, /* u8 ep_bmAttributes; Bulk */
0x40, 0x00, /* u16 ep_wMaxPacketSize; */
0x00, /* u8 ep_bInterval; */
static const USBDescStrings desc_strings = {
[STR_MANUFACTURER] = "QEMU " QEMU_VERSION,
[STR_PRODUCT] = "QEMU USB CCID",
[STR_SERIALNUMBER] = "1",
[STR_INTERFACE] = "CCID Interface",
};
/* Bulk-Out endpoint */
0x07, /* u8 ep_bLength; */
/* u8 ep_bDescriptorType; Endpoint */
USB_DT_ENDPOINT,
/* u8 ep_bEndpointAddress; OUT Endpoint 3 */
CCID_BULK_OUT_EP,
0x02, /* u8 ep_bmAttributes; Bulk */
0x40, 0x00, /* u16 ep_wMaxPacketSize; */
0x00, /* u8 ep_bInterval; */
static const USBDescIface desc_iface0 = {
.bInterfaceNumber = 0,
.bNumEndpoints = 3,
.bInterfaceClass = 0x0b,
.bInterfaceSubClass = 0x00,
.bInterfaceProtocol = 0x00,
.iInterface = STR_INTERFACE,
.ndesc = 1,
.descs = (USBDescOther[]) {
{
/* smartcard descriptor */
.data = qemu_ccid_descriptor,
},
},
.eps = (USBDescEndpoint[]) {
{
.bEndpointAddress = USB_DIR_IN | CCID_INT_IN_EP,
.bmAttributes = USB_ENDPOINT_XFER_INT,
.bInterval = 255,
.wMaxPacketSize = 64,
},{
.bEndpointAddress = USB_DIR_IN | CCID_BULK_IN_EP,
.bmAttributes = USB_ENDPOINT_XFER_BULK,
.wMaxPacketSize = 64,
},{
.bEndpointAddress = USB_DIR_OUT | CCID_BULK_OUT_EP,
.bmAttributes = USB_ENDPOINT_XFER_BULK,
.wMaxPacketSize = 64,
},
}
};
static const USBDescDevice desc_device = {
.bcdUSB = 0x0110,
.bMaxPacketSize0 = 64,
.bNumConfigurations = 1,
.confs = (USBDescConfig[]) {
{
.bNumInterfaces = 1,
.bConfigurationValue = 1,
.bmAttributes = 0xa0,
.bMaxPower = 50,
.nif = 1,
.ifs = &desc_iface0,
},
},
};
static const USBDesc desc_ccid = {
.id = {
.idVendor = CCID_VENDOR_ID,
.idProduct = CCID_PRODUCT_ID,
.bcdDevice = CCID_DEVICE_VERSION,
.iManufacturer = STR_MANUFACTURER,
.iProduct = STR_PRODUCT,
.iSerialNumber = STR_SERIALNUMBER,
},
.full = &desc_device,
.str = desc_strings,
};
static bool ccid_has_pending_answers(USBCCIDState *s)
@ -610,87 +605,12 @@ static int ccid_handle_control(USBDevice *dev, USBPacket *p, int request,
int ret = 0;
DPRINTF(s, 1, "got control %x, value %x\n", request, value);
ret = usb_desc_handle_control(dev, p, request, value, index, length, data);
if (ret >= 0) {
return ret;
}
switch (request) {
case DeviceRequest | USB_REQ_GET_STATUS:
data[0] = (1 << USB_DEVICE_SELF_POWERED) |
(dev->remote_wakeup << USB_DEVICE_REMOTE_WAKEUP);
data[1] = 0x00;
ret = 2;
break;
case DeviceOutRequest | USB_REQ_CLEAR_FEATURE:
if (value == USB_DEVICE_REMOTE_WAKEUP) {
dev->remote_wakeup = 0;
} else {
goto fail;
}
ret = 0;
break;
case DeviceOutRequest | USB_REQ_SET_FEATURE:
if (value == USB_DEVICE_REMOTE_WAKEUP) {
dev->remote_wakeup = 1;
} else {
goto fail;
}
ret = 0;
break;
case DeviceOutRequest | USB_REQ_SET_ADDRESS:
dev->addr = value;
ret = 0;
break;
case DeviceRequest | USB_REQ_GET_DESCRIPTOR:
switch (value >> 8) {
case USB_DT_DEVICE:
memcpy(data, qemu_ccid_dev_descriptor,
sizeof(qemu_ccid_dev_descriptor));
ret = sizeof(qemu_ccid_dev_descriptor);
break;
case USB_DT_CONFIG:
memcpy(data, qemu_ccid_config_descriptor,
sizeof(qemu_ccid_config_descriptor));
ret = sizeof(qemu_ccid_config_descriptor);
break;
case USB_DT_STRING:
switch (value & 0xff) {
case 0:
/* language ids */
data[0] = 4;
data[1] = 3;
data[2] = 0x09;
data[3] = 0x04;
ret = 4;
break;
case 1:
/* vendor description */
ret = set_usb_string(data, CCID_VENDOR_DESCRIPTION);
break;
case 2:
/* product description */
ret = set_usb_string(data, CCID_PRODUCT_DESCRIPTION);
break;
case 3:
/* serial number */
ret = set_usb_string(data, CCID_SERIAL_NUMBER_STRING);
break;
case 4:
/* interface name */
ret = set_usb_string(data, CCID_INTERFACE_NAME);
break;
default:
goto fail;
}
break;
default:
goto fail;
}
break;
case DeviceRequest | USB_REQ_GET_CONFIGURATION:
data[0] = 1;
ret = 1;
break;
case DeviceOutRequest | USB_REQ_SET_CONFIGURATION:
/* Only one configuration - we just ignore the request */
ret = 0;
break;
case DeviceRequest | USB_REQ_GET_INTERFACE:
data[0] = 0;
ret = 1;
@ -698,9 +618,6 @@ static int ccid_handle_control(USBDevice *dev, USBPacket *p, int request,
case InterfaceOutRequest | USB_REQ_SET_INTERFACE:
ret = 0;
break;
case EndpointOutRequest | USB_REQ_CLEAR_FEATURE:
ret = 0;
break;
/* Class specific requests. */
case InterfaceOutClass | CCID_CONTROL_ABORT:
@ -716,7 +633,6 @@ static int ccid_handle_control(USBDevice *dev, USBPacket *p, int request,
ret = USB_RET_STALL;
break;
default:
fail:
DPRINTF(s, 1, "got unsupported/bogus control %x, value %x\n",
request, value);
ret = USB_RET_STALL;
@ -895,6 +811,7 @@ static void ccid_on_slot_change(USBCCIDState *s, bool full)
s->bmSlotICCState |= SLOT_0_CHANGED_MASK;
}
s->notify_slot_change = true;
usb_wakeup(&s->dev);
}
static void ccid_write_data_block_error(
@ -1075,6 +992,7 @@ static int ccid_handle_data(USBDevice *dev, USBPacket *p)
break;
default:
DPRINTF(s, 1, "Bad endpoint\n");
ret = USB_RET_STALL;
break;
}
break;
@ -1256,6 +1174,7 @@ static int ccid_initfn(USBDevice *dev)
{
USBCCIDState *s = DO_UPCAST(USBCCIDState, dev, dev);
usb_desc_init(dev);
qbus_create_inplace(&s->bus.qbus, &ccid_bus_info, &dev->qdev, NULL);
s->bus.qbus.allow_hotplug = 1;
s->card = NULL;
@ -1381,6 +1300,7 @@ static struct USBDeviceInfo ccid_info = {
.qdev.desc = "CCID Rev 1.1 smartcard reader",
.qdev.size = sizeof(USBCCIDState),
.init = ccid_initfn,
.usb_desc = &desc_ccid,
.handle_packet = usb_generic_handle_packet,
.handle_reset = ccid_handle_reset,
.handle_control = ccid_handle_control,

2
hw/usb-desc.h
View File

@ -75,7 +75,7 @@ struct USBDescEndpoint {
struct USBDescOther {
uint8_t length;
uint8_t *data;
const uint8_t *data;
};
typedef const char *USBDescStrings[256];

65
hw/usb-ehci.c
View File

@ -149,6 +149,7 @@ typedef enum {
EST_FETCHENTRY,
EST_FETCHQH,
EST_FETCHITD,
EST_FETCHSITD,
EST_ADVANCEQUEUE,
EST_FETCHQTD,
EST_EXECUTE,
@ -646,6 +647,13 @@ static void ehci_trace_itd(EHCIState *s, target_phys_addr_t addr, EHCIitd *itd)
get_field(itd->bufptr[0], ITD_BUFPTR_DEVADDR));
}
static void ehci_trace_sitd(EHCIState *s, target_phys_addr_t addr,
EHCIsitd *sitd)
{
trace_usb_ehci_sitd(addr, sitd->next,
(bool)(sitd->results & SITD_RESULTS_ACTIVE));
}
/* queue management */
static EHCIQueue *ehci_alloc_queue(EHCIState *ehci, int async)
@ -849,8 +857,8 @@ static void ehci_reset(void *opaque)
*/
for(i = 0; i < NB_PORTS; i++) {
devs[i] = s->ports[i].dev;
if (devs[i]) {
usb_attach(&s->ports[i], NULL);
if (devs[i] && devs[i]->attached) {
usb_detach(&s->ports[i]);
}
}
@ -870,8 +878,8 @@ static void ehci_reset(void *opaque)
} else {
s->portsc[i] = PORTSC_PPOWER;
}
if (devs[i]) {
usb_attach(&s->ports[i], devs[i]);
if (devs[i] && devs[i]->attached) {
usb_attach(&s->ports[i]);
}
}
ehci_queues_rip_all(s);
@ -937,15 +945,15 @@ static void handle_port_owner_write(EHCIState *s, int port, uint32_t owner)
return;
}
if (dev) {
usb_attach(&s->ports[port], NULL);
if (dev && dev->attached) {
usb_detach(&s->ports[port]);
}
*portsc &= ~PORTSC_POWNER;
*portsc |= owner;
if (dev) {
usb_attach(&s->ports[port], dev);
if (dev && dev->attached) {
usb_attach(&s->ports[port]);
}
}
@ -969,8 +977,8 @@ static void handle_port_status_write(EHCIState *s, int port, uint32_t val)
if (!(val & PORTSC_PRESET) &&(*portsc & PORTSC_PRESET)) {
trace_usb_ehci_port_reset(port, 0);
if (dev) {
usb_attach(&s->ports[port], dev);
if (dev && dev->attached) {
usb_attach(&s->ports[port]);
usb_send_msg(dev, USB_MSG_RESET);
*portsc &= ~PORTSC_CSC;
}
@ -979,7 +987,7 @@ static void handle_port_status_write(EHCIState *s, int port, uint32_t val)
* Table 2.16 Set the enable bit(and enable bit change) to indicate
* to SW that this port has a high speed device attached
*/
if (dev && (dev->speedmask & USB_SPEED_MASK_HIGH)) {
if (dev && dev->attached && (dev->speedmask & USB_SPEED_MASK_HIGH)) {
val |= PORTSC_PED;
}
}
@ -1584,8 +1592,13 @@ static int ehci_state_fetchentry(EHCIState *ehci, int async)
again = 1;
break;
case NLPTR_TYPE_STITD:
ehci_set_state(ehci, async, EST_FETCHSITD);
again = 1;
break;
default:
// TODO: handle siTD and FSTN types
/* TODO: handle FSTN type */
fprintf(stderr, "FETCHENTRY: entry at %X is of type %d "
"which is not supported yet\n", entry, NLPTR_TYPE_GET(entry));
return -1;
@ -1701,6 +1714,30 @@ static int ehci_state_fetchitd(EHCIState *ehci, int async)
return 1;
}
static int ehci_state_fetchsitd(EHCIState *ehci, int async)
{
uint32_t entry;
EHCIsitd sitd;
assert(!async);
entry = ehci_get_fetch_addr(ehci, async);
get_dwords(NLPTR_GET(entry), (uint32_t *)&sitd,
sizeof(EHCIsitd) >> 2);
ehci_trace_sitd(ehci, entry, &sitd);
if (!(sitd.results & SITD_RESULTS_ACTIVE)) {
/* siTD is not active, nothing to do */;
} else {
/* TODO: split transfers are not implemented */
fprintf(stderr, "WARNING: Skipping active siTD\n");
}
ehci_set_fetch_addr(ehci, async, sitd.next);
ehci_set_state(ehci, async, EST_FETCHENTRY);
return 1;
}
/* Section 4.10.2 - paragraph 3 */
static int ehci_state_advqueue(EHCIQueue *q, int async)
{
@ -1976,6 +2013,10 @@ static void ehci_advance_state(EHCIState *ehci,
again = ehci_state_fetchitd(ehci, async);
break;
case EST_FETCHSITD:
again = ehci_state_fetchsitd(ehci, async);
break;
case EST_ADVANCEQUEUE:
again = ehci_state_advqueue(q, async);
break;

12
hw/usb-hub.c
View File

@ -213,16 +213,6 @@ static void usb_hub_complete(USBPort *port, USBPacket *packet)
usb_packet_complete(&s->dev, packet);
}
static void usb_hub_handle_attach(USBDevice *dev)
{
USBHubState *s = DO_UPCAST(USBHubState, dev, dev);
int i;
for (i = 0; i < NUM_PORTS; i++) {
usb_port_location(&s->ports[i].port, dev->port, i+1);
}
}
static void usb_hub_handle_reset(USBDevice *dev)
{
/* XXX: do it */
@ -499,6 +489,7 @@ static int usb_hub_initfn(USBDevice *dev)
usb_register_port(usb_bus_from_device(dev),
&port->port, s, i, &usb_hub_port_ops,
USB_SPEED_MASK_LOW | USB_SPEED_MASK_FULL);
usb_port_location(&port->port, dev->port, i+1);
port->wPortStatus = PORT_STAT_POWER;
port->wPortChange = 0;
}
@ -537,7 +528,6 @@ static struct USBDeviceInfo hub_info = {
.usb_desc = &desc_hub,
.init = usb_hub_initfn,
.handle_packet = usb_hub_handle_packet,
.handle_attach = usb_hub_handle_attach,
.handle_reset = usb_hub_handle_reset,
.handle_control = usb_hub_handle_control,
.handle_data = usb_hub_handle_data,

26
hw/usb-musb.c
View File

@ -314,7 +314,7 @@ struct MUSBEndPoint {
};
struct MUSBState {
qemu_irq *irqs;
qemu_irq irqs[musb_irq_max];
USBBus bus;
USBPort port;
@ -340,14 +340,12 @@ struct MUSBState {
MUSBEndPoint ep[16];
};
struct MUSBState *musb_init(qemu_irq *irqs)
void musb_reset(MUSBState *s)
{
MUSBState *s = g_malloc0(sizeof(*s));
int i;
s->irqs = irqs;
s->faddr = 0x00;
s->devctl = 0;
s->power = MGC_M_POWER_HSENAB;
s->tx_intr = 0x0000;
s->rx_intr = 0x0000;
@ -357,6 +355,10 @@ struct MUSBState *musb_init(qemu_irq *irqs)
s->mask = 0x06;
s->idx = 0;
s->setup_len = 0;
s->session = 0;
memset(s->buf, 0, sizeof(s->buf));
/* TODO: _DW */
s->ep[0].config = MGC_M_CONFIGDATA_SOFTCONE | MGC_M_CONFIGDATA_DYNFIFO;
for (i = 0; i < 16; i ++) {
@ -368,8 +370,20 @@ struct MUSBState *musb_init(qemu_irq *irqs)
usb_packet_init(&s->ep[i].packey[0].p);
usb_packet_init(&s->ep[i].packey[1].p);
}
}
usb_bus_new(&s->bus, &musb_bus_ops, NULL /* FIXME */);
struct MUSBState *musb_init(DeviceState *parent_device, int gpio_base)
{
MUSBState *s = g_malloc0(sizeof(*s));
int i;
for (i = 0; i < musb_irq_max; i++) {
s->irqs[i] = qdev_get_gpio_in(parent_device, gpio_base + i);
}
musb_reset(s);
usb_bus_new(&s->bus, &musb_bus_ops, parent_device);
usb_register_port(&s->bus, &s->port, s, 0, &musb_port_ops,
USB_SPEED_MASK_LOW | USB_SPEED_MASK_FULL);

4
hw/usb-ohci.c
View File

@ -448,8 +448,8 @@ static void ohci_reset(void *opaque)
{
port = &ohci->rhport[i];
port->ctrl = 0;
if (port->port.dev) {
usb_attach(&port->port, port->port.dev);
if (port->port.dev && port->port.dev->attached) {
usb_attach(&port->port);
}
}
if (ohci->async_td) {

11
hw/usb-uhci.c
View File

@ -340,8 +340,8 @@ static void uhci_reset(void *opaque)
for(i = 0; i < NB_PORTS; i++) {
port = &s->ports[i];
port->ctrl = 0x0080;
if (port->port.dev) {
usb_attach(&port->port, port->port.dev);
if (port->port.dev && port->port.dev->attached) {
usb_attach(&port->port);
}
}
@ -446,7 +446,7 @@ static void uhci_ioport_writew(void *opaque, uint32_t addr, uint32_t val)
for(i = 0; i < NB_PORTS; i++) {
port = &s->ports[i];
dev = port->port.dev;
if (dev) {
if (dev && dev->attached) {
usb_send_msg(dev, USB_MSG_RESET);
}
}
@ -486,7 +486,7 @@ static void uhci_ioport_writew(void *opaque, uint32_t addr, uint32_t val)
return;
port = &s->ports[n];
dev = port->port.dev;
if (dev) {
if (dev && dev->attached) {
/* port reset */
if ( (val & UHCI_PORT_RESET) &&
!(port->ctrl & UHCI_PORT_RESET) ) {
@ -660,8 +660,9 @@ static int uhci_broadcast_packet(UHCIState *s, USBPacket *p)
UHCIPort *port = &s->ports[i];
USBDevice *dev = port->port.dev;
if (dev && (port->ctrl & UHCI_PORT_EN))
if (dev && dev->attached && (port->ctrl & UHCI_PORT_EN)) {
ret = usb_handle_packet(dev, p);
}
}
DPRINTF("uhci: packet exit. ret %d len %zd\n", ret, p->iov.size);

37
hw/usb.c
View File

@ -27,26 +27,23 @@
#include "usb.h"
#include "iov.h"
void usb_attach(USBPort *port, USBDevice *dev)
void usb_attach(USBPort *port)
{
if (dev != NULL) {
/* attach */
if (port->dev) {
usb_attach(port, NULL);
}
dev->port = port;
port->dev = dev;
port->ops->attach(port);
usb_send_msg(dev, USB_MSG_ATTACH);
} else {
/* detach */
dev = port->dev;
assert(dev);
port->ops->detach(port);
usb_send_msg(dev, USB_MSG_DETACH);
dev->port = NULL;
port->dev = NULL;
}
USBDevice *dev = port->dev;
assert(dev != NULL);
assert(dev->attached);
port->ops->attach(port);
usb_send_msg(dev, USB_MSG_ATTACH);
}
void usb_detach(USBPort *port)
{
USBDevice *dev = port->dev;
assert(dev != NULL);
port->ops->detach(port);
usb_send_msg(dev, USB_MSG_DETACH);
}
void usb_wakeup(USBDevice *dev)
@ -338,8 +335,8 @@ void usb_packet_complete(USBDevice *dev, USBPacket *p)
{
/* Note: p->owner != dev is possible in case dev is a hub */
assert(p->owner != NULL);
dev->port->ops->complete(dev->port, p);
p->owner = NULL;
dev->port->ops->complete(dev->port, p);
}
/* Cancel an active packet. The packed must have been deferred by

11
hw/usb.h
View File

@ -304,7 +304,8 @@ int usb_handle_packet(USBDevice *dev, USBPacket *p);
void usb_packet_complete(USBDevice *dev, USBPacket *p);
void usb_cancel_packet(USBPacket * p);
void usb_attach(USBPort *port, USBDevice *dev);
void usb_attach(USBPort *port);
void usb_detach(USBPort *port);
void usb_wakeup(USBDevice *dev);
int usb_generic_handle_packet(USBDevice *s, USBPacket *p);
void usb_generic_async_ctrl_complete(USBDevice *s, USBPacket *p);
@ -337,11 +338,13 @@ enum musb_irq_source_e {
musb_irq_tx,
musb_set_vbus,
musb_set_session,
__musb_irq_max,
/* Add new interrupts here */
musb_irq_max, /* total number of interrupts defined */
};
typedef struct MUSBState MUSBState;
MUSBState *musb_init(qemu_irq *irqs);
MUSBState *musb_init(DeviceState *parent_device, int gpio_base);
void musb_reset(MUSBState *s);
uint32_t musb_core_intr_get(MUSBState *s);
void musb_core_intr_clear(MUSBState *s, uint32_t mask);
void musb_set_size(MUSBState *s, int epnum, int size, int is_tx);
@ -378,6 +381,8 @@ int usb_register_companion(const char *masterbus, USBPort *ports[],
void *opaque, USBPortOps *ops, int speedmask);
void usb_port_location(USBPort *downstream, USBPort *upstream, int portnr);
void usb_unregister_port(USBBus *bus, USBPort *port);
int usb_claim_port(USBDevice *dev);
void usb_release_port(USBDevice *dev);
int usb_device_attach(USBDevice *dev);
int usb_device_detach(USBDevice *dev);
int usb_device_delete_addr(int busnr, int addr);

32
trace-events
View File

@ -209,6 +209,12 @@ sun4m_iommu_page_get_flags(uint64_t pa, uint64_t iopte, uint32_t ret) "get flags
sun4m_iommu_translate_pa(uint64_t addr, uint64_t pa, uint32_t iopte) "xlate dva %"PRIx64" => pa %"PRIx64" iopte = %x"
sun4m_iommu_bad_addr(uint64_t addr) "bad addr %"PRIx64""
# hw/usb-bus.c
usb_port_claim(int bus, const char *port) "bus %d, port %s"
usb_port_attach(int bus, const char *port) "bus %d, port %s"
usb_port_detach(int bus, const char *port) "bus %d, port %s"
usb_port_release(int bus, const char *port) "bus %d, port %s"
# hw/usb-ehci.c
usb_ehci_reset(void) "=== RESET ==="
usb_ehci_mmio_readl(uint32_t addr, const char *str, uint32_t val) "rd mmio %04x [%s] = %x"
@ -223,6 +229,7 @@ usb_ehci_qtd_ptrs(void *q, uint32_t addr, uint32_t nxt, uint32_t altnext) "q %p
usb_ehci_qtd_fields(uint32_t addr, int tbytes, int cpage, int cerr, int pid) "QTD @ %08x - tbytes %d, cpage %d, cerr %d, pid %d"
usb_ehci_qtd_bits(uint32_t addr, int ioc, int active, int halt, int babble, int xacterr) "QTD @ %08x - ioc %d, active %d, halt %d, babble %d, xacterr %d"
usb_ehci_itd(uint32_t addr, uint32_t nxt, uint32_t mplen, uint32_t mult, uint32_t ep, uint32_t devaddr) "ITD @ %08x: next %08x - mplen %d, mult %d, ep %d, dev %d"
usb_ehci_sitd(uint32_t addr, uint32_t nxt, uint32_t active) "ITD @ %08x: next %08x - active %d"
usb_ehci_port_attach(uint32_t port, const char *device) "attach port #%d - %s"
usb_ehci_port_detach(uint32_t port) "detach port #%d"
usb_ehci_port_reset(uint32_t port, int enable) "reset port #%d - %d"
@ -240,6 +247,31 @@ usb_set_config(int addr, int config, int ret) "dev %d, config %d, ret %d"
usb_clear_device_feature(int addr, int feature, int ret) "dev %d, feature %d, ret %d"
usb_set_device_feature(int addr, int feature, int ret) "dev %d, feature %d, ret %d"
# usb-linux.c
usb_host_open_started(int bus, int addr) "dev %d:%d"
usb_host_open_success(int bus, int addr) "dev %d:%d"
usb_host_open_failure(int bus, int addr) "dev %d:%d"
usb_host_disconnect(int bus, int addr) "dev %d:%d"
usb_host_close(int bus, int addr) "dev %d:%d"
usb_host_set_address(int bus, int addr, int config) "dev %d:%d, address %d"
usb_host_set_config(int bus, int addr, int config) "dev %d:%d, config %d"
usb_host_set_interface(int bus, int addr, int interface, int alt) "dev %d:%d, interface %d, alt %d"
usb_host_claim_interfaces(int bus, int addr, int config, int nif) "dev %d:%d, config %d, nif %d"
usb_host_release_interfaces(int bus, int addr) "dev %d:%d"
usb_host_req_control(int bus, int addr, int req, int value, int index) "dev %d:%d, req 0x%x, value %d, index %d"
usb_host_req_data(int bus, int addr, int in, int ep, int size) "dev %d:%d, in %d, ep %d, size %d"
usb_host_req_complete(int bus, int addr, int status) "dev %d:%d, status %d"
usb_host_urb_submit(int bus, int addr, void *aurb, int length, int more) "dev %d:%d, aurb %p, length %d, more %d"
usb_host_urb_complete(int bus, int addr, void *aurb, int status, int length, int more) "dev %d:%d, aurb %p, status %d, length %d, more %d"
usb_host_ep_set_halt(int bus, int addr, int ep) "dev %d:%d, ep %d"
usb_host_ep_clear_halt(int bus, int addr, int ep) "dev %d:%d, ep %d"
usb_host_ep_start_iso(int bus, int addr, int ep) "dev %d:%d, ep %d"
usb_host_ep_stop_iso(int bus, int addr, int ep) "dev %d:%d, ep %d"
usb_host_reset(int bus, int addr) "dev %d:%d"
usb_host_auto_scan_enabled(void)
usb_host_auto_scan_disabled(void)
usb_host_claim_port(int bus, int hub, int port) "bus %d, hub addr %d, port %d"
# hw/scsi-bus.c
scsi_req_alloc(int target, int lun, int tag) "target %d lun %d tag %d"
scsi_req_data(int target, int lun, int tag, int len) "target %d lun %d tag %d len %d"

450
usb-linux.c
View File

@ -34,6 +34,7 @@
#include "qemu-timer.h"
#include "monitor.h"
#include "sysemu.h"
#include "trace.h"
#include <dirent.h>
#include <sys/ioctl.h>
@ -53,7 +54,7 @@ struct usb_ctrltransfer {
void *data;
};
typedef int USBScanFunc(void *opaque, int bus_num, int addr, char *port,
typedef int USBScanFunc(void *opaque, int bus_num, int addr, const char *port,
int class_id, int vendor_id, int product_id,
const char *product_name, int speed);
@ -114,6 +115,7 @@ struct USBAutoFilter {
typedef struct USBHostDevice {
USBDevice dev;
int fd;
int hub_fd;
uint8_t descr[8192];
int descr_len;
@ -123,7 +125,8 @@ typedef struct USBHostDevice {
uint32_t iso_urb_count;
Notifier exit;
struct endp_data endp_table[MAX_ENDPOINTS];
struct endp_data ep_in[MAX_ENDPOINTS];
struct endp_data ep_out[MAX_ENDPOINTS];
QLIST_HEAD(, AsyncURB) aurbs;
/* Host side address */
@ -131,6 +134,7 @@ typedef struct USBHostDevice {
int addr;
char port[MAX_PORTLEN];
struct USBAutoFilter match;
int seen, errcount;
QTAILQ_ENTRY(USBHostDevice) next;
} USBHostDevice;
@ -142,95 +146,107 @@ static int parse_filter(const char *spec, struct USBAutoFilter *f);
static void usb_host_auto_check(void *unused);
static int usb_host_read_file(char *line, size_t line_size,
const char *device_file, const char *device_name);
static int usb_linux_update_endp_table(USBHostDevice *s);
static struct endp_data *get_endp(USBHostDevice *s, int ep)
static struct endp_data *get_endp(USBHostDevice *s, int pid, int ep)
{
return s->endp_table + ep - 1;
struct endp_data *eps = pid == USB_TOKEN_IN ? s->ep_in : s->ep_out;
assert(pid == USB_TOKEN_IN || pid == USB_TOKEN_OUT);
assert(ep > 0 && ep <= MAX_ENDPOINTS);
return eps + ep - 1;
}
static int is_isoc(USBHostDevice *s, int ep)
static int is_isoc(USBHostDevice *s, int pid, int ep)
{
return get_endp(s, ep)->type == USBDEVFS_URB_TYPE_ISO;
return get_endp(s, pid, ep)->type == USBDEVFS_URB_TYPE_ISO;
}
static int is_valid(USBHostDevice *s, int ep)
static int is_valid(USBHostDevice *s, int pid, int ep)
{
return get_endp(s, ep)->type != INVALID_EP_TYPE;
return get_endp(s, pid, ep)->type != INVALID_EP_TYPE;
}
static int is_halted(USBHostDevice *s, int ep)
static int is_halted(USBHostDevice *s, int pid, int ep)
{
return get_endp(s, ep)->halted;
return get_endp(s, pid, ep)->halted;
}
static void clear_halt(USBHostDevice *s, int ep)
static void clear_halt(USBHostDevice *s, int pid, int ep)
{
get_endp(s, ep)->halted = 0;
trace_usb_host_ep_clear_halt(s->bus_num, s->addr, ep);
get_endp(s, pid, ep)->halted = 0;
}
static void set_halt(USBHostDevice *s, int ep)
static void set_halt(USBHostDevice *s, int pid, int ep)
{
get_endp(s, ep)->halted = 1;
if (ep != 0) {
trace_usb_host_ep_set_halt(s->bus_num, s->addr, ep);
get_endp(s, pid, ep)->halted = 1;
}
}
static int is_iso_started(USBHostDevice *s, int ep)
static int is_iso_started(USBHostDevice *s, int pid, int ep)
{
return get_endp(s, ep)->iso_started;
return get_endp(s, pid, ep)->iso_started;
}
static void clear_iso_started(USBHostDevice *s, int ep)
static void clear_iso_started(USBHostDevice *s, int pid, int ep)
{
get_endp(s, ep)->iso_started = 0;
trace_usb_host_ep_stop_iso(s->bus_num, s->addr, ep);
get_endp(s, pid, ep)->iso_started = 0;
}
static void set_iso_started(USBHostDevice *s, int ep)
static void set_iso_started(USBHostDevice *s, int pid, int ep)
{
struct endp_data *e = get_endp(s, ep);
struct endp_data *e = get_endp(s, pid, ep);
trace_usb_host_ep_start_iso(s->bus_num, s->addr, ep);
if (!e->iso_started) {
e->iso_started = 1;
e->inflight = 0;
}
}
static int change_iso_inflight(USBHostDevice *s, int ep, int value)
static int change_iso_inflight(USBHostDevice *s, int pid, int ep, int value)
{
struct endp_data *e = get_endp(s, ep);
struct endp_data *e = get_endp(s, pid, ep);
e->inflight += value;
return e->inflight;
}
static void set_iso_urb(USBHostDevice *s, int ep, AsyncURB *iso_urb)
static void set_iso_urb(USBHostDevice *s, int pid, int ep, AsyncURB *iso_urb)
{
get_endp(s, ep)->iso_urb = iso_urb;
get_endp(s, pid, ep)->iso_urb = iso_urb;
}
static AsyncURB *get_iso_urb(USBHostDevice *s, int ep)
static AsyncURB *get_iso_urb(USBHostDevice *s, int pid, int ep)
{
return get_endp(s, ep)->iso_urb;
return get_endp(s, pid, ep)->iso_urb;
}
static void set_iso_urb_idx(USBHostDevice *s, int ep, int i)
static void set_iso_urb_idx(USBHostDevice *s, int pid, int ep, int i)
{
get_endp(s, ep)->iso_urb_idx = i;
get_endp(s, pid, ep)->iso_urb_idx = i;
}
static int get_iso_urb_idx(USBHostDevice *s, int ep)
static int get_iso_urb_idx(USBHostDevice *s, int pid, int ep)
{
return get_endp(s, ep)->iso_urb_idx;
return get_endp(s, pid, ep)->iso_urb_idx;
}
static void set_iso_buffer_used(USBHostDevice *s, int ep, int i)
static void set_iso_buffer_used(USBHostDevice *s, int pid, int ep, int i)
{
get_endp(s, ep)->iso_buffer_used = i;
get_endp(s, pid, ep)->iso_buffer_used = i;
}
static int get_iso_buffer_used(USBHostDevice *s, int ep)
static int get_iso_buffer_used(USBHostDevice *s, int pid, int ep)
{
return get_endp(s, ep)->iso_buffer_used;
return get_endp(s, pid, ep)->iso_buffer_used;
}
static void set_max_packet_size(USBHostDevice *s, int ep, uint8_t *descriptor)
static void set_max_packet_size(USBHostDevice *s, int pid, int ep,
uint8_t *descriptor)
{
int raw = descriptor[4] + (descriptor[5] << 8);
int size, microframes;
@ -241,12 +257,12 @@ static void set_max_packet_size(USBHostDevice *s, int ep, uint8_t *descriptor)
case 2: microframes = 3; break;
default: microframes = 1; break;
}
get_endp(s, ep)->max_packet_size = size * microframes;
get_endp(s, pid, ep)->max_packet_size = size * microframes;
}
static int get_max_packet_size(USBHostDevice *s, int ep)
static int get_max_packet_size(USBHostDevice *s, int pid, int ep)
{
return get_endp(s, ep)->max_packet_size;
return get_endp(s, pid, ep)->max_packet_size;
}
/*
@ -285,8 +301,6 @@ static void async_free(AsyncURB *aurb)
static void do_disconnect(USBHostDevice *s)
{
printf("husb: device %d.%d disconnected\n",
s->bus_num, s->addr);
usb_host_close(s);
usb_host_auto_check(NULL);
}
@ -308,12 +322,15 @@ static void async_complete(void *opaque)
}
return;
}
if (errno == ENODEV && !s->closing) {
do_disconnect(s);
if (errno == ENODEV) {
if (!s->closing) {
trace_usb_host_disconnect(s->bus_num, s->addr);
do_disconnect(s);
}
return;
}
DPRINTF("husb: async. reap urb failed errno %d\n", errno);
perror("USBDEVFS_REAPURBNDELAY");
return;
}
@ -324,19 +341,24 @@ static void async_complete(void *opaque)
anything else (it is handled further in usb_host_handle_iso_data) */
if (aurb->iso_frame_idx == -1) {
int inflight;
int pid = (aurb->urb.endpoint & USB_DIR_IN) ?
USB_TOKEN_IN : USB_TOKEN_OUT;
int ep = aurb->urb.endpoint & 0xf;
if (aurb->urb.status == -EPIPE) {
set_halt(s, aurb->urb.endpoint & 0xf);
set_halt(s, pid, ep);
}
aurb->iso_frame_idx = 0;
urbs++;
inflight = change_iso_inflight(s, aurb->urb.endpoint & 0xf, -1);
if (inflight == 0 && is_iso_started(s, aurb->urb.endpoint & 0xf)) {
inflight = change_iso_inflight(s, pid, ep, -1);
if (inflight == 0 && is_iso_started(s, pid, ep)) {
fprintf(stderr, "husb: out of buffers for iso stream\n");
}
continue;
}
p = aurb->packet;
trace_usb_host_urb_complete(s->bus_num, s->addr, aurb, aurb->urb.status,
aurb->urb.actual_length, aurb->more);
if (p) {
switch (aurb->urb.status) {
@ -345,7 +367,7 @@ static void async_complete(void *opaque)
break;
case -EPIPE:
set_halt(s, p->devep);
set_halt(s, p->pid, p->devep);
p->result = USB_RET_STALL;
break;
@ -355,8 +377,10 @@ static void async_complete(void *opaque)
}
if (aurb->urb.type == USBDEVFS_URB_TYPE_CONTROL) {
trace_usb_host_req_complete(s->bus_num, s->addr, p->result);
usb_generic_async_ctrl_complete(&s->dev, p);
} else if (!aurb->more) {
trace_usb_host_req_complete(s->bus_num, s->addr, p->result);
usb_packet_complete(&s->dev, p);
}
}
@ -394,8 +418,11 @@ static int usb_host_claim_interfaces(USBHostDevice *dev, int configuration)
int interface, nb_interfaces;
int ret, i;
if (configuration == 0) /* address state - ignore */
if (configuration == 0) { /* address state - ignore */
dev->ninterfaces = 0;
dev->configuration = 0;
return 1;
}
DPRINTF("husb: claiming interfaces. config %d\n", configuration);
@ -418,9 +445,9 @@ static int usb_host_claim_interfaces(USBHostDevice *dev, int configuration)
}
config_descr_len = dev->descr[i];
printf("husb: config #%d need %d\n", dev->descr[i + 5], configuration);
DPRINTF("husb: config #%d need %d\n", dev->descr[i + 5], configuration);
if (configuration < 0 || configuration == dev->descr[i + 5]) {
if (configuration == dev->descr[i + 5]) {
configuration = dev->descr[i + 5];
break;
}
@ -457,17 +484,12 @@ static int usb_host_claim_interfaces(USBHostDevice *dev, int configuration)
op = "USBDEVFS_CLAIMINTERFACE";
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");
}
goto fail;
}
}
printf("husb: %d interfaces claimed for configuration %d\n",
nb_interfaces, configuration);
trace_usb_host_claim_interfaces(dev->bus_num, dev->addr,
nb_interfaces, configuration);
dev->ninterfaces = nb_interfaces;
dev->configuration = configuration;
@ -485,16 +507,15 @@ static int usb_host_release_interfaces(USBHostDevice *s)
{
int ret, i;
DPRINTF("husb: releasing interfaces\n");
trace_usb_host_release_interfaces(s->bus_num, s->addr);
for (i = 0; i < s->ninterfaces; i++) {
ret = ioctl(s->fd, USBDEVFS_RELEASEINTERFACE, &i);
if (ret < 0) {
perror("husb: failed to release interface");
perror("USBDEVFS_RELEASEINTERFACE");
return 0;
}
}
return 1;
}
@ -502,11 +523,12 @@ 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);
trace_usb_host_reset(s->bus_num, s->addr);
ioctl(s->fd, USBDEVFS_RESET);
usb_host_claim_interfaces(s, s->configuration);
usb_host_claim_interfaces(s, 0);
usb_linux_update_endp_table(s);
}
static void usb_host_handle_destroy(USBDevice *dev)
@ -514,19 +536,20 @@ static void usb_host_handle_destroy(USBDevice *dev)
USBHostDevice *s = (USBHostDevice *)dev;
usb_host_close(s);
if (s->hub_fd != -1) {
close(s->hub_fd);
}
QTAILQ_REMOVE(&hostdevs, s, next);
qemu_remove_exit_notifier(&s->exit);
}
static int usb_linux_update_endp_table(USBHostDevice *s);
/* iso data is special, we need to keep enough urbs in flight to make sure
that the controller never runs out of them, otherwise the device will
likely suffer a buffer underrun / overrun. */
static AsyncURB *usb_host_alloc_iso(USBHostDevice *s, uint8_t ep, int in)
static AsyncURB *usb_host_alloc_iso(USBHostDevice *s, int pid, uint8_t ep)
{
AsyncURB *aurb;
int i, j, len = get_max_packet_size(s, ep);
int i, j, len = get_max_packet_size(s, pid, ep);
aurb = g_malloc0(s->iso_urb_count * sizeof(*aurb));
for (i = 0; i < s->iso_urb_count; i++) {
@ -538,23 +561,23 @@ static AsyncURB *usb_host_alloc_iso(USBHostDevice *s, uint8_t ep, int in)
aurb[i].urb.number_of_packets = ISO_FRAME_DESC_PER_URB;
for (j = 0 ; j < ISO_FRAME_DESC_PER_URB; j++)
aurb[i].urb.iso_frame_desc[j].length = len;
if (in) {
if (pid == USB_TOKEN_IN) {
aurb[i].urb.endpoint |= 0x80;
/* Mark as fully consumed (idle) */
aurb[i].iso_frame_idx = ISO_FRAME_DESC_PER_URB;
}
}
set_iso_urb(s, ep, aurb);
set_iso_urb(s, pid, ep, aurb);
return aurb;
}
static void usb_host_stop_n_free_iso(USBHostDevice *s, uint8_t ep)
static void usb_host_stop_n_free_iso(USBHostDevice *s, int pid, uint8_t ep)
{
AsyncURB *aurb;
int i, ret, killed = 0, free = 1;
aurb = get_iso_urb(s, ep);
aurb = get_iso_urb(s, pid, ep);
if (!aurb) {
return;
}
@ -564,7 +587,7 @@ static void usb_host_stop_n_free_iso(USBHostDevice *s, uint8_t ep)
if (aurb[i].iso_frame_idx == -1) {
ret = ioctl(s->fd, USBDEVFS_DISCARDURB, &aurb[i]);
if (ret < 0) {
printf("husb: discard isoc in urb failed errno %d\n", errno);
perror("USBDEVFS_DISCARDURB");
free = 0;
continue;
}
@ -585,9 +608,9 @@ static void usb_host_stop_n_free_iso(USBHostDevice *s, uint8_t ep)
g_free(aurb);
else
printf("husb: leaking iso urbs because of discard failure\n");
set_iso_urb(s, ep, NULL);
set_iso_urb_idx(s, ep, 0);
clear_iso_started(s, ep);
set_iso_urb(s, pid, ep, NULL);
set_iso_urb_idx(s, pid, ep, 0);
clear_iso_started(s, pid, ep);
}
static int urb_status_to_usb_ret(int status)
@ -606,16 +629,16 @@ static int usb_host_handle_iso_data(USBHostDevice *s, USBPacket *p, int in)
int i, j, ret, max_packet_size, offset, len = 0;
uint8_t *buf;
max_packet_size = get_max_packet_size(s, p->devep);
max_packet_size = get_max_packet_size(s, p->pid, p->devep);
if (max_packet_size == 0)
return USB_RET_NAK;
aurb = get_iso_urb(s, p->devep);
aurb = get_iso_urb(s, p->pid, p->devep);
if (!aurb) {
aurb = usb_host_alloc_iso(s, p->devep, in);
aurb = usb_host_alloc_iso(s, p->pid, p->devep);
}
i = get_iso_urb_idx(s, p->devep);
i = get_iso_urb_idx(s, p->pid, p->devep);
j = aurb[i].iso_frame_idx;
if (j >= 0 && j < ISO_FRAME_DESC_PER_URB) {
if (in) {
@ -642,7 +665,7 @@ static int usb_host_handle_iso_data(USBHostDevice *s, USBPacket *p, int in)
}
} else {
len = p->iov.size;
offset = (j == 0) ? 0 : get_iso_buffer_used(s, p->devep);
offset = (j == 0) ? 0 : get_iso_buffer_used(s, p->pid, p->devep);
/* Check the frame fits */
if (len > max_packet_size) {
@ -654,33 +677,33 @@ static int usb_host_handle_iso_data(USBHostDevice *s, USBPacket *p, int in)
usb_packet_copy(p, aurb[i].urb.buffer + offset, len);
aurb[i].urb.iso_frame_desc[j].length = len;
offset += len;
set_iso_buffer_used(s, p->devep, offset);
set_iso_buffer_used(s, p->pid, p->devep, offset);
/* Start the stream once we have buffered enough data */
if (!is_iso_started(s, p->devep) && i == 1 && j == 8) {
set_iso_started(s, p->devep);
if (!is_iso_started(s, p->pid, p->devep) && i == 1 && j == 8) {
set_iso_started(s, p->pid, p->devep);
}
}
aurb[i].iso_frame_idx++;
if (aurb[i].iso_frame_idx == ISO_FRAME_DESC_PER_URB) {
i = (i + 1) % s->iso_urb_count;
set_iso_urb_idx(s, p->devep, i);
set_iso_urb_idx(s, p->pid, p->devep, i);
}
} else {
if (in) {
set_iso_started(s, p->devep);
set_iso_started(s, p->pid, p->devep);
} else {
DPRINTF("hubs: iso out error no free buffer, dropping packet\n");
}
}
if (is_iso_started(s, p->devep)) {
if (is_iso_started(s, p->pid, p->devep)) {
/* (Re)-submit all fully consumed / filled urbs */
for (i = 0; i < s->iso_urb_count; i++) {
if (aurb[i].iso_frame_idx == ISO_FRAME_DESC_PER_URB) {
ret = ioctl(s->fd, USBDEVFS_SUBMITURB, &aurb[i]);
if (ret < 0) {
printf("husb error submitting iso urb %d: %d\n", i, errno);
perror("USBDEVFS_SUBMITURB");
if (!in || len == 0) {
switch(errno) {
case ETIMEDOUT:
@ -694,7 +717,7 @@ static int usb_host_handle_iso_data(USBHostDevice *s, USBPacket *p, int in)
break;
}
aurb[i].iso_frame_idx = -1;
change_iso_inflight(s, p->devep, +1);
change_iso_inflight(s, p->pid, p->devep, 1);
}
}
}
@ -711,7 +734,12 @@ static int usb_host_handle_data(USBDevice *dev, USBPacket *p)
uint8_t *pbuf;
uint8_t ep;
if (!is_valid(s, p->devep)) {
trace_usb_host_req_data(s->bus_num, s->addr,
p->pid == USB_TOKEN_IN,
p->devep, p->iov.size);
if (!is_valid(s, p->pid, p->devep)) {
trace_usb_host_req_complete(s->bus_num, s->addr, USB_RET_NAK);
return USB_RET_NAK;
}
@ -721,17 +749,18 @@ static int usb_host_handle_data(USBDevice *dev, USBPacket *p)
ep = p->devep;
}
if (is_halted(s, p->devep)) {
ret = ioctl(s->fd, USBDEVFS_CLEAR_HALT, &ep);
if (is_halted(s, p->pid, p->devep)) {
unsigned int arg = ep;
ret = ioctl(s->fd, USBDEVFS_CLEAR_HALT, &arg);
if (ret < 0) {
DPRINTF("husb: failed to clear halt. ep 0x%x errno %d\n",
ep, errno);
perror("USBDEVFS_CLEAR_HALT");
trace_usb_host_req_complete(s->bus_num, s->addr, USB_RET_NAK);
return USB_RET_NAK;
}
clear_halt(s, p->devep);
clear_halt(s, p->pid, p->devep);
}
if (is_isoc(s, p->devep)) {
if (is_isoc(s, p->pid, p->devep)) {
return usb_host_handle_iso_data(s, p, p->pid == USB_TOKEN_IN);
}
@ -767,20 +796,24 @@ static int usb_host_handle_data(USBDevice *dev, USBPacket *p)
aurb->more = 1;
}
trace_usb_host_urb_submit(s->bus_num, s->addr, aurb,
urb->buffer_length, aurb->more);
ret = ioctl(s->fd, USBDEVFS_SUBMITURB, urb);
DPRINTF("husb: data submit: ep 0x%x, len %u, more %d, packet %p, aurb %p\n",
urb->endpoint, urb->buffer_length, aurb->more, p, aurb);
if (ret < 0) {
DPRINTF("husb: submit failed. errno %d\n", errno);
perror("USBDEVFS_SUBMITURB");
async_free(aurb);
switch(errno) {
case ETIMEDOUT:
trace_usb_host_req_complete(s->bus_num, s->addr, USB_RET_NAK);
return USB_RET_NAK;
case EPIPE:
default:
trace_usb_host_req_complete(s->bus_num, s->addr, USB_RET_STALL);
return USB_RET_STALL;
}
}
@ -800,13 +833,15 @@ static int ctrl_error(void)
static int usb_host_set_address(USBHostDevice *s, int addr)
{
DPRINTF("husb: ctrl set addr %u\n", addr);
trace_usb_host_set_address(s->bus_num, s->addr, addr);
s->dev.addr = addr;
return 0;
}
static int usb_host_set_config(USBHostDevice *s, int config)
{
trace_usb_host_set_config(s->bus_num, s->addr, config);
usb_host_release_interfaces(s);
int ret = ioctl(s->fd, USBDEVFS_SETCONFIGURATION, &config);
@ -817,6 +852,7 @@ static int usb_host_set_config(USBHostDevice *s, int config)
return ctrl_error();
}
usb_host_claim_interfaces(s, config);
usb_linux_update_endp_table(s);
return 0;
}
@ -825,9 +861,14 @@ static int usb_host_set_interface(USBHostDevice *s, int iface, int alt)
struct usbdevfs_setinterface si;
int i, ret;
trace_usb_host_set_interface(s->bus_num, s->addr, iface, alt);
for (i = 1; i <= MAX_ENDPOINTS; i++) {
if (is_isoc(s, i)) {
usb_host_stop_n_free_iso(s, i);
if (is_isoc(s, USB_TOKEN_IN, i)) {
usb_host_stop_n_free_iso(s, USB_TOKEN_IN, i);
}
if (is_isoc(s, USB_TOKEN_OUT, i)) {
usb_host_stop_n_free_iso(s, USB_TOKEN_OUT, i);
}
}
@ -859,8 +900,7 @@ static int usb_host_handle_control(USBDevice *dev, USBPacket *p,
*/
/* Note request is (bRequestType << 8) | bRequest */
DPRINTF("husb: ctrl type 0x%x req 0x%x val 0x%x index %u len %u\n",
request >> 8, request & 0xff, value, index, length);
trace_usb_host_req_control(s->bus_num, s->addr, request, value, index);
switch (request) {
case DeviceOutRequest | USB_REQ_SET_ADDRESS:
@ -900,6 +940,8 @@ static int usb_host_handle_control(USBDevice *dev, USBPacket *p,
urb->usercontext = s;
trace_usb_host_urb_submit(s->bus_num, s->addr, aurb,
urb->buffer_length, aurb->more);
ret = ioctl(s->fd, USBDEVFS_SUBMITURB, urb);
DPRINTF("husb: submit ctrl. len %u aurb %p\n", urb->buffer_length, aurb);
@ -920,51 +962,6 @@ static int usb_host_handle_control(USBDevice *dev, USBPacket *p,
return USB_RET_ASYNC;
}
static int usb_linux_get_configuration(USBHostDevice *s)
{
uint8_t configuration;
struct usb_ctrltransfer ct;
int ret;
if (usb_fs_type == USB_FS_SYS) {
char device_name[32], line[1024];
int configuration;
sprintf(device_name, "%d-%s", s->bus_num, s->port);
if (!usb_host_read_file(line, sizeof(line), "bConfigurationValue",
device_name)) {
goto usbdevfs;
}
if (sscanf(line, "%d", &configuration) != 1) {
goto usbdevfs;
}
return configuration;
}
usbdevfs:
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_get_configuration");
return -1;
}
/* in address state */
if (configuration == 0) {
return -1;
}
return configuration;
}
static uint8_t usb_linux_get_alt_setting(USBHostDevice *s,
uint8_t configuration, uint8_t interface)
{
@ -1010,16 +1007,19 @@ usbdevfs:
static int usb_linux_update_endp_table(USBHostDevice *s)
{
uint8_t *descriptors;
uint8_t devep, type, configuration, alt_interface;
int interface, length, i;
uint8_t devep, type, alt_interface;
int interface, length, i, ep, pid;
struct endp_data *epd;
for (i = 0; i < MAX_ENDPOINTS; i++)
s->endp_table[i].type = INVALID_EP_TYPE;
for (i = 0; i < MAX_ENDPOINTS; i++) {
s->ep_in[i].type = INVALID_EP_TYPE;
s->ep_out[i].type = INVALID_EP_TYPE;
}
i = usb_linux_get_configuration(s);
if (i < 0)
return 1;
configuration = i;
if (s->configuration == 0) {
/* not configured yet -- leave all endpoints disabled */
return 0;
}
/* get the desired configuration, interface, and endpoint descriptors
* from device description */
@ -1028,8 +1028,9 @@ static int usb_linux_update_endp_table(USBHostDevice *s)
i = 0;
if (descriptors[i + 1] != USB_DT_CONFIG ||
descriptors[i + 5] != configuration) {
DPRINTF("invalid descriptor data - configuration\n");
descriptors[i + 5] != s->configuration) {
fprintf(stderr, "invalid descriptor data - configuration %d\n",
s->configuration);
return 1;
}
i += descriptors[i];
@ -1043,7 +1044,8 @@ static int usb_linux_update_endp_table(USBHostDevice *s)
}
interface = descriptors[i + 2];
alt_interface = usb_linux_get_alt_setting(s, configuration, interface);
alt_interface = usb_linux_get_alt_setting(s, s->configuration,
interface);
/* the current interface descriptor is the active interface
* and has endpoints */
@ -1066,7 +1068,9 @@ static int usb_linux_update_endp_table(USBHostDevice *s)
}
devep = descriptors[i + 2];
if ((devep & 0x0f) == 0) {
pid = (devep & USB_DIR_IN) ? USB_TOKEN_IN : USB_TOKEN_OUT;
ep = devep & 0xf;
if (ep == 0) {
fprintf(stderr, "usb-linux: invalid ep descriptor, ep == 0\n");
return 1;
}
@ -1077,7 +1081,7 @@ static int usb_linux_update_endp_table(USBHostDevice *s)
break;
case 0x01:
type = USBDEVFS_URB_TYPE_ISO;
set_max_packet_size(s, (devep & 0xf), descriptors + i);
set_max_packet_size(s, pid, ep, descriptors + i);
break;
case 0x02:
type = USBDEVFS_URB_TYPE_BULK;
@ -1089,8 +1093,10 @@ static int usb_linux_update_endp_table(USBHostDevice *s)
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;
epd = get_endp(s, pid, ep);
assert(epd->type == INVALID_EP_TYPE);
epd->type = type;
epd->halted = 0;
i += descriptors[i];
}
@ -1135,15 +1141,17 @@ static int usb_linux_full_speed_compat(USBHostDevice *dev)
}
static int usb_host_open(USBHostDevice *dev, int bus_num,
int addr, char *port, const char *prod_name, int speed)
int addr, const char *port,
const char *prod_name, int speed)
{
int fd = -1, ret;
char buf[1024];
trace_usb_host_open_started(bus_num, addr);
if (dev->fd != -1) {
goto fail;
}
printf("husb: open device %d.%d\n", bus_num, addr);
if (!usb_host_device_path) {
perror("husb: USB Host Device Path not set");
@ -1182,13 +1190,8 @@ static int usb_host_open(USBHostDevice *dev, int bus_num,
#endif
/*
* Initial configuration is -1 which makes us claim first
* available config. We used to start with 1, which does not
* always work. I've seen devices where first config starts
* with 2.
*/
if (!usb_host_claim_interfaces(dev, -1)) {
/* start unconfigured -- we'll wait for the guest to set a configuration */
if (!usb_host_claim_interfaces(dev, 0)) {
goto fail;
}
@ -1218,7 +1221,7 @@ static int usb_host_open(USBHostDevice *dev, int bus_num,
dev->dev.speedmask |= USB_SPEED_MASK_FULL;
}
printf("husb: grabbed usb device %d.%d\n", bus_num, addr);
trace_usb_host_open_success(bus_num, addr);
if (!prod_name || prod_name[0] == '\0') {
snprintf(dev->dev.product_desc, sizeof(dev->dev.product_desc),
@ -1239,6 +1242,7 @@ static int usb_host_open(USBHostDevice *dev, int bus_num,
return 0;
fail:
trace_usb_host_open_failure(bus_num, addr);
if (dev->fd != -1) {
close(dev->fd);
dev->fd = -1;
@ -1254,11 +1258,16 @@ static int usb_host_close(USBHostDevice *dev)
return -1;
}
trace_usb_host_close(dev->bus_num, dev->addr);
qemu_set_fd_handler(dev->fd, NULL, NULL, NULL);
dev->closing = 1;
for (i = 1; i <= MAX_ENDPOINTS; i++) {
if (is_isoc(dev, i)) {
usb_host_stop_n_free_iso(dev, i);
if (is_isoc(dev, USB_TOKEN_IN, i)) {
usb_host_stop_n_free_iso(dev, USB_TOKEN_IN, i);
}
if (is_isoc(dev, USB_TOKEN_OUT, i)) {
usb_host_stop_n_free_iso(dev, USB_TOKEN_OUT, i);
}
}
async_complete(dev);
@ -1285,17 +1294,76 @@ static int usb_host_initfn(USBDevice *dev)
dev->auto_attach = 0;
s->fd = -1;
s->hub_fd = -1;
QTAILQ_INSERT_TAIL(&hostdevs, s, next);
s->exit.notify = usb_host_exit_notifier;
qemu_add_exit_notifier(&s->exit);
usb_host_auto_check(NULL);
#ifdef USBDEVFS_CLAIM_PORT
if (s->match.bus_num != 0 && s->match.port != NULL) {
char *h, hub_name[64], line[1024];
int hub_addr, portnr, ret;
snprintf(hub_name, sizeof(hub_name), "%d-%s",
s->match.bus_num, s->match.port);
/* try strip off last ".$portnr" to get hub */
h = strrchr(hub_name, '.');
if (h != NULL) {
portnr = atoi(h+1);
*h = '\0';
} else {
/* no dot in there -> it is the root hub */
snprintf(hub_name, sizeof(hub_name), "usb%d",
s->match.bus_num);
portnr = atoi(s->match.port);
}
if (!usb_host_read_file(line, sizeof(line), "devnum",
hub_name)) {
goto out;
}
if (sscanf(line, "%d", &hub_addr) != 1) {
goto out;
}
if (!usb_host_device_path) {
goto out;
}
snprintf(line, sizeof(line), "%s/%03d/%03d",
usb_host_device_path, s->match.bus_num, hub_addr);
s->hub_fd = open(line, O_RDWR | O_NONBLOCK);
if (s->hub_fd < 0) {
goto out;
}
ret = ioctl(s->hub_fd, USBDEVFS_CLAIM_PORT, &portnr);
if (ret < 0) {
close(s->hub_fd);
s->hub_fd = -1;
goto out;
}
trace_usb_host_claim_port(s->match.bus_num, hub_addr, portnr);
}
out:
#endif
return 0;
}
static const VMStateDescription vmstate_usb_host = {
.name = "usb-host",
.unmigratable = 1,
};
static struct USBDeviceInfo usb_host_dev_info = {
.product_desc = "USB Host Device",
.qdev.name = "usb-host",
.qdev.size = sizeof(USBHostDevice),
.qdev.vmsd = &vmstate_usb_host,
.init = usb_host_initfn,
.handle_packet = usb_generic_handle_packet,
.cancel_packet = usb_host_async_cancel,
@ -1421,7 +1489,8 @@ static int usb_host_scan_dev(void *opaque, USBScanFunc *func)
FILE *f = NULL;
char line[1024];
char buf[1024];
int bus_num, addr, speed, device_count, class_id, product_id, vendor_id;
int bus_num, addr, speed, device_count;
int class_id, product_id, vendor_id, port;
char product_name[512];
int ret = 0;
@ -1437,7 +1506,7 @@ static int usb_host_scan_dev(void *opaque, USBScanFunc *func)
}
device_count = 0;
bus_num = addr = class_id = product_id = vendor_id = 0;
bus_num = addr = class_id = product_id = vendor_id = port = 0;
speed = -1; /* Can't get the speed from /[proc|dev]/bus/usb/devices */
for(;;) {
if (fgets(line, sizeof(line), f) == NULL) {
@ -1459,6 +1528,10 @@ static int usb_host_scan_dev(void *opaque, USBScanFunc *func)
goto fail;
}
bus_num = atoi(buf);
if (get_tag_value(buf, sizeof(buf), line, "Port=", " ") < 0) {
goto fail;
}
port = atoi(buf);
if (get_tag_value(buf, sizeof(buf), line, "Dev#=", " ") < 0) {
goto fail;
}
@ -1504,7 +1577,12 @@ static int usb_host_scan_dev(void *opaque, USBScanFunc *func)
}
if (device_count && (vendor_id || product_id)) {
/* Add the last device. */
ret = func(opaque, bus_num, addr, 0, class_id, vendor_id,
if (port > 0) {
snprintf(buf, sizeof(buf), "%d", port);
} else {
snprintf(buf, sizeof(buf), "?");
}
ret = func(opaque, bus_num, addr, buf, class_id, vendor_id,
product_id, product_name, speed);
}
the_end:
@ -1713,7 +1791,8 @@ static int usb_host_scan(void *opaque, USBScanFunc *func)
static QEMUTimer *usb_auto_timer;
static int usb_host_auto_scan(void *opaque, int bus_num, int addr, char *port,
static int usb_host_auto_scan(void *opaque, int bus_num,
int addr, const char *port,
int class_id, int vendor_id, int product_id,
const char *product_name, int speed)
{
@ -1745,6 +1824,10 @@ static int usb_host_auto_scan(void *opaque, int bus_num, int addr, char *port,
continue;
}
/* We got a match */
s->seen++;
if (s->errcount >= 3) {
return 0;
}
/* Already attached ? */
if (s->fd != -1) {
@ -1752,7 +1835,9 @@ static int usb_host_auto_scan(void *opaque, int bus_num, int addr, char *port,
}
DPRINTF("husb: auto open: bus_num %d addr %d\n", bus_num, addr);
usb_host_open(s, bus_num, addr, port, product_name, speed);
if (usb_host_open(s, bus_num, addr, port, product_name, speed) < 0) {
s->errcount++;
}
break;
}
@ -1770,12 +1855,17 @@ static void usb_host_auto_check(void *unused)
if (s->fd == -1) {
unconnected++;
}
if (s->seen == 0) {
s->errcount = 0;
}
s->seen = 0;
}
if (unconnected == 0) {
/* nothing to watch */
if (usb_auto_timer) {
qemu_del_timer(usb_auto_timer);
trace_usb_host_auto_scan_disabled();
}
return;
}
@ -1785,6 +1875,7 @@ static void usb_host_auto_check(void *unused)
if (!usb_auto_timer) {
return;
}
trace_usb_host_auto_scan_enabled();
}
qemu_mod_timer(usb_auto_timer, qemu_get_clock_ms(rt_clock) + 2000);
}
@ -1875,7 +1966,8 @@ static const char *usb_class_str(uint8_t class)
return p->class_name;
}
static void usb_info_device(Monitor *mon, int bus_num, int addr, char *port,
static void usb_info_device(Monitor *mon, int bus_num,
int addr, const char *port,
int class_id, int vendor_id, int product_id,
const char *product_name,
int speed)
@ -1916,7 +2008,7 @@ static void usb_info_device(Monitor *mon, int bus_num, int addr, char *port,
}
static int usb_host_info_device(void *opaque, int bus_num, int addr,
char *path, int class_id,
const char *path, int class_id,
int vendor_id, int product_id,
const char *product_name,
int speed)