hw/arm/raspi: fix CPRMAN base address
[qemu.git] / hw / usb / dev-hub.c
1 /*
2 * QEMU USB HUB emulation
3 *
4 * Copyright (c) 2005 Fabrice Bellard
5 *
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:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
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
22 * THE SOFTWARE.
23 */
24
25 #include "qemu/osdep.h"
26 #include "qapi/error.h"
27 #include "qemu/timer.h"
28 #include "trace.h"
29 #include "hw/qdev-properties.h"
30 #include "hw/usb.h"
31 #include "migration/vmstate.h"
32 #include "desc.h"
33 #include "qemu/error-report.h"
34 #include "qemu/module.h"
35 #include "qom/object.h"
36
37 #define MAX_PORTS 8
38
39 typedef struct USBHubPort {
40 USBPort port;
41 uint16_t wPortStatus;
42 uint16_t wPortChange;
43 } USBHubPort;
44
45 struct USBHubState {
46 USBDevice dev;
47 USBEndpoint *intr;
48 uint32_t num_ports;
49 bool port_power;
50 QEMUTimer *port_timer;
51 USBHubPort ports[MAX_PORTS];
52 };
53
54 #define TYPE_USB_HUB "usb-hub"
55 OBJECT_DECLARE_SIMPLE_TYPE(USBHubState, USB_HUB)
56
57 #define ClearHubFeature (0x2000 | USB_REQ_CLEAR_FEATURE)
58 #define ClearPortFeature (0x2300 | USB_REQ_CLEAR_FEATURE)
59 #define GetHubDescriptor (0xa000 | USB_REQ_GET_DESCRIPTOR)
60 #define GetHubStatus (0xa000 | USB_REQ_GET_STATUS)
61 #define GetPortStatus (0xa300 | USB_REQ_GET_STATUS)
62 #define SetHubFeature (0x2000 | USB_REQ_SET_FEATURE)
63 #define SetPortFeature (0x2300 | USB_REQ_SET_FEATURE)
64
65 #define PORT_STAT_CONNECTION 0x0001
66 #define PORT_STAT_ENABLE 0x0002
67 #define PORT_STAT_SUSPEND 0x0004
68 #define PORT_STAT_OVERCURRENT 0x0008
69 #define PORT_STAT_RESET 0x0010
70 #define PORT_STAT_POWER 0x0100
71 #define PORT_STAT_LOW_SPEED 0x0200
72 #define PORT_STAT_HIGH_SPEED 0x0400
73 #define PORT_STAT_TEST 0x0800
74 #define PORT_STAT_INDICATOR 0x1000
75
76 #define PORT_STAT_C_CONNECTION 0x0001
77 #define PORT_STAT_C_ENABLE 0x0002
78 #define PORT_STAT_C_SUSPEND 0x0004
79 #define PORT_STAT_C_OVERCURRENT 0x0008
80 #define PORT_STAT_C_RESET 0x0010
81
82 #define PORT_CONNECTION 0
83 #define PORT_ENABLE 1
84 #define PORT_SUSPEND 2
85 #define PORT_OVERCURRENT 3
86 #define PORT_RESET 4
87 #define PORT_POWER 8
88 #define PORT_LOWSPEED 9
89 #define PORT_HIGHSPEED 10
90 #define PORT_C_CONNECTION 16
91 #define PORT_C_ENABLE 17
92 #define PORT_C_SUSPEND 18
93 #define PORT_C_OVERCURRENT 19
94 #define PORT_C_RESET 20
95 #define PORT_TEST 21
96 #define PORT_INDICATOR 22
97
98 /* same as Linux kernel root hubs */
99
100 enum {
101 STR_MANUFACTURER = 1,
102 STR_PRODUCT,
103 STR_SERIALNUMBER,
104 };
105
106 static const USBDescStrings desc_strings = {
107 [STR_MANUFACTURER] = "QEMU",
108 [STR_PRODUCT] = "QEMU USB Hub",
109 [STR_SERIALNUMBER] = "314159",
110 };
111
112 static const USBDescIface desc_iface_hub = {
113 .bInterfaceNumber = 0,
114 .bNumEndpoints = 1,
115 .bInterfaceClass = USB_CLASS_HUB,
116 .eps = (USBDescEndpoint[]) {
117 {
118 .bEndpointAddress = USB_DIR_IN | 0x01,
119 .bmAttributes = USB_ENDPOINT_XFER_INT,
120 .wMaxPacketSize = 1 + DIV_ROUND_UP(MAX_PORTS, 8),
121 .bInterval = 0xff,
122 },
123 }
124 };
125
126 static const USBDescDevice desc_device_hub = {
127 .bcdUSB = 0x0110,
128 .bDeviceClass = USB_CLASS_HUB,
129 .bMaxPacketSize0 = 8,
130 .bNumConfigurations = 1,
131 .confs = (USBDescConfig[]) {
132 {
133 .bNumInterfaces = 1,
134 .bConfigurationValue = 1,
135 .bmAttributes = USB_CFG_ATT_ONE | USB_CFG_ATT_SELFPOWER |
136 USB_CFG_ATT_WAKEUP,
137 .nif = 1,
138 .ifs = &desc_iface_hub,
139 },
140 },
141 };
142
143 static const USBDesc desc_hub = {
144 .id = {
145 .idVendor = 0x0409,
146 .idProduct = 0x55aa,
147 .bcdDevice = 0x0101,
148 .iManufacturer = STR_MANUFACTURER,
149 .iProduct = STR_PRODUCT,
150 .iSerialNumber = STR_SERIALNUMBER,
151 },
152 .full = &desc_device_hub,
153 .str = desc_strings,
154 };
155
156 static const uint8_t qemu_hub_hub_descriptor[] =
157 {
158 0x00, /* u8 bLength; patched in later */
159 0x29, /* u8 bDescriptorType; Hub-descriptor */
160 0x00, /* u8 bNbrPorts; (patched later) */
161 0x0a, /* u16 wHubCharacteristics; */
162 0x00, /* (per-port OC, no power switching) */
163 0x01, /* u8 bPwrOn2pwrGood; 2ms */
164 0x00 /* u8 bHubContrCurrent; 0 mA */
165
166 /* DeviceRemovable and PortPwrCtrlMask patched in later */
167 };
168
169 static bool usb_hub_port_change(USBHubPort *port, uint16_t status)
170 {
171 bool notify = false;
172
173 if (status & 0x1f) {
174 port->wPortChange |= status;
175 notify = true;
176 }
177 return notify;
178 }
179
180 static bool usb_hub_port_set(USBHubPort *port, uint16_t status)
181 {
182 if (port->wPortStatus & status) {
183 return false;
184 }
185 port->wPortStatus |= status;
186 return usb_hub_port_change(port, status);
187 }
188
189 static bool usb_hub_port_clear(USBHubPort *port, uint16_t status)
190 {
191 if (!(port->wPortStatus & status)) {
192 return false;
193 }
194 port->wPortStatus &= ~status;
195 return usb_hub_port_change(port, status);
196 }
197
198 static bool usb_hub_port_update(USBHubPort *port)
199 {
200 bool notify = false;
201
202 if (port->port.dev && port->port.dev->attached) {
203 notify = usb_hub_port_set(port, PORT_STAT_CONNECTION);
204 if (port->port.dev->speed == USB_SPEED_LOW) {
205 usb_hub_port_set(port, PORT_STAT_LOW_SPEED);
206 } else {
207 usb_hub_port_clear(port, PORT_STAT_LOW_SPEED);
208 }
209 }
210 return notify;
211 }
212
213 static void usb_hub_port_update_timer(void *opaque)
214 {
215 USBHubState *s = opaque;
216 bool notify = false;
217 int i;
218
219 for (i = 0; i < s->num_ports; i++) {
220 notify |= usb_hub_port_update(&s->ports[i]);
221 }
222 if (notify) {
223 usb_wakeup(s->intr, 0);
224 }
225 }
226
227 static void usb_hub_attach(USBPort *port1)
228 {
229 USBHubState *s = port1->opaque;
230 USBHubPort *port = &s->ports[port1->index];
231
232 trace_usb_hub_attach(s->dev.addr, port1->index + 1);
233 usb_hub_port_update(port);
234 usb_wakeup(s->intr, 0);
235 }
236
237 static void usb_hub_detach(USBPort *port1)
238 {
239 USBHubState *s = port1->opaque;
240 USBHubPort *port = &s->ports[port1->index];
241
242 trace_usb_hub_detach(s->dev.addr, port1->index + 1);
243 usb_wakeup(s->intr, 0);
244
245 /* Let upstream know the device on this port is gone */
246 s->dev.port->ops->child_detach(s->dev.port, port1->dev);
247
248 usb_hub_port_clear(port, PORT_STAT_CONNECTION);
249 usb_hub_port_clear(port, PORT_STAT_ENABLE);
250 usb_hub_port_clear(port, PORT_STAT_SUSPEND);
251 usb_wakeup(s->intr, 0);
252 }
253
254 static void usb_hub_child_detach(USBPort *port1, USBDevice *child)
255 {
256 USBHubState *s = port1->opaque;
257
258 /* Pass along upstream */
259 s->dev.port->ops->child_detach(s->dev.port, child);
260 }
261
262 static void usb_hub_wakeup(USBPort *port1)
263 {
264 USBHubState *s = port1->opaque;
265 USBHubPort *port = &s->ports[port1->index];
266
267 if (usb_hub_port_clear(port, PORT_STAT_SUSPEND)) {
268 usb_wakeup(s->intr, 0);
269 }
270 }
271
272 static void usb_hub_complete(USBPort *port, USBPacket *packet)
273 {
274 USBHubState *s = port->opaque;
275
276 /*
277 * Just pass it along upstream for now.
278 *
279 * If we ever implement usb 2.0 split transactions this will
280 * become a little more complicated ...
281 *
282 * Can't use usb_packet_complete() here because packet->owner is
283 * cleared already, go call the ->complete() callback directly
284 * instead.
285 */
286 s->dev.port->ops->complete(s->dev.port, packet);
287 }
288
289 static USBDevice *usb_hub_find_device(USBDevice *dev, uint8_t addr)
290 {
291 USBHubState *s = USB_HUB(dev);
292 USBHubPort *port;
293 USBDevice *downstream;
294 int i;
295
296 for (i = 0; i < s->num_ports; i++) {
297 port = &s->ports[i];
298 if (!(port->wPortStatus & PORT_STAT_ENABLE)) {
299 continue;
300 }
301 downstream = usb_find_device(&port->port, addr);
302 if (downstream != NULL) {
303 return downstream;
304 }
305 }
306 return NULL;
307 }
308
309 static void usb_hub_handle_reset(USBDevice *dev)
310 {
311 USBHubState *s = USB_HUB(dev);
312 USBHubPort *port;
313 int i;
314
315 trace_usb_hub_reset(s->dev.addr);
316 for (i = 0; i < s->num_ports; i++) {
317 port = s->ports + i;
318 port->wPortStatus = 0;
319 port->wPortChange = 0;
320 usb_hub_port_set(port, PORT_STAT_POWER);
321 usb_hub_port_update(port);
322 }
323 }
324
325 static const char *feature_name(int feature)
326 {
327 static const char *name[] = {
328 [PORT_CONNECTION] = "connection",
329 [PORT_ENABLE] = "enable",
330 [PORT_SUSPEND] = "suspend",
331 [PORT_OVERCURRENT] = "overcurrent",
332 [PORT_RESET] = "reset",
333 [PORT_POWER] = "power",
334 [PORT_LOWSPEED] = "lowspeed",
335 [PORT_HIGHSPEED] = "highspeed",
336 [PORT_C_CONNECTION] = "change-connection",
337 [PORT_C_ENABLE] = "change-enable",
338 [PORT_C_SUSPEND] = "change-suspend",
339 [PORT_C_OVERCURRENT] = "change-overcurrent",
340 [PORT_C_RESET] = "change-reset",
341 [PORT_TEST] = "test",
342 [PORT_INDICATOR] = "indicator",
343 };
344 if (feature < 0 || feature >= ARRAY_SIZE(name)) {
345 return "?";
346 }
347 return name[feature] ?: "?";
348 }
349
350 static void usb_hub_handle_control(USBDevice *dev, USBPacket *p,
351 int request, int value, int index, int length, uint8_t *data)
352 {
353 USBHubState *s = (USBHubState *)dev;
354 int ret;
355
356 trace_usb_hub_control(s->dev.addr, request, value, index, length);
357
358 ret = usb_desc_handle_control(dev, p, request, value, index, length, data);
359 if (ret >= 0) {
360 return;
361 }
362
363 switch(request) {
364 case EndpointOutRequest | USB_REQ_CLEAR_FEATURE:
365 if (value == 0 && index != 0x81) { /* clear ep halt */
366 goto fail;
367 }
368 break;
369 /* usb specific requests */
370 case GetHubStatus:
371 data[0] = 0;
372 data[1] = 0;
373 data[2] = 0;
374 data[3] = 0;
375 p->actual_length = 4;
376 break;
377 case GetPortStatus:
378 {
379 unsigned int n = index - 1;
380 USBHubPort *port;
381 if (n >= s->num_ports) {
382 goto fail;
383 }
384 port = &s->ports[n];
385 trace_usb_hub_get_port_status(s->dev.addr, index,
386 port->wPortStatus,
387 port->wPortChange);
388 data[0] = port->wPortStatus;
389 data[1] = port->wPortStatus >> 8;
390 data[2] = port->wPortChange;
391 data[3] = port->wPortChange >> 8;
392 p->actual_length = 4;
393 }
394 break;
395 case SetHubFeature:
396 case ClearHubFeature:
397 if (value != 0 && value != 1) {
398 goto fail;
399 }
400 break;
401 case SetPortFeature:
402 {
403 unsigned int n = index - 1;
404 USBHubPort *port;
405 USBDevice *dev;
406
407 trace_usb_hub_set_port_feature(s->dev.addr, index,
408 feature_name(value));
409
410 if (n >= s->num_ports) {
411 goto fail;
412 }
413 port = &s->ports[n];
414 dev = port->port.dev;
415 switch(value) {
416 case PORT_SUSPEND:
417 port->wPortStatus |= PORT_STAT_SUSPEND;
418 break;
419 case PORT_RESET:
420 usb_hub_port_set(port, PORT_STAT_RESET);
421 usb_hub_port_clear(port, PORT_STAT_RESET);
422 if (dev && dev->attached) {
423 usb_device_reset(dev);
424 usb_hub_port_set(port, PORT_STAT_ENABLE);
425 }
426 usb_wakeup(s->intr, 0);
427 break;
428 case PORT_POWER:
429 if (s->port_power) {
430 int64_t now = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
431 usb_hub_port_set(port, PORT_STAT_POWER);
432 timer_mod(s->port_timer, now + 5000000); /* 5 ms */
433 }
434 break;
435 default:
436 goto fail;
437 }
438 }
439 break;
440 case ClearPortFeature:
441 {
442 unsigned int n = index - 1;
443 USBHubPort *port;
444
445 trace_usb_hub_clear_port_feature(s->dev.addr, index,
446 feature_name(value));
447
448 if (n >= s->num_ports) {
449 goto fail;
450 }
451 port = &s->ports[n];
452 switch(value) {
453 case PORT_ENABLE:
454 port->wPortStatus &= ~PORT_STAT_ENABLE;
455 break;
456 case PORT_C_ENABLE:
457 port->wPortChange &= ~PORT_STAT_C_ENABLE;
458 break;
459 case PORT_SUSPEND:
460 usb_hub_port_clear(port, PORT_STAT_SUSPEND);
461 break;
462 case PORT_C_SUSPEND:
463 port->wPortChange &= ~PORT_STAT_C_SUSPEND;
464 break;
465 case PORT_C_CONNECTION:
466 port->wPortChange &= ~PORT_STAT_C_CONNECTION;
467 break;
468 case PORT_C_OVERCURRENT:
469 port->wPortChange &= ~PORT_STAT_C_OVERCURRENT;
470 break;
471 case PORT_C_RESET:
472 port->wPortChange &= ~PORT_STAT_C_RESET;
473 break;
474 case PORT_POWER:
475 if (s->port_power) {
476 usb_hub_port_clear(port, PORT_STAT_POWER);
477 usb_hub_port_clear(port, PORT_STAT_CONNECTION);
478 usb_hub_port_clear(port, PORT_STAT_ENABLE);
479 usb_hub_port_clear(port, PORT_STAT_SUSPEND);
480 port->wPortChange = 0;
481 }
482 default:
483 goto fail;
484 }
485 }
486 break;
487 case GetHubDescriptor:
488 {
489 unsigned int n, limit, var_hub_size = 0;
490 memcpy(data, qemu_hub_hub_descriptor,
491 sizeof(qemu_hub_hub_descriptor));
492 data[2] = s->num_ports;
493
494 if (s->port_power) {
495 data[3] &= ~0x03;
496 data[3] |= 0x01;
497 }
498
499 /* fill DeviceRemovable bits */
500 limit = DIV_ROUND_UP(s->num_ports + 1, 8) + 7;
501 for (n = 7; n < limit; n++) {
502 data[n] = 0x00;
503 var_hub_size++;
504 }
505
506 /* fill PortPwrCtrlMask bits */
507 limit = limit + DIV_ROUND_UP(s->num_ports, 8);
508 for (;n < limit; n++) {
509 data[n] = 0xff;
510 var_hub_size++;
511 }
512
513 p->actual_length = sizeof(qemu_hub_hub_descriptor) + var_hub_size;
514 data[0] = p->actual_length;
515 break;
516 }
517 default:
518 fail:
519 p->status = USB_RET_STALL;
520 break;
521 }
522 }
523
524 static void usb_hub_handle_data(USBDevice *dev, USBPacket *p)
525 {
526 USBHubState *s = (USBHubState *)dev;
527
528 switch(p->pid) {
529 case USB_TOKEN_IN:
530 if (p->ep->nr == 1) {
531 USBHubPort *port;
532 unsigned int status;
533 uint8_t buf[4];
534 int i, n;
535 n = DIV_ROUND_UP(s->num_ports + 1, 8);
536 if (p->iov.size == 1) { /* FreeBSD workaround */
537 n = 1;
538 } else if (n > p->iov.size) {
539 p->status = USB_RET_BABBLE;
540 return;
541 }
542 status = 0;
543 for (i = 0; i < s->num_ports; i++) {
544 port = &s->ports[i];
545 if (port->wPortChange)
546 status |= (1 << (i + 1));
547 }
548 if (status != 0) {
549 trace_usb_hub_status_report(s->dev.addr, status);
550 for(i = 0; i < n; i++) {
551 buf[i] = status >> (8 * i);
552 }
553 usb_packet_copy(p, buf, n);
554 } else {
555 p->status = USB_RET_NAK; /* usb11 11.13.1 */
556 }
557 } else {
558 goto fail;
559 }
560 break;
561 case USB_TOKEN_OUT:
562 default:
563 fail:
564 p->status = USB_RET_STALL;
565 break;
566 }
567 }
568
569 static void usb_hub_unrealize(USBDevice *dev)
570 {
571 USBHubState *s = (USBHubState *)dev;
572 int i;
573
574 for (i = 0; i < s->num_ports; i++) {
575 usb_unregister_port(usb_bus_from_device(dev),
576 &s->ports[i].port);
577 }
578
579 timer_del(s->port_timer);
580 timer_free(s->port_timer);
581 }
582
583 static USBPortOps usb_hub_port_ops = {
584 .attach = usb_hub_attach,
585 .detach = usb_hub_detach,
586 .child_detach = usb_hub_child_detach,
587 .wakeup = usb_hub_wakeup,
588 .complete = usb_hub_complete,
589 };
590
591 static void usb_hub_realize(USBDevice *dev, Error **errp)
592 {
593 USBHubState *s = USB_HUB(dev);
594 USBHubPort *port;
595 int i;
596
597 if (s->num_ports < 1 || s->num_ports > MAX_PORTS) {
598 error_setg(errp, "num_ports (%d) out of range (1..%d)",
599 s->num_ports, MAX_PORTS);
600 return;
601 }
602
603 if (dev->port->hubcount == 5) {
604 error_setg(errp, "usb hub chain too deep");
605 return;
606 }
607
608 usb_desc_create_serial(dev);
609 usb_desc_init(dev);
610 s->port_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL,
611 usb_hub_port_update_timer, s);
612 s->intr = usb_ep_get(dev, USB_TOKEN_IN, 1);
613 for (i = 0; i < s->num_ports; i++) {
614 port = &s->ports[i];
615 usb_register_port(usb_bus_from_device(dev),
616 &port->port, s, i, &usb_hub_port_ops,
617 USB_SPEED_MASK_LOW | USB_SPEED_MASK_FULL);
618 usb_port_location(&port->port, dev->port, i+1);
619 }
620 usb_hub_handle_reset(dev);
621 }
622
623 static const VMStateDescription vmstate_usb_hub_port = {
624 .name = "usb-hub-port",
625 .version_id = 1,
626 .minimum_version_id = 1,
627 .fields = (VMStateField[]) {
628 VMSTATE_UINT16(wPortStatus, USBHubPort),
629 VMSTATE_UINT16(wPortChange, USBHubPort),
630 VMSTATE_END_OF_LIST()
631 }
632 };
633
634 static bool usb_hub_port_timer_needed(void *opaque)
635 {
636 USBHubState *s = opaque;
637
638 return s->port_power;
639 }
640
641 static const VMStateDescription vmstate_usb_hub_port_timer = {
642 .name = "usb-hub/port-timer",
643 .version_id = 1,
644 .minimum_version_id = 1,
645 .needed = usb_hub_port_timer_needed,
646 .fields = (VMStateField[]) {
647 VMSTATE_TIMER_PTR(port_timer, USBHubState),
648 VMSTATE_END_OF_LIST()
649 },
650 };
651
652 static const VMStateDescription vmstate_usb_hub = {
653 .name = "usb-hub",
654 .version_id = 1,
655 .minimum_version_id = 1,
656 .fields = (VMStateField[]) {
657 VMSTATE_USB_DEVICE(dev, USBHubState),
658 VMSTATE_STRUCT_ARRAY(ports, USBHubState, MAX_PORTS, 0,
659 vmstate_usb_hub_port, USBHubPort),
660 VMSTATE_END_OF_LIST()
661 },
662 .subsections = (const VMStateDescription * []) {
663 &vmstate_usb_hub_port_timer,
664 NULL
665 }
666 };
667
668 static Property usb_hub_properties[] = {
669 DEFINE_PROP_UINT32("ports", USBHubState, num_ports, 8),
670 DEFINE_PROP_BOOL("port-power", USBHubState, port_power, false),
671 DEFINE_PROP_END_OF_LIST(),
672 };
673
674 static void usb_hub_class_initfn(ObjectClass *klass, void *data)
675 {
676 DeviceClass *dc = DEVICE_CLASS(klass);
677 USBDeviceClass *uc = USB_DEVICE_CLASS(klass);
678
679 uc->realize = usb_hub_realize;
680 uc->product_desc = "QEMU USB Hub";
681 uc->usb_desc = &desc_hub;
682 uc->find_device = usb_hub_find_device;
683 uc->handle_reset = usb_hub_handle_reset;
684 uc->handle_control = usb_hub_handle_control;
685 uc->handle_data = usb_hub_handle_data;
686 uc->unrealize = usb_hub_unrealize;
687 set_bit(DEVICE_CATEGORY_BRIDGE, dc->categories);
688 dc->fw_name = "hub";
689 dc->vmsd = &vmstate_usb_hub;
690 device_class_set_props(dc, usb_hub_properties);
691 }
692
693 static const TypeInfo hub_info = {
694 .name = TYPE_USB_HUB,
695 .parent = TYPE_USB_DEVICE,
696 .instance_size = sizeof(USBHubState),
697 .class_init = usb_hub_class_initfn,
698 };
699
700 static void usb_hub_register_types(void)
701 {
702 type_register_static(&hub_info);
703 }
704
705 type_init(usb_hub_register_types)