dma/rc4030: use AddressSpace and address_space_rw in users
[qemu/ar7.git] / hw / usb / dev-hub.c
blobc8c685550541843ad2d703770fd0a31523eb8619
1 /*
2 * QEMU USB HUB emulation
4 * Copyright (c) 2005 Fabrice Bellard
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:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
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.
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"
30 #define NUM_PORTS 8
32 typedef struct USBHubPort {
33 USBPort port;
34 uint16_t wPortStatus;
35 uint16_t wPortChange;
36 } USBHubPort;
38 typedef struct USBHubState {
39 USBDevice dev;
40 USBEndpoint *intr;
41 USBHubPort ports[NUM_PORTS];
42 } USBHubState;
44 #define TYPE_USB_HUB "usb-hub"
45 #define USB_HUB(obj) OBJECT_CHECK(USBHubState, (obj), TYPE_USB_HUB)
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)
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
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
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
88 /* same as Linux kernel root hubs */
90 enum {
91 STR_MANUFACTURER = 1,
92 STR_PRODUCT,
93 STR_SERIALNUMBER,
96 static const USBDescStrings desc_strings = {
97 [STR_MANUFACTURER] = "QEMU",
98 [STR_PRODUCT] = "QEMU USB Hub",
99 [STR_SERIALNUMBER] = "314159",
102 static const USBDescIface desc_iface_hub = {
103 .bInterfaceNumber = 0,
104 .bNumEndpoints = 1,
105 .bInterfaceClass = USB_CLASS_HUB,
106 .eps = (USBDescEndpoint[]) {
108 .bEndpointAddress = USB_DIR_IN | 0x01,
109 .bmAttributes = USB_ENDPOINT_XFER_INT,
110 .wMaxPacketSize = 1 + (NUM_PORTS + 7) / 8,
111 .bInterval = 0xff,
116 static const USBDescDevice desc_device_hub = {
117 .bcdUSB = 0x0110,
118 .bDeviceClass = USB_CLASS_HUB,
119 .bMaxPacketSize0 = 8,
120 .bNumConfigurations = 1,
121 .confs = (USBDescConfig[]) {
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,
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,
142 .full = &desc_device_hub,
143 .str = desc_strings,
146 static const uint8_t qemu_hub_hub_descriptor[] =
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 */
156 /* DeviceRemovable and PortPwrCtrlMask patched in later */
159 static void usb_hub_attach(USBPort *port1)
161 USBHubState *s = port1->opaque;
162 USBHubPort *port = &s->ports[port1->index];
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;
172 usb_wakeup(s->intr, 0);
175 static void usb_hub_detach(USBPort *port1)
177 USBHubState *s = port1->opaque;
178 USBHubPort *port = &s->ports[port1->index];
180 trace_usb_hub_detach(s->dev.addr, port1->index + 1);
181 usb_wakeup(s->intr, 0);
183 /* Let upstream know the device on this port is gone */
184 s->dev.port->ops->child_detach(s->dev.port, port1->dev);
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;
192 usb_wakeup(s->intr, 0);
195 static void usb_hub_child_detach(USBPort *port1, USBDevice *child)
197 USBHubState *s = port1->opaque;
199 /* Pass along upstream */
200 s->dev.port->ops->child_detach(s->dev.port, child);
203 static void usb_hub_wakeup(USBPort *port1)
205 USBHubState *s = port1->opaque;
206 USBHubPort *port = &s->ports[port1->index];
208 if (port->wPortStatus & PORT_STAT_SUSPEND) {
209 port->wPortChange |= PORT_STAT_C_SUSPEND;
210 usb_wakeup(s->intr, 0);
214 static void usb_hub_complete(USBPort *port, USBPacket *packet)
216 USBHubState *s = port->opaque;
219 * Just pass it along upstream for now.
221 * If we ever implement usb 2.0 split transactions this will
222 * become a little more complicated ...
224 * Can't use usb_packet_complete() here because packet->owner is
225 * cleared already, go call the ->complete() callback directly
226 * instead.
228 s->dev.port->ops->complete(s->dev.port, packet);
231 static USBDevice *usb_hub_find_device(USBDevice *dev, uint8_t addr)
233 USBHubState *s = USB_HUB(dev);
234 USBHubPort *port;
235 USBDevice *downstream;
236 int i;
238 for (i = 0; i < NUM_PORTS; i++) {
239 port = &s->ports[i];
240 if (!(port->wPortStatus & PORT_STAT_ENABLE)) {
241 continue;
243 downstream = usb_find_device(&port->port, addr);
244 if (downstream != NULL) {
245 return downstream;
248 return NULL;
251 static void usb_hub_handle_reset(USBDevice *dev)
253 USBHubState *s = USB_HUB(dev);
254 USBHubPort *port;
255 int i;
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;
272 static const char *feature_name(int feature)
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",
291 if (feature < 0 || feature >= ARRAY_SIZE(name)) {
292 return "?";
294 return name[feature] ?: "?";
297 static void usb_hub_handle_control(USBDevice *dev, USBPacket *p,
298 int request, int value, int index, int length, uint8_t *data)
300 USBHubState *s = (USBHubState *)dev;
301 int ret;
303 trace_usb_hub_control(s->dev.addr, request, value, index, length);
305 ret = usb_desc_handle_control(dev, p, request, value, index, length, data);
306 if (ret >= 0) {
307 return;
310 switch(request) {
311 case EndpointOutRequest | USB_REQ_CLEAR_FEATURE:
312 if (value == 0 && index != 0x81) { /* clear ep halt */
313 goto fail;
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:
326 unsigned int n = index - 1;
327 USBHubPort *port;
328 if (n >= NUM_PORTS) {
329 goto fail;
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;
341 break;
342 case SetHubFeature:
343 case ClearHubFeature:
344 if (value != 0 && value != 1) {
345 goto fail;
347 break;
348 case SetPortFeature:
350 unsigned int n = index - 1;
351 USBHubPort *port;
352 USBDevice *dev;
354 trace_usb_hub_set_port_feature(s->dev.addr, index,
355 feature_name(value));
357 if (n >= NUM_PORTS) {
358 goto fail;
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);
374 break;
375 case PORT_POWER:
376 break;
377 default:
378 goto fail;
381 break;
382 case ClearPortFeature:
384 unsigned int n = index - 1;
385 USBHubPort *port;
387 trace_usb_hub_clear_port_feature(s->dev.addr, index,
388 feature_name(value));
390 if (n >= NUM_PORTS) {
391 goto fail;
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;
420 break;
421 case GetHubDescriptor:
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;
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++;
435 /* fill PortPwrCtrlMask bits */
436 limit = limit + ((NUM_PORTS + 7) / 8);
437 for (;n < limit; n++) {
438 data[n] = 0xff;
439 var_hub_size++;
442 p->actual_length = sizeof(qemu_hub_hub_descriptor) + var_hub_size;
443 data[0] = p->actual_length;
444 break;
446 default:
447 fail:
448 p->status = USB_RET_STALL;
449 break;
453 static void usb_hub_handle_data(USBDevice *dev, USBPacket *p)
455 USBHubState *s = (USBHubState *)dev;
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;
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));
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);
482 usb_packet_copy(p, buf, n);
483 } else {
484 p->status = USB_RET_NAK; /* usb11 11.13.1 */
486 } else {
487 goto fail;
489 break;
490 case USB_TOKEN_OUT:
491 default:
492 fail:
493 p->status = USB_RET_STALL;
494 break;
498 static void usb_hub_handle_destroy(USBDevice *dev)
500 USBHubState *s = (USBHubState *)dev;
501 int i;
503 for (i = 0; i < NUM_PORTS; i++) {
504 usb_unregister_port(usb_bus_from_device(dev),
505 &s->ports[i].port);
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,
517 static void usb_hub_realize(USBDevice *dev, Error **errp)
519 USBHubState *s = USB_HUB(dev);
520 USBHubPort *port;
521 int i;
523 if (dev->port->hubcount == 5) {
524 error_setg(errp, "usb hub chain too deep");
525 return;
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);
538 usb_hub_handle_reset(dev);
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()
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()
564 static void usb_hub_class_initfn(ObjectClass *klass, void *data)
566 DeviceClass *dc = DEVICE_CLASS(klass);
567 USBDeviceClass *uc = USB_DEVICE_CLASS(klass);
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;
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,
589 static void usb_hub_register_types(void)
591 type_register_static(&hub_info);
594 type_init(usb_hub_register_types)