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