1/*
2 *
3 *  Digianswer Bluetooth USB driver
4 *
5 *  Copyright (C) 2004-2007  Marcel Holtmann <marcel@holtmann.org>
6 *
7 *
8 *  This program is free software; you can redistribute it and/or modify
9 *  it under the terms of the GNU General Public License as published by
10 *  the Free Software Foundation; either version 2 of the License, or
11 *  (at your option) any later version.
12 *
13 *  This program is distributed in the hope that it will be useful,
14 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
15 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 *  GNU General Public License for more details.
17 *
18 *  You should have received a copy of the GNU General Public License
19 *  along with this program; if not, write to the Free Software
20 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
21 *
22 */
23
24#include <linux/kernel.h>
25#include <linux/module.h>
26#include <linux/init.h>
27#include <linux/slab.h>
28#include <linux/types.h>
29#include <linux/sched.h>
30#include <linux/errno.h>
31#include <linux/skbuff.h>
32
33#include <linux/usb.h>
34
35#include <net/bluetooth/bluetooth.h>
36#include <net/bluetooth/hci_core.h>
37
38#define VERSION "0.10"
39
40static struct usb_device_id bpa10x_table[] = {
41	/* Tektronix BPA 100/105 (Digianswer) */
42	{ USB_DEVICE(0x08fd, 0x0002) },
43
44	{ }	/* Terminating entry */
45};
46
47MODULE_DEVICE_TABLE(usb, bpa10x_table);
48
49struct bpa10x_data {
50	struct hci_dev    *hdev;
51	struct usb_device *udev;
52
53	struct usb_anchor tx_anchor;
54	struct usb_anchor rx_anchor;
55
56	struct sk_buff *rx_skb[2];
57};
58
59#define HCI_VENDOR_HDR_SIZE 5
60
61struct hci_vendor_hdr {
62	__u8    type;
63	__le16  snum;
64	__le16  dlen;
65} __packed;
66
67static int bpa10x_recv(struct hci_dev *hdev, int queue, void *buf, int count)
68{
69	struct bpa10x_data *data = hci_get_drvdata(hdev);
70
71	BT_DBG("%s queue %d buffer %p count %d", hdev->name,
72							queue, buf, count);
73
74	if (queue < 0 || queue > 1)
75		return -EILSEQ;
76
77	hdev->stat.byte_rx += count;
78
79	while (count) {
80		struct sk_buff *skb = data->rx_skb[queue];
81		struct { __u8 type; int expect; } *scb;
82		int type, len = 0;
83
84		if (!skb) {
85			/* Start of the frame */
86
87			type = *((__u8 *) buf);
88			count--; buf++;
89
90			switch (type) {
91			case HCI_EVENT_PKT:
92				if (count >= HCI_EVENT_HDR_SIZE) {
93					struct hci_event_hdr *h = buf;
94					len = HCI_EVENT_HDR_SIZE + h->plen;
95				} else
96					return -EILSEQ;
97				break;
98
99			case HCI_ACLDATA_PKT:
100				if (count >= HCI_ACL_HDR_SIZE) {
101					struct hci_acl_hdr *h = buf;
102					len = HCI_ACL_HDR_SIZE +
103							__le16_to_cpu(h->dlen);
104				} else
105					return -EILSEQ;
106				break;
107
108			case HCI_SCODATA_PKT:
109				if (count >= HCI_SCO_HDR_SIZE) {
110					struct hci_sco_hdr *h = buf;
111					len = HCI_SCO_HDR_SIZE + h->dlen;
112				} else
113					return -EILSEQ;
114				break;
115
116			case HCI_VENDOR_PKT:
117				if (count >= HCI_VENDOR_HDR_SIZE) {
118					struct hci_vendor_hdr *h = buf;
119					len = HCI_VENDOR_HDR_SIZE +
120							__le16_to_cpu(h->dlen);
121				} else
122					return -EILSEQ;
123				break;
124			}
125
126			skb = bt_skb_alloc(len, GFP_ATOMIC);
127			if (!skb) {
128				BT_ERR("%s no memory for packet", hdev->name);
129				return -ENOMEM;
130			}
131
132			skb->dev = (void *) hdev;
133
134			data->rx_skb[queue] = skb;
135
136			scb = (void *) skb->cb;
137			scb->type = type;
138			scb->expect = len;
139		} else {
140			/* Continuation */
141
142			scb = (void *) skb->cb;
143			len = scb->expect;
144		}
145
146		len = min(len, count);
147
148		memcpy(skb_put(skb, len), buf, len);
149
150		scb->expect -= len;
151
152		if (scb->expect == 0) {
153			/* Complete frame */
154
155			data->rx_skb[queue] = NULL;
156
157			bt_cb(skb)->pkt_type = scb->type;
158			hci_recv_frame(skb);
159		}
160
161		count -= len; buf += len;
162	}
163
164	return 0;
165}
166
167static void bpa10x_tx_complete(struct urb *urb)
168{
169	struct sk_buff *skb = urb->context;
170	struct hci_dev *hdev = (struct hci_dev *) skb->dev;
171
172	BT_DBG("%s urb %p status %d count %d", hdev->name,
173					urb, urb->status, urb->actual_length);
174
175	if (!test_bit(HCI_RUNNING, &hdev->flags))
176		goto done;
177
178	if (!urb->status)
179		hdev->stat.byte_tx += urb->transfer_buffer_length;
180	else
181		hdev->stat.err_tx++;
182
183done:
184	kfree(urb->setup_packet);
185
186	kfree_skb(skb);
187}
188
189static void bpa10x_rx_complete(struct urb *urb)
190{
191	struct hci_dev *hdev = urb->context;
192	struct bpa10x_data *data = hci_get_drvdata(hdev);
193	int err;
194
195	BT_DBG("%s urb %p status %d count %d", hdev->name,
196					urb, urb->status, urb->actual_length);
197
198	if (!test_bit(HCI_RUNNING, &hdev->flags))
199		return;
200
201	if (urb->status == 0) {
202		if (bpa10x_recv(hdev, usb_pipebulk(urb->pipe),
203						urb->transfer_buffer,
204						urb->actual_length) < 0) {
205			BT_ERR("%s corrupted event packet", hdev->name);
206			hdev->stat.err_rx++;
207		}
208	}
209
210	usb_anchor_urb(urb, &data->rx_anchor);
211
212	err = usb_submit_urb(urb, GFP_ATOMIC);
213	if (err < 0) {
214		BT_ERR("%s urb %p failed to resubmit (%d)",
215						hdev->name, urb, -err);
216		usb_unanchor_urb(urb);
217	}
218}
219
220static inline int bpa10x_submit_intr_urb(struct hci_dev *hdev)
221{
222	struct bpa10x_data *data = hci_get_drvdata(hdev);
223	struct urb *urb;
224	unsigned char *buf;
225	unsigned int pipe;
226	int err, size = 16;
227
228	BT_DBG("%s", hdev->name);
229
230	urb = usb_alloc_urb(0, GFP_KERNEL);
231	if (!urb)
232		return -ENOMEM;
233
234	buf = kmalloc(size, GFP_KERNEL);
235	if (!buf) {
236		usb_free_urb(urb);
237		return -ENOMEM;
238	}
239
240	pipe = usb_rcvintpipe(data->udev, 0x81);
241
242	usb_fill_int_urb(urb, data->udev, pipe, buf, size,
243						bpa10x_rx_complete, hdev, 1);
244
245	urb->transfer_flags |= URB_FREE_BUFFER;
246
247	usb_anchor_urb(urb, &data->rx_anchor);
248
249	err = usb_submit_urb(urb, GFP_KERNEL);
250	if (err < 0) {
251		BT_ERR("%s urb %p submission failed (%d)",
252						hdev->name, urb, -err);
253		usb_unanchor_urb(urb);
254	}
255
256	usb_free_urb(urb);
257
258	return err;
259}
260
261static inline int bpa10x_submit_bulk_urb(struct hci_dev *hdev)
262{
263	struct bpa10x_data *data = hci_get_drvdata(hdev);
264	struct urb *urb;
265	unsigned char *buf;
266	unsigned int pipe;
267	int err, size = 64;
268
269	BT_DBG("%s", hdev->name);
270
271	urb = usb_alloc_urb(0, GFP_KERNEL);
272	if (!urb)
273		return -ENOMEM;
274
275	buf = kmalloc(size, GFP_KERNEL);
276	if (!buf) {
277		usb_free_urb(urb);
278		return -ENOMEM;
279	}
280
281	pipe = usb_rcvbulkpipe(data->udev, 0x82);
282
283	usb_fill_bulk_urb(urb, data->udev, pipe,
284					buf, size, bpa10x_rx_complete, hdev);
285
286	urb->transfer_flags |= URB_FREE_BUFFER;
287
288	usb_anchor_urb(urb, &data->rx_anchor);
289
290	err = usb_submit_urb(urb, GFP_KERNEL);
291	if (err < 0) {
292		BT_ERR("%s urb %p submission failed (%d)",
293						hdev->name, urb, -err);
294		usb_unanchor_urb(urb);
295	}
296
297	usb_free_urb(urb);
298
299	return err;
300}
301
302static int bpa10x_open(struct hci_dev *hdev)
303{
304	struct bpa10x_data *data = hci_get_drvdata(hdev);
305	int err;
306
307	BT_DBG("%s", hdev->name);
308
309	if (test_and_set_bit(HCI_RUNNING, &hdev->flags))
310		return 0;
311
312	err = bpa10x_submit_intr_urb(hdev);
313	if (err < 0)
314		goto error;
315
316	err = bpa10x_submit_bulk_urb(hdev);
317	if (err < 0)
318		goto error;
319
320	return 0;
321
322error:
323	usb_kill_anchored_urbs(&data->rx_anchor);
324
325	clear_bit(HCI_RUNNING, &hdev->flags);
326
327	return err;
328}
329
330static int bpa10x_close(struct hci_dev *hdev)
331{
332	struct bpa10x_data *data = hci_get_drvdata(hdev);
333
334	BT_DBG("%s", hdev->name);
335
336	if (!test_and_clear_bit(HCI_RUNNING, &hdev->flags))
337		return 0;
338
339	usb_kill_anchored_urbs(&data->rx_anchor);
340
341	return 0;
342}
343
344static int bpa10x_flush(struct hci_dev *hdev)
345{
346	struct bpa10x_data *data = hci_get_drvdata(hdev);
347
348	BT_DBG("%s", hdev->name);
349
350	usb_kill_anchored_urbs(&data->tx_anchor);
351
352	return 0;
353}
354
355static int bpa10x_send_frame(struct sk_buff *skb)
356{
357	struct hci_dev *hdev = (struct hci_dev *) skb->dev;
358	struct bpa10x_data *data = hci_get_drvdata(hdev);
359	struct usb_ctrlrequest *dr;
360	struct urb *urb;
361	unsigned int pipe;
362	int err;
363
364	BT_DBG("%s", hdev->name);
365
366	if (!test_bit(HCI_RUNNING, &hdev->flags))
367		return -EBUSY;
368
369	urb = usb_alloc_urb(0, GFP_ATOMIC);
370	if (!urb)
371		return -ENOMEM;
372
373	/* Prepend skb with frame type */
374	*skb_push(skb, 1) = bt_cb(skb)->pkt_type;
375
376	switch (bt_cb(skb)->pkt_type) {
377	case HCI_COMMAND_PKT:
378		dr = kmalloc(sizeof(*dr), GFP_ATOMIC);
379		if (!dr) {
380			usb_free_urb(urb);
381			return -ENOMEM;
382		}
383
384		dr->bRequestType = USB_TYPE_VENDOR;
385		dr->bRequest     = 0;
386		dr->wIndex       = 0;
387		dr->wValue       = 0;
388		dr->wLength      = __cpu_to_le16(skb->len);
389
390		pipe = usb_sndctrlpipe(data->udev, 0x00);
391
392		usb_fill_control_urb(urb, data->udev, pipe, (void *) dr,
393				skb->data, skb->len, bpa10x_tx_complete, skb);
394
395		hdev->stat.cmd_tx++;
396		break;
397
398	case HCI_ACLDATA_PKT:
399		pipe = usb_sndbulkpipe(data->udev, 0x02);
400
401		usb_fill_bulk_urb(urb, data->udev, pipe,
402				skb->data, skb->len, bpa10x_tx_complete, skb);
403
404		hdev->stat.acl_tx++;
405		break;
406
407	case HCI_SCODATA_PKT:
408		pipe = usb_sndbulkpipe(data->udev, 0x02);
409
410		usb_fill_bulk_urb(urb, data->udev, pipe,
411				skb->data, skb->len, bpa10x_tx_complete, skb);
412
413		hdev->stat.sco_tx++;
414		break;
415
416	default:
417		usb_free_urb(urb);
418		return -EILSEQ;
419	}
420
421	usb_anchor_urb(urb, &data->tx_anchor);
422
423	err = usb_submit_urb(urb, GFP_ATOMIC);
424	if (err < 0) {
425		BT_ERR("%s urb %p submission failed", hdev->name, urb);
426		kfree(urb->setup_packet);
427		usb_unanchor_urb(urb);
428	}
429
430	usb_free_urb(urb);
431
432	return 0;
433}
434
435static int bpa10x_probe(struct usb_interface *intf, const struct usb_device_id *id)
436{
437	struct bpa10x_data *data;
438	struct hci_dev *hdev;
439	int err;
440
441	BT_DBG("intf %p id %p", intf, id);
442
443	if (intf->cur_altsetting->desc.bInterfaceNumber != 0)
444		return -ENODEV;
445
446	data = kzalloc(sizeof(*data), GFP_KERNEL);
447	if (!data)
448		return -ENOMEM;
449
450	data->udev = interface_to_usbdev(intf);
451
452	init_usb_anchor(&data->tx_anchor);
453	init_usb_anchor(&data->rx_anchor);
454
455	hdev = hci_alloc_dev();
456	if (!hdev) {
457		kfree(data);
458		return -ENOMEM;
459	}
460
461	hdev->bus = HCI_USB;
462	hci_set_drvdata(hdev, data);
463
464	data->hdev = hdev;
465
466	SET_HCIDEV_DEV(hdev, &intf->dev);
467
468	hdev->open     = bpa10x_open;
469	hdev->close    = bpa10x_close;
470	hdev->flush    = bpa10x_flush;
471	hdev->send     = bpa10x_send_frame;
472
473	set_bit(HCI_QUIRK_NO_RESET, &hdev->quirks);
474
475	err = hci_register_dev(hdev);
476	if (err < 0) {
477		hci_free_dev(hdev);
478		kfree(data);
479		return err;
480	}
481
482	usb_set_intfdata(intf, data);
483
484	return 0;
485}
486
487static void bpa10x_disconnect(struct usb_interface *intf)
488{
489	struct bpa10x_data *data = usb_get_intfdata(intf);
490
491	BT_DBG("intf %p", intf);
492
493	if (!data)
494		return;
495
496	usb_set_intfdata(intf, NULL);
497
498	hci_unregister_dev(data->hdev);
499
500	hci_free_dev(data->hdev);
501	kfree_skb(data->rx_skb[0]);
502	kfree_skb(data->rx_skb[1]);
503	kfree(data);
504}
505
506static struct usb_driver bpa10x_driver = {
507	.name		= "bpa10x",
508	.probe		= bpa10x_probe,
509	.disconnect	= bpa10x_disconnect,
510	.id_table	= bpa10x_table,
511};
512
513module_usb_driver(bpa10x_driver);
514
515MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
516MODULE_DESCRIPTION("Digianswer Bluetooth USB driver ver " VERSION);
517MODULE_VERSION(VERSION);
518MODULE_LICENSE("GPL");
519