1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 *
4 * Digianswer Bluetooth USB driver
5 *
6 * Copyright (C) 2004-2007 Marcel Holtmann <marcel@holtmann.org>
7 */
8
9 #include <linux/kernel.h>
10 #include <linux/module.h>
11 #include <linux/init.h>
12 #include <linux/slab.h>
13 #include <linux/types.h>
14 #include <linux/sched.h>
15 #include <linux/errno.h>
16 #include <linux/skbuff.h>
17
18 #include <linux/usb.h>
19
20 #include <net/bluetooth/bluetooth.h>
21 #include <net/bluetooth/hci_core.h>
22
23 #include "hci_uart.h"
24
25 #define VERSION "0.11"
26
27 static const struct usb_device_id bpa10x_table[] = {
28 /* Tektronix BPA 100/105 (Digianswer) */
29 { USB_DEVICE(0x08fd, 0x0002) },
30
31 { } /* Terminating entry */
32 };
33
34 MODULE_DEVICE_TABLE(usb, bpa10x_table);
35
36 struct bpa10x_data {
37 struct hci_dev *hdev;
38 struct usb_device *udev;
39
40 struct usb_anchor tx_anchor;
41 struct usb_anchor rx_anchor;
42
43 struct sk_buff *rx_skb[2];
44 struct hci_uart hu;
45 };
46
bpa10x_tx_complete(struct urb * urb)47 static void bpa10x_tx_complete(struct urb *urb)
48 {
49 struct sk_buff *skb = urb->context;
50 struct hci_dev *hdev = (struct hci_dev *) skb->dev;
51
52 BT_DBG("%s urb %p status %d count %d", hdev->name,
53 urb, urb->status, urb->actual_length);
54
55 if (!test_bit(HCI_RUNNING, &hdev->flags))
56 goto done;
57
58 if (!urb->status)
59 hdev->stat.byte_tx += urb->transfer_buffer_length;
60 else
61 hdev->stat.err_tx++;
62
63 done:
64 kfree(urb->setup_packet);
65
66 kfree_skb(skb);
67 }
68
69 #define HCI_VENDOR_HDR_SIZE 5
70
71 #define HCI_RECV_VENDOR \
72 .type = HCI_VENDOR_PKT, \
73 .hlen = HCI_VENDOR_HDR_SIZE, \
74 .loff = 3, \
75 .lsize = 2, \
76 .maxlen = HCI_MAX_FRAME_SIZE
77
78 static const struct h4_recv_pkt bpa10x_recv_pkts[] = {
79 { H4_RECV_ACL, .recv = hci_recv_frame },
80 { H4_RECV_SCO, .recv = hci_recv_frame },
81 { H4_RECV_EVENT, .recv = hci_recv_frame },
82 { HCI_RECV_VENDOR, .recv = hci_recv_diag },
83 };
84
bpa10x_rx_complete(struct urb * urb)85 static void bpa10x_rx_complete(struct urb *urb)
86 {
87 struct hci_dev *hdev = urb->context;
88 struct bpa10x_data *data = hci_get_drvdata(hdev);
89 int err;
90
91 BT_DBG("%s urb %p status %d count %d", hdev->name,
92 urb, urb->status, urb->actual_length);
93
94 if (!test_bit(HCI_RUNNING, &hdev->flags))
95 return;
96
97 if (urb->status == 0) {
98 bool idx = usb_pipebulk(urb->pipe);
99
100 data->rx_skb[idx] = h4_recv_buf(&data->hu, data->rx_skb[idx],
101 urb->transfer_buffer,
102 urb->actual_length,
103 bpa10x_recv_pkts,
104 ARRAY_SIZE(bpa10x_recv_pkts));
105 if (IS_ERR(data->rx_skb[idx])) {
106 bt_dev_err(hdev, "corrupted event packet");
107 hdev->stat.err_rx++;
108 data->rx_skb[idx] = NULL;
109 }
110 }
111
112 usb_anchor_urb(urb, &data->rx_anchor);
113
114 err = usb_submit_urb(urb, GFP_ATOMIC);
115 if (err < 0) {
116 bt_dev_err(hdev, "urb %p failed to resubmit (%d)", urb, -err);
117 usb_unanchor_urb(urb);
118 }
119 }
120
bpa10x_submit_intr_urb(struct hci_dev * hdev)121 static inline int bpa10x_submit_intr_urb(struct hci_dev *hdev)
122 {
123 struct bpa10x_data *data = hci_get_drvdata(hdev);
124 struct urb *urb;
125 unsigned char *buf;
126 unsigned int pipe;
127 int err, size = 16;
128
129 BT_DBG("%s", hdev->name);
130
131 urb = usb_alloc_urb(0, GFP_KERNEL);
132 if (!urb)
133 return -ENOMEM;
134
135 buf = kmalloc(size, GFP_KERNEL);
136 if (!buf) {
137 usb_free_urb(urb);
138 return -ENOMEM;
139 }
140
141 pipe = usb_rcvintpipe(data->udev, 0x81);
142
143 usb_fill_int_urb(urb, data->udev, pipe, buf, size,
144 bpa10x_rx_complete, hdev, 1);
145
146 urb->transfer_flags |= URB_FREE_BUFFER;
147
148 usb_anchor_urb(urb, &data->rx_anchor);
149
150 err = usb_submit_urb(urb, GFP_KERNEL);
151 if (err < 0) {
152 bt_dev_err(hdev, "urb %p submission failed (%d)", urb, -err);
153 usb_unanchor_urb(urb);
154 }
155
156 usb_free_urb(urb);
157
158 return err;
159 }
160
bpa10x_submit_bulk_urb(struct hci_dev * hdev)161 static inline int bpa10x_submit_bulk_urb(struct hci_dev *hdev)
162 {
163 struct bpa10x_data *data = hci_get_drvdata(hdev);
164 struct urb *urb;
165 unsigned char *buf;
166 unsigned int pipe;
167 int err, size = 64;
168
169 BT_DBG("%s", hdev->name);
170
171 urb = usb_alloc_urb(0, GFP_KERNEL);
172 if (!urb)
173 return -ENOMEM;
174
175 buf = kmalloc(size, GFP_KERNEL);
176 if (!buf) {
177 usb_free_urb(urb);
178 return -ENOMEM;
179 }
180
181 pipe = usb_rcvbulkpipe(data->udev, 0x82);
182
183 usb_fill_bulk_urb(urb, data->udev, pipe,
184 buf, size, bpa10x_rx_complete, hdev);
185
186 urb->transfer_flags |= URB_FREE_BUFFER;
187
188 usb_anchor_urb(urb, &data->rx_anchor);
189
190 err = usb_submit_urb(urb, GFP_KERNEL);
191 if (err < 0) {
192 bt_dev_err(hdev, "urb %p submission failed (%d)", urb, -err);
193 usb_unanchor_urb(urb);
194 }
195
196 usb_free_urb(urb);
197
198 return err;
199 }
200
bpa10x_open(struct hci_dev * hdev)201 static int bpa10x_open(struct hci_dev *hdev)
202 {
203 struct bpa10x_data *data = hci_get_drvdata(hdev);
204 int err;
205
206 BT_DBG("%s", hdev->name);
207
208 err = bpa10x_submit_intr_urb(hdev);
209 if (err < 0)
210 goto error;
211
212 err = bpa10x_submit_bulk_urb(hdev);
213 if (err < 0)
214 goto error;
215
216 return 0;
217
218 error:
219 usb_kill_anchored_urbs(&data->rx_anchor);
220
221 return err;
222 }
223
bpa10x_close(struct hci_dev * hdev)224 static int bpa10x_close(struct hci_dev *hdev)
225 {
226 struct bpa10x_data *data = hci_get_drvdata(hdev);
227
228 BT_DBG("%s", hdev->name);
229
230 usb_kill_anchored_urbs(&data->rx_anchor);
231
232 return 0;
233 }
234
bpa10x_flush(struct hci_dev * hdev)235 static int bpa10x_flush(struct hci_dev *hdev)
236 {
237 struct bpa10x_data *data = hci_get_drvdata(hdev);
238
239 BT_DBG("%s", hdev->name);
240
241 usb_kill_anchored_urbs(&data->tx_anchor);
242
243 return 0;
244 }
245
bpa10x_setup(struct hci_dev * hdev)246 static int bpa10x_setup(struct hci_dev *hdev)
247 {
248 static const u8 req[] = { 0x07 };
249 struct sk_buff *skb;
250
251 BT_DBG("%s", hdev->name);
252
253 /* Read revision string */
254 skb = __hci_cmd_sync(hdev, 0xfc0e, sizeof(req), req, HCI_INIT_TIMEOUT);
255 if (IS_ERR(skb))
256 return PTR_ERR(skb);
257
258 bt_dev_info(hdev, "%s", (char *)(skb->data + 1));
259
260 hci_set_fw_info(hdev, "%s", skb->data + 1);
261
262 kfree_skb(skb);
263 return 0;
264 }
265
bpa10x_send_frame(struct hci_dev * hdev,struct sk_buff * skb)266 static int bpa10x_send_frame(struct hci_dev *hdev, struct sk_buff *skb)
267 {
268 struct bpa10x_data *data = hci_get_drvdata(hdev);
269 struct usb_ctrlrequest *dr;
270 struct urb *urb;
271 unsigned int pipe;
272 int err;
273
274 BT_DBG("%s", hdev->name);
275
276 skb->dev = (void *) hdev;
277
278 urb = usb_alloc_urb(0, GFP_KERNEL);
279 if (!urb)
280 return -ENOMEM;
281
282 /* Prepend skb with frame type */
283 *(u8 *)skb_push(skb, 1) = hci_skb_pkt_type(skb);
284
285 switch (hci_skb_pkt_type(skb)) {
286 case HCI_COMMAND_PKT:
287 dr = kmalloc(sizeof(*dr), GFP_KERNEL);
288 if (!dr) {
289 usb_free_urb(urb);
290 return -ENOMEM;
291 }
292
293 dr->bRequestType = USB_TYPE_VENDOR;
294 dr->bRequest = 0;
295 dr->wIndex = 0;
296 dr->wValue = 0;
297 dr->wLength = __cpu_to_le16(skb->len);
298
299 pipe = usb_sndctrlpipe(data->udev, 0x00);
300
301 usb_fill_control_urb(urb, data->udev, pipe, (void *) dr,
302 skb->data, skb->len, bpa10x_tx_complete, skb);
303
304 hdev->stat.cmd_tx++;
305 break;
306
307 case HCI_ACLDATA_PKT:
308 pipe = usb_sndbulkpipe(data->udev, 0x02);
309
310 usb_fill_bulk_urb(urb, data->udev, pipe,
311 skb->data, skb->len, bpa10x_tx_complete, skb);
312
313 hdev->stat.acl_tx++;
314 break;
315
316 case HCI_SCODATA_PKT:
317 pipe = usb_sndbulkpipe(data->udev, 0x02);
318
319 usb_fill_bulk_urb(urb, data->udev, pipe,
320 skb->data, skb->len, bpa10x_tx_complete, skb);
321
322 hdev->stat.sco_tx++;
323 break;
324
325 default:
326 usb_free_urb(urb);
327 return -EILSEQ;
328 }
329
330 usb_anchor_urb(urb, &data->tx_anchor);
331
332 err = usb_submit_urb(urb, GFP_KERNEL);
333 if (err < 0) {
334 bt_dev_err(hdev, "urb %p submission failed", urb);
335 kfree(urb->setup_packet);
336 usb_unanchor_urb(urb);
337 }
338
339 usb_free_urb(urb);
340
341 return err;
342 }
343
bpa10x_set_diag(struct hci_dev * hdev,bool enable)344 static int bpa10x_set_diag(struct hci_dev *hdev, bool enable)
345 {
346 const u8 req[] = { 0x00, enable };
347 struct sk_buff *skb;
348
349 BT_DBG("%s", hdev->name);
350
351 if (!test_bit(HCI_RUNNING, &hdev->flags))
352 return -ENETDOWN;
353
354 /* Enable sniffer operation */
355 skb = __hci_cmd_sync(hdev, 0xfc0e, sizeof(req), req, HCI_INIT_TIMEOUT);
356 if (IS_ERR(skb))
357 return PTR_ERR(skb);
358
359 kfree_skb(skb);
360 return 0;
361 }
362
bpa10x_probe(struct usb_interface * intf,const struct usb_device_id * id)363 static int bpa10x_probe(struct usb_interface *intf,
364 const struct usb_device_id *id)
365 {
366 struct bpa10x_data *data;
367 struct hci_dev *hdev;
368 int err;
369
370 BT_DBG("intf %p id %p", intf, id);
371
372 if (intf->cur_altsetting->desc.bInterfaceNumber != 0)
373 return -ENODEV;
374
375 data = devm_kzalloc(&intf->dev, sizeof(*data), GFP_KERNEL);
376 if (!data)
377 return -ENOMEM;
378
379 data->udev = interface_to_usbdev(intf);
380
381 init_usb_anchor(&data->tx_anchor);
382 init_usb_anchor(&data->rx_anchor);
383
384 hdev = hci_alloc_dev();
385 if (!hdev)
386 return -ENOMEM;
387
388 hdev->bus = HCI_USB;
389 hci_set_drvdata(hdev, data);
390
391 data->hdev = hdev;
392 data->hu.hdev = hdev;
393
394 SET_HCIDEV_DEV(hdev, &intf->dev);
395
396 hdev->open = bpa10x_open;
397 hdev->close = bpa10x_close;
398 hdev->flush = bpa10x_flush;
399 hdev->setup = bpa10x_setup;
400 hdev->send = bpa10x_send_frame;
401 hdev->set_diag = bpa10x_set_diag;
402
403 hci_set_quirk(hdev, HCI_QUIRK_RESET_ON_CLOSE);
404
405 err = hci_register_dev(hdev);
406 if (err < 0) {
407 hci_free_dev(hdev);
408 return err;
409 }
410
411 usb_set_intfdata(intf, data);
412
413 return 0;
414 }
415
bpa10x_disconnect(struct usb_interface * intf)416 static void bpa10x_disconnect(struct usb_interface *intf)
417 {
418 struct bpa10x_data *data = usb_get_intfdata(intf);
419
420 BT_DBG("intf %p", intf);
421
422 if (!data)
423 return;
424
425 usb_set_intfdata(intf, NULL);
426
427 hci_unregister_dev(data->hdev);
428
429 hci_free_dev(data->hdev);
430 kfree_skb(data->rx_skb[0]);
431 kfree_skb(data->rx_skb[1]);
432 }
433
434 static struct usb_driver bpa10x_driver = {
435 .name = "bpa10x",
436 .probe = bpa10x_probe,
437 .disconnect = bpa10x_disconnect,
438 .id_table = bpa10x_table,
439 .disable_hub_initiated_lpm = 1,
440 };
441
442 module_usb_driver(bpa10x_driver);
443
444 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
445 MODULE_DESCRIPTION("Digianswer Bluetooth USB driver ver " VERSION);
446 MODULE_VERSION(VERSION);
447 MODULE_LICENSE("GPL");
448