[thirdparty/linux.git] / drivers / bluetooth / bpa10x.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 *
 *  Digianswer Bluetooth USB driver
 *
 *  Copyright (C) 2004-2007  Marcel Holtmann <marcel@holtmann.org>
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/types.h>
#include <linux/sched.h>
#include <linux/errno.h>
#include <linux/skbuff.h>

#include <linux/usb.h>

#include <net/bluetooth/bluetooth.h>
#include <net/bluetooth/hci_core.h>

#include "h4_recv.h"

#define VERSION "0.11"

static const struct usb_device_id bpa10x_table[] = {
	/* Tektronix BPA 100/105 (Digianswer) */
	{ USB_DEVICE(0x08fd, 0x0002) },

	{ }	/* Terminating entry */
};

MODULE_DEVICE_TABLE(usb, bpa10x_table);

struct bpa10x_data {
	struct hci_dev    *hdev;
	struct usb_device *udev;

	struct usb_anchor tx_anchor;
	struct usb_anchor rx_anchor;

	struct sk_buff *rx_skb[2];
};

static void bpa10x_tx_complete(struct urb *urb)
{
	struct sk_buff *skb = urb->context;
	struct hci_dev *hdev = (struct hci_dev *) skb->dev;

	BT_DBG("%s urb %p status %d count %d", hdev->name,
					urb, urb->status, urb->actual_length);

	if (!test_bit(HCI_RUNNING, &hdev->flags))
		goto done;

	if (!urb->status)
		hdev->stat.byte_tx += urb->transfer_buffer_length;
	else
		hdev->stat.err_tx++;

done:
	kfree(urb->setup_packet);

	kfree_skb(skb);
}

#define HCI_VENDOR_HDR_SIZE 5

#define HCI_RECV_VENDOR \
	.type = HCI_VENDOR_PKT, \
	.hlen = HCI_VENDOR_HDR_SIZE, \
	.loff = 3, \
	.lsize = 2, \
	.maxlen = HCI_MAX_FRAME_SIZE

static const struct h4_recv_pkt bpa10x_recv_pkts[] = {
	{ H4_RECV_ACL,     .recv = hci_recv_frame },
	{ H4_RECV_SCO,     .recv = hci_recv_frame },
	{ H4_RECV_EVENT,   .recv = hci_recv_frame },
	{ HCI_RECV_VENDOR, .recv = hci_recv_diag  },
};

static void bpa10x_rx_complete(struct urb *urb)
{
	struct hci_dev *hdev = urb->context;
	struct bpa10x_data *data = hci_get_drvdata(hdev);
	int err;

	BT_DBG("%s urb %p status %d count %d", hdev->name,
					urb, urb->status, urb->actual_length);

	if (!test_bit(HCI_RUNNING, &hdev->flags))
		return;

	if (urb->status == 0) {
		bool idx = usb_pipebulk(urb->pipe);

		data->rx_skb[idx] = h4_recv_buf(hdev, data->rx_skb[idx],
						urb->transfer_buffer,
						urb->actual_length,
						bpa10x_recv_pkts,
						ARRAY_SIZE(bpa10x_recv_pkts));
		if (IS_ERR(data->rx_skb[idx])) {
			bt_dev_err(hdev, "corrupted event packet");
			hdev->stat.err_rx++;
			data->rx_skb[idx] = NULL;
		}
	}

	usb_anchor_urb(urb, &data->rx_anchor);

	err = usb_submit_urb(urb, GFP_ATOMIC);
	if (err < 0) {
		bt_dev_err(hdev, "urb %p failed to resubmit (%d)", urb, -err);
		usb_unanchor_urb(urb);
	}
}

static inline int bpa10x_submit_intr_urb(struct hci_dev *hdev)
{
	struct bpa10x_data *data = hci_get_drvdata(hdev);
	struct urb *urb;
	unsigned char *buf;
	unsigned int pipe;
	int err, size = 16;

	BT_DBG("%s", hdev->name);

	urb = usb_alloc_urb(0, GFP_KERNEL);
	if (!urb)
		return -ENOMEM;

	buf = kmalloc(size, GFP_KERNEL);
	if (!buf) {
		usb_free_urb(urb);
		return -ENOMEM;
	}

	pipe = usb_rcvintpipe(data->udev, 0x81);

	usb_fill_int_urb(urb, data->udev, pipe, buf, size,
						bpa10x_rx_complete, hdev, 1);

	urb->transfer_flags |= URB_FREE_BUFFER;

	usb_anchor_urb(urb, &data->rx_anchor);

	err = usb_submit_urb(urb, GFP_KERNEL);
	if (err < 0) {
		bt_dev_err(hdev, "urb %p submission failed (%d)", urb, -err);
		usb_unanchor_urb(urb);
	}

	usb_free_urb(urb);

	return err;
}

