brintos / linux-shallow public Read only

1// SPDX-License-Identifier: GPL-2.0-or-later2/*3 *4 *  Generic Bluetooth USB driver5 *6 *  Copyright (C) 2005-2008  Marcel Holtmann <marcel@holtmann.org>7 */8 9#include <linux/dmi.h>10#include <linux/module.h>11#include <linux/usb.h>12#include <linux/usb/quirks.h>13#include <linux/firmware.h>14#include <linux/iopoll.h>15#include <linux/of_device.h>16#include <linux/of_irq.h>17#include <linux/suspend.h>18#include <linux/gpio/consumer.h>19#include <linux/debugfs.h>20#include <linux/unaligned.h>21 22#include <net/bluetooth/bluetooth.h>23#include <net/bluetooth/hci_core.h>24 25#include "btintel.h"26#include "btbcm.h"27#include "btrtl.h"28#include "btmtk.h"29 30#define VERSION "0.8"31 32static bool disable_scofix;33static bool force_scofix;34static bool enable_autosuspend = IS_ENABLED(CONFIG_BT_HCIBTUSB_AUTOSUSPEND);35static bool enable_poll_sync = IS_ENABLED(CONFIG_BT_HCIBTUSB_POLL_SYNC);36static bool reset = true;37 38static struct usb_driver btusb_driver;39 40#define BTUSB_IGNORE			BIT(0)41#define BTUSB_DIGIANSWER		BIT(1)42#define BTUSB_CSR			BIT(2)43#define BTUSB_SNIFFER			BIT(3)44#define BTUSB_BCM92035			BIT(4)45#define BTUSB_BROKEN_ISOC		BIT(5)46#define BTUSB_WRONG_SCO_MTU		BIT(6)47#define BTUSB_ATH3012			BIT(7)48#define BTUSB_INTEL_COMBINED		BIT(8)49#define BTUSB_INTEL_BOOT		BIT(9)50#define BTUSB_BCM_PATCHRAM		BIT(10)51#define BTUSB_MARVELL			BIT(11)52#define BTUSB_SWAVE			BIT(12)53#define BTUSB_AMP			BIT(13)54#define BTUSB_QCA_ROME			BIT(14)55#define BTUSB_BCM_APPLE			BIT(15)56#define BTUSB_REALTEK			BIT(16)57#define BTUSB_BCM2045			BIT(17)58#define BTUSB_IFNUM_2			BIT(18)59#define BTUSB_CW6622			BIT(19)60#define BTUSB_MEDIATEK			BIT(20)61#define BTUSB_WIDEBAND_SPEECH		BIT(21)62#define BTUSB_INVALID_LE_STATES		BIT(22)63#define BTUSB_QCA_WCN6855		BIT(23)64#define BTUSB_INTEL_BROKEN_SHUTDOWN_LED	BIT(24)65#define BTUSB_INTEL_BROKEN_INITIAL_NCMD BIT(25)66#define BTUSB_INTEL_NO_WBS_SUPPORT	BIT(26)67#define BTUSB_ACTIONS_SEMI		BIT(27)68 69static const struct usb_device_id btusb_table[] = {70	/* Generic Bluetooth USB device */71	{ USB_DEVICE_INFO(0xe0, 0x01, 0x01) },72 73	/* Generic Bluetooth AMP device */74	{ USB_DEVICE_INFO(0xe0, 0x01, 0x04), .driver_info = BTUSB_AMP },75 76	/* Generic Bluetooth USB interface */77	{ USB_INTERFACE_INFO(0xe0, 0x01, 0x01) },78 79	/* Apple-specific (Broadcom) devices */80	{ USB_VENDOR_AND_INTERFACE_INFO(0x05ac, 0xff, 0x01, 0x01),81	  .driver_info = BTUSB_BCM_APPLE | BTUSB_IFNUM_2 },82 83	/* MediaTek MT76x0E */84	{ USB_DEVICE(0x0e8d, 0x763f) },85 86	/* Broadcom SoftSailing reporting vendor specific */87	{ USB_DEVICE(0x0a5c, 0x21e1) },88 89	/* Apple MacBookPro 7,1 */90	{ USB_DEVICE(0x05ac, 0x8213) },91 92	/* Apple iMac11,1 */93	{ USB_DEVICE(0x05ac, 0x8215) },94 95	/* Apple MacBookPro6,2 */96	{ USB_DEVICE(0x05ac, 0x8218) },97 98	/* Apple MacBookAir3,1, MacBookAir3,2 */99	{ USB_DEVICE(0x05ac, 0x821b) },100 101	/* Apple MacBookAir4,1 */102	{ USB_DEVICE(0x05ac, 0x821f) },103 104	/* Apple MacBookPro8,2 */105	{ USB_DEVICE(0x05ac, 0x821a) },106 107	/* Apple MacMini5,1 */108	{ USB_DEVICE(0x05ac, 0x8281) },109 110	/* AVM BlueFRITZ! USB v2.0 */111	{ USB_DEVICE(0x057c, 0x3800), .driver_info = BTUSB_SWAVE },112 113	/* Bluetooth Ultraport Module from IBM */114	{ USB_DEVICE(0x04bf, 0x030a) },115 116	/* ALPS Modules with non-standard id */117	{ USB_DEVICE(0x044e, 0x3001) },118	{ USB_DEVICE(0x044e, 0x3002) },119 120	/* Ericsson with non-standard id */121	{ USB_DEVICE(0x0bdb, 0x1002) },122 123	/* Canyon CN-BTU1 with HID interfaces */124	{ USB_DEVICE(0x0c10, 0x0000) },125 126	/* Broadcom BCM20702B0 (Dynex/Insignia) */127	{ USB_DEVICE(0x19ff, 0x0239), .driver_info = BTUSB_BCM_PATCHRAM },128 129	/* Broadcom BCM43142A0 (Foxconn/Lenovo) */130	{ USB_VENDOR_AND_INTERFACE_INFO(0x105b, 0xff, 0x01, 0x01),131	  .driver_info = BTUSB_BCM_PATCHRAM },132 133	/* Broadcom BCM920703 (HTC Vive) */134	{ USB_VENDOR_AND_INTERFACE_INFO(0x0bb4, 0xff, 0x01, 0x01),135	  .driver_info = BTUSB_BCM_PATCHRAM },136 137	/* Foxconn - Hon Hai */138	{ USB_VENDOR_AND_INTERFACE_INFO(0x0489, 0xff, 0x01, 0x01),139	  .driver_info = BTUSB_BCM_PATCHRAM },140 141	/* Lite-On Technology - Broadcom based */142	{ USB_VENDOR_AND_INTERFACE_INFO(0x04ca, 0xff, 0x01, 0x01),143	  .driver_info = BTUSB_BCM_PATCHRAM },144 145	/* Broadcom devices with vendor specific id */146	{ USB_VENDOR_AND_INTERFACE_INFO(0x0a5c, 0xff, 0x01, 0x01),147	  .driver_info = BTUSB_BCM_PATCHRAM },148 149	/* ASUSTek Computer - Broadcom based */150	{ USB_VENDOR_AND_INTERFACE_INFO(0x0b05, 0xff, 0x01, 0x01),151	  .driver_info = BTUSB_BCM_PATCHRAM },152 153	/* Belkin F8065bf - Broadcom based */154	{ USB_VENDOR_AND_INTERFACE_INFO(0x050d, 0xff, 0x01, 0x01),155	  .driver_info = BTUSB_BCM_PATCHRAM },156 157	/* IMC Networks - Broadcom based */158	{ USB_VENDOR_AND_INTERFACE_INFO(0x13d3, 0xff, 0x01, 0x01),159	  .driver_info = BTUSB_BCM_PATCHRAM },160 161	/* Dell Computer - Broadcom based  */162	{ USB_VENDOR_AND_INTERFACE_INFO(0x413c, 0xff, 0x01, 0x01),163	  .driver_info = BTUSB_BCM_PATCHRAM },164 165	/* Toshiba Corp - Broadcom based */166	{ USB_VENDOR_AND_INTERFACE_INFO(0x0930, 0xff, 0x01, 0x01),167	  .driver_info = BTUSB_BCM_PATCHRAM },168 169	/* Intel Bluetooth USB Bootloader (RAM module) */170	{ USB_DEVICE(0x8087, 0x0a5a),171	  .driver_info = BTUSB_INTEL_BOOT | BTUSB_BROKEN_ISOC },172 173	{ }	/* Terminating entry */174};175 176MODULE_DEVICE_TABLE(usb, btusb_table);177 178static const struct usb_device_id quirks_table[] = {179	/* CSR BlueCore devices */180	{ USB_DEVICE(0x0a12, 0x0001), .driver_info = BTUSB_CSR },181 182	/* Broadcom BCM2033 without firmware */183	{ USB_DEVICE(0x0a5c, 0x2033), .driver_info = BTUSB_IGNORE },184 185	/* Broadcom BCM2045 devices */186	{ USB_DEVICE(0x0a5c, 0x2045), .driver_info = BTUSB_BCM2045 },187 188	/* Atheros 3011 with sflash firmware */189	{ USB_DEVICE(0x0489, 0xe027), .driver_info = BTUSB_IGNORE },190	{ USB_DEVICE(0x0489, 0xe03d), .driver_info = BTUSB_IGNORE },191	{ USB_DEVICE(0x04f2, 0xaff1), .driver_info = BTUSB_IGNORE },192	{ USB_DEVICE(0x0930, 0x0215), .driver_info = BTUSB_IGNORE },193	{ USB_DEVICE(0x0cf3, 0x3002), .driver_info = BTUSB_IGNORE },194	{ USB_DEVICE(0x0cf3, 0xe019), .driver_info = BTUSB_IGNORE },195	{ USB_DEVICE(0x13d3, 0x3304), .driver_info = BTUSB_IGNORE },196 197	/* Atheros AR9285 Malbec with sflash firmware */198	{ USB_DEVICE(0x03f0, 0x311d), .driver_info = BTUSB_IGNORE },199 200	/* Atheros 3012 with sflash firmware */201	{ USB_DEVICE(0x0489, 0xe04d), .driver_info = BTUSB_ATH3012 },202	{ USB_DEVICE(0x0489, 0xe04e), .driver_info = BTUSB_ATH3012 },203	{ USB_DEVICE(0x0489, 0xe056), .driver_info = BTUSB_ATH3012 },204	{ USB_DEVICE(0x0489, 0xe057), .driver_info = BTUSB_ATH3012 },205	{ USB_DEVICE(0x0489, 0xe05f), .driver_info = BTUSB_ATH3012 },206	{ USB_DEVICE(0x0489, 0xe076), .driver_info = BTUSB_ATH3012 },207	{ USB_DEVICE(0x0489, 0xe078), .driver_info = BTUSB_ATH3012 },208	{ USB_DEVICE(0x0489, 0xe095), .driver_info = BTUSB_ATH3012 },209	{ USB_DEVICE(0x04c5, 0x1330), .driver_info = BTUSB_ATH3012 },210	{ USB_DEVICE(0x04ca, 0x3004), .driver_info = BTUSB_ATH3012 },211	{ USB_DEVICE(0x04ca, 0x3005), .driver_info = BTUSB_ATH3012 },212	{ USB_DEVICE(0x04ca, 0x3006), .driver_info = BTUSB_ATH3012 },213	{ USB_DEVICE(0x04ca, 0x3007), .driver_info = BTUSB_ATH3012 },214	{ USB_DEVICE(0x04ca, 0x3008), .driver_info = BTUSB_ATH3012 },215	{ USB_DEVICE(0x04ca, 0x300b), .driver_info = BTUSB_ATH3012 },216	{ USB_DEVICE(0x04ca, 0x300d), .driver_info = BTUSB_ATH3012 },217	{ USB_DEVICE(0x04ca, 0x300f), .driver_info = BTUSB_ATH3012 },218	{ USB_DEVICE(0x04ca, 0x3010), .driver_info = BTUSB_ATH3012 },219	{ USB_DEVICE(0x04ca, 0x3014), .driver_info = BTUSB_ATH3012 },220	{ USB_DEVICE(0x04ca, 0x3018), .driver_info = BTUSB_ATH3012 },221	{ USB_DEVICE(0x0930, 0x0219), .driver_info = BTUSB_ATH3012 },222	{ USB_DEVICE(0x0930, 0x021c), .driver_info = BTUSB_ATH3012 },223	{ USB_DEVICE(0x0930, 0x0220), .driver_info = BTUSB_ATH3012 },224	{ USB_DEVICE(0x0930, 0x0227), .driver_info = BTUSB_ATH3012 },225	{ USB_DEVICE(0x0b05, 0x17d0), .driver_info = BTUSB_ATH3012 },226	{ USB_DEVICE(0x0cf3, 0x0036), .driver_info = BTUSB_ATH3012 },227	{ USB_DEVICE(0x0cf3, 0x3004), .driver_info = BTUSB_ATH3012 },228	{ USB_DEVICE(0x0cf3, 0x3008), .driver_info = BTUSB_ATH3012 },229	{ USB_DEVICE(0x0cf3, 0x311d), .driver_info = BTUSB_ATH3012 },230	{ USB_DEVICE(0x0cf3, 0x311e), .driver_info = BTUSB_ATH3012 },231	{ USB_DEVICE(0x0cf3, 0x311f), .driver_info = BTUSB_ATH3012 },232	{ USB_DEVICE(0x0cf3, 0x3121), .driver_info = BTUSB_ATH3012 },233	{ USB_DEVICE(0x0cf3, 0x817a), .driver_info = BTUSB_ATH3012 },234	{ USB_DEVICE(0x0cf3, 0x817b), .driver_info = BTUSB_ATH3012 },235	{ USB_DEVICE(0x0cf3, 0xe003), .driver_info = BTUSB_ATH3012 },236	{ USB_DEVICE(0x0cf3, 0xe004), .driver_info = BTUSB_ATH3012 },237	{ USB_DEVICE(0x0cf3, 0xe005), .driver_info = BTUSB_ATH3012 },238	{ USB_DEVICE(0x0cf3, 0xe006), .driver_info = BTUSB_ATH3012 },239	{ USB_DEVICE(0x13d3, 0x3362), .driver_info = BTUSB_ATH3012 },240	{ USB_DEVICE(0x13d3, 0x3375), .driver_info = BTUSB_ATH3012 },241	{ USB_DEVICE(0x13d3, 0x3393), .driver_info = BTUSB_ATH3012 },242	{ USB_DEVICE(0x13d3, 0x3395), .driver_info = BTUSB_ATH3012 },243	{ USB_DEVICE(0x13d3, 0x3402), .driver_info = BTUSB_ATH3012 },244	{ USB_DEVICE(0x13d3, 0x3408), .driver_info = BTUSB_ATH3012 },245	{ USB_DEVICE(0x13d3, 0x3423), .driver_info = BTUSB_ATH3012 },246	{ USB_DEVICE(0x13d3, 0x3432), .driver_info = BTUSB_ATH3012 },247	{ USB_DEVICE(0x13d3, 0x3472), .driver_info = BTUSB_ATH3012 },248	{ USB_DEVICE(0x13d3, 0x3474), .driver_info = BTUSB_ATH3012 },249	{ USB_DEVICE(0x13d3, 0x3487), .driver_info = BTUSB_ATH3012 },250	{ USB_DEVICE(0x13d3, 0x3490), .driver_info = BTUSB_ATH3012 },251 252	/* Atheros AR5BBU12 with sflash firmware */253	{ USB_DEVICE(0x0489, 0xe02c), .driver_info = BTUSB_IGNORE },254 255	/* Atheros AR5BBU12 with sflash firmware */256	{ USB_DEVICE(0x0489, 0xe036), .driver_info = BTUSB_ATH3012 },257	{ USB_DEVICE(0x0489, 0xe03c), .driver_info = BTUSB_ATH3012 },258 259	/* QCA ROME chipset */260	{ USB_DEVICE(0x0cf3, 0x535b), .driver_info = BTUSB_QCA_ROME |261						     BTUSB_WIDEBAND_SPEECH },262	{ USB_DEVICE(0x0cf3, 0xe007), .driver_info = BTUSB_QCA_ROME |263						     BTUSB_WIDEBAND_SPEECH },264	{ USB_DEVICE(0x0cf3, 0xe009), .driver_info = BTUSB_QCA_ROME |265						     BTUSB_WIDEBAND_SPEECH },266	{ USB_DEVICE(0x0cf3, 0xe010), .driver_info = BTUSB_QCA_ROME |267						     BTUSB_WIDEBAND_SPEECH },268	{ USB_DEVICE(0x0cf3, 0xe300), .driver_info = BTUSB_QCA_ROME |269						     BTUSB_WIDEBAND_SPEECH },270	{ USB_DEVICE(0x0cf3, 0xe301), .driver_info = BTUSB_QCA_ROME |271						     BTUSB_WIDEBAND_SPEECH },272	{ USB_DEVICE(0x0cf3, 0xe360), .driver_info = BTUSB_QCA_ROME |273						     BTUSB_WIDEBAND_SPEECH },274	{ USB_DEVICE(0x0cf3, 0xe500), .driver_info = BTUSB_QCA_ROME |275						     BTUSB_WIDEBAND_SPEECH },276	{ USB_DEVICE(0x0489, 0xe092), .driver_info = BTUSB_QCA_ROME |277						     BTUSB_WIDEBAND_SPEECH },278	{ USB_DEVICE(0x0489, 0xe09f), .driver_info = BTUSB_QCA_ROME |279						     BTUSB_WIDEBAND_SPEECH },280	{ USB_DEVICE(0x0489, 0xe0a2), .driver_info = BTUSB_QCA_ROME |281						     BTUSB_WIDEBAND_SPEECH },282	{ USB_DEVICE(0x04ca, 0x3011), .driver_info = BTUSB_QCA_ROME |283						     BTUSB_WIDEBAND_SPEECH },284	{ USB_DEVICE(0x04ca, 0x3015), .driver_info = BTUSB_QCA_ROME |285						     BTUSB_WIDEBAND_SPEECH },286	{ USB_DEVICE(0x04ca, 0x3016), .driver_info = BTUSB_QCA_ROME |287						     BTUSB_WIDEBAND_SPEECH },288	{ USB_DEVICE(0x04ca, 0x301a), .driver_info = BTUSB_QCA_ROME |289						     BTUSB_WIDEBAND_SPEECH },290	{ USB_DEVICE(0x04ca, 0x3021), .driver_info = BTUSB_QCA_ROME |291						     BTUSB_WIDEBAND_SPEECH },292	{ USB_DEVICE(0x13d3, 0x3491), .driver_info = BTUSB_QCA_ROME |293						     BTUSB_WIDEBAND_SPEECH },294	{ USB_DEVICE(0x13d3, 0x3496), .driver_info = BTUSB_QCA_ROME |295						     BTUSB_WIDEBAND_SPEECH },296	{ USB_DEVICE(0x13d3, 0x3501), .driver_info = BTUSB_QCA_ROME |297						     BTUSB_WIDEBAND_SPEECH },298 299	/* QCA WCN6855 chipset */300	{ USB_DEVICE(0x0cf3, 0xe600), .driver_info = BTUSB_QCA_WCN6855 |301						     BTUSB_WIDEBAND_SPEECH },302	{ USB_DEVICE(0x0489, 0xe0cc), .driver_info = BTUSB_QCA_WCN6855 |303						     BTUSB_WIDEBAND_SPEECH },304	{ USB_DEVICE(0x0489, 0xe0d6), .driver_info = BTUSB_QCA_WCN6855 |305						     BTUSB_WIDEBAND_SPEECH },306	{ USB_DEVICE(0x0489, 0xe0e3), .driver_info = BTUSB_QCA_WCN6855 |307						     BTUSB_WIDEBAND_SPEECH },308	{ USB_DEVICE(0x10ab, 0x9309), .driver_info = BTUSB_QCA_WCN6855 |309						     BTUSB_WIDEBAND_SPEECH },310	{ USB_DEVICE(0x10ab, 0x9409), .driver_info = BTUSB_QCA_WCN6855 |311						     BTUSB_WIDEBAND_SPEECH },312	{ USB_DEVICE(0x0489, 0xe0d0), .driver_info = BTUSB_QCA_WCN6855 |313						     BTUSB_WIDEBAND_SPEECH },314	{ USB_DEVICE(0x10ab, 0x9108), .driver_info = BTUSB_QCA_WCN6855 |315						     BTUSB_WIDEBAND_SPEECH },316	{ USB_DEVICE(0x10ab, 0x9109), .driver_info = BTUSB_QCA_WCN6855 |317						     BTUSB_WIDEBAND_SPEECH },318	{ USB_DEVICE(0x10ab, 0x9208), .driver_info = BTUSB_QCA_WCN6855 |319						     BTUSB_WIDEBAND_SPEECH },320	{ USB_DEVICE(0x10ab, 0x9209), .driver_info = BTUSB_QCA_WCN6855 |321						     BTUSB_WIDEBAND_SPEECH },322	{ USB_DEVICE(0x10ab, 0x9308), .driver_info = BTUSB_QCA_WCN6855 |323						     BTUSB_WIDEBAND_SPEECH },324	{ USB_DEVICE(0x10ab, 0x9408), .driver_info = BTUSB_QCA_WCN6855 |325						     BTUSB_WIDEBAND_SPEECH },326	{ USB_DEVICE(0x10ab, 0x9508), .driver_info = BTUSB_QCA_WCN6855 |327						     BTUSB_WIDEBAND_SPEECH },328	{ USB_DEVICE(0x10ab, 0x9509), .driver_info = BTUSB_QCA_WCN6855 |329						     BTUSB_WIDEBAND_SPEECH },330	{ USB_DEVICE(0x10ab, 0x9608), .driver_info = BTUSB_QCA_WCN6855 |331						     BTUSB_WIDEBAND_SPEECH },332	{ USB_DEVICE(0x10ab, 0x9609), .driver_info = BTUSB_QCA_WCN6855 |333						     BTUSB_WIDEBAND_SPEECH },334	{ USB_DEVICE(0x10ab, 0x9f09), .driver_info = BTUSB_QCA_WCN6855 |335						     BTUSB_WIDEBAND_SPEECH },336	{ USB_DEVICE(0x04ca, 0x3022), .driver_info = BTUSB_QCA_WCN6855 |337						     BTUSB_WIDEBAND_SPEECH },338	{ USB_DEVICE(0x0489, 0xe0c7), .driver_info = BTUSB_QCA_WCN6855 |339						     BTUSB_WIDEBAND_SPEECH },340	{ USB_DEVICE(0x0489, 0xe0c9), .driver_info = BTUSB_QCA_WCN6855 |341						     BTUSB_WIDEBAND_SPEECH },342	{ USB_DEVICE(0x0489, 0xe0ca), .driver_info = BTUSB_QCA_WCN6855 |343						     BTUSB_WIDEBAND_SPEECH },344	{ USB_DEVICE(0x0489, 0xe0cb), .driver_info = BTUSB_QCA_WCN6855 |345						     BTUSB_WIDEBAND_SPEECH },346	{ USB_DEVICE(0x0489, 0xe0ce), .driver_info = BTUSB_QCA_WCN6855 |347						     BTUSB_WIDEBAND_SPEECH },348	{ USB_DEVICE(0x0489, 0xe0de), .driver_info = BTUSB_QCA_WCN6855 |349						     BTUSB_WIDEBAND_SPEECH },350	{ USB_DEVICE(0x0489, 0xe0df), .driver_info = BTUSB_QCA_WCN6855 |351						     BTUSB_WIDEBAND_SPEECH },352	{ USB_DEVICE(0x0489, 0xe0e1), .driver_info = BTUSB_QCA_WCN6855 |353						     BTUSB_WIDEBAND_SPEECH },354	{ USB_DEVICE(0x0489, 0xe0ea), .driver_info = BTUSB_QCA_WCN6855 |355						     BTUSB_WIDEBAND_SPEECH },356	{ USB_DEVICE(0x0489, 0xe0ec), .driver_info = BTUSB_QCA_WCN6855 |357						     BTUSB_WIDEBAND_SPEECH },358	{ USB_DEVICE(0x04ca, 0x3023), .driver_info = BTUSB_QCA_WCN6855 |359						     BTUSB_WIDEBAND_SPEECH },360	{ USB_DEVICE(0x04ca, 0x3024), .driver_info = BTUSB_QCA_WCN6855 |361						     BTUSB_WIDEBAND_SPEECH },362	{ USB_DEVICE(0x04ca, 0x3a22), .driver_info = BTUSB_QCA_WCN6855 |363						     BTUSB_WIDEBAND_SPEECH },364	{ USB_DEVICE(0x04ca, 0x3a24), .driver_info = BTUSB_QCA_WCN6855 |365						     BTUSB_WIDEBAND_SPEECH },366	{ USB_DEVICE(0x04ca, 0x3a26), .driver_info = BTUSB_QCA_WCN6855 |367						     BTUSB_WIDEBAND_SPEECH },368	{ USB_DEVICE(0x04ca, 0x3a27), .driver_info = BTUSB_QCA_WCN6855 |369						     BTUSB_WIDEBAND_SPEECH },370 371	/* QCA WCN785x chipset */372	{ USB_DEVICE(0x0cf3, 0xe700), .driver_info = BTUSB_QCA_WCN6855 |373						     BTUSB_WIDEBAND_SPEECH },374 375	/* Broadcom BCM2035 */376	{ USB_DEVICE(0x0a5c, 0x2009), .driver_info = BTUSB_BCM92035 },377	{ USB_DEVICE(0x0a5c, 0x200a), .driver_info = BTUSB_WRONG_SCO_MTU },378	{ USB_DEVICE(0x0a5c, 0x2035), .driver_info = BTUSB_WRONG_SCO_MTU },379 380	/* Broadcom BCM2045 */381	{ USB_DEVICE(0x0a5c, 0x2039), .driver_info = BTUSB_WRONG_SCO_MTU },382	{ USB_DEVICE(0x0a5c, 0x2101), .driver_info = BTUSB_WRONG_SCO_MTU },383 384	/* IBM/Lenovo ThinkPad with Broadcom chip */385	{ USB_DEVICE(0x0a5c, 0x201e), .driver_info = BTUSB_WRONG_SCO_MTU },386	{ USB_DEVICE(0x0a5c, 0x2110), .driver_info = BTUSB_WRONG_SCO_MTU },387 388	/* HP laptop with Broadcom chip */389	{ USB_DEVICE(0x03f0, 0x171d), .driver_info = BTUSB_WRONG_SCO_MTU },390 391	/* Dell laptop with Broadcom chip */392	{ USB_DEVICE(0x413c, 0x8126), .driver_info = BTUSB_WRONG_SCO_MTU },393 394	/* Dell Wireless 370 and 410 devices */395	{ USB_DEVICE(0x413c, 0x8152), .driver_info = BTUSB_WRONG_SCO_MTU },396	{ USB_DEVICE(0x413c, 0x8156), .driver_info = BTUSB_WRONG_SCO_MTU },397 398	/* Belkin F8T012 and F8T013 devices */399	{ USB_DEVICE(0x050d, 0x0012), .driver_info = BTUSB_WRONG_SCO_MTU },400	{ USB_DEVICE(0x050d, 0x0013), .driver_info = BTUSB_WRONG_SCO_MTU },401 402	/* Asus WL-BTD202 device */403	{ USB_DEVICE(0x0b05, 0x1715), .driver_info = BTUSB_WRONG_SCO_MTU },404 405	/* Kensington Bluetooth USB adapter */406	{ USB_DEVICE(0x047d, 0x105e), .driver_info = BTUSB_WRONG_SCO_MTU },407 408	/* RTX Telecom based adapters with buggy SCO support */409	{ USB_DEVICE(0x0400, 0x0807), .driver_info = BTUSB_BROKEN_ISOC },410	{ USB_DEVICE(0x0400, 0x080a), .driver_info = BTUSB_BROKEN_ISOC },411 412	/* CONWISE Technology based adapters with buggy SCO support */413	{ USB_DEVICE(0x0e5e, 0x6622),414	  .driver_info = BTUSB_BROKEN_ISOC | BTUSB_CW6622},415 416	/* Roper Class 1 Bluetooth Dongle (Silicon Wave based) */417	{ USB_DEVICE(0x1310, 0x0001), .driver_info = BTUSB_SWAVE },418 419	/* Digianswer devices */420	{ USB_DEVICE(0x08fd, 0x0001), .driver_info = BTUSB_DIGIANSWER },421	{ USB_DEVICE(0x08fd, 0x0002), .driver_info = BTUSB_IGNORE },422 423	/* CSR BlueCore Bluetooth Sniffer */424	{ USB_DEVICE(0x0a12, 0x0002),425	  .driver_info = BTUSB_SNIFFER | BTUSB_BROKEN_ISOC },426 427	/* Frontline ComProbe Bluetooth Sniffer */428	{ USB_DEVICE(0x16d3, 0x0002),429	  .driver_info = BTUSB_SNIFFER | BTUSB_BROKEN_ISOC },430 431	/* Marvell Bluetooth devices */432	{ USB_DEVICE(0x1286, 0x2044), .driver_info = BTUSB_MARVELL },433	{ USB_DEVICE(0x1286, 0x2046), .driver_info = BTUSB_MARVELL },434	{ USB_DEVICE(0x1286, 0x204e), .driver_info = BTUSB_MARVELL },435 436	/* Intel Bluetooth devices */437	{ USB_DEVICE(0x8087, 0x0025), .driver_info = BTUSB_INTEL_COMBINED },438	{ USB_DEVICE(0x8087, 0x0026), .driver_info = BTUSB_INTEL_COMBINED },439	{ USB_DEVICE(0x8087, 0x0029), .driver_info = BTUSB_INTEL_COMBINED },440	{ USB_DEVICE(0x8087, 0x0032), .driver_info = BTUSB_INTEL_COMBINED },441	{ USB_DEVICE(0x8087, 0x0033), .driver_info = BTUSB_INTEL_COMBINED },442	{ USB_DEVICE(0x8087, 0x0035), .driver_info = BTUSB_INTEL_COMBINED },443	{ USB_DEVICE(0x8087, 0x0036), .driver_info = BTUSB_INTEL_COMBINED },444	{ USB_DEVICE(0x8087, 0x0037), .driver_info = BTUSB_INTEL_COMBINED },445	{ USB_DEVICE(0x8087, 0x0038), .driver_info = BTUSB_INTEL_COMBINED },446	{ USB_DEVICE(0x8087, 0x0039), .driver_info = BTUSB_INTEL_COMBINED },447	{ USB_DEVICE(0x8087, 0x07da), .driver_info = BTUSB_CSR },448	{ USB_DEVICE(0x8087, 0x07dc), .driver_info = BTUSB_INTEL_COMBINED |449						     BTUSB_INTEL_NO_WBS_SUPPORT |450						     BTUSB_INTEL_BROKEN_INITIAL_NCMD |451						     BTUSB_INTEL_BROKEN_SHUTDOWN_LED },452	{ USB_DEVICE(0x8087, 0x0a2a), .driver_info = BTUSB_INTEL_COMBINED |453						     BTUSB_INTEL_NO_WBS_SUPPORT |454						     BTUSB_INTEL_BROKEN_SHUTDOWN_LED },455	{ USB_DEVICE(0x8087, 0x0a2b), .driver_info = BTUSB_INTEL_COMBINED },456	{ USB_DEVICE(0x8087, 0x0aa7), .driver_info = BTUSB_INTEL_COMBINED |457						     BTUSB_INTEL_BROKEN_SHUTDOWN_LED },458	{ USB_DEVICE(0x8087, 0x0aaa), .driver_info = BTUSB_INTEL_COMBINED },459 460	/* Other Intel Bluetooth devices */461	{ USB_VENDOR_AND_INTERFACE_INFO(0x8087, 0xe0, 0x01, 0x01),462	  .driver_info = BTUSB_IGNORE },463 464	/* Realtek 8821CE Bluetooth devices */465	{ USB_DEVICE(0x13d3, 0x3529), .driver_info = BTUSB_REALTEK |466						     BTUSB_WIDEBAND_SPEECH },467 468	/* Realtek 8822CE Bluetooth devices */469	{ USB_DEVICE(0x0bda, 0xb00c), .driver_info = BTUSB_REALTEK |470						     BTUSB_WIDEBAND_SPEECH },471	{ USB_DEVICE(0x0bda, 0xc822), .driver_info = BTUSB_REALTEK |472						     BTUSB_WIDEBAND_SPEECH },473 474	/* Realtek 8822CU Bluetooth devices */475	{ USB_DEVICE(0x13d3, 0x3549), .driver_info = BTUSB_REALTEK |476						     BTUSB_WIDEBAND_SPEECH },477 478	/* Realtek 8852AE Bluetooth devices */479	{ USB_DEVICE(0x0bda, 0x2852), .driver_info = BTUSB_REALTEK |480						     BTUSB_WIDEBAND_SPEECH },481	{ USB_DEVICE(0x0bda, 0xc852), .driver_info = BTUSB_REALTEK |482						     BTUSB_WIDEBAND_SPEECH },483	{ USB_DEVICE(0x0bda, 0x385a), .driver_info = BTUSB_REALTEK |484						     BTUSB_WIDEBAND_SPEECH },485	{ USB_DEVICE(0x0bda, 0x4852), .driver_info = BTUSB_REALTEK |486						     BTUSB_WIDEBAND_SPEECH },487	{ USB_DEVICE(0x04c5, 0x165c), .driver_info = BTUSB_REALTEK |488						     BTUSB_WIDEBAND_SPEECH },489	{ USB_DEVICE(0x04ca, 0x4006), .driver_info = BTUSB_REALTEK |490						     BTUSB_WIDEBAND_SPEECH },491	{ USB_DEVICE(0x0cb8, 0xc549), .driver_info = BTUSB_REALTEK |492						     BTUSB_WIDEBAND_SPEECH },493 494	/* Realtek 8852CE Bluetooth devices */495	{ USB_DEVICE(0x04ca, 0x4007), .driver_info = BTUSB_REALTEK |496						     BTUSB_WIDEBAND_SPEECH },497	{ USB_DEVICE(0x04c5, 0x1675), .driver_info = BTUSB_REALTEK |498						     BTUSB_WIDEBAND_SPEECH },499	{ USB_DEVICE(0x0cb8, 0xc558), .driver_info = BTUSB_REALTEK |500						     BTUSB_WIDEBAND_SPEECH },501	{ USB_DEVICE(0x13d3, 0x3587), .driver_info = BTUSB_REALTEK |502						     BTUSB_WIDEBAND_SPEECH },503	{ USB_DEVICE(0x13d3, 0x3586), .driver_info = BTUSB_REALTEK |504						     BTUSB_WIDEBAND_SPEECH },505	{ USB_DEVICE(0x13d3, 0x3592), .driver_info = BTUSB_REALTEK |506						     BTUSB_WIDEBAND_SPEECH },507	{ USB_DEVICE(0x0489, 0xe122), .driver_info = BTUSB_REALTEK |508						     BTUSB_WIDEBAND_SPEECH },509 510	/* Realtek 8852BE Bluetooth devices */511	{ USB_DEVICE(0x0cb8, 0xc559), .driver_info = BTUSB_REALTEK |512						     BTUSB_WIDEBAND_SPEECH },513	{ USB_DEVICE(0x0bda, 0x4853), .driver_info = BTUSB_REALTEK |514						     BTUSB_WIDEBAND_SPEECH },515	{ USB_DEVICE(0x0bda, 0x887b), .driver_info = BTUSB_REALTEK |516						     BTUSB_WIDEBAND_SPEECH },517	{ USB_DEVICE(0x0bda, 0xb85b), .driver_info = BTUSB_REALTEK |518						     BTUSB_WIDEBAND_SPEECH },519	{ USB_DEVICE(0x13d3, 0x3570), .driver_info = BTUSB_REALTEK |520						     BTUSB_WIDEBAND_SPEECH },521	{ USB_DEVICE(0x13d3, 0x3571), .driver_info = BTUSB_REALTEK |522						     BTUSB_WIDEBAND_SPEECH },523	{ USB_DEVICE(0x13d3, 0x3572), .driver_info = BTUSB_REALTEK |524						     BTUSB_WIDEBAND_SPEECH },525	{ USB_DEVICE(0x13d3, 0x3591), .driver_info = BTUSB_REALTEK |526						     BTUSB_WIDEBAND_SPEECH },527	{ USB_DEVICE(0x0489, 0xe125), .driver_info = BTUSB_REALTEK |528						     BTUSB_WIDEBAND_SPEECH },529 530	/* Realtek 8852BT/8852BE-VT Bluetooth devices */531	{ USB_DEVICE(0x0bda, 0x8520), .driver_info = BTUSB_REALTEK |532						     BTUSB_WIDEBAND_SPEECH },533 534	/* Realtek 8922AE Bluetooth devices */535	{ USB_DEVICE(0x0bda, 0x8922), .driver_info = BTUSB_REALTEK |536						     BTUSB_WIDEBAND_SPEECH },537	{ USB_DEVICE(0x13d3, 0x3617), .driver_info = BTUSB_REALTEK |538						     BTUSB_WIDEBAND_SPEECH },539	{ USB_DEVICE(0x13d3, 0x3616), .driver_info = BTUSB_REALTEK |540						     BTUSB_WIDEBAND_SPEECH },541	{ USB_DEVICE(0x0489, 0xe130), .driver_info = BTUSB_REALTEK |542						     BTUSB_WIDEBAND_SPEECH },543 544	/* Realtek Bluetooth devices */545	{ USB_VENDOR_AND_INTERFACE_INFO(0x0bda, 0xe0, 0x01, 0x01),546	  .driver_info = BTUSB_REALTEK },547 548	/* MediaTek Bluetooth devices */549	{ USB_VENDOR_AND_INTERFACE_INFO(0x0e8d, 0xe0, 0x01, 0x01),550	  .driver_info = BTUSB_MEDIATEK |551			 BTUSB_WIDEBAND_SPEECH },552 553	/* Additional MediaTek MT7615E Bluetooth devices */554	{ USB_DEVICE(0x13d3, 0x3560), .driver_info = BTUSB_MEDIATEK},555 556	/* Additional MediaTek MT7663 Bluetooth devices */557	{ USB_DEVICE(0x043e, 0x310c), .driver_info = BTUSB_MEDIATEK |558						     BTUSB_WIDEBAND_SPEECH },559	{ USB_DEVICE(0x04ca, 0x3801), .driver_info = BTUSB_MEDIATEK |560						     BTUSB_WIDEBAND_SPEECH },561 562	/* Additional MediaTek MT7668 Bluetooth devices */563	{ USB_DEVICE(0x043e, 0x3109), .driver_info = BTUSB_MEDIATEK |564						     BTUSB_WIDEBAND_SPEECH },565 566	/* Additional MediaTek MT7921 Bluetooth devices */567	{ USB_DEVICE(0x0489, 0xe0c8), .driver_info = BTUSB_MEDIATEK |568						     BTUSB_WIDEBAND_SPEECH },569	{ USB_DEVICE(0x0489, 0xe0cd), .driver_info = BTUSB_MEDIATEK |570						     BTUSB_WIDEBAND_SPEECH },571	{ USB_DEVICE(0x0489, 0xe0e0), .driver_info = BTUSB_MEDIATEK |572						     BTUSB_WIDEBAND_SPEECH },573	{ USB_DEVICE(0x0489, 0xe0f2), .driver_info = BTUSB_MEDIATEK |574						     BTUSB_WIDEBAND_SPEECH },575	{ USB_DEVICE(0x04ca, 0x3802), .driver_info = BTUSB_MEDIATEK |576						     BTUSB_WIDEBAND_SPEECH },577	{ USB_DEVICE(0x0e8d, 0x0608), .driver_info = BTUSB_MEDIATEK |578						     BTUSB_WIDEBAND_SPEECH },579	{ USB_DEVICE(0x13d3, 0x3563), .driver_info = BTUSB_MEDIATEK |580						     BTUSB_WIDEBAND_SPEECH },581	{ USB_DEVICE(0x13d3, 0x3564), .driver_info = BTUSB_MEDIATEK |582						     BTUSB_WIDEBAND_SPEECH },583	{ USB_DEVICE(0x13d3, 0x3567), .driver_info = BTUSB_MEDIATEK |584						     BTUSB_WIDEBAND_SPEECH },585	{ USB_DEVICE(0x13d3, 0x3578), .driver_info = BTUSB_MEDIATEK |586						     BTUSB_WIDEBAND_SPEECH },587	{ USB_DEVICE(0x13d3, 0x3583), .driver_info = BTUSB_MEDIATEK |588						     BTUSB_WIDEBAND_SPEECH },589	{ USB_DEVICE(0x13d3, 0x3606), .driver_info = BTUSB_MEDIATEK |590						     BTUSB_WIDEBAND_SPEECH },591 592	/* MediaTek MT7922 Bluetooth devices */593	{ USB_DEVICE(0x13d3, 0x3585), .driver_info = BTUSB_MEDIATEK |594						     BTUSB_WIDEBAND_SPEECH },595 596	/* MediaTek MT7922A Bluetooth devices */597	{ USB_DEVICE(0x0489, 0xe0d8), .driver_info = BTUSB_MEDIATEK |598						     BTUSB_WIDEBAND_SPEECH },599	{ USB_DEVICE(0x0489, 0xe0d9), .driver_info = BTUSB_MEDIATEK |600						     BTUSB_WIDEBAND_SPEECH },601	{ USB_DEVICE(0x0489, 0xe0e2), .driver_info = BTUSB_MEDIATEK |602						     BTUSB_WIDEBAND_SPEECH },603	{ USB_DEVICE(0x0489, 0xe0e4), .driver_info = BTUSB_MEDIATEK |604						     BTUSB_WIDEBAND_SPEECH },605	{ USB_DEVICE(0x0489, 0xe0f1), .driver_info = BTUSB_MEDIATEK |606						     BTUSB_WIDEBAND_SPEECH },607	{ USB_DEVICE(0x0489, 0xe0f2), .driver_info = BTUSB_MEDIATEK |608						     BTUSB_WIDEBAND_SPEECH },609	{ USB_DEVICE(0x0489, 0xe0f5), .driver_info = BTUSB_MEDIATEK |610						     BTUSB_WIDEBAND_SPEECH },611	{ USB_DEVICE(0x0489, 0xe0f6), .driver_info = BTUSB_MEDIATEK |612						     BTUSB_WIDEBAND_SPEECH },613	{ USB_DEVICE(0x0489, 0xe102), .driver_info = BTUSB_MEDIATEK |614						     BTUSB_WIDEBAND_SPEECH },615	{ USB_DEVICE(0x04ca, 0x3804), .driver_info = BTUSB_MEDIATEK |616						     BTUSB_WIDEBAND_SPEECH },617	{ USB_DEVICE(0x04ca, 0x38e4), .driver_info = BTUSB_MEDIATEK |618						     BTUSB_WIDEBAND_SPEECH },619	{ USB_DEVICE(0x13d3, 0x3568), .driver_info = BTUSB_MEDIATEK |620						     BTUSB_WIDEBAND_SPEECH },621	{ USB_DEVICE(0x13d3, 0x3605), .driver_info = BTUSB_MEDIATEK |622						     BTUSB_WIDEBAND_SPEECH },623	{ USB_DEVICE(0x13d3, 0x3607), .driver_info = BTUSB_MEDIATEK |624						     BTUSB_WIDEBAND_SPEECH },625	{ USB_DEVICE(0x13d3, 0x3614), .driver_info = BTUSB_MEDIATEK |626						     BTUSB_WIDEBAND_SPEECH },627	{ USB_DEVICE(0x13d3, 0x3615), .driver_info = BTUSB_MEDIATEK |628						     BTUSB_WIDEBAND_SPEECH },629	{ USB_DEVICE(0x35f5, 0x7922), .driver_info = BTUSB_MEDIATEK |630						     BTUSB_WIDEBAND_SPEECH },631 632	/* Additional MediaTek MT7925 Bluetooth devices */633	{ USB_DEVICE(0x0489, 0xe113), .driver_info = BTUSB_MEDIATEK |634						     BTUSB_WIDEBAND_SPEECH },635	{ USB_DEVICE(0x0489, 0xe118), .driver_info = BTUSB_MEDIATEK |636						     BTUSB_WIDEBAND_SPEECH },637	{ USB_DEVICE(0x0489, 0xe11e), .driver_info = BTUSB_MEDIATEK |638						     BTUSB_WIDEBAND_SPEECH },639	{ USB_DEVICE(0x13d3, 0x3602), .driver_info = BTUSB_MEDIATEK |640						     BTUSB_WIDEBAND_SPEECH },641	{ USB_DEVICE(0x13d3, 0x3603), .driver_info = BTUSB_MEDIATEK |642						     BTUSB_WIDEBAND_SPEECH },643	{ USB_DEVICE(0x13d3, 0x3604), .driver_info = BTUSB_MEDIATEK |644						     BTUSB_WIDEBAND_SPEECH },645	{ USB_DEVICE(0x13d3, 0x3608), .driver_info = BTUSB_MEDIATEK |646						     BTUSB_WIDEBAND_SPEECH },647 648	/* Additional Realtek 8723AE Bluetooth devices */649	{ USB_DEVICE(0x0930, 0x021d), .driver_info = BTUSB_REALTEK },650	{ USB_DEVICE(0x13d3, 0x3394), .driver_info = BTUSB_REALTEK },651 652	/* Additional Realtek 8723BE Bluetooth devices */653	{ USB_DEVICE(0x0489, 0xe085), .driver_info = BTUSB_REALTEK },654	{ USB_DEVICE(0x0489, 0xe08b), .driver_info = BTUSB_REALTEK },655	{ USB_DEVICE(0x04f2, 0xb49f), .driver_info = BTUSB_REALTEK },656	{ USB_DEVICE(0x13d3, 0x3410), .driver_info = BTUSB_REALTEK },657	{ USB_DEVICE(0x13d3, 0x3416), .driver_info = BTUSB_REALTEK },658	{ USB_DEVICE(0x13d3, 0x3459), .driver_info = BTUSB_REALTEK },659	{ USB_DEVICE(0x13d3, 0x3494), .driver_info = BTUSB_REALTEK },660 661	/* Additional Realtek 8723BU Bluetooth devices */662	{ USB_DEVICE(0x7392, 0xa611), .driver_info = BTUSB_REALTEK },663 664	/* Additional Realtek 8723DE Bluetooth devices */665	{ USB_DEVICE(0x0bda, 0xb009), .driver_info = BTUSB_REALTEK },666	{ USB_DEVICE(0x2ff8, 0xb011), .driver_info = BTUSB_REALTEK },667 668	/* Additional Realtek 8761BUV Bluetooth devices */669	{ USB_DEVICE(0x2357, 0x0604), .driver_info = BTUSB_REALTEK |670						     BTUSB_WIDEBAND_SPEECH },671	{ USB_DEVICE(0x0b05, 0x190e), .driver_info = BTUSB_REALTEK |672	  					     BTUSB_WIDEBAND_SPEECH },673	{ USB_DEVICE(0x2550, 0x8761), .driver_info = BTUSB_REALTEK |674						     BTUSB_WIDEBAND_SPEECH },675	{ USB_DEVICE(0x0bda, 0x8771), .driver_info = BTUSB_REALTEK |676						     BTUSB_WIDEBAND_SPEECH },677	{ USB_DEVICE(0x6655, 0x8771), .driver_info = BTUSB_REALTEK |678						     BTUSB_WIDEBAND_SPEECH },679	{ USB_DEVICE(0x7392, 0xc611), .driver_info = BTUSB_REALTEK |680						     BTUSB_WIDEBAND_SPEECH },681	{ USB_DEVICE(0x2b89, 0x8761), .driver_info = BTUSB_REALTEK |682						     BTUSB_WIDEBAND_SPEECH },683 684	/* Additional Realtek 8821AE Bluetooth devices */685	{ USB_DEVICE(0x0b05, 0x17dc), .driver_info = BTUSB_REALTEK },686	{ USB_DEVICE(0x13d3, 0x3414), .driver_info = BTUSB_REALTEK },687	{ USB_DEVICE(0x13d3, 0x3458), .driver_info = BTUSB_REALTEK },688	{ USB_DEVICE(0x13d3, 0x3461), .driver_info = BTUSB_REALTEK },689	{ USB_DEVICE(0x13d3, 0x3462), .driver_info = BTUSB_REALTEK },690 691	/* Additional Realtek 8822BE Bluetooth devices */692	{ USB_DEVICE(0x13d3, 0x3526), .driver_info = BTUSB_REALTEK },693	{ USB_DEVICE(0x0b05, 0x185c), .driver_info = BTUSB_REALTEK },694 695	/* Additional Realtek 8822CE Bluetooth devices */696	{ USB_DEVICE(0x04ca, 0x4005), .driver_info = BTUSB_REALTEK |697						     BTUSB_WIDEBAND_SPEECH },698	{ USB_DEVICE(0x04c5, 0x161f), .driver_info = BTUSB_REALTEK |699						     BTUSB_WIDEBAND_SPEECH },700	{ USB_DEVICE(0x0b05, 0x18ef), .driver_info = BTUSB_REALTEK |701						     BTUSB_WIDEBAND_SPEECH },702	{ USB_DEVICE(0x13d3, 0x3548), .driver_info = BTUSB_REALTEK |703						     BTUSB_WIDEBAND_SPEECH },704	{ USB_DEVICE(0x13d3, 0x3549), .driver_info = BTUSB_REALTEK |705						     BTUSB_WIDEBAND_SPEECH },706	{ USB_DEVICE(0x13d3, 0x3553), .driver_info = BTUSB_REALTEK |707						     BTUSB_WIDEBAND_SPEECH },708	{ USB_DEVICE(0x13d3, 0x3555), .driver_info = BTUSB_REALTEK |709						     BTUSB_WIDEBAND_SPEECH },710	{ USB_DEVICE(0x2ff8, 0x3051), .driver_info = BTUSB_REALTEK |711						     BTUSB_WIDEBAND_SPEECH },712	{ USB_DEVICE(0x1358, 0xc123), .driver_info = BTUSB_REALTEK |713						     BTUSB_WIDEBAND_SPEECH },714	{ USB_DEVICE(0x0bda, 0xc123), .driver_info = BTUSB_REALTEK |715						     BTUSB_WIDEBAND_SPEECH },716	{ USB_DEVICE(0x0cb5, 0xc547), .driver_info = BTUSB_REALTEK |717						     BTUSB_WIDEBAND_SPEECH },718 719	/* Actions Semiconductor ATS2851 based devices */720	{ USB_DEVICE(0x10d7, 0xb012), .driver_info = BTUSB_ACTIONS_SEMI },721 722	/* Silicon Wave based devices */723	{ USB_DEVICE(0x0c10, 0x0000), .driver_info = BTUSB_SWAVE },724 725	{ }	/* Terminating entry */726};727 728/* The Bluetooth USB module build into some devices needs to be reset on resume,729 * this is a problem with the platform (likely shutting off all power) not with730 * the module itself. So we use a DMI list to match known broken platforms.731 */732static const struct dmi_system_id btusb_needs_reset_resume_table[] = {733	{734		/* Dell OptiPlex 3060 (QCA ROME device 0cf3:e007) */735		.matches = {736			DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),737			DMI_MATCH(DMI_PRODUCT_NAME, "OptiPlex 3060"),738		},739	},740	{741		/* Dell XPS 9360 (QCA ROME device 0cf3:e300) */742		.matches = {743			DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),744			DMI_MATCH(DMI_PRODUCT_NAME, "XPS 13 9360"),745		},746	},747	{748		/* Dell Inspiron 5565 (QCA ROME device 0cf3:e009) */749		.matches = {750			DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),751			DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron 5565"),752		},753	},754	{}755};756 757struct qca_dump_info {758	/* fields for dump collection */759	u16 id_vendor;760	u16 id_product;761	u32 fw_version;762	u32 controller_id;763	u32 ram_dump_size;764	u16 ram_dump_seqno;765};766 767#define BTUSB_MAX_ISOC_FRAMES	10768 769#define BTUSB_INTR_RUNNING	0770#define BTUSB_BULK_RUNNING	1771#define BTUSB_ISOC_RUNNING	2772#define BTUSB_SUSPENDING	3773#define BTUSB_DID_ISO_RESUME	4774#define BTUSB_BOOTLOADER	5775#define BTUSB_DOWNLOADING	6776#define BTUSB_FIRMWARE_LOADED	7777#define BTUSB_FIRMWARE_FAILED	8778#define BTUSB_BOOTING		9779#define BTUSB_DIAG_RUNNING	10780#define BTUSB_OOB_WAKE_ENABLED	11781#define BTUSB_HW_RESET_ACTIVE	12782#define BTUSB_TX_WAIT_VND_EVT	13783#define BTUSB_WAKEUP_AUTOSUSPEND	14784#define BTUSB_USE_ALT3_FOR_WBS	15785#define BTUSB_ALT6_CONTINUOUS_TX	16786#define BTUSB_HW_SSR_ACTIVE	17787 788struct btusb_data {789	struct hci_dev       *hdev;790	struct usb_device    *udev;791	struct usb_interface *intf;792	struct usb_interface *isoc;793	struct usb_interface *diag;794	unsigned isoc_ifnum;795 796	unsigned long flags;797 798	bool poll_sync;799	int intr_interval;800	struct work_struct  work;801	struct work_struct  waker;802	struct delayed_work rx_work;803 804	struct sk_buff_head acl_q;805 806	struct usb_anchor deferred;807	struct usb_anchor tx_anchor;808	int tx_in_flight;809	spinlock_t txlock;810 811	struct usb_anchor intr_anchor;812	struct usb_anchor bulk_anchor;813	struct usb_anchor isoc_anchor;814	struct usb_anchor diag_anchor;815	struct usb_anchor ctrl_anchor;816	spinlock_t rxlock;817 818	struct sk_buff *evt_skb;819	struct sk_buff *acl_skb;820	struct sk_buff *sco_skb;821 822	struct usb_endpoint_descriptor *intr_ep;823	struct usb_endpoint_descriptor *bulk_tx_ep;824	struct usb_endpoint_descriptor *bulk_rx_ep;825	struct usb_endpoint_descriptor *isoc_tx_ep;826	struct usb_endpoint_descriptor *isoc_rx_ep;827	struct usb_endpoint_descriptor *diag_tx_ep;828	struct usb_endpoint_descriptor *diag_rx_ep;829 830	struct gpio_desc *reset_gpio;831 832	__u8 cmdreq_type;833	__u8 cmdreq;834 835	unsigned int sco_num;836	unsigned int air_mode;837	bool usb_alt6_packet_flow;838	int isoc_altsetting;839	int suspend_count;840 841	int (*recv_event)(struct hci_dev *hdev, struct sk_buff *skb);842	int (*recv_acl)(struct hci_dev *hdev, struct sk_buff *skb);843	int (*recv_bulk)(struct btusb_data *data, void *buffer, int count);844 845	int (*setup_on_usb)(struct hci_dev *hdev);846 847	int (*suspend)(struct hci_dev *hdev);848	int (*resume)(struct hci_dev *hdev);849 850	int oob_wake_irq;   /* irq for out-of-band wake-on-bt */851	unsigned cmd_timeout_cnt;852 853	struct qca_dump_info qca_dump;854};855 856static void btusb_reset(struct hci_dev *hdev)857{858	struct btusb_data *data;859	int err;860 861	if (hdev->reset) {862		hdev->reset(hdev);863		return;864	}865 866	data = hci_get_drvdata(hdev);867	/* This is not an unbalanced PM reference since the device will reset */868	err = usb_autopm_get_interface(data->intf);869	if (err) {870		bt_dev_err(hdev, "Failed usb_autopm_get_interface: %d", err);871		return;872	}873 874	bt_dev_err(hdev, "Resetting usb device.");875	usb_queue_reset_device(data->intf);876}877 878static void btusb_intel_cmd_timeout(struct hci_dev *hdev)879{880	struct btusb_data *data = hci_get_drvdata(hdev);881	struct gpio_desc *reset_gpio = data->reset_gpio;882	struct btintel_data *intel_data = hci_get_priv(hdev);883 884	if (++data->cmd_timeout_cnt < 5)885		return;886 887	if (intel_data->acpi_reset_method) {888		if (test_and_set_bit(INTEL_ACPI_RESET_ACTIVE, intel_data->flags)) {889			bt_dev_err(hdev, "acpi: last reset failed ? Not resetting again");890			return;891		}892 893		bt_dev_err(hdev, "Initiating acpi reset method");894		/* If ACPI reset method fails, lets try with legacy GPIO895		 * toggling896		 */897		if (!intel_data->acpi_reset_method(hdev)) {898			return;899		}900	}901 902	if (!reset_gpio) {903		btusb_reset(hdev);904		return;905	}906 907	/*908	 * Toggle the hard reset line if the platform provides one. The reset909	 * is going to yank the device off the USB and then replug. So doing910	 * once is enough. The cleanup is handled correctly on the way out911	 * (standard USB disconnect), and the new device is detected cleanly912	 * and bound to the driver again like it should be.913	 */914	if (test_and_set_bit(BTUSB_HW_RESET_ACTIVE, &data->flags)) {915		bt_dev_err(hdev, "last reset failed? Not resetting again");916		return;917	}918 919	bt_dev_err(hdev, "Initiating HW reset via gpio");920	gpiod_set_value_cansleep(reset_gpio, 1);921	msleep(100);922	gpiod_set_value_cansleep(reset_gpio, 0);923}924 925#define RTK_DEVCOREDUMP_CODE_MEMDUMP		0x01926#define RTK_DEVCOREDUMP_CODE_HW_ERR		0x02927#define RTK_DEVCOREDUMP_CODE_CMD_TIMEOUT	0x03928 929#define RTK_SUB_EVENT_CODE_COREDUMP		0x34930 931struct rtk_dev_coredump_hdr {932	u8 type;933	u8 code;934	u8 reserved[2];935} __packed;936 937static inline void btusb_rtl_alloc_devcoredump(struct hci_dev *hdev,938		struct rtk_dev_coredump_hdr *hdr, u8 *buf, u32 len)939{940	struct sk_buff *skb;941 942	skb = alloc_skb(len + sizeof(*hdr), GFP_ATOMIC);943	if (!skb)944		return;945 946	skb_put_data(skb, hdr, sizeof(*hdr));947	if (len)948		skb_put_data(skb, buf, len);949 950	if (!hci_devcd_init(hdev, skb->len)) {951		hci_devcd_append(hdev, skb);952		hci_devcd_complete(hdev);953	} else {954		bt_dev_err(hdev, "RTL: Failed to generate devcoredump");955		kfree_skb(skb);956	}957}958 959static void btusb_rtl_cmd_timeout(struct hci_dev *hdev)960{961	struct btusb_data *data = hci_get_drvdata(hdev);962	struct gpio_desc *reset_gpio = data->reset_gpio;963	struct rtk_dev_coredump_hdr hdr = {964		.type = RTK_DEVCOREDUMP_CODE_CMD_TIMEOUT,965	};966 967	btusb_rtl_alloc_devcoredump(hdev, &hdr, NULL, 0);968 969	if (++data->cmd_timeout_cnt < 5)970		return;971 972	if (!reset_gpio) {973		btusb_reset(hdev);974		return;975	}976 977	/* Toggle the hard reset line. The Realtek device is going to978	 * yank itself off the USB and then replug. The cleanup is handled979	 * correctly on the way out (standard USB disconnect), and the new980	 * device is detected cleanly and bound to the driver again like981	 * it should be.982	 */983	if (test_and_set_bit(BTUSB_HW_RESET_ACTIVE, &data->flags)) {984		bt_dev_err(hdev, "last reset failed? Not resetting again");985		return;986	}987 988	bt_dev_err(hdev, "Reset Realtek device via gpio");989	gpiod_set_value_cansleep(reset_gpio, 1);990	msleep(200);991	gpiod_set_value_cansleep(reset_gpio, 0);992}993 994static void btusb_rtl_hw_error(struct hci_dev *hdev, u8 code)995{996	struct rtk_dev_coredump_hdr hdr = {997		.type = RTK_DEVCOREDUMP_CODE_HW_ERR,998		.code = code,999	};1000 1001	bt_dev_err(hdev, "RTL: hw err, trigger devcoredump (%d)", code);1002 1003	btusb_rtl_alloc_devcoredump(hdev, &hdr, NULL, 0);1004}1005 1006static void btusb_qca_cmd_timeout(struct hci_dev *hdev)1007{1008	struct btusb_data *data = hci_get_drvdata(hdev);1009	struct gpio_desc *reset_gpio = data->reset_gpio;1010 1011	if (test_bit(BTUSB_HW_SSR_ACTIVE, &data->flags)) {1012		bt_dev_info(hdev, "Ramdump in progress, defer cmd_timeout");1013		return;1014	}1015 1016	if (++data->cmd_timeout_cnt < 5)1017		return;1018 1019	if (reset_gpio) {1020		bt_dev_err(hdev, "Reset qca device via bt_en gpio");1021 1022		/* Toggle the hard reset line. The qca bt device is going to1023		 * yank itself off the USB and then replug. The cleanup is handled1024		 * correctly on the way out (standard USB disconnect), and the new1025		 * device is detected cleanly and bound to the driver again like1026		 * it should be.1027		 */1028		if (test_and_set_bit(BTUSB_HW_RESET_ACTIVE, &data->flags)) {1029			bt_dev_err(hdev, "last reset failed? Not resetting again");1030			return;1031		}1032 1033		gpiod_set_value_cansleep(reset_gpio, 0);1034		msleep(200);1035		gpiod_set_value_cansleep(reset_gpio, 1);1036 1037		return;1038	}1039 1040	btusb_reset(hdev);1041}1042 1043static inline void btusb_free_frags(struct btusb_data *data)1044{1045	unsigned long flags;1046 1047	spin_lock_irqsave(&data->rxlock, flags);1048 1049	dev_kfree_skb_irq(data->evt_skb);1050	data->evt_skb = NULL;1051 1052	dev_kfree_skb_irq(data->acl_skb);1053	data->acl_skb = NULL;1054 1055	dev_kfree_skb_irq(data->sco_skb);1056	data->sco_skb = NULL;1057 1058	spin_unlock_irqrestore(&data->rxlock, flags);1059}1060 1061static int btusb_recv_event(struct btusb_data *data, struct sk_buff *skb)1062{1063	if (data->intr_interval) {1064		/* Trigger dequeue immediatelly if an event is received */1065		schedule_delayed_work(&data->rx_work, 0);1066	}1067 1068	return data->recv_event(data->hdev, skb);1069}1070 1071static int btusb_recv_intr(struct btusb_data *data, void *buffer, int count)1072{1073	struct sk_buff *skb;1074	unsigned long flags;1075	int err = 0;1076 1077	spin_lock_irqsave(&data->rxlock, flags);1078	skb = data->evt_skb;1079 1080	while (count) {1081		int len;1082 1083		if (!skb) {1084			skb = bt_skb_alloc(HCI_MAX_EVENT_SIZE, GFP_ATOMIC);1085			if (!skb) {1086				err = -ENOMEM;1087				break;1088			}1089 1090			hci_skb_pkt_type(skb) = HCI_EVENT_PKT;1091			hci_skb_expect(skb) = HCI_EVENT_HDR_SIZE;1092		}1093 1094		len = min_t(uint, hci_skb_expect(skb), count);1095		skb_put_data(skb, buffer, len);1096 1097		count -= len;1098		buffer += len;1099		hci_skb_expect(skb) -= len;1100 1101		if (skb->len == HCI_EVENT_HDR_SIZE) {1102			/* Complete event header */1103			hci_skb_expect(skb) = hci_event_hdr(skb)->plen;1104 1105			if (skb_tailroom(skb) < hci_skb_expect(skb)) {1106				kfree_skb(skb);1107				skb = NULL;1108 1109				err = -EILSEQ;1110				break;1111			}1112		}1113 1114		if (!hci_skb_expect(skb)) {1115			/* Complete frame */1116			btusb_recv_event(data, skb);1117			skb = NULL;1118		}1119	}1120 1121	data->evt_skb = skb;1122	spin_unlock_irqrestore(&data->rxlock, flags);1123 1124	return err;1125}1126 1127static int btusb_recv_acl(struct btusb_data *data, struct sk_buff *skb)1128{1129	/* Only queue ACL packet if intr_interval is set as it means1130	 * force_poll_sync has been enabled.1131	 */1132	if (!data->intr_interval)1133		return data->recv_acl(data->hdev, skb);1134 1135	skb_queue_tail(&data->acl_q, skb);1136	schedule_delayed_work(&data->rx_work, data->intr_interval);1137 1138	return 0;1139}1140 1141static int btusb_recv_bulk(struct btusb_data *data, void *buffer, int count)1142{1143	struct sk_buff *skb;1144	unsigned long flags;1145	int err = 0;1146 1147	spin_lock_irqsave(&data->rxlock, flags);1148	skb = data->acl_skb;1149 1150	while (count) {1151		int len;1152 1153		if (!skb) {1154			skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC);1155			if (!skb) {1156				err = -ENOMEM;1157				break;1158			}1159 1160			hci_skb_pkt_type(skb) = HCI_ACLDATA_PKT;1161			hci_skb_expect(skb) = HCI_ACL_HDR_SIZE;1162		}1163 1164		len = min_t(uint, hci_skb_expect(skb), count);1165		skb_put_data(skb, buffer, len);1166 1167		count -= len;1168		buffer += len;1169		hci_skb_expect(skb) -= len;1170 1171		if (skb->len == HCI_ACL_HDR_SIZE) {1172			__le16 dlen = hci_acl_hdr(skb)->dlen;1173 1174			/* Complete ACL header */1175			hci_skb_expect(skb) = __le16_to_cpu(dlen);1176 1177			if (skb_tailroom(skb) < hci_skb_expect(skb)) {1178				kfree_skb(skb);1179				skb = NULL;1180 1181				err = -EILSEQ;1182				break;1183			}1184		}1185 1186		if (!hci_skb_expect(skb)) {1187			/* Complete frame */1188			btusb_recv_acl(data, skb);1189			skb = NULL;1190		}1191	}1192 1193	data->acl_skb = skb;1194	spin_unlock_irqrestore(&data->rxlock, flags);1195 1196	return err;1197}1198 1199static bool btusb_validate_sco_handle(struct hci_dev *hdev,1200				      struct hci_sco_hdr *hdr)1201{1202	__u16 handle;1203 1204	if (hci_dev_test_flag(hdev, HCI_USER_CHANNEL))1205		// Can't validate, userspace controls everything.1206		return true;1207 1208	/*1209	 * USB isochronous transfers are not designed to be reliable and may1210	 * lose fragments.  When this happens, the next first fragment1211	 * encountered might actually be a continuation fragment.1212	 * Validate the handle to detect it and drop it, or else the upper1213	 * layer will get garbage for a while.1214	 */1215 1216	handle = hci_handle(__le16_to_cpu(hdr->handle));1217 1218	switch (hci_conn_lookup_type(hdev, handle)) {1219	case SCO_LINK:1220	case ESCO_LINK:1221		return true;1222	default:1223		return false;1224	}1225}1226 1227static int btusb_recv_isoc(struct btusb_data *data, void *buffer, int count)1228{1229	struct sk_buff *skb;1230	unsigned long flags;1231	int err = 0;1232 1233	spin_lock_irqsave(&data->rxlock, flags);1234	skb = data->sco_skb;1235 1236	while (count) {1237		int len;1238 1239		if (!skb) {1240			skb = bt_skb_alloc(HCI_MAX_SCO_SIZE, GFP_ATOMIC);1241			if (!skb) {1242				err = -ENOMEM;1243				break;1244			}1245 1246			hci_skb_pkt_type(skb) = HCI_SCODATA_PKT;1247			hci_skb_expect(skb) = HCI_SCO_HDR_SIZE;1248		}1249 1250		len = min_t(uint, hci_skb_expect(skb), count);1251		skb_put_data(skb, buffer, len);1252 1253		count -= len;1254		buffer += len;1255		hci_skb_expect(skb) -= len;1256 1257		if (skb->len == HCI_SCO_HDR_SIZE) {1258			/* Complete SCO header */1259			struct hci_sco_hdr *hdr = hci_sco_hdr(skb);1260 1261			hci_skb_expect(skb) = hdr->dlen;1262 1263			if (skb_tailroom(skb) < hci_skb_expect(skb) ||1264			    !btusb_validate_sco_handle(data->hdev, hdr)) {1265				kfree_skb(skb);1266				skb = NULL;1267 1268				err = -EILSEQ;1269				break;1270			}1271		}1272 1273		if (!hci_skb_expect(skb)) {1274			/* Complete frame */1275			hci_recv_frame(data->hdev, skb);1276			skb = NULL;1277		}1278	}1279 1280	data->sco_skb = skb;1281	spin_unlock_irqrestore(&data->rxlock, flags);1282 1283	return err;1284}1285 1286static void btusb_intr_complete(struct urb *urb)1287{1288	struct hci_dev *hdev = urb->context;1289	struct btusb_data *data = hci_get_drvdata(hdev);1290	int err;1291 1292	BT_DBG("%s urb %p status %d count %d", hdev->name, urb, urb->status,1293	       urb->actual_length);1294 1295	if (!test_bit(HCI_RUNNING, &hdev->flags))1296		return;1297 1298	if (urb->status == 0) {1299		hdev->stat.byte_rx += urb->actual_length;1300 1301		if (btusb_recv_intr(data, urb->transfer_buffer,1302				    urb->actual_length) < 0) {1303			bt_dev_err(hdev, "corrupted event packet");1304			hdev->stat.err_rx++;1305		}1306	} else if (urb->status == -ENOENT) {1307		/* Avoid suspend failed when usb_kill_urb */1308		return;1309	}1310 1311	if (!test_bit(BTUSB_INTR_RUNNING, &data->flags))1312		return;1313 1314	usb_mark_last_busy(data->udev);1315	usb_anchor_urb(urb, &data->intr_anchor);1316 1317	err = usb_submit_urb(urb, GFP_ATOMIC);1318	if (err < 0) {1319		/* -EPERM: urb is being killed;1320		 * -ENODEV: device got disconnected1321		 */1322		if (err != -EPERM && err != -ENODEV)1323			bt_dev_err(hdev, "urb %p failed to resubmit (%d)",1324				   urb, -err);1325		if (err != -EPERM)1326			hci_cmd_sync_cancel(hdev, -err);1327		usb_unanchor_urb(urb);1328	}1329}1330 1331static int btusb_submit_intr_urb(struct hci_dev *hdev, gfp_t mem_flags)1332{1333	struct btusb_data *data = hci_get_drvdata(hdev);1334	struct urb *urb;1335	unsigned char *buf;1336	unsigned int pipe;1337	int err, size;1338 1339	BT_DBG("%s", hdev->name);1340 1341	if (!data->intr_ep)1342		return -ENODEV;1343 1344	urb = usb_alloc_urb(0, mem_flags);1345	if (!urb)1346		return -ENOMEM;1347 1348	if (le16_to_cpu(data->udev->descriptor.idVendor)  == 0x0a12 &&1349	    le16_to_cpu(data->udev->descriptor.idProduct) == 0x0001)1350		/* Fake CSR devices don't seem to support sort-transter */1351		size = le16_to_cpu(data->intr_ep->wMaxPacketSize);1352	else1353		/* Use maximum HCI Event size so the USB stack handles1354		 * ZPL/short-transfer automatically.1355		 */1356		size = HCI_MAX_EVENT_SIZE;1357 1358	buf = kmalloc(size, mem_flags);1359	if (!buf) {1360		usb_free_urb(urb);1361		return -ENOMEM;1362	}1363 1364	pipe = usb_rcvintpipe(data->udev, data->intr_ep->bEndpointAddress);1365 1366	usb_fill_int_urb(urb, data->udev, pipe, buf, size,1367			 btusb_intr_complete, hdev, data->intr_ep->bInterval);1368 1369	urb->transfer_flags |= URB_FREE_BUFFER;1370 1371	usb_anchor_urb(urb, &data->intr_anchor);1372 1373	err = usb_submit_urb(urb, mem_flags);1374	if (err < 0) {1375		if (err != -EPERM && err != -ENODEV)1376			bt_dev_err(hdev, "urb %p submission failed (%d)",1377				   urb, -err);1378		if (err != -EPERM)1379			hci_cmd_sync_cancel(hdev, -err);1380		usb_unanchor_urb(urb);1381	}1382 1383	/* Only initialize intr_interval if URB poll sync is enabled */1384	if (!data->poll_sync)1385		goto done;1386 1387	/* The units are frames (milliseconds) for full and low speed devices,1388	 * and microframes (1/8 millisecond) for highspeed and SuperSpeed1389	 * devices.1390	 *1391	 * This is done once on open/resume so it shouldn't change even if1392	 * force_poll_sync changes.1393	 */1394	switch (urb->dev->speed) {1395	case USB_SPEED_SUPER_PLUS:1396	case USB_SPEED_SUPER:	/* units are 125us */1397		data->intr_interval = usecs_to_jiffies(urb->interval * 125);1398		break;1399	default:1400		data->intr_interval = msecs_to_jiffies(urb->interval);1401		break;1402	}1403 1404done:1405	usb_free_urb(urb);1406 1407	return err;1408}1409 1410static void btusb_bulk_complete(struct urb *urb)1411{1412	struct hci_dev *hdev = urb->context;1413	struct btusb_data *data = hci_get_drvdata(hdev);1414	int err;1415 1416	BT_DBG("%s urb %p status %d count %d", hdev->name, urb, urb->status,1417	       urb->actual_length);1418 1419	if (!test_bit(HCI_RUNNING, &hdev->flags))1420		return;1421 1422	if (urb->status == 0) {1423		hdev->stat.byte_rx += urb->actual_length;1424 1425		if (data->recv_bulk(data, urb->transfer_buffer,1426				    urb->actual_length) < 0) {1427			bt_dev_err(hdev, "corrupted ACL packet");1428			hdev->stat.err_rx++;1429		}1430	} else if (urb->status == -ENOENT) {1431		/* Avoid suspend failed when usb_kill_urb */1432		return;1433	}1434 1435	if (!test_bit(BTUSB_BULK_RUNNING, &data->flags))1436		return;1437 1438	usb_anchor_urb(urb, &data->bulk_anchor);1439	usb_mark_last_busy(data->udev);1440 1441	err = usb_submit_urb(urb, GFP_ATOMIC);1442	if (err < 0) {1443		/* -EPERM: urb is being killed;1444		 * -ENODEV: device got disconnected1445		 */1446		if (err != -EPERM && err != -ENODEV)1447			bt_dev_err(hdev, "urb %p failed to resubmit (%d)",1448				   urb, -err);1449		usb_unanchor_urb(urb);1450	}1451}1452 1453static int btusb_submit_bulk_urb(struct hci_dev *hdev, gfp_t mem_flags)1454{1455	struct btusb_data *data = hci_get_drvdata(hdev);1456	struct urb *urb;1457	unsigned char *buf;1458	unsigned int pipe;1459	int err, size = HCI_MAX_FRAME_SIZE;1460 1461	BT_DBG("%s", hdev->name);1462 1463	if (!data->bulk_rx_ep)1464		return -ENODEV;1465 1466	urb = usb_alloc_urb(0, mem_flags);1467	if (!urb)1468		return -ENOMEM;1469 1470	buf = kmalloc(size, mem_flags);1471	if (!buf) {1472		usb_free_urb(urb);1473		return -ENOMEM;1474	}1475 1476	pipe = usb_rcvbulkpipe(data->udev, data->bulk_rx_ep->bEndpointAddress);1477 1478	usb_fill_bulk_urb(urb, data->udev, pipe, buf, size,1479			  btusb_bulk_complete, hdev);1480 1481	urb->transfer_flags |= URB_FREE_BUFFER;1482 1483	usb_mark_last_busy(data->udev);1484	usb_anchor_urb(urb, &data->bulk_anchor);1485 1486	err = usb_submit_urb(urb, mem_flags);1487	if (err < 0) {1488		if (err != -EPERM && err != -ENODEV)1489			bt_dev_err(hdev, "urb %p submission failed (%d)",1490				   urb, -err);1491		usb_unanchor_urb(urb);1492	}1493 1494	usb_free_urb(urb);1495 1496	return err;1497}1498 1499static void btusb_isoc_complete(struct urb *urb)1500{1501	struct hci_dev *hdev = urb->context;1502	struct btusb_data *data = hci_get_drvdata(hdev);1503	int i, err;1504 1505	BT_DBG("%s urb %p status %d count %d", hdev->name, urb, urb->status,1506	       urb->actual_length);1507 1508	if (!test_bit(HCI_RUNNING, &hdev->flags))1509		return;1510 1511	if (urb->status == 0) {1512		for (i = 0; i < urb->number_of_packets; i++) {1513			unsigned int offset = urb->iso_frame_desc[i].offset;1514			unsigned int length = urb->iso_frame_desc[i].actual_length;1515 1516			if (urb->iso_frame_desc[i].status)1517				continue;1518 1519			hdev->stat.byte_rx += length;1520 1521			if (btusb_recv_isoc(data, urb->transfer_buffer + offset,1522					    length) < 0) {1523				bt_dev_err(hdev, "corrupted SCO packet");1524				hdev->stat.err_rx++;1525			}1526		}1527	} else if (urb->status == -ENOENT) {1528		/* Avoid suspend failed when usb_kill_urb */1529		return;1530	}1531 1532	if (!test_bit(BTUSB_ISOC_RUNNING, &data->flags))1533		return;1534 1535	usb_anchor_urb(urb, &data->isoc_anchor);1536 1537	err = usb_submit_urb(urb, GFP_ATOMIC);1538	if (err < 0) {1539		/* -EPERM: urb is being killed;1540		 * -ENODEV: device got disconnected1541		 */1542		if (err != -EPERM && err != -ENODEV)1543			bt_dev_err(hdev, "urb %p failed to resubmit (%d)",1544				   urb, -err);1545		usb_unanchor_urb(urb);1546	}1547}1548 1549static inline void __fill_isoc_descriptor_msbc(struct urb *urb, int len,1550					       int mtu, struct btusb_data *data)1551{1552	int i = 0, offset = 0;1553	unsigned int interval;1554 1555	BT_DBG("len %d mtu %d", len, mtu);1556 1557	/* For mSBC ALT 6 settings some chips need to transmit the data1558	 * continuously without the zero length of USB packets.1559	 */1560	if (test_bit(BTUSB_ALT6_CONTINUOUS_TX, &data->flags))1561		goto ignore_usb_alt6_packet_flow;1562 1563	/* For mSBC ALT 6 setting the host will send the packet at continuous1564	 * flow. As per core spec 5, vol 4, part B, table 2.1. For ALT setting1565	 * 6 the HCI PACKET INTERVAL should be 7.5ms for every usb packets.1566	 * To maintain the rate we send 63bytes of usb packets alternatively for1567	 * 7ms and 8ms to maintain the rate as 7.5ms.1568	 */1569	if (data->usb_alt6_packet_flow) {1570		interval = 7;1571		data->usb_alt6_packet_flow = false;1572	} else {1573		interval = 6;1574		data->usb_alt6_packet_flow = true;1575	}1576 1577	for (i = 0; i < interval; i++) {1578		urb->iso_frame_desc[i].offset = offset;1579		urb->iso_frame_desc[i].length = offset;1580	}1581 1582ignore_usb_alt6_packet_flow:1583	if (len && i < BTUSB_MAX_ISOC_FRAMES) {1584		urb->iso_frame_desc[i].offset = offset;1585		urb->iso_frame_desc[i].length = len;1586		i++;1587	}1588 1589	urb->number_of_packets = i;1590}1591 1592static inline void __fill_isoc_descriptor(struct urb *urb, int len, int mtu)1593{1594	int i, offset = 0;1595 1596	BT_DBG("len %d mtu %d", len, mtu);1597 1598	for (i = 0; i < BTUSB_MAX_ISOC_FRAMES && len >= mtu;1599					i++, offset += mtu, len -= mtu) {1600		urb->iso_frame_desc[i].offset = offset;1601		urb->iso_frame_desc[i].length = mtu;1602	}1603 1604	if (len && i < BTUSB_MAX_ISOC_FRAMES) {1605		urb->iso_frame_desc[i].offset = offset;1606		urb->iso_frame_desc[i].length = len;1607		i++;1608	}1609 1610	urb->number_of_packets = i;1611}1612 1613static int btusb_submit_isoc_urb(struct hci_dev *hdev, gfp_t mem_flags)1614{1615	struct btusb_data *data = hci_get_drvdata(hdev);1616	struct urb *urb;1617	unsigned char *buf;1618	unsigned int pipe;1619	int err, size;1620 1621	BT_DBG("%s", hdev->name);1622 1623	if (!data->isoc_rx_ep)1624		return -ENODEV;1625 1626	urb = usb_alloc_urb(BTUSB_MAX_ISOC_FRAMES, mem_flags);1627	if (!urb)1628		return -ENOMEM;1629 1630	size = le16_to_cpu(data->isoc_rx_ep->wMaxPacketSize) *1631						BTUSB_MAX_ISOC_FRAMES;1632 1633	buf = kmalloc(size, mem_flags);1634	if (!buf) {1635		usb_free_urb(urb);1636		return -ENOMEM;1637	}1638 1639	pipe = usb_rcvisocpipe(data->udev, data->isoc_rx_ep->bEndpointAddress);1640 1641	usb_fill_int_urb(urb, data->udev, pipe, buf, size, btusb_isoc_complete,1642			 hdev, data->isoc_rx_ep->bInterval);1643 1644	urb->transfer_flags = URB_FREE_BUFFER | URB_ISO_ASAP;1645 1646	__fill_isoc_descriptor(urb, size,1647			       le16_to_cpu(data->isoc_rx_ep->wMaxPacketSize));1648 1649	usb_anchor_urb(urb, &data->isoc_anchor);1650 1651	err = usb_submit_urb(urb, mem_flags);1652	if (err < 0) {1653		if (err != -EPERM && err != -ENODEV)1654			bt_dev_err(hdev, "urb %p submission failed (%d)",1655				   urb, -err);1656		usb_unanchor_urb(urb);1657	}1658 1659	usb_free_urb(urb);1660 1661	return err;1662}1663 1664static void btusb_diag_complete(struct urb *urb)1665{1666	struct hci_dev *hdev = urb->context;1667	struct btusb_data *data = hci_get_drvdata(hdev);1668	int err;1669 1670	BT_DBG("%s urb %p status %d count %d", hdev->name, urb, urb->status,1671	       urb->actual_length);1672 1673	if (urb->status == 0) {1674		struct sk_buff *skb;1675 1676		skb = bt_skb_alloc(urb->actual_length, GFP_ATOMIC);1677		if (skb) {1678			skb_put_data(skb, urb->transfer_buffer,1679				     urb->actual_length);1680			hci_recv_diag(hdev, skb);1681		}1682	} else if (urb->status == -ENOENT) {1683		/* Avoid suspend failed when usb_kill_urb */1684		return;1685	}1686 1687	if (!test_bit(BTUSB_DIAG_RUNNING, &data->flags))1688		return;1689 1690	usb_anchor_urb(urb, &data->diag_anchor);1691	usb_mark_last_busy(data->udev);1692 1693	err = usb_submit_urb(urb, GFP_ATOMIC);1694	if (err < 0) {1695		/* -EPERM: urb is being killed;1696		 * -ENODEV: device got disconnected1697		 */1698		if (err != -EPERM && err != -ENODEV)1699			bt_dev_err(hdev, "urb %p failed to resubmit (%d)",1700				   urb, -err);1701		usb_unanchor_urb(urb);1702	}1703}1704 1705static int btusb_submit_diag_urb(struct hci_dev *hdev, gfp_t mem_flags)1706{1707	struct btusb_data *data = hci_get_drvdata(hdev);1708	struct urb *urb;1709	unsigned char *buf;1710	unsigned int pipe;1711	int err, size = HCI_MAX_FRAME_SIZE;1712 1713	BT_DBG("%s", hdev->name);1714 1715	if (!data->diag_rx_ep)1716		return -ENODEV;1717 1718	urb = usb_alloc_urb(0, mem_flags);1719	if (!urb)1720		return -ENOMEM;1721 1722	buf = kmalloc(size, mem_flags);1723	if (!buf) {1724		usb_free_urb(urb);1725		return -ENOMEM;1726	}1727 1728	pipe = usb_rcvbulkpipe(data->udev, data->diag_rx_ep->bEndpointAddress);1729 1730	usb_fill_bulk_urb(urb, data->udev, pipe, buf, size,1731			  btusb_diag_complete, hdev);1732 1733	urb->transfer_flags |= URB_FREE_BUFFER;1734 1735	usb_mark_last_busy(data->udev);1736	usb_anchor_urb(urb, &data->diag_anchor);1737 1738	err = usb_submit_urb(urb, mem_flags);1739	if (err < 0) {1740		if (err != -EPERM && err != -ENODEV)1741			bt_dev_err(hdev, "urb %p submission failed (%d)",1742				   urb, -err);1743		usb_unanchor_urb(urb);1744	}1745 1746	usb_free_urb(urb);1747 1748	return err;1749}1750 1751static void btusb_tx_complete(struct urb *urb)1752{1753	struct sk_buff *skb = urb->context;1754	struct hci_dev *hdev = (struct hci_dev *)skb->dev;1755	struct btusb_data *data = hci_get_drvdata(hdev);1756	unsigned long flags;1757 1758	BT_DBG("%s urb %p status %d count %d", hdev->name, urb, urb->status,1759	       urb->actual_length);1760 1761	if (!test_bit(HCI_RUNNING, &hdev->flags))1762		goto done;1763 1764	if (!urb->status) {1765		hdev->stat.byte_tx += urb->transfer_buffer_length;1766	} else {1767		if (hci_skb_pkt_type(skb) == HCI_COMMAND_PKT)1768			hci_cmd_sync_cancel(hdev, -urb->status);1769		hdev->stat.err_tx++;1770	}1771 1772done:1773	spin_lock_irqsave(&data->txlock, flags);1774	data->tx_in_flight--;1775	spin_unlock_irqrestore(&data->txlock, flags);1776 1777	kfree(urb->setup_packet);1778 1779	kfree_skb(skb);1780}1781 1782static void btusb_isoc_tx_complete(struct urb *urb)1783{1784	struct sk_buff *skb = urb->context;1785	struct hci_dev *hdev = (struct hci_dev *)skb->dev;1786 1787	BT_DBG("%s urb %p status %d count %d", hdev->name, urb, urb->status,1788	       urb->actual_length);1789 1790	if (!test_bit(HCI_RUNNING, &hdev->flags))1791		goto done;1792 1793	if (!urb->status)1794		hdev->stat.byte_tx += urb->transfer_buffer_length;1795	else1796		hdev->stat.err_tx++;1797 1798done:1799	kfree(urb->setup_packet);1800 1801	kfree_skb(skb);1802}1803 1804static int btusb_open(struct hci_dev *hdev)1805{1806	struct btusb_data *data = hci_get_drvdata(hdev);1807	int err;1808 1809	BT_DBG("%s", hdev->name);1810 1811	err = usb_autopm_get_interface(data->intf);1812	if (err < 0)1813		return err;1814 1815	/* Patching USB firmware files prior to starting any URBs of HCI path1816	 * It is more safe to use USB bulk channel for downloading USB patch1817	 */1818	if (data->setup_on_usb) {1819		err = data->setup_on_usb(hdev);1820		if (err < 0)1821			goto setup_fail;1822	}1823 1824	data->intf->needs_remote_wakeup = 1;1825 1826	if (test_and_set_bit(BTUSB_INTR_RUNNING, &data->flags))1827		goto done;1828 1829	err = btusb_submit_intr_urb(hdev, GFP_KERNEL);1830	if (err < 0)1831		goto failed;1832 1833	err = btusb_submit_bulk_urb(hdev, GFP_KERNEL);1834	if (err < 0) {1835		usb_kill_anchored_urbs(&data->intr_anchor);1836		goto failed;1837	}1838 1839	set_bit(BTUSB_BULK_RUNNING, &data->flags);1840	btusb_submit_bulk_urb(hdev, GFP_KERNEL);1841 1842	if (data->diag) {1843		if (!btusb_submit_diag_urb(hdev, GFP_KERNEL))1844			set_bit(BTUSB_DIAG_RUNNING, &data->flags);1845	}1846 1847done:1848	usb_autopm_put_interface(data->intf);1849	return 0;1850 1851failed:1852	clear_bit(BTUSB_INTR_RUNNING, &data->flags);1853setup_fail:1854	usb_autopm_put_interface(data->intf);1855	return err;1856}1857 1858static void btusb_stop_traffic(struct btusb_data *data)1859{1860	usb_kill_anchored_urbs(&data->intr_anchor);1861	usb_kill_anchored_urbs(&data->bulk_anchor);1862	usb_kill_anchored_urbs(&data->isoc_anchor);1863	usb_kill_anchored_urbs(&data->diag_anchor);1864	usb_kill_anchored_urbs(&data->ctrl_anchor);1865}1866 1867static int btusb_close(struct hci_dev *hdev)1868{1869	struct btusb_data *data = hci_get_drvdata(hdev);1870	int err;1871 1872	BT_DBG("%s", hdev->name);1873 1874	cancel_delayed_work(&data->rx_work);1875	cancel_work_sync(&data->work);1876	cancel_work_sync(&data->waker);1877 1878	skb_queue_purge(&data->acl_q);1879 1880	clear_bit(BTUSB_ISOC_RUNNING, &data->flags);1881	clear_bit(BTUSB_BULK_RUNNING, &data->flags);1882	clear_bit(BTUSB_INTR_RUNNING, &data->flags);1883	clear_bit(BTUSB_DIAG_RUNNING, &data->flags);1884 1885	btusb_stop_traffic(data);1886	btusb_free_frags(data);1887 1888	err = usb_autopm_get_interface(data->intf);1889	if (err < 0)1890		goto failed;1891 1892	data->intf->needs_remote_wakeup = 0;1893 1894	/* Enable remote wake up for auto-suspend */1895	if (test_bit(BTUSB_WAKEUP_AUTOSUSPEND, &data->flags))1896		data->intf->needs_remote_wakeup = 1;1897 1898	usb_autopm_put_interface(data->intf);1899 1900failed:1901	usb_scuttle_anchored_urbs(&data->deferred);1902	return 0;1903}1904 1905static int btusb_flush(struct hci_dev *hdev)1906{1907	struct btusb_data *data = hci_get_drvdata(hdev);1908 1909	BT_DBG("%s", hdev->name);1910 1911	cancel_delayed_work(&data->rx_work);1912 1913	skb_queue_purge(&data->acl_q);1914 1915	usb_kill_anchored_urbs(&data->tx_anchor);1916	btusb_free_frags(data);1917 1918	return 0;1919}1920 1921static struct urb *alloc_ctrl_urb(struct hci_dev *hdev, struct sk_buff *skb)1922{1923	struct btusb_data *data = hci_get_drvdata(hdev);1924	struct usb_ctrlrequest *dr;1925	struct urb *urb;1926	unsigned int pipe;1927 1928	urb = usb_alloc_urb(0, GFP_KERNEL);1929	if (!urb)1930		return ERR_PTR(-ENOMEM);1931 1932	dr = kmalloc(sizeof(*dr), GFP_KERNEL);1933	if (!dr) {1934		usb_free_urb(urb);1935		return ERR_PTR(-ENOMEM);1936	}1937 1938	dr->bRequestType = data->cmdreq_type;1939	dr->bRequest     = data->cmdreq;1940	dr->wIndex       = 0;1941	dr->wValue       = 0;1942	dr->wLength      = __cpu_to_le16(skb->len);1943 1944	pipe = usb_sndctrlpipe(data->udev, 0x00);1945 1946	usb_fill_control_urb(urb, data->udev, pipe, (void *)dr,1947			     skb->data, skb->len, btusb_tx_complete, skb);1948 1949	skb->dev = (void *)hdev;1950 1951	return urb;1952}1953 1954static struct urb *alloc_bulk_urb(struct hci_dev *hdev, struct sk_buff *skb)1955{1956	struct btusb_data *data = hci_get_drvdata(hdev);1957	struct urb *urb;1958	unsigned int pipe;1959 1960	if (!data->bulk_tx_ep)1961		return ERR_PTR(-ENODEV);1962 1963	urb = usb_alloc_urb(0, GFP_KERNEL);1964	if (!urb)1965		return ERR_PTR(-ENOMEM);1966 1967	pipe = usb_sndbulkpipe(data->udev, data->bulk_tx_ep->bEndpointAddress);1968 1969	usb_fill_bulk_urb(urb, data->udev, pipe,1970			  skb->data, skb->len, btusb_tx_complete, skb);1971 1972	skb->dev = (void *)hdev;1973 1974	return urb;1975}1976 1977static struct urb *alloc_isoc_urb(struct hci_dev *hdev, struct sk_buff *skb)1978{1979	struct btusb_data *data = hci_get_drvdata(hdev);1980	struct urb *urb;1981	unsigned int pipe;1982 1983	if (!data->isoc_tx_ep)1984		return ERR_PTR(-ENODEV);1985 1986	urb = usb_alloc_urb(BTUSB_MAX_ISOC_FRAMES, GFP_KERNEL);1987	if (!urb)1988		return ERR_PTR(-ENOMEM);1989 1990	pipe = usb_sndisocpipe(data->udev, data->isoc_tx_ep->bEndpointAddress);1991 1992	usb_fill_int_urb(urb, data->udev, pipe,1993			 skb->data, skb->len, btusb_isoc_tx_complete,1994			 skb, data->isoc_tx_ep->bInterval);1995 1996	urb->transfer_flags  = URB_ISO_ASAP;1997 1998	if (data->isoc_altsetting == 6)1999		__fill_isoc_descriptor_msbc(urb, skb->len,2000					    le16_to_cpu(data->isoc_tx_ep->wMaxPacketSize),2001					    data);2002	else2003		__fill_isoc_descriptor(urb, skb->len,2004				       le16_to_cpu(data->isoc_tx_ep->wMaxPacketSize));2005	skb->dev = (void *)hdev;2006 2007	return urb;2008}2009 2010static int submit_tx_urb(struct hci_dev *hdev, struct urb *urb)2011{2012	struct btusb_data *data = hci_get_drvdata(hdev);2013	int err;2014 2015	usb_anchor_urb(urb, &data->tx_anchor);2016 2017	err = usb_submit_urb(urb, GFP_KERNEL);2018	if (err < 0) {2019		if (err != -EPERM && err != -ENODEV)2020			bt_dev_err(hdev, "urb %p submission failed (%d)",2021				   urb, -err);2022		kfree(urb->setup_packet);2023		usb_unanchor_urb(urb);2024	} else {2025		usb_mark_last_busy(data->udev);2026	}2027 2028	usb_free_urb(urb);2029	return err;2030}2031 2032static int submit_or_queue_tx_urb(struct hci_dev *hdev, struct urb *urb)2033{2034	struct btusb_data *data = hci_get_drvdata(hdev);2035	unsigned long flags;2036	bool suspending;2037 2038	spin_lock_irqsave(&data->txlock, flags);2039	suspending = test_bit(BTUSB_SUSPENDING, &data->flags);2040	if (!suspending)2041		data->tx_in_flight++;2042	spin_unlock_irqrestore(&data->txlock, flags);2043 2044	if (!suspending)2045		return submit_tx_urb(hdev, urb);2046 2047	usb_anchor_urb(urb, &data->deferred);2048	schedule_work(&data->waker);2049 2050	usb_free_urb(urb);2051	return 0;2052}2053 2054static int btusb_send_frame(struct hci_dev *hdev, struct sk_buff *skb)2055{2056	struct urb *urb;2057 2058	BT_DBG("%s", hdev->name);2059 2060	switch (hci_skb_pkt_type(skb)) {2061	case HCI_COMMAND_PKT:2062		urb = alloc_ctrl_urb(hdev, skb);2063		if (IS_ERR(urb))2064			return PTR_ERR(urb);2065 2066		hdev->stat.cmd_tx++;2067		return submit_or_queue_tx_urb(hdev, urb);2068 2069	case HCI_ACLDATA_PKT:2070		urb = alloc_bulk_urb(hdev, skb);2071		if (IS_ERR(urb))2072			return PTR_ERR(urb);2073 2074		hdev->stat.acl_tx++;2075		return submit_or_queue_tx_urb(hdev, urb);2076 2077	case HCI_SCODATA_PKT:2078		if (hci_conn_num(hdev, SCO_LINK) < 1)2079			return -ENODEV;2080 2081		urb = alloc_isoc_urb(hdev, skb);2082		if (IS_ERR(urb))2083			return PTR_ERR(urb);2084 2085		hdev->stat.sco_tx++;2086		return submit_tx_urb(hdev, urb);2087 2088	case HCI_ISODATA_PKT:2089		urb = alloc_bulk_urb(hdev, skb);2090		if (IS_ERR(urb))2091			return PTR_ERR(urb);2092 2093		return submit_or_queue_tx_urb(hdev, urb);2094	}2095 2096	return -EILSEQ;2097}2098 2099static void btusb_notify(struct hci_dev *hdev, unsigned int evt)2100{2101	struct btusb_data *data = hci_get_drvdata(hdev);2102 2103	BT_DBG("%s evt %d", hdev->name, evt);2104 2105	if (hci_conn_num(hdev, SCO_LINK) != data->sco_num) {2106		data->sco_num = hci_conn_num(hdev, SCO_LINK);2107		data->air_mode = evt;2108		schedule_work(&data->work);2109	}2110}2111 2112static inline int __set_isoc_interface(struct hci_dev *hdev, int altsetting)2113{2114	struct btusb_data *data = hci_get_drvdata(hdev);2115	struct usb_interface *intf = data->isoc;2116	struct usb_endpoint_descriptor *ep_desc;2117	int i, err;2118 2119	if (!data->isoc)2120		return -ENODEV;2121 2122	err = usb_set_interface(data->udev, data->isoc_ifnum, altsetting);2123	if (err < 0) {2124		bt_dev_err(hdev, "setting interface failed (%d)", -err);2125		return err;2126	}2127 2128	data->isoc_altsetting = altsetting;2129 2130	data->isoc_tx_ep = NULL;2131	data->isoc_rx_ep = NULL;2132 2133	for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++) {2134		ep_desc = &intf->cur_altsetting->endpoint[i].desc;2135 2136		if (!data->isoc_tx_ep && usb_endpoint_is_isoc_out(ep_desc)) {2137			data->isoc_tx_ep = ep_desc;2138			continue;2139		}2140 2141		if (!data->isoc_rx_ep && usb_endpoint_is_isoc_in(ep_desc)) {2142			data->isoc_rx_ep = ep_desc;2143			continue;2144		}2145	}2146 2147	if (!data->isoc_tx_ep || !data->isoc_rx_ep) {2148		bt_dev_err(hdev, "invalid SCO descriptors");2149		return -ENODEV;2150	}2151 2152	return 0;2153}2154 2155static int btusb_switch_alt_setting(struct hci_dev *hdev, int new_alts)2156{2157	struct btusb_data *data = hci_get_drvdata(hdev);2158	int err;2159 2160	if (data->isoc_altsetting != new_alts) {2161		unsigned long flags;2162 2163		clear_bit(BTUSB_ISOC_RUNNING, &data->flags);2164		usb_kill_anchored_urbs(&data->isoc_anchor);2165 2166		/* When isochronous alternate setting needs to be2167		 * changed, because SCO connection has been added2168		 * or removed, a packet fragment may be left in the2169		 * reassembling state. This could lead to wrongly2170		 * assembled fragments.2171		 *2172		 * Clear outstanding fragment when selecting a new2173		 * alternate setting.2174		 */2175		spin_lock_irqsave(&data->rxlock, flags);2176		dev_kfree_skb_irq(data->sco_skb);2177		data->sco_skb = NULL;2178		spin_unlock_irqrestore(&data->rxlock, flags);2179 2180		err = __set_isoc_interface(hdev, new_alts);2181		if (err < 0)2182			return err;2183	}2184 2185	if (!test_and_set_bit(BTUSB_ISOC_RUNNING, &data->flags)) {2186		if (btusb_submit_isoc_urb(hdev, GFP_KERNEL) < 0)2187			clear_bit(BTUSB_ISOC_RUNNING, &data->flags);2188		else2189			btusb_submit_isoc_urb(hdev, GFP_KERNEL);2190	}2191 2192	return 0;2193}2194 2195static struct usb_host_interface *btusb_find_altsetting(struct btusb_data *data,2196							int alt)2197{2198	struct usb_interface *intf = data->isoc;2199	int i;2200 2201	BT_DBG("Looking for Alt no :%d", alt);2202 2203	if (!intf)2204		return NULL;2205 2206	for (i = 0; i < intf->num_altsetting; i++) {2207		if (intf->altsetting[i].desc.bAlternateSetting == alt)2208			return &intf->altsetting[i];2209	}2210 2211	return NULL;2212}2213 2214static void btusb_work(struct work_struct *work)2215{2216	struct btusb_data *data = container_of(work, struct btusb_data, work);2217	struct hci_dev *hdev = data->hdev;2218	int new_alts = 0;2219	int err;2220 2221	if (data->sco_num > 0) {2222		if (!test_bit(BTUSB_DID_ISO_RESUME, &data->flags)) {2223			err = usb_autopm_get_interface(data->isoc ? data->isoc : data->intf);2224			if (err < 0) {2225				clear_bit(BTUSB_ISOC_RUNNING, &data->flags);2226				usb_kill_anchored_urbs(&data->isoc_anchor);2227				return;2228			}2229 2230			set_bit(BTUSB_DID_ISO_RESUME, &data->flags);2231		}2232 2233		if (data->air_mode == HCI_NOTIFY_ENABLE_SCO_CVSD) {2234			if (hdev->voice_setting & 0x0020) {2235				static const int alts[3] = { 2, 4, 5 };2236 2237				new_alts = alts[data->sco_num - 1];2238			} else {2239				new_alts = data->sco_num;2240			}2241		} else if (data->air_mode == HCI_NOTIFY_ENABLE_SCO_TRANSP) {2242			/* Bluetooth USB spec recommends alt 6 (63 bytes), but2243			 * many adapters do not support it.  Alt 1 appears to2244			 * work for all adapters that do not have alt 6, and2245			 * which work with WBS at all.  Some devices prefer2246			 * alt 3 (HCI payload >= 60 Bytes let air packet2247			 * data satisfy 60 bytes), requiring2248			 * MTU >= 3 (packets) * 25 (size) - 3 (headers) = 722249			 * see also Core spec 5, vol 4, B 2.1.1 & Table 2.1.2250			 */2251			if (btusb_find_altsetting(data, 6))2252				new_alts = 6;2253			else if (btusb_find_altsetting(data, 3) &&2254				 hdev->sco_mtu >= 72 &&2255				 test_bit(BTUSB_USE_ALT3_FOR_WBS, &data->flags))2256				new_alts = 3;2257			else2258				new_alts = 1;2259		}2260 2261		if (btusb_switch_alt_setting(hdev, new_alts) < 0)2262			bt_dev_err(hdev, "set USB alt:(%d) failed!", new_alts);2263	} else {2264		usb_kill_anchored_urbs(&data->isoc_anchor);2265 2266		if (test_and_clear_bit(BTUSB_ISOC_RUNNING, &data->flags))2267			__set_isoc_interface(hdev, 0);2268 2269		if (test_and_clear_bit(BTUSB_DID_ISO_RESUME, &data->flags))2270			usb_autopm_put_interface(data->isoc ? data->isoc : data->intf);2271	}2272}2273 2274static void btusb_waker(struct work_struct *work)2275{2276	struct btusb_data *data = container_of(work, struct btusb_data, waker);2277	int err;2278 2279	err = usb_autopm_get_interface(data->intf);2280	if (err < 0)2281		return;2282 2283	usb_autopm_put_interface(data->intf);2284}2285 2286static void btusb_rx_work(struct work_struct *work)2287{2288	struct btusb_data *data = container_of(work, struct btusb_data,2289					       rx_work.work);2290	struct sk_buff *skb;2291 2292	/* Dequeue ACL data received during the interval */2293	while ((skb = skb_dequeue(&data->acl_q)))2294		data->recv_acl(data->hdev, skb);2295}2296 2297static int btusb_setup_bcm92035(struct hci_dev *hdev)2298{2299	struct sk_buff *skb;2300	u8 val = 0x00;2301 2302	BT_DBG("%s", hdev->name);2303 2304	skb = __hci_cmd_sync(hdev, 0xfc3b, 1, &val, HCI_INIT_TIMEOUT);2305	if (IS_ERR(skb))2306		bt_dev_err(hdev, "BCM92035 command failed (%ld)", PTR_ERR(skb));2307	else2308		kfree_skb(skb);2309 2310	return 0;2311}2312 2313static int btusb_setup_csr(struct hci_dev *hdev)2314{2315	struct btusb_data *data = hci_get_drvdata(hdev);2316	u16 bcdDevice = le16_to_cpu(data->udev->descriptor.bcdDevice);2317	struct hci_rp_read_local_version *rp;2318	struct sk_buff *skb;2319	bool is_fake = false;2320	int ret;2321 2322	BT_DBG("%s", hdev->name);2323 2324	skb = __hci_cmd_sync(hdev, HCI_OP_READ_LOCAL_VERSION, 0, NULL,2325			     HCI_INIT_TIMEOUT);2326	if (IS_ERR(skb)) {2327		int err = PTR_ERR(skb);2328		bt_dev_err(hdev, "CSR: Local version failed (%d)", err);2329		return err;2330	}2331 2332	rp = skb_pull_data(skb, sizeof(*rp));2333	if (!rp) {2334		bt_dev_err(hdev, "CSR: Local version length mismatch");2335		kfree_skb(skb);2336		return -EIO;2337	}2338 2339	bt_dev_info(hdev, "CSR: Setting up dongle with HCI ver=%u rev=%04x",2340		    rp->hci_ver, le16_to_cpu(rp->hci_rev));2341 2342	bt_dev_info(hdev, "LMP ver=%u subver=%04x; manufacturer=%u",2343		    rp->lmp_ver, le16_to_cpu(rp->lmp_subver),2344		    le16_to_cpu(rp->manufacturer));2345 2346	/* Detect a wide host of Chinese controllers that aren't CSR.2347	 *2348	 * Known fake bcdDevices: 0x0100, 0x0134, 0x1915, 0x2520, 0x7558, 0x88912349	 *2350	 * The main thing they have in common is that these are really popular low-cost2351	 * options that support newer Bluetooth versions but rely on heavy VID/PID2352	 * squatting of this poor old Bluetooth 1.1 device. Even sold as such.2353	 *2354	 * We detect actual CSR devices by checking that the HCI manufacturer code2355	 * is Cambridge Silicon Radio (10) and ensuring that LMP sub-version and2356	 * HCI rev values always match. As they both store the firmware number.2357	 */2358	if (le16_to_cpu(rp->manufacturer) != 10 ||2359	    le16_to_cpu(rp->hci_rev) != le16_to_cpu(rp->lmp_subver))2360		is_fake = true;2361 2362	/* Known legit CSR firmware build numbers and their supported BT versions:2363	 * - 1.1 (0x1) -> 0x0073, 0x020d, 0x033c, 0x034e2364	 * - 1.2 (0x2) ->                 0x04d9, 0x05292365	 * - 2.0 (0x3) ->         0x07a6, 0x07ad, 0x0c5c2366	 * - 2.1 (0x4) ->         0x149c, 0x1735, 0x1899 (0x1899 is a BlueCore4-External)2367	 * - 4.0 (0x6) ->         0x1d86, 0x2031, 0x22bb2368	 *2369	 * e.g. Real CSR dongles with LMP subversion 0x73 are old enough that2370	 *      support BT 1.1 only; so it's a dead giveaway when some2371	 *      third-party BT 4.0 dongle reuses it.2372	 */2373	else if (le16_to_cpu(rp->lmp_subver) <= 0x034e &&2374		 rp->hci_ver > BLUETOOTH_VER_1_1)2375		is_fake = true;2376 2377	else if (le16_to_cpu(rp->lmp_subver) <= 0x0529 &&2378		 rp->hci_ver > BLUETOOTH_VER_1_2)2379		is_fake = true;2380 2381	else if (le16_to_cpu(rp->lmp_subver) <= 0x0c5c &&2382		 rp->hci_ver > BLUETOOTH_VER_2_0)2383		is_fake = true;2384 2385	else if (le16_to_cpu(rp->lmp_subver) <= 0x1899 &&2386		 rp->hci_ver > BLUETOOTH_VER_2_1)2387		is_fake = true;2388 2389	else if (le16_to_cpu(rp->lmp_subver) <= 0x22bb &&2390		 rp->hci_ver > BLUETOOTH_VER_4_0)2391		is_fake = true;2392 2393	/* Other clones which beat all the above checks */2394	else if (bcdDevice == 0x0134 &&2395		 le16_to_cpu(rp->lmp_subver) == 0x0c5c &&2396		 rp->hci_ver == BLUETOOTH_VER_2_0)2397		is_fake = true;2398 2399	if (is_fake) {2400		bt_dev_warn(hdev, "CSR: Unbranded CSR clone detected; adding workarounds and force-suspending once...");2401 2402		/* Generally these clones have big discrepancies between2403		 * advertised features and what's actually supported.2404		 * Probably will need to be expanded in the future;2405		 * without these the controller will lock up.2406		 */2407		set_bit(HCI_QUIRK_BROKEN_STORED_LINK_KEY, &hdev->quirks);2408		set_bit(HCI_QUIRK_BROKEN_ERR_DATA_REPORTING, &hdev->quirks);2409		set_bit(HCI_QUIRK_BROKEN_FILTER_CLEAR_ALL, &hdev->quirks);2410		set_bit(HCI_QUIRK_NO_SUSPEND_NOTIFIER, &hdev->quirks);2411 2412		/* Clear the reset quirk since this is not an actual2413		 * early Bluetooth 1.1 device from CSR.2414		 */2415		clear_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks);2416		clear_bit(HCI_QUIRK_SIMULTANEOUS_DISCOVERY, &hdev->quirks);2417 2418		/*2419		 * Special workaround for these BT 4.0 chip clones, and potentially more:2420		 *2421		 * - 0x0134: a Barrot 8041a02                 (HCI rev: 0x0810 sub: 0x1012)2422		 * - 0x7558: IC markings FR3191AHAL 749H15143 (HCI rev/sub-version: 0x0709)2423		 *2424		 * These controllers are really messed-up.2425		 *2426		 * 1. Their bulk RX endpoint will never report any data unless2427		 *    the device was suspended at least once (yes, really).2428		 * 2. They will not wakeup when autosuspended and receiving data2429		 *    on their bulk RX endpoint from e.g. a keyboard or mouse2430		 *    (IOW remote-wakeup support is broken for the bulk endpoint).2431		 *2432		 * To fix 1. enable runtime-suspend, force-suspend the2433		 * HCI and then wake-it up by disabling runtime-suspend.2434		 *2435		 * To fix 2. clear the HCI's can_wake flag, this way the HCI2436		 * will still be autosuspended when it is not open.2437		 *2438		 * --2439		 *2440		 * Because these are widespread problems we prefer generic solutions; so2441		 * apply this initialization quirk to every controller that gets here,2442		 * it should be harmless. The alternative is to not work at all.2443		 */2444		pm_runtime_allow(&data->udev->dev);2445 2446		ret = pm_runtime_suspend(&data->udev->dev);2447		if (ret >= 0)2448			msleep(200);2449		else2450			bt_dev_warn(hdev, "CSR: Couldn't suspend the device for our Barrot 8041a02 receive-issue workaround");2451 2452		pm_runtime_forbid(&data->udev->dev);2453 2454		device_set_wakeup_capable(&data->udev->dev, false);2455 2456		/* Re-enable autosuspend if this was requested */2457		if (enable_autosuspend)2458			usb_enable_autosuspend(data->udev);2459	}2460 2461	kfree_skb(skb);2462 2463	return 0;2464}2465 2466static int inject_cmd_complete(struct hci_dev *hdev, __u16 opcode)2467{2468	struct sk_buff *skb;2469	struct hci_event_hdr *hdr;2470	struct hci_ev_cmd_complete *evt;2471 2472	skb = bt_skb_alloc(sizeof(*hdr) + sizeof(*evt) + 1, GFP_KERNEL);2473	if (!skb)2474		return -ENOMEM;2475 2476	hdr = skb_put(skb, sizeof(*hdr));2477	hdr->evt = HCI_EV_CMD_COMPLETE;2478	hdr->plen = sizeof(*evt) + 1;2479 2480	evt = skb_put(skb, sizeof(*evt));2481	evt->ncmd = 0x01;2482	evt->opcode = cpu_to_le16(opcode);2483 2484	skb_put_u8(skb, 0x00);2485 2486	hci_skb_pkt_type(skb) = HCI_EVENT_PKT;2487 2488	return hci_recv_frame(hdev, skb);2489}2490 2491static int btusb_recv_bulk_intel(struct btusb_data *data, void *buffer,2492				 int count)2493{2494	struct hci_dev *hdev = data->hdev;2495 2496	/* When the device is in bootloader mode, then it can send2497	 * events via the bulk endpoint. These events are treated the2498	 * same way as the ones received from the interrupt endpoint.2499	 */2500	if (btintel_test_flag(hdev, INTEL_BOOTLOADER))2501		return btusb_recv_intr(data, buffer, count);2502 2503	return btusb_recv_bulk(data, buffer, count);2504}2505 2506static int btusb_send_frame_intel(struct hci_dev *hdev, struct sk_buff *skb)2507{2508	struct urb *urb;2509 2510	BT_DBG("%s", hdev->name);2511 2512	switch (hci_skb_pkt_type(skb)) {2513	case HCI_COMMAND_PKT:2514		if (btintel_test_flag(hdev, INTEL_BOOTLOADER)) {2515			struct hci_command_hdr *cmd = (void *)skb->data;2516			__u16 opcode = le16_to_cpu(cmd->opcode);2517 2518			/* When in bootloader mode and the command 0xfc092519			 * is received, it needs to be send down the2520			 * bulk endpoint. So allocate a bulk URB instead.2521			 */2522			if (opcode == 0xfc09)2523				urb = alloc_bulk_urb(hdev, skb);2524			else2525				urb = alloc_ctrl_urb(hdev, skb);2526 2527			/* When the 0xfc01 command is issued to boot into2528			 * the operational firmware, it will actually not2529			 * send a command complete event. To keep the flow2530			 * control working inject that event here.2531			 */2532			if (opcode == 0xfc01)2533				inject_cmd_complete(hdev, opcode);2534		} else {2535			urb = alloc_ctrl_urb(hdev, skb);2536		}2537		if (IS_ERR(urb))2538			return PTR_ERR(urb);2539 2540		hdev->stat.cmd_tx++;2541		return submit_or_queue_tx_urb(hdev, urb);2542 2543	case HCI_ACLDATA_PKT:2544		urb = alloc_bulk_urb(hdev, skb);2545		if (IS_ERR(urb))2546			return PTR_ERR(urb);2547 2548		hdev->stat.acl_tx++;2549		return submit_or_queue_tx_urb(hdev, urb);2550 2551	case HCI_SCODATA_PKT:2552		if (hci_conn_num(hdev, SCO_LINK) < 1)2553			return -ENODEV;2554 2555		urb = alloc_isoc_urb(hdev, skb);2556		if (IS_ERR(urb))2557			return PTR_ERR(urb);2558 2559		hdev->stat.sco_tx++;2560		return submit_tx_urb(hdev, urb);2561 2562	case HCI_ISODATA_PKT:2563		urb = alloc_bulk_urb(hdev, skb);2564		if (IS_ERR(urb))2565			return PTR_ERR(urb);2566 2567		return submit_or_queue_tx_urb(hdev, urb);2568	}2569 2570	return -EILSEQ;2571}2572 2573static int btusb_setup_realtek(struct hci_dev *hdev)2574{2575	struct btusb_data *data = hci_get_drvdata(hdev);2576	int ret;2577 2578	ret = btrtl_setup_realtek(hdev);2579 2580	if (btrealtek_test_flag(data->hdev, REALTEK_ALT6_CONTINUOUS_TX_CHIP))2581		set_bit(BTUSB_ALT6_CONTINUOUS_TX, &data->flags);2582 2583	return ret;2584}2585 2586static int btusb_recv_event_realtek(struct hci_dev *hdev, struct sk_buff *skb)2587{2588	if (skb->data[0] == HCI_VENDOR_PKT && skb->data[2] == RTK_SUB_EVENT_CODE_COREDUMP) {2589		struct rtk_dev_coredump_hdr hdr = {2590			.code = RTK_DEVCOREDUMP_CODE_MEMDUMP,2591		};2592 2593		bt_dev_dbg(hdev, "RTL: received coredump vendor evt, len %u",2594			skb->len);2595 2596		btusb_rtl_alloc_devcoredump(hdev, &hdr, skb->data, skb->len);2597		kfree_skb(skb);2598 2599		return 0;2600	}2601 2602	return hci_recv_frame(hdev, skb);2603}2604 2605static void btusb_mtk_claim_iso_intf(struct btusb_data *data)2606{2607	struct btmtk_data *btmtk_data = hci_get_priv(data->hdev);2608	int err;2609 2610	err = usb_driver_claim_interface(&btusb_driver,2611					 btmtk_data->isopkt_intf, data);2612	if (err < 0) {2613		btmtk_data->isopkt_intf = NULL;2614		bt_dev_err(data->hdev, "Failed to claim iso interface");2615		return;2616	}2617 2618	set_bit(BTMTK_ISOPKT_OVER_INTR, &btmtk_data->flags);2619}2620 2621static void btusb_mtk_release_iso_intf(struct btusb_data *data)2622{2623	struct btmtk_data *btmtk_data = hci_get_priv(data->hdev);2624 2625	if (btmtk_data->isopkt_intf) {2626		usb_kill_anchored_urbs(&btmtk_data->isopkt_anchor);2627		clear_bit(BTMTK_ISOPKT_RUNNING, &btmtk_data->flags);2628 2629		dev_kfree_skb_irq(btmtk_data->isopkt_skb);2630		btmtk_data->isopkt_skb = NULL;2631		usb_set_intfdata(btmtk_data->isopkt_intf, NULL);2632		usb_driver_release_interface(&btusb_driver,2633					     btmtk_data->isopkt_intf);2634	}2635 2636	clear_bit(BTMTK_ISOPKT_OVER_INTR, &btmtk_data->flags);2637}2638 2639static int btusb_mtk_reset(struct hci_dev *hdev, void *rst_data)2640{2641	struct btusb_data *data = hci_get_drvdata(hdev);2642	struct btmtk_data *btmtk_data = hci_get_priv(hdev);2643	int err;2644 2645	/* It's MediaTek specific bluetooth reset mechanism via USB */2646	if (test_and_set_bit(BTMTK_HW_RESET_ACTIVE, &btmtk_data->flags)) {2647		bt_dev_err(hdev, "last reset failed? Not resetting again");2648		return -EBUSY;2649	}2650 2651	err = usb_autopm_get_interface(data->intf);2652	if (err < 0)2653		return err;2654 2655	if (test_bit(BTMTK_ISOPKT_RUNNING, &btmtk_data->flags))2656		btusb_mtk_release_iso_intf(data);2657 2658	btusb_stop_traffic(data);2659	usb_kill_anchored_urbs(&data->tx_anchor);2660 2661	err = btmtk_usb_subsys_reset(hdev, btmtk_data->dev_id);2662 2663	usb_queue_reset_device(data->intf);2664	clear_bit(BTMTK_HW_RESET_ACTIVE, &btmtk_data->flags);2665 2666	return err;2667}2668 2669static int btusb_send_frame_mtk(struct hci_dev *hdev, struct sk_buff *skb)2670{2671	struct urb *urb;2672 2673	BT_DBG("%s", hdev->name);2674 2675	if (hci_skb_pkt_type(skb) == HCI_ISODATA_PKT) {2676		urb = alloc_mtk_intr_urb(hdev, skb, btusb_tx_complete);2677		if (IS_ERR(urb))2678			return PTR_ERR(urb);2679 2680		return submit_or_queue_tx_urb(hdev, urb);2681	} else {2682		return btusb_send_frame(hdev, skb);2683	}2684}2685 2686static int btusb_mtk_setup(struct hci_dev *hdev)2687{2688	struct btusb_data *data = hci_get_drvdata(hdev);2689	struct btmtk_data *btmtk_data = hci_get_priv(hdev);2690 2691	/* MediaTek WMT vendor cmd requiring below USB resources to2692	 * complete the handshake.2693	 */2694	btmtk_data->drv_name = btusb_driver.name;2695	btmtk_data->intf = data->intf;2696	btmtk_data->udev = data->udev;2697	btmtk_data->ctrl_anchor = &data->ctrl_anchor;2698	btmtk_data->reset_sync = btusb_mtk_reset;2699 2700	/* Claim ISO data interface and endpoint */2701	btmtk_data->isopkt_intf = usb_ifnum_to_if(data->udev, MTK_ISO_IFNUM);2702	if (btmtk_data->isopkt_intf)2703		btusb_mtk_claim_iso_intf(data);2704 2705	return btmtk_usb_setup(hdev);2706}2707 2708static int btusb_mtk_shutdown(struct hci_dev *hdev)2709{2710	struct btusb_data *data = hci_get_drvdata(hdev);2711	struct btmtk_data *btmtk_data = hci_get_priv(hdev);2712 2713	if (test_bit(BTMTK_ISOPKT_RUNNING, &btmtk_data->flags))2714		btusb_mtk_release_iso_intf(data);2715 2716	return btmtk_usb_shutdown(hdev);2717}2718 2719#ifdef CONFIG_PM2720/* Configure an out-of-band gpio as wake-up pin, if specified in device tree */2721static int marvell_config_oob_wake(struct hci_dev *hdev)2722{2723	struct sk_buff *skb;2724	struct btusb_data *data = hci_get_drvdata(hdev);2725	struct device *dev = &data->udev->dev;2726	u16 pin, gap, opcode;2727	int ret;2728	u8 cmd[5];2729 2730	/* Move on if no wakeup pin specified */2731	if (of_property_read_u16(dev->of_node, "marvell,wakeup-pin", &pin) ||2732	    of_property_read_u16(dev->of_node, "marvell,wakeup-gap-ms", &gap))2733		return 0;2734 2735	/* Vendor specific command to configure a GPIO as wake-up pin */2736	opcode = hci_opcode_pack(0x3F, 0x59);2737	cmd[0] = opcode & 0xFF;2738	cmd[1] = opcode >> 8;2739	cmd[2] = 2; /* length of parameters that follow */2740	cmd[3] = pin;2741	cmd[4] = gap; /* time in ms, for which wakeup pin should be asserted */2742 2743	skb = bt_skb_alloc(sizeof(cmd), GFP_KERNEL);2744	if (!skb) {2745		bt_dev_err(hdev, "%s: No memory", __func__);2746		return -ENOMEM;2747	}2748 2749	skb_put_data(skb, cmd, sizeof(cmd));2750	hci_skb_pkt_type(skb) = HCI_COMMAND_PKT;2751 2752	ret = btusb_send_frame(hdev, skb);2753	if (ret) {2754		bt_dev_err(hdev, "%s: configuration failed", __func__);2755		kfree_skb(skb);2756		return ret;2757	}2758 2759	return 0;2760}2761#endif2762 2763static int btusb_set_bdaddr_marvell(struct hci_dev *hdev,2764				    const bdaddr_t *bdaddr)2765{2766	struct sk_buff *skb;2767	u8 buf[8];2768	long ret;2769 2770	buf[0] = 0xfe;2771	buf[1] = sizeof(bdaddr_t);2772	memcpy(buf + 2, bdaddr, sizeof(bdaddr_t));2773 2774	skb = __hci_cmd_sync(hdev, 0xfc22, sizeof(buf), buf, HCI_INIT_TIMEOUT);2775	if (IS_ERR(skb)) {2776		ret = PTR_ERR(skb);2777		bt_dev_err(hdev, "changing Marvell device address failed (%ld)",2778			   ret);2779		return ret;2780	}2781	kfree_skb(skb);2782 2783	return 0;2784}2785 2786static int btusb_set_bdaddr_ath3012(struct hci_dev *hdev,2787				    const bdaddr_t *bdaddr)2788{2789	struct sk_buff *skb;2790	u8 buf[10];2791	long ret;2792 2793	buf[0] = 0x01;2794	buf[1] = 0x01;2795	buf[2] = 0x00;2796	buf[3] = sizeof(bdaddr_t);2797	memcpy(buf + 4, bdaddr, sizeof(bdaddr_t));2798 2799	skb = __hci_cmd_sync(hdev, 0xfc0b, sizeof(buf), buf, HCI_INIT_TIMEOUT);2800	if (IS_ERR(skb)) {2801		ret = PTR_ERR(skb);2802		bt_dev_err(hdev, "Change address command failed (%ld)", ret);2803		return ret;2804	}2805	kfree_skb(skb);2806 2807	return 0;2808}2809 2810static int btusb_set_bdaddr_wcn6855(struct hci_dev *hdev,2811				const bdaddr_t *bdaddr)2812{2813	struct sk_buff *skb;2814	u8 buf[6];2815	long ret;2816 2817	memcpy(buf, bdaddr, sizeof(bdaddr_t));2818 2819	skb = __hci_cmd_sync_ev(hdev, 0xfc14, sizeof(buf), buf,2820				HCI_EV_CMD_COMPLETE, HCI_INIT_TIMEOUT);2821	if (IS_ERR(skb)) {2822		ret = PTR_ERR(skb);2823		bt_dev_err(hdev, "Change address command failed (%ld)", ret);2824		return ret;2825	}2826	kfree_skb(skb);2827 2828	return 0;2829}2830 2831#define QCA_MEMDUMP_ACL_HANDLE 0x2EDD2832#define QCA_MEMDUMP_SIZE_MAX  0x1000002833#define QCA_MEMDUMP_VSE_CLASS 0x012834#define QCA_MEMDUMP_MSG_TYPE 0x082835#define QCA_MEMDUMP_PKT_SIZE 2482836#define QCA_LAST_SEQUENCE_NUM 0xffff2837 2838struct qca_dump_hdr {2839	u8 vse_class;2840	u8 msg_type;2841	__le16 seqno;2842	u8 reserved;2843	union {2844		u8 data[0];2845		struct {2846			__le32 ram_dump_size;2847			u8 data0[0];2848		} __packed;2849	};2850} __packed;2851 2852 2853static void btusb_dump_hdr_qca(struct hci_dev *hdev, struct sk_buff *skb)2854{2855	char buf[128];2856	struct btusb_data *btdata = hci_get_drvdata(hdev);2857 2858	snprintf(buf, sizeof(buf), "Controller Name: 0x%x\n",2859			btdata->qca_dump.controller_id);2860	skb_put_data(skb, buf, strlen(buf));2861 2862	snprintf(buf, sizeof(buf), "Firmware Version: 0x%x\n",2863			btdata->qca_dump.fw_version);2864	skb_put_data(skb, buf, strlen(buf));2865 2866	snprintf(buf, sizeof(buf), "Driver: %s\nVendor: qca\n",2867			btusb_driver.name);2868	skb_put_data(skb, buf, strlen(buf));2869 2870	snprintf(buf, sizeof(buf), "VID: 0x%x\nPID:0x%x\n",2871			btdata->qca_dump.id_vendor, btdata->qca_dump.id_product);2872	skb_put_data(skb, buf, strlen(buf));2873 2874	snprintf(buf, sizeof(buf), "Lmp Subversion: 0x%x\n",2875			hdev->lmp_subver);2876	skb_put_data(skb, buf, strlen(buf));2877}2878 2879static void btusb_coredump_qca(struct hci_dev *hdev)2880{2881	int err;2882	static const u8 param[] = { 0x26 };2883 2884	err = __hci_cmd_send(hdev, 0xfc0c, 1, param);2885	if (err < 0)2886		bt_dev_err(hdev, "%s: triggle crash failed (%d)", __func__, err);2887}2888 2889/*2890 * ==0: not a dump pkt.2891 * < 0: fails to handle a dump pkt2892 * > 0: otherwise.2893 */2894static int handle_dump_pkt_qca(struct hci_dev *hdev, struct sk_buff *skb)2895{2896	int ret = 1;2897	u8 pkt_type;2898	u8 *sk_ptr;2899	unsigned int sk_len;2900	u16 seqno;2901	u32 dump_size;2902 2903	struct hci_event_hdr *event_hdr;2904	struct hci_acl_hdr *acl_hdr;2905	struct qca_dump_hdr *dump_hdr;2906	struct btusb_data *btdata = hci_get_drvdata(hdev);2907	struct usb_device *udev = btdata->udev;2908 2909	pkt_type = hci_skb_pkt_type(skb);2910	sk_ptr = skb->data;2911	sk_len = skb->len;2912 2913	if (pkt_type == HCI_ACLDATA_PKT) {2914		acl_hdr = hci_acl_hdr(skb);2915		if (le16_to_cpu(acl_hdr->handle) != QCA_MEMDUMP_ACL_HANDLE)2916			return 0;2917		sk_ptr += HCI_ACL_HDR_SIZE;2918		sk_len -= HCI_ACL_HDR_SIZE;2919		event_hdr = (struct hci_event_hdr *)sk_ptr;2920	} else {2921		event_hdr = hci_event_hdr(skb);2922	}2923 2924	if ((event_hdr->evt != HCI_VENDOR_PKT)2925		|| (event_hdr->plen != (sk_len - HCI_EVENT_HDR_SIZE)))2926		return 0;2927 2928	sk_ptr += HCI_EVENT_HDR_SIZE;2929	sk_len -= HCI_EVENT_HDR_SIZE;2930 2931	dump_hdr = (struct qca_dump_hdr *)sk_ptr;2932	if ((sk_len < offsetof(struct qca_dump_hdr, data))2933		|| (dump_hdr->vse_class != QCA_MEMDUMP_VSE_CLASS)2934	    || (dump_hdr->msg_type != QCA_MEMDUMP_MSG_TYPE))2935		return 0;2936 2937	/*it is dump pkt now*/2938	seqno = le16_to_cpu(dump_hdr->seqno);2939	if (seqno == 0) {2940		set_bit(BTUSB_HW_SSR_ACTIVE, &btdata->flags);2941		dump_size = le32_to_cpu(dump_hdr->ram_dump_size);2942		if (!dump_size || (dump_size > QCA_MEMDUMP_SIZE_MAX)) {2943			ret = -EILSEQ;2944			bt_dev_err(hdev, "Invalid memdump size(%u)",2945				   dump_size);2946			goto out;2947		}2948 2949		ret = hci_devcd_init(hdev, dump_size);2950		if (ret < 0) {2951			bt_dev_err(hdev, "memdump init error(%d)", ret);2952			goto out;2953		}2954 2955		btdata->qca_dump.ram_dump_size = dump_size;2956		btdata->qca_dump.ram_dump_seqno = 0;2957		sk_ptr += offsetof(struct qca_dump_hdr, data0);2958		sk_len -= offsetof(struct qca_dump_hdr, data0);2959 2960		usb_disable_autosuspend(udev);2961		bt_dev_info(hdev, "%s memdump size(%u)\n",2962			    (pkt_type == HCI_ACLDATA_PKT) ? "ACL" : "event",2963			    dump_size);2964	} else {2965		sk_ptr += offsetof(struct qca_dump_hdr, data);2966		sk_len -= offsetof(struct qca_dump_hdr, data);2967	}2968 2969	if (!btdata->qca_dump.ram_dump_size) {2970		ret = -EINVAL;2971		bt_dev_err(hdev, "memdump is not active");2972		goto out;2973	}2974 2975	if ((seqno > btdata->qca_dump.ram_dump_seqno + 1) && (seqno != QCA_LAST_SEQUENCE_NUM)) {2976		dump_size = QCA_MEMDUMP_PKT_SIZE * (seqno - btdata->qca_dump.ram_dump_seqno - 1);2977		hci_devcd_append_pattern(hdev, 0x0, dump_size);2978		bt_dev_err(hdev,2979			   "expected memdump seqno(%u) is not received(%u)\n",2980			   btdata->qca_dump.ram_dump_seqno, seqno);2981		btdata->qca_dump.ram_dump_seqno = seqno;2982		kfree_skb(skb);2983		return ret;2984	}2985 2986	skb_pull(skb, skb->len - sk_len);2987	hci_devcd_append(hdev, skb);2988	btdata->qca_dump.ram_dump_seqno++;2989	if (seqno == QCA_LAST_SEQUENCE_NUM) {2990		bt_dev_info(hdev,2991				"memdump done: pkts(%u), total(%u)\n",2992				btdata->qca_dump.ram_dump_seqno, btdata->qca_dump.ram_dump_size);2993 2994		hci_devcd_complete(hdev);2995		goto out;2996	}2997	return ret;2998 2999out:3000	if (btdata->qca_dump.ram_dump_size)3001		usb_enable_autosuspend(udev);3002	btdata->qca_dump.ram_dump_size = 0;3003	btdata->qca_dump.ram_dump_seqno = 0;3004	clear_bit(BTUSB_HW_SSR_ACTIVE, &btdata->flags);3005 3006	if (ret < 0)3007		kfree_skb(skb);3008	return ret;3009}3010 3011static int btusb_recv_acl_qca(struct hci_dev *hdev, struct sk_buff *skb)3012{3013	if (handle_dump_pkt_qca(hdev, skb))3014		return 0;3015	return hci_recv_frame(hdev, skb);3016}3017 3018static int btusb_recv_evt_qca(struct hci_dev *hdev, struct sk_buff *skb)3019{3020	if (handle_dump_pkt_qca(hdev, skb))3021		return 0;3022	return hci_recv_frame(hdev, skb);3023}3024 3025 3026#define QCA_DFU_PACKET_LEN	40963027 3028#define QCA_GET_TARGET_VERSION	0x093029#define QCA_CHECK_STATUS	0x053030#define QCA_DFU_DOWNLOAD	0x013031 3032#define QCA_SYSCFG_UPDATED	0x403033#define QCA_PATCH_UPDATED	0x803034#define QCA_DFU_TIMEOUT		30003035#define QCA_FLAG_MULTI_NVM      0x803036#define QCA_BT_RESET_WAIT_MS    1003037 3038#define WCN6855_2_0_RAM_VERSION_GF 0x400c12003039#define WCN6855_2_1_RAM_VERSION_GF 0x400c12113040 3041struct qca_version {3042	__le32	rom_version;3043	__le32	patch_version;3044	__le32	ram_version;3045	__u8	chip_id;3046	__u8	platform_id;3047	__le16	flag;3048	__u8	reserved[4];3049} __packed;3050 3051struct qca_rampatch_version {3052	__le16	rom_version_high;3053	__le16  rom_version_low;3054	__le16	patch_version;3055} __packed;3056 3057struct qca_device_info {3058	u32	rom_version;3059	u8	rampatch_hdr;	/* length of header in rampatch */3060	u8	nvm_hdr;	/* length of header in NVM */3061	u8	ver_offset;	/* offset of version structure in rampatch */3062};3063 3064static const struct qca_device_info qca_devices_table[] = {3065	{ 0x00000100, 20, 4,  8 }, /* Rome 1.0 */3066	{ 0x00000101, 20, 4,  8 }, /* Rome 1.1 */3067	{ 0x00000200, 28, 4, 16 }, /* Rome 2.0 */3068	{ 0x00000201, 28, 4, 16 }, /* Rome 2.1 */3069	{ 0x00000300, 28, 4, 16 }, /* Rome 3.0 */3070	{ 0x00000302, 28, 4, 16 }, /* Rome 3.2 */3071	{ 0x00130100, 40, 4, 16 }, /* WCN6855 1.0 */3072	{ 0x00130200, 40, 4, 16 }, /* WCN6855 2.0 */3073	{ 0x00130201, 40, 4, 16 }, /* WCN6855 2.1 */3074	{ 0x00190200, 40, 4, 16 }, /* WCN785x 2.0 */3075};3076 3077static int btusb_qca_send_vendor_req(struct usb_device *udev, u8 request,3078				     void *data, u16 size)3079{3080	int pipe, err;3081	u8 *buf;3082 3083	buf = kmalloc(size, GFP_KERNEL);3084	if (!buf)3085		return -ENOMEM;3086 3087	/* Found some of USB hosts have IOT issues with ours so that we should3088	 * not wait until HCI layer is ready.3089	 */3090	pipe = usb_rcvctrlpipe(udev, 0);3091	err = usb_control_msg(udev, pipe, request, USB_TYPE_VENDOR | USB_DIR_IN,3092			      0, 0, buf, size, USB_CTRL_GET_TIMEOUT);3093	if (err < 0) {3094		dev_err(&udev->dev, "Failed to access otp area (%d)", err);3095		goto done;3096	}3097 3098	memcpy(data, buf, size);3099 3100done:3101	kfree(buf);3102 3103	return err;3104}3105 3106static int btusb_setup_qca_download_fw(struct hci_dev *hdev,3107				       const struct firmware *firmware,3108				       size_t hdr_size)3109{3110	struct btusb_data *btdata = hci_get_drvdata(hdev);3111	struct usb_device *udev = btdata->udev;3112	size_t count, size, sent = 0;3113	int pipe, len, err;3114	u8 *buf;3115 3116	buf = kmalloc(QCA_DFU_PACKET_LEN, GFP_KERNEL);3117	if (!buf)3118		return -ENOMEM;3119 3120	count = firmware->size;3121 3122	size = min_t(size_t, count, hdr_size);3123	memcpy(buf, firmware->data, size);3124 3125	/* USB patches should go down to controller through USB path3126	 * because binary format fits to go down through USB channel.3127	 * USB control path is for patching headers and USB bulk is for3128	 * patch body.3129	 */3130	pipe = usb_sndctrlpipe(udev, 0);3131	err = usb_control_msg(udev, pipe, QCA_DFU_DOWNLOAD, USB_TYPE_VENDOR,3132			      0, 0, buf, size, USB_CTRL_SET_TIMEOUT);3133	if (err < 0) {3134		bt_dev_err(hdev, "Failed to send headers (%d)", err);3135		goto done;3136	}3137 3138	sent += size;3139	count -= size;3140 3141	/* ep2 need time to switch from function acl to function dfu,3142	 * so we add 20ms delay here.3143	 */3144	msleep(20);3145 3146	while (count) {3147		size = min_t(size_t, count, QCA_DFU_PACKET_LEN);3148 3149		memcpy(buf, firmware->data + sent, size);3150 3151		pipe = usb_sndbulkpipe(udev, 0x02);3152		err = usb_bulk_msg(udev, pipe, buf, size, &len,3153				   QCA_DFU_TIMEOUT);3154		if (err < 0) {3155			bt_dev_err(hdev, "Failed to send body at %zd of %zd (%d)",3156				   sent, firmware->size, err);3157			break;3158		}3159 3160		if (size != len) {3161			bt_dev_err(hdev, "Failed to get bulk buffer");3162			err = -EILSEQ;3163			break;3164		}3165 3166		sent  += size;3167		count -= size;3168	}3169 3170done:3171	kfree(buf);3172	return err;3173}3174 3175static int btusb_setup_qca_load_rampatch(struct hci_dev *hdev,3176					 struct qca_version *ver,3177					 const struct qca_device_info *info)3178{3179	struct qca_rampatch_version *rver;3180	const struct firmware *fw;3181	u32 ver_rom, ver_patch, rver_rom;3182	u16 rver_rom_low, rver_rom_high, rver_patch;3183	char fwname[64];3184	int err;3185 3186	ver_rom = le32_to_cpu(ver->rom_version);3187	ver_patch = le32_to_cpu(ver->patch_version);3188 3189	snprintf(fwname, sizeof(fwname), "qca/rampatch_usb_%08x.bin", ver_rom);3190 3191	err = request_firmware(&fw, fwname, &hdev->dev);3192	if (err) {3193		bt_dev_err(hdev, "failed to request rampatch file: %s (%d)",3194			   fwname, err);3195		return err;3196	}3197 3198	bt_dev_info(hdev, "using rampatch file: %s", fwname);3199 3200	rver = (struct qca_rampatch_version *)(fw->data + info->ver_offset);3201	rver_rom_low = le16_to_cpu(rver->rom_version_low);3202	rver_patch = le16_to_cpu(rver->patch_version);3203 3204	if (ver_rom & ~0xffffU) {3205		rver_rom_high = le16_to_cpu(rver->rom_version_high);3206		rver_rom = rver_rom_high << 16 | rver_rom_low;3207	} else {3208		rver_rom = rver_rom_low;3209	}3210 3211	bt_dev_info(hdev, "QCA: patch rome 0x%x build 0x%x, "3212		    "firmware rome 0x%x build 0x%x",3213		    rver_rom, rver_patch, ver_rom, ver_patch);3214 3215	if (rver_rom != ver_rom || rver_patch <= ver_patch) {3216		bt_dev_err(hdev, "rampatch file version did not match with firmware");3217		err = -EINVAL;3218		goto done;3219	}3220 3221	err = btusb_setup_qca_download_fw(hdev, fw, info->rampatch_hdr);3222 3223done:3224	release_firmware(fw);3225 3226	return err;3227}3228 3229static void btusb_generate_qca_nvm_name(char *fwname, size_t max_size,3230					const struct qca_version *ver)3231{3232	u32 rom_version = le32_to_cpu(ver->rom_version);3233	u16 flag = le16_to_cpu(ver->flag);3234 3235	if (((flag >> 8) & 0xff) == QCA_FLAG_MULTI_NVM) {3236		/* The board_id should be split into two bytes3237		 * The 1st byte is chip ID, and the 2nd byte is platform ID3238		 * For example, board ID 0x010A, 0x01 is platform ID. 0x0A is chip ID3239		 * we have several platforms, and platform IDs are continuously added3240		 * Platform ID:3241		 * 0x00 is for Mobile3242		 * 0x01 is for X863243		 * 0x02 is for Automotive3244		 * 0x03 is for Consumer electronic3245		 */3246		u16 board_id = (ver->chip_id << 8) + ver->platform_id;3247		const char *variant;3248 3249		switch (le32_to_cpu(ver->ram_version)) {3250		case WCN6855_2_0_RAM_VERSION_GF:3251		case WCN6855_2_1_RAM_VERSION_GF:3252			variant = "_gf";3253			break;3254		default:3255			variant = "";3256			break;3257		}3258 3259		if (board_id == 0) {3260			snprintf(fwname, max_size, "qca/nvm_usb_%08x%s.bin",3261				rom_version, variant);3262		} else {3263			snprintf(fwname, max_size, "qca/nvm_usb_%08x%s_%04x.bin",3264				rom_version, variant, board_id);3265		}3266	} else {3267		snprintf(fwname, max_size, "qca/nvm_usb_%08x.bin",3268			rom_version);3269	}3270 3271}3272 3273static int btusb_setup_qca_load_nvm(struct hci_dev *hdev,3274				    struct qca_version *ver,3275				    const struct qca_device_info *info)3276{3277	const struct firmware *fw;3278	char fwname[64];3279	int err;3280 3281	btusb_generate_qca_nvm_name(fwname, sizeof(fwname), ver);3282 3283	err = request_firmware(&fw, fwname, &hdev->dev);3284	if (err) {3285		bt_dev_err(hdev, "failed to request NVM file: %s (%d)",3286			   fwname, err);3287		return err;3288	}3289 3290	bt_dev_info(hdev, "using NVM file: %s", fwname);3291 3292	err = btusb_setup_qca_download_fw(hdev, fw, info->nvm_hdr);3293 3294	release_firmware(fw);3295 3296	return err;3297}3298 3299/* identify the ROM version and check whether patches are needed */3300static bool btusb_qca_need_patch(struct usb_device *udev)3301{3302	struct qca_version ver;3303 3304	if (btusb_qca_send_vendor_req(udev, QCA_GET_TARGET_VERSION, &ver,3305				      sizeof(ver)) < 0)3306		return false;3307	/* only low ROM versions need patches */3308	return !(le32_to_cpu(ver.rom_version) & ~0xffffU);3309}3310 3311static int btusb_setup_qca(struct hci_dev *hdev)3312{3313	struct btusb_data *btdata = hci_get_drvdata(hdev);3314	struct usb_device *udev = btdata->udev;3315	const struct qca_device_info *info = NULL;3316	struct qca_version ver;3317	u32 ver_rom;3318	u8 status;3319	int i, err;3320 3321	err = btusb_qca_send_vendor_req(udev, QCA_GET_TARGET_VERSION, &ver,3322					sizeof(ver));3323	if (err < 0)3324		return err;3325 3326	ver_rom = le32_to_cpu(ver.rom_version);3327 3328	for (i = 0; i < ARRAY_SIZE(qca_devices_table); i++) {3329		if (ver_rom == qca_devices_table[i].rom_version)3330			info = &qca_devices_table[i];3331	}3332	if (!info) {3333		/* If the rom_version is not matched in the qca_devices_table3334		 * and the high ROM version is not zero, we assume this chip no3335		 * need to load the rampatch and nvm.3336		 */3337		if (ver_rom & ~0xffffU)3338			return 0;3339 3340		bt_dev_err(hdev, "don't support firmware rome 0x%x", ver_rom);3341		return -ENODEV;3342	}3343 3344	err = btusb_qca_send_vendor_req(udev, QCA_CHECK_STATUS, &status,3345					sizeof(status));3346	if (err < 0)3347		return err;3348 3349	if (!(status & QCA_PATCH_UPDATED)) {3350		err = btusb_setup_qca_load_rampatch(hdev, &ver, info);3351		if (err < 0)3352			return err;3353	}3354 3355	err = btusb_qca_send_vendor_req(udev, QCA_GET_TARGET_VERSION, &ver,3356					sizeof(ver));3357	if (err < 0)3358		return err;3359 3360	btdata->qca_dump.fw_version = le32_to_cpu(ver.patch_version);3361	btdata->qca_dump.controller_id = le32_to_cpu(ver.rom_version);3362 3363	if (!(status & QCA_SYSCFG_UPDATED)) {3364		err = btusb_setup_qca_load_nvm(hdev, &ver, info);3365		if (err < 0)3366			return err;3367 3368		/* WCN6855 2.1 and later will reset to apply firmware downloaded here, so3369		 * wait ~100ms for reset Done then go ahead, otherwise, it maybe3370		 * cause potential enable failure.3371		 */3372		if (info->rom_version >= 0x00130201)3373			msleep(QCA_BT_RESET_WAIT_MS);3374	}3375 3376	/* Mark HCI_OP_ENHANCED_SETUP_SYNC_CONN as broken as it doesn't seem to3377	 * work with the likes of HSP/HFP mSBC.3378	 */3379	set_bit(HCI_QUIRK_BROKEN_ENHANCED_SETUP_SYNC_CONN, &hdev->quirks);3380 3381	return 0;3382}3383 3384static inline int __set_diag_interface(struct hci_dev *hdev)3385{3386	struct btusb_data *data = hci_get_drvdata(hdev);3387	struct usb_interface *intf = data->diag;3388	int i;3389 3390	if (!data->diag)3391		return -ENODEV;3392 3393	data->diag_tx_ep = NULL;3394	data->diag_rx_ep = NULL;3395 3396	for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++) {3397		struct usb_endpoint_descriptor *ep_desc;3398 3399		ep_desc = &intf->cur_altsetting->endpoint[i].desc;3400 3401		if (!data->diag_tx_ep && usb_endpoint_is_bulk_out(ep_desc)) {3402			data->diag_tx_ep = ep_desc;3403			continue;3404		}3405 3406		if (!data->diag_rx_ep && usb_endpoint_is_bulk_in(ep_desc)) {3407			data->diag_rx_ep = ep_desc;3408			continue;3409		}3410	}3411 3412	if (!data->diag_tx_ep || !data->diag_rx_ep) {3413		bt_dev_err(hdev, "invalid diagnostic descriptors");3414		return -ENODEV;3415	}3416 3417	return 0;3418}3419 3420static struct urb *alloc_diag_urb(struct hci_dev *hdev, bool enable)3421{3422	struct btusb_data *data = hci_get_drvdata(hdev);3423	struct sk_buff *skb;3424	struct urb *urb;3425	unsigned int pipe;3426 3427	if (!data->diag_tx_ep)3428		return ERR_PTR(-ENODEV);3429 3430	urb = usb_alloc_urb(0, GFP_KERNEL);3431	if (!urb)3432		return ERR_PTR(-ENOMEM);3433 3434	skb = bt_skb_alloc(2, GFP_KERNEL);3435	if (!skb) {3436		usb_free_urb(urb);3437		return ERR_PTR(-ENOMEM);3438	}3439 3440	skb_put_u8(skb, 0xf0);3441	skb_put_u8(skb, enable);3442 3443	pipe = usb_sndbulkpipe(data->udev, data->diag_tx_ep->bEndpointAddress);3444 3445	usb_fill_bulk_urb(urb, data->udev, pipe,3446			  skb->data, skb->len, btusb_tx_complete, skb);3447 3448	skb->dev = (void *)hdev;3449 3450	return urb;3451}3452 3453static int btusb_bcm_set_diag(struct hci_dev *hdev, bool enable)3454{3455	struct btusb_data *data = hci_get_drvdata(hdev);3456	struct urb *urb;3457 3458	if (!data->diag)3459		return -ENODEV;3460 3461	if (!test_bit(HCI_RUNNING, &hdev->flags))3462		return -ENETDOWN;3463 3464	urb = alloc_diag_urb(hdev, enable);3465	if (IS_ERR(urb))3466		return PTR_ERR(urb);3467 3468	return submit_or_queue_tx_urb(hdev, urb);3469}3470 3471#ifdef CONFIG_PM3472static irqreturn_t btusb_oob_wake_handler(int irq, void *priv)3473{3474	struct btusb_data *data = priv;3475 3476	pm_wakeup_event(&data->udev->dev, 0);3477	pm_system_wakeup();3478 3479	/* Disable only if not already disabled (keep it balanced) */3480	if (test_and_clear_bit(BTUSB_OOB_WAKE_ENABLED, &data->flags)) {3481		disable_irq_nosync(irq);3482		disable_irq_wake(irq);3483	}3484	return IRQ_HANDLED;3485}3486 3487static const struct of_device_id btusb_match_table[] = {3488	{ .compatible = "usb1286,204e" },3489	{ .compatible = "usbcf3,e300" }, /* QCA6174A */3490	{ .compatible = "usb4ca,301a" }, /* QCA6174A (Lite-On) */3491	{ }3492};3493MODULE_DEVICE_TABLE(of, btusb_match_table);3494 3495/* Use an oob wakeup pin? */3496static int btusb_config_oob_wake(struct hci_dev *hdev)3497{3498	struct btusb_data *data = hci_get_drvdata(hdev);3499	struct device *dev = &data->udev->dev;3500	int irq, ret;3501 3502	clear_bit(BTUSB_OOB_WAKE_ENABLED, &data->flags);3503 3504	if (!of_match_device(btusb_match_table, dev))3505		return 0;3506 3507	/* Move on if no IRQ specified */3508	irq = of_irq_get_byname(dev->of_node, "wakeup");3509	if (irq <= 0) {3510		bt_dev_dbg(hdev, "%s: no OOB Wakeup IRQ in DT", __func__);3511		return 0;3512	}3513 3514	irq_set_status_flags(irq, IRQ_NOAUTOEN);3515	ret = devm_request_irq(&hdev->dev, irq, btusb_oob_wake_handler,3516			       0, "OOB Wake-on-BT", data);3517	if (ret) {3518		bt_dev_err(hdev, "%s: IRQ request failed", __func__);3519		return ret;3520	}3521 3522	ret = device_init_wakeup(dev, true);3523	if (ret) {3524		bt_dev_err(hdev, "%s: failed to init_wakeup", __func__);3525		return ret;3526	}3527 3528	data->oob_wake_irq = irq;3529	bt_dev_info(hdev, "OOB Wake-on-BT configured at IRQ %u", irq);3530	return 0;3531}3532#endif3533 3534static void btusb_check_needs_reset_resume(struct usb_interface *intf)3535{3536	if (dmi_check_system(btusb_needs_reset_resume_table))3537		interface_to_usbdev(intf)->quirks |= USB_QUIRK_RESET_RESUME;3538}3539 3540static bool btusb_wakeup(struct hci_dev *hdev)3541{3542	struct btusb_data *data = hci_get_drvdata(hdev);3543 3544	return device_may_wakeup(&data->udev->dev);3545}3546 3547static int btusb_shutdown_qca(struct hci_dev *hdev)3548{3549	struct sk_buff *skb;3550 3551	skb = __hci_cmd_sync(hdev, HCI_OP_RESET, 0, NULL, HCI_INIT_TIMEOUT);3552	if (IS_ERR(skb)) {3553		bt_dev_err(hdev, "HCI reset during shutdown failed");3554		return PTR_ERR(skb);3555	}3556	kfree_skb(skb);3557 3558	return 0;3559}3560 3561static ssize_t force_poll_sync_read(struct file *file, char __user *user_buf,3562				    size_t count, loff_t *ppos)3563{3564	struct btusb_data *data = file->private_data;3565	char buf[3];3566 3567	buf[0] = data->poll_sync ? 'Y' : 'N';3568	buf[1] = '\n';3569	buf[2] = '\0';3570	return simple_read_from_buffer(user_buf, count, ppos, buf, 2);3571}3572 3573static ssize_t force_poll_sync_write(struct file *file,3574				     const char __user *user_buf,3575				     size_t count, loff_t *ppos)3576{3577	struct btusb_data *data = file->private_data;3578	bool enable;3579	int err;3580 3581	err = kstrtobool_from_user(user_buf, count, &enable);3582	if (err)3583		return err;3584 3585	/* Only allow changes while the adapter is down */3586	if (test_bit(HCI_UP, &data->hdev->flags))3587		return -EPERM;3588 3589	if (data->poll_sync == enable)3590		return -EALREADY;3591 3592	data->poll_sync = enable;3593 3594	return count;3595}3596 3597static const struct file_operations force_poll_sync_fops = {3598	.open		= simple_open,3599	.read		= force_poll_sync_read,3600	.write		= force_poll_sync_write,3601	.llseek		= default_llseek,3602};3603 3604static int btusb_probe(struct usb_interface *intf,3605		       const struct usb_device_id *id)3606{3607	struct usb_endpoint_descriptor *ep_desc;3608	struct gpio_desc *reset_gpio;3609	struct btusb_data *data;3610	struct hci_dev *hdev;3611	unsigned ifnum_base;3612	int i, err, priv_size;3613 3614	BT_DBG("intf %p id %p", intf, id);3615 3616	if ((id->driver_info & BTUSB_IFNUM_2) &&3617	    (intf->cur_altsetting->desc.bInterfaceNumber != 0) &&3618	    (intf->cur_altsetting->desc.bInterfaceNumber != 2))3619		return -ENODEV;3620 3621	ifnum_base = intf->cur_altsetting->desc.bInterfaceNumber;3622 3623	if (!id->driver_info) {3624		const struct usb_device_id *match;3625 3626		match = usb_match_id(intf, quirks_table);3627		if (match)3628			id = match;3629	}3630 3631	if (id->driver_info == BTUSB_IGNORE)3632		return -ENODEV;3633 3634	if (id->driver_info & BTUSB_ATH3012) {3635		struct usb_device *udev = interface_to_usbdev(intf);3636 3637		/* Old firmware would otherwise let ath3k driver load3638		 * patch and sysconfig files3639		 */3640		if (le16_to_cpu(udev->descriptor.bcdDevice) <= 0x0001 &&3641		    !btusb_qca_need_patch(udev))3642			return -ENODEV;3643	}3644 3645	data = devm_kzalloc(&intf->dev, sizeof(*data), GFP_KERNEL);3646	if (!data)3647		return -ENOMEM;3648 3649	for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++) {3650		ep_desc = &intf->cur_altsetting->endpoint[i].desc;3651 3652		if (!data->intr_ep && usb_endpoint_is_int_in(ep_desc)) {3653			data->intr_ep = ep_desc;3654			continue;3655		}3656 3657		if (!data->bulk_tx_ep && usb_endpoint_is_bulk_out(ep_desc)) {3658			data->bulk_tx_ep = ep_desc;3659			continue;3660		}3661 3662		if (!data->bulk_rx_ep && usb_endpoint_is_bulk_in(ep_desc)) {3663			data->bulk_rx_ep = ep_desc;3664			continue;3665		}3666	}3667 3668	if (!data->intr_ep || !data->bulk_tx_ep || !data->bulk_rx_ep)3669		return -ENODEV;3670 3671	if (id->driver_info & BTUSB_AMP) {3672		data->cmdreq_type = USB_TYPE_CLASS | 0x01;3673		data->cmdreq = 0x2b;3674	} else {3675		data->cmdreq_type = USB_TYPE_CLASS;3676		data->cmdreq = 0x00;3677	}3678 3679	data->udev = interface_to_usbdev(intf);3680	data->intf = intf;3681 3682	INIT_WORK(&data->work, btusb_work);3683	INIT_WORK(&data->waker, btusb_waker);3684	INIT_DELAYED_WORK(&data->rx_work, btusb_rx_work);3685 3686	skb_queue_head_init(&data->acl_q);3687 3688	init_usb_anchor(&data->deferred);3689	init_usb_anchor(&data->tx_anchor);3690	spin_lock_init(&data->txlock);3691 3692	init_usb_anchor(&data->intr_anchor);3693	init_usb_anchor(&data->bulk_anchor);3694	init_usb_anchor(&data->isoc_anchor);3695	init_usb_anchor(&data->diag_anchor);3696	init_usb_anchor(&data->ctrl_anchor);3697	spin_lock_init(&data->rxlock);3698 3699	priv_size = 0;3700 3701	data->recv_event = hci_recv_frame;3702	data->recv_bulk = btusb_recv_bulk;3703 3704	if (id->driver_info & BTUSB_INTEL_COMBINED) {3705		/* Allocate extra space for Intel device */3706		priv_size += sizeof(struct btintel_data);3707 3708		/* Override the rx handlers */3709		data->recv_event = btintel_recv_event;3710		data->recv_bulk = btusb_recv_bulk_intel;3711	} else if (id->driver_info & BTUSB_REALTEK) {3712		/* Allocate extra space for Realtek device */3713		priv_size += sizeof(struct btrealtek_data);3714 3715		data->recv_event = btusb_recv_event_realtek;3716	} else if (id->driver_info & BTUSB_MEDIATEK) {3717		/* Allocate extra space for Mediatek device */3718		priv_size += sizeof(struct btmtk_data);3719	}3720 3721	data->recv_acl = hci_recv_frame;3722 3723	hdev = hci_alloc_dev_priv(priv_size);3724	if (!hdev)3725		return -ENOMEM;3726 3727	hdev->bus = HCI_USB;3728	hci_set_drvdata(hdev, data);3729 3730	data->hdev = hdev;3731 3732	SET_HCIDEV_DEV(hdev, &intf->dev);3733 3734	reset_gpio = gpiod_get_optional(&data->udev->dev, "reset",3735					GPIOD_OUT_LOW);3736	if (IS_ERR(reset_gpio)) {3737		err = PTR_ERR(reset_gpio);3738		goto out_free_dev;3739	} else if (reset_gpio) {3740		data->reset_gpio = reset_gpio;3741	}3742 3743	hdev->open   = btusb_open;3744	hdev->close  = btusb_close;3745	hdev->flush  = btusb_flush;3746	hdev->send   = btusb_send_frame;3747	hdev->notify = btusb_notify;3748	hdev->wakeup = btusb_wakeup;3749 3750#ifdef CONFIG_PM3751	err = btusb_config_oob_wake(hdev);3752	if (err)3753		goto out_free_dev;3754 3755	/* Marvell devices may need a specific chip configuration */3756	if (id->driver_info & BTUSB_MARVELL && data->oob_wake_irq) {3757		err = marvell_config_oob_wake(hdev);3758		if (err)3759			goto out_free_dev;3760	}3761#endif3762	if (id->driver_info & BTUSB_CW6622)3763		set_bit(HCI_QUIRK_BROKEN_STORED_LINK_KEY, &hdev->quirks);3764 3765	if (id->driver_info & BTUSB_BCM2045)3766		set_bit(HCI_QUIRK_BROKEN_STORED_LINK_KEY, &hdev->quirks);3767 3768	if (id->driver_info & BTUSB_BCM92035)3769		hdev->setup = btusb_setup_bcm92035;3770 3771	if (IS_ENABLED(CONFIG_BT_HCIBTUSB_BCM) &&3772	    (id->driver_info & BTUSB_BCM_PATCHRAM)) {3773		hdev->manufacturer = 15;3774		hdev->setup = btbcm_setup_patchram;3775		hdev->set_diag = btusb_bcm_set_diag;3776		hdev->set_bdaddr = btbcm_set_bdaddr;3777 3778		/* Broadcom LM_DIAG Interface numbers are hardcoded */3779		data->diag = usb_ifnum_to_if(data->udev, ifnum_base + 2);3780	}3781 3782	if (IS_ENABLED(CONFIG_BT_HCIBTUSB_BCM) &&3783	    (id->driver_info & BTUSB_BCM_APPLE)) {3784		hdev->manufacturer = 15;3785		hdev->setup = btbcm_setup_apple;3786		hdev->set_diag = btusb_bcm_set_diag;3787 3788		/* Broadcom LM_DIAG Interface numbers are hardcoded */3789		data->diag = usb_ifnum_to_if(data->udev, ifnum_base + 2);3790	}3791 3792	/* Combined Intel Device setup to support multiple setup routine */3793	if (id->driver_info & BTUSB_INTEL_COMBINED) {3794		err = btintel_configure_setup(hdev, btusb_driver.name);3795		if (err)3796			goto out_free_dev;3797 3798		/* Transport specific configuration */3799		hdev->send = btusb_send_frame_intel;3800		hdev->cmd_timeout = btusb_intel_cmd_timeout;3801 3802		if (id->driver_info & BTUSB_INTEL_NO_WBS_SUPPORT)3803			btintel_set_flag(hdev, INTEL_ROM_LEGACY_NO_WBS_SUPPORT);3804 3805		if (id->driver_info & BTUSB_INTEL_BROKEN_INITIAL_NCMD)3806			btintel_set_flag(hdev, INTEL_BROKEN_INITIAL_NCMD);3807 3808		if (id->driver_info & BTUSB_INTEL_BROKEN_SHUTDOWN_LED)3809			btintel_set_flag(hdev, INTEL_BROKEN_SHUTDOWN_LED);3810	}3811 3812	if (id->driver_info & BTUSB_MARVELL)3813		hdev->set_bdaddr = btusb_set_bdaddr_marvell;3814 3815	if (IS_ENABLED(CONFIG_BT_HCIBTUSB_MTK) &&3816	    (id->driver_info & BTUSB_MEDIATEK)) {3817		hdev->setup = btusb_mtk_setup;3818		hdev->shutdown = btusb_mtk_shutdown;3819		hdev->manufacturer = 70;3820		hdev->cmd_timeout = btmtk_reset_sync;3821		hdev->set_bdaddr = btmtk_set_bdaddr;3822		hdev->send = btusb_send_frame_mtk;3823		set_bit(HCI_QUIRK_BROKEN_ENHANCED_SETUP_SYNC_CONN, &hdev->quirks);3824		set_bit(HCI_QUIRK_NON_PERSISTENT_SETUP, &hdev->quirks);3825		data->recv_acl = btmtk_usb_recv_acl;3826		data->suspend = btmtk_usb_suspend;3827		data->resume = btmtk_usb_resume;3828	}3829 3830	if (id->driver_info & BTUSB_SWAVE) {3831		set_bit(HCI_QUIRK_FIXUP_INQUIRY_MODE, &hdev->quirks);3832		set_bit(HCI_QUIRK_BROKEN_LOCAL_COMMANDS, &hdev->quirks);3833	}3834 3835	if (id->driver_info & BTUSB_INTEL_BOOT) {3836		hdev->manufacturer = 2;3837		set_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks);3838	}3839 3840	if (id->driver_info & BTUSB_ATH3012) {3841		data->setup_on_usb = btusb_setup_qca;3842		hdev->set_bdaddr = btusb_set_bdaddr_ath3012;3843		set_bit(HCI_QUIRK_SIMULTANEOUS_DISCOVERY, &hdev->quirks);3844		set_bit(HCI_QUIRK_STRICT_DUPLICATE_FILTER, &hdev->quirks);3845	}3846 3847	if (id->driver_info & BTUSB_QCA_ROME) {3848		data->setup_on_usb = btusb_setup_qca;3849		hdev->shutdown = btusb_shutdown_qca;3850		hdev->set_bdaddr = btusb_set_bdaddr_ath3012;3851		hdev->cmd_timeout = btusb_qca_cmd_timeout;3852		set_bit(HCI_QUIRK_SIMULTANEOUS_DISCOVERY, &hdev->quirks);3853		btusb_check_needs_reset_resume(intf);3854	}3855 3856	if (id->driver_info & BTUSB_QCA_WCN6855) {3857		data->qca_dump.id_vendor = id->idVendor;3858		data->qca_dump.id_product = id->idProduct;3859		data->recv_event = btusb_recv_evt_qca;3860		data->recv_acl = btusb_recv_acl_qca;3861		hci_devcd_register(hdev, btusb_coredump_qca, btusb_dump_hdr_qca, NULL);3862		data->setup_on_usb = btusb_setup_qca;3863		hdev->shutdown = btusb_shutdown_qca;3864		hdev->set_bdaddr = btusb_set_bdaddr_wcn6855;3865		hdev->cmd_timeout = btusb_qca_cmd_timeout;3866		set_bit(HCI_QUIRK_SIMULTANEOUS_DISCOVERY, &hdev->quirks);3867		hci_set_msft_opcode(hdev, 0xFD70);3868	}3869 3870	if (id->driver_info & BTUSB_AMP) {3871		/* AMP controllers do not support SCO packets */3872		data->isoc = NULL;3873	} else {3874		/* Interface orders are hardcoded in the specification */3875		data->isoc = usb_ifnum_to_if(data->udev, ifnum_base + 1);3876		data->isoc_ifnum = ifnum_base + 1;3877	}3878 3879	if (IS_ENABLED(CONFIG_BT_HCIBTUSB_RTL) &&3880	    (id->driver_info & BTUSB_REALTEK)) {3881		btrtl_set_driver_name(hdev, btusb_driver.name);3882		hdev->setup = btusb_setup_realtek;3883		hdev->shutdown = btrtl_shutdown_realtek;3884		hdev->cmd_timeout = btusb_rtl_cmd_timeout;3885		hdev->hw_error = btusb_rtl_hw_error;3886 3887		/* Realtek devices need to set remote wakeup on auto-suspend */3888		set_bit(BTUSB_WAKEUP_AUTOSUSPEND, &data->flags);3889		set_bit(BTUSB_USE_ALT3_FOR_WBS, &data->flags);3890	}3891 3892	if (id->driver_info & BTUSB_ACTIONS_SEMI) {3893		/* Support is advertised, but not implemented */3894		set_bit(HCI_QUIRK_BROKEN_ERR_DATA_REPORTING, &hdev->quirks);3895		set_bit(HCI_QUIRK_BROKEN_READ_TRANSMIT_POWER, &hdev->quirks);3896		set_bit(HCI_QUIRK_BROKEN_SET_RPA_TIMEOUT, &hdev->quirks);3897		set_bit(HCI_QUIRK_BROKEN_EXT_SCAN, &hdev->quirks);3898		set_bit(HCI_QUIRK_BROKEN_READ_ENC_KEY_SIZE, &hdev->quirks);3899	}3900 3901	if (!reset)3902		set_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks);3903 3904	if (force_scofix || id->driver_info & BTUSB_WRONG_SCO_MTU) {3905		if (!disable_scofix)3906			set_bit(HCI_QUIRK_FIXUP_BUFFER_SIZE, &hdev->quirks);3907	}3908 3909	if (id->driver_info & BTUSB_BROKEN_ISOC)3910		data->isoc = NULL;3911 3912	if (id->driver_info & BTUSB_WIDEBAND_SPEECH)3913		set_bit(HCI_QUIRK_WIDEBAND_SPEECH_SUPPORTED, &hdev->quirks);3914 3915	if (id->driver_info & BTUSB_INVALID_LE_STATES)3916		set_bit(HCI_QUIRK_BROKEN_LE_STATES, &hdev->quirks);3917 3918	if (id->driver_info & BTUSB_DIGIANSWER) {3919		data->cmdreq_type = USB_TYPE_VENDOR;3920		set_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks);3921	}3922 3923	if (id->driver_info & BTUSB_CSR) {3924		struct usb_device *udev = data->udev;3925		u16 bcdDevice = le16_to_cpu(udev->descriptor.bcdDevice);3926 3927		/* Old firmware would otherwise execute USB reset */3928		if (bcdDevice < 0x117)3929			set_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks);3930 3931		/* This must be set first in case we disable it for fakes */3932		set_bit(HCI_QUIRK_SIMULTANEOUS_DISCOVERY, &hdev->quirks);3933 3934		/* Fake CSR devices with broken commands */3935		if (le16_to_cpu(udev->descriptor.idVendor)  == 0x0a12 &&3936		    le16_to_cpu(udev->descriptor.idProduct) == 0x0001)3937			hdev->setup = btusb_setup_csr;3938	}3939 3940	if (id->driver_info & BTUSB_SNIFFER) {3941		struct usb_device *udev = data->udev;3942 3943		/* New sniffer firmware has crippled HCI interface */3944		if (le16_to_cpu(udev->descriptor.bcdDevice) > 0x997)3945			set_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks);3946	}3947 3948	if (id->driver_info & BTUSB_INTEL_BOOT) {3949		/* A bug in the bootloader causes that interrupt interface is3950		 * only enabled after receiving SetInterface(0, AltSetting=0).3951		 */3952		err = usb_set_interface(data->udev, 0, 0);3953		if (err < 0) {3954			BT_ERR("failed to set interface 0, alt 0 %d", err);3955			goto out_free_dev;3956		}3957	}3958 3959	if (data->isoc) {3960		err = usb_driver_claim_interface(&btusb_driver,3961						 data->isoc, data);3962		if (err < 0)3963			goto out_free_dev;3964	}3965 3966	if (IS_ENABLED(CONFIG_BT_HCIBTUSB_BCM) && data->diag) {3967		if (!usb_driver_claim_interface(&btusb_driver,3968						data->diag, data))3969			__set_diag_interface(hdev);3970		else3971			data->diag = NULL;3972	}3973 3974	if (enable_autosuspend)3975		usb_enable_autosuspend(data->udev);3976 3977	data->poll_sync = enable_poll_sync;3978 3979	err = hci_register_dev(hdev);3980	if (err < 0)3981		goto out_free_dev;3982 3983	usb_set_intfdata(intf, data);3984 3985	debugfs_create_file("force_poll_sync", 0644, hdev->debugfs, data,3986			    &force_poll_sync_fops);3987 3988	return 0;3989 3990out_free_dev:3991	if (data->reset_gpio)3992		gpiod_put(data->reset_gpio);3993	hci_free_dev(hdev);3994	return err;3995}3996 3997static void btusb_disconnect(struct usb_interface *intf)3998{3999	struct btusb_data *data = usb_get_intfdata(intf);4000	struct hci_dev *hdev;4001 4002	BT_DBG("intf %p", intf);4003 4004	if (!data)4005		return;4006 4007	hdev = data->hdev;4008	usb_set_intfdata(data->intf, NULL);4009 4010	if (data->isoc)4011		usb_set_intfdata(data->isoc, NULL);4012 4013	if (data->diag)4014		usb_set_intfdata(data->diag, NULL);4015 4016	hci_unregister_dev(hdev);4017 4018	if (intf == data->intf) {4019		if (data->isoc)4020			usb_driver_release_interface(&btusb_driver, data->isoc);4021		if (data->diag)4022			usb_driver_release_interface(&btusb_driver, data->diag);4023	} else if (intf == data->isoc) {4024		if (data->diag)4025			usb_driver_release_interface(&btusb_driver, data->diag);4026		usb_driver_release_interface(&btusb_driver, data->intf);4027	} else if (intf == data->diag) {4028		usb_driver_release_interface(&btusb_driver, data->intf);4029		if (data->isoc)4030			usb_driver_release_interface(&btusb_driver, data->isoc);4031	}4032 4033	if (data->oob_wake_irq)4034		device_init_wakeup(&data->udev->dev, false);4035 4036	if (data->reset_gpio)4037		gpiod_put(data->reset_gpio);4038 4039	hci_free_dev(hdev);4040}4041 4042#ifdef CONFIG_PM4043static int btusb_suspend(struct usb_interface *intf, pm_message_t message)4044{4045	struct btusb_data *data = usb_get_intfdata(intf);4046 4047	BT_DBG("intf %p", intf);4048 4049	/* Don't auto-suspend if there are connections; external suspend calls4050	 * shall never fail.4051	 */4052	if (PMSG_IS_AUTO(message) && hci_conn_count(data->hdev))4053		return -EBUSY;4054 4055	if (data->suspend_count++)4056		return 0;4057 4058	spin_lock_irq(&data->txlock);4059	if (!(PMSG_IS_AUTO(message) && data->tx_in_flight)) {4060		set_bit(BTUSB_SUSPENDING, &data->flags);4061		spin_unlock_irq(&data->txlock);4062	} else {4063		spin_unlock_irq(&data->txlock);4064		data->suspend_count--;4065		return -EBUSY;4066	}4067 4068	cancel_work_sync(&data->work);4069 4070	if (data->suspend)4071		data->suspend(data->hdev);4072 4073	btusb_stop_traffic(data);4074	usb_kill_anchored_urbs(&data->tx_anchor);4075 4076	if (data->oob_wake_irq && device_may_wakeup(&data->udev->dev)) {4077		set_bit(BTUSB_OOB_WAKE_ENABLED, &data->flags);4078		enable_irq_wake(data->oob_wake_irq);4079		enable_irq(data->oob_wake_irq);4080	}4081 4082	/* For global suspend, Realtek devices lose the loaded fw4083	 * in them. But for autosuspend, firmware should remain.4084	 * Actually, it depends on whether the usb host sends4085	 * set feature (enable wakeup) or not.4086	 */4087	if (test_bit(BTUSB_WAKEUP_AUTOSUSPEND, &data->flags)) {4088		if (PMSG_IS_AUTO(message) &&4089		    device_can_wakeup(&data->udev->dev))4090			data->udev->do_remote_wakeup = 1;4091		else if (!PMSG_IS_AUTO(message) &&4092			 !device_may_wakeup(&data->udev->dev)) {4093			data->udev->do_remote_wakeup = 0;4094			data->udev->reset_resume = 1;4095		}4096	}4097 4098	return 0;4099}4100 4101static void play_deferred(struct btusb_data *data)4102{4103	struct urb *urb;4104	int err;4105 4106	while ((urb = usb_get_from_anchor(&data->deferred))) {4107		usb_anchor_urb(urb, &data->tx_anchor);4108 4109		err = usb_submit_urb(urb, GFP_ATOMIC);4110		if (err < 0) {4111			if (err != -EPERM && err != -ENODEV)4112				BT_ERR("%s urb %p submission failed (%d)",4113				       data->hdev->name, urb, -err);4114			kfree(urb->setup_packet);4115			usb_unanchor_urb(urb);4116			usb_free_urb(urb);4117			break;4118		}4119 4120		data->tx_in_flight++;4121		usb_free_urb(urb);4122	}4123 4124	/* Cleanup the rest deferred urbs. */4125	while ((urb = usb_get_from_anchor(&data->deferred))) {4126		kfree(urb->setup_packet);4127		usb_free_urb(urb);4128	}4129}4130 4131static int btusb_resume(struct usb_interface *intf)4132{4133	struct btusb_data *data = usb_get_intfdata(intf);4134	struct hci_dev *hdev = data->hdev;4135	int err = 0;4136 4137	BT_DBG("intf %p", intf);4138 4139	if (--data->suspend_count)4140		return 0;4141 4142	/* Disable only if not already disabled (keep it balanced) */4143	if (test_and_clear_bit(BTUSB_OOB_WAKE_ENABLED, &data->flags)) {4144		disable_irq(data->oob_wake_irq);4145		disable_irq_wake(data->oob_wake_irq);4146	}4147 4148	if (!test_bit(HCI_RUNNING, &hdev->flags))4149		goto done;4150 4151	if (test_bit(BTUSB_INTR_RUNNING, &data->flags)) {4152		err = btusb_submit_intr_urb(hdev, GFP_NOIO);4153		if (err < 0) {4154			clear_bit(BTUSB_INTR_RUNNING, &data->flags);4155			goto failed;4156		}4157	}4158 4159	if (test_bit(BTUSB_BULK_RUNNING, &data->flags)) {4160		err = btusb_submit_bulk_urb(hdev, GFP_NOIO);4161		if (err < 0) {4162			clear_bit(BTUSB_BULK_RUNNING, &data->flags);4163			goto failed;4164		}4165 4166		btusb_submit_bulk_urb(hdev, GFP_NOIO);4167	}4168 4169	if (test_bit(BTUSB_ISOC_RUNNING, &data->flags)) {4170		if (btusb_submit_isoc_urb(hdev, GFP_NOIO) < 0)4171			clear_bit(BTUSB_ISOC_RUNNING, &data->flags);4172		else4173			btusb_submit_isoc_urb(hdev, GFP_NOIO);4174	}4175 4176	if (data->resume)4177		data->resume(hdev);4178 4179	spin_lock_irq(&data->txlock);4180	play_deferred(data);4181	clear_bit(BTUSB_SUSPENDING, &data->flags);4182	spin_unlock_irq(&data->txlock);4183	schedule_work(&data->work);4184 4185	return 0;4186 4187failed:4188	usb_scuttle_anchored_urbs(&data->deferred);4189done:4190	spin_lock_irq(&data->txlock);4191	clear_bit(BTUSB_SUSPENDING, &data->flags);4192	spin_unlock_irq(&data->txlock);4193 4194	return err;4195}4196#endif4197 4198#ifdef CONFIG_DEV_COREDUMP4199static void btusb_coredump(struct device *dev)4200{4201	struct btusb_data *data = dev_get_drvdata(dev);4202	struct hci_dev *hdev = data->hdev;4203 4204	if (hdev->dump.coredump)4205		hdev->dump.coredump(hdev);4206}4207#endif4208 4209static struct usb_driver btusb_driver = {4210	.name		= "btusb",4211	.probe		= btusb_probe,4212	.disconnect	= btusb_disconnect,4213#ifdef CONFIG_PM4214	.suspend	= btusb_suspend,4215	.resume		= btusb_resume,4216#endif4217	.id_table	= btusb_table,4218	.supports_autosuspend = 1,4219	.disable_hub_initiated_lpm = 1,4220 4221#ifdef CONFIG_DEV_COREDUMP4222	.driver = {4223		.coredump = btusb_coredump,4224	},4225#endif4226};4227 4228module_usb_driver(btusb_driver);4229 4230module_param(disable_scofix, bool, 0644);4231MODULE_PARM_DESC(disable_scofix, "Disable fixup of wrong SCO buffer size");4232 4233module_param(force_scofix, bool, 0644);4234MODULE_PARM_DESC(force_scofix, "Force fixup of wrong SCO buffers size");4235 4236module_param(enable_autosuspend, bool, 0644);4237MODULE_PARM_DESC(enable_autosuspend, "Enable USB autosuspend by default");4238 4239module_param(reset, bool, 0644);4240MODULE_PARM_DESC(reset, "Send HCI reset command on initialization");4241 4242MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");4243MODULE_DESCRIPTION("Generic Bluetooth USB driver ver " VERSION);4244MODULE_VERSION(VERSION);4245MODULE_LICENSE("GPL");4246