![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dev-bluetooth.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 / usb|
Return to dev-bluetooth.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / hw / usb |
1.1 root 1: /*
2: * QEMU Bluetooth HCI USB Transport Layer v1.0
3: *
4: * Copyright (C) 2007 OpenMoko, Inc.
5: * Copyright (C) 2008 Andrzej Zaborowski <[email protected]>
6: *
7: * This program is free software; you can redistribute it and/or
8: * modify it under the terms of the GNU General Public License as
9: * published by the Free Software Foundation; either version 2 or
10: * (at your option) version 3 of the License.
11: *
12: * This program is distributed in the hope that it will be useful,
13: * but WITHOUT ANY WARRANTY; without even the implied warranty of
14: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15: * GNU General Public License for more details.
16: *
17: * You should have received a copy of the GNU General Public License along
18: * with this program; if not, see <http://www.gnu.org/licenses/>.
19: */
20:
21: #include "qemu-common.h"
22: #include "hw/usb.h"
23: #include "hw/usb/desc.h"
24: #include "net.h"
25: #include "hw/bt.h"
26:
27: struct USBBtState {
28: USBDevice dev;
29: struct HCIInfo *hci;
30:
31: int config;
32:
33: #define CFIFO_LEN_MASK 255
34: #define DFIFO_LEN_MASK 4095
35: struct usb_hci_in_fifo_s {
36: uint8_t data[(DFIFO_LEN_MASK + 1) * 2];
37: struct {
38: uint8_t *data;
39: int len;
40: } fifo[CFIFO_LEN_MASK + 1];
41: int dstart, dlen, dsize, start, len;
42: } evt, acl, sco;
43:
44: struct usb_hci_out_fifo_s {
45: uint8_t data[4096];
46: int len;
47: } outcmd, outacl, outsco;
48: };
49:
50: #define USB_EVT_EP 1
51: #define USB_ACL_EP 2
52: #define USB_SCO_EP 3
53:
54: enum {
55: STR_MANUFACTURER = 1,
56: STR_SERIALNUMBER,
57: };
58:
59: static const USBDescStrings desc_strings = {
60: [STR_MANUFACTURER] = "QEMU " QEMU_VERSION,
61: [STR_SERIALNUMBER] = "1",
62: };
63:
64: static const USBDescIface desc_iface_bluetooth[] = {
65: {
66: .bInterfaceNumber = 0,
67: .bNumEndpoints = 3,
68: .bInterfaceClass = 0xe0, /* Wireless */
69: .bInterfaceSubClass = 0x01, /* Radio Frequency */
70: .bInterfaceProtocol = 0x01, /* Bluetooth */
71: .eps = (USBDescEndpoint[]) {
72: {
73: .bEndpointAddress = USB_DIR_IN | USB_EVT_EP,
74: .bmAttributes = USB_ENDPOINT_XFER_INT,
75: .wMaxPacketSize = 0x10,
76: .bInterval = 0x02,
77: },
78: {
79: .bEndpointAddress = USB_DIR_OUT | USB_ACL_EP,
80: .bmAttributes = USB_ENDPOINT_XFER_BULK,
81: .wMaxPacketSize = 0x40,
82: .bInterval = 0x0a,
83: },
84: {
85: .bEndpointAddress = USB_DIR_IN | USB_ACL_EP,
86: .bmAttributes = USB_ENDPOINT_XFER_BULK,
87: .wMaxPacketSize = 0x40,
88: .bInterval = 0x0a,
89: },
90: },
91: },{
92: .bInterfaceNumber = 1,
93: .bAlternateSetting = 0,
94: .bNumEndpoints = 2,
95: .bInterfaceClass = 0xe0, /* Wireless */
96: .bInterfaceSubClass = 0x01, /* Radio Frequency */
97: .bInterfaceProtocol = 0x01, /* Bluetooth */
98: .eps = (USBDescEndpoint[]) {
99: {
100: .bEndpointAddress = USB_DIR_OUT | USB_SCO_EP,
101: .bmAttributes = USB_ENDPOINT_XFER_ISOC,
102: .wMaxPacketSize = 0,
103: .bInterval = 0x01,
104: },
105: {
106: .bEndpointAddress = USB_DIR_IN | USB_SCO_EP,
107: .bmAttributes = USB_ENDPOINT_XFER_ISOC,
108: .wMaxPacketSize = 0,
109: .bInterval = 0x01,
110: },
111: },
112: },{
113: .bInterfaceNumber = 1,
114: .bAlternateSetting = 1,
115: .bNumEndpoints = 2,
116: .bInterfaceClass = 0xe0, /* Wireless */
117: .bInterfaceSubClass = 0x01, /* Radio Frequency */
118: .bInterfaceProtocol = 0x01, /* Bluetooth */
119: .eps = (USBDescEndpoint[]) {
120: {
121: .bEndpointAddress = USB_DIR_OUT | USB_SCO_EP,
122: .bmAttributes = USB_ENDPOINT_XFER_ISOC,
123: .wMaxPacketSize = 0x09,
124: .bInterval = 0x01,
125: },
126: {
127: .bEndpointAddress = USB_DIR_IN | USB_SCO_EP,
128: .bmAttributes = USB_ENDPOINT_XFER_ISOC,
129: .wMaxPacketSize = 0x09,
130: .bInterval = 0x01,
131: },
132: },
133: },{
134: .bInterfaceNumber = 1,
135: .bAlternateSetting = 2,
136: .bNumEndpoints = 2,
137: .bInterfaceClass = 0xe0, /* Wireless */
138: .bInterfaceSubClass = 0x01, /* Radio Frequency */
139: .bInterfaceProtocol = 0x01, /* Bluetooth */
140: .eps = (USBDescEndpoint[]) {
141: {
142: .bEndpointAddress = USB_DIR_OUT | USB_SCO_EP,
143: .bmAttributes = USB_ENDPOINT_XFER_ISOC,
144: .wMaxPacketSize = 0x11,
145: .bInterval = 0x01,
146: },
147: {
148: .bEndpointAddress = USB_DIR_IN | USB_SCO_EP,
149: .bmAttributes = USB_ENDPOINT_XFER_ISOC,
150: .wMaxPacketSize = 0x11,
151: .bInterval = 0x01,
152: },
153: },
154: },{
155: .bInterfaceNumber = 1,
156: .bAlternateSetting = 3,
157: .bNumEndpoints = 2,
158: .bInterfaceClass = 0xe0, /* Wireless */
159: .bInterfaceSubClass = 0x01, /* Radio Frequency */
160: .bInterfaceProtocol = 0x01, /* Bluetooth */
161: .eps = (USBDescEndpoint[]) {
162: {
163: .bEndpointAddress = USB_DIR_OUT | USB_SCO_EP,
164: .bmAttributes = USB_ENDPOINT_XFER_ISOC,
165: .wMaxPacketSize = 0x19,
166: .bInterval = 0x01,
167: },
168: {
169: .bEndpointAddress = USB_DIR_IN | USB_SCO_EP,
170: .bmAttributes = USB_ENDPOINT_XFER_ISOC,
171: .wMaxPacketSize = 0x19,
172: .bInterval = 0x01,
173: },
174: },
175: },{
176: .bInterfaceNumber = 1,
177: .bAlternateSetting = 4,
178: .bNumEndpoints = 2,
179: .bInterfaceClass = 0xe0, /* Wireless */
180: .bInterfaceSubClass = 0x01, /* Radio Frequency */
181: .bInterfaceProtocol = 0x01, /* Bluetooth */
182: .eps = (USBDescEndpoint[]) {
183: {
184: .bEndpointAddress = USB_DIR_OUT | USB_SCO_EP,
185: .bmAttributes = USB_ENDPOINT_XFER_ISOC,
186: .wMaxPacketSize = 0x21,
187: .bInterval = 0x01,
188: },
189: {
190: .bEndpointAddress = USB_DIR_IN | USB_SCO_EP,
191: .bmAttributes = USB_ENDPOINT_XFER_ISOC,
192: .wMaxPacketSize = 0x21,
193: .bInterval = 0x01,
194: },
195: },
196: },{
197: .bInterfaceNumber = 1,
198: .bAlternateSetting = 5,
199: .bNumEndpoints = 2,
200: .bInterfaceClass = 0xe0, /* Wireless */
201: .bInterfaceSubClass = 0x01, /* Radio Frequency */
202: .bInterfaceProtocol = 0x01, /* Bluetooth */
203: .eps = (USBDescEndpoint[]) {
204: {
205: .bEndpointAddress = USB_DIR_OUT | USB_SCO_EP,
206: .bmAttributes = USB_ENDPOINT_XFER_ISOC,
207: .wMaxPacketSize = 0x31,
208: .bInterval = 0x01,
209: },
210: {
211: .bEndpointAddress = USB_DIR_IN | USB_SCO_EP,
212: .bmAttributes = USB_ENDPOINT_XFER_ISOC,
213: .wMaxPacketSize = 0x31,
214: .bInterval = 0x01,
215: },
216: },
217: }
218: };
219:
220: static const USBDescDevice desc_device_bluetooth = {
221: .bcdUSB = 0x0110,
222: .bDeviceClass = 0xe0, /* Wireless */
223: .bDeviceSubClass = 0x01, /* Radio Frequency */
224: .bDeviceProtocol = 0x01, /* Bluetooth */
225: .bMaxPacketSize0 = 64,
226: .bNumConfigurations = 1,
227: .confs = (USBDescConfig[]) {
228: {
229: .bNumInterfaces = 2,
230: .bConfigurationValue = 1,
231: .bmAttributes = 0xc0,
232: .bMaxPower = 0,
233: .nif = ARRAY_SIZE(desc_iface_bluetooth),
234: .ifs = desc_iface_bluetooth,
235: },
236: },
237: };
238:
239: static const USBDesc desc_bluetooth = {
240: .id = {
241: .idVendor = 0x0a12,
242: .idProduct = 0x0001,
243: .bcdDevice = 0x1958,
244: .iManufacturer = STR_MANUFACTURER,
245: .iProduct = 0,
246: .iSerialNumber = STR_SERIALNUMBER,
247: },
248: .full = &desc_device_bluetooth,
249: .str = desc_strings,
250: };
251:
252: static void usb_bt_fifo_reset(struct usb_hci_in_fifo_s *fifo)
253: {
254: fifo->dstart = 0;
255: fifo->dlen = 0;
256: fifo->dsize = DFIFO_LEN_MASK + 1;
257: fifo->start = 0;
258: fifo->len = 0;
259: }
260:
261: static void usb_bt_fifo_enqueue(struct usb_hci_in_fifo_s *fifo,
262: const uint8_t *data, int len)
263: {
264: int off = fifo->dstart + fifo->dlen;
265: uint8_t *buf;
266:
267: fifo->dlen += len;
268: if (off <= DFIFO_LEN_MASK) {
269: if (off + len > DFIFO_LEN_MASK + 1 &&
270: (fifo->dsize = off + len) > (DFIFO_LEN_MASK + 1) * 2) {
271: fprintf(stderr, "%s: can't alloc %i bytes\n", __FUNCTION__, len);
272: exit(-1);
273: }
274: buf = fifo->data + off;
275: } else {
276: if (fifo->dlen > fifo->dsize) {
277: fprintf(stderr, "%s: can't alloc %i bytes\n", __FUNCTION__, len);
278: exit(-1);
279: }
280: buf = fifo->data + off - fifo->dsize;
281: }
282:
283: off = (fifo->start + fifo->len ++) & CFIFO_LEN_MASK;
284: fifo->fifo[off].data = memcpy(buf, data, len);
285: fifo->fifo[off].len = len;
286: }
287:
288: static inline int usb_bt_fifo_dequeue(struct usb_hci_in_fifo_s *fifo,
289: USBPacket *p)
290: {
291: int len;
292:
293: if (likely(!fifo->len))
294: return USB_RET_STALL;
295:
296: len = MIN(p->iov.size, fifo->fifo[fifo->start].len);
297: usb_packet_copy(p, fifo->fifo[fifo->start].data, len);
298: if (len == p->iov.size) {
299: fifo->fifo[fifo->start].len -= len;
300: fifo->fifo[fifo->start].data += len;
301: } else {
302: fifo->start ++;
303: fifo->start &= CFIFO_LEN_MASK;
304: fifo->len --;
305: }
306:
307: fifo->dstart += len;
308: fifo->dlen -= len;
309: if (fifo->dstart >= fifo->dsize) {
310: fifo->dstart = 0;
311: fifo->dsize = DFIFO_LEN_MASK + 1;
312: }
313:
314: return len;
315: }
316:
317: static inline void usb_bt_fifo_out_enqueue(struct USBBtState *s,
318: struct usb_hci_out_fifo_s *fifo,
319: void (*send)(struct HCIInfo *, const uint8_t *, int),
320: int (*complete)(const uint8_t *, int),
321: USBPacket *p)
322: {
323: usb_packet_copy(p, fifo->data + fifo->len, p->iov.size);
324: fifo->len += p->iov.size;
325: if (complete(fifo->data, fifo->len)) {
326: send(s->hci, fifo->data, fifo->len);
327: fifo->len = 0;
328: }
329:
330: /* TODO: do we need to loop? */
331: }
332:
333: static int usb_bt_hci_cmd_complete(const uint8_t *data, int len)
334: {
335: len -= HCI_COMMAND_HDR_SIZE;
336: return len >= 0 &&
337: len >= ((struct hci_command_hdr *) data)->plen;
338: }
339:
340: static int usb_bt_hci_acl_complete(const uint8_t *data, int len)
341: {
342: len -= HCI_ACL_HDR_SIZE;
343: return len >= 0 &&
344: len >= le16_to_cpu(((struct hci_acl_hdr *) data)->dlen);
345: }
346:
347: static int usb_bt_hci_sco_complete(const uint8_t *data, int len)
348: {
349: len -= HCI_SCO_HDR_SIZE;
350: return len >= 0 &&
351: len >= ((struct hci_sco_hdr *) data)->dlen;
352: }
353:
354: static void usb_bt_handle_reset(USBDevice *dev)
355: {
356: struct USBBtState *s = (struct USBBtState *) dev->opaque;
357:
358: usb_bt_fifo_reset(&s->evt);
359: usb_bt_fifo_reset(&s->acl);
360: usb_bt_fifo_reset(&s->sco);
361: s->outcmd.len = 0;
362: s->outacl.len = 0;
363: s->outsco.len = 0;
364: }
365:
366: static int usb_bt_handle_control(USBDevice *dev, USBPacket *p,
367: int request, int value, int index, int length, uint8_t *data)
368: {
369: struct USBBtState *s = (struct USBBtState *) dev->opaque;
370: int ret;
371:
372: ret = usb_desc_handle_control(dev, p, request, value, index, length, data);
373: if (ret >= 0) {
374: switch (request) {
375: case DeviceRequest | USB_REQ_GET_CONFIGURATION:
376: s->config = 0;
377: break;
378: case DeviceOutRequest | USB_REQ_SET_CONFIGURATION:
379: s->config = 1;
380: usb_bt_fifo_reset(&s->evt);
381: usb_bt_fifo_reset(&s->acl);
382: usb_bt_fifo_reset(&s->sco);
383: break;
384: }
385: return ret;
386: }
387:
388: ret = 0;
389: switch (request) {
390: case InterfaceRequest | USB_REQ_GET_STATUS:
391: case EndpointRequest | USB_REQ_GET_STATUS:
392: data[0] = 0x00;
393: data[1] = 0x00;
394: ret = 2;
395: break;
396: case InterfaceOutRequest | USB_REQ_CLEAR_FEATURE:
397: case EndpointOutRequest | USB_REQ_CLEAR_FEATURE:
398: goto fail;
399: case InterfaceOutRequest | USB_REQ_SET_FEATURE:
400: case EndpointOutRequest | USB_REQ_SET_FEATURE:
401: goto fail;
402: break;
403: case ((USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_DEVICE) << 8):
404: if (s->config)
405: usb_bt_fifo_out_enqueue(s, &s->outcmd, s->hci->cmd_send,
406: usb_bt_hci_cmd_complete, p);
407: break;
408: default:
409: fail:
410: ret = USB_RET_STALL;
411: break;
412: }
413: return ret;
414: }
415:
416: static int usb_bt_handle_data(USBDevice *dev, USBPacket *p)
417: {
418: struct USBBtState *s = (struct USBBtState *) dev->opaque;
419: int ret = 0;
420:
421: if (!s->config)
422: goto fail;
423:
424: switch (p->pid) {
425: case USB_TOKEN_IN:
426: switch (p->ep->nr) {
427: case USB_EVT_EP:
428: ret = usb_bt_fifo_dequeue(&s->evt, p);
429: break;
430:
431: case USB_ACL_EP:
432: ret = usb_bt_fifo_dequeue(&s->acl, p);
433: break;
434:
435: case USB_SCO_EP:
436: ret = usb_bt_fifo_dequeue(&s->sco, p);
437: break;
438:
439: default:
440: goto fail;
441: }
442: break;
443:
444: case USB_TOKEN_OUT:
445: switch (p->ep->nr) {
446: case USB_ACL_EP:
447: usb_bt_fifo_out_enqueue(s, &s->outacl, s->hci->acl_send,
448: usb_bt_hci_acl_complete, p);
449: break;
450:
451: case USB_SCO_EP:
452: usb_bt_fifo_out_enqueue(s, &s->outsco, s->hci->sco_send,
453: usb_bt_hci_sco_complete, p);
454: break;
455:
456: default:
457: goto fail;
458: }
459: break;
460:
461: default:
462: fail:
463: ret = USB_RET_STALL;
464: break;
465: }
466:
467: return ret;
468: }
469:
470: static void usb_bt_out_hci_packet_event(void *opaque,
471: const uint8_t *data, int len)
472: {
473: struct USBBtState *s = (struct USBBtState *) opaque;
474:
475: usb_bt_fifo_enqueue(&s->evt, data, len);
476: }
477:
478: static void usb_bt_out_hci_packet_acl(void *opaque,
479: const uint8_t *data, int len)
480: {
481: struct USBBtState *s = (struct USBBtState *) opaque;
482:
483: usb_bt_fifo_enqueue(&s->acl, data, len);
484: }
485:
486: static void usb_bt_handle_destroy(USBDevice *dev)
487: {
488: struct USBBtState *s = (struct USBBtState *) dev->opaque;
489:
490: s->hci->opaque = NULL;
491: s->hci->evt_recv = NULL;
492: s->hci->acl_recv = NULL;
493: }
494:
495: static int usb_bt_initfn(USBDevice *dev)
496: {
497: usb_desc_create_serial(dev);
498: usb_desc_init(dev);
499: return 0;
500: }
501:
502: USBDevice *usb_bt_init(USBBus *bus, HCIInfo *hci)
503: {
504: USBDevice *dev;
505: struct USBBtState *s;
506:
507: if (!hci)
508: return NULL;
509: dev = usb_create_simple(bus, "usb-bt-dongle");
510: if (!dev) {
511: return NULL;
512: }
513: s = DO_UPCAST(struct USBBtState, dev, dev);
514: s->dev.opaque = s;
515:
516: s->hci = hci;
517: s->hci->opaque = s;
518: s->hci->evt_recv = usb_bt_out_hci_packet_event;
519: s->hci->acl_recv = usb_bt_out_hci_packet_acl;
520:
521: usb_bt_handle_reset(&s->dev);
522:
523: return dev;
524: }
525:
526: static const VMStateDescription vmstate_usb_bt = {
527: .name = "usb-bt",
528: .unmigratable = 1,
529: };
530:
531: static void usb_bt_class_initfn(ObjectClass *klass, void *data)
532: {
533: DeviceClass *dc = DEVICE_CLASS(klass);
534: USBDeviceClass *uc = USB_DEVICE_CLASS(klass);
535:
536: uc->init = usb_bt_initfn;
537: uc->product_desc = "QEMU BT dongle";
538: uc->usb_desc = &desc_bluetooth;
539: uc->handle_reset = usb_bt_handle_reset;
540: uc->handle_control = usb_bt_handle_control;
541: uc->handle_data = usb_bt_handle_data;
542: uc->handle_destroy = usb_bt_handle_destroy;
543: dc->vmsd = &vmstate_usb_bt;
544: }
545:
546: static TypeInfo bt_info = {
547: .name = "usb-bt-dongle",
548: .parent = TYPE_USB_DEVICE,
549: .instance_size = sizeof(struct USBBtState),
550: .class_init = usb_bt_class_initfn,
551: };
552:
553: static void usb_bt_register_types(void)
554: {
555: type_register_static(&bt_info);
556: }
557:
558: type_init(usb_bt_register_types)
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.