1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24#include "qemu/osdep.h"
25#include "qapi/error.h"
26#include "qemu-common.h"
27#include "trace.h"
28#include "hw/usb.h"
29#include "hw/usb/desc.h"
30#include "qemu/error-report.h"
31
32#define NUM_PORTS 8
33
34typedef struct USBHubPort {
35 USBPort port;
36 uint16_t wPortStatus;
37 uint16_t wPortChange;
38} USBHubPort;
39
40typedef struct USBHubState {
41 USBDevice dev;
42 USBEndpoint *intr;
43 USBHubPort ports[NUM_PORTS];
44} USBHubState;
45
46#define TYPE_USB_HUB "usb-hub"
47#define USB_HUB(obj) OBJECT_CHECK(USBHubState, (obj), TYPE_USB_HUB)
48
49#define ClearHubFeature (0x2000 | USB_REQ_CLEAR_FEATURE)
50#define ClearPortFeature (0x2300 | USB_REQ_CLEAR_FEATURE)
51#define GetHubDescriptor (0xa000 | USB_REQ_GET_DESCRIPTOR)
52#define GetHubStatus (0xa000 | USB_REQ_GET_STATUS)
53#define GetPortStatus (0xa300 | USB_REQ_GET_STATUS)
54#define SetHubFeature (0x2000 | USB_REQ_SET_FEATURE)
55#define SetPortFeature (0x2300 | USB_REQ_SET_FEATURE)
56
57#define PORT_STAT_CONNECTION 0x0001
58#define PORT_STAT_ENABLE 0x0002
59#define PORT_STAT_SUSPEND 0x0004
60#define PORT_STAT_OVERCURRENT 0x0008
61#define PORT_STAT_RESET 0x0010
62#define PORT_STAT_POWER 0x0100
63#define PORT_STAT_LOW_SPEED 0x0200
64#define PORT_STAT_HIGH_SPEED 0x0400
65#define PORT_STAT_TEST 0x0800
66#define PORT_STAT_INDICATOR 0x1000
67
68#define PORT_STAT_C_CONNECTION 0x0001
69#define PORT_STAT_C_ENABLE 0x0002
70#define PORT_STAT_C_SUSPEND 0x0004
71#define PORT_STAT_C_OVERCURRENT 0x0008
72#define PORT_STAT_C_RESET 0x0010
73
74#define PORT_CONNECTION 0
75#define PORT_ENABLE 1
76#define PORT_SUSPEND 2
77#define PORT_OVERCURRENT 3
78#define PORT_RESET 4
79#define PORT_POWER 8
80#define PORT_LOWSPEED 9
81#define PORT_HIGHSPEED 10
82#define PORT_C_CONNECTION 16
83#define PORT_C_ENABLE 17
84#define PORT_C_SUSPEND 18
85#define PORT_C_OVERCURRENT 19
86#define PORT_C_RESET 20
87#define PORT_TEST 21
88#define PORT_INDICATOR 22
89
90
91
92enum {
93 STR_MANUFACTURER = 1,
94 STR_PRODUCT,
95 STR_SERIALNUMBER,
96};
97
98static const USBDescStrings desc_strings = {
99 [STR_MANUFACTURER] = "QEMU",
100 [STR_PRODUCT] = "QEMU USB Hub",
101 [STR_SERIALNUMBER] = "314159",
102};
103
104static const USBDescIface desc_iface_hub = {
105 .bInterfaceNumber = 0,
106 .bNumEndpoints = 1,
107 .bInterfaceClass = USB_CLASS_HUB,
108 .eps = (USBDescEndpoint[]) {
109 {
110 .bEndpointAddress = USB_DIR_IN | 0x01,
111 .bmAttributes = USB_ENDPOINT_XFER_INT,
112 .wMaxPacketSize = 1 + DIV_ROUND_UP(NUM_PORTS, 8),
113 .bInterval = 0xff,
114 },
115 }
116};
117
118static const USBDescDevice desc_device_hub = {
119 .bcdUSB = 0x0110,
120 .bDeviceClass = USB_CLASS_HUB,
121 .bMaxPacketSize0 = 8,
122 .bNumConfigurations = 1,
123 .confs = (USBDescConfig[]) {
124 {
125 .bNumInterfaces = 1,
126 .bConfigurationValue = 1,
127 .bmAttributes = USB_CFG_ATT_ONE | USB_CFG_ATT_SELFPOWER |
128 USB_CFG_ATT_WAKEUP,
129 .nif = 1,
130 .ifs = &desc_iface_hub,
131 },
132 },
133};
134
135static const USBDesc desc_hub = {
136 .id = {
137 .idVendor = 0x0409,
138 .idProduct = 0x55aa,
139 .bcdDevice = 0x0101,
140 .iManufacturer = STR_MANUFACTURER,
141 .iProduct = STR_PRODUCT,
142 .iSerialNumber = STR_SERIALNUMBER,
143 },
144 .full = &desc_device_hub,
145 .str = desc_strings,
146};
147
148static const uint8_t qemu_hub_hub_descriptor[] =
149{
150 0x00,
151 0x29,
152 0x00,
153 0x0a,
154 0x00,
155 0x01,
156 0x00
157
158
159};
160
161static void usb_hub_attach(USBPort *port1)
162{
163 USBHubState *s = port1->opaque;
164 USBHubPort *port = &s->ports[port1->index];
165
166 trace_usb_hub_attach(s->dev.addr, port1->index + 1);
167 port->wPortStatus |= PORT_STAT_CONNECTION;
168 port->wPortChange |= PORT_STAT_C_CONNECTION;
169 if (port->port.dev->speed == USB_SPEED_LOW) {
170 port->wPortStatus |= PORT_STAT_LOW_SPEED;
171 } else {
172 port->wPortStatus &= ~PORT_STAT_LOW_SPEED;
173 }
174 usb_wakeup(s->intr, 0);
175}
176
177static void usb_hub_detach(USBPort *port1)
178{
179 USBHubState *s = port1->opaque;
180 USBHubPort *port = &s->ports[port1->index];
181
182 trace_usb_hub_detach(s->dev.addr, port1->index + 1);
183 usb_wakeup(s->intr, 0);
184
185
186 s->dev.port->ops->child_detach(s->dev.port, port1->dev);
187
188 port->wPortStatus &= ~PORT_STAT_CONNECTION;
189 port->wPortChange |= PORT_STAT_C_CONNECTION;
190 if (port->wPortStatus & PORT_STAT_ENABLE) {
191 port->wPortStatus &= ~PORT_STAT_ENABLE;
192 port->wPortChange |= PORT_STAT_C_ENABLE;
193 }
194 usb_wakeup(s->intr, 0);
195}
196
197static void usb_hub_child_detach(USBPort *port1, USBDevice *child)
198{
199 USBHubState *s = port1->opaque;
200
201
202 s->dev.port->ops->child_detach(s->dev.port, child);
203}
204
205static void usb_hub_wakeup(USBPort *port1)
206{
207 USBHubState *s = port1->opaque;
208 USBHubPort *port = &s->ports[port1->index];
209
210 if (port->wPortStatus & PORT_STAT_SUSPEND) {
211 port->wPortStatus &= ~PORT_STAT_SUSPEND;
212 port->wPortChange |= PORT_STAT_C_SUSPEND;
213 usb_wakeup(s->intr, 0);
214 }
215}
216
217static void usb_hub_complete(USBPort *port, USBPacket *packet)
218{
219 USBHubState *s = port->opaque;
220
221
222
223
224
225
226
227
228
229
230
231 s->dev.port->ops->complete(s->dev.port, packet);
232}
233
234static USBDevice *usb_hub_find_device(USBDevice *dev, uint8_t addr)
235{
236 USBHubState *s = USB_HUB(dev);
237 USBHubPort *port;
238 USBDevice *downstream;
239 int i;
240
241 for (i = 0; i < NUM_PORTS; i++) {
242 port = &s->ports[i];
243 if (!(port->wPortStatus & PORT_STAT_ENABLE)) {
244 continue;
245 }
246 downstream = usb_find_device(&port->port, addr);
247 if (downstream != NULL) {
248 return downstream;
249 }
250 }
251 return NULL;
252}
253
254static void usb_hub_handle_reset(USBDevice *dev)
255{
256 USBHubState *s = USB_HUB(dev);
257 USBHubPort *port;
258 int i;
259
260 trace_usb_hub_reset(s->dev.addr);
261 for (i = 0; i < NUM_PORTS; i++) {
262 port = s->ports + i;
263 port->wPortStatus = PORT_STAT_POWER;
264 port->wPortChange = 0;
265 if (port->port.dev && port->port.dev->attached) {
266 port->wPortStatus |= PORT_STAT_CONNECTION;
267 port->wPortChange |= PORT_STAT_C_CONNECTION;
268 if (port->port.dev->speed == USB_SPEED_LOW) {
269 port->wPortStatus |= PORT_STAT_LOW_SPEED;
270 }
271 }
272 }
273}
274
275static const char *feature_name(int feature)
276{
277 static const char *name[] = {
278 [PORT_CONNECTION] = "connection",
279 [PORT_ENABLE] = "enable",
280 [PORT_SUSPEND] = "suspend",
281 [PORT_OVERCURRENT] = "overcurrent",
282 [PORT_RESET] = "reset",
283 [PORT_POWER] = "power",
284 [PORT_LOWSPEED] = "lowspeed",
285 [PORT_HIGHSPEED] = "highspeed",
286 [PORT_C_CONNECTION] = "change connection",
287 [PORT_C_ENABLE] = "change enable",
288 [PORT_C_SUSPEND] = "change suspend",
289 [PORT_C_OVERCURRENT] = "change overcurrent",
290 [PORT_C_RESET] = "change reset",
291 [PORT_TEST] = "test",
292 [PORT_INDICATOR] = "indicator",
293 };
294 if (feature < 0 || feature >= ARRAY_SIZE(name)) {
295 return "?";
296 }
297 return name[feature] ?: "?";
298}
299
300static void usb_hub_handle_control(USBDevice *dev, USBPacket *p,
301 int request, int value, int index, int length, uint8_t *data)
302{
303 USBHubState *s = (USBHubState *)dev;
304 int ret;
305
306 trace_usb_hub_control(s->dev.addr, request, value, index, length);
307
308 ret = usb_desc_handle_control(dev, p, request, value, index, length, data);
309 if (ret >= 0) {
310 return;
311 }
312
313 switch(request) {
314 case EndpointOutRequest | USB_REQ_CLEAR_FEATURE:
315 if (value == 0 && index != 0x81) {
316 goto fail;
317 }
318 break;
319
320 case GetHubStatus:
321 data[0] = 0;
322 data[1] = 0;
323 data[2] = 0;
324 data[3] = 0;
325 p->actual_length = 4;
326 break;
327 case GetPortStatus:
328 {
329 unsigned int n = index - 1;
330 USBHubPort *port;
331 if (n >= NUM_PORTS) {
332 goto fail;
333 }
334 port = &s->ports[n];
335 trace_usb_hub_get_port_status(s->dev.addr, index,
336 port->wPortStatus,
337 port->wPortChange);
338 data[0] = port->wPortStatus;
339 data[1] = port->wPortStatus >> 8;
340 data[2] = port->wPortChange;
341 data[3] = port->wPortChange >> 8;
342 p->actual_length = 4;
343 }
344 break;
345 case SetHubFeature:
346 case ClearHubFeature:
347 if (value != 0 && value != 1) {
348 goto fail;
349 }
350 break;
351 case SetPortFeature:
352 {
353 unsigned int n = index - 1;
354 USBHubPort *port;
355 USBDevice *dev;
356
357 trace_usb_hub_set_port_feature(s->dev.addr, index,
358 feature_name(value));
359
360 if (n >= NUM_PORTS) {
361 goto fail;
362 }
363 port = &s->ports[n];
364 dev = port->port.dev;
365 switch(value) {
366 case PORT_SUSPEND:
367 port->wPortStatus |= PORT_STAT_SUSPEND;
368 break;
369 case PORT_RESET:
370 if (dev && dev->attached) {
371 usb_device_reset(dev);
372 port->wPortChange |= PORT_STAT_C_RESET;
373
374 port->wPortStatus |= PORT_STAT_ENABLE;
375 usb_wakeup(s->intr, 0);
376 }
377 break;
378 case PORT_POWER:
379 break;
380 default:
381 goto fail;
382 }
383 }
384 break;
385 case ClearPortFeature:
386 {
387 unsigned int n = index - 1;
388 USBHubPort *port;
389
390 trace_usb_hub_clear_port_feature(s->dev.addr, index,
391 feature_name(value));
392
393 if (n >= NUM_PORTS) {
394 goto fail;
395 }
396 port = &s->ports[n];
397 switch(value) {
398 case PORT_ENABLE:
399 port->wPortStatus &= ~PORT_STAT_ENABLE;
400 break;
401 case PORT_C_ENABLE:
402 port->wPortChange &= ~PORT_STAT_C_ENABLE;
403 break;
404 case PORT_SUSPEND:
405 if (port->wPortStatus & PORT_STAT_SUSPEND) {
406 port->wPortStatus &= ~PORT_STAT_SUSPEND;
407
408
409
410
411
412
413
414
415
416
417 port->wPortChange |= PORT_STAT_C_SUSPEND;
418 }
419 break;
420 case PORT_C_SUSPEND:
421 port->wPortChange &= ~PORT_STAT_C_SUSPEND;
422 break;
423 case PORT_C_CONNECTION:
424 port->wPortChange &= ~PORT_STAT_C_CONNECTION;
425 break;
426 case PORT_C_OVERCURRENT:
427 port->wPortChange &= ~PORT_STAT_C_OVERCURRENT;
428 break;
429 case PORT_C_RESET:
430 port->wPortChange &= ~PORT_STAT_C_RESET;
431 break;
432 default:
433 goto fail;
434 }
435 }
436 break;
437 case GetHubDescriptor:
438 {
439 unsigned int n, limit, var_hub_size = 0;
440 memcpy(data, qemu_hub_hub_descriptor,
441 sizeof(qemu_hub_hub_descriptor));
442 data[2] = NUM_PORTS;
443
444
445 limit = DIV_ROUND_UP(NUM_PORTS + 1, 8) + 7;
446 for (n = 7; n < limit; n++) {
447 data[n] = 0x00;
448 var_hub_size++;
449 }
450
451
452 limit = limit + DIV_ROUND_UP(NUM_PORTS, 8);
453 for (;n < limit; n++) {
454 data[n] = 0xff;
455 var_hub_size++;
456 }
457
458 p->actual_length = sizeof(qemu_hub_hub_descriptor) + var_hub_size;
459 data[0] = p->actual_length;
460 break;
461 }
462 default:
463 fail:
464 p->status = USB_RET_STALL;
465 break;
466 }
467}
468
469static void usb_hub_handle_data(USBDevice *dev, USBPacket *p)
470{
471 USBHubState *s = (USBHubState *)dev;
472
473 switch(p->pid) {
474 case USB_TOKEN_IN:
475 if (p->ep->nr == 1) {
476 USBHubPort *port;
477 unsigned int status;
478 uint8_t buf[4];
479 int i, n;
480 n = DIV_ROUND_UP(NUM_PORTS + 1, 8);
481 if (p->iov.size == 1) {
482 n = 1;
483 } else if (n > p->iov.size) {
484 p->status = USB_RET_BABBLE;
485 return;
486 }
487 status = 0;
488 for(i = 0; i < NUM_PORTS; i++) {
489 port = &s->ports[i];
490 if (port->wPortChange)
491 status |= (1 << (i + 1));
492 }
493 if (status != 0) {
494 trace_usb_hub_status_report(s->dev.addr, status);
495 for(i = 0; i < n; i++) {
496 buf[i] = status >> (8 * i);
497 }
498 usb_packet_copy(p, buf, n);
499 } else {
500 p->status = USB_RET_NAK;
501 }
502 } else {
503 goto fail;
504 }
505 break;
506 case USB_TOKEN_OUT:
507 default:
508 fail:
509 p->status = USB_RET_STALL;
510 break;
511 }
512}
513
514static void usb_hub_unrealize(USBDevice *dev, Error **errp)
515{
516 USBHubState *s = (USBHubState *)dev;
517 int i;
518
519 for (i = 0; i < NUM_PORTS; i++) {
520 usb_unregister_port(usb_bus_from_device(dev),
521 &s->ports[i].port);
522 }
523}
524
525static USBPortOps usb_hub_port_ops = {
526 .attach = usb_hub_attach,
527 .detach = usb_hub_detach,
528 .child_detach = usb_hub_child_detach,
529 .wakeup = usb_hub_wakeup,
530 .complete = usb_hub_complete,
531};
532
533static void usb_hub_realize(USBDevice *dev, Error **errp)
534{
535 USBHubState *s = USB_HUB(dev);
536 USBHubPort *port;
537 int i;
538
539 if (dev->port->hubcount == 5) {
540 error_setg(errp, "usb hub chain too deep");
541 return;
542 }
543
544 usb_desc_create_serial(dev);
545 usb_desc_init(dev);
546 s->intr = usb_ep_get(dev, USB_TOKEN_IN, 1);
547 for (i = 0; i < NUM_PORTS; i++) {
548 port = &s->ports[i];
549 usb_register_port(usb_bus_from_device(dev),
550 &port->port, s, i, &usb_hub_port_ops,
551 USB_SPEED_MASK_LOW | USB_SPEED_MASK_FULL);
552 usb_port_location(&port->port, dev->port, i+1);
553 }
554 usb_hub_handle_reset(dev);
555}
556
557static const VMStateDescription vmstate_usb_hub_port = {
558 .name = "usb-hub-port",
559 .version_id = 1,
560 .minimum_version_id = 1,
561 .fields = (VMStateField[]) {
562 VMSTATE_UINT16(wPortStatus, USBHubPort),
563 VMSTATE_UINT16(wPortChange, USBHubPort),
564 VMSTATE_END_OF_LIST()
565 }
566};
567
568static const VMStateDescription vmstate_usb_hub = {
569 .name = "usb-hub",
570 .version_id = 1,
571 .minimum_version_id = 1,
572 .fields = (VMStateField[]) {
573 VMSTATE_USB_DEVICE(dev, USBHubState),
574 VMSTATE_STRUCT_ARRAY(ports, USBHubState, NUM_PORTS, 0,
575 vmstate_usb_hub_port, USBHubPort),
576 VMSTATE_END_OF_LIST()
577 }
578};
579
580static void usb_hub_class_initfn(ObjectClass *klass, void *data)
581{
582 DeviceClass *dc = DEVICE_CLASS(klass);
583 USBDeviceClass *uc = USB_DEVICE_CLASS(klass);
584
585 uc->realize = usb_hub_realize;
586 uc->product_desc = "QEMU USB Hub";
587 uc->usb_desc = &desc_hub;
588 uc->find_device = usb_hub_find_device;
589 uc->handle_reset = usb_hub_handle_reset;
590 uc->handle_control = usb_hub_handle_control;
591 uc->handle_data = usb_hub_handle_data;
592 uc->unrealize = usb_hub_unrealize;
593 set_bit(DEVICE_CATEGORY_BRIDGE, dc->categories);
594 dc->fw_name = "hub";
595 dc->vmsd = &vmstate_usb_hub;
596}
597
598static const TypeInfo hub_info = {
599 .name = TYPE_USB_HUB,
600 .parent = TYPE_USB_DEVICE,
601 .instance_size = sizeof(USBHubState),
602 .class_init = usb_hub_class_initfn,
603};
604
605static void usb_hub_register_types(void)
606{
607 type_register_static(&hub_info);
608}
609
610type_init(usb_hub_register_types)
611