usb: move complete callback to port ops
[qemu.git] / hw / usb-hub.c
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 "usb.h"
26 #include "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 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 " QEMU_VERSION,
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 .ifs = &desc_iface_hub,
123 },
124 },
125 };
126
127 static const USBDesc desc_hub = {
128 .id = {
129 .idVendor = 0,
130 .idProduct = 0,
131 .bcdDevice = 0x0101,
132 .iManufacturer = STR_MANUFACTURER,
133 .iProduct = STR_PRODUCT,
134 .iSerialNumber = STR_SERIALNUMBER,
135 },
136 .full = &desc_device_hub,
137 .str = desc_strings,
138 };
139
140 static const uint8_t qemu_hub_dev_descriptor[] = {
141 0x12, /* u8 bLength; */
142 0x01, /* u8 bDescriptorType; Device */
143 0x10, 0x01, /* u16 bcdUSB; v1.1 */
144
145 0x09, /* u8 bDeviceClass; HUB_CLASSCODE */
146 0x00, /* u8 bDeviceSubClass; */
147 0x00, /* u8 bDeviceProtocol; [ low/full speeds only ] */
148 0x08, /* u8 bMaxPacketSize0; 8 Bytes */
149
150 0x00, 0x00, /* u16 idVendor; */
151 0x00, 0x00, /* u16 idProduct; */
152 0x01, 0x01, /* u16 bcdDevice */
153
154 0x03, /* u8 iManufacturer; */
155 0x02, /* u8 iProduct; */
156 0x01, /* u8 iSerialNumber; */
157 0x01 /* u8 bNumConfigurations; */
158 };
159
160 /* XXX: patch interrupt size */
161 static const uint8_t qemu_hub_config_descriptor[] = {
162
163 /* one configuration */
164 0x09, /* u8 bLength; */
165 0x02, /* u8 bDescriptorType; Configuration */
166 0x19, 0x00, /* u16 wTotalLength; */
167 0x01, /* u8 bNumInterfaces; (1) */
168 0x01, /* u8 bConfigurationValue; */
169 0x00, /* u8 iConfiguration; */
170 0xe0, /* u8 bmAttributes;
171 Bit 7: must be set,
172 6: Self-powered,
173 5: Remote wakeup,
174 4..0: resvd */
175 0x00, /* u8 MaxPower; */
176
177 /* USB 1.1:
178 * USB 2.0, single TT organization (mandatory):
179 * one interface, protocol 0
180 *
181 * USB 2.0, multiple TT organization (optional):
182 * two interfaces, protocols 1 (like single TT)
183 * and 2 (multiple TT mode) ... config is
184 * sometimes settable
185 * NOT IMPLEMENTED
186 */
187
188 /* one interface */
189 0x09, /* u8 if_bLength; */
190 0x04, /* u8 if_bDescriptorType; Interface */
191 0x00, /* u8 if_bInterfaceNumber; */
192 0x00, /* u8 if_bAlternateSetting; */
193 0x01, /* u8 if_bNumEndpoints; */
194 0x09, /* u8 if_bInterfaceClass; HUB_CLASSCODE */
195 0x00, /* u8 if_bInterfaceSubClass; */
196 0x00, /* u8 if_bInterfaceProtocol; [usb1.1 or single tt] */
197 0x00, /* u8 if_iInterface; */
198
199 /* one endpoint (status change endpoint) */
200 0x07, /* u8 ep_bLength; */
201 0x05, /* u8 ep_bDescriptorType; Endpoint */
202 0x81, /* u8 ep_bEndpointAddress; IN Endpoint 1 */
203 0x03, /* u8 ep_bmAttributes; Interrupt */
204 0x02, 0x00, /* u16 ep_wMaxPacketSize; 1 + (MAX_ROOT_PORTS / 8) */
205 0xff /* u8 ep_bInterval; (255ms -- usb 2.0 spec) */
206 };
207
208 static const uint8_t qemu_hub_hub_descriptor[] =
209 {
210 0x00, /* u8 bLength; patched in later */
211 0x29, /* u8 bDescriptorType; Hub-descriptor */
212 0x00, /* u8 bNbrPorts; (patched later) */
213 0x0a, /* u16 wHubCharacteristics; */
214 0x00, /* (per-port OC, no power switching) */
215 0x01, /* u8 bPwrOn2pwrGood; 2ms */
216 0x00 /* u8 bHubContrCurrent; 0 mA */
217
218 /* DeviceRemovable and PortPwrCtrlMask patched in later */
219 };
220
221 static void usb_hub_attach(USBPort *port1)
222 {
223 USBHubState *s = port1->opaque;
224 USBHubPort *port = &s->ports[port1->index];
225
226 port->wPortStatus |= PORT_STAT_CONNECTION;
227 port->wPortChange |= PORT_STAT_C_CONNECTION;
228 if (port->port.dev->speed == USB_SPEED_LOW) {
229 port->wPortStatus |= PORT_STAT_LOW_SPEED;
230 } else {
231 port->wPortStatus &= ~PORT_STAT_LOW_SPEED;
232 }
233 }
234
235 static void usb_hub_detach(USBPort *port1)
236 {
237 USBHubState *s = port1->opaque;
238 USBHubPort *port = &s->ports[port1->index];
239
240 port->wPortStatus &= ~PORT_STAT_CONNECTION;
241 port->wPortChange |= PORT_STAT_C_CONNECTION;
242 if (port->wPortStatus & PORT_STAT_ENABLE) {
243 port->wPortStatus &= ~PORT_STAT_ENABLE;
244 port->wPortChange |= PORT_STAT_C_ENABLE;
245 }
246 }
247
248 static void usb_hub_wakeup(USBDevice *dev)
249 {
250 USBHubState *s = dev->port->opaque;
251 USBHubPort *port = &s->ports[dev->port->index];
252
253 if (port->wPortStatus & PORT_STAT_SUSPEND) {
254 port->wPortChange |= PORT_STAT_C_SUSPEND;
255 usb_wakeup(&s->dev);
256 }
257 }
258
259 static void usb_hub_complete(USBDevice *dev, USBPacket *packet)
260 {
261 USBHubState *s = dev->port->opaque;
262
263 /*
264 * Just pass it along upstream for now.
265 *
266 * If we ever inplement usb 2.0 split transactions this will
267 * become a little more complicated ...
268 */
269 usb_packet_complete(&s->dev, packet);
270 }
271
272 static void usb_hub_handle_attach(USBDevice *dev)
273 {
274 USBHubState *s = DO_UPCAST(USBHubState, dev, dev);
275 int i;
276
277 for (i = 0; i < NUM_PORTS; i++) {
278 usb_port_location(&s->ports[i].port, dev->port, i+1);
279 }
280 }
281
282 static void usb_hub_handle_reset(USBDevice *dev)
283 {
284 /* XXX: do it */
285 }
286
287 static int usb_hub_handle_control(USBDevice *dev, int request, int value,
288 int index, int length, uint8_t *data)
289 {
290 USBHubState *s = (USBHubState *)dev;
291 int ret;
292
293 ret = usb_desc_handle_control(dev, request, value, index, length, data);
294 if (ret >= 0) {
295 return ret;
296 }
297
298 switch(request) {
299 case EndpointOutRequest | USB_REQ_CLEAR_FEATURE:
300 if (value == 0 && index != 0x81) { /* clear ep halt */
301 goto fail;
302 }
303 ret = 0;
304 break;
305 case DeviceRequest | USB_REQ_GET_INTERFACE:
306 data[0] = 0;
307 ret = 1;
308 break;
309 case DeviceOutRequest | USB_REQ_SET_INTERFACE:
310 ret = 0;
311 break;
312 /* usb specific requests */
313 case GetHubStatus:
314 data[0] = 0;
315 data[1] = 0;
316 data[2] = 0;
317 data[3] = 0;
318 ret = 4;
319 break;
320 case GetPortStatus:
321 {
322 unsigned int n = index - 1;
323 USBHubPort *port;
324 if (n >= NUM_PORTS) {
325 goto fail;
326 }
327 port = &s->ports[n];
328 data[0] = port->wPortStatus;
329 data[1] = port->wPortStatus >> 8;
330 data[2] = port->wPortChange;
331 data[3] = port->wPortChange >> 8;
332 ret = 4;
333 }
334 break;
335 case SetHubFeature:
336 case ClearHubFeature:
337 if (value == 0 || value == 1) {
338 } else {
339 goto fail;
340 }
341 ret = 0;
342 break;
343 case SetPortFeature:
344 {
345 unsigned int n = index - 1;
346 USBHubPort *port;
347 USBDevice *dev;
348 if (n >= NUM_PORTS) {
349 goto fail;
350 }
351 port = &s->ports[n];
352 dev = port->port.dev;
353 switch(value) {
354 case PORT_SUSPEND:
355 port->wPortStatus |= PORT_STAT_SUSPEND;
356 break;
357 case PORT_RESET:
358 if (dev) {
359 usb_send_msg(dev, USB_MSG_RESET);
360 port->wPortChange |= PORT_STAT_C_RESET;
361 /* set enable bit */
362 port->wPortStatus |= PORT_STAT_ENABLE;
363 }
364 break;
365 case PORT_POWER:
366 break;
367 default:
368 goto fail;
369 }
370 ret = 0;
371 }
372 break;
373 case ClearPortFeature:
374 {
375 unsigned int n = index - 1;
376 USBHubPort *port;
377
378 if (n >= NUM_PORTS) {
379 goto fail;
380 }
381 port = &s->ports[n];
382 switch(value) {
383 case PORT_ENABLE:
384 port->wPortStatus &= ~PORT_STAT_ENABLE;
385 break;
386 case PORT_C_ENABLE:
387 port->wPortChange &= ~PORT_STAT_C_ENABLE;
388 break;
389 case PORT_SUSPEND:
390 port->wPortStatus &= ~PORT_STAT_SUSPEND;
391 break;
392 case PORT_C_SUSPEND:
393 port->wPortChange &= ~PORT_STAT_C_SUSPEND;
394 break;
395 case PORT_C_CONNECTION:
396 port->wPortChange &= ~PORT_STAT_C_CONNECTION;
397 break;
398 case PORT_C_OVERCURRENT:
399 port->wPortChange &= ~PORT_STAT_C_OVERCURRENT;
400 break;
401 case PORT_C_RESET:
402 port->wPortChange &= ~PORT_STAT_C_RESET;
403 break;
404 default:
405 goto fail;
406 }
407 ret = 0;
408 }
409 break;
410 case GetHubDescriptor:
411 {
412 unsigned int n, limit, var_hub_size = 0;
413 memcpy(data, qemu_hub_hub_descriptor,
414 sizeof(qemu_hub_hub_descriptor));
415 data[2] = NUM_PORTS;
416
417 /* fill DeviceRemovable bits */
418 limit = ((NUM_PORTS + 1 + 7) / 8) + 7;
419 for (n = 7; n < limit; n++) {
420 data[n] = 0x00;
421 var_hub_size++;
422 }
423
424 /* fill PortPwrCtrlMask bits */
425 limit = limit + ((NUM_PORTS + 7) / 8);
426 for (;n < limit; n++) {
427 data[n] = 0xff;
428 var_hub_size++;
429 }
430
431 ret = sizeof(qemu_hub_hub_descriptor) + var_hub_size;
432 data[0] = ret;
433 break;
434 }
435 default:
436 fail:
437 ret = USB_RET_STALL;
438 break;
439 }
440 return ret;
441 }
442
443 static int usb_hub_handle_data(USBDevice *dev, USBPacket *p)
444 {
445 USBHubState *s = (USBHubState *)dev;
446 int ret;
447
448 switch(p->pid) {
449 case USB_TOKEN_IN:
450 if (p->devep == 1) {
451 USBHubPort *port;
452 unsigned int status;
453 int i, n;
454 n = (NUM_PORTS + 1 + 7) / 8;
455 if (p->len == 1) { /* FreeBSD workaround */
456 n = 1;
457 } else if (n > p->len) {
458 return USB_RET_BABBLE;
459 }
460 status = 0;
461 for(i = 0; i < NUM_PORTS; i++) {
462 port = &s->ports[i];
463 if (port->wPortChange)
464 status |= (1 << (i + 1));
465 }
466 if (status != 0) {
467 for(i = 0; i < n; i++) {
468 p->data[i] = status >> (8 * i);
469 }
470 ret = n;
471 } else {
472 ret = USB_RET_NAK; /* usb11 11.13.1 */
473 }
474 } else {
475 goto fail;
476 }
477 break;
478 case USB_TOKEN_OUT:
479 default:
480 fail:
481 ret = USB_RET_STALL;
482 break;
483 }
484 return ret;
485 }
486
487 static int usb_hub_broadcast_packet(USBHubState *s, USBPacket *p)
488 {
489 USBHubPort *port;
490 USBDevice *dev;
491 int i, ret;
492
493 for(i = 0; i < NUM_PORTS; i++) {
494 port = &s->ports[i];
495 dev = port->port.dev;
496 if (dev && (port->wPortStatus & PORT_STAT_ENABLE)) {
497 ret = dev->info->handle_packet(dev, p);
498 if (ret != USB_RET_NODEV) {
499 return ret;
500 }
501 }
502 }
503 return USB_RET_NODEV;
504 }
505
506 static int usb_hub_handle_packet(USBDevice *dev, USBPacket *p)
507 {
508 USBHubState *s = (USBHubState *)dev;
509
510 #if defined(DEBUG) && 0
511 printf("usb_hub: pid=0x%x\n", pid);
512 #endif
513 if (dev->state == USB_STATE_DEFAULT &&
514 dev->addr != 0 &&
515 p->devaddr != dev->addr &&
516 (p->pid == USB_TOKEN_SETUP ||
517 p->pid == USB_TOKEN_OUT ||
518 p->pid == USB_TOKEN_IN)) {
519 /* broadcast the packet to the devices */
520 return usb_hub_broadcast_packet(s, p);
521 }
522 return usb_generic_handle_packet(dev, p);
523 }
524
525 static void usb_hub_handle_destroy(USBDevice *dev)
526 {
527 USBHubState *s = (USBHubState *)dev;
528 int i;
529
530 for (i = 0; i < NUM_PORTS; i++) {
531 usb_unregister_port(usb_bus_from_device(dev),
532 &s->ports[i].port);
533 }
534 }
535
536 static USBPortOps usb_hub_port_ops = {
537 .attach = usb_hub_attach,
538 .detach = usb_hub_detach,
539 .wakeup = usb_hub_wakeup,
540 .complete = usb_hub_complete,
541 };
542
543 static int usb_hub_initfn(USBDevice *dev)
544 {
545 USBHubState *s = DO_UPCAST(USBHubState, dev, dev);
546 USBHubPort *port;
547 int i;
548
549 usb_desc_init(dev);
550 for (i = 0; i < NUM_PORTS; i++) {
551 port = &s->ports[i];
552 usb_register_port(usb_bus_from_device(dev),
553 &port->port, s, i, &usb_hub_port_ops,
554 USB_SPEED_MASK_LOW | USB_SPEED_MASK_FULL);
555 port->wPortStatus = PORT_STAT_POWER;
556 port->wPortChange = 0;
557 }
558 return 0;
559 }
560
561 static const VMStateDescription vmstate_usb_hub_port = {
562 .name = "usb-hub-port",
563 .version_id = 1,
564 .minimum_version_id = 1,
565 .fields = (VMStateField []) {
566 VMSTATE_UINT16(wPortStatus, USBHubPort),
567 VMSTATE_UINT16(wPortChange, USBHubPort),
568 VMSTATE_END_OF_LIST()
569 }
570 };
571
572 static const VMStateDescription vmstate_usb_hub = {
573 .name = "usb-hub",
574 .version_id = 1,
575 .minimum_version_id = 1,
576 .fields = (VMStateField []) {
577 VMSTATE_USB_DEVICE(dev, USBHubState),
578 VMSTATE_STRUCT_ARRAY(ports, USBHubState, NUM_PORTS, 0,
579 vmstate_usb_hub_port, USBHubPort),
580 VMSTATE_END_OF_LIST()
581 }
582 };
583
584 static struct USBDeviceInfo hub_info = {
585 .product_desc = "QEMU USB Hub",
586 .qdev.name = "usb-hub",
587 .qdev.fw_name = "hub",
588 .qdev.size = sizeof(USBHubState),
589 .qdev.vmsd = &vmstate_usb_hub,
590 .usb_desc = &desc_hub,
591 .init = usb_hub_initfn,
592 .handle_packet = usb_hub_handle_packet,
593 .handle_attach = usb_hub_handle_attach,
594 .handle_reset = usb_hub_handle_reset,
595 .handle_control = usb_hub_handle_control,
596 .handle_data = usb_hub_handle_data,
597 .handle_destroy = usb_hub_handle_destroy,
598 };
599
600 static void usb_hub_register_devices(void)
601 {
602 usb_qdev_register(&hub_info);
603 }
604 device_init(usb_hub_register_devices)