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