coroutine: add test-coroutine --benchmark-lifecycle
[qemu/stefanha.git] / hw / usb-desc.c
blobbc6858f62f540969a500861fc023fc0b8d6cd83d
1 #include "usb.h"
2 #include "usb-desc.h"
3 #include "trace.h"
5 /* ------------------------------------------------------------------ */
7 static uint8_t usb_lo(uint16_t val)
9 return val & 0xff;
12 static uint8_t usb_hi(uint16_t val)
14 return (val >> 8) & 0xff;
17 int usb_desc_device(const USBDescID *id, const USBDescDevice *dev,
18 uint8_t *dest, size_t len)
20 uint8_t bLength = 0x12;
22 if (len < bLength) {
23 return -1;
26 dest[0x00] = bLength;
27 dest[0x01] = USB_DT_DEVICE;
29 dest[0x02] = usb_lo(dev->bcdUSB);
30 dest[0x03] = usb_hi(dev->bcdUSB);
31 dest[0x04] = dev->bDeviceClass;
32 dest[0x05] = dev->bDeviceSubClass;
33 dest[0x06] = dev->bDeviceProtocol;
34 dest[0x07] = dev->bMaxPacketSize0;
36 dest[0x08] = usb_lo(id->idVendor);
37 dest[0x09] = usb_hi(id->idVendor);
38 dest[0x0a] = usb_lo(id->idProduct);
39 dest[0x0b] = usb_hi(id->idProduct);
40 dest[0x0c] = usb_lo(id->bcdDevice);
41 dest[0x0d] = usb_hi(id->bcdDevice);
42 dest[0x0e] = id->iManufacturer;
43 dest[0x0f] = id->iProduct;
44 dest[0x10] = id->iSerialNumber;
46 dest[0x11] = dev->bNumConfigurations;
48 return bLength;
51 int usb_desc_device_qualifier(const USBDescDevice *dev,
52 uint8_t *dest, size_t len)
54 uint8_t bLength = 0x0a;
56 if (len < bLength) {
57 return -1;
60 dest[0x00] = bLength;
61 dest[0x01] = USB_DT_DEVICE_QUALIFIER;
63 dest[0x02] = usb_lo(dev->bcdUSB);
64 dest[0x03] = usb_hi(dev->bcdUSB);
65 dest[0x04] = dev->bDeviceClass;
66 dest[0x05] = dev->bDeviceSubClass;
67 dest[0x06] = dev->bDeviceProtocol;
68 dest[0x07] = dev->bMaxPacketSize0;
69 dest[0x08] = dev->bNumConfigurations;
70 dest[0x09] = 0; /* reserved */
72 return bLength;
75 int usb_desc_config(const USBDescConfig *conf, uint8_t *dest, size_t len)
77 uint8_t bLength = 0x09;
78 uint16_t wTotalLength = 0;
79 int i, rc;
81 if (len < bLength) {
82 return -1;
85 dest[0x00] = bLength;
86 dest[0x01] = USB_DT_CONFIG;
87 dest[0x04] = conf->bNumInterfaces;
88 dest[0x05] = conf->bConfigurationValue;
89 dest[0x06] = conf->iConfiguration;
90 dest[0x07] = conf->bmAttributes;
91 dest[0x08] = conf->bMaxPower;
92 wTotalLength += bLength;
94 /* handle grouped interfaces if any*/
95 for (i = 0; i < conf->nif_groups; i++) {
96 rc = usb_desc_iface_group(&(conf->if_groups[i]),
97 dest + wTotalLength,
98 len - wTotalLength);
99 if (rc < 0) {
100 return rc;
102 wTotalLength += rc;
105 /* handle normal (ungrouped / no IAD) interfaces if any */
106 for (i = 0; i < conf->nif; i++) {
107 rc = usb_desc_iface(conf->ifs + i, dest + wTotalLength, len - wTotalLength);
108 if (rc < 0) {
109 return rc;
111 wTotalLength += rc;
114 dest[0x02] = usb_lo(wTotalLength);
115 dest[0x03] = usb_hi(wTotalLength);
116 return wTotalLength;
119 int usb_desc_iface_group(const USBDescIfaceAssoc *iad, uint8_t *dest,
120 size_t len)
122 int pos = 0;
123 int i = 0;
125 /* handle interface association descriptor */
126 uint8_t bLength = 0x08;
128 if (len < bLength) {
129 return -1;
132 dest[0x00] = bLength;
133 dest[0x01] = USB_DT_INTERFACE_ASSOC;
134 dest[0x02] = iad->bFirstInterface;
135 dest[0x03] = iad->bInterfaceCount;
136 dest[0x04] = iad->bFunctionClass;
137 dest[0x05] = iad->bFunctionSubClass;
138 dest[0x06] = iad->bFunctionProtocol;
139 dest[0x07] = iad->iFunction;
140 pos += bLength;
142 /* handle associated interfaces in this group */
143 for (i = 0; i < iad->nif; i++) {
144 int rc = usb_desc_iface(&(iad->ifs[i]), dest + pos, len - pos);
145 if (rc < 0) {
146 return rc;
148 pos += rc;
151 return pos;
154 int usb_desc_iface(const USBDescIface *iface, uint8_t *dest, size_t len)
156 uint8_t bLength = 0x09;
157 int i, rc, pos = 0;
159 if (len < bLength) {
160 return -1;
163 dest[0x00] = bLength;
164 dest[0x01] = USB_DT_INTERFACE;
165 dest[0x02] = iface->bInterfaceNumber;
166 dest[0x03] = iface->bAlternateSetting;
167 dest[0x04] = iface->bNumEndpoints;
168 dest[0x05] = iface->bInterfaceClass;
169 dest[0x06] = iface->bInterfaceSubClass;
170 dest[0x07] = iface->bInterfaceProtocol;
171 dest[0x08] = iface->iInterface;
172 pos += bLength;
174 for (i = 0; i < iface->ndesc; i++) {
175 rc = usb_desc_other(iface->descs + i, dest + pos, len - pos);
176 if (rc < 0) {
177 return rc;
179 pos += rc;
182 for (i = 0; i < iface->bNumEndpoints; i++) {
183 rc = usb_desc_endpoint(iface->eps + i, dest + pos, len - pos);
184 if (rc < 0) {
185 return rc;
187 pos += rc;
190 return pos;
193 int usb_desc_endpoint(const USBDescEndpoint *ep, uint8_t *dest, size_t len)
195 uint8_t bLength = 0x07;
197 if (len < bLength) {
198 return -1;
201 dest[0x00] = bLength;
202 dest[0x01] = USB_DT_ENDPOINT;
203 dest[0x02] = ep->bEndpointAddress;
204 dest[0x03] = ep->bmAttributes;
205 dest[0x04] = usb_lo(ep->wMaxPacketSize);
206 dest[0x05] = usb_hi(ep->wMaxPacketSize);
207 dest[0x06] = ep->bInterval;
209 return bLength;
212 int usb_desc_other(const USBDescOther *desc, uint8_t *dest, size_t len)
214 int bLength = desc->length ? desc->length : desc->data[0];
216 if (len < bLength) {
217 return -1;
220 memcpy(dest, desc->data, bLength);
221 return bLength;
224 /* ------------------------------------------------------------------ */
226 static void usb_desc_setdefaults(USBDevice *dev)
228 const USBDesc *desc = dev->info->usb_desc;
230 assert(desc != NULL);
231 switch (dev->speed) {
232 case USB_SPEED_LOW:
233 case USB_SPEED_FULL:
234 dev->device = desc->full;
235 break;
236 case USB_SPEED_HIGH:
237 dev->device = desc->high;
238 break;
240 dev->config = dev->device->confs;
243 void usb_desc_init(USBDevice *dev)
245 const USBDesc *desc = dev->info->usb_desc;
247 assert(desc != NULL);
248 dev->speed = USB_SPEED_FULL;
249 dev->speedmask = 0;
250 if (desc->full) {
251 dev->speedmask |= USB_SPEED_MASK_FULL;
253 if (desc->high) {
254 dev->speedmask |= USB_SPEED_MASK_HIGH;
256 usb_desc_setdefaults(dev);
259 void usb_desc_attach(USBDevice *dev)
261 const USBDesc *desc = dev->info->usb_desc;
263 assert(desc != NULL);
264 if (desc->high && (dev->port->speedmask & USB_SPEED_MASK_HIGH)) {
265 dev->speed = USB_SPEED_HIGH;
266 } else if (desc->full && (dev->port->speedmask & USB_SPEED_MASK_FULL)) {
267 dev->speed = USB_SPEED_FULL;
268 } else {
269 fprintf(stderr, "usb: port/device speed mismatch for \"%s\"\n",
270 dev->info->product_desc);
271 return;
273 usb_desc_setdefaults(dev);
276 void usb_desc_set_string(USBDevice *dev, uint8_t index, const char *str)
278 USBDescString *s;
280 QLIST_FOREACH(s, &dev->strings, next) {
281 if (s->index == index) {
282 break;
285 if (s == NULL) {
286 s = qemu_mallocz(sizeof(*s));
287 s->index = index;
288 QLIST_INSERT_HEAD(&dev->strings, s, next);
290 qemu_free(s->str);
291 s->str = qemu_strdup(str);
294 const char *usb_desc_get_string(USBDevice *dev, uint8_t index)
296 USBDescString *s;
298 QLIST_FOREACH(s, &dev->strings, next) {
299 if (s->index == index) {
300 return s->str;
303 return NULL;
306 int usb_desc_string(USBDevice *dev, int index, uint8_t *dest, size_t len)
308 uint8_t bLength, pos, i;
309 const char *str;
311 if (len < 4) {
312 return -1;
315 if (index == 0) {
316 /* language ids */
317 dest[0] = 4;
318 dest[1] = USB_DT_STRING;
319 dest[2] = 0x09;
320 dest[3] = 0x04;
321 return 4;
324 str = usb_desc_get_string(dev, index);
325 if (str == NULL) {
326 str = dev->info->usb_desc->str[index];
327 if (str == NULL) {
328 return 0;
332 bLength = strlen(str) * 2 + 2;
333 dest[0] = bLength;
334 dest[1] = USB_DT_STRING;
335 i = 0; pos = 2;
336 while (pos+1 < bLength && pos+1 < len) {
337 dest[pos++] = str[i++];
338 dest[pos++] = 0;
340 return pos;
343 int usb_desc_get_descriptor(USBDevice *dev, int value, uint8_t *dest, size_t len)
345 const USBDesc *desc = dev->info->usb_desc;
346 const USBDescDevice *other_dev;
347 uint8_t buf[256];
348 uint8_t type = value >> 8;
349 uint8_t index = value & 0xff;
350 int ret = -1;
352 if (dev->speed == USB_SPEED_HIGH) {
353 other_dev = dev->info->usb_desc->full;
354 } else {
355 other_dev = dev->info->usb_desc->high;
358 switch(type) {
359 case USB_DT_DEVICE:
360 ret = usb_desc_device(&desc->id, dev->device, buf, sizeof(buf));
361 trace_usb_desc_device(dev->addr, len, ret);
362 break;
363 case USB_DT_CONFIG:
364 if (index < dev->device->bNumConfigurations) {
365 ret = usb_desc_config(dev->device->confs + index, buf, sizeof(buf));
367 trace_usb_desc_config(dev->addr, index, len, ret);
368 break;
369 case USB_DT_STRING:
370 ret = usb_desc_string(dev, index, buf, sizeof(buf));
371 trace_usb_desc_string(dev->addr, index, len, ret);
372 break;
374 case USB_DT_DEVICE_QUALIFIER:
375 if (other_dev != NULL) {
376 ret = usb_desc_device_qualifier(other_dev, buf, sizeof(buf));
378 trace_usb_desc_device_qualifier(dev->addr, len, ret);
379 break;
380 case USB_DT_OTHER_SPEED_CONFIG:
381 if (other_dev != NULL && index < other_dev->bNumConfigurations) {
382 ret = usb_desc_config(other_dev->confs + index, buf, sizeof(buf));
383 buf[0x01] = USB_DT_OTHER_SPEED_CONFIG;
385 trace_usb_desc_other_speed_config(dev->addr, index, len, ret);
386 break;
388 case USB_DT_DEBUG:
389 /* ignore silently */
390 break;
392 default:
393 fprintf(stderr, "%s: %d unknown type %d (len %zd)\n", __FUNCTION__,
394 dev->addr, type, len);
395 break;
398 if (ret > 0) {
399 if (ret > len) {
400 ret = len;
402 memcpy(dest, buf, ret);
404 return ret;
407 int usb_desc_handle_control(USBDevice *dev, USBPacket *p,
408 int request, int value, int index, int length, uint8_t *data)
410 const USBDesc *desc = dev->info->usb_desc;
411 int i, ret = -1;
413 assert(desc != NULL);
414 switch(request) {
415 case DeviceOutRequest | USB_REQ_SET_ADDRESS:
416 dev->addr = value;
417 trace_usb_set_addr(dev->addr);
418 ret = 0;
419 break;
421 case DeviceRequest | USB_REQ_GET_DESCRIPTOR:
422 ret = usb_desc_get_descriptor(dev, value, data, length);
423 break;
425 case DeviceRequest | USB_REQ_GET_CONFIGURATION:
426 data[0] = dev->config->bConfigurationValue;
427 ret = 1;
428 break;
429 case DeviceOutRequest | USB_REQ_SET_CONFIGURATION:
430 for (i = 0; i < dev->device->bNumConfigurations; i++) {
431 if (dev->device->confs[i].bConfigurationValue == value) {
432 dev->config = dev->device->confs + i;
433 ret = 0;
436 trace_usb_set_config(dev->addr, value, ret);
437 break;
439 case DeviceRequest | USB_REQ_GET_STATUS:
440 data[0] = 0;
441 if (dev->config->bmAttributes & 0x40) {
442 data[0] |= 1 << USB_DEVICE_SELF_POWERED;
444 if (dev->remote_wakeup) {
445 data[0] |= 1 << USB_DEVICE_REMOTE_WAKEUP;
447 data[1] = 0x00;
448 ret = 2;
449 break;
450 case DeviceOutRequest | USB_REQ_CLEAR_FEATURE:
451 if (value == USB_DEVICE_REMOTE_WAKEUP) {
452 dev->remote_wakeup = 0;
453 ret = 0;
455 trace_usb_clear_device_feature(dev->addr, value, ret);
456 break;
457 case DeviceOutRequest | USB_REQ_SET_FEATURE:
458 if (value == USB_DEVICE_REMOTE_WAKEUP) {
459 dev->remote_wakeup = 1;
460 ret = 0;
462 trace_usb_set_device_feature(dev->addr, value, ret);
463 break;
465 return ret;