2006-04-24 23:18:20 +02:00
|
|
|
/*
|
|
|
|
* QEMU USB HUB emulation
|
|
|
|
*
|
|
|
|
* Copyright (c) 2005 Fabrice Bellard
|
2007-09-16 23:08:06 +02:00
|
|
|
*
|
2006-04-24 23:18:20 +02:00
|
|
|
* 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.
|
|
|
|
*/
|
2016-01-26 19:17:12 +01:00
|
|
|
#include "qemu/osdep.h"
|
2007-11-17 18:14:51 +01:00
|
|
|
#include "qemu-common.h"
|
2012-03-23 15:42:58 +01:00
|
|
|
#include "trace.h"
|
2012-03-07 14:55:18 +01:00
|
|
|
#include "hw/usb.h"
|
|
|
|
#include "hw/usb/desc.h"
|
2013-03-20 11:40:02 +01:00
|
|
|
#include "qemu/error-report.h"
|
2006-04-24 23:18:20 +02:00
|
|
|
|
2010-11-26 13:13:22 +01:00
|
|
|
#define NUM_PORTS 8
|
2006-04-24 23:18:20 +02:00
|
|
|
|
|
|
|
typedef struct USBHubPort {
|
|
|
|
USBPort port;
|
|
|
|
uint16_t wPortStatus;
|
|
|
|
uint16_t wPortChange;
|
|
|
|
} USBHubPort;
|
|
|
|
|
|
|
|
typedef struct USBHubState {
|
|
|
|
USBDevice dev;
|
2012-01-17 13:25:46 +01:00
|
|
|
USBEndpoint *intr;
|
2010-11-26 13:13:22 +01:00
|
|
|
USBHubPort ports[NUM_PORTS];
|
2006-04-24 23:18:20 +02:00
|
|
|
} USBHubState;
|
|
|
|
|
2015-05-06 14:55:27 +02:00
|
|
|
#define TYPE_USB_HUB "usb-hub"
|
|
|
|
#define USB_HUB(obj) OBJECT_CHECK(USBHubState, (obj), TYPE_USB_HUB)
|
|
|
|
|
2006-04-24 23:18:20 +02:00
|
|
|
#define ClearHubFeature (0x2000 | USB_REQ_CLEAR_FEATURE)
|
|
|
|
#define ClearPortFeature (0x2300 | USB_REQ_CLEAR_FEATURE)
|
|
|
|
#define GetHubDescriptor (0xa000 | USB_REQ_GET_DESCRIPTOR)
|
|
|
|
#define GetHubStatus (0xa000 | USB_REQ_GET_STATUS)
|
|
|
|
#define GetPortStatus (0xa300 | USB_REQ_GET_STATUS)
|
|
|
|
#define SetHubFeature (0x2000 | USB_REQ_SET_FEATURE)
|
|
|
|
#define SetPortFeature (0x2300 | USB_REQ_SET_FEATURE)
|
|
|
|
|
|
|
|
#define PORT_STAT_CONNECTION 0x0001
|
|
|
|
#define PORT_STAT_ENABLE 0x0002
|
|
|
|
#define PORT_STAT_SUSPEND 0x0004
|
|
|
|
#define PORT_STAT_OVERCURRENT 0x0008
|
|
|
|
#define PORT_STAT_RESET 0x0010
|
|
|
|
#define PORT_STAT_POWER 0x0100
|
|
|
|
#define PORT_STAT_LOW_SPEED 0x0200
|
|
|
|
#define PORT_STAT_HIGH_SPEED 0x0400
|
|
|
|
#define PORT_STAT_TEST 0x0800
|
|
|
|
#define PORT_STAT_INDICATOR 0x1000
|
|
|
|
|
|
|
|
#define PORT_STAT_C_CONNECTION 0x0001
|
|
|
|
#define PORT_STAT_C_ENABLE 0x0002
|
|
|
|
#define PORT_STAT_C_SUSPEND 0x0004
|
|
|
|
#define PORT_STAT_C_OVERCURRENT 0x0008
|
|
|
|
#define PORT_STAT_C_RESET 0x0010
|
|
|
|
|
|
|
|
#define PORT_CONNECTION 0
|
|
|
|
#define PORT_ENABLE 1
|
|
|
|
#define PORT_SUSPEND 2
|
|
|
|
#define PORT_OVERCURRENT 3
|
|
|
|
#define PORT_RESET 4
|
|
|
|
#define PORT_POWER 8
|
|
|
|
#define PORT_LOWSPEED 9
|
|
|
|
#define PORT_HIGHSPEED 10
|
|
|
|
#define PORT_C_CONNECTION 16
|
|
|
|
#define PORT_C_ENABLE 17
|
|
|
|
#define PORT_C_SUSPEND 18
|
|
|
|
#define PORT_C_OVERCURRENT 19
|
|
|
|
#define PORT_C_RESET 20
|
|
|
|
#define PORT_TEST 21
|
|
|
|
#define PORT_INDICATOR 22
|
|
|
|
|
|
|
|
/* same as Linux kernel root hubs */
|
|
|
|
|
2010-11-26 13:13:22 +01:00
|
|
|
enum {
|
|
|
|
STR_MANUFACTURER = 1,
|
|
|
|
STR_PRODUCT,
|
|
|
|
STR_SERIALNUMBER,
|
|
|
|
};
|
|
|
|
|
|
|
|
static const USBDescStrings desc_strings = {
|
2012-05-30 05:35:51 +02:00
|
|
|
[STR_MANUFACTURER] = "QEMU",
|
2010-11-26 13:13:22 +01:00
|
|
|
[STR_PRODUCT] = "QEMU USB Hub",
|
|
|
|
[STR_SERIALNUMBER] = "314159",
|
|
|
|
};
|
|
|
|
|
|
|
|
static const USBDescIface desc_iface_hub = {
|
|
|
|
.bInterfaceNumber = 0,
|
|
|
|
.bNumEndpoints = 1,
|
|
|
|
.bInterfaceClass = USB_CLASS_HUB,
|
|
|
|
.eps = (USBDescEndpoint[]) {
|
|
|
|
{
|
|
|
|
.bEndpointAddress = USB_DIR_IN | 0x01,
|
|
|
|
.bmAttributes = USB_ENDPOINT_XFER_INT,
|
|
|
|
.wMaxPacketSize = 1 + (NUM_PORTS + 7) / 8,
|
|
|
|
.bInterval = 0xff,
|
|
|
|
},
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
static const USBDescDevice desc_device_hub = {
|
|
|
|
.bcdUSB = 0x0110,
|
|
|
|
.bDeviceClass = USB_CLASS_HUB,
|
|
|
|
.bMaxPacketSize0 = 8,
|
|
|
|
.bNumConfigurations = 1,
|
|
|
|
.confs = (USBDescConfig[]) {
|
|
|
|
{
|
|
|
|
.bNumInterfaces = 1,
|
|
|
|
.bConfigurationValue = 1,
|
2013-12-16 08:42:49 +01:00
|
|
|
.bmAttributes = USB_CFG_ATT_ONE | USB_CFG_ATT_SELFPOWER |
|
|
|
|
USB_CFG_ATT_WAKEUP,
|
2011-04-03 07:33:19 +02:00
|
|
|
.nif = 1,
|
2010-11-26 13:13:22 +01:00
|
|
|
.ifs = &desc_iface_hub,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
static const USBDesc desc_hub = {
|
|
|
|
.id = {
|
2011-09-15 05:25:47 +02:00
|
|
|
.idVendor = 0x0409,
|
|
|
|
.idProduct = 0x55aa,
|
2010-11-26 13:13:22 +01:00
|
|
|
.bcdDevice = 0x0101,
|
|
|
|
.iManufacturer = STR_MANUFACTURER,
|
|
|
|
.iProduct = STR_PRODUCT,
|
|
|
|
.iSerialNumber = STR_SERIALNUMBER,
|
|
|
|
},
|
|
|
|
.full = &desc_device_hub,
|
|
|
|
.str = desc_strings,
|
|
|
|
};
|
|
|
|
|
2006-04-24 23:18:20 +02:00
|
|
|
static const uint8_t qemu_hub_hub_descriptor[] =
|
|
|
|
{
|
2006-05-05 22:05:35 +02:00
|
|
|
0x00, /* u8 bLength; patched in later */
|
2006-04-24 23:18:20 +02:00
|
|
|
0x29, /* u8 bDescriptorType; Hub-descriptor */
|
|
|
|
0x00, /* u8 bNbrPorts; (patched later) */
|
|
|
|
0x0a, /* u16 wHubCharacteristics; */
|
|
|
|
0x00, /* (per-port OC, no power switching) */
|
|
|
|
0x01, /* u8 bPwrOn2pwrGood; 2ms */
|
2006-04-30 23:53:59 +02:00
|
|
|
0x00 /* u8 bHubContrCurrent; 0 mA */
|
|
|
|
|
|
|
|
/* DeviceRemovable and PortPwrCtrlMask patched in later */
|
2006-04-24 23:18:20 +02:00
|
|
|
};
|
|
|
|
|
2010-12-01 11:27:05 +01:00
|
|
|
static void usb_hub_attach(USBPort *port1)
|
2006-04-24 23:18:20 +02:00
|
|
|
{
|
|
|
|
USBHubState *s = port1->opaque;
|
|
|
|
USBHubPort *port = &s->ports[port1->index];
|
2007-09-17 10:09:54 +02:00
|
|
|
|
2012-03-23 15:42:58 +01:00
|
|
|
trace_usb_hub_attach(s->dev.addr, port1->index + 1);
|
2010-12-01 11:27:05 +01:00
|
|
|
port->wPortStatus |= PORT_STAT_CONNECTION;
|
|
|
|
port->wPortChange |= PORT_STAT_C_CONNECTION;
|
|
|
|
if (port->port.dev->speed == USB_SPEED_LOW) {
|
|
|
|
port->wPortStatus |= PORT_STAT_LOW_SPEED;
|
2006-04-24 23:18:20 +02:00
|
|
|
} else {
|
2010-12-01 11:27:05 +01:00
|
|
|
port->wPortStatus &= ~PORT_STAT_LOW_SPEED;
|
|
|
|
}
|
2013-01-29 12:44:35 +01:00
|
|
|
usb_wakeup(s->intr, 0);
|
2010-12-01 11:27:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static void usb_hub_detach(USBPort *port1)
|
|
|
|
{
|
|
|
|
USBHubState *s = port1->opaque;
|
|
|
|
USBHubPort *port = &s->ports[port1->index];
|
|
|
|
|
2012-03-23 15:42:58 +01:00
|
|
|
trace_usb_hub_detach(s->dev.addr, port1->index + 1);
|
2013-01-29 12:44:35 +01:00
|
|
|
usb_wakeup(s->intr, 0);
|
2011-11-22 13:20:14 +01:00
|
|
|
|
2011-06-24 12:31:11 +02:00
|
|
|
/* Let upstream know the device on this port is gone */
|
|
|
|
s->dev.port->ops->child_detach(s->dev.port, port1->dev);
|
|
|
|
|
2010-12-01 11:27:05 +01:00
|
|
|
port->wPortStatus &= ~PORT_STAT_CONNECTION;
|
|
|
|
port->wPortChange |= PORT_STAT_C_CONNECTION;
|
|
|
|
if (port->wPortStatus & PORT_STAT_ENABLE) {
|
|
|
|
port->wPortStatus &= ~PORT_STAT_ENABLE;
|
|
|
|
port->wPortChange |= PORT_STAT_C_ENABLE;
|
2006-04-24 23:18:20 +02:00
|
|
|
}
|
2013-01-29 12:44:35 +01:00
|
|
|
usb_wakeup(s->intr, 0);
|
2006-04-24 23:18:20 +02:00
|
|
|
}
|
|
|
|
|
2011-06-24 12:31:11 +02:00
|
|
|
static void usb_hub_child_detach(USBPort *port1, USBDevice *child)
|
|
|
|
{
|
|
|
|
USBHubState *s = port1->opaque;
|
|
|
|
|
|
|
|
/* Pass along upstream */
|
|
|
|
s->dev.port->ops->child_detach(s->dev.port, child);
|
|
|
|
}
|
|
|
|
|
2011-06-21 11:52:28 +02:00
|
|
|
static void usb_hub_wakeup(USBPort *port1)
|
2010-12-15 12:26:59 +01:00
|
|
|
{
|
2011-06-21 11:52:28 +02:00
|
|
|
USBHubState *s = port1->opaque;
|
|
|
|
USBHubPort *port = &s->ports[port1->index];
|
2010-12-15 12:26:59 +01:00
|
|
|
|
|
|
|
if (port->wPortStatus & PORT_STAT_SUSPEND) {
|
|
|
|
port->wPortChange |= PORT_STAT_C_SUSPEND;
|
2013-01-29 12:44:35 +01:00
|
|
|
usb_wakeup(s->intr, 0);
|
2010-12-15 12:26:59 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-06-21 11:52:28 +02:00
|
|
|
static void usb_hub_complete(USBPort *port, USBPacket *packet)
|
2010-12-16 17:03:44 +01:00
|
|
|
{
|
2011-06-21 11:52:28 +02:00
|
|
|
USBHubState *s = port->opaque;
|
2010-12-16 17:03:44 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Just pass it along upstream for now.
|
|
|
|
*
|
2011-10-13 12:52:47 +02:00
|
|
|
* If we ever implement usb 2.0 split transactions this will
|
2010-12-16 17:03:44 +01:00
|
|
|
* become a little more complicated ...
|
2011-10-13 12:52:47 +02:00
|
|
|
*
|
|
|
|
* Can't use usb_packet_complete() here because packet->owner is
|
|
|
|
* cleared already, go call the ->complete() callback directly
|
|
|
|
* instead.
|
2010-12-16 17:03:44 +01:00
|
|
|
*/
|
2011-10-13 12:52:47 +02:00
|
|
|
s->dev.port->ops->complete(s->dev.port, packet);
|
2010-12-16 17:03:44 +01:00
|
|
|
}
|
|
|
|
|
2012-01-10 17:08:13 +01:00
|
|
|
static USBDevice *usb_hub_find_device(USBDevice *dev, uint8_t addr)
|
|
|
|
{
|
2015-05-06 14:55:27 +02:00
|
|
|
USBHubState *s = USB_HUB(dev);
|
2012-01-10 17:08:13 +01:00
|
|
|
USBHubPort *port;
|
|
|
|
USBDevice *downstream;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < NUM_PORTS; i++) {
|
|
|
|
port = &s->ports[i];
|
|
|
|
if (!(port->wPortStatus & PORT_STAT_ENABLE)) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
downstream = usb_find_device(&port->port, addr);
|
|
|
|
if (downstream != NULL) {
|
|
|
|
return downstream;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2006-07-19 20:06:15 +02:00
|
|
|
static void usb_hub_handle_reset(USBDevice *dev)
|
2006-04-24 23:18:20 +02:00
|
|
|
{
|
2015-05-06 14:55:27 +02:00
|
|
|
USBHubState *s = USB_HUB(dev);
|
2011-11-23 13:31:08 +01:00
|
|
|
USBHubPort *port;
|
|
|
|
int i;
|
|
|
|
|
2012-03-23 15:42:58 +01:00
|
|
|
trace_usb_hub_reset(s->dev.addr);
|
2011-11-23 13:31:08 +01:00
|
|
|
for (i = 0; i < NUM_PORTS; i++) {
|
|
|
|
port = s->ports + i;
|
|
|
|
port->wPortStatus = PORT_STAT_POWER;
|
|
|
|
port->wPortChange = 0;
|
|
|
|
if (port->port.dev && port->port.dev->attached) {
|
|
|
|
port->wPortStatus |= PORT_STAT_CONNECTION;
|
|
|
|
port->wPortChange |= PORT_STAT_C_CONNECTION;
|
|
|
|
if (port->port.dev->speed == USB_SPEED_LOW) {
|
|
|
|
port->wPortStatus |= PORT_STAT_LOW_SPEED;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2006-04-24 23:18:20 +02:00
|
|
|
}
|
|
|
|
|
2012-03-23 15:42:58 +01:00
|
|
|
static const char *feature_name(int feature)
|
|
|
|
{
|
|
|
|
static const char *name[] = {
|
|
|
|
[PORT_CONNECTION] = "connection",
|
|
|
|
[PORT_ENABLE] = "enable",
|
|
|
|
[PORT_SUSPEND] = "suspend",
|
|
|
|
[PORT_OVERCURRENT] = "overcurrent",
|
|
|
|
[PORT_RESET] = "reset",
|
|
|
|
[PORT_POWER] = "power",
|
|
|
|
[PORT_LOWSPEED] = "lowspeed",
|
|
|
|
[PORT_HIGHSPEED] = "highspeed",
|
|
|
|
[PORT_C_CONNECTION] = "change connection",
|
|
|
|
[PORT_C_ENABLE] = "change enable",
|
|
|
|
[PORT_C_SUSPEND] = "change suspend",
|
|
|
|
[PORT_C_OVERCURRENT] = "change overcurrent",
|
|
|
|
[PORT_C_RESET] = "change reset",
|
|
|
|
[PORT_TEST] = "test",
|
|
|
|
[PORT_INDICATOR] = "indicator",
|
|
|
|
};
|
|
|
|
if (feature < 0 || feature >= ARRAY_SIZE(name)) {
|
|
|
|
return "?";
|
|
|
|
}
|
|
|
|
return name[feature] ?: "?";
|
|
|
|
}
|
|
|
|
|
usb: split packet result into actual_length + status
Since with the ehci and xhci controllers a single packet can be larger
then maxpacketsize, it is possible for the result of a single packet
to be both having transferred some data as well as the transfer to have
an error.
An example would be an input transfer from a bulk endpoint successfully
receiving 1 or more maxpacketsize packets from the device, followed
by a packet signalling halt.
While already touching all the devices and controllers handle_packet /
handle_data / handle_control code, also change the return type of
these functions to void, solely storing the status in the packet. To
make the code paths for regular versus async packet handling more
uniform.
This patch unfortunately is somewhat invasive, since makeing the qemu
usb core deal with this requires changes everywhere. This patch only
prepares the usb core for this, all the hcd / device changes are done
in such a way that there are no functional changes.
This patch has been tested with uhci and ehci hcds, together with usb-audio,
usb-hid and usb-storage devices, as well as with usb-redir redirection
with a wide variety of real devices.
Note that there is usually no need to directly set packet->actual_length
form devices handle_data callback, as that is done by usb_packet_copy()
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
2012-11-01 17:15:01 +01:00
|
|
|
static void usb_hub_handle_control(USBDevice *dev, USBPacket *p,
|
2011-02-02 16:33:13 +01:00
|
|
|
int request, int value, int index, int length, uint8_t *data)
|
2006-04-24 23:18:20 +02:00
|
|
|
{
|
|
|
|
USBHubState *s = (USBHubState *)dev;
|
|
|
|
int ret;
|
|
|
|
|
2012-03-23 15:42:58 +01:00
|
|
|
trace_usb_hub_control(s->dev.addr, request, value, index, length);
|
|
|
|
|
2011-02-02 16:33:13 +01:00
|
|
|
ret = usb_desc_handle_control(dev, p, request, value, index, length, data);
|
2010-11-26 13:13:22 +01:00
|
|
|
if (ret >= 0) {
|
usb: split packet result into actual_length + status
Since with the ehci and xhci controllers a single packet can be larger
then maxpacketsize, it is possible for the result of a single packet
to be both having transferred some data as well as the transfer to have
an error.
An example would be an input transfer from a bulk endpoint successfully
receiving 1 or more maxpacketsize packets from the device, followed
by a packet signalling halt.
While already touching all the devices and controllers handle_packet /
handle_data / handle_control code, also change the return type of
these functions to void, solely storing the status in the packet. To
make the code paths for regular versus async packet handling more
uniform.
This patch unfortunately is somewhat invasive, since makeing the qemu
usb core deal with this requires changes everywhere. This patch only
prepares the usb core for this, all the hcd / device changes are done
in such a way that there are no functional changes.
This patch has been tested with uhci and ehci hcds, together with usb-audio,
usb-hid and usb-storage devices, as well as with usb-redir redirection
with a wide variety of real devices.
Note that there is usually no need to directly set packet->actual_length
form devices handle_data callback, as that is done by usb_packet_copy()
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
2012-11-01 17:15:01 +01:00
|
|
|
return;
|
2010-11-26 13:13:22 +01:00
|
|
|
}
|
|
|
|
|
2006-04-24 23:18:20 +02:00
|
|
|
switch(request) {
|
2006-04-30 23:53:59 +02:00
|
|
|
case EndpointOutRequest | USB_REQ_CLEAR_FEATURE:
|
|
|
|
if (value == 0 && index != 0x81) { /* clear ep halt */
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
break;
|
2006-04-24 23:18:20 +02:00
|
|
|
/* usb specific requests */
|
|
|
|
case GetHubStatus:
|
|
|
|
data[0] = 0;
|
|
|
|
data[1] = 0;
|
|
|
|
data[2] = 0;
|
|
|
|
data[3] = 0;
|
usb: split packet result into actual_length + status
Since with the ehci and xhci controllers a single packet can be larger
then maxpacketsize, it is possible for the result of a single packet
to be both having transferred some data as well as the transfer to have
an error.
An example would be an input transfer from a bulk endpoint successfully
receiving 1 or more maxpacketsize packets from the device, followed
by a packet signalling halt.
While already touching all the devices and controllers handle_packet /
handle_data / handle_control code, also change the return type of
these functions to void, solely storing the status in the packet. To
make the code paths for regular versus async packet handling more
uniform.
This patch unfortunately is somewhat invasive, since makeing the qemu
usb core deal with this requires changes everywhere. This patch only
prepares the usb core for this, all the hcd / device changes are done
in such a way that there are no functional changes.
This patch has been tested with uhci and ehci hcds, together with usb-audio,
usb-hid and usb-storage devices, as well as with usb-redir redirection
with a wide variety of real devices.
Note that there is usually no need to directly set packet->actual_length
form devices handle_data callback, as that is done by usb_packet_copy()
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
2012-11-01 17:15:01 +01:00
|
|
|
p->actual_length = 4;
|
2006-04-24 23:18:20 +02:00
|
|
|
break;
|
|
|
|
case GetPortStatus:
|
|
|
|
{
|
|
|
|
unsigned int n = index - 1;
|
|
|
|
USBHubPort *port;
|
2010-11-26 13:13:22 +01:00
|
|
|
if (n >= NUM_PORTS) {
|
2006-04-24 23:18:20 +02:00
|
|
|
goto fail;
|
2010-11-26 13:13:22 +01:00
|
|
|
}
|
2006-04-24 23:18:20 +02:00
|
|
|
port = &s->ports[n];
|
2012-03-23 15:42:58 +01:00
|
|
|
trace_usb_hub_get_port_status(s->dev.addr, index,
|
|
|
|
port->wPortStatus,
|
|
|
|
port->wPortChange);
|
2006-04-24 23:18:20 +02:00
|
|
|
data[0] = port->wPortStatus;
|
|
|
|
data[1] = port->wPortStatus >> 8;
|
|
|
|
data[2] = port->wPortChange;
|
|
|
|
data[3] = port->wPortChange >> 8;
|
usb: split packet result into actual_length + status
Since with the ehci and xhci controllers a single packet can be larger
then maxpacketsize, it is possible for the result of a single packet
to be both having transferred some data as well as the transfer to have
an error.
An example would be an input transfer from a bulk endpoint successfully
receiving 1 or more maxpacketsize packets from the device, followed
by a packet signalling halt.
While already touching all the devices and controllers handle_packet /
handle_data / handle_control code, also change the return type of
these functions to void, solely storing the status in the packet. To
make the code paths for regular versus async packet handling more
uniform.
This patch unfortunately is somewhat invasive, since makeing the qemu
usb core deal with this requires changes everywhere. This patch only
prepares the usb core for this, all the hcd / device changes are done
in such a way that there are no functional changes.
This patch has been tested with uhci and ehci hcds, together with usb-audio,
usb-hid and usb-storage devices, as well as with usb-redir redirection
with a wide variety of real devices.
Note that there is usually no need to directly set packet->actual_length
form devices handle_data callback, as that is done by usb_packet_copy()
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
2012-11-01 17:15:01 +01:00
|
|
|
p->actual_length = 4;
|
2006-04-24 23:18:20 +02:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case SetHubFeature:
|
|
|
|
case ClearHubFeature:
|
usb: split packet result into actual_length + status
Since with the ehci and xhci controllers a single packet can be larger
then maxpacketsize, it is possible for the result of a single packet
to be both having transferred some data as well as the transfer to have
an error.
An example would be an input transfer from a bulk endpoint successfully
receiving 1 or more maxpacketsize packets from the device, followed
by a packet signalling halt.
While already touching all the devices and controllers handle_packet /
handle_data / handle_control code, also change the return type of
these functions to void, solely storing the status in the packet. To
make the code paths for regular versus async packet handling more
uniform.
This patch unfortunately is somewhat invasive, since makeing the qemu
usb core deal with this requires changes everywhere. This patch only
prepares the usb core for this, all the hcd / device changes are done
in such a way that there are no functional changes.
This patch has been tested with uhci and ehci hcds, together with usb-audio,
usb-hid and usb-storage devices, as well as with usb-redir redirection
with a wide variety of real devices.
Note that there is usually no need to directly set packet->actual_length
form devices handle_data callback, as that is done by usb_packet_copy()
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
2012-11-01 17:15:01 +01:00
|
|
|
if (value != 0 && value != 1) {
|
2006-04-24 23:18:20 +02:00
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case SetPortFeature:
|
|
|
|
{
|
|
|
|
unsigned int n = index - 1;
|
|
|
|
USBHubPort *port;
|
|
|
|
USBDevice *dev;
|
2012-03-23 15:42:58 +01:00
|
|
|
|
|
|
|
trace_usb_hub_set_port_feature(s->dev.addr, index,
|
|
|
|
feature_name(value));
|
|
|
|
|
2010-11-26 13:13:22 +01:00
|
|
|
if (n >= NUM_PORTS) {
|
2006-04-24 23:18:20 +02:00
|
|
|
goto fail;
|
2010-11-26 13:13:22 +01:00
|
|
|
}
|
2006-04-24 23:18:20 +02:00
|
|
|
port = &s->ports[n];
|
|
|
|
dev = port->port.dev;
|
|
|
|
switch(value) {
|
|
|
|
case PORT_SUSPEND:
|
|
|
|
port->wPortStatus |= PORT_STAT_SUSPEND;
|
|
|
|
break;
|
|
|
|
case PORT_RESET:
|
2011-09-15 09:20:02 +02:00
|
|
|
if (dev && dev->attached) {
|
2012-01-06 15:23:10 +01:00
|
|
|
usb_device_reset(dev);
|
2006-04-24 23:18:20 +02:00
|
|
|
port->wPortChange |= PORT_STAT_C_RESET;
|
|
|
|
/* set enable bit */
|
|
|
|
port->wPortStatus |= PORT_STAT_ENABLE;
|
2013-01-29 12:44:35 +01:00
|
|
|
usb_wakeup(s->intr, 0);
|
2006-04-24 23:18:20 +02:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case PORT_POWER:
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case ClearPortFeature:
|
|
|
|
{
|
|
|
|
unsigned int n = index - 1;
|
|
|
|
USBHubPort *port;
|
2010-04-25 20:23:04 +02:00
|
|
|
|
2012-03-23 15:42:58 +01:00
|
|
|
trace_usb_hub_clear_port_feature(s->dev.addr, index,
|
|
|
|
feature_name(value));
|
|
|
|
|
2010-11-26 13:13:22 +01:00
|
|
|
if (n >= NUM_PORTS) {
|
2006-04-24 23:18:20 +02:00
|
|
|
goto fail;
|
2010-11-26 13:13:22 +01:00
|
|
|
}
|
2006-04-24 23:18:20 +02:00
|
|
|
port = &s->ports[n];
|
|
|
|
switch(value) {
|
|
|
|
case PORT_ENABLE:
|
|
|
|
port->wPortStatus &= ~PORT_STAT_ENABLE;
|
|
|
|
break;
|
|
|
|
case PORT_C_ENABLE:
|
|
|
|
port->wPortChange &= ~PORT_STAT_C_ENABLE;
|
|
|
|
break;
|
|
|
|
case PORT_SUSPEND:
|
|
|
|
port->wPortStatus &= ~PORT_STAT_SUSPEND;
|
|
|
|
break;
|
|
|
|
case PORT_C_SUSPEND:
|
|
|
|
port->wPortChange &= ~PORT_STAT_C_SUSPEND;
|
|
|
|
break;
|
|
|
|
case PORT_C_CONNECTION:
|
|
|
|
port->wPortChange &= ~PORT_STAT_C_CONNECTION;
|
|
|
|
break;
|
|
|
|
case PORT_C_OVERCURRENT:
|
|
|
|
port->wPortChange &= ~PORT_STAT_C_OVERCURRENT;
|
|
|
|
break;
|
|
|
|
case PORT_C_RESET:
|
|
|
|
port->wPortChange &= ~PORT_STAT_C_RESET;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case GetHubDescriptor:
|
2006-04-30 23:53:59 +02:00
|
|
|
{
|
|
|
|
unsigned int n, limit, var_hub_size = 0;
|
2007-09-16 23:08:06 +02:00
|
|
|
memcpy(data, qemu_hub_hub_descriptor,
|
2006-04-30 23:53:59 +02:00
|
|
|
sizeof(qemu_hub_hub_descriptor));
|
2010-11-26 13:13:22 +01:00
|
|
|
data[2] = NUM_PORTS;
|
2006-04-30 23:53:59 +02:00
|
|
|
|
|
|
|
/* fill DeviceRemovable bits */
|
2010-11-26 13:13:22 +01:00
|
|
|
limit = ((NUM_PORTS + 1 + 7) / 8) + 7;
|
2006-04-30 23:53:59 +02:00
|
|
|
for (n = 7; n < limit; n++) {
|
|
|
|
data[n] = 0x00;
|
|
|
|
var_hub_size++;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* fill PortPwrCtrlMask bits */
|
2010-11-26 13:13:22 +01:00
|
|
|
limit = limit + ((NUM_PORTS + 7) / 8);
|
2006-04-30 23:53:59 +02:00
|
|
|
for (;n < limit; n++) {
|
|
|
|
data[n] = 0xff;
|
|
|
|
var_hub_size++;
|
|
|
|
}
|
|
|
|
|
usb: split packet result into actual_length + status
Since with the ehci and xhci controllers a single packet can be larger
then maxpacketsize, it is possible for the result of a single packet
to be both having transferred some data as well as the transfer to have
an error.
An example would be an input transfer from a bulk endpoint successfully
receiving 1 or more maxpacketsize packets from the device, followed
by a packet signalling halt.
While already touching all the devices and controllers handle_packet /
handle_data / handle_control code, also change the return type of
these functions to void, solely storing the status in the packet. To
make the code paths for regular versus async packet handling more
uniform.
This patch unfortunately is somewhat invasive, since makeing the qemu
usb core deal with this requires changes everywhere. This patch only
prepares the usb core for this, all the hcd / device changes are done
in such a way that there are no functional changes.
This patch has been tested with uhci and ehci hcds, together with usb-audio,
usb-hid and usb-storage devices, as well as with usb-redir redirection
with a wide variety of real devices.
Note that there is usually no need to directly set packet->actual_length
form devices handle_data callback, as that is done by usb_packet_copy()
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
2012-11-01 17:15:01 +01:00
|
|
|
p->actual_length = sizeof(qemu_hub_hub_descriptor) + var_hub_size;
|
|
|
|
data[0] = p->actual_length;
|
2006-04-30 23:53:59 +02:00
|
|
|
break;
|
|
|
|
}
|
2006-04-24 23:18:20 +02:00
|
|
|
default:
|
|
|
|
fail:
|
usb: split packet result into actual_length + status
Since with the ehci and xhci controllers a single packet can be larger
then maxpacketsize, it is possible for the result of a single packet
to be both having transferred some data as well as the transfer to have
an error.
An example would be an input transfer from a bulk endpoint successfully
receiving 1 or more maxpacketsize packets from the device, followed
by a packet signalling halt.
While already touching all the devices and controllers handle_packet /
handle_data / handle_control code, also change the return type of
these functions to void, solely storing the status in the packet. To
make the code paths for regular versus async packet handling more
uniform.
This patch unfortunately is somewhat invasive, since makeing the qemu
usb core deal with this requires changes everywhere. This patch only
prepares the usb core for this, all the hcd / device changes are done
in such a way that there are no functional changes.
This patch has been tested with uhci and ehci hcds, together with usb-audio,
usb-hid and usb-storage devices, as well as with usb-redir redirection
with a wide variety of real devices.
Note that there is usually no need to directly set packet->actual_length
form devices handle_data callback, as that is done by usb_packet_copy()
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
2012-11-01 17:15:01 +01:00
|
|
|
p->status = USB_RET_STALL;
|
2006-04-24 23:18:20 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
usb: split packet result into actual_length + status
Since with the ehci and xhci controllers a single packet can be larger
then maxpacketsize, it is possible for the result of a single packet
to be both having transferred some data as well as the transfer to have
an error.
An example would be an input transfer from a bulk endpoint successfully
receiving 1 or more maxpacketsize packets from the device, followed
by a packet signalling halt.
While already touching all the devices and controllers handle_packet /
handle_data / handle_control code, also change the return type of
these functions to void, solely storing the status in the packet. To
make the code paths for regular versus async packet handling more
uniform.
This patch unfortunately is somewhat invasive, since makeing the qemu
usb core deal with this requires changes everywhere. This patch only
prepares the usb core for this, all the hcd / device changes are done
in such a way that there are no functional changes.
This patch has been tested with uhci and ehci hcds, together with usb-audio,
usb-hid and usb-storage devices, as well as with usb-redir redirection
with a wide variety of real devices.
Note that there is usually no need to directly set packet->actual_length
form devices handle_data callback, as that is done by usb_packet_copy()
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
2012-11-01 17:15:01 +01:00
|
|
|
static void usb_hub_handle_data(USBDevice *dev, USBPacket *p)
|
2006-04-24 23:18:20 +02:00
|
|
|
{
|
|
|
|
USBHubState *s = (USBHubState *)dev;
|
|
|
|
|
2006-08-12 03:04:27 +02:00
|
|
|
switch(p->pid) {
|
2006-04-24 23:18:20 +02:00
|
|
|
case USB_TOKEN_IN:
|
2012-01-12 13:23:01 +01:00
|
|
|
if (p->ep->nr == 1) {
|
2006-04-24 23:18:20 +02:00
|
|
|
USBHubPort *port;
|
|
|
|
unsigned int status;
|
2011-07-12 15:22:25 +02:00
|
|
|
uint8_t buf[4];
|
2006-04-24 23:18:20 +02:00
|
|
|
int i, n;
|
2010-11-26 13:13:22 +01:00
|
|
|
n = (NUM_PORTS + 1 + 7) / 8;
|
2011-07-12 15:22:25 +02:00
|
|
|
if (p->iov.size == 1) { /* FreeBSD workaround */
|
2006-04-30 23:53:59 +02:00
|
|
|
n = 1;
|
2011-07-12 15:22:25 +02:00
|
|
|
} else if (n > p->iov.size) {
|
usb: split packet result into actual_length + status
Since with the ehci and xhci controllers a single packet can be larger
then maxpacketsize, it is possible for the result of a single packet
to be both having transferred some data as well as the transfer to have
an error.
An example would be an input transfer from a bulk endpoint successfully
receiving 1 or more maxpacketsize packets from the device, followed
by a packet signalling halt.
While already touching all the devices and controllers handle_packet /
handle_data / handle_control code, also change the return type of
these functions to void, solely storing the status in the packet. To
make the code paths for regular versus async packet handling more
uniform.
This patch unfortunately is somewhat invasive, since makeing the qemu
usb core deal with this requires changes everywhere. This patch only
prepares the usb core for this, all the hcd / device changes are done
in such a way that there are no functional changes.
This patch has been tested with uhci and ehci hcds, together with usb-audio,
usb-hid and usb-storage devices, as well as with usb-redir redirection
with a wide variety of real devices.
Note that there is usually no need to directly set packet->actual_length
form devices handle_data callback, as that is done by usb_packet_copy()
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
2012-11-01 17:15:01 +01:00
|
|
|
p->status = USB_RET_BABBLE;
|
|
|
|
return;
|
2006-04-30 23:53:59 +02:00
|
|
|
}
|
2006-04-24 23:18:20 +02:00
|
|
|
status = 0;
|
2010-11-26 13:13:22 +01:00
|
|
|
for(i = 0; i < NUM_PORTS; i++) {
|
2006-04-24 23:18:20 +02:00
|
|
|
port = &s->ports[i];
|
2013-08-27 17:00:04 +02:00
|
|
|
if (port->wPortChange)
|
2006-04-24 23:18:20 +02:00
|
|
|
status |= (1 << (i + 1));
|
|
|
|
}
|
|
|
|
if (status != 0) {
|
2013-08-27 16:59:37 +02:00
|
|
|
trace_usb_hub_status_report(s->dev.addr, status);
|
2006-04-24 23:18:20 +02:00
|
|
|
for(i = 0; i < n; i++) {
|
2011-07-12 15:22:25 +02:00
|
|
|
buf[i] = status >> (8 * i);
|
2006-04-24 23:18:20 +02:00
|
|
|
}
|
2011-07-12 15:22:25 +02:00
|
|
|
usb_packet_copy(p, buf, n);
|
2006-04-24 23:18:20 +02:00
|
|
|
} else {
|
usb: split packet result into actual_length + status
Since with the ehci and xhci controllers a single packet can be larger
then maxpacketsize, it is possible for the result of a single packet
to be both having transferred some data as well as the transfer to have
an error.
An example would be an input transfer from a bulk endpoint successfully
receiving 1 or more maxpacketsize packets from the device, followed
by a packet signalling halt.
While already touching all the devices and controllers handle_packet /
handle_data / handle_control code, also change the return type of
these functions to void, solely storing the status in the packet. To
make the code paths for regular versus async packet handling more
uniform.
This patch unfortunately is somewhat invasive, since makeing the qemu
usb core deal with this requires changes everywhere. This patch only
prepares the usb core for this, all the hcd / device changes are done
in such a way that there are no functional changes.
This patch has been tested with uhci and ehci hcds, together with usb-audio,
usb-hid and usb-storage devices, as well as with usb-redir redirection
with a wide variety of real devices.
Note that there is usually no need to directly set packet->actual_length
form devices handle_data callback, as that is done by usb_packet_copy()
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
2012-11-01 17:15:01 +01:00
|
|
|
p->status = USB_RET_NAK; /* usb11 11.13.1 */
|
2006-04-24 23:18:20 +02:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case USB_TOKEN_OUT:
|
|
|
|
default:
|
|
|
|
fail:
|
usb: split packet result into actual_length + status
Since with the ehci and xhci controllers a single packet can be larger
then maxpacketsize, it is possible for the result of a single packet
to be both having transferred some data as well as the transfer to have
an error.
An example would be an input transfer from a bulk endpoint successfully
receiving 1 or more maxpacketsize packets from the device, followed
by a packet signalling halt.
While already touching all the devices and controllers handle_packet /
handle_data / handle_control code, also change the return type of
these functions to void, solely storing the status in the packet. To
make the code paths for regular versus async packet handling more
uniform.
This patch unfortunately is somewhat invasive, since makeing the qemu
usb core deal with this requires changes everywhere. This patch only
prepares the usb core for this, all the hcd / device changes are done
in such a way that there are no functional changes.
This patch has been tested with uhci and ehci hcds, together with usb-audio,
usb-hid and usb-storage devices, as well as with usb-redir redirection
with a wide variety of real devices.
Note that there is usually no need to directly set packet->actual_length
form devices handle_data callback, as that is done by usb_packet_copy()
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
2012-11-01 17:15:01 +01:00
|
|
|
p->status = USB_RET_STALL;
|
2006-04-24 23:18:20 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-07-19 20:06:15 +02:00
|
|
|
static void usb_hub_handle_destroy(USBDevice *dev)
|
|
|
|
{
|
|
|
|
USBHubState *s = (USBHubState *)dev;
|
2009-09-25 21:42:39 +02:00
|
|
|
int i;
|
2006-07-19 20:06:15 +02:00
|
|
|
|
2010-11-26 13:13:22 +01:00
|
|
|
for (i = 0; i < NUM_PORTS; i++) {
|
2009-09-25 21:42:39 +02:00
|
|
|
usb_unregister_port(usb_bus_from_device(dev),
|
|
|
|
&s->ports[i].port);
|
|
|
|
}
|
2006-07-19 20:06:15 +02:00
|
|
|
}
|
|
|
|
|
2010-12-01 11:08:44 +01:00
|
|
|
static USBPortOps usb_hub_port_ops = {
|
|
|
|
.attach = usb_hub_attach,
|
2010-12-01 11:27:05 +01:00
|
|
|
.detach = usb_hub_detach,
|
2011-06-24 12:31:11 +02:00
|
|
|
.child_detach = usb_hub_child_detach,
|
2010-12-15 12:26:59 +01:00
|
|
|
.wakeup = usb_hub_wakeup,
|
2010-12-16 17:03:44 +01:00
|
|
|
.complete = usb_hub_complete,
|
2010-12-01 11:08:44 +01:00
|
|
|
};
|
|
|
|
|
2014-09-19 08:48:28 +02:00
|
|
|
static void usb_hub_realize(USBDevice *dev, Error **errp)
|
2006-04-24 23:18:20 +02:00
|
|
|
{
|
2015-05-06 14:55:27 +02:00
|
|
|
USBHubState *s = USB_HUB(dev);
|
2006-04-24 23:18:20 +02:00
|
|
|
USBHubPort *port;
|
|
|
|
int i;
|
|
|
|
|
2013-03-20 11:40:02 +01:00
|
|
|
if (dev->port->hubcount == 5) {
|
2014-09-19 08:48:28 +02:00
|
|
|
error_setg(errp, "usb hub chain too deep");
|
|
|
|
return;
|
2013-03-20 11:40:02 +01:00
|
|
|
}
|
|
|
|
|
2012-04-20 12:33:30 +02:00
|
|
|
usb_desc_create_serial(dev);
|
2010-11-26 20:20:41 +01:00
|
|
|
usb_desc_init(dev);
|
2012-01-17 13:25:46 +01:00
|
|
|
s->intr = usb_ep_get(dev, USB_TOKEN_IN, 1);
|
2010-11-26 13:13:22 +01:00
|
|
|
for (i = 0; i < NUM_PORTS; i++) {
|
2006-04-24 23:18:20 +02:00
|
|
|
port = &s->ports[i];
|
2009-08-31 14:24:00 +02:00
|
|
|
usb_register_port(usb_bus_from_device(dev),
|
2011-01-12 11:34:50 +01:00
|
|
|
&port->port, s, i, &usb_hub_port_ops,
|
2010-12-03 17:30:13 +01:00
|
|
|
USB_SPEED_MASK_LOW | USB_SPEED_MASK_FULL);
|
2011-09-01 13:56:37 +02:00
|
|
|
usb_port_location(&port->port, dev->port, i+1);
|
2006-04-24 23:18:20 +02:00
|
|
|
}
|
2011-11-23 13:31:08 +01:00
|
|
|
usb_hub_handle_reset(dev);
|
2009-08-31 14:23:59 +02:00
|
|
|
}
|
|
|
|
|
2010-12-15 12:45:24 +01:00
|
|
|
static const VMStateDescription vmstate_usb_hub_port = {
|
|
|
|
.name = "usb-hub-port",
|
|
|
|
.version_id = 1,
|
|
|
|
.minimum_version_id = 1,
|
2014-04-16 13:31:26 +02:00
|
|
|
.fields = (VMStateField[]) {
|
2010-12-15 12:45:24 +01:00
|
|
|
VMSTATE_UINT16(wPortStatus, USBHubPort),
|
|
|
|
VMSTATE_UINT16(wPortChange, USBHubPort),
|
|
|
|
VMSTATE_END_OF_LIST()
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
static const VMStateDescription vmstate_usb_hub = {
|
|
|
|
.name = "usb-hub",
|
|
|
|
.version_id = 1,
|
|
|
|
.minimum_version_id = 1,
|
2014-04-16 13:31:26 +02:00
|
|
|
.fields = (VMStateField[]) {
|
2010-12-15 12:45:24 +01:00
|
|
|
VMSTATE_USB_DEVICE(dev, USBHubState),
|
|
|
|
VMSTATE_STRUCT_ARRAY(ports, USBHubState, NUM_PORTS, 0,
|
|
|
|
vmstate_usb_hub_port, USBHubPort),
|
|
|
|
VMSTATE_END_OF_LIST()
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2011-12-08 04:34:16 +01:00
|
|
|
static void usb_hub_class_initfn(ObjectClass *klass, void *data)
|
2011-12-15 21:53:10 +01:00
|
|
|
{
|
2011-12-08 04:34:16 +01:00
|
|
|
DeviceClass *dc = DEVICE_CLASS(klass);
|
2011-12-15 21:53:10 +01:00
|
|
|
USBDeviceClass *uc = USB_DEVICE_CLASS(klass);
|
|
|
|
|
2014-09-19 08:48:28 +02:00
|
|
|
uc->realize = usb_hub_realize;
|
2011-12-15 21:53:10 +01:00
|
|
|
uc->product_desc = "QEMU USB Hub";
|
|
|
|
uc->usb_desc = &desc_hub;
|
2012-01-10 17:08:13 +01:00
|
|
|
uc->find_device = usb_hub_find_device;
|
2011-12-15 21:53:10 +01:00
|
|
|
uc->handle_reset = usb_hub_handle_reset;
|
|
|
|
uc->handle_control = usb_hub_handle_control;
|
|
|
|
uc->handle_data = usb_hub_handle_data;
|
|
|
|
uc->handle_destroy = usb_hub_handle_destroy;
|
2013-07-29 16:17:45 +02:00
|
|
|
set_bit(DEVICE_CATEGORY_BRIDGE, dc->categories);
|
2011-12-08 04:34:16 +01:00
|
|
|
dc->fw_name = "hub";
|
|
|
|
dc->vmsd = &vmstate_usb_hub;
|
2011-12-15 21:53:10 +01:00
|
|
|
}
|
|
|
|
|
2013-01-10 16:19:07 +01:00
|
|
|
static const TypeInfo hub_info = {
|
2015-05-06 14:55:27 +02:00
|
|
|
.name = TYPE_USB_HUB,
|
2011-12-08 04:34:16 +01:00
|
|
|
.parent = TYPE_USB_DEVICE,
|
|
|
|
.instance_size = sizeof(USBHubState),
|
|
|
|
.class_init = usb_hub_class_initfn,
|
2009-08-31 14:23:59 +02:00
|
|
|
};
|
|
|
|
|
2012-02-09 15:20:55 +01:00
|
|
|
static void usb_hub_register_types(void)
|
2009-08-31 14:23:59 +02:00
|
|
|
{
|
2011-12-08 04:34:16 +01:00
|
|
|
type_register_static(&hub_info);
|
2006-04-24 23:18:20 +02:00
|
|
|
}
|
2012-02-09 15:20:55 +01:00
|
|
|
|
|
|
|
type_init(usb_hub_register_types)
|