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