static inline int bpa10x_submit_bulk_urb(struct hci_dev *hdev)
{
	struct bpa10x_data *data = hci_get_drvdata(hdev);
	struct urb *urb;
	unsigned char *buf;
	unsigned int pipe;
	int err, size = 64;

	BT_DBG("%s", hdev->name);

	urb = usb_alloc_urb(0, GFP_KERNEL);
	if (!urb)
		return -ENOMEM;

	buf = kmalloc(size, GFP_KERNEL);
	if (!buf) {
		usb_free_urb(urb);
		return -ENOMEM;
	}

	pipe = usb_rcvbulkpipe(data->udev, 0x82);

	usb_fill_bulk_urb(urb, data->udev, pipe,
					buf, size, bpa10x_rx_complete, hdev);

	urb->transfer_flags |= URB_FREE_BUFFER;

	usb_anchor_urb(urb, &data->rx_anchor);

	err = usb_submit_urb(urb, GFP_KERNEL);
	if (err < 0) {
		bt_dev_err(hdev, "urb %p submission failed (%d)", urb, -err);
		usb_unanchor_urb(urb);
	}

	usb_free_urb(urb);

	return err;
}

static int bpa10x_open(struct hci_dev *hdev)
{
	struct bpa10x_data *data = hci_get_drvdata(hdev);
	int err;

	BT_DBG("%s", hdev->name);

	err = bpa10x_submit_intr_urb(hdev);
	if (err < 0)
		goto error;

	err = bpa10x_submit_bulk_urb(hdev);
	if (err < 0)
		goto error;

	return 0;

error:
	usb_kill_anchored_urbs(&data->rx_anchor);

	return err;
}

static int bpa10x_close(struct hci_dev *hdev)
{
	struct bpa10x_data *data = hci_get_drvdata(hdev);

	BT_DBG("%s", hdev->name);

	usb_kill_anchored_urbs(&data->rx_anchor);

	return 0;
}

static int bpa10x_flush(struct hci_dev *hdev)
{
	struct bpa10x_data *data = hci_get_drvdata(hdev);

	BT_DBG("%s", hdev->name);

	usb_kill_anchored_urbs(&data->tx_anchor);

	return 0;
}

static int bpa10x_setup(struct hci_dev *hdev)
{
	static const u8 req[] = { 0x07 };
	struct sk_buff *skb;

	BT_DBG("%s", hdev->name);

	/* Read revision string */
	skb = __hci_cmd_sync(hdev, 0xfc0e, sizeof(req), req, HCI_INIT_TIMEOUT);
	if (IS_ERR(skb))
		return PTR_ERR(skb);

	bt_dev_info(hdev, "%s", (char *)(skb->data + 1));

	hci_set_fw_info(hdev, "%s", skb->data + 1);

	kfree_skb(skb);
	return 0;
}

static int bpa10x_send_frame(struct hci_dev *hdev, struct sk_buff *skb)
{
	struct bpa10x_data *data = hci_get_drvdata(hdev);
	struct usb_ctrlrequest *dr;
	struct urb *urb;
	unsigned int pipe;
	int err;

	BT_DBG("%s", hdev->name);

	skb->dev = (void *) hdev;

	urb = usb_alloc_urb(0, GFP_KERNEL);
	if (!urb)
		return -ENOMEM;

	/* Prepend skb with frame type */
	*(u8 *)skb_push(skb, 1) = hci_skb_pkt_type(skb);

	switch (hci_skb_pkt_type(skb)) {
	case HCI_COMMAND_PKT:
		dr = kmalloc(sizeof(*dr), GFP_KERNEL);
		if (!dr) {
			usb_free_urb(urb);
			return -ENOMEM;
		}

		dr->bRequestType = USB_TYPE_VENDOR;
		dr->bRequest     = 0;
		dr->wIndex       = 0;
		dr->wValue       = 0;
		dr->wLength      = __cpu_to_le16(skb->len);

		pipe = usb_sndctrlpipe(data->udev, 0x00);

		usb_fill_control_urb(urb, data->udev, pipe, (void *) dr,
				skb->data, skb->len, bpa10x_tx_complete, skb);

		hdev->stat.cmd_tx++;
		break;

	case HCI_ACLDATA_PKT:
		pipe = usb_sndbulkpipe(data->udev, 0x02);

		usb_fill_bulk_urb(urb, data->udev, pipe,
				skb->data, skb->len, bpa10x_tx_complete, skb);

		hdev->stat.acl_tx++;
		break;

	case HCI_SCODATA_PKT:
		pipe = usb_sndbulkpipe(data->udev, 0x02);

		usb_fill_bulk_urb(urb, data->udev, pipe,
				skb->data, skb->len, bpa10x_tx_complete, skb);

		hdev->stat.sco_tx++;
		break;

	default:
		usb_free_urb(urb);
		return -EILSEQ;
	}

	usb_anchor_urb(urb, &data->tx_anchor);

	err = usb_submit_urb(urb, GFP_KERNEL);
	if (err < 0) {
		bt_dev_err(hdev, "urb %p submission failed", urb);
		kfree(urb->setup_packet);
		usb_unanchor_urb(urb);
	}

	usb_free_urb(urb);

	return 0;
}

static int bpa10x_set_diag(struct hci_dev *hdev, bool enable)
{
	const u8 req[] = { 0x00, enable };
	struct sk_buff *skb;

	BT_DBG("%s", hdev->name);

	if (!test_bit(HCI_RUNNING, &hdev->flags))
		return -ENETDOWN;

	/* Enable sniffer operation */
	skb = __hci_cmd_sync(hdev, 0xfc0e, sizeof(req), req, HCI_INIT_TIMEOUT);
	if (IS_ERR(skb))
		return PTR_ERR(skb);

	kfree_skb(skb);
	return 0;
}

static int bpa10x_probe(struct usb_interface *intf, const struct usb_device_id *id)
{
	struct bpa10x_data *data;
	struct hci_dev *hdev;
	int err;

	BT_DBG("intf %p id %p", intf, id);

	if (intf->cur_altsetting->desc.bInterfaceNumber != 0)
		return -ENODEV;

	data = devm_kzalloc(&intf->dev, sizeof(*data), GFP_KERNEL);
	if (!data)
		return -ENOMEM;

	data->udev = interface_to_usbdev(intf);

	init_usb_anchor(&data->tx_anchor);
	init_usb_anchor(&data->rx_anchor);

	hdev = hci_alloc_dev();
	if (!hdev)
		return -ENOMEM;

	hdev->bus = HCI_USB;
	hci_set_drvdata(hdev, data);

	data->hdev = hdev;

	SET_HCIDEV_DEV(hdev, &intf->dev);

	hdev->open     = bpa10x_open;
	hdev->close    = bpa10x_close;
	hdev->flush    = bpa10x_flush;
	hdev->setup    = bpa10x_setup;
	hdev->send     = bpa10x_send_frame;
	hdev->set_diag = bpa10x_set_diag;

	set_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks);

	err = hci_register_dev(hdev);
	if (err < 0) {
		hci_free_dev(hdev);
		return err;
	}

	usb_set_intfdata(intf, data);

	return 0;
}

static void bpa10x_disconnect(struct usb_interface *intf)
{
	struct bpa10x_data *data = usb_get_intfdata(intf);

	BT_DBG("intf %p", intf);

	if (!data)
		return;

	usb_set_intfdata(intf, NULL);

	hci_unregister_dev(data->hdev);

	hci_free_dev(data->hdev);
	kfree_skb(data->rx_skb[0]);
	kfree_skb(data->rx_skb[1]);
}

static struct usb_driver bpa10x_driver = {
	.name		= "bpa10x",
	.probe		= bpa10x_probe,
	.disconnect	= bpa10x_disconnect,
	.id_table	= bpa10x_table,
	.disable_hub_initiated_lpm = 1,
};

module_usb_driver(bpa10x_driver);

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