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