mirror of
https://mirrors.bfsu.edu.cn/git/linux.git
synced 2024-12-16 23:45:31 +08:00
81cac64ba2
There exists a set of Bluetooth USB devices that show up on the USB
bus as 0a12:0001 and identify themselves as devices from CSR. However
they are not. When sending Read Local Version command they now have
a split personality and say they are from Broadcom.
< HCI Command: Read Local Version Information (0x04|0x0001) plen 0
> HCI Event: Command Complete (0x0e) plen 12
Read Local Version Information (0x04|0x0001) ncmd 1
status 0x00
HCI Version: 2.0 (0x3) HCI Revision: 0x3000
LMP Version: 2.0 (0x3) LMP Subversion: 0x420b
Manufacturer: Broadcom Corporation (15)
The assumption is that they are neither CSR nor Broadcom based devices
and that they are designed and manufactured by someone else.
For the most parts they follow the Bluetooth HCI specification and
can be used as standard Bluetooth devices. However they have the
minor problem that the Delete Stored Link Key command is not working
as it should.
During the Bluetooth controller setup, this command is needed if
stored link keys are supported. For these devices it has to be
assumed that this is broken and so just set a quirk to clearly
indicate the behavior. After that the setup can just proceed.
Now the trick part is to detect these faulty devices since we do
not want to punish all CSR and all Broadcom devices. The original
devices do actually work according to the specification.
What is known so far is that these broken devices set the USB bcdDevice
revision information to 1.0 or less.
T: Bus=02 Lev=01 Prnt=01 Port=08 Cnt=03 Dev#= 9 Spd=12 MxCh= 0
D: Ver= 2.00 Cls=e0(wlcon) Sub=01 Prot=01 MxPS=64 #Cfgs= 1
P: Vendor=0a12 ProdID=0001 Rev= 1.00
S: Manufacturer=Bluetooth v2.0
S: Product=Bluetooth V2.0 Dongle
T: Bus=05 Lev=01 Prnt=01 Port=01 Cnt=01 Dev#= 2 Spd=12 MxCh= 0
D: Ver= 1.10 Cls=e0(wlcon) Sub=01 Prot=01 MxPS=64 #Cfgs= 1
P: Vendor=0a12 ProdID=0001 Rev= 0.07
In case of CSR devices, the bcdDevice revision contains the firmware
build ID and that is normally a higher value. If the bcdDevice revision
is 1.0 or less, then an extra setup stage is checking if Read Local
Version returns CSR manufacturer information. If not then it will be
assumed that this is a broken device and the Delete Stored Link Key
command will be marked as broken.
Signed-off-by: Marcel Holtmann <marcel@holtmann.org>
Signed-off-by: Johan Hedberg <johan.hedberg@intel.com>
1711 lines
43 KiB
C
1711 lines
43 KiB
C
/*
|
|
*
|
|
* Generic Bluetooth USB driver
|
|
*
|
|
* Copyright (C) 2005-2008 Marcel Holtmann <marcel@holtmann.org>
|
|
*
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*
|
|
*/
|
|
|
|
#include <linux/module.h>
|
|
#include <linux/usb.h>
|
|
#include <linux/firmware.h>
|
|
|
|
#include <net/bluetooth/bluetooth.h>
|
|
#include <net/bluetooth/hci_core.h>
|
|
|
|
#define VERSION "0.6"
|
|
|
|
static bool ignore_dga;
|
|
static bool ignore_csr;
|
|
static bool ignore_sniffer;
|
|
static bool disable_scofix;
|
|
static bool force_scofix;
|
|
|
|
static bool reset = 1;
|
|
|
|
static struct usb_driver btusb_driver;
|
|
|
|
#define BTUSB_IGNORE 0x01
|
|
#define BTUSB_DIGIANSWER 0x02
|
|
#define BTUSB_CSR 0x04
|
|
#define BTUSB_SNIFFER 0x08
|
|
#define BTUSB_BCM92035 0x10
|
|
#define BTUSB_BROKEN_ISOC 0x20
|
|
#define BTUSB_WRONG_SCO_MTU 0x40
|
|
#define BTUSB_ATH3012 0x80
|
|
#define BTUSB_INTEL 0x100
|
|
|
|
static const struct usb_device_id btusb_table[] = {
|
|
/* Generic Bluetooth USB device */
|
|
{ USB_DEVICE_INFO(0xe0, 0x01, 0x01) },
|
|
|
|
/* Apple-specific (Broadcom) devices */
|
|
{ USB_VENDOR_AND_INTERFACE_INFO(0x05ac, 0xff, 0x01, 0x01) },
|
|
|
|
/* MediaTek MT76x0E */
|
|
{ USB_DEVICE(0x0e8d, 0x763f) },
|
|
|
|
/* Broadcom SoftSailing reporting vendor specific */
|
|
{ USB_DEVICE(0x0a5c, 0x21e1) },
|
|
|
|
/* Apple MacBookPro 7,1 */
|
|
{ USB_DEVICE(0x05ac, 0x8213) },
|
|
|
|
/* Apple iMac11,1 */
|
|
{ USB_DEVICE(0x05ac, 0x8215) },
|
|
|
|
/* Apple MacBookPro6,2 */
|
|
{ USB_DEVICE(0x05ac, 0x8218) },
|
|
|
|
/* Apple MacBookAir3,1, MacBookAir3,2 */
|
|
{ USB_DEVICE(0x05ac, 0x821b) },
|
|
|
|
/* Apple MacBookAir4,1 */
|
|
{ USB_DEVICE(0x05ac, 0x821f) },
|
|
|
|
/* Apple MacBookPro8,2 */
|
|
{ USB_DEVICE(0x05ac, 0x821a) },
|
|
|
|
/* Apple MacMini5,1 */
|
|
{ USB_DEVICE(0x05ac, 0x8281) },
|
|
|
|
/* AVM BlueFRITZ! USB v2.0 */
|
|
{ USB_DEVICE(0x057c, 0x3800) },
|
|
|
|
/* Bluetooth Ultraport Module from IBM */
|
|
{ USB_DEVICE(0x04bf, 0x030a) },
|
|
|
|
/* ALPS Modules with non-standard id */
|
|
{ USB_DEVICE(0x044e, 0x3001) },
|
|
{ USB_DEVICE(0x044e, 0x3002) },
|
|
|
|
/* Ericsson with non-standard id */
|
|
{ USB_DEVICE(0x0bdb, 0x1002) },
|
|
|
|
/* Canyon CN-BTU1 with HID interfaces */
|
|
{ USB_DEVICE(0x0c10, 0x0000) },
|
|
|
|
/* Broadcom BCM20702A0 */
|
|
{ USB_DEVICE(0x0b05, 0x17b5) },
|
|
{ USB_DEVICE(0x0b05, 0x17cb) },
|
|
{ USB_DEVICE(0x04ca, 0x2003) },
|
|
{ USB_DEVICE(0x0489, 0xe042) },
|
|
{ USB_DEVICE(0x413c, 0x8197) },
|
|
|
|
/* Foxconn - Hon Hai */
|
|
{ USB_VENDOR_AND_INTERFACE_INFO(0x0489, 0xff, 0x01, 0x01) },
|
|
|
|
/*Broadcom devices with vendor specific id */
|
|
{ USB_VENDOR_AND_INTERFACE_INFO(0x0a5c, 0xff, 0x01, 0x01) },
|
|
|
|
/* Belkin F8065bf - Broadcom based */
|
|
{ USB_VENDOR_AND_INTERFACE_INFO(0x050d, 0xff, 0x01, 0x01) },
|
|
|
|
{ } /* Terminating entry */
|
|
};
|
|
|
|
MODULE_DEVICE_TABLE(usb, btusb_table);
|
|
|
|
static const struct usb_device_id blacklist_table[] = {
|
|
/* CSR BlueCore devices */
|
|
{ USB_DEVICE(0x0a12, 0x0001), .driver_info = BTUSB_CSR },
|
|
|
|
/* Broadcom BCM2033 without firmware */
|
|
{ USB_DEVICE(0x0a5c, 0x2033), .driver_info = BTUSB_IGNORE },
|
|
|
|
/* Atheros 3011 with sflash firmware */
|
|
{ USB_DEVICE(0x0cf3, 0x3002), .driver_info = BTUSB_IGNORE },
|
|
{ USB_DEVICE(0x0cf3, 0xe019), .driver_info = BTUSB_IGNORE },
|
|
{ USB_DEVICE(0x13d3, 0x3304), .driver_info = BTUSB_IGNORE },
|
|
{ USB_DEVICE(0x0930, 0x0215), .driver_info = BTUSB_IGNORE },
|
|
{ USB_DEVICE(0x0489, 0xe03d), .driver_info = BTUSB_IGNORE },
|
|
{ USB_DEVICE(0x0489, 0xe027), .driver_info = BTUSB_IGNORE },
|
|
|
|
/* Atheros AR9285 Malbec with sflash firmware */
|
|
{ USB_DEVICE(0x03f0, 0x311d), .driver_info = BTUSB_IGNORE },
|
|
|
|
/* Atheros 3012 with sflash firmware */
|
|
{ USB_DEVICE(0x0cf3, 0x0036), .driver_info = BTUSB_ATH3012 },
|
|
{ USB_DEVICE(0x0cf3, 0x3004), .driver_info = BTUSB_ATH3012 },
|
|
{ USB_DEVICE(0x0cf3, 0x3008), .driver_info = BTUSB_ATH3012 },
|
|
{ USB_DEVICE(0x0cf3, 0x311d), .driver_info = BTUSB_ATH3012 },
|
|
{ USB_DEVICE(0x0cf3, 0x817a), .driver_info = BTUSB_ATH3012 },
|
|
{ USB_DEVICE(0x13d3, 0x3375), .driver_info = BTUSB_ATH3012 },
|
|
{ USB_DEVICE(0x04ca, 0x3004), .driver_info = BTUSB_ATH3012 },
|
|
{ USB_DEVICE(0x04ca, 0x3005), .driver_info = BTUSB_ATH3012 },
|
|
{ USB_DEVICE(0x04ca, 0x3006), .driver_info = BTUSB_ATH3012 },
|
|
{ USB_DEVICE(0x04ca, 0x3008), .driver_info = BTUSB_ATH3012 },
|
|
{ USB_DEVICE(0x04ca, 0x300b), .driver_info = BTUSB_ATH3012 },
|
|
{ USB_DEVICE(0x13d3, 0x3362), .driver_info = BTUSB_ATH3012 },
|
|
{ USB_DEVICE(0x0cf3, 0xe004), .driver_info = BTUSB_ATH3012 },
|
|
{ USB_DEVICE(0x0cf3, 0xe005), .driver_info = BTUSB_ATH3012 },
|
|
{ USB_DEVICE(0x0930, 0x0219), .driver_info = BTUSB_ATH3012 },
|
|
{ USB_DEVICE(0x0489, 0xe057), .driver_info = BTUSB_ATH3012 },
|
|
{ USB_DEVICE(0x13d3, 0x3393), .driver_info = BTUSB_ATH3012 },
|
|
{ USB_DEVICE(0x0489, 0xe04e), .driver_info = BTUSB_ATH3012 },
|
|
{ USB_DEVICE(0x0489, 0xe056), .driver_info = BTUSB_ATH3012 },
|
|
{ USB_DEVICE(0x0489, 0xe04d), .driver_info = BTUSB_ATH3012 },
|
|
{ USB_DEVICE(0x04c5, 0x1330), .driver_info = BTUSB_ATH3012 },
|
|
{ USB_DEVICE(0x13d3, 0x3402), .driver_info = BTUSB_ATH3012 },
|
|
{ USB_DEVICE(0x0cf3, 0x3121), .driver_info = BTUSB_ATH3012 },
|
|
{ USB_DEVICE(0x0cf3, 0xe003), .driver_info = BTUSB_ATH3012 },
|
|
{ USB_DEVICE(0x0489, 0xe05f), .driver_info = BTUSB_ATH3012 },
|
|
|
|
/* Atheros AR5BBU12 with sflash firmware */
|
|
{ USB_DEVICE(0x0489, 0xe02c), .driver_info = BTUSB_IGNORE },
|
|
|
|
/* Atheros AR5BBU12 with sflash firmware */
|
|
{ USB_DEVICE(0x0489, 0xe03c), .driver_info = BTUSB_ATH3012 },
|
|
{ USB_DEVICE(0x0489, 0xe036), .driver_info = BTUSB_ATH3012 },
|
|
|
|
/* Broadcom BCM2035 */
|
|
{ USB_DEVICE(0x0a5c, 0x2035), .driver_info = BTUSB_WRONG_SCO_MTU },
|
|
{ USB_DEVICE(0x0a5c, 0x200a), .driver_info = BTUSB_WRONG_SCO_MTU },
|
|
{ USB_DEVICE(0x0a5c, 0x2009), .driver_info = BTUSB_BCM92035 },
|
|
|
|
/* Broadcom BCM2045 */
|
|
{ USB_DEVICE(0x0a5c, 0x2039), .driver_info = BTUSB_WRONG_SCO_MTU },
|
|
{ USB_DEVICE(0x0a5c, 0x2101), .driver_info = BTUSB_WRONG_SCO_MTU },
|
|
|
|
/* IBM/Lenovo ThinkPad with Broadcom chip */
|
|
{ USB_DEVICE(0x0a5c, 0x201e), .driver_info = BTUSB_WRONG_SCO_MTU },
|
|
{ USB_DEVICE(0x0a5c, 0x2110), .driver_info = BTUSB_WRONG_SCO_MTU },
|
|
|
|
/* HP laptop with Broadcom chip */
|
|
{ USB_DEVICE(0x03f0, 0x171d), .driver_info = BTUSB_WRONG_SCO_MTU },
|
|
|
|
/* Dell laptop with Broadcom chip */
|
|
{ USB_DEVICE(0x413c, 0x8126), .driver_info = BTUSB_WRONG_SCO_MTU },
|
|
|
|
/* Dell Wireless 370 and 410 devices */
|
|
{ USB_DEVICE(0x413c, 0x8152), .driver_info = BTUSB_WRONG_SCO_MTU },
|
|
{ USB_DEVICE(0x413c, 0x8156), .driver_info = BTUSB_WRONG_SCO_MTU },
|
|
|
|
/* Belkin F8T012 and F8T013 devices */
|
|
{ USB_DEVICE(0x050d, 0x0012), .driver_info = BTUSB_WRONG_SCO_MTU },
|
|
{ USB_DEVICE(0x050d, 0x0013), .driver_info = BTUSB_WRONG_SCO_MTU },
|
|
|
|
/* Asus WL-BTD202 device */
|
|
{ USB_DEVICE(0x0b05, 0x1715), .driver_info = BTUSB_WRONG_SCO_MTU },
|
|
|
|
/* Kensington Bluetooth USB adapter */
|
|
{ USB_DEVICE(0x047d, 0x105e), .driver_info = BTUSB_WRONG_SCO_MTU },
|
|
|
|
/* RTX Telecom based adapters with buggy SCO support */
|
|
{ USB_DEVICE(0x0400, 0x0807), .driver_info = BTUSB_BROKEN_ISOC },
|
|
{ USB_DEVICE(0x0400, 0x080a), .driver_info = BTUSB_BROKEN_ISOC },
|
|
|
|
/* CONWISE Technology based adapters with buggy SCO support */
|
|
{ USB_DEVICE(0x0e5e, 0x6622), .driver_info = BTUSB_BROKEN_ISOC },
|
|
|
|
/* Digianswer devices */
|
|
{ USB_DEVICE(0x08fd, 0x0001), .driver_info = BTUSB_DIGIANSWER },
|
|
{ USB_DEVICE(0x08fd, 0x0002), .driver_info = BTUSB_IGNORE },
|
|
|
|
/* CSR BlueCore Bluetooth Sniffer */
|
|
{ USB_DEVICE(0x0a12, 0x0002), .driver_info = BTUSB_SNIFFER },
|
|
|
|
/* Frontline ComProbe Bluetooth Sniffer */
|
|
{ USB_DEVICE(0x16d3, 0x0002), .driver_info = BTUSB_SNIFFER },
|
|
|
|
/* Intel Bluetooth device */
|
|
{ USB_DEVICE(0x8087, 0x07dc), .driver_info = BTUSB_INTEL },
|
|
{ USB_DEVICE(0x8087, 0x0a2a), .driver_info = BTUSB_INTEL },
|
|
|
|
{ } /* Terminating entry */
|
|
};
|
|
|
|
#define BTUSB_MAX_ISOC_FRAMES 10
|
|
|
|
#define BTUSB_INTR_RUNNING 0
|
|
#define BTUSB_BULK_RUNNING 1
|
|
#define BTUSB_ISOC_RUNNING 2
|
|
#define BTUSB_SUSPENDING 3
|
|
#define BTUSB_DID_ISO_RESUME 4
|
|
|
|
struct btusb_data {
|
|
struct hci_dev *hdev;
|
|
struct usb_device *udev;
|
|
struct usb_interface *intf;
|
|
struct usb_interface *isoc;
|
|
|
|
spinlock_t lock;
|
|
|
|
unsigned long flags;
|
|
|
|
struct work_struct work;
|
|
struct work_struct waker;
|
|
|
|
struct usb_anchor tx_anchor;
|
|
struct usb_anchor intr_anchor;
|
|
struct usb_anchor bulk_anchor;
|
|
struct usb_anchor isoc_anchor;
|
|
struct usb_anchor deferred;
|
|
int tx_in_flight;
|
|
spinlock_t txlock;
|
|
|
|
struct usb_endpoint_descriptor *intr_ep;
|
|
struct usb_endpoint_descriptor *bulk_tx_ep;
|
|
struct usb_endpoint_descriptor *bulk_rx_ep;
|
|
struct usb_endpoint_descriptor *isoc_tx_ep;
|
|
struct usb_endpoint_descriptor *isoc_rx_ep;
|
|
|
|
__u8 cmdreq_type;
|
|
|
|
unsigned int sco_num;
|
|
int isoc_altsetting;
|
|
int suspend_count;
|
|
};
|
|
|
|
static int inc_tx(struct btusb_data *data)
|
|
{
|
|
unsigned long flags;
|
|
int rv;
|
|
|
|
spin_lock_irqsave(&data->txlock, flags);
|
|
rv = test_bit(BTUSB_SUSPENDING, &data->flags);
|
|
if (!rv)
|
|
data->tx_in_flight++;
|
|
spin_unlock_irqrestore(&data->txlock, flags);
|
|
|
|
return rv;
|
|
}
|
|
|
|
static void btusb_intr_complete(struct urb *urb)
|
|
{
|
|
struct hci_dev *hdev = urb->context;
|
|
struct btusb_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) {
|
|
hdev->stat.byte_rx += urb->actual_length;
|
|
|
|
if (hci_recv_fragment(hdev, HCI_EVENT_PKT,
|
|
urb->transfer_buffer,
|
|
urb->actual_length) < 0) {
|
|
BT_ERR("%s corrupted event packet", hdev->name);
|
|
hdev->stat.err_rx++;
|
|
}
|
|
}
|
|
|
|
if (!test_bit(BTUSB_INTR_RUNNING, &data->flags))
|
|
return;
|
|
|
|
usb_mark_last_busy(data->udev);
|
|
usb_anchor_urb(urb, &data->intr_anchor);
|
|
|
|
err = usb_submit_urb(urb, GFP_ATOMIC);
|
|
if (err < 0) {
|
|
/* -EPERM: urb is being killed;
|
|
* -ENODEV: device got disconnected */
|
|
if (err != -EPERM && err != -ENODEV)
|
|
BT_ERR("%s urb %p failed to resubmit (%d)",
|
|
hdev->name, urb, -err);
|
|
usb_unanchor_urb(urb);
|
|
}
|
|
}
|
|
|
|
static int btusb_submit_intr_urb(struct hci_dev *hdev, gfp_t mem_flags)
|
|
{
|
|
struct btusb_data *data = hci_get_drvdata(hdev);
|
|
struct urb *urb;
|
|
unsigned char *buf;
|
|
unsigned int pipe;
|
|
int err, size;
|
|
|
|
BT_DBG("%s", hdev->name);
|
|
|
|
if (!data->intr_ep)
|
|
return -ENODEV;
|
|
|
|
urb = usb_alloc_urb(0, mem_flags);
|
|
if (!urb)
|
|
return -ENOMEM;
|
|
|
|
size = le16_to_cpu(data->intr_ep->wMaxPacketSize);
|
|
|
|
buf = kmalloc(size, mem_flags);
|
|
if (!buf) {
|
|
usb_free_urb(urb);
|
|
return -ENOMEM;
|
|
}
|
|
|
|
pipe = usb_rcvintpipe(data->udev, data->intr_ep->bEndpointAddress);
|
|
|
|
usb_fill_int_urb(urb, data->udev, pipe, buf, size,
|
|
btusb_intr_complete, hdev,
|
|
data->intr_ep->bInterval);
|
|
|
|
urb->transfer_flags |= URB_FREE_BUFFER;
|
|
|
|
usb_anchor_urb(urb, &data->intr_anchor);
|
|
|
|
err = usb_submit_urb(urb, mem_flags);
|
|
if (err < 0) {
|
|
if (err != -EPERM && err != -ENODEV)
|
|
BT_ERR("%s urb %p submission failed (%d)",
|
|
hdev->name, urb, -err);
|
|
usb_unanchor_urb(urb);
|
|
}
|
|
|
|
usb_free_urb(urb);
|
|
|
|
return err;
|
|
}
|
|
|
|
static void btusb_bulk_complete(struct urb *urb)
|
|
{
|
|
struct hci_dev *hdev = urb->context;
|
|
struct btusb_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) {
|
|
hdev->stat.byte_rx += urb->actual_length;
|
|
|
|
if (hci_recv_fragment(hdev, HCI_ACLDATA_PKT,
|
|
urb->transfer_buffer,
|
|
urb->actual_length) < 0) {
|
|
BT_ERR("%s corrupted ACL packet", hdev->name);
|
|
hdev->stat.err_rx++;
|
|
}
|
|
}
|
|
|
|
if (!test_bit(BTUSB_BULK_RUNNING, &data->flags))
|
|
return;
|
|
|
|
usb_anchor_urb(urb, &data->bulk_anchor);
|
|
usb_mark_last_busy(data->udev);
|
|
|
|
err = usb_submit_urb(urb, GFP_ATOMIC);
|
|
if (err < 0) {
|
|
/* -EPERM: urb is being killed;
|
|
* -ENODEV: device got disconnected */
|
|
if (err != -EPERM && err != -ENODEV)
|
|
BT_ERR("%s urb %p failed to resubmit (%d)",
|
|
hdev->name, urb, -err);
|
|
usb_unanchor_urb(urb);
|
|
}
|
|
}
|
|
|
|
static int btusb_submit_bulk_urb(struct hci_dev *hdev, gfp_t mem_flags)
|
|
{
|
|
struct btusb_data *data = hci_get_drvdata(hdev);
|
|
struct urb *urb;
|
|
unsigned char *buf;
|
|
unsigned int pipe;
|
|
int err, size = HCI_MAX_FRAME_SIZE;
|
|
|
|
BT_DBG("%s", hdev->name);
|
|
|
|
if (!data->bulk_rx_ep)
|
|
return -ENODEV;
|
|
|
|
urb = usb_alloc_urb(0, mem_flags);
|
|
if (!urb)
|
|
return -ENOMEM;
|
|
|
|
buf = kmalloc(size, mem_flags);
|
|
if (!buf) {
|
|
usb_free_urb(urb);
|
|
return -ENOMEM;
|
|
}
|
|
|
|
pipe = usb_rcvbulkpipe(data->udev, data->bulk_rx_ep->bEndpointAddress);
|
|
|
|
usb_fill_bulk_urb(urb, data->udev, pipe,
|
|
buf, size, btusb_bulk_complete, hdev);
|
|
|
|
urb->transfer_flags |= URB_FREE_BUFFER;
|
|
|
|
usb_mark_last_busy(data->udev);
|
|
usb_anchor_urb(urb, &data->bulk_anchor);
|
|
|
|
err = usb_submit_urb(urb, mem_flags);
|
|
if (err < 0) {
|
|
if (err != -EPERM && err != -ENODEV)
|
|
BT_ERR("%s urb %p submission failed (%d)",
|
|
hdev->name, urb, -err);
|
|
usb_unanchor_urb(urb);
|
|
}
|
|
|
|
usb_free_urb(urb);
|
|
|
|
return err;
|
|
}
|
|
|
|
static void btusb_isoc_complete(struct urb *urb)
|
|
{
|
|
struct hci_dev *hdev = urb->context;
|
|
struct btusb_data *data = hci_get_drvdata(hdev);
|
|
int i, 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) {
|
|
for (i = 0; i < urb->number_of_packets; i++) {
|
|
unsigned int offset = urb->iso_frame_desc[i].offset;
|
|
unsigned int length = urb->iso_frame_desc[i].actual_length;
|
|
|
|
if (urb->iso_frame_desc[i].status)
|
|
continue;
|
|
|
|
hdev->stat.byte_rx += length;
|
|
|
|
if (hci_recv_fragment(hdev, HCI_SCODATA_PKT,
|
|
urb->transfer_buffer + offset,
|
|
length) < 0) {
|
|
BT_ERR("%s corrupted SCO packet", hdev->name);
|
|
hdev->stat.err_rx++;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!test_bit(BTUSB_ISOC_RUNNING, &data->flags))
|
|
return;
|
|
|
|
usb_anchor_urb(urb, &data->isoc_anchor);
|
|
|
|
err = usb_submit_urb(urb, GFP_ATOMIC);
|
|
if (err < 0) {
|
|
/* -EPERM: urb is being killed;
|
|
* -ENODEV: device got disconnected */
|
|
if (err != -EPERM && err != -ENODEV)
|
|
BT_ERR("%s urb %p failed to resubmit (%d)",
|
|
hdev->name, urb, -err);
|
|
usb_unanchor_urb(urb);
|
|
}
|
|
}
|
|
|
|
static inline void __fill_isoc_descriptor(struct urb *urb, int len, int mtu)
|
|
{
|
|
int i, offset = 0;
|
|
|
|
BT_DBG("len %d mtu %d", len, mtu);
|
|
|
|
for (i = 0; i < BTUSB_MAX_ISOC_FRAMES && len >= mtu;
|
|
i++, offset += mtu, len -= mtu) {
|
|
urb->iso_frame_desc[i].offset = offset;
|
|
urb->iso_frame_desc[i].length = mtu;
|
|
}
|
|
|
|
if (len && i < BTUSB_MAX_ISOC_FRAMES) {
|
|
urb->iso_frame_desc[i].offset = offset;
|
|
urb->iso_frame_desc[i].length = len;
|
|
i++;
|
|
}
|
|
|
|
urb->number_of_packets = i;
|
|
}
|
|
|
|
static int btusb_submit_isoc_urb(struct hci_dev *hdev, gfp_t mem_flags)
|
|
{
|
|
struct btusb_data *data = hci_get_drvdata(hdev);
|
|
struct urb *urb;
|
|
unsigned char *buf;
|
|
unsigned int pipe;
|
|
int err, size;
|
|
|
|
BT_DBG("%s", hdev->name);
|
|
|
|
if (!data->isoc_rx_ep)
|
|
return -ENODEV;
|
|
|
|
urb = usb_alloc_urb(BTUSB_MAX_ISOC_FRAMES, mem_flags);
|
|
if (!urb)
|
|
return -ENOMEM;
|
|
|
|
size = le16_to_cpu(data->isoc_rx_ep->wMaxPacketSize) *
|
|
BTUSB_MAX_ISOC_FRAMES;
|
|
|
|
buf = kmalloc(size, mem_flags);
|
|
if (!buf) {
|
|
usb_free_urb(urb);
|
|
return -ENOMEM;
|
|
}
|
|
|
|
pipe = usb_rcvisocpipe(data->udev, data->isoc_rx_ep->bEndpointAddress);
|
|
|
|
usb_fill_int_urb(urb, data->udev, pipe, buf, size, btusb_isoc_complete,
|
|
hdev, data->isoc_rx_ep->bInterval);
|
|
|
|
urb->transfer_flags = URB_FREE_BUFFER | URB_ISO_ASAP;
|
|
|
|
__fill_isoc_descriptor(urb, size,
|
|
le16_to_cpu(data->isoc_rx_ep->wMaxPacketSize));
|
|
|
|
usb_anchor_urb(urb, &data->isoc_anchor);
|
|
|
|
err = usb_submit_urb(urb, mem_flags);
|
|
if (err < 0) {
|
|
if (err != -EPERM && err != -ENODEV)
|
|
BT_ERR("%s urb %p submission failed (%d)",
|
|
hdev->name, urb, -err);
|
|
usb_unanchor_urb(urb);
|
|
}
|
|
|
|
usb_free_urb(urb);
|
|
|
|
return err;
|
|
}
|
|
|
|
static void btusb_tx_complete(struct urb *urb)
|
|
{
|
|
struct sk_buff *skb = urb->context;
|
|
struct hci_dev *hdev = (struct hci_dev *) skb->dev;
|
|
struct btusb_data *data = hci_get_drvdata(hdev);
|
|
|
|
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:
|
|
spin_lock(&data->txlock);
|
|
data->tx_in_flight--;
|
|
spin_unlock(&data->txlock);
|
|
|
|
kfree(urb->setup_packet);
|
|
|
|
kfree_skb(skb);
|
|
}
|
|
|
|
static void btusb_isoc_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);
|
|
}
|
|
|
|
static int btusb_open(struct hci_dev *hdev)
|
|
{
|
|
struct btusb_data *data = hci_get_drvdata(hdev);
|
|
int err;
|
|
|
|
BT_DBG("%s", hdev->name);
|
|
|
|
err = usb_autopm_get_interface(data->intf);
|
|
if (err < 0)
|
|
return err;
|
|
|
|
data->intf->needs_remote_wakeup = 1;
|
|
|
|
if (test_and_set_bit(HCI_RUNNING, &hdev->flags))
|
|
goto done;
|
|
|
|
if (test_and_set_bit(BTUSB_INTR_RUNNING, &data->flags))
|
|
goto done;
|
|
|
|
err = btusb_submit_intr_urb(hdev, GFP_KERNEL);
|
|
if (err < 0)
|
|
goto failed;
|
|
|
|
err = btusb_submit_bulk_urb(hdev, GFP_KERNEL);
|
|
if (err < 0) {
|
|
usb_kill_anchored_urbs(&data->intr_anchor);
|
|
goto failed;
|
|
}
|
|
|
|
set_bit(BTUSB_BULK_RUNNING, &data->flags);
|
|
btusb_submit_bulk_urb(hdev, GFP_KERNEL);
|
|
|
|
done:
|
|
usb_autopm_put_interface(data->intf);
|
|
return 0;
|
|
|
|
failed:
|
|
clear_bit(BTUSB_INTR_RUNNING, &data->flags);
|
|
clear_bit(HCI_RUNNING, &hdev->flags);
|
|
usb_autopm_put_interface(data->intf);
|
|
return err;
|
|
}
|
|
|
|
static void btusb_stop_traffic(struct btusb_data *data)
|
|
{
|
|
usb_kill_anchored_urbs(&data->intr_anchor);
|
|
usb_kill_anchored_urbs(&data->bulk_anchor);
|
|
usb_kill_anchored_urbs(&data->isoc_anchor);
|
|
}
|
|
|
|
static int btusb_close(struct hci_dev *hdev)
|
|
{
|
|
struct btusb_data *data = hci_get_drvdata(hdev);
|
|
int err;
|
|
|
|
BT_DBG("%s", hdev->name);
|
|
|
|
if (!test_and_clear_bit(HCI_RUNNING, &hdev->flags))
|
|
return 0;
|
|
|
|
cancel_work_sync(&data->work);
|
|
cancel_work_sync(&data->waker);
|
|
|
|
clear_bit(BTUSB_ISOC_RUNNING, &data->flags);
|
|
clear_bit(BTUSB_BULK_RUNNING, &data->flags);
|
|
clear_bit(BTUSB_INTR_RUNNING, &data->flags);
|
|
|
|
btusb_stop_traffic(data);
|
|
err = usb_autopm_get_interface(data->intf);
|
|
if (err < 0)
|
|
goto failed;
|
|
|
|
data->intf->needs_remote_wakeup = 0;
|
|
usb_autopm_put_interface(data->intf);
|
|
|
|
failed:
|
|
usb_scuttle_anchored_urbs(&data->deferred);
|
|
return 0;
|
|
}
|
|
|
|
static int btusb_flush(struct hci_dev *hdev)
|
|
{
|
|
struct btusb_data *data = hci_get_drvdata(hdev);
|
|
|
|
BT_DBG("%s", hdev->name);
|
|
|
|
usb_kill_anchored_urbs(&data->tx_anchor);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int btusb_send_frame(struct hci_dev *hdev, struct sk_buff *skb)
|
|
{
|
|
struct btusb_data *data = hci_get_drvdata(hdev);
|
|
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;
|
|
|
|
skb->dev = (void *) hdev;
|
|
|
|
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)
|
|
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 || hci_conn_num(hdev, SCO_LINK) < 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);
|
|
|
|
usb_fill_int_urb(urb, data->udev, pipe,
|
|
skb->data, skb->len, btusb_isoc_tx_complete,
|
|
skb, data->isoc_tx_ep->bInterval);
|
|
|
|
urb->transfer_flags = URB_ISO_ASAP;
|
|
|
|
__fill_isoc_descriptor(urb, skb->len,
|
|
le16_to_cpu(data->isoc_tx_ep->wMaxPacketSize));
|
|
|
|
hdev->stat.sco_tx++;
|
|
goto skip_waking;
|
|
|
|
default:
|
|
return -EILSEQ;
|
|
}
|
|
|
|
err = inc_tx(data);
|
|
if (err) {
|
|
usb_anchor_urb(urb, &data->deferred);
|
|
schedule_work(&data->waker);
|
|
err = 0;
|
|
goto done;
|
|
}
|
|
|
|
skip_waking:
|
|
usb_anchor_urb(urb, &data->tx_anchor);
|
|
|
|
err = usb_submit_urb(urb, GFP_ATOMIC);
|
|
if (err < 0) {
|
|
if (err != -EPERM && err != -ENODEV)
|
|
BT_ERR("%s urb %p submission failed (%d)",
|
|
hdev->name, urb, -err);
|
|
kfree(urb->setup_packet);
|
|
usb_unanchor_urb(urb);
|
|
} else {
|
|
usb_mark_last_busy(data->udev);
|
|
}
|
|
|
|
done:
|
|
usb_free_urb(urb);
|
|
return err;
|
|
}
|
|
|
|
static void btusb_notify(struct hci_dev *hdev, unsigned int evt)
|
|
{
|
|
struct btusb_data *data = hci_get_drvdata(hdev);
|
|
|
|
BT_DBG("%s evt %d", hdev->name, evt);
|
|
|
|
if (hci_conn_num(hdev, SCO_LINK) != data->sco_num) {
|
|
data->sco_num = hci_conn_num(hdev, SCO_LINK);
|
|
schedule_work(&data->work);
|
|
}
|
|
}
|
|
|
|
static inline int __set_isoc_interface(struct hci_dev *hdev, int altsetting)
|
|
{
|
|
struct btusb_data *data = hci_get_drvdata(hdev);
|
|
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;
|
|
int new_alts;
|
|
int err;
|
|
|
|
if (data->sco_num > 0) {
|
|
if (!test_bit(BTUSB_DID_ISO_RESUME, &data->flags)) {
|
|
err = usb_autopm_get_interface(data->isoc ? data->isoc : data->intf);
|
|
if (err < 0) {
|
|
clear_bit(BTUSB_ISOC_RUNNING, &data->flags);
|
|
usb_kill_anchored_urbs(&data->isoc_anchor);
|
|
return;
|
|
}
|
|
|
|
set_bit(BTUSB_DID_ISO_RESUME, &data->flags);
|
|
}
|
|
|
|
if (hdev->voice_setting & 0x0020) {
|
|
static const int alts[3] = { 2, 4, 5 };
|
|
new_alts = alts[data->sco_num - 1];
|
|
} else {
|
|
new_alts = data->sco_num;
|
|
}
|
|
|
|
if (data->isoc_altsetting != new_alts) {
|
|
clear_bit(BTUSB_ISOC_RUNNING, &data->flags);
|
|
usb_kill_anchored_urbs(&data->isoc_anchor);
|
|
|
|
if (__set_isoc_interface(hdev, new_alts) < 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);
|
|
if (test_and_clear_bit(BTUSB_DID_ISO_RESUME, &data->flags))
|
|
usb_autopm_put_interface(data->isoc ? data->isoc : data->intf);
|
|
}
|
|
}
|
|
|
|
static void btusb_waker(struct work_struct *work)
|
|
{
|
|
struct btusb_data *data = container_of(work, struct btusb_data, waker);
|
|
int err;
|
|
|
|
err = usb_autopm_get_interface(data->intf);
|
|
if (err < 0)
|
|
return;
|
|
|
|
usb_autopm_put_interface(data->intf);
|
|
}
|
|
|
|
static int btusb_setup_bcm92035(struct hci_dev *hdev)
|
|
{
|
|
struct sk_buff *skb;
|
|
u8 val = 0x00;
|
|
|
|
BT_DBG("%s", hdev->name);
|
|
|
|
skb = __hci_cmd_sync(hdev, 0xfc3b, 1, &val, HCI_INIT_TIMEOUT);
|
|
if (IS_ERR(skb))
|
|
BT_ERR("BCM92035 command failed (%ld)", -PTR_ERR(skb));
|
|
else
|
|
kfree_skb(skb);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int btusb_setup_csr(struct hci_dev *hdev)
|
|
{
|
|
struct hci_rp_read_local_version *rp;
|
|
struct sk_buff *skb;
|
|
int ret;
|
|
|
|
BT_DBG("%s", hdev->name);
|
|
|
|
skb = __hci_cmd_sync(hdev, HCI_OP_READ_LOCAL_VERSION, 0, NULL,
|
|
HCI_INIT_TIMEOUT);
|
|
if (IS_ERR(skb)) {
|
|
BT_ERR("Reading local version failed (%ld)", -PTR_ERR(skb));
|
|
return -PTR_ERR(skb);
|
|
}
|
|
|
|
rp = (struct hci_rp_read_local_version *) skb->data;
|
|
|
|
if (!rp->status) {
|
|
if (le16_to_cpu(rp->manufacturer) != 10) {
|
|
/* Clear the reset quirk since this is not an actual
|
|
* early Bluetooth 1.1 device from CSR.
|
|
*/
|
|
clear_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks);
|
|
|
|
/* These fake CSR controllers have all a broken
|
|
* stored link key handling and so just disable it.
|
|
*/
|
|
set_bit(HCI_QUIRK_BROKEN_STORED_LINK_KEY,
|
|
&hdev->quirks);
|
|
}
|
|
}
|
|
|
|
ret = -bt_to_errno(rp->status);
|
|
|
|
kfree_skb(skb);
|
|
|
|
return ret;
|
|
}
|
|
|
|
struct intel_version {
|
|
u8 status;
|
|
u8 hw_platform;
|
|
u8 hw_variant;
|
|
u8 hw_revision;
|
|
u8 fw_variant;
|
|
u8 fw_revision;
|
|
u8 fw_build_num;
|
|
u8 fw_build_ww;
|
|
u8 fw_build_yy;
|
|
u8 fw_patch_num;
|
|
} __packed;
|
|
|
|
static const struct firmware *btusb_setup_intel_get_fw(struct hci_dev *hdev,
|
|
struct intel_version *ver)
|
|
{
|
|
const struct firmware *fw;
|
|
char fwname[64];
|
|
int ret;
|
|
|
|
snprintf(fwname, sizeof(fwname),
|
|
"intel/ibt-hw-%x.%x.%x-fw-%x.%x.%x.%x.%x.bseq",
|
|
ver->hw_platform, ver->hw_variant, ver->hw_revision,
|
|
ver->fw_variant, ver->fw_revision, ver->fw_build_num,
|
|
ver->fw_build_ww, ver->fw_build_yy);
|
|
|
|
ret = request_firmware(&fw, fwname, &hdev->dev);
|
|
if (ret < 0) {
|
|
if (ret == -EINVAL) {
|
|
BT_ERR("%s Intel firmware file request failed (%d)",
|
|
hdev->name, ret);
|
|
return NULL;
|
|
}
|
|
|
|
BT_ERR("%s failed to open Intel firmware file: %s(%d)",
|
|
hdev->name, fwname, ret);
|
|
|
|
/* If the correct firmware patch file is not found, use the
|
|
* default firmware patch file instead
|
|
*/
|
|
snprintf(fwname, sizeof(fwname), "intel/ibt-hw-%x.%x.bseq",
|
|
ver->hw_platform, ver->hw_variant);
|
|
if (request_firmware(&fw, fwname, &hdev->dev) < 0) {
|
|
BT_ERR("%s failed to open default Intel fw file: %s",
|
|
hdev->name, fwname);
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
BT_INFO("%s: Intel Bluetooth firmware file: %s", hdev->name, fwname);
|
|
|
|
return fw;
|
|
}
|
|
|
|
static int btusb_setup_intel_patching(struct hci_dev *hdev,
|
|
const struct firmware *fw,
|
|
const u8 **fw_ptr, int *disable_patch)
|
|
{
|
|
struct sk_buff *skb;
|
|
struct hci_command_hdr *cmd;
|
|
const u8 *cmd_param;
|
|
struct hci_event_hdr *evt = NULL;
|
|
const u8 *evt_param = NULL;
|
|
int remain = fw->size - (*fw_ptr - fw->data);
|
|
|
|
/* The first byte indicates the types of the patch command or event.
|
|
* 0x01 means HCI command and 0x02 is HCI event. If the first bytes
|
|
* in the current firmware buffer doesn't start with 0x01 or
|
|
* the size of remain buffer is smaller than HCI command header,
|
|
* the firmware file is corrupted and it should stop the patching
|
|
* process.
|
|
*/
|
|
if (remain > HCI_COMMAND_HDR_SIZE && *fw_ptr[0] != 0x01) {
|
|
BT_ERR("%s Intel fw corrupted: invalid cmd read", hdev->name);
|
|
return -EINVAL;
|
|
}
|
|
(*fw_ptr)++;
|
|
remain--;
|
|
|
|
cmd = (struct hci_command_hdr *)(*fw_ptr);
|
|
*fw_ptr += sizeof(*cmd);
|
|
remain -= sizeof(*cmd);
|
|
|
|
/* Ensure that the remain firmware data is long enough than the length
|
|
* of command parameter. If not, the firmware file is corrupted.
|
|
*/
|
|
if (remain < cmd->plen) {
|
|
BT_ERR("%s Intel fw corrupted: invalid cmd len", hdev->name);
|
|
return -EFAULT;
|
|
}
|
|
|
|
/* If there is a command that loads a patch in the firmware
|
|
* file, then enable the patch upon success, otherwise just
|
|
* disable the manufacturer mode, for example patch activation
|
|
* is not required when the default firmware patch file is used
|
|
* because there are no patch data to load.
|
|
*/
|
|
if (*disable_patch && le16_to_cpu(cmd->opcode) == 0xfc8e)
|
|
*disable_patch = 0;
|
|
|
|
cmd_param = *fw_ptr;
|
|
*fw_ptr += cmd->plen;
|
|
remain -= cmd->plen;
|
|
|
|
/* This reads the expected events when the above command is sent to the
|
|
* device. Some vendor commands expects more than one events, for
|
|
* example command status event followed by vendor specific event.
|
|
* For this case, it only keeps the last expected event. so the command
|
|
* can be sent with __hci_cmd_sync_ev() which returns the sk_buff of
|
|
* last expected event.
|
|
*/
|
|
while (remain > HCI_EVENT_HDR_SIZE && *fw_ptr[0] == 0x02) {
|
|
(*fw_ptr)++;
|
|
remain--;
|
|
|
|
evt = (struct hci_event_hdr *)(*fw_ptr);
|
|
*fw_ptr += sizeof(*evt);
|
|
remain -= sizeof(*evt);
|
|
|
|
if (remain < evt->plen) {
|
|
BT_ERR("%s Intel fw corrupted: invalid evt len",
|
|
hdev->name);
|
|
return -EFAULT;
|
|
}
|
|
|
|
evt_param = *fw_ptr;
|
|
*fw_ptr += evt->plen;
|
|
remain -= evt->plen;
|
|
}
|
|
|
|
/* Every HCI commands in the firmware file has its correspond event.
|
|
* If event is not found or remain is smaller than zero, the firmware
|
|
* file is corrupted.
|
|
*/
|
|
if (!evt || !evt_param || remain < 0) {
|
|
BT_ERR("%s Intel fw corrupted: invalid evt read", hdev->name);
|
|
return -EFAULT;
|
|
}
|
|
|
|
skb = __hci_cmd_sync_ev(hdev, le16_to_cpu(cmd->opcode), cmd->plen,
|
|
cmd_param, evt->evt, HCI_INIT_TIMEOUT);
|
|
if (IS_ERR(skb)) {
|
|
BT_ERR("%s sending Intel patch command (0x%4.4x) failed (%ld)",
|
|
hdev->name, cmd->opcode, PTR_ERR(skb));
|
|
return PTR_ERR(skb);
|
|
}
|
|
|
|
/* It ensures that the returned event matches the event data read from
|
|
* the firmware file. At fist, it checks the length and then
|
|
* the contents of the event.
|
|
*/
|
|
if (skb->len != evt->plen) {
|
|
BT_ERR("%s mismatch event length (opcode 0x%4.4x)", hdev->name,
|
|
le16_to_cpu(cmd->opcode));
|
|
kfree_skb(skb);
|
|
return -EFAULT;
|
|
}
|
|
|
|
if (memcmp(skb->data, evt_param, evt->plen)) {
|
|
BT_ERR("%s mismatch event parameter (opcode 0x%4.4x)",
|
|
hdev->name, le16_to_cpu(cmd->opcode));
|
|
kfree_skb(skb);
|
|
return -EFAULT;
|
|
}
|
|
kfree_skb(skb);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int btusb_setup_intel(struct hci_dev *hdev)
|
|
{
|
|
struct sk_buff *skb;
|
|
const struct firmware *fw;
|
|
const u8 *fw_ptr;
|
|
int disable_patch;
|
|
struct intel_version *ver;
|
|
|
|
const u8 mfg_enable[] = { 0x01, 0x00 };
|
|
const u8 mfg_disable[] = { 0x00, 0x00 };
|
|
const u8 mfg_reset_deactivate[] = { 0x00, 0x01 };
|
|
const u8 mfg_reset_activate[] = { 0x00, 0x02 };
|
|
|
|
BT_DBG("%s", hdev->name);
|
|
|
|
/* The controller has a bug with the first HCI command sent to it
|
|
* returning number of completed commands as zero. This would stall the
|
|
* command processing in the Bluetooth core.
|
|
*
|
|
* As a workaround, send HCI Reset command first which will reset the
|
|
* number of completed commands and allow normal command processing
|
|
* from now on.
|
|
*/
|
|
skb = __hci_cmd_sync(hdev, HCI_OP_RESET, 0, NULL, HCI_INIT_TIMEOUT);
|
|
if (IS_ERR(skb)) {
|
|
BT_ERR("%s sending initial HCI reset command failed (%ld)",
|
|
hdev->name, PTR_ERR(skb));
|
|
return PTR_ERR(skb);
|
|
}
|
|
kfree_skb(skb);
|
|
|
|
/* Read Intel specific controller version first to allow selection of
|
|
* which firmware file to load.
|
|
*
|
|
* The returned information are hardware variant and revision plus
|
|
* firmware variant, revision and build number.
|
|
*/
|
|
skb = __hci_cmd_sync(hdev, 0xfc05, 0, NULL, HCI_INIT_TIMEOUT);
|
|
if (IS_ERR(skb)) {
|
|
BT_ERR("%s reading Intel fw version command failed (%ld)",
|
|
hdev->name, PTR_ERR(skb));
|
|
return PTR_ERR(skb);
|
|
}
|
|
|
|
if (skb->len != sizeof(*ver)) {
|
|
BT_ERR("%s Intel version event length mismatch", hdev->name);
|
|
kfree_skb(skb);
|
|
return -EIO;
|
|
}
|
|
|
|
ver = (struct intel_version *)skb->data;
|
|
if (ver->status) {
|
|
BT_ERR("%s Intel fw version event failed (%02x)", hdev->name,
|
|
ver->status);
|
|
kfree_skb(skb);
|
|
return -bt_to_errno(ver->status);
|
|
}
|
|
|
|
BT_INFO("%s: read Intel version: %02x%02x%02x%02x%02x%02x%02x%02x%02x",
|
|
hdev->name, ver->hw_platform, ver->hw_variant,
|
|
ver->hw_revision, ver->fw_variant, ver->fw_revision,
|
|
ver->fw_build_num, ver->fw_build_ww, ver->fw_build_yy,
|
|
ver->fw_patch_num);
|
|
|
|
/* fw_patch_num indicates the version of patch the device currently
|
|
* have. If there is no patch data in the device, it is always 0x00.
|
|
* So, if it is other than 0x00, no need to patch the deivce again.
|
|
*/
|
|
if (ver->fw_patch_num) {
|
|
BT_INFO("%s: Intel device is already patched. patch num: %02x",
|
|
hdev->name, ver->fw_patch_num);
|
|
kfree_skb(skb);
|
|
return 0;
|
|
}
|
|
|
|
/* Opens the firmware patch file based on the firmware version read
|
|
* from the controller. If it fails to open the matching firmware
|
|
* patch file, it tries to open the default firmware patch file.
|
|
* If no patch file is found, allow the device to operate without
|
|
* a patch.
|
|
*/
|
|
fw = btusb_setup_intel_get_fw(hdev, ver);
|
|
if (!fw) {
|
|
kfree_skb(skb);
|
|
return 0;
|
|
}
|
|
fw_ptr = fw->data;
|
|
|
|
/* This Intel specific command enables the manufacturer mode of the
|
|
* controller.
|
|
*
|
|
* Only while this mode is enabled, the driver can download the
|
|
* firmware patch data and configuration parameters.
|
|
*/
|
|
skb = __hci_cmd_sync(hdev, 0xfc11, 2, mfg_enable, HCI_INIT_TIMEOUT);
|
|
if (IS_ERR(skb)) {
|
|
BT_ERR("%s entering Intel manufacturer mode failed (%ld)",
|
|
hdev->name, PTR_ERR(skb));
|
|
release_firmware(fw);
|
|
return PTR_ERR(skb);
|
|
}
|
|
|
|
if (skb->data[0]) {
|
|
u8 evt_status = skb->data[0];
|
|
BT_ERR("%s enable Intel manufacturer mode event failed (%02x)",
|
|
hdev->name, evt_status);
|
|
kfree_skb(skb);
|
|
release_firmware(fw);
|
|
return -bt_to_errno(evt_status);
|
|
}
|
|
kfree_skb(skb);
|
|
|
|
disable_patch = 1;
|
|
|
|
/* The firmware data file consists of list of Intel specific HCI
|
|
* commands and its expected events. The first byte indicates the
|
|
* type of the message, either HCI command or HCI event.
|
|
*
|
|
* It reads the command and its expected event from the firmware file,
|
|
* and send to the controller. Once __hci_cmd_sync_ev() returns,
|
|
* the returned event is compared with the event read from the firmware
|
|
* file and it will continue until all the messages are downloaded to
|
|
* the controller.
|
|
*
|
|
* Once the firmware patching is completed successfully,
|
|
* the manufacturer mode is disabled with reset and activating the
|
|
* downloaded patch.
|
|
*
|
|
* If the firmware patching fails, the manufacturer mode is
|
|
* disabled with reset and deactivating the patch.
|
|
*
|
|
* If the default patch file is used, no reset is done when disabling
|
|
* the manufacturer.
|
|
*/
|
|
while (fw->size > fw_ptr - fw->data) {
|
|
int ret;
|
|
|
|
ret = btusb_setup_intel_patching(hdev, fw, &fw_ptr,
|
|
&disable_patch);
|
|
if (ret < 0)
|
|
goto exit_mfg_deactivate;
|
|
}
|
|
|
|
release_firmware(fw);
|
|
|
|
if (disable_patch)
|
|
goto exit_mfg_disable;
|
|
|
|
/* Patching completed successfully and disable the manufacturer mode
|
|
* with reset and activate the downloaded firmware patches.
|
|
*/
|
|
skb = __hci_cmd_sync(hdev, 0xfc11, sizeof(mfg_reset_activate),
|
|
mfg_reset_activate, HCI_INIT_TIMEOUT);
|
|
if (IS_ERR(skb)) {
|
|
BT_ERR("%s exiting Intel manufacturer mode failed (%ld)",
|
|
hdev->name, PTR_ERR(skb));
|
|
return PTR_ERR(skb);
|
|
}
|
|
kfree_skb(skb);
|
|
|
|
BT_INFO("%s: Intel Bluetooth firmware patch completed and activated",
|
|
hdev->name);
|
|
|
|
return 0;
|
|
|
|
exit_mfg_disable:
|
|
/* Disable the manufacturer mode without reset */
|
|
skb = __hci_cmd_sync(hdev, 0xfc11, sizeof(mfg_disable), mfg_disable,
|
|
HCI_INIT_TIMEOUT);
|
|
if (IS_ERR(skb)) {
|
|
BT_ERR("%s exiting Intel manufacturer mode failed (%ld)",
|
|
hdev->name, PTR_ERR(skb));
|
|
return PTR_ERR(skb);
|
|
}
|
|
kfree_skb(skb);
|
|
|
|
BT_INFO("%s: Intel Bluetooth firmware patch completed", hdev->name);
|
|
return 0;
|
|
|
|
exit_mfg_deactivate:
|
|
release_firmware(fw);
|
|
|
|
/* Patching failed. Disable the manufacturer mode with reset and
|
|
* deactivate the downloaded firmware patches.
|
|
*/
|
|
skb = __hci_cmd_sync(hdev, 0xfc11, sizeof(mfg_reset_deactivate),
|
|
mfg_reset_deactivate, HCI_INIT_TIMEOUT);
|
|
if (IS_ERR(skb)) {
|
|
BT_ERR("%s exiting Intel manufacturer mode failed (%ld)",
|
|
hdev->name, PTR_ERR(skb));
|
|
return PTR_ERR(skb);
|
|
}
|
|
kfree_skb(skb);
|
|
|
|
BT_INFO("%s: Intel Bluetooth firmware patch completed and deactivated",
|
|
hdev->name);
|
|
|
|
return 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;
|
|
|
|
if (id->driver_info & BTUSB_ATH3012) {
|
|
struct usb_device *udev = interface_to_usbdev(intf);
|
|
|
|
/* Old firmware would otherwise let ath3k driver load
|
|
* patch and sysconfig files */
|
|
if (le16_to_cpu(udev->descriptor.bcdDevice) <= 0x0001)
|
|
return -ENODEV;
|
|
}
|
|
|
|
data = devm_kzalloc(&intf->dev, 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)
|
|
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_WORK(&data->waker, btusb_waker);
|
|
spin_lock_init(&data->txlock);
|
|
|
|
init_usb_anchor(&data->tx_anchor);
|
|
init_usb_anchor(&data->intr_anchor);
|
|
init_usb_anchor(&data->bulk_anchor);
|
|
init_usb_anchor(&data->isoc_anchor);
|
|
init_usb_anchor(&data->deferred);
|
|
|
|
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 = btusb_open;
|
|
hdev->close = btusb_close;
|
|
hdev->flush = btusb_flush;
|
|
hdev->send = btusb_send_frame;
|
|
hdev->notify = btusb_notify;
|
|
|
|
if (id->driver_info & BTUSB_BCM92035)
|
|
hdev->setup = btusb_setup_bcm92035;
|
|
|
|
if (id->driver_info & BTUSB_INTEL) {
|
|
usb_enable_autosuspend(data->udev);
|
|
hdev->setup = btusb_setup_intel;
|
|
}
|
|
|
|
/* Interface numbers are hardcoded in the specification */
|
|
data->isoc = usb_ifnum_to_if(data->udev, 1);
|
|
|
|
if (!reset)
|
|
set_bit(HCI_QUIRK_RESET_ON_CLOSE, &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_RESET_ON_CLOSE, &hdev->quirks);
|
|
}
|
|
|
|
if (id->driver_info & BTUSB_CSR) {
|
|
struct usb_device *udev = data->udev;
|
|
u16 bcdDevice = le16_to_cpu(udev->descriptor.bcdDevice);
|
|
|
|
/* Old firmware would otherwise execute USB reset */
|
|
if (bcdDevice < 0x117)
|
|
set_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks);
|
|
|
|
/* Fake CSR devices with broken commands */
|
|
if (bcdDevice <= 0x100)
|
|
hdev->setup = btusb_setup_csr;
|
|
}
|
|
|
|
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 (data->isoc) {
|
|
err = usb_driver_claim_interface(&btusb_driver,
|
|
data->isoc, data);
|
|
if (err < 0) {
|
|
hci_free_dev(hdev);
|
|
return err;
|
|
}
|
|
}
|
|
|
|
err = hci_register_dev(hdev);
|
|
if (err < 0) {
|
|
hci_free_dev(hdev);
|
|
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;
|
|
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_free_dev(hdev);
|
|
}
|
|
|
|
#ifdef CONFIG_PM
|
|
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;
|
|
|
|
spin_lock_irq(&data->txlock);
|
|
if (!(PMSG_IS_AUTO(message) && data->tx_in_flight)) {
|
|
set_bit(BTUSB_SUSPENDING, &data->flags);
|
|
spin_unlock_irq(&data->txlock);
|
|
} else {
|
|
spin_unlock_irq(&data->txlock);
|
|
data->suspend_count--;
|
|
return -EBUSY;
|
|
}
|
|
|
|
cancel_work_sync(&data->work);
|
|
|
|
btusb_stop_traffic(data);
|
|
usb_kill_anchored_urbs(&data->tx_anchor);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void play_deferred(struct btusb_data *data)
|
|
{
|
|
struct urb *urb;
|
|
int err;
|
|
|
|
while ((urb = usb_get_from_anchor(&data->deferred))) {
|
|
err = usb_submit_urb(urb, GFP_ATOMIC);
|
|
if (err < 0)
|
|
break;
|
|
|
|
data->tx_in_flight++;
|
|
}
|
|
usb_scuttle_anchored_urbs(&data->deferred);
|
|
}
|
|
|
|
static int btusb_resume(struct usb_interface *intf)
|
|
{
|
|
struct btusb_data *data = usb_get_intfdata(intf);
|
|
struct hci_dev *hdev = data->hdev;
|
|
int err = 0;
|
|
|
|
BT_DBG("intf %p", intf);
|
|
|
|
if (--data->suspend_count)
|
|
return 0;
|
|
|
|
if (!test_bit(HCI_RUNNING, &hdev->flags))
|
|
goto done;
|
|
|
|
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);
|
|
goto failed;
|
|
}
|
|
}
|
|
|
|
if (test_bit(BTUSB_BULK_RUNNING, &data->flags)) {
|
|
err = btusb_submit_bulk_urb(hdev, GFP_NOIO);
|
|
if (err < 0) {
|
|
clear_bit(BTUSB_BULK_RUNNING, &data->flags);
|
|
goto failed;
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
spin_lock_irq(&data->txlock);
|
|
play_deferred(data);
|
|
clear_bit(BTUSB_SUSPENDING, &data->flags);
|
|
spin_unlock_irq(&data->txlock);
|
|
schedule_work(&data->work);
|
|
|
|
return 0;
|
|
|
|
failed:
|
|
usb_scuttle_anchored_urbs(&data->deferred);
|
|
done:
|
|
spin_lock_irq(&data->txlock);
|
|
clear_bit(BTUSB_SUSPENDING, &data->flags);
|
|
spin_unlock_irq(&data->txlock);
|
|
|
|
return err;
|
|
}
|
|
#endif
|
|
|
|
static struct usb_driver btusb_driver = {
|
|
.name = "btusb",
|
|
.probe = btusb_probe,
|
|
.disconnect = btusb_disconnect,
|
|
#ifdef CONFIG_PM
|
|
.suspend = btusb_suspend,
|
|
.resume = btusb_resume,
|
|
#endif
|
|
.id_table = btusb_table,
|
|
.supports_autosuspend = 1,
|
|
.disable_hub_initiated_lpm = 1,
|
|
};
|
|
|
|
module_usb_driver(btusb_driver);
|
|
|
|
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");
|