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
27static const struct usb_device_id bpa10x_table[] = {
28 /* Tektronix BPA 100/105 (Digianswer) */
29 { USB_DEVICE(0x08fd, 0x0002) },
30
31 { } /* Terminating entry */
32};
33
34MODULE_DEVICE_TABLE(usb, bpa10x_table);
35
36struct 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
47static 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
63done:
64 kfree(objp: 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
78static 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
85static 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(hu: &data->hu, skb: data->rx_skb[idx],
101 buffer: urb->transfer_buffer,
102 count: urb->actual_length,
103 pkts: bpa10x_recv_pkts,
104 ARRAY_SIZE(bpa10x_recv_pkts));
105 if (IS_ERR(ptr: 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, anchor: &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
121static 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(iso_packets: 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, dev: data->udev, pipe, transfer_buffer: buf, buffer_length: size,
144 complete_fn: bpa10x_rx_complete, context: hdev, interval: 1);
145
146 urb->transfer_flags |= URB_FREE_BUFFER;
147
148 usb_anchor_urb(urb, anchor: &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
161static 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(iso_packets: 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, dev: data->udev, pipe,
184 transfer_buffer: buf, buffer_length: size, complete_fn: bpa10x_rx_complete, context: hdev);
185
186 urb->transfer_flags |= URB_FREE_BUFFER;
187
188 usb_anchor_urb(urb, anchor: &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
201static 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
218error:
219 usb_kill_anchored_urbs(anchor: &data->rx_anchor);
220
221 return err;
222}
223
224static 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(anchor: &data->rx_anchor);
231
232 return 0;
233}
234
235static 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(anchor: &data->tx_anchor);
242
243 return 0;
244}
245
246static 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, opcode: 0xfc0e, plen: sizeof(req), param: req, HCI_INIT_TIMEOUT);
255 if (IS_ERR(ptr: skb))
256 return PTR_ERR(ptr: skb);
257
258 bt_dev_info(hdev, "%s", (char *)(skb->data + 1));
259
260 hci_set_fw_info(hdev, fmt: "%s", skb->data + 1);
261
262 kfree_skb(skb);
263 return 0;
264}
265
266static 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(iso_packets: 0, GFP_KERNEL);
279 if (!urb)
280 return -ENOMEM;
281
282 /* Prepend skb with frame type */
283 *(u8 *)skb_push(skb, len: 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, dev: data->udev, pipe, setup_packet: (void *) dr,
302 transfer_buffer: skb->data, buffer_length: skb->len, complete_fn: bpa10x_tx_complete, context: 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, dev: data->udev, pipe,
311 transfer_buffer: skb->data, buffer_length: skb->len, complete_fn: bpa10x_tx_complete, context: 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, dev: data->udev, pipe,
320 transfer_buffer: skb->data, buffer_length: skb->len, complete_fn: bpa10x_tx_complete, context: 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, anchor: &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(objp: urb->setup_packet);
336 usb_unanchor_urb(urb);
337 }
338
339 usb_free_urb(urb);
340
341 return err;
342}
343
344static 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, opcode: 0xfc0e, plen: sizeof(req), param: req, HCI_INIT_TIMEOUT);
356 if (IS_ERR(ptr: skb))
357 return PTR_ERR(ptr: skb);
358
359 kfree_skb(skb);
360 return 0;
361}
362
363static 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(dev: &intf->dev, size: sizeof(*data), GFP_KERNEL);
376 if (!data)
377 return -ENOMEM;
378
379 data->udev = interface_to_usbdev(intf);
380
381 init_usb_anchor(anchor: &data->tx_anchor);
382 init_usb_anchor(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
416static 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(hdev: data->hdev);
428
429 hci_free_dev(hdev: data->hdev);
430 kfree_skb(skb: data->rx_skb[0]);
431 kfree_skb(skb: data->rx_skb[1]);
432}
433
434static 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
442module_usb_driver(bpa10x_driver);
443
444MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
445MODULE_DESCRIPTION("Digianswer Bluetooth USB driver ver " VERSION);
446MODULE_VERSION(VERSION);
447MODULE_LICENSE("GPL");
448

source code of linux/drivers/bluetooth/bpa10x.c