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