usb_kill_anchored_urbs(&data->intr_anchor);	return 0;}static int btusb_flush(struct hci_dev *hdev){	struct btusb_data *data = hdev->driver_data;	BT_DBG("%s", hdev->name);	usb_kill_anchored_urbs(&data->tx_anchor);	return 0;}static int btusb_send_frame(struct sk_buff *skb){	struct hci_dev *hdev = (struct hci_dev *) skb->dev;	struct btusb_data *data = hdev->driver_data;	struct usb_ctrlrequest *dr;	struct urb *urb;	unsigned int pipe;	int err;	BT_DBG("%s", hdev->name);	if (!test_bit(HCI_RUNNING, &hdev->flags))		return -EBUSY;	switch (bt_cb(skb)->pkt_type) {	case HCI_COMMAND_PKT:		urb = usb_alloc_urb(0, GFP_ATOMIC);		if (!urb)			return -ENOMEM;		dr = kmalloc(sizeof(*dr), GFP_ATOMIC);		if (!dr) {			usb_free_urb(urb);			return -ENOMEM;		}		dr->bRequestType = data->cmdreq_type;		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, btusb_tx_complete, skb);		hdev->stat.cmd_tx++;		break;	case HCI_ACLDATA_PKT:		if (!data->bulk_tx_ep || hdev->conn_hash.acl_num < 1)			return -ENODEV;		urb = usb_alloc_urb(0, GFP_ATOMIC);		if (!urb)			return -ENOMEM;		pipe = usb_sndbulkpipe(data->udev,					data->bulk_tx_ep->bEndpointAddress);		usb_fill_bulk_urb(urb, data->udev, pipe,				skb->data, skb->len, btusb_tx_complete, skb);		hdev->stat.acl_tx++;		break;	case HCI_SCODATA_PKT:		if (!data->isoc_tx_ep || hdev->conn_hash.sco_num < 1)			return -ENODEV;		urb = usb_alloc_urb(BTUSB_MAX_ISOC_FRAMES, GFP_ATOMIC);		if (!urb)			return -ENOMEM;		pipe = usb_sndisocpipe(data->udev,					data->isoc_tx_ep->bEndpointAddress);		urb->dev      = data->udev;		urb->pipe     = pipe;		urb->context  = skb;		urb->complete = btusb_tx_complete;		urb->interval = data->isoc_tx_ep->bInterval;		urb->transfer_flags  = URB_ISO_ASAP;		urb->transfer_buffer = skb->data;		urb->transfer_buffer_length = skb->len;		__fill_isoc_descriptor(urb, skb->len,				le16_to_cpu(data->isoc_tx_ep->wMaxPacketSize));		hdev->stat.sco_tx++;		break;	default:		return -EILSEQ;	}	usb_anchor_urb(urb, &data->tx_anchor);	err = usb_submit_urb(urb, GFP_ATOMIC);	if (err < 0) {		BT_ERR("%s urb %p submission failed", hdev->name, urb);		kfree(urb->setup_packet);		usb_unanchor_urb(urb);	}	usb_free_urb(urb);	return err;}static void btusb_destruct(struct hci_dev *hdev){	struct btusb_data *data = hdev->driver_data;	BT_DBG("%s", hdev->name);	kfree(data);}static void btusb_notify(struct hci_dev *hdev, unsigned int evt){	struct btusb_data *data = hdev->driver_data;	BT_DBG("%s evt %d", hdev->name, evt);	if (hdev->conn_hash.acl_num > 0) {		if (!test_and_set_bit(BTUSB_BULK_RUNNING, &data->flags)) {			if (btusb_submit_bulk_urb(hdev, GFP_ATOMIC) < 0)				clear_bit(BTUSB_BULK_RUNNING, &data->flags);			else				btusb_submit_bulk_urb(hdev, GFP_ATOMIC);		}	} else {		clear_bit(BTUSB_BULK_RUNNING, &data->flags);		usb_unlink_anchored_urbs(&data->bulk_anchor);	}	schedule_work(&data->work);}static int inline __set_isoc_interface(struct hci_dev *hdev, int altsetting){	struct btusb_data *data = hdev->driver_data;	struct usb_interface *intf = data->isoc;	struct usb_endpoint_descriptor *ep_desc;	int i, err;	if (!data->isoc)		return -ENODEV;	err = usb_set_interface(data->udev, 1, altsetting);	if (err < 0) {		BT_ERR("%s setting interface failed (%d)", hdev->name, -err);		return err;	}	data->isoc_altsetting = altsetting;	data->isoc_tx_ep = NULL;	data->isoc_rx_ep = NULL;	for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++) {		ep_desc = &intf->cur_altsetting->endpoint[i].desc;		if (!data->isoc_tx_ep && usb_endpoint_is_isoc_out(ep_desc)) {			data->isoc_tx_ep = ep_desc;			continue;		}		if (!data->isoc_rx_ep && usb_endpoint_is_isoc_in(ep_desc)) {			data->isoc_rx_ep = ep_desc;			continue;		}	}	if (!data->isoc_tx_ep || !data->isoc_rx_ep) {		BT_ERR("%s invalid SCO descriptors", hdev->name);		return -ENODEV;	}	return 0;}static void btusb_work(struct work_struct *work){	struct btusb_data *data = container_of(work, struct btusb_data, work);	struct hci_dev *hdev = data->hdev;	if (hdev->conn_hash.sco_num > 0) {		if (data->isoc_altsetting != 2) {			clear_bit(BTUSB_ISOC_RUNNING, &data->flags);			usb_kill_anchored_urbs(&data->isoc_anchor);			if (__set_isoc_interface(hdev, 2) < 0)				return;		}		if (!test_and_set_bit(BTUSB_ISOC_RUNNING, &data->flags)) {			if (btusb_submit_isoc_urb(hdev, GFP_KERNEL) < 0)				clear_bit(BTUSB_ISOC_RUNNING, &data->flags);			else				btusb_submit_isoc_urb(hdev, GFP_KERNEL);		}	} else {		clear_bit(BTUSB_ISOC_RUNNING, &data->flags);		usb_kill_anchored_urbs(&data->isoc_anchor);		__set_isoc_interface(hdev, 0);	}}static int btusb_probe(struct usb_interface *intf,				const struct usb_device_id *id){	struct usb_endpoint_descriptor *ep_desc;	struct btusb_data *data;	struct hci_dev *hdev;	int i, err;	BT_DBG("intf %p id %p", intf, id);	/* interface numbers are hardcoded in the spec */	if (intf->cur_altsetting->desc.bInterfaceNumber != 0)		return -ENODEV;	if (!id->driver_info) {		const struct usb_device_id *match;		match = usb_match_id(intf, blacklist_table);		if (match)			id = match;	}	if (id->driver_info == BTUSB_IGNORE)		return -ENODEV;	if (ignore_dga && id->driver_info & BTUSB_DIGIANSWER)		return -ENODEV;	if (ignore_csr && id->driver_info & BTUSB_CSR)		return -ENODEV;	if (ignore_sniffer && id->driver_info & BTUSB_SNIFFER)		return -ENODEV;	data = kzalloc(sizeof(*data), GFP_KERNEL);	if (!data)		return -ENOMEM;	for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++) {		ep_desc = &intf->cur_altsetting->endpoint[i].desc;		if (!data->intr_ep && usb_endpoint_is_int_in(ep_desc)) {			data->intr_ep = ep_desc;			continue;		}		if (!data->bulk_tx_ep && usb_endpoint_is_bulk_out(ep_desc)) {			data->bulk_tx_ep = ep_desc;			continue;		}		if (!data->bulk_rx_ep && usb_endpoint_is_bulk_in(ep_desc)) {			data->bulk_rx_ep = ep_desc;			continue;		}	}	if (!data->intr_ep || !data->bulk_tx_ep || !data->bulk_rx_ep) {		kfree(data);		return -ENODEV;	}	data->cmdreq_type = USB_TYPE_CLASS;	data->udev = interface_to_usbdev(intf);	data->intf = intf;	spin_lock_init(&data->lock);	INIT_WORK(&data->work, btusb_work);	init_usb_anchor(&data->tx_anchor);	init_usb_anchor(&data->intr_anchor);	init_usb_anchor(&data->bulk_anchor);	init_usb_anchor(&data->isoc_anchor);	hdev = hci_alloc_dev();	if (!hdev) {		kfree(data);		return -ENOMEM;	}	hdev->type = HCI_USB;	hdev->driver_data = data;	data->hdev = hdev;	SET_HCIDEV_DEV(hdev, &intf->dev);	hdev->open     = btusb_open;	hdev->close    = btusb_close;	hdev->flush    = btusb_flush;	hdev->send     = btusb_send_frame;	hdev->destruct = btusb_destruct;	hdev->notify   = btusb_notify;	hdev->owner = THIS_MODULE;	/* Interface numbers are hardcoded in the specification */	data->isoc = usb_ifnum_to_if(data->udev, 1);	if (!reset)		set_bit(HCI_QUIRK_NO_RESET, &hdev->quirks);	if (force_scofix || id->driver_info & BTUSB_WRONG_SCO_MTU) {		if (!disable_scofix)			set_bit(HCI_QUIRK_FIXUP_BUFFER_SIZE, &hdev->quirks);	}	if (id->driver_info & BTUSB_BROKEN_ISOC)		data->isoc = NULL;	if (id->driver_info & BTUSB_DIGIANSWER) {		data->cmdreq_type = USB_TYPE_VENDOR;		set_bit(HCI_QUIRK_NO_RESET, &hdev->quirks);	}	if (id->driver_info & BTUSB_CSR) {		struct usb_device *udev = data->udev;		/* Old firmware would otherwise execute USB reset */		if (le16_to_cpu(udev->descriptor.bcdDevice) < 0x117)			set_bit(HCI_QUIRK_NO_RESET, &hdev->quirks);	}	if (id->driver_info & BTUSB_SNIFFER) {		struct usb_device *udev = data->udev;		/* New sniffer firmware has crippled HCI interface */		if (le16_to_cpu(udev->descriptor.bcdDevice) > 0x997)			set_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks);		data->isoc = NULL;	}	if (id->driver_info & BTUSB_BCM92035) {		unsigned char cmd[] = { 0x3b, 0xfc, 0x01, 0x00 };		struct sk_buff *skb;		skb = bt_skb_alloc(sizeof(cmd), GFP_KERNEL);		if (skb) {			memcpy(skb_put(skb, sizeof(cmd)), cmd, sizeof(cmd));			skb_queue_tail(&hdev->driver_init, skb);		}	}	if (data->isoc) {		err = usb_driver_claim_interface(&btusb_driver,							data->isoc, data);		if (err < 0) {			hci_free_dev(hdev);			kfree(data);			return err;		}	}	err = hci_register_dev(hdev);	if (err < 0) {		hci_free_dev(hdev);		kfree(data);		return err;	}	usb_set_intfdata(intf, data);	return 0;}static void btusb_disconnect(struct usb_interface *intf){	struct btusb_data *data = usb_get_intfdata(intf);	struct hci_dev *hdev;	BT_DBG("intf %p", intf);	if (!data)		return;	hdev = data->hdev;	__hci_dev_hold(hdev);	usb_set_intfdata(data->intf, NULL);	if (data->isoc)		usb_set_intfdata(data->isoc, NULL);	hci_unregister_dev(hdev);	if (intf == data->isoc)		usb_driver_release_interface(&btusb_driver, data->intf);	else if (data->isoc)		usb_driver_release_interface(&btusb_driver, data->isoc);	__hci_dev_put(hdev);	hci_free_dev(hdev);}static int btusb_suspend(struct usb_interface *intf, pm_message_t message){	struct btusb_data *data = usb_get_intfdata(intf);	BT_DBG("intf %p", intf);	if (data->suspend_count++)		return 0;	cancel_work_sync(&data->work);	usb_kill_anchored_urbs(&data->tx_anchor);	usb_kill_anchored_urbs(&data->isoc_anchor);	usb_kill_anchored_urbs(&data->bulk_anchor);	usb_kill_anchored_urbs(&data->intr_anchor);	return 0;}static int btusb_resume(struct usb_interface *intf){	struct btusb_data *data = usb_get_intfdata(intf);	struct hci_dev *hdev = data->hdev;	int err;	BT_DBG("intf %p", intf);	if (--data->suspend_count)		return 0;	if (!test_bit(HCI_RUNNING, &hdev->flags))		return 0;	if (test_bit(BTUSB_INTR_RUNNING, &data->flags)) {		err = btusb_submit_intr_urb(hdev, GFP_NOIO);		if (err < 0) {			clear_bit(BTUSB_INTR_RUNNING, &data->flags);			return err;		}	}	if (test_bit(BTUSB_BULK_RUNNING, &data->flags)) {		if (btusb_submit_bulk_urb(hdev, GFP_NOIO) < 0)			clear_bit(BTUSB_BULK_RUNNING, &data->flags);		else			btusb_submit_bulk_urb(hdev, GFP_NOIO);	}	if (test_bit(BTUSB_ISOC_RUNNING, &data->flags)) {		if (btusb_submit_isoc_urb(hdev, GFP_NOIO) < 0)			clear_bit(BTUSB_ISOC_RUNNING, &data->flags);		else			btusb_submit_isoc_urb(hdev, GFP_NOIO);	}	return 0;}static struct usb_driver btusb_driver = {	.name		= "btusb",	.probe		= btusb_probe,	.disconnect	= btusb_disconnect,	.suspend	= btusb_suspend,	.resume		= btusb_resume,	.id_table	= btusb_table,};static int __init btusb_init(void){	BT_INFO("Generic Bluetooth USB driver ver %s", VERSION);	return usb_register(&btusb_driver);}static void __exit btusb_exit(void){	usb_deregister(&btusb_driver);}module_init(btusb_init);module_exit(btusb_exit);module_param(ignore_dga, bool, 0644);MODULE_PARM_DESC(ignore_dga, "Ignore devices with id 08fd:0001");module_param(ignore_csr, bool, 0644);MODULE_PARM_DESC(ignore_csr, "Ignore devices with id 0a12:0001");module_param(ignore_sniffer, bool, 0644);MODULE_PARM_DESC(ignore_sniffer, "Ignore devices with id 0a12:0002");module_param(disable_scofix, bool, 0644);MODULE_PARM_DESC(disable_scofix, "Disable fixup of wrong SCO buffer size");module_param(force_scofix, bool, 0644);MODULE_PARM_DESC(force_scofix, "Force fixup of wrong SCO buffers size");module_param(reset, bool, 0644);MODULE_PARM_DESC(reset, "Send HCI reset command on initialization");MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");MODULE_DESCRIPTION("Generic Bluetooth USB driver ver " VERSION);MODULE_VERSION(VERSION);MODULE_LICENSE("GPL");