2 * QEMU USB HUB emulation
4 * Copyright (c) 2005 Fabrice Bellard
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
24 #include "qemu-common.h"
27 #include "hw/usb/desc.h"
28 #include "qemu/error-report.h"
32 typedef struct USBHubPort
{
38 typedef struct USBHubState
{
41 USBHubPort ports
[NUM_PORTS
];
44 #define TYPE_USB_HUB "usb-hub"
45 #define USB_HUB(obj) OBJECT_CHECK(USBHubState, (obj), TYPE_USB_HUB)
47 #define ClearHubFeature (0x2000 | USB_REQ_CLEAR_FEATURE)
48 #define ClearPortFeature (0x2300 | USB_REQ_CLEAR_FEATURE)
49 #define GetHubDescriptor (0xa000 | USB_REQ_GET_DESCRIPTOR)
50 #define GetHubStatus (0xa000 | USB_REQ_GET_STATUS)
51 #define GetPortStatus (0xa300 | USB_REQ_GET_STATUS)
52 #define SetHubFeature (0x2000 | USB_REQ_SET_FEATURE)
53 #define SetPortFeature (0x2300 | USB_REQ_SET_FEATURE)
55 #define PORT_STAT_CONNECTION 0x0001
56 #define PORT_STAT_ENABLE 0x0002
57 #define PORT_STAT_SUSPEND 0x0004
58 #define PORT_STAT_OVERCURRENT 0x0008
59 #define PORT_STAT_RESET 0x0010
60 #define PORT_STAT_POWER 0x0100
61 #define PORT_STAT_LOW_SPEED 0x0200
62 #define PORT_STAT_HIGH_SPEED 0x0400
63 #define PORT_STAT_TEST 0x0800
64 #define PORT_STAT_INDICATOR 0x1000
66 #define PORT_STAT_C_CONNECTION 0x0001
67 #define PORT_STAT_C_ENABLE 0x0002
68 #define PORT_STAT_C_SUSPEND 0x0004
69 #define PORT_STAT_C_OVERCURRENT 0x0008
70 #define PORT_STAT_C_RESET 0x0010
72 #define PORT_CONNECTION 0
74 #define PORT_SUSPEND 2
75 #define PORT_OVERCURRENT 3
78 #define PORT_LOWSPEED 9
79 #define PORT_HIGHSPEED 10
80 #define PORT_C_CONNECTION 16
81 #define PORT_C_ENABLE 17
82 #define PORT_C_SUSPEND 18
83 #define PORT_C_OVERCURRENT 19
84 #define PORT_C_RESET 20
86 #define PORT_INDICATOR 22
88 /* same as Linux kernel root hubs */
96 static const USBDescStrings desc_strings
= {
97 [STR_MANUFACTURER
] = "QEMU",
98 [STR_PRODUCT
] = "QEMU USB Hub",
99 [STR_SERIALNUMBER
] = "314159",
102 static const USBDescIface desc_iface_hub
= {
103 .bInterfaceNumber
= 0,
105 .bInterfaceClass
= USB_CLASS_HUB
,
106 .eps
= (USBDescEndpoint
[]) {
108 .bEndpointAddress
= USB_DIR_IN
| 0x01,
109 .bmAttributes
= USB_ENDPOINT_XFER_INT
,
110 .wMaxPacketSize
= 1 + (NUM_PORTS
+ 7) / 8,
116 static const USBDescDevice desc_device_hub
= {
118 .bDeviceClass
= USB_CLASS_HUB
,
119 .bMaxPacketSize0
= 8,
120 .bNumConfigurations
= 1,
121 .confs
= (USBDescConfig
[]) {
124 .bConfigurationValue
= 1,
125 .bmAttributes
= USB_CFG_ATT_ONE
| USB_CFG_ATT_SELFPOWER
|
128 .ifs
= &desc_iface_hub
,
133 static const USBDesc desc_hub
= {
138 .iManufacturer
= STR_MANUFACTURER
,
139 .iProduct
= STR_PRODUCT
,
140 .iSerialNumber
= STR_SERIALNUMBER
,
142 .full
= &desc_device_hub
,
146 static const uint8_t qemu_hub_hub_descriptor
[] =
148 0x00, /* u8 bLength; patched in later */
149 0x29, /* u8 bDescriptorType; Hub-descriptor */
150 0x00, /* u8 bNbrPorts; (patched later) */
151 0x0a, /* u16 wHubCharacteristics; */
152 0x00, /* (per-port OC, no power switching) */
153 0x01, /* u8 bPwrOn2pwrGood; 2ms */
154 0x00 /* u8 bHubContrCurrent; 0 mA */
156 /* DeviceRemovable and PortPwrCtrlMask patched in later */
159 static void usb_hub_attach(USBPort
*port1
)
161 USBHubState
*s
= port1
->opaque
;
162 USBHubPort
*port
= &s
->ports
[port1
->index
];
164 trace_usb_hub_attach(s
->dev
.addr
, port1
->index
+ 1);
165 port
->wPortStatus
|= PORT_STAT_CONNECTION
;
166 port
->wPortChange
|= PORT_STAT_C_CONNECTION
;
167 if (port
->port
.dev
->speed
== USB_SPEED_LOW
) {
168 port
->wPortStatus
|= PORT_STAT_LOW_SPEED
;
170 port
->wPortStatus
&= ~PORT_STAT_LOW_SPEED
;
172 usb_wakeup(s
->intr
, 0);
175 static void usb_hub_detach(USBPort
*port1
)
177 USBHubState
*s
= port1
->opaque
;
178 USBHubPort
*port
= &s
->ports
[port1
->index
];
180 trace_usb_hub_detach(s
->dev
.addr
, port1
->index
+ 1);
181 usb_wakeup(s
->intr
, 0);
183 /* Let upstream know the device on this port is gone */
184 s
->dev
.port
->ops
->child_detach(s
->dev
.port
, port1
->dev
);
186 port
->wPortStatus
&= ~PORT_STAT_CONNECTION
;
187 port
->wPortChange
|= PORT_STAT_C_CONNECTION
;
188 if (port
->wPortStatus
& PORT_STAT_ENABLE
) {
189 port
->wPortStatus
&= ~PORT_STAT_ENABLE
;
190 port
->wPortChange
|= PORT_STAT_C_ENABLE
;
192 usb_wakeup(s
->intr
, 0);
195 static void usb_hub_child_detach(USBPort
*port1
, USBDevice
*child
)
197 USBHubState
*s
= port1
->opaque
;
199 /* Pass along upstream */
200 s
->dev
.port
->ops
->child_detach(s
->dev
.port
, child
);
203 static void usb_hub_wakeup(USBPort
*port1
)
205 USBHubState
*s
= port1
->opaque
;
206 USBHubPort
*port
= &s
->ports
[port1
->index
];
208 if (port
->wPortStatus
& PORT_STAT_SUSPEND
) {
209 port
->wPortChange
|= PORT_STAT_C_SUSPEND
;
210 usb_wakeup(s
->intr
, 0);
214 static void usb_hub_complete(USBPort
*port
, USBPacket
*packet
)
216 USBHubState
*s
= port
->opaque
;
219 * Just pass it along upstream for now.
221 * If we ever implement usb 2.0 split transactions this will
222 * become a little more complicated ...
224 * Can't use usb_packet_complete() here because packet->owner is
225 * cleared already, go call the ->complete() callback directly
228 s
->dev
.port
->ops
->complete(s
->dev
.port
, packet
);
231 static USBDevice
*usb_hub_find_device(USBDevice
*dev
, uint8_t addr
)
233 USBHubState
*s
= USB_HUB(dev
);
235 USBDevice
*downstream
;
238 for (i
= 0; i
< NUM_PORTS
; i
++) {
240 if (!(port
->wPortStatus
& PORT_STAT_ENABLE
)) {
243 downstream
= usb_find_device(&port
->port
, addr
);
244 if (downstream
!= NULL
) {
251 static void usb_hub_handle_reset(USBDevice
*dev
)
253 USBHubState
*s
= USB_HUB(dev
);
257 trace_usb_hub_reset(s
->dev
.addr
);
258 for (i
= 0; i
< NUM_PORTS
; i
++) {
260 port
->wPortStatus
= PORT_STAT_POWER
;
261 port
->wPortChange
= 0;
262 if (port
->port
.dev
&& port
->port
.dev
->attached
) {
263 port
->wPortStatus
|= PORT_STAT_CONNECTION
;
264 port
->wPortChange
|= PORT_STAT_C_CONNECTION
;
265 if (port
->port
.dev
->speed
== USB_SPEED_LOW
) {
266 port
->wPortStatus
|= PORT_STAT_LOW_SPEED
;
272 static const char *feature_name(int feature
)
274 static const char *name
[] = {
275 [PORT_CONNECTION
] = "connection",
276 [PORT_ENABLE
] = "enable",
277 [PORT_SUSPEND
] = "suspend",
278 [PORT_OVERCURRENT
] = "overcurrent",
279 [PORT_RESET
] = "reset",
280 [PORT_POWER
] = "power",
281 [PORT_LOWSPEED
] = "lowspeed",
282 [PORT_HIGHSPEED
] = "highspeed",
283 [PORT_C_CONNECTION
] = "change connection",
284 [PORT_C_ENABLE
] = "change enable",
285 [PORT_C_SUSPEND
] = "change suspend",
286 [PORT_C_OVERCURRENT
] = "change overcurrent",
287 [PORT_C_RESET
] = "change reset",
288 [PORT_TEST
] = "test",
289 [PORT_INDICATOR
] = "indicator",
291 if (feature
< 0 || feature
>= ARRAY_SIZE(name
)) {
294 return name
[feature
] ?: "?";
297 static void usb_hub_handle_control(USBDevice
*dev
, USBPacket
*p
,
298 int request
, int value
, int index
, int length
, uint8_t *data
)
300 USBHubState
*s
= (USBHubState
*)dev
;
303 trace_usb_hub_control(s
->dev
.addr
, request
, value
, index
, length
);
305 ret
= usb_desc_handle_control(dev
, p
, request
, value
, index
, length
, data
);
311 case EndpointOutRequest
| USB_REQ_CLEAR_FEATURE
:
312 if (value
== 0 && index
!= 0x81) { /* clear ep halt */
316 /* usb specific requests */
322 p
->actual_length
= 4;
326 unsigned int n
= index
- 1;
328 if (n
>= NUM_PORTS
) {
332 trace_usb_hub_get_port_status(s
->dev
.addr
, index
,
335 data
[0] = port
->wPortStatus
;
336 data
[1] = port
->wPortStatus
>> 8;
337 data
[2] = port
->wPortChange
;
338 data
[3] = port
->wPortChange
>> 8;
339 p
->actual_length
= 4;
343 case ClearHubFeature
:
344 if (value
!= 0 && value
!= 1) {
350 unsigned int n
= index
- 1;
354 trace_usb_hub_set_port_feature(s
->dev
.addr
, index
,
355 feature_name(value
));
357 if (n
>= NUM_PORTS
) {
361 dev
= port
->port
.dev
;
364 port
->wPortStatus
|= PORT_STAT_SUSPEND
;
367 if (dev
&& dev
->attached
) {
368 usb_device_reset(dev
);
369 port
->wPortChange
|= PORT_STAT_C_RESET
;
371 port
->wPortStatus
|= PORT_STAT_ENABLE
;
372 usb_wakeup(s
->intr
, 0);
382 case ClearPortFeature
:
384 unsigned int n
= index
- 1;
387 trace_usb_hub_clear_port_feature(s
->dev
.addr
, index
,
388 feature_name(value
));
390 if (n
>= NUM_PORTS
) {
396 port
->wPortStatus
&= ~PORT_STAT_ENABLE
;
399 port
->wPortChange
&= ~PORT_STAT_C_ENABLE
;
402 port
->wPortStatus
&= ~PORT_STAT_SUSPEND
;
405 port
->wPortChange
&= ~PORT_STAT_C_SUSPEND
;
407 case PORT_C_CONNECTION
:
408 port
->wPortChange
&= ~PORT_STAT_C_CONNECTION
;
410 case PORT_C_OVERCURRENT
:
411 port
->wPortChange
&= ~PORT_STAT_C_OVERCURRENT
;
414 port
->wPortChange
&= ~PORT_STAT_C_RESET
;
421 case GetHubDescriptor
:
423 unsigned int n
, limit
, var_hub_size
= 0;
424 memcpy(data
, qemu_hub_hub_descriptor
,
425 sizeof(qemu_hub_hub_descriptor
));
428 /* fill DeviceRemovable bits */
429 limit
= ((NUM_PORTS
+ 1 + 7) / 8) + 7;
430 for (n
= 7; n
< limit
; n
++) {
435 /* fill PortPwrCtrlMask bits */
436 limit
= limit
+ ((NUM_PORTS
+ 7) / 8);
437 for (;n
< limit
; n
++) {
442 p
->actual_length
= sizeof(qemu_hub_hub_descriptor
) + var_hub_size
;
443 data
[0] = p
->actual_length
;
448 p
->status
= USB_RET_STALL
;
453 static void usb_hub_handle_data(USBDevice
*dev
, USBPacket
*p
)
455 USBHubState
*s
= (USBHubState
*)dev
;
459 if (p
->ep
->nr
== 1) {
464 n
= (NUM_PORTS
+ 1 + 7) / 8;
465 if (p
->iov
.size
== 1) { /* FreeBSD workaround */
467 } else if (n
> p
->iov
.size
) {
468 p
->status
= USB_RET_BABBLE
;
472 for(i
= 0; i
< NUM_PORTS
; i
++) {
474 if (port
->wPortChange
)
475 status
|= (1 << (i
+ 1));
478 trace_usb_hub_status_report(s
->dev
.addr
, status
);
479 for(i
= 0; i
< n
; i
++) {
480 buf
[i
] = status
>> (8 * i
);
482 usb_packet_copy(p
, buf
, n
);
484 p
->status
= USB_RET_NAK
; /* usb11 11.13.1 */
493 p
->status
= USB_RET_STALL
;
498 static void usb_hub_handle_destroy(USBDevice
*dev
)
500 USBHubState
*s
= (USBHubState
*)dev
;
503 for (i
= 0; i
< NUM_PORTS
; i
++) {
504 usb_unregister_port(usb_bus_from_device(dev
),
509 static USBPortOps usb_hub_port_ops
= {
510 .attach
= usb_hub_attach
,
511 .detach
= usb_hub_detach
,
512 .child_detach
= usb_hub_child_detach
,
513 .wakeup
= usb_hub_wakeup
,
514 .complete
= usb_hub_complete
,
517 static void usb_hub_realize(USBDevice
*dev
, Error
**errp
)
519 USBHubState
*s
= USB_HUB(dev
);
523 if (dev
->port
->hubcount
== 5) {
524 error_setg(errp
, "usb hub chain too deep");
528 usb_desc_create_serial(dev
);
530 s
->intr
= usb_ep_get(dev
, USB_TOKEN_IN
, 1);
531 for (i
= 0; i
< NUM_PORTS
; i
++) {
533 usb_register_port(usb_bus_from_device(dev
),
534 &port
->port
, s
, i
, &usb_hub_port_ops
,
535 USB_SPEED_MASK_LOW
| USB_SPEED_MASK_FULL
);
536 usb_port_location(&port
->port
, dev
->port
, i
+1);
538 usb_hub_handle_reset(dev
);
541 static const VMStateDescription vmstate_usb_hub_port
= {
542 .name
= "usb-hub-port",
544 .minimum_version_id
= 1,
545 .fields
= (VMStateField
[]) {
546 VMSTATE_UINT16(wPortStatus
, USBHubPort
),
547 VMSTATE_UINT16(wPortChange
, USBHubPort
),
548 VMSTATE_END_OF_LIST()
552 static const VMStateDescription vmstate_usb_hub
= {
555 .minimum_version_id
= 1,
556 .fields
= (VMStateField
[]) {
557 VMSTATE_USB_DEVICE(dev
, USBHubState
),
558 VMSTATE_STRUCT_ARRAY(ports
, USBHubState
, NUM_PORTS
, 0,
559 vmstate_usb_hub_port
, USBHubPort
),
560 VMSTATE_END_OF_LIST()
564 static void usb_hub_class_initfn(ObjectClass
*klass
, void *data
)
566 DeviceClass
*dc
= DEVICE_CLASS(klass
);
567 USBDeviceClass
*uc
= USB_DEVICE_CLASS(klass
);
569 uc
->realize
= usb_hub_realize
;
570 uc
->product_desc
= "QEMU USB Hub";
571 uc
->usb_desc
= &desc_hub
;
572 uc
->find_device
= usb_hub_find_device
;
573 uc
->handle_reset
= usb_hub_handle_reset
;
574 uc
->handle_control
= usb_hub_handle_control
;
575 uc
->handle_data
= usb_hub_handle_data
;
576 uc
->handle_destroy
= usb_hub_handle_destroy
;
577 set_bit(DEVICE_CATEGORY_BRIDGE
, dc
->categories
);
579 dc
->vmsd
= &vmstate_usb_hub
;
582 static const TypeInfo hub_info
= {
583 .name
= TYPE_USB_HUB
,
584 .parent
= TYPE_USB_DEVICE
,
585 .instance_size
= sizeof(USBHubState
),
586 .class_init
= usb_hub_class_initfn
,
589 static void usb_hub_register_types(void)
591 type_register_static(&hub_info
);
594 type_init(usb_hub_register_types
)