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