![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to usb-desc.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / hw|
Return to usb-desc.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / hw |
1.1 root 1: #include "usb.h"
2: #include "usb-desc.h"
3: #include "trace.h"
4:
5: /* ------------------------------------------------------------------ */
6:
7: static uint8_t usb_lo(uint16_t val)
8: {
9: return val & 0xff;
10: }
11:
12: static uint8_t usb_hi(uint16_t val)
13: {
14: return (val >> 8) & 0xff;
15: }
16:
17: int usb_desc_device(const USBDescID *id, const USBDescDevice *dev,
18: uint8_t *dest, size_t len)
19: {
20: uint8_t bLength = 0x12;
21:
22: if (len < bLength) {
23: return -1;
24: }
25:
26: dest[0x00] = bLength;
27: dest[0x01] = USB_DT_DEVICE;
28:
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;
35:
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;
45:
46: dest[0x11] = dev->bNumConfigurations;
47:
48: return bLength;
49: }
50:
51: int usb_desc_device_qualifier(const USBDescDevice *dev,
52: uint8_t *dest, size_t len)
53: {
54: uint8_t bLength = 0x0a;
55:
56: if (len < bLength) {
57: return -1;
58: }
59:
60: dest[0x00] = bLength;
61: dest[0x01] = USB_DT_DEVICE_QUALIFIER;
62:
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 */
71:
72: return bLength;
73: }
74:
75: int usb_desc_config(const USBDescConfig *conf, uint8_t *dest, size_t len)
76: {
77: uint8_t bLength = 0x09;
78: uint16_t wTotalLength = 0;
79: int i, rc, count;
80:
81: if (len < bLength) {
82: return -1;
83: }
84:
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;
93:
94: count = conf->nif ? conf->nif : conf->bNumInterfaces;
95: for (i = 0; i < count; i++) {
96: rc = usb_desc_iface(conf->ifs + i, dest + wTotalLength, len - wTotalLength);
97: if (rc < 0) {
98: return rc;
99: }
100: wTotalLength += rc;
101: }
102:
103: dest[0x02] = usb_lo(wTotalLength);
104: dest[0x03] = usb_hi(wTotalLength);
105: return wTotalLength;
106: }
107:
108: int usb_desc_iface(const USBDescIface *iface, uint8_t *dest, size_t len)
109: {
110: uint8_t bLength = 0x09;
111: int i, rc, pos = 0;
112:
113: if (len < bLength) {
114: return -1;
115: }
116:
117: dest[0x00] = bLength;
118: dest[0x01] = USB_DT_INTERFACE;
119: dest[0x02] = iface->bInterfaceNumber;
120: dest[0x03] = iface->bAlternateSetting;
121: dest[0x04] = iface->bNumEndpoints;
122: dest[0x05] = iface->bInterfaceClass;
123: dest[0x06] = iface->bInterfaceSubClass;
124: dest[0x07] = iface->bInterfaceProtocol;
125: dest[0x08] = iface->iInterface;
126: pos += bLength;
127:
128: for (i = 0; i < iface->ndesc; i++) {
129: rc = usb_desc_other(iface->descs + i, dest + pos, len - pos);
130: if (rc < 0) {
131: return rc;
132: }
133: pos += rc;
134: }
135:
136: for (i = 0; i < iface->bNumEndpoints; i++) {
137: rc = usb_desc_endpoint(iface->eps + i, dest + pos, len - pos);
138: if (rc < 0) {
139: return rc;
140: }
141: pos += rc;
142: }
143:
144: return pos;
145: }
146:
147: int usb_desc_endpoint(const USBDescEndpoint *ep, uint8_t *dest, size_t len)
148: {
149: uint8_t bLength = 0x07;
150:
151: if (len < bLength) {
152: return -1;
153: }
154:
155: dest[0x00] = bLength;
156: dest[0x01] = USB_DT_ENDPOINT;
157: dest[0x02] = ep->bEndpointAddress;
158: dest[0x03] = ep->bmAttributes;
159: dest[0x04] = usb_lo(ep->wMaxPacketSize);
160: dest[0x05] = usb_hi(ep->wMaxPacketSize);
161: dest[0x06] = ep->bInterval;
162:
163: return bLength;
164: }
165:
166: int usb_desc_other(const USBDescOther *desc, uint8_t *dest, size_t len)
167: {
168: int bLength = desc->length ? desc->length : desc->data[0];
169:
170: if (len < bLength) {
171: return -1;
172: }
173:
174: memcpy(dest, desc->data, bLength);
175: return bLength;
176: }
177:
178: /* ------------------------------------------------------------------ */
179:
180: static void usb_desc_setdefaults(USBDevice *dev)
181: {
182: const USBDesc *desc = dev->info->usb_desc;
183:
184: assert(desc != NULL);
185: switch (dev->speed) {
186: case USB_SPEED_LOW:
187: case USB_SPEED_FULL:
188: dev->device = desc->full;
189: break;
190: case USB_SPEED_HIGH:
191: dev->device = desc->high;
192: break;
193: }
194: dev->config = dev->device->confs;
195: }
196:
197: void usb_desc_init(USBDevice *dev)
198: {
199: dev->speed = USB_SPEED_FULL;
200: usb_desc_setdefaults(dev);
201: }
202:
203: void usb_desc_attach(USBDevice *dev)
204: {
205: const USBDesc *desc = dev->info->usb_desc;
206:
207: assert(desc != NULL);
208: if (desc->high && (dev->port->speedmask & USB_SPEED_MASK_HIGH)) {
209: dev->speed = USB_SPEED_HIGH;
210: } else if (desc->full && (dev->port->speedmask & USB_SPEED_MASK_FULL)) {
211: dev->speed = USB_SPEED_FULL;
212: } else {
213: fprintf(stderr, "usb: port/device speed mismatch for \"%s\"\n",
214: dev->info->product_desc);
215: return;
216: }
217: usb_desc_setdefaults(dev);
218: }
219:
220: void usb_desc_set_string(USBDevice *dev, uint8_t index, const char *str)
221: {
222: USBDescString *s;
223:
224: QLIST_FOREACH(s, &dev->strings, next) {
225: if (s->index == index) {
226: break;
227: }
228: }
229: if (s == NULL) {
230: s = qemu_mallocz(sizeof(*s));
231: s->index = index;
232: QLIST_INSERT_HEAD(&dev->strings, s, next);
233: }
234: qemu_free(s->str);
235: s->str = qemu_strdup(str);
236: }
237:
238: const char *usb_desc_get_string(USBDevice *dev, uint8_t index)
239: {
240: USBDescString *s;
241:
242: QLIST_FOREACH(s, &dev->strings, next) {
243: if (s->index == index) {
244: return s->str;
245: }
246: }
247: return NULL;
248: }
249:
250: int usb_desc_string(USBDevice *dev, int index, uint8_t *dest, size_t len)
251: {
252: uint8_t bLength, pos, i;
253: const char *str;
254:
255: if (len < 4) {
256: return -1;
257: }
258:
259: if (index == 0) {
260: /* language ids */
261: dest[0] = 4;
262: dest[1] = USB_DT_STRING;
263: dest[2] = 0x09;
264: dest[3] = 0x04;
265: return 4;
266: }
267:
268: str = usb_desc_get_string(dev, index);
269: if (str == NULL) {
270: str = dev->info->usb_desc->str[index];
271: if (str == NULL) {
272: return 0;
273: }
274: }
275:
276: bLength = strlen(str) * 2 + 2;
277: dest[0] = bLength;
278: dest[1] = USB_DT_STRING;
279: i = 0; pos = 2;
280: while (pos+1 < bLength && pos+1 < len) {
281: dest[pos++] = str[i++];
282: dest[pos++] = 0;
283: }
284: return pos;
285: }
286:
287: int usb_desc_get_descriptor(USBDevice *dev, int value, uint8_t *dest, size_t len)
288: {
289: const USBDesc *desc = dev->info->usb_desc;
290: const USBDescDevice *other_dev;
291: uint8_t buf[256];
292: uint8_t type = value >> 8;
293: uint8_t index = value & 0xff;
294: int ret = -1;
295:
296: if (dev->speed == USB_SPEED_HIGH) {
297: other_dev = dev->info->usb_desc->full;
298: } else {
299: other_dev = dev->info->usb_desc->high;
300: }
301:
302: switch(type) {
303: case USB_DT_DEVICE:
304: ret = usb_desc_device(&desc->id, dev->device, buf, sizeof(buf));
305: trace_usb_desc_device(dev->addr, len, ret);
306: break;
307: case USB_DT_CONFIG:
308: if (index < dev->device->bNumConfigurations) {
309: ret = usb_desc_config(dev->device->confs + index, buf, sizeof(buf));
310: }
311: trace_usb_desc_config(dev->addr, index, len, ret);
312: break;
313: case USB_DT_STRING:
314: ret = usb_desc_string(dev, index, buf, sizeof(buf));
315: trace_usb_desc_string(dev->addr, index, len, ret);
316: break;
317:
318: case USB_DT_DEVICE_QUALIFIER:
319: if (other_dev != NULL) {
320: ret = usb_desc_device_qualifier(other_dev, buf, sizeof(buf));
321: }
322: trace_usb_desc_device_qualifier(dev->addr, len, ret);
323: break;
324: case USB_DT_OTHER_SPEED_CONFIG:
325: if (other_dev != NULL && index < other_dev->bNumConfigurations) {
326: ret = usb_desc_config(other_dev->confs + index, buf, sizeof(buf));
327: buf[0x01] = USB_DT_OTHER_SPEED_CONFIG;
328: }
329: trace_usb_desc_other_speed_config(dev->addr, index, len, ret);
330: break;
331:
332: default:
333: fprintf(stderr, "%s: %d unknown type %d (len %zd)\n", __FUNCTION__,
334: dev->addr, type, len);
335: break;
336: }
337:
338: if (ret > 0) {
339: if (ret > len) {
340: ret = len;
341: }
342: memcpy(dest, buf, ret);
343: }
344: return ret;
345: }
346:
347: int usb_desc_handle_control(USBDevice *dev, int request, int value,
348: int index, int length, uint8_t *data)
349: {
350: const USBDesc *desc = dev->info->usb_desc;
351: int i, ret = -1;
352:
353: assert(desc != NULL);
354: switch(request) {
355: case DeviceOutRequest | USB_REQ_SET_ADDRESS:
356: dev->addr = value;
357: trace_usb_set_addr(dev->addr);
358: ret = 0;
359: break;
360:
361: case DeviceRequest | USB_REQ_GET_DESCRIPTOR:
362: ret = usb_desc_get_descriptor(dev, value, data, length);
363: break;
364:
365: case DeviceRequest | USB_REQ_GET_CONFIGURATION:
366: data[0] = dev->config->bConfigurationValue;
367: ret = 1;
368: break;
369: case DeviceOutRequest | USB_REQ_SET_CONFIGURATION:
370: for (i = 0; i < dev->device->bNumConfigurations; i++) {
371: if (dev->device->confs[i].bConfigurationValue == value) {
372: dev->config = dev->device->confs + i;
373: ret = 0;
374: }
375: }
376: trace_usb_set_config(dev->addr, value, ret);
377: break;
378:
379: case DeviceRequest | USB_REQ_GET_STATUS:
380: data[0] = 0;
381: if (dev->config->bmAttributes & 0x40) {
382: data[0] |= 1 << USB_DEVICE_SELF_POWERED;
383: }
384: if (dev->remote_wakeup) {
385: data[0] |= 1 << USB_DEVICE_REMOTE_WAKEUP;
386: }
387: data[1] = 0x00;
388: ret = 2;
389: break;
390: case DeviceOutRequest | USB_REQ_CLEAR_FEATURE:
391: if (value == USB_DEVICE_REMOTE_WAKEUP) {
392: dev->remote_wakeup = 0;
393: ret = 0;
394: }
395: trace_usb_clear_device_feature(dev->addr, value, ret);
396: break;
397: case DeviceOutRequest | USB_REQ_SET_FEATURE:
398: if (value == USB_DEVICE_REMOTE_WAKEUP) {
399: dev->remote_wakeup = 1;
400: ret = 0;
401: }
402: trace_usb_set_device_feature(dev->addr, value, ret);
403: break;
404: }
405: return ret;
406: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.