]> git.proxmox.com Git - mirror_ubuntu-hirsute-kernel.git/blame - drivers/bluetooth/btusb.c
projects / mirror_ubuntu-hirsute-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Bluetooth: Fix incorrect bits for LE states
[mirror_ubuntu-hirsute-kernel.git] / drivers / bluetooth / btusb.c
CommitLineData
5e23b923
MH		 1/*
2 *
3 * Generic Bluetooth USB driver
4 *
9bfa35fe 5 * Copyright (C) 2005-2008 Marcel Holtmann <marcel@holtmann.org>
5e23b923
MH		 6 *
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 *
22 */
23
5e23b923 24#include <linux/module.h>
5e23b923 25#include <linux/usb.h>
61f5acea 26#include <linux/usb/quirks.h>
dffd30ee 27#include <linux/firmware.h>
fd913ef7
RJ		 28#include <linux/of_device.h>
29#include <linux/of_irq.h>
017789f3 30#include <linux/suspend.h>
a2698a9b 31#include <asm/unaligned.h>
5e23b923
MH		 32
33#include <net/bluetooth/bluetooth.h>
34#include <net/bluetooth/hci_core.h>
35
4185a0f5 36#include "btintel.h"
1df1f591 37#include "btbcm.h"
db33c77d 38#include "btrtl.h"
1df1f591 39
34dced9b 40#define VERSION "0.8"
cfeb4145 41
90ab5ee9
RR		 42static bool disable_scofix;
43static bool force_scofix;
eff2d68c 44static bool enable_autosuspend = IS_ENABLED(CONFIG_BT_HCIBTUSB_AUTOSUSPEND);
7a9d4020 45
917a3337 46static bool reset = true;
cfeb4145
MH		 47
48static struct usb_driver btusb_driver;
49
50#define BTUSB_IGNORE 0x01
7a9d4020
MH		 51#define BTUSB_DIGIANSWER 0x02
52#define BTUSB_CSR 0x04
53#define BTUSB_SNIFFER 0x08
54#define BTUSB_BCM92035 0x10
55#define BTUSB_BROKEN_ISOC 0x20
56#define BTUSB_WRONG_SCO_MTU 0x40
2d25f8b4 57#define BTUSB_ATH3012 0x80
dffd30ee 58#define BTUSB_INTEL 0x100
40df783d
MH		 59#define BTUSB_INTEL_BOOT 0x200
60#define BTUSB_BCM_PATCHRAM 0x400
ae8df494 61#define BTUSB_MARVELL 0x800
4fcef8ed 62#define BTUSB_SWAVE 0x1000
cda0dd78 63#define BTUSB_INTEL_NEW 0x2000
893ba544 64#define BTUSB_AMP 0x4000
3267c884 65#define BTUSB_QCA_ROME 0x8000
17b2772b 66#define BTUSB_BCM_APPLE 0x10000
a2698a9b 67#define BTUSB_REALTEK 0x20000
6c9d435d 68#define BTUSB_BCM2045 0x40000
22f8e9db 69#define BTUSB_IFNUM_2 0x80000
418678b0 70#define BTUSB_CW6622 0x100000
5e23b923 71
54265202 72static const struct usb_device_id btusb_table[] = {
5e23b923
MH		 73 /* Generic Bluetooth USB device */
74 { USB_DEVICE_INFO(0xe0, 0x01, 0x01) },
75
893ba544
MH		 76 /* Generic Bluetooth AMP device */
77 { USB_DEVICE_INFO(0xe0, 0x01, 0x04), .driver_info = BTUSB_AMP },
78
d63b2826
DD		 79 /* Generic Bluetooth USB interface */
80 { USB_INTERFACE_INFO(0xe0, 0x01, 0x01) },
81
1fa6535f 82 /* Apple-specific (Broadcom) devices */
17b2772b 83 { USB_VENDOR_AND_INTERFACE_INFO(0x05ac, 0xff, 0x01, 0x01),
22f8e9db 84 .driver_info = BTUSB_BCM_APPLE | BTUSB_IFNUM_2 },
1fa6535f 85
178c059e
CYC		 86 /* MediaTek MT76x0E */
87 { USB_DEVICE(0x0e8d, 0x763f) },
88
c510eae3 89 /* Broadcom SoftSailing reporting vendor specific */
2e8b5063 90 { USB_DEVICE(0x0a5c, 0x21e1) },
c510eae3 91
3cd01976
NI		 92 /* Apple MacBookPro 7,1 */
93 { USB_DEVICE(0x05ac, 0x8213) },
94
0a79f674
CL		 95 /* Apple iMac11,1 */
96 { USB_DEVICE(0x05ac, 0x8215) },
97
9c047157
NI		 98 /* Apple MacBookPro6,2 */
99 { USB_DEVICE(0x05ac, 0x8218) },
100
3e3ede7d
EH		 101 /* Apple MacBookAir3,1, MacBookAir3,2 */
102 { USB_DEVICE(0x05ac, 0x821b) },
103
a63b723d
PAVM		 104 /* Apple MacBookAir4,1 */
105 { USB_DEVICE(0x05ac, 0x821f) },
106
88d377b6
MAP		 107 /* Apple MacBookPro8,2 */
108 { USB_DEVICE(0x05ac, 0x821a) },
109
f78b6826
JK		 110 /* Apple MacMini5,1 */
111 { USB_DEVICE(0x05ac, 0x8281) },
112
cfeb4145 113 /* AVM BlueFRITZ! USB v2.0 */
4fcef8ed 114 { USB_DEVICE(0x057c, 0x3800), .driver_info = BTUSB_SWAVE },
cfeb4145
MH		 115
116 /* Bluetooth Ultraport Module from IBM */
117 { USB_DEVICE(0x04bf, 0x030a) },
118
119 /* ALPS Modules with non-standard id */
120 { USB_DEVICE(0x044e, 0x3001) },
121 { USB_DEVICE(0x044e, 0x3002) },
122
123 /* Ericsson with non-standard id */
124 { USB_DEVICE(0x0bdb, 0x1002) },
125
126 /* Canyon CN-BTU1 with HID interfaces */
7a9d4020 127 { USB_DEVICE(0x0c10, 0x0000) },
cfeb4145 128
d13431ca
WJS		 129 /* Broadcom BCM20702A0 */
130 { USB_DEVICE(0x413c, 0x8197) },
131
d049f4e5
MH		 132 /* Broadcom BCM20702B0 (Dynex/Insignia) */
133 { USB_DEVICE(0x19ff, 0x0239), .driver_info = BTUSB_BCM_PATCHRAM },
134
2faf71ce 135 /* Broadcom BCM43142A0 (Foxconn/Lenovo) */
628c26b4
DT		 136 { USB_VENDOR_AND_INTERFACE_INFO(0x105b, 0xff, 0x01, 0x01),
137 .driver_info = BTUSB_BCM_PATCHRAM },
2faf71ce 138
a57bac43
CH		 139 /* Broadcom BCM920703 (HTC Vive) */
140 { USB_VENDOR_AND_INTERFACE_INFO(0x0bb4, 0xff, 0x01, 0x01),
141 .driver_info = BTUSB_BCM_PATCHRAM },
142
98514036 143 /* Foxconn - Hon Hai */
6029ddc2
HS		 144 { USB_VENDOR_AND_INTERFACE_INFO(0x0489, 0xff, 0x01, 0x01),
145 .driver_info = BTUSB_BCM_PATCHRAM },
98514036 146
8f0c304c
MD		 147 /* Lite-On Technology - Broadcom based */
148 { USB_VENDOR_AND_INTERFACE_INFO(0x04ca, 0xff, 0x01, 0x01),
149 .driver_info = BTUSB_BCM_PATCHRAM },
150
0b880062 151 /* Broadcom devices with vendor specific id */
10d4c673
PG		 152 { USB_VENDOR_AND_INTERFACE_INFO(0x0a5c, 0xff, 0x01, 0x01),
153 .driver_info = BTUSB_BCM_PATCHRAM },
92c385f4 154
c2aef6e8 155 /* ASUSTek Computer - Broadcom based */
9a5abdaa
RD		 156 { USB_VENDOR_AND_INTERFACE_INFO(0x0b05, 0xff, 0x01, 0x01),
157 .driver_info = BTUSB_BCM_PATCHRAM },
c2aef6e8 158
5bcecf32 159 /* Belkin F8065bf - Broadcom based */
6331c686
MH		 160 { USB_VENDOR_AND_INTERFACE_INFO(0x050d, 0xff, 0x01, 0x01),
161 .driver_info = BTUSB_BCM_PATCHRAM },
5bcecf32 162
9113bfd8 163 /* IMC Networks - Broadcom based */
6331c686
MH		 164 { USB_VENDOR_AND_INTERFACE_INFO(0x13d3, 0xff, 0x01, 0x01),
165 .driver_info = BTUSB_BCM_PATCHRAM },
9113bfd8 166
fdfddc60
WJS		 167 /* Dell Computer - Broadcom based */
168 { USB_VENDOR_AND_INTERFACE_INFO(0x413c, 0xff, 0x01, 0x01),
169 .driver_info = BTUSB_BCM_PATCHRAM },
170
1623d0bf
DT		 171 /* Toshiba Corp - Broadcom based */
172 { USB_VENDOR_AND_INTERFACE_INFO(0x0930, 0xff, 0x01, 0x01),
173 .driver_info = BTUSB_BCM_PATCHRAM },
174
40df783d 175 /* Intel Bluetooth USB Bootloader (RAM module) */
d92f2df0
MH		 176 { USB_DEVICE(0x8087, 0x0a5a),
177 .driver_info = BTUSB_INTEL_BOOT | BTUSB_BROKEN_ISOC },
40df783d 178
5e23b923
MH		 179 { } /* Terminating entry */
180};
181
182MODULE_DEVICE_TABLE(usb, btusb_table);
183
54265202 184static const struct usb_device_id blacklist_table[] = {
cfeb4145
MH		 185 /* CSR BlueCore devices */
186 { USB_DEVICE(0x0a12, 0x0001), .driver_info = BTUSB_CSR },
187
188 /* Broadcom BCM2033 without firmware */
189 { USB_DEVICE(0x0a5c, 0x2033), .driver_info = BTUSB_IGNORE },
190
6c9d435d
MH		 191 /* Broadcom BCM2045 devices */
192 { USB_DEVICE(0x0a5c, 0x2045), .driver_info = BTUSB_BCM2045 },
193
be93112a 194 /* Atheros 3011 with sflash firmware */
0b880062
AS		 195 { USB_DEVICE(0x0489, 0xe027), .driver_info = BTUSB_IGNORE },
196 { USB_DEVICE(0x0489, 0xe03d), .driver_info = BTUSB_IGNORE },
2eeff0b4 197 { USB_DEVICE(0x04f2, 0xaff1), .driver_info = BTUSB_IGNORE },
0b880062 198 { USB_DEVICE(0x0930, 0x0215), .driver_info = BTUSB_IGNORE },
be93112a 199 { USB_DEVICE(0x0cf3, 0x3002), .driver_info = BTUSB_IGNORE },
6eda541d 200 { USB_DEVICE(0x0cf3, 0xe019), .driver_info = BTUSB_IGNORE },
2a7bcccc 201 { USB_DEVICE(0x13d3, 0x3304), .driver_info = BTUSB_IGNORE },
be93112a 202
509e7861
CYC		 203 /* Atheros AR9285 Malbec with sflash firmware */
204 { USB_DEVICE(0x03f0, 0x311d), .driver_info = BTUSB_IGNORE },
205
d9f51b51 206 /* Atheros 3012 with sflash firmware */
0b880062
AS		 207 { USB_DEVICE(0x0489, 0xe04d), .driver_info = BTUSB_ATH3012 },
208 { USB_DEVICE(0x0489, 0xe04e), .driver_info = BTUSB_ATH3012 },
209 { USB_DEVICE(0x0489, 0xe056), .driver_info = BTUSB_ATH3012 },
210 { USB_DEVICE(0x0489, 0xe057), .driver_info = BTUSB_ATH3012 },
211 { USB_DEVICE(0x0489, 0xe05f), .driver_info = BTUSB_ATH3012 },
692c062e 212 { USB_DEVICE(0x0489, 0xe076), .driver_info = BTUSB_ATH3012 },
4b552bc9 213 { USB_DEVICE(0x0489, 0xe078), .driver_info = BTUSB_ATH3012 },
28c971d8 214 { USB_DEVICE(0x0489, 0xe095), .driver_info = BTUSB_ATH3012 },
0b880062
AS		 215 { USB_DEVICE(0x04c5, 0x1330), .driver_info = BTUSB_ATH3012 },
216 { USB_DEVICE(0x04ca, 0x3004), .driver_info = BTUSB_ATH3012 },
217 { USB_DEVICE(0x04ca, 0x3005), .driver_info = BTUSB_ATH3012 },
218 { USB_DEVICE(0x04ca, 0x3006), .driver_info = BTUSB_ATH3012 },
1fb4e09a 219 { USB_DEVICE(0x04ca, 0x3007), .driver_info = BTUSB_ATH3012 },
0b880062
AS		 220 { USB_DEVICE(0x04ca, 0x3008), .driver_info = BTUSB_ATH3012 },
221 { USB_DEVICE(0x04ca, 0x300b), .driver_info = BTUSB_ATH3012 },
7e730c7f 222 { USB_DEVICE(0x04ca, 0x300d), .driver_info = BTUSB_ATH3012 },
ec0810d2 223 { USB_DEVICE(0x04ca, 0x300f), .driver_info = BTUSB_ATH3012 },
134d3b35 224 { USB_DEVICE(0x04ca, 0x3010), .driver_info = BTUSB_ATH3012 },
81d90442 225 { USB_DEVICE(0x04ca, 0x3014), .driver_info = BTUSB_ATH3012 },
441ad62d 226 { USB_DEVICE(0x04ca, 0x3018), .driver_info = BTUSB_ATH3012 },
0b880062 227 { USB_DEVICE(0x0930, 0x0219), .driver_info = BTUSB_ATH3012 },
cd355ff0 228 { USB_DEVICE(0x0930, 0x021c), .driver_info = BTUSB_ATH3012 },
0b880062 229 { USB_DEVICE(0x0930, 0x0220), .driver_info = BTUSB_ATH3012 },
89d2975f 230 { USB_DEVICE(0x0930, 0x0227), .driver_info = BTUSB_ATH3012 },
a735f9e2 231 { USB_DEVICE(0x0b05, 0x17d0), .driver_info = BTUSB_ATH3012 },
d66629c1 232 { USB_DEVICE(0x0cf3, 0x0036), .driver_info = BTUSB_ATH3012 },
2d25f8b4 233 { USB_DEVICE(0x0cf3, 0x3004), .driver_info = BTUSB_ATH3012 },
94a32d10 234 { USB_DEVICE(0x0cf3, 0x3008), .driver_info = BTUSB_ATH3012 },
07c0ea87 235 { USB_DEVICE(0x0cf3, 0x311d), .driver_info = BTUSB_ATH3012 },
b131237c 236 { USB_DEVICE(0x0cf3, 0x311e), .driver_info = BTUSB_ATH3012 },
1e56f1eb 237 { USB_DEVICE(0x0cf3, 0x311f), .driver_info = BTUSB_ATH3012 },
0b880062 238 { USB_DEVICE(0x0cf3, 0x3121), .driver_info = BTUSB_ATH3012 },
ebaf5795 239 { USB_DEVICE(0x0cf3, 0x817a), .driver_info = BTUSB_ATH3012 },
18e0afab 240 { USB_DEVICE(0x0cf3, 0x817b), .driver_info = BTUSB_ATH3012 },
0b880062 241 { USB_DEVICE(0x0cf3, 0xe003), .driver_info = BTUSB_ATH3012 },
ac71311e 242 { USB_DEVICE(0x0cf3, 0xe004), .driver_info = BTUSB_ATH3012 },
0a3658cc 243 { USB_DEVICE(0x0cf3, 0xe005), .driver_info = BTUSB_ATH3012 },
ca79f232 244 { USB_DEVICE(0x0cf3, 0xe006), .driver_info = BTUSB_ATH3012 },
0b880062
AS		 245 { USB_DEVICE(0x13d3, 0x3362), .driver_info = BTUSB_ATH3012 },
246 { USB_DEVICE(0x13d3, 0x3375), .driver_info = BTUSB_ATH3012 },
eed307e2 247 { USB_DEVICE(0x13d3, 0x3393), .driver_info = BTUSB_ATH3012 },
609574eb 248 { USB_DEVICE(0x13d3, 0x3395), .driver_info = BTUSB_ATH3012 },
5b77a1f3 249 { USB_DEVICE(0x13d3, 0x3402), .driver_info = BTUSB_ATH3012 },
3bb30a7c 250 { USB_DEVICE(0x13d3, 0x3408), .driver_info = BTUSB_ATH3012 },
033efa92 251 { USB_DEVICE(0x13d3, 0x3423), .driver_info = BTUSB_ATH3012 },
fa2f1394 252 { USB_DEVICE(0x13d3, 0x3432), .driver_info = BTUSB_ATH3012 },
75c6aca4 253 { USB_DEVICE(0x13d3, 0x3472), .driver_info = BTUSB_ATH3012 },
0d0cef61 254 { USB_DEVICE(0x13d3, 0x3474), .driver_info = BTUSB_ATH3012 },
72f9f8b5 255 { USB_DEVICE(0x13d3, 0x3487), .driver_info = BTUSB_ATH3012 },
12d86896 256 { USB_DEVICE(0x13d3, 0x3490), .driver_info = BTUSB_ATH3012 },
d9f51b51 257
e9036e33
CYC		 258 /* Atheros AR5BBU12 with sflash firmware */
259 { USB_DEVICE(0x0489, 0xe02c), .driver_info = BTUSB_IGNORE },
260
85d59726 261 /* Atheros AR5BBU12 with sflash firmware */
bc21fde2 262 { USB_DEVICE(0x0489, 0xe036), .driver_info = BTUSB_ATH3012 },
0b880062 263 { USB_DEVICE(0x0489, 0xe03c), .driver_info = BTUSB_ATH3012 },
85d59726 264
3267c884 265 /* QCA ROME chipset */
2054111b 266 { USB_DEVICE(0x0cf3, 0xe007), .driver_info = BTUSB_QCA_ROME },
93519934 267 { USB_DEVICE(0x0cf3, 0xe009), .driver_info = BTUSB_QCA_ROME },
e5a49ee9 268 { USB_DEVICE(0x0cf3, 0xe010), .driver_info = BTUSB_QCA_ROME },
c9e44474 269 { USB_DEVICE(0x0cf3, 0xe300), .driver_info = BTUSB_QCA_ROME },
1eef1c35 270 { USB_DEVICE(0x0cf3, 0xe301), .driver_info = BTUSB_QCA_ROME },
c9e44474 271 { USB_DEVICE(0x0cf3, 0xe360), .driver_info = BTUSB_QCA_ROME },
47ca5898 272 { USB_DEVICE(0x0489, 0xe092), .driver_info = BTUSB_QCA_ROME },
858ff38a 273 { USB_DEVICE(0x0489, 0xe09f), .driver_info = BTUSB_QCA_ROME },
06e41d8a 274 { USB_DEVICE(0x0489, 0xe0a2), .driver_info = BTUSB_QCA_ROME },
1144a4ee 275 { USB_DEVICE(0x04ca, 0x3011), .driver_info = BTUSB_QCA_ROME },
0a03f98b 276 { USB_DEVICE(0x04ca, 0x3015), .driver_info = BTUSB_QCA_ROME },
d829b9e2 277 { USB_DEVICE(0x04ca, 0x3016), .driver_info = BTUSB_QCA_ROME },
3267c884 278
cfeb4145 279 /* Broadcom BCM2035 */
7a9d4020 280 { USB_DEVICE(0x0a5c, 0x2009), .driver_info = BTUSB_BCM92035 },
0b880062
AS		 281 { USB_DEVICE(0x0a5c, 0x200a), .driver_info = BTUSB_WRONG_SCO_MTU },
282 { USB_DEVICE(0x0a5c, 0x2035), .driver_info = BTUSB_WRONG_SCO_MTU },
cfeb4145
MH		 283
284 /* Broadcom BCM2045 */
7a9d4020
MH		 285 { USB_DEVICE(0x0a5c, 0x2039), .driver_info = BTUSB_WRONG_SCO_MTU },
286 { USB_DEVICE(0x0a5c, 0x2101), .driver_info = BTUSB_WRONG_SCO_MTU },
bdbef3d6 287
cfeb4145 288 /* IBM/Lenovo ThinkPad with Broadcom chip */
7a9d4020
MH		 289 { USB_DEVICE(0x0a5c, 0x201e), .driver_info = BTUSB_WRONG_SCO_MTU },
290 { USB_DEVICE(0x0a5c, 0x2110), .driver_info = BTUSB_WRONG_SCO_MTU },
cfeb4145
MH		 291
292 /* HP laptop with Broadcom chip */
7a9d4020 293 { USB_DEVICE(0x03f0, 0x171d), .driver_info = BTUSB_WRONG_SCO_MTU },
cfeb4145
MH		 294
295 /* Dell laptop with Broadcom chip */
7a9d4020 296 { USB_DEVICE(0x413c, 0x8126), .driver_info = BTUSB_WRONG_SCO_MTU },
cfeb4145 297
5ddd4a60 298 /* Dell Wireless 370 and 410 devices */
7a9d4020 299 { USB_DEVICE(0x413c, 0x8152), .driver_info = BTUSB_WRONG_SCO_MTU },
5ddd4a60 300 { USB_DEVICE(0x413c, 0x8156), .driver_info = BTUSB_WRONG_SCO_MTU },
cfeb4145 301
7a9d4020
MH		 302 /* Belkin F8T012 and F8T013 devices */
303 { USB_DEVICE(0x050d, 0x0012), .driver_info = BTUSB_WRONG_SCO_MTU },
304 { USB_DEVICE(0x050d, 0x0013), .driver_info = BTUSB_WRONG_SCO_MTU },
cfeb4145 305
5ddd4a60
MH		 306 /* Asus WL-BTD202 device */
307 { USB_DEVICE(0x0b05, 0x1715), .driver_info = BTUSB_WRONG_SCO_MTU },
308
309 /* Kensington Bluetooth USB adapter */
310 { USB_DEVICE(0x047d, 0x105e), .driver_info = BTUSB_WRONG_SCO_MTU },
311
cfeb4145
MH		 312 /* RTX Telecom based adapters with buggy SCO support */
313 { USB_DEVICE(0x0400, 0x0807), .driver_info = BTUSB_BROKEN_ISOC },
314 { USB_DEVICE(0x0400, 0x080a), .driver_info = BTUSB_BROKEN_ISOC },
315
316 /* CONWISE Technology based adapters with buggy SCO support */
418678b0
SJ		 317 { USB_DEVICE(0x0e5e, 0x6622),
318 .driver_info = BTUSB_BROKEN_ISOC | BTUSB_CW6622},
cfeb4145 319
4fcef8ed 320 /* Roper Class 1 Bluetooth Dongle (Silicon Wave based) */
2eeac871 321 { USB_DEVICE(0x1310, 0x0001), .driver_info = BTUSB_SWAVE },
4fcef8ed 322
cfeb4145
MH		 323 /* Digianswer devices */
324 { USB_DEVICE(0x08fd, 0x0001), .driver_info = BTUSB_DIGIANSWER },
325 { USB_DEVICE(0x08fd, 0x0002), .driver_info = BTUSB_IGNORE },
326
327 /* CSR BlueCore Bluetooth Sniffer */
4f64fa80
MH		 328 { USB_DEVICE(0x0a12, 0x0002),
329 .driver_info = BTUSB_SNIFFER | BTUSB_BROKEN_ISOC },
cfeb4145
MH		 330
331 /* Frontline ComProbe Bluetooth Sniffer */
4f64fa80
MH		 332 { USB_DEVICE(0x16d3, 0x0002),
333 .driver_info = BTUSB_SNIFFER | BTUSB_BROKEN_ISOC },
cfeb4145 334
cb1ee89f
MH		 335 /* Marvell Bluetooth devices */
336 { USB_DEVICE(0x1286, 0x2044), .driver_info = BTUSB_MARVELL },
337 { USB_DEVICE(0x1286, 0x2046), .driver_info = BTUSB_MARVELL },
1165df0e 338 { USB_DEVICE(0x1286, 0x204e), .driver_info = BTUSB_MARVELL },
cb1ee89f 339
d0ac9eb7 340 /* Intel Bluetooth devices */
de766142 341 { USB_DEVICE(0x8087, 0x0025), .driver_info = BTUSB_INTEL_NEW },
1ce0cec1 342 { USB_DEVICE(0x8087, 0x0026), .driver_info = BTUSB_INTEL_NEW },
407550fe 343 { USB_DEVICE(0x8087, 0x07da), .driver_info = BTUSB_CSR },
dffd30ee 344 { USB_DEVICE(0x8087, 0x07dc), .driver_info = BTUSB_INTEL },
ef4e5e4a 345 { USB_DEVICE(0x8087, 0x0a2a), .driver_info = BTUSB_INTEL },
cda0dd78 346 { USB_DEVICE(0x8087, 0x0a2b), .driver_info = BTUSB_INTEL_NEW },
439e65d3 347 { USB_DEVICE(0x8087, 0x0aa7), .driver_info = BTUSB_INTEL },
86a6129a 348 { USB_DEVICE(0x8087, 0x0aaa), .driver_info = BTUSB_INTEL_NEW },
dffd30ee 349
d0ac9eb7
MH		 350 /* Other Intel Bluetooth devices */
351 { USB_VENDOR_AND_INTERFACE_INFO(0x8087, 0xe0, 0x01, 0x01),
352 .driver_info = BTUSB_IGNORE },
ae8df494 353
a2698a9b
DD		 354 /* Realtek Bluetooth devices */
355 { USB_VENDOR_AND_INTERFACE_INFO(0x0bda, 0xe0, 0x01, 0x01),
356 .driver_info = BTUSB_REALTEK },
357
358 /* Additional Realtek 8723AE Bluetooth devices */
359 { USB_DEVICE(0x0930, 0x021d), .driver_info = BTUSB_REALTEK },
360 { USB_DEVICE(0x13d3, 0x3394), .driver_info = BTUSB_REALTEK },
361
362 /* Additional Realtek 8723BE Bluetooth devices */
363 { USB_DEVICE(0x0489, 0xe085), .driver_info = BTUSB_REALTEK },
364 { USB_DEVICE(0x0489, 0xe08b), .driver_info = BTUSB_REALTEK },
365 { USB_DEVICE(0x13d3, 0x3410), .driver_info = BTUSB_REALTEK },
366 { USB_DEVICE(0x13d3, 0x3416), .driver_info = BTUSB_REALTEK },
367 { USB_DEVICE(0x13d3, 0x3459), .driver_info = BTUSB_REALTEK },
a81d72d2 368 { USB_DEVICE(0x13d3, 0x3494), .driver_info = BTUSB_REALTEK },
a2698a9b
DD		 369
370 /* Additional Realtek 8821AE Bluetooth devices */
371 { USB_DEVICE(0x0b05, 0x17dc), .driver_info = BTUSB_REALTEK },
372 { USB_DEVICE(0x13d3, 0x3414), .driver_info = BTUSB_REALTEK },
373 { USB_DEVICE(0x13d3, 0x3458), .driver_info = BTUSB_REALTEK },
374 { USB_DEVICE(0x13d3, 0x3461), .driver_info = BTUSB_REALTEK },
375 { USB_DEVICE(0x13d3, 0x3462), .driver_info = BTUSB_REALTEK },
376
4481c076
PP		 377 /* Silicon Wave based devices */
378 { USB_DEVICE(0x0c10, 0x0000), .driver_info = BTUSB_SWAVE },
379
5e23b923
MH		 380 { } /* Terminating entry */
381};
382
9bfa35fe
MH		 383#define BTUSB_MAX_ISOC_FRAMES 10
384
5e23b923
MH		 385#define BTUSB_INTR_RUNNING 0
386#define BTUSB_BULK_RUNNING 1
9bfa35fe 387#define BTUSB_ISOC_RUNNING 2
7bee549e 388#define BTUSB_SUSPENDING 3
08b8b6c4 389#define BTUSB_DID_ISO_RESUME 4
cda0dd78
MH		 390#define BTUSB_BOOTLOADER 5
391#define BTUSB_DOWNLOADING 6
ce6bb929 392#define BTUSB_FIRMWARE_LOADED 7
cda0dd78 393#define BTUSB_FIRMWARE_FAILED 8
ce6bb929 394#define BTUSB_BOOTING 9
61f5acea
HG		 395#define BTUSB_DIAG_RUNNING 10
396#define BTUSB_OOB_WAKE_ENABLED 11
5e23b923
MH		 397
398struct btusb_data {
399 struct hci_dev *hdev;
400 struct usb_device *udev;
5fbcd260 401 struct usb_interface *intf;
9bfa35fe 402 struct usb_interface *isoc;
9d08f504 403 struct usb_interface *diag;
459232fc 404 unsigned isoc_ifnum;
5e23b923 405
5e23b923
MH		 406 unsigned long flags;
407
408 struct work_struct work;
7bee549e 409 struct work_struct waker;
5e23b923 410
803b5836 411 struct usb_anchor deferred;
5e23b923 412 struct usb_anchor tx_anchor;
803b5836
MH		 413 int tx_in_flight;
414 spinlock_t txlock;
415
5e23b923
MH		 416 struct usb_anchor intr_anchor;
417 struct usb_anchor bulk_anchor;
9bfa35fe 418 struct usb_anchor isoc_anchor;
9d08f504 419 struct usb_anchor diag_anchor;
803b5836
MH		 420 spinlock_t rxlock;
421
422 struct sk_buff *evt_skb;
423 struct sk_buff *acl_skb;
424 struct sk_buff *sco_skb;
5e23b923
MH		 425
426 struct usb_endpoint_descriptor *intr_ep;
427 struct usb_endpoint_descriptor *bulk_tx_ep;
428 struct usb_endpoint_descriptor *bulk_rx_ep;
9bfa35fe
MH		 429 struct usb_endpoint_descriptor *isoc_tx_ep;
430 struct usb_endpoint_descriptor *isoc_rx_ep;
9d08f504
MH		 431 struct usb_endpoint_descriptor *diag_tx_ep;
432 struct usb_endpoint_descriptor *diag_rx_ep;
9bfa35fe 433
7a9d4020 434 __u8 cmdreq_type;
893ba544 435 __u8 cmdreq;
7a9d4020 436
43c2e57f 437 unsigned int sco_num;
9bfa35fe 438 int isoc_altsetting;
6a88adf2 439 int suspend_count;
2cbd3f5c 440
97307f51 441 int (*recv_event)(struct hci_dev *hdev, struct sk_buff *skb);
2cbd3f5c 442 int (*recv_bulk)(struct btusb_data *data, void *buffer, int count);
ace31982
KBYT		 443
444 int (*setup_on_usb)(struct hci_dev *hdev);
fd913ef7
RJ		 445
446 int oob_wake_irq; /* irq for out-of-band wake-on-bt */
5e23b923
MH		 447};
448
803b5836
MH		 449static inline void btusb_free_frags(struct btusb_data *data)
450{
451 unsigned long flags;
452
453 spin_lock_irqsave(&data->rxlock, flags);
454
455 kfree_skb(data->evt_skb);
456 data->evt_skb = NULL;
457
458 kfree_skb(data->acl_skb);
459 data->acl_skb = NULL;
460
461 kfree_skb(data->sco_skb);
462 data->sco_skb = NULL;
463
464 spin_unlock_irqrestore(&data->rxlock, flags);
465}
466
1ffa4ad0
MH		 467static int btusb_recv_intr(struct btusb_data *data, void *buffer, int count)
468{
803b5836
MH		 469 struct sk_buff *skb;
470 int err = 0;
471
472 spin_lock(&data->rxlock);
473 skb = data->evt_skb;
474
475 while (count) {
476 int len;
477
478 if (!skb) {
479 skb = bt_skb_alloc(HCI_MAX_EVENT_SIZE, GFP_ATOMIC);
480 if (!skb) {
481 err = -ENOMEM;
482 break;
483 }
484
618e8bc2
MH		 485 hci_skb_pkt_type(skb) = HCI_EVENT_PKT;
486 hci_skb_expect(skb) = HCI_EVENT_HDR_SIZE;
803b5836
MH		 487 }
488
618e8bc2 489 len = min_t(uint, hci_skb_expect(skb), count);
59ae1d12 490 skb_put_data(skb, buffer, len);
803b5836
MH		 491
492 count -= len;
493 buffer += len;
618e8bc2 494 hci_skb_expect(skb) -= len;
803b5836
MH		 495
496 if (skb->len == HCI_EVENT_HDR_SIZE) {
497 /* Complete event header */
618e8bc2 498 hci_skb_expect(skb) = hci_event_hdr(skb)->plen;
803b5836 499
618e8bc2 500 if (skb_tailroom(skb) < hci_skb_expect(skb)) {
803b5836
MH		 501 kfree_skb(skb);
502 skb = NULL;
503
504 err = -EILSEQ;
505 break;
506 }
507 }
508
618e8bc2 509 if (!hci_skb_expect(skb)) {
803b5836 510 /* Complete frame */
97307f51 511 data->recv_event(data->hdev, skb);
803b5836
MH		 512 skb = NULL;
513 }
514 }
515
516 data->evt_skb = skb;
517 spin_unlock(&data->rxlock);
518
519 return err;
1ffa4ad0
MH		 520}
521
522static int btusb_recv_bulk(struct btusb_data *data, void *buffer, int count)
523{
803b5836
MH		 524 struct sk_buff *skb;
525 int err = 0;
526
527 spin_lock(&data->rxlock);
528 skb = data->acl_skb;
529
530 while (count) {
531 int len;
532
533 if (!skb) {
534 skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC);
535 if (!skb) {
536 err = -ENOMEM;
537 break;
538 }
539
618e8bc2
MH		 540 hci_skb_pkt_type(skb) = HCI_ACLDATA_PKT;
541 hci_skb_expect(skb) = HCI_ACL_HDR_SIZE;
803b5836
MH		 542 }
543
618e8bc2 544 len = min_t(uint, hci_skb_expect(skb), count);
59ae1d12 545 skb_put_data(skb, buffer, len);
803b5836
MH		 546
547 count -= len;
548 buffer += len;
618e8bc2 549 hci_skb_expect(skb) -= len;
803b5836
MH		 550
551 if (skb->len == HCI_ACL_HDR_SIZE) {
552 __le16 dlen = hci_acl_hdr(skb)->dlen;
553
554 /* Complete ACL header */
618e8bc2 555 hci_skb_expect(skb) = __le16_to_cpu(dlen);
803b5836 556
618e8bc2 557 if (skb_tailroom(skb) < hci_skb_expect(skb)) {
803b5836
MH		 558 kfree_skb(skb);
559 skb = NULL;
560
561 err = -EILSEQ;
562 break;
563 }
564 }
565
618e8bc2 566 if (!hci_skb_expect(skb)) {
803b5836
MH		 567 /* Complete frame */
568 hci_recv_frame(data->hdev, skb);
569 skb = NULL;
570 }
571 }
572
573 data->acl_skb = skb;
574 spin_unlock(&data->rxlock);
575
576 return err;
1ffa4ad0
MH		 577}
578
579static int btusb_recv_isoc(struct btusb_data *data, void *buffer, int count)
580{
803b5836
MH		 581 struct sk_buff *skb;
582 int err = 0;
583
584 spin_lock(&data->rxlock);
585 skb = data->sco_skb;
586
587 while (count) {
588 int len;
589
590 if (!skb) {
591 skb = bt_skb_alloc(HCI_MAX_SCO_SIZE, GFP_ATOMIC);
592 if (!skb) {
593 err = -ENOMEM;
594 break;
595 }
596
618e8bc2
MH		 597 hci_skb_pkt_type(skb) = HCI_SCODATA_PKT;
598 hci_skb_expect(skb) = HCI_SCO_HDR_SIZE;
803b5836
MH		 599 }
600
618e8bc2 601 len = min_t(uint, hci_skb_expect(skb), count);
59ae1d12 602 skb_put_data(skb, buffer, len);
803b5836
MH		 603
604 count -= len;
605 buffer += len;
618e8bc2 606 hci_skb_expect(skb) -= len;
803b5836
MH		 607
608 if (skb->len == HCI_SCO_HDR_SIZE) {
609 /* Complete SCO header */
618e8bc2 610 hci_skb_expect(skb) = hci_sco_hdr(skb)->dlen;
803b5836 611
618e8bc2 612 if (skb_tailroom(skb) < hci_skb_expect(skb)) {
803b5836
MH		 613 kfree_skb(skb);
614 skb = NULL;
615
616 err = -EILSEQ;
617 break;
618 }
619 }
620
618e8bc2 621 if (!hci_skb_expect(skb)) {
803b5836
MH		 622 /* Complete frame */
623 hci_recv_frame(data->hdev, skb);
624 skb = NULL;
625 }
626 }
627
628 data->sco_skb = skb;
629 spin_unlock(&data->rxlock);
630
631 return err;
1ffa4ad0
MH		 632}
633
5e23b923
MH		 634static void btusb_intr_complete(struct urb *urb)
635{
636 struct hci_dev *hdev = urb->context;
155961e8 637 struct btusb_data *data = hci_get_drvdata(hdev);
5e23b923
MH		 638 int err;
639
89e7533d
MH		 640 BT_DBG("%s urb %p status %d count %d", hdev->name, urb, urb->status,
641 urb->actual_length);
5e23b923
MH		 642
643 if (!test_bit(HCI_RUNNING, &hdev->flags))
644 return;
645
646 if (urb->status == 0) {
9bfa35fe
MH		 647 hdev->stat.byte_rx += urb->actual_length;
648
1ffa4ad0
MH		 649 if (btusb_recv_intr(data, urb->transfer_buffer,
650 urb->actual_length) < 0) {
2064ee33 651 bt_dev_err(hdev, "corrupted event packet");
5e23b923
MH		 652 hdev->stat.err_rx++;
653 }
85560c4a
CC		 654 } else if (urb->status == -ENOENT) {
655 /* Avoid suspend failed when usb_kill_urb */
656 return;
5e23b923
MH		 657 }
658
659 if (!test_bit(BTUSB_INTR_RUNNING, &data->flags))
660 return;
661
7bee549e 662 usb_mark_last_busy(data->udev);
5e23b923
MH		 663 usb_anchor_urb(urb, &data->intr_anchor);
664
665 err = usb_submit_urb(urb, GFP_ATOMIC);
666 if (err < 0) {
4935f1c1 667 /* -EPERM: urb is being killed;
d98422cb
DR		 668 * -ENODEV: device got disconnected
669 */
4935f1c1 670 if (err != -EPERM && err != -ENODEV)
2064ee33
MH		 671 bt_dev_err(hdev, "urb %p failed to resubmit (%d)",
672 urb, -err);
5e23b923
MH		 673 usb_unanchor_urb(urb);
674 }
675}
676
2eda66f4 677static int btusb_submit_intr_urb(struct hci_dev *hdev, gfp_t mem_flags)
5e23b923 678{
155961e8 679 struct btusb_data *data = hci_get_drvdata(hdev);
5e23b923
MH		 680 struct urb *urb;
681 unsigned char *buf;
682 unsigned int pipe;
683 int err, size;
684
685 BT_DBG("%s", hdev->name);
686
9bfa35fe
MH		 687 if (!data->intr_ep)
688 return -ENODEV;
689
2eda66f4 690 urb = usb_alloc_urb(0, mem_flags);
5e23b923
MH		 691 if (!urb)
692 return -ENOMEM;
693
694 size = le16_to_cpu(data->intr_ep->wMaxPacketSize);
695
2eda66f4 696 buf = kmalloc(size, mem_flags);
5e23b923
MH		 697 if (!buf) {
698 usb_free_urb(urb);
699 return -ENOMEM;
700 }
701
702 pipe = usb_rcvintpipe(data->udev, data->intr_ep->bEndpointAddress);
703
704 usb_fill_int_urb(urb, data->udev, pipe, buf, size,
89e7533d 705 btusb_intr_complete, hdev, data->intr_ep->bInterval);
5e23b923
MH		 706
707 urb->transfer_flags |= URB_FREE_BUFFER;
708
709 usb_anchor_urb(urb, &data->intr_anchor);
710
2eda66f4 711 err = usb_submit_urb(urb, mem_flags);
5e23b923 712 if (err < 0) {
d4b8d1c9 713 if (err != -EPERM && err != -ENODEV)
2064ee33
MH		 714 bt_dev_err(hdev, "urb %p submission failed (%d)",
715 urb, -err);
5e23b923 716 usb_unanchor_urb(urb);
5e23b923
MH		 717 }
718
719 usb_free_urb(urb);
720
721 return err;
722}
723
724static void btusb_bulk_complete(struct urb *urb)
725{
726 struct hci_dev *hdev = urb->context;
155961e8 727 struct btusb_data *data = hci_get_drvdata(hdev);
5e23b923
MH		 728 int err;
729
89e7533d
MH		 730 BT_DBG("%s urb %p status %d count %d", hdev->name, urb, urb->status,
731 urb->actual_length);
5e23b923
MH		 732
733 if (!test_bit(HCI_RUNNING, &hdev->flags))
734 return;
735
736 if (urb->status == 0) {
9bfa35fe
MH		 737 hdev->stat.byte_rx += urb->actual_length;
738
2cbd3f5c 739 if (data->recv_bulk(data, urb->transfer_buffer,
1ffa4ad0 740 urb->actual_length) < 0) {
2064ee33 741 bt_dev_err(hdev, "corrupted ACL packet");
5e23b923
MH		 742 hdev->stat.err_rx++;
743 }
85560c4a
CC		 744 } else if (urb->status == -ENOENT) {
745 /* Avoid suspend failed when usb_kill_urb */
746 return;
5e23b923
MH		 747 }
748
749 if (!test_bit(BTUSB_BULK_RUNNING, &data->flags))
750 return;
751
752 usb_anchor_urb(urb, &data->bulk_anchor);
652fd781 753 usb_mark_last_busy(data->udev);
5e23b923
MH		 754
755 err = usb_submit_urb(urb, GFP_ATOMIC);
756 if (err < 0) {
4935f1c1 757 /* -EPERM: urb is being killed;
d98422cb
DR		 758 * -ENODEV: device got disconnected
759 */
4935f1c1 760 if (err != -EPERM && err != -ENODEV)
2064ee33
MH		 761 bt_dev_err(hdev, "urb %p failed to resubmit (%d)",
762 urb, -err);
5e23b923
MH		 763 usb_unanchor_urb(urb);
764 }
765}
766
2eda66f4 767static int btusb_submit_bulk_urb(struct hci_dev *hdev, gfp_t mem_flags)
5e23b923 768{
155961e8 769 struct btusb_data *data = hci_get_drvdata(hdev);
5e23b923
MH		 770 struct urb *urb;
771 unsigned char *buf;
772 unsigned int pipe;
290ba200 773 int err, size = HCI_MAX_FRAME_SIZE;
5e23b923
MH		 774
775 BT_DBG("%s", hdev->name);
776
9bfa35fe
MH		 777 if (!data->bulk_rx_ep)
778 return -ENODEV;
779
2eda66f4 780 urb = usb_alloc_urb(0, mem_flags);
5e23b923
MH		 781 if (!urb)
782 return -ENOMEM;
783
2eda66f4 784 buf = kmalloc(size, mem_flags);
5e23b923
MH		 785 if (!buf) {
786 usb_free_urb(urb);
787 return -ENOMEM;
788 }
789
790 pipe = usb_rcvbulkpipe(data->udev, data->bulk_rx_ep->bEndpointAddress);
791
89e7533d
MH		 792 usb_fill_bulk_urb(urb, data->udev, pipe, buf, size,
793 btusb_bulk_complete, hdev);
5e23b923
MH		 794
795 urb->transfer_flags |= URB_FREE_BUFFER;
796
7bee549e 797 usb_mark_last_busy(data->udev);
5e23b923
MH		 798 usb_anchor_urb(urb, &data->bulk_anchor);
799
2eda66f4 800 err = usb_submit_urb(urb, mem_flags);
5e23b923 801 if (err < 0) {
d4b8d1c9 802 if (err != -EPERM && err != -ENODEV)
2064ee33
MH		 803 bt_dev_err(hdev, "urb %p submission failed (%d)",
804 urb, -err);
5e23b923 805 usb_unanchor_urb(urb);
5e23b923
MH		 806 }
807
808 usb_free_urb(urb);
809
810 return err;
811}
812
9bfa35fe
MH		 813static void btusb_isoc_complete(struct urb *urb)
814{
815 struct hci_dev *hdev = urb->context;
155961e8 816 struct btusb_data *data = hci_get_drvdata(hdev);
9bfa35fe
MH		 817 int i, err;
818
89e7533d
MH		 819 BT_DBG("%s urb %p status %d count %d", hdev->name, urb, urb->status,
820 urb->actual_length);
9bfa35fe
MH		 821
822 if (!test_bit(HCI_RUNNING, &hdev->flags))
823 return;
824
825 if (urb->status == 0) {
826 for (i = 0; i < urb->number_of_packets; i++) {
827 unsigned int offset = urb->iso_frame_desc[i].offset;
828 unsigned int length = urb->iso_frame_desc[i].actual_length;
829
830 if (urb->iso_frame_desc[i].status)
831 continue;
832
833 hdev->stat.byte_rx += length;
834
1ffa4ad0
MH		 835 if (btusb_recv_isoc(data, urb->transfer_buffer + offset,
836 length) < 0) {
2064ee33 837 bt_dev_err(hdev, "corrupted SCO packet");
9bfa35fe
MH		 838 hdev->stat.err_rx++;
839 }
840 }
85560c4a
CC		 841 } else if (urb->status == -ENOENT) {
842 /* Avoid suspend failed when usb_kill_urb */
843 return;
9bfa35fe
MH		 844 }
845
846 if (!test_bit(BTUSB_ISOC_RUNNING, &data->flags))
847 return;
848
849 usb_anchor_urb(urb, &data->isoc_anchor);
850
851 err = usb_submit_urb(urb, GFP_ATOMIC);
852 if (err < 0) {
4935f1c1 853 /* -EPERM: urb is being killed;
d98422cb
DR		 854 * -ENODEV: device got disconnected
855 */
4935f1c1 856 if (err != -EPERM && err != -ENODEV)
2064ee33
MH		 857 bt_dev_err(hdev, "urb %p failed to resubmit (%d)",
858 urb, -err);
9bfa35fe
MH		 859 usb_unanchor_urb(urb);
860 }
861}
862
42b16b3f 863static inline void __fill_isoc_descriptor(struct urb *urb, int len, int mtu)
9bfa35fe
MH		 864{
865 int i, offset = 0;
866
867 BT_DBG("len %d mtu %d", len, mtu);
868
869 for (i = 0; i < BTUSB_MAX_ISOC_FRAMES && len >= mtu;
870 i++, offset += mtu, len -= mtu) {
871 urb->iso_frame_desc[i].offset = offset;
872 urb->iso_frame_desc[i].length = mtu;
873 }
874
875 if (len && i < BTUSB_MAX_ISOC_FRAMES) {
876 urb->iso_frame_desc[i].offset = offset;
877 urb->iso_frame_desc[i].length = len;
878 i++;
879 }
880
881 urb->number_of_packets = i;
882}
883
2eda66f4 884static int btusb_submit_isoc_urb(struct hci_dev *hdev, gfp_t mem_flags)
9bfa35fe 885{
155961e8 886 struct btusb_data *data = hci_get_drvdata(hdev);
9bfa35fe
MH		 887 struct urb *urb;
888 unsigned char *buf;
889 unsigned int pipe;
890 int err, size;
891
892 BT_DBG("%s", hdev->name);
893
894 if (!data->isoc_rx_ep)
895 return -ENODEV;
896
2eda66f4 897 urb = usb_alloc_urb(BTUSB_MAX_ISOC_FRAMES, mem_flags);
9bfa35fe
MH		 898 if (!urb)
899 return -ENOMEM;
900
901 size = le16_to_cpu(data->isoc_rx_ep->wMaxPacketSize) *
902 BTUSB_MAX_ISOC_FRAMES;
903
2eda66f4 904 buf = kmalloc(size, mem_flags);
9bfa35fe
MH		 905 if (!buf) {
906 usb_free_urb(urb);
907 return -ENOMEM;
908 }
909
910 pipe = usb_rcvisocpipe(data->udev, data->isoc_rx_ep->bEndpointAddress);
911
fa0fb93f 912 usb_fill_int_urb(urb, data->udev, pipe, buf, size, btusb_isoc_complete,
89e7533d 913 hdev, data->isoc_rx_ep->bInterval);
9bfa35fe 914
89e7533d 915 urb->transfer_flags = URB_FREE_BUFFER | URB_ISO_ASAP;
9bfa35fe
MH		 916
917 __fill_isoc_descriptor(urb, size,
89e7533d 918 le16_to_cpu(data->isoc_rx_ep->wMaxPacketSize));
9bfa35fe
MH		 919
920 usb_anchor_urb(urb, &data->isoc_anchor);
921
2eda66f4 922 err = usb_submit_urb(urb, mem_flags);
9bfa35fe 923 if (err < 0) {
d4b8d1c9 924 if (err != -EPERM && err != -ENODEV)
2064ee33
MH		 925 bt_dev_err(hdev, "urb %p submission failed (%d)",
926 urb, -err);
9bfa35fe 927 usb_unanchor_urb(urb);
9bfa35fe
MH		 928 }
929
930 usb_free_urb(urb);
931
932 return err;
933}
934
9d08f504
MH		 935static void btusb_diag_complete(struct urb *urb)
936{
937 struct hci_dev *hdev = urb->context;
938 struct btusb_data *data = hci_get_drvdata(hdev);
939 int err;
940
941 BT_DBG("%s urb %p status %d count %d", hdev->name, urb, urb->status,
942 urb->actual_length);
943
944 if (urb->status == 0) {
945 struct sk_buff *skb;
946
947 skb = bt_skb_alloc(urb->actual_length, GFP_ATOMIC);
948 if (skb) {
59ae1d12
JB		 949 skb_put_data(skb, urb->transfer_buffer,
950 urb->actual_length);
9d08f504
MH		 951 hci_recv_diag(hdev, skb);
952 }
953 } else if (urb->status == -ENOENT) {
954 /* Avoid suspend failed when usb_kill_urb */
955 return;
956 }
957
958 if (!test_bit(BTUSB_DIAG_RUNNING, &data->flags))
959 return;
960
961 usb_anchor_urb(urb, &data->diag_anchor);
962 usb_mark_last_busy(data->udev);
963
964 err = usb_submit_urb(urb, GFP_ATOMIC);
965 if (err < 0) {
966 /* -EPERM: urb is being killed;
d98422cb
DR		 967 * -ENODEV: device got disconnected
968 */
9d08f504 969 if (err != -EPERM && err != -ENODEV)
2064ee33
MH		 970 bt_dev_err(hdev, "urb %p failed to resubmit (%d)",
971 urb, -err);
9d08f504
MH		 972 usb_unanchor_urb(urb);
973 }
974}
975
976static int btusb_submit_diag_urb(struct hci_dev *hdev, gfp_t mem_flags)
977{
978 struct btusb_data *data = hci_get_drvdata(hdev);
979 struct urb *urb;
980 unsigned char *buf;
981 unsigned int pipe;
982 int err, size = HCI_MAX_FRAME_SIZE;
983
984 BT_DBG("%s", hdev->name);
985
986 if (!data->diag_rx_ep)
987 return -ENODEV;
988
989 urb = usb_alloc_urb(0, mem_flags);
990 if (!urb)
991 return -ENOMEM;
992
993 buf = kmalloc(size, mem_flags);
994 if (!buf) {
995 usb_free_urb(urb);
996 return -ENOMEM;
997 }
998
999 pipe = usb_rcvbulkpipe(data->udev, data->diag_rx_ep->bEndpointAddress);
1000
1001 usb_fill_bulk_urb(urb, data->udev, pipe, buf, size,
1002 btusb_diag_complete, hdev);
1003
1004 urb->transfer_flags |= URB_FREE_BUFFER;
1005
1006 usb_mark_last_busy(data->udev);
1007 usb_anchor_urb(urb, &data->diag_anchor);
1008
1009 err = usb_submit_urb(urb, mem_flags);
1010 if (err < 0) {
1011 if (err != -EPERM && err != -ENODEV)
2064ee33
MH		 1012 bt_dev_err(hdev, "urb %p submission failed (%d)",
1013 urb, -err);
9d08f504
MH		 1014 usb_unanchor_urb(urb);
1015 }
1016
1017 usb_free_urb(urb);
1018
1019 return err;
1020}
1021
5e23b923 1022static void btusb_tx_complete(struct urb *urb)
7bee549e
ON		 1023{
1024 struct sk_buff *skb = urb->context;
89e7533d 1025 struct hci_dev *hdev = (struct hci_dev *)skb->dev;
155961e8 1026 struct btusb_data *data = hci_get_drvdata(hdev);
7bee549e 1027
89e7533d
MH		 1028 BT_DBG("%s urb %p status %d count %d", hdev->name, urb, urb->status,
1029 urb->actual_length);
7bee549e
ON		 1030
1031 if (!test_bit(HCI_RUNNING, &hdev->flags))
1032 goto done;
1033
1034 if (!urb->status)
1035 hdev->stat.byte_tx += urb->transfer_buffer_length;
1036 else
1037 hdev->stat.err_tx++;
1038
1039done:
1040 spin_lock(&data->txlock);
1041 data->tx_in_flight--;
1042 spin_unlock(&data->txlock);
1043
1044 kfree(urb->setup_packet);
1045
1046 kfree_skb(skb);
1047}
1048
1049static void btusb_isoc_tx_complete(struct urb *urb)
5e23b923
MH		 1050{
1051 struct sk_buff *skb = urb->context;
89e7533d 1052 struct hci_dev *hdev = (struct hci_dev *)skb->dev;
5e23b923 1053
89e7533d
MH		 1054 BT_DBG("%s urb %p status %d count %d", hdev->name, urb, urb->status,
1055 urb->actual_length);
5e23b923
MH		 1056
1057 if (!test_bit(HCI_RUNNING, &hdev->flags))
1058 goto done;
1059
1060 if (!urb->status)
1061 hdev->stat.byte_tx += urb->transfer_buffer_length;
1062 else
1063 hdev->stat.err_tx++;
1064
1065done:
1066 kfree(urb->setup_packet);
1067
1068 kfree_skb(skb);
1069}
1070
1071static int btusb_open(struct hci_dev *hdev)
1072{
155961e8 1073 struct btusb_data *data = hci_get_drvdata(hdev);
5e23b923
MH		 1074 int err;
1075
1076 BT_DBG("%s", hdev->name);
1077
c7e163fe
EH		 1078 err = usb_autopm_get_interface(data->intf);
1079 if (err < 0)
1080 return err;
1081
ace31982
KBYT		 1082 /* Patching USB firmware files prior to starting any URBs of HCI path
1083 * It is more safe to use USB bulk channel for downloading USB patch
1084 */
1085 if (data->setup_on_usb) {
1086 err = data->setup_on_usb(hdev);
eb50042f 1087 if (err < 0)
ace31982
KBYT		 1088 return err;
1089 }
1090
7bee549e 1091 data->intf->needs_remote_wakeup = 1;
a0085f25
SG		 1092 /* device specific wakeup source enabled and required for USB
1093 * remote wakeup while host is suspended
1094 */
1095 device_wakeup_enable(&data->udev->dev);
7bee549e 1096
5e23b923 1097 if (test_and_set_bit(BTUSB_INTR_RUNNING, &data->flags))
7bee549e 1098 goto done;
5e23b923 1099
2eda66f4 1100 err = btusb_submit_intr_urb(hdev, GFP_KERNEL);
43c2e57f
MH		 1101 if (err < 0)
1102 goto failed;
1103
1104 err = btusb_submit_bulk_urb(hdev, GFP_KERNEL);
5e23b923 1105 if (err < 0) {
43c2e57f
MH		 1106 usb_kill_anchored_urbs(&data->intr_anchor);
1107 goto failed;
5e23b923
MH		 1108 }
1109
43c2e57f
MH		 1110 set_bit(BTUSB_BULK_RUNNING, &data->flags);
1111 btusb_submit_bulk_urb(hdev, GFP_KERNEL);
1112
9d08f504
MH		 1113 if (data->diag) {
1114 if (!btusb_submit_diag_urb(hdev, GFP_KERNEL))
1115 set_bit(BTUSB_DIAG_RUNNING, &data->flags);
1116 }
1117
7bee549e
ON		 1118done:
1119 usb_autopm_put_interface(data->intf);
43c2e57f
MH		 1120 return 0;
1121
1122failed:
1123 clear_bit(BTUSB_INTR_RUNNING, &data->flags);
7bee549e 1124 usb_autopm_put_interface(data->intf);
5e23b923
MH		 1125 return err;
1126}
1127
7bee549e
ON		 1128static void btusb_stop_traffic(struct btusb_data *data)
1129{
1130 usb_kill_anchored_urbs(&data->intr_anchor);
1131 usb_kill_anchored_urbs(&data->bulk_anchor);
1132 usb_kill_anchored_urbs(&data->isoc_anchor);
9d08f504 1133 usb_kill_anchored_urbs(&data->diag_anchor);
7bee549e
ON		 1134}
1135
5e23b923
MH		 1136static int btusb_close(struct hci_dev *hdev)
1137{
155961e8 1138 struct btusb_data *data = hci_get_drvdata(hdev);
7bee549e 1139 int err;
5e23b923
MH		 1140
1141 BT_DBG("%s", hdev->name);
1142
e8c3c3d2 1143 cancel_work_sync(&data->work);
404291ac 1144 cancel_work_sync(&data->waker);
e8c3c3d2 1145
9bfa35fe 1146 clear_bit(BTUSB_ISOC_RUNNING, &data->flags);
5e23b923 1147 clear_bit(BTUSB_BULK_RUNNING, &data->flags);
5e23b923 1148 clear_bit(BTUSB_INTR_RUNNING, &data->flags);
9d08f504 1149 clear_bit(BTUSB_DIAG_RUNNING, &data->flags);
7bee549e
ON		 1150
1151 btusb_stop_traffic(data);
803b5836
MH		 1152 btusb_free_frags(data);
1153
7bee549e
ON		 1154 err = usb_autopm_get_interface(data->intf);
1155 if (err < 0)
7b8e2c1d 1156 goto failed;
7bee549e
ON		 1157
1158 data->intf->needs_remote_wakeup = 0;
a0085f25 1159 device_wakeup_disable(&data->udev->dev);
7bee549e 1160 usb_autopm_put_interface(data->intf);
5e23b923 1161
7b8e2c1d
ON		 1162failed:
1163 usb_scuttle_anchored_urbs(&data->deferred);
5e23b923
MH		 1164 return 0;
1165}
1166
1167static int btusb_flush(struct hci_dev *hdev)
1168{
155961e8 1169 struct btusb_data *data = hci_get_drvdata(hdev);
5e23b923
MH		 1170
1171 BT_DBG("%s", hdev->name);
1172
1173 usb_kill_anchored_urbs(&data->tx_anchor);
803b5836 1174 btusb_free_frags(data);
5e23b923
MH		 1175
1176 return 0;
1177}
1178
047b2ec8 1179static struct urb *alloc_ctrl_urb(struct hci_dev *hdev, struct sk_buff *skb)
5e23b923 1180{
155961e8 1181 struct btusb_data *data = hci_get_drvdata(hdev);
5e23b923
MH		 1182 struct usb_ctrlrequest *dr;
1183 struct urb *urb;
1184 unsigned int pipe;
5e23b923 1185
047b2ec8
MH		 1186 urb = usb_alloc_urb(0, GFP_KERNEL);
1187 if (!urb)
1188 return ERR_PTR(-ENOMEM);
5e23b923 1189
047b2ec8
MH		 1190 dr = kmalloc(sizeof(*dr), GFP_KERNEL);
1191 if (!dr) {
1192 usb_free_urb(urb);
1193 return ERR_PTR(-ENOMEM);
1194 }
5e23b923 1195
047b2ec8 1196 dr->bRequestType = data->cmdreq_type;
893ba544 1197 dr->bRequest = data->cmdreq;
047b2ec8
MH		 1198 dr->wIndex = 0;
1199 dr->wValue = 0;
1200 dr->wLength = __cpu_to_le16(skb->len);
7bd8f09f 1201
047b2ec8 1202 pipe = usb_sndctrlpipe(data->udev, 0x00);
5e23b923 1203
89e7533d 1204 usb_fill_control_urb(urb, data->udev, pipe, (void *)dr,
047b2ec8 1205 skb->data, skb->len, btusb_tx_complete, skb);
5e23b923 1206
89e7533d 1207 skb->dev = (void *)hdev;
5e23b923 1208
047b2ec8
MH		 1209 return urb;
1210}
5e23b923 1211
047b2ec8
MH		 1212static struct urb *alloc_bulk_urb(struct hci_dev *hdev, struct sk_buff *skb)
1213{
1214 struct btusb_data *data = hci_get_drvdata(hdev);
1215 struct urb *urb;
1216 unsigned int pipe;
5e23b923 1217
047b2ec8
MH		 1218 if (!data->bulk_tx_ep)
1219 return ERR_PTR(-ENODEV);
9bfa35fe 1220
047b2ec8
MH		 1221 urb = usb_alloc_urb(0, GFP_KERNEL);
1222 if (!urb)
1223 return ERR_PTR(-ENOMEM);
5e23b923 1224
047b2ec8 1225 pipe = usb_sndbulkpipe(data->udev, data->bulk_tx_ep->bEndpointAddress);
5e23b923 1226
047b2ec8
MH		 1227 usb_fill_bulk_urb(urb, data->udev, pipe,
1228 skb->data, skb->len, btusb_tx_complete, skb);
5e23b923 1229
89e7533d 1230 skb->dev = (void *)hdev;
5e23b923 1231
047b2ec8
MH		 1232 return urb;
1233}
9bfa35fe 1234
047b2ec8
MH		 1235static struct urb *alloc_isoc_urb(struct hci_dev *hdev, struct sk_buff *skb)
1236{
1237 struct btusb_data *data = hci_get_drvdata(hdev);
1238 struct urb *urb;
1239 unsigned int pipe;
9bfa35fe 1240
047b2ec8
MH		 1241 if (!data->isoc_tx_ep)
1242 return ERR_PTR(-ENODEV);
9bfa35fe 1243
047b2ec8
MH		 1244 urb = usb_alloc_urb(BTUSB_MAX_ISOC_FRAMES, GFP_KERNEL);
1245 if (!urb)
1246 return ERR_PTR(-ENOMEM);
9bfa35fe 1247
047b2ec8 1248 pipe = usb_sndisocpipe(data->udev, data->isoc_tx_ep->bEndpointAddress);
9bfa35fe 1249
047b2ec8
MH		 1250 usb_fill_int_urb(urb, data->udev, pipe,
1251 skb->data, skb->len, btusb_isoc_tx_complete,
1252 skb, data->isoc_tx_ep->bInterval);
9bfa35fe 1253
047b2ec8 1254 urb->transfer_flags = URB_ISO_ASAP;
5e23b923 1255
047b2ec8
MH		 1256 __fill_isoc_descriptor(urb, skb->len,
1257 le16_to_cpu(data->isoc_tx_ep->wMaxPacketSize));
5e23b923 1258
89e7533d 1259 skb->dev = (void *)hdev;
047b2ec8
MH		 1260
1261 return urb;
1262}
1263
1264static int submit_tx_urb(struct hci_dev *hdev, struct urb *urb)
1265{
1266 struct btusb_data *data = hci_get_drvdata(hdev);
1267 int err;
7bee549e 1268
5e23b923
MH		 1269 usb_anchor_urb(urb, &data->tx_anchor);
1270
e9753eff 1271 err = usb_submit_urb(urb, GFP_KERNEL);
5e23b923 1272 if (err < 0) {
5a9b80e2 1273 if (err != -EPERM && err != -ENODEV)
2064ee33
MH		 1274 bt_dev_err(hdev, "urb %p submission failed (%d)",
1275 urb, -err);
5e23b923
MH		 1276 kfree(urb->setup_packet);
1277 usb_unanchor_urb(urb);
7bee549e
ON		 1278 } else {
1279 usb_mark_last_busy(data->udev);
5e23b923
MH		 1280 }
1281
54a8a79c 1282 usb_free_urb(urb);
5e23b923
MH		 1283 return err;
1284}
1285
047b2ec8
MH		 1286static int submit_or_queue_tx_urb(struct hci_dev *hdev, struct urb *urb)
1287{
1288 struct btusb_data *data = hci_get_drvdata(hdev);
1289 unsigned long flags;
1290 bool suspending;
1291
1292 spin_lock_irqsave(&data->txlock, flags);
1293 suspending = test_bit(BTUSB_SUSPENDING, &data->flags);
1294 if (!suspending)
1295 data->tx_in_flight++;
1296 spin_unlock_irqrestore(&data->txlock, flags);
1297
1298 if (!suspending)
1299 return submit_tx_urb(hdev, urb);
1300
1301 usb_anchor_urb(urb, &data->deferred);
1302 schedule_work(&data->waker);
1303
1304 usb_free_urb(urb);
1305 return 0;
1306}
1307
1308static int btusb_send_frame(struct hci_dev *hdev, struct sk_buff *skb)
1309{
1310 struct urb *urb;
1311
1312 BT_DBG("%s", hdev->name);
1313
618e8bc2 1314 switch (hci_skb_pkt_type(skb)) {
047b2ec8
MH		 1315 case HCI_COMMAND_PKT:
1316 urb = alloc_ctrl_urb(hdev, skb);
1317 if (IS_ERR(urb))
1318 return PTR_ERR(urb);
1319
1320 hdev->stat.cmd_tx++;
1321 return submit_or_queue_tx_urb(hdev, urb);
1322
1323 case HCI_ACLDATA_PKT:
1324 urb = alloc_bulk_urb(hdev, skb);
1325 if (IS_ERR(urb))
1326 return PTR_ERR(urb);
1327
1328 hdev->stat.acl_tx++;
1329 return submit_or_queue_tx_urb(hdev, urb);
1330
1331 case HCI_SCODATA_PKT:
1332 if (hci_conn_num(hdev, SCO_LINK) < 1)
1333 return -ENODEV;
1334
1335 urb = alloc_isoc_urb(hdev, skb);
1336 if (IS_ERR(urb))
1337 return PTR_ERR(urb);
1338
1339 hdev->stat.sco_tx++;
1340 return submit_tx_urb(hdev, urb);
1341 }
1342
1343 return -EILSEQ;
1344}
1345
5e23b923
MH		 1346static void btusb_notify(struct hci_dev *hdev, unsigned int evt)
1347{
155961e8 1348 struct btusb_data *data = hci_get_drvdata(hdev);
5e23b923
MH		 1349
1350 BT_DBG("%s evt %d", hdev->name, evt);
1351
014f7bc7
MH		 1352 if (hci_conn_num(hdev, SCO_LINK) != data->sco_num) {
1353 data->sco_num = hci_conn_num(hdev, SCO_LINK);
43c2e57f 1354 schedule_work(&data->work);
a780efa8 1355 }
5e23b923
MH		 1356}
1357
42b16b3f 1358static inline int __set_isoc_interface(struct hci_dev *hdev, int altsetting)
9bfa35fe 1359{
155961e8 1360 struct btusb_data *data = hci_get_drvdata(hdev);
9bfa35fe
MH		 1361 struct usb_interface *intf = data->isoc;
1362 struct usb_endpoint_descriptor *ep_desc;
1363 int i, err;
1364
1365 if (!data->isoc)
1366 return -ENODEV;
1367
459232fc 1368 err = usb_set_interface(data->udev, data->isoc_ifnum, altsetting);
9bfa35fe 1369 if (err < 0) {
2064ee33 1370 bt_dev_err(hdev, "setting interface failed (%d)", -err);
9bfa35fe
MH		 1371 return err;
1372 }
1373
1374 data->isoc_altsetting = altsetting;
1375
1376 data->isoc_tx_ep = NULL;
1377 data->isoc_rx_ep = NULL;
1378
1379 for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++) {
1380 ep_desc = &intf->cur_altsetting->endpoint[i].desc;
1381
1382 if (!data->isoc_tx_ep && usb_endpoint_is_isoc_out(ep_desc)) {
1383 data->isoc_tx_ep = ep_desc;
1384 continue;
1385 }
1386
1387 if (!data->isoc_rx_ep && usb_endpoint_is_isoc_in(ep_desc)) {
1388 data->isoc_rx_ep = ep_desc;
1389 continue;
1390 }
1391 }
1392
1393 if (!data->isoc_tx_ep || !data->isoc_rx_ep) {
2064ee33 1394 bt_dev_err(hdev, "invalid SCO descriptors");
9bfa35fe
MH		 1395 return -ENODEV;
1396 }
1397
1398 return 0;
1399}
1400
5e23b923
MH		 1401static void btusb_work(struct work_struct *work)
1402{
1403 struct btusb_data *data = container_of(work, struct btusb_data, work);
1404 struct hci_dev *hdev = data->hdev;
f4001d28 1405 int new_alts;
7bee549e 1406 int err;
5e23b923 1407
014f7bc7 1408 if (data->sco_num > 0) {
08b8b6c4 1409 if (!test_bit(BTUSB_DID_ISO_RESUME, &data->flags)) {
8efdd0cd 1410 err = usb_autopm_get_interface(data->isoc ? data->isoc : data->intf);
7bee549e
ON		 1411 if (err < 0) {
1412 clear_bit(BTUSB_ISOC_RUNNING, &data->flags);
1413 usb_kill_anchored_urbs(&data->isoc_anchor);
1414 return;
1415 }
1416
08b8b6c4 1417 set_bit(BTUSB_DID_ISO_RESUME, &data->flags);
7bee549e 1418 }
f4001d28
MA		 1419
1420 if (hdev->voice_setting & 0x0020) {
1421 static const int alts[3] = { 2, 4, 5 };
89e7533d 1422
014f7bc7 1423 new_alts = alts[data->sco_num - 1];
f4001d28 1424 } else {
014f7bc7 1425 new_alts = data->sco_num;
f4001d28
MA		 1426 }
1427
1428 if (data->isoc_altsetting != new_alts) {
f6fc86f2
KP		 1429 unsigned long flags;
1430
9bfa35fe
MH		 1431 clear_bit(BTUSB_ISOC_RUNNING, &data->flags);
1432 usb_kill_anchored_urbs(&data->isoc_anchor);
1433
8f9d02f4
KP		 1434 /* When isochronous alternate setting needs to be
1435 * changed, because SCO connection has been added
1436 * or removed, a packet fragment may be left in the
1437 * reassembling state. This could lead to wrongly
1438 * assembled fragments.
1439 *
1440 * Clear outstanding fragment when selecting a new
1441 * alternate setting.
1442 */
f6fc86f2 1443 spin_lock_irqsave(&data->rxlock, flags);
8f9d02f4
KP		 1444 kfree_skb(data->sco_skb);
1445 data->sco_skb = NULL;
f6fc86f2 1446 spin_unlock_irqrestore(&data->rxlock, flags);
8f9d02f4 1447
f4001d28 1448 if (__set_isoc_interface(hdev, new_alts) < 0)
9bfa35fe
MH		 1449 return;
1450 }
1451
1452 if (!test_and_set_bit(BTUSB_ISOC_RUNNING, &data->flags)) {
2eda66f4 1453 if (btusb_submit_isoc_urb(hdev, GFP_KERNEL) < 0)
9bfa35fe
MH		 1454 clear_bit(BTUSB_ISOC_RUNNING, &data->flags);
1455 else
2eda66f4 1456 btusb_submit_isoc_urb(hdev, GFP_KERNEL);
9bfa35fe
MH		 1457 }
1458 } else {
1459 clear_bit(BTUSB_ISOC_RUNNING, &data->flags);
1460 usb_kill_anchored_urbs(&data->isoc_anchor);
1461
1462 __set_isoc_interface(hdev, 0);
08b8b6c4 1463 if (test_and_clear_bit(BTUSB_DID_ISO_RESUME, &data->flags))
8efdd0cd 1464 usb_autopm_put_interface(data->isoc ? data->isoc : data->intf);
5e23b923
MH		 1465 }
1466}
1467
7bee549e
ON		 1468static void btusb_waker(struct work_struct *work)
1469{
1470 struct btusb_data *data = container_of(work, struct btusb_data, waker);
1471 int err;
1472
1473 err = usb_autopm_get_interface(data->intf);
1474 if (err < 0)
1475 return;
1476
1477 usb_autopm_put_interface(data->intf);
1478}
1479
9f8f962c
MH		 1480static int btusb_setup_bcm92035(struct hci_dev *hdev)
1481{
1482 struct sk_buff *skb;
1483 u8 val = 0x00;
1484
1485 BT_DBG("%s", hdev->name);
1486
1487 skb = __hci_cmd_sync(hdev, 0xfc3b, 1, &val, HCI_INIT_TIMEOUT);
1488 if (IS_ERR(skb))
2064ee33 1489 bt_dev_err(hdev, "BCM92035 command failed (%ld)", PTR_ERR(skb));
9f8f962c
MH		 1490 else
1491 kfree_skb(skb);
1492
1493 return 0;
1494}
1495
81cac64b
MH		 1496static int btusb_setup_csr(struct hci_dev *hdev)
1497{
1498 struct hci_rp_read_local_version *rp;
1499 struct sk_buff *skb;
81cac64b
MH		 1500
1501 BT_DBG("%s", hdev->name);
1502
7cd84d72
MH		 1503 skb = __hci_cmd_sync(hdev, HCI_OP_READ_LOCAL_VERSION, 0, NULL,
1504 HCI_INIT_TIMEOUT);
1505 if (IS_ERR(skb)) {
1506 int err = PTR_ERR(skb);
2064ee33 1507 bt_dev_err(hdev, "CSR: Local version failed (%d)", err);
7cd84d72
MH		 1508 return err;
1509 }
1510
1511 if (skb->len != sizeof(struct hci_rp_read_local_version)) {
2064ee33 1512 bt_dev_err(hdev, "CSR: Local version length mismatch");
7cd84d72
MH		 1513 kfree_skb(skb);
1514 return -EIO;
1515 }
81cac64b 1516
89e7533d 1517 rp = (struct hci_rp_read_local_version *)skb->data;
81cac64b 1518
6cafcd95
JH		 1519 /* Detect controllers which aren't real CSR ones. */
1520 if (le16_to_cpu(rp->manufacturer) != 10 ||
1521 le16_to_cpu(rp->lmp_subver) == 0x0c5c) {
9641d343
MH		 1522 /* Clear the reset quirk since this is not an actual
1523 * early Bluetooth 1.1 device from CSR.
1524 */
1525 clear_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks);
81cac64b 1526
9641d343
MH		 1527 /* These fake CSR controllers have all a broken
1528 * stored link key handling and so just disable it.
1529 */
1530 set_bit(HCI_QUIRK_BROKEN_STORED_LINK_KEY, &hdev->quirks);
1531 }
81cac64b
MH		 1532
1533 kfree_skb(skb);
1534
9641d343 1535 return 0;
81cac64b
MH		 1536}
1537
dffd30ee 1538static const struct firmware *btusb_setup_intel_get_fw(struct hci_dev *hdev,
89e7533d 1539 struct intel_version *ver)
dffd30ee
THJA		 1540{
1541 const struct firmware *fw;
1542 char fwname[64];
1543 int ret;
1544
1545 snprintf(fwname, sizeof(fwname),
1546 "intel/ibt-hw-%x.%x.%x-fw-%x.%x.%x.%x.%x.bseq",
1547 ver->hw_platform, ver->hw_variant, ver->hw_revision,
1548 ver->fw_variant, ver->fw_revision, ver->fw_build_num,
1549 ver->fw_build_ww, ver->fw_build_yy);
1550
1551 ret = request_firmware(&fw, fwname, &hdev->dev);
1552 if (ret < 0) {
1553 if (ret == -EINVAL) {
1554 BT_ERR("%s Intel firmware file request failed (%d)",
1555 hdev->name, ret);
1556 return NULL;
1557 }
1558
1559 BT_ERR("%s failed to open Intel firmware file: %s(%d)",
1560 hdev->name, fwname, ret);
1561
1562 /* If the correct firmware patch file is not found, use the
1563 * default firmware patch file instead
1564 */
1565 snprintf(fwname, sizeof(fwname), "intel/ibt-hw-%x.%x.bseq",
1566 ver->hw_platform, ver->hw_variant);
1567 if (request_firmware(&fw, fwname, &hdev->dev) < 0) {
1568 BT_ERR("%s failed to open default Intel fw file: %s",
1569 hdev->name, fwname);
1570 return NULL;
1571 }
1572 }
1573
2064ee33 1574 bt_dev_info(hdev, "Intel Bluetooth firmware file: %s", fwname);
dffd30ee
THJA		 1575
1576 return fw;
1577}
1578
1579static int btusb_setup_intel_patching(struct hci_dev *hdev,
1580 const struct firmware *fw,
1581 const u8 **fw_ptr, int *disable_patch)
1582{
1583 struct sk_buff *skb;
1584 struct hci_command_hdr *cmd;
1585 const u8 *cmd_param;
1586 struct hci_event_hdr *evt = NULL;
1587 const u8 *evt_param = NULL;
1588 int remain = fw->size - (*fw_ptr - fw->data);
1589
1590 /* The first byte indicates the types of the patch command or event.
1591 * 0x01 means HCI command and 0x02 is HCI event. If the first bytes
1592 * in the current firmware buffer doesn't start with 0x01 or
1593 * the size of remain buffer is smaller than HCI command header,
1594 * the firmware file is corrupted and it should stop the patching
1595 * process.
1596 */
1597 if (remain > HCI_COMMAND_HDR_SIZE && *fw_ptr[0] != 0x01) {
1598 BT_ERR("%s Intel fw corrupted: invalid cmd read", hdev->name);
1599 return -EINVAL;
1600 }
1601 (*fw_ptr)++;
1602 remain--;
1603
1604 cmd = (struct hci_command_hdr *)(*fw_ptr);
1605 *fw_ptr += sizeof(*cmd);
1606 remain -= sizeof(*cmd);
1607
1608 /* Ensure that the remain firmware data is long enough than the length
1609 * of command parameter. If not, the firmware file is corrupted.
1610 */
1611 if (remain < cmd->plen) {
1612 BT_ERR("%s Intel fw corrupted: invalid cmd len", hdev->name);
1613 return -EFAULT;
1614 }
1615
1616 /* If there is a command that loads a patch in the firmware
1617 * file, then enable the patch upon success, otherwise just
1618 * disable the manufacturer mode, for example patch activation
1619 * is not required when the default firmware patch file is used
1620 * because there are no patch data to load.
1621 */
1622 if (*disable_patch && le16_to_cpu(cmd->opcode) == 0xfc8e)
1623 *disable_patch = 0;
1624
1625 cmd_param = *fw_ptr;
1626 *fw_ptr += cmd->plen;
1627 remain -= cmd->plen;
1628
1629 /* This reads the expected events when the above command is sent to the
1630 * device. Some vendor commands expects more than one events, for
1631 * example command status event followed by vendor specific event.
1632 * For this case, it only keeps the last expected event. so the command
1633 * can be sent with __hci_cmd_sync_ev() which returns the sk_buff of
1634 * last expected event.
1635 */
1636 while (remain > HCI_EVENT_HDR_SIZE && *fw_ptr[0] == 0x02) {
1637 (*fw_ptr)++;
1638 remain--;
1639
1640 evt = (struct hci_event_hdr *)(*fw_ptr);
1641 *fw_ptr += sizeof(*evt);
1642 remain -= sizeof(*evt);
1643
1644 if (remain < evt->plen) {
1645 BT_ERR("%s Intel fw corrupted: invalid evt len",
1646 hdev->name);
1647 return -EFAULT;
1648 }
1649
1650 evt_param = *fw_ptr;
1651 *fw_ptr += evt->plen;
1652 remain -= evt->plen;
1653 }
1654
1655 /* Every HCI commands in the firmware file has its correspond event.
1656 * If event is not found or remain is smaller than zero, the firmware
1657 * file is corrupted.
1658 */
1659 if (!evt || !evt_param || remain < 0) {
1660 BT_ERR("%s Intel fw corrupted: invalid evt read", hdev->name);
1661 return -EFAULT;
1662 }
1663
1664 skb = __hci_cmd_sync_ev(hdev, le16_to_cpu(cmd->opcode), cmd->plen,
1665 cmd_param, evt->evt, HCI_INIT_TIMEOUT);
1666 if (IS_ERR(skb)) {
1667 BT_ERR("%s sending Intel patch command (0x%4.4x) failed (%ld)",
1668 hdev->name, cmd->opcode, PTR_ERR(skb));
d9c78e97 1669 return PTR_ERR(skb);
dffd30ee
THJA		 1670 }
1671
1672 /* It ensures that the returned event matches the event data read from
1673 * the firmware file. At fist, it checks the length and then
1674 * the contents of the event.
1675 */
1676 if (skb->len != evt->plen) {
1677 BT_ERR("%s mismatch event length (opcode 0x%4.4x)", hdev->name,
1678 le16_to_cpu(cmd->opcode));
1679 kfree_skb(skb);
1680 return -EFAULT;
1681 }
1682
1683 if (memcmp(skb->data, evt_param, evt->plen)) {
1684 BT_ERR("%s mismatch event parameter (opcode 0x%4.4x)",
1685 hdev->name, le16_to_cpu(cmd->opcode));
1686 kfree_skb(skb);
1687 return -EFAULT;
1688 }
1689 kfree_skb(skb);
1690
1691 return 0;
1692}
1693
1694static int btusb_setup_intel(struct hci_dev *hdev)
1695{
1696 struct sk_buff *skb;
1697 const struct firmware *fw;
1698 const u8 *fw_ptr;
28dc4b92 1699 int disable_patch, err;
6c483de1 1700 struct intel_version ver;
dffd30ee 1701
dffd30ee
THJA		 1702 BT_DBG("%s", hdev->name);
1703
1704 /* The controller has a bug with the first HCI command sent to it
1705 * returning number of completed commands as zero. This would stall the
1706 * command processing in the Bluetooth core.
1707 *
1708 * As a workaround, send HCI Reset command first which will reset the
1709 * number of completed commands and allow normal command processing
1710 * from now on.
1711 */
1712 skb = __hci_cmd_sync(hdev, HCI_OP_RESET, 0, NULL, HCI_INIT_TIMEOUT);
1713 if (IS_ERR(skb)) {
1714 BT_ERR("%s sending initial HCI reset command failed (%ld)",
1715 hdev->name, PTR_ERR(skb));
d9c78e97 1716 return PTR_ERR(skb);
dffd30ee
THJA		 1717 }
1718 kfree_skb(skb);
1719
1720 /* Read Intel specific controller version first to allow selection of
1721 * which firmware file to load.
1722 *
1723 * The returned information are hardware variant and revision plus
1724 * firmware variant, revision and build number.
1725 */
6c483de1
LP		 1726 err = btintel_read_version(hdev, &ver);
1727 if (err)
1728 return err;
dffd30ee 1729
2064ee33
MH		 1730 bt_dev_info(hdev, "read Intel version: %02x%02x%02x%02x%02x%02x%02x%02x%02x",
1731 ver.hw_platform, ver.hw_variant, ver.hw_revision,
1732 ver.fw_variant, ver.fw_revision, ver.fw_build_num,
1733 ver.fw_build_ww, ver.fw_build_yy, ver.fw_patch_num);
dffd30ee
THJA		 1734
1735 /* fw_patch_num indicates the version of patch the device currently
1736 * have. If there is no patch data in the device, it is always 0x00.
5075edae 1737 * So, if it is other than 0x00, no need to patch the device again.
dffd30ee 1738 */
6c483de1 1739 if (ver.fw_patch_num) {
2064ee33
MH		 1740 bt_dev_info(hdev, "Intel device is already patched. "
1741 "patch num: %02x", ver.fw_patch_num);
213445b2 1742 goto complete;
dffd30ee
THJA		 1743 }
1744
1745 /* Opens the firmware patch file based on the firmware version read
1746 * from the controller. If it fails to open the matching firmware
1747 * patch file, it tries to open the default firmware patch file.
1748 * If no patch file is found, allow the device to operate without
1749 * a patch.
1750 */
6c483de1
LP		 1751 fw = btusb_setup_intel_get_fw(hdev, &ver);
1752 if (!fw)
213445b2 1753 goto complete;
dffd30ee
THJA		 1754 fw_ptr = fw->data;
1755
28dc4b92 1756 /* Enable the manufacturer mode of the controller.
dffd30ee
THJA		 1757 * Only while this mode is enabled, the driver can download the
1758 * firmware patch data and configuration parameters.
1759 */
28dc4b92
LP		 1760 err = btintel_enter_mfg(hdev);
1761 if (err) {
dffd30ee 1762 release_firmware(fw);
28dc4b92 1763 return err;
dffd30ee
THJA		 1764 }
1765
dffd30ee
THJA		 1766 disable_patch = 1;
1767
1768 /* The firmware data file consists of list of Intel specific HCI
1769 * commands and its expected events. The first byte indicates the
1770 * type of the message, either HCI command or HCI event.
1771 *
1772 * It reads the command and its expected event from the firmware file,
1773 * and send to the controller. Once __hci_cmd_sync_ev() returns,
1774 * the returned event is compared with the event read from the firmware
1775 * file and it will continue until all the messages are downloaded to
1776 * the controller.
1777 *
1778 * Once the firmware patching is completed successfully,
1779 * the manufacturer mode is disabled with reset and activating the
1780 * downloaded patch.
1781 *
1782 * If the firmware patching fails, the manufacturer mode is
1783 * disabled with reset and deactivating the patch.
1784 *
1785 * If the default patch file is used, no reset is done when disabling
1786 * the manufacturer.
1787 */
1788 while (fw->size > fw_ptr - fw->data) {
1789 int ret;
1790
1791 ret = btusb_setup_intel_patching(hdev, fw, &fw_ptr,
1792 &disable_patch);
1793 if (ret < 0)
1794 goto exit_mfg_deactivate;
1795 }
1796
1797 release_firmware(fw);
1798
1799 if (disable_patch)
1800 goto exit_mfg_disable;
1801
1802 /* Patching completed successfully and disable the manufacturer mode
1803 * with reset and activate the downloaded firmware patches.
1804 */
28dc4b92
LP		 1805 err = btintel_exit_mfg(hdev, true, true);
1806 if (err)
1807 return err;
dffd30ee 1808
2064ee33 1809 bt_dev_info(hdev, "Intel firmware patch completed and activated");
dffd30ee 1810
213445b2 1811 goto complete;
dffd30ee
THJA		 1812
1813exit_mfg_disable:
1814 /* Disable the manufacturer mode without reset */
28dc4b92
LP		 1815 err = btintel_exit_mfg(hdev, false, false);
1816 if (err)
1817 return err;
dffd30ee 1818
2064ee33 1819 bt_dev_info(hdev, "Intel firmware patch completed");
40cb0984 1820
213445b2 1821 goto complete;
dffd30ee
THJA		 1822
1823exit_mfg_deactivate:
1824 release_firmware(fw);
1825
1826 /* Patching failed. Disable the manufacturer mode with reset and
1827 * deactivate the downloaded firmware patches.
1828 */
28dc4b92
LP		 1829 err = btintel_exit_mfg(hdev, true, false);
1830 if (err)
1831 return err;
dffd30ee 1832
2064ee33 1833 bt_dev_info(hdev, "Intel firmware patch completed and deactivated");
dffd30ee 1834
213445b2
MH		 1835complete:
1836 /* Set the event mask for Intel specific vendor events. This enables
1837 * a few extra events that are useful during general operation.
1838 */
1839 btintel_set_event_mask_mfg(hdev, false);
1840
4185a0f5 1841 btintel_check_bdaddr(hdev);
dffd30ee
THJA		 1842 return 0;
1843}
1844
cda0dd78
MH		 1845static int inject_cmd_complete(struct hci_dev *hdev, __u16 opcode)
1846{
1847 struct sk_buff *skb;
1848 struct hci_event_hdr *hdr;
1849 struct hci_ev_cmd_complete *evt;
1850
1851 skb = bt_skb_alloc(sizeof(*hdr) + sizeof(*evt) + 1, GFP_ATOMIC);
1852 if (!skb)
1853 return -ENOMEM;
1854
4df864c1 1855 hdr = skb_put(skb, sizeof(*hdr));
cda0dd78
MH		 1856 hdr->evt = HCI_EV_CMD_COMPLETE;
1857 hdr->plen = sizeof(*evt) + 1;
1858
4df864c1 1859 evt = skb_put(skb, sizeof(*evt));
cda0dd78
MH		 1860 evt->ncmd = 0x01;
1861 evt->opcode = cpu_to_le16(opcode);
1862
634fef61 1863 skb_put_u8(skb, 0x00);
cda0dd78 1864
618e8bc2 1865 hci_skb_pkt_type(skb) = HCI_EVENT_PKT;
cda0dd78
MH		 1866
1867 return hci_recv_frame(hdev, skb);
1868}
1869
1870static int btusb_recv_bulk_intel(struct btusb_data *data, void *buffer,
1871 int count)
1872{
1873 /* When the device is in bootloader mode, then it can send
1874 * events via the bulk endpoint. These events are treated the
1875 * same way as the ones received from the interrupt endpoint.
1876 */
1877 if (test_bit(BTUSB_BOOTLOADER, &data->flags))
1878 return btusb_recv_intr(data, buffer, count);
1879
1880 return btusb_recv_bulk(data, buffer, count);
1881}
1882
ccd6da2a
MH		 1883static void btusb_intel_bootup(struct btusb_data *data, const void *ptr,
1884 unsigned int len)
1885{
1886 const struct intel_bootup *evt = ptr;
1887
1888 if (len != sizeof(*evt))
1889 return;
1890
1891 if (test_and_clear_bit(BTUSB_BOOTING, &data->flags)) {
1892 smp_mb__after_atomic();
1893 wake_up_bit(&data->flags, BTUSB_BOOTING);
1894 }
1895}
1896
1897static void btusb_intel_secure_send_result(struct btusb_data *data,
1898 const void *ptr, unsigned int len)
1899{
1900 const struct intel_secure_send_result *evt = ptr;
1901
1902 if (len != sizeof(*evt))
1903 return;
1904
1905 if (evt->result)
1906 set_bit(BTUSB_FIRMWARE_FAILED, &data->flags);
1907
1908 if (test_and_clear_bit(BTUSB_DOWNLOADING, &data->flags) &&
1909 test_bit(BTUSB_FIRMWARE_LOADED, &data->flags)) {
1910 smp_mb__after_atomic();
1911 wake_up_bit(&data->flags, BTUSB_DOWNLOADING);
1912 }
1913}
1914
cda0dd78
MH		 1915static int btusb_recv_event_intel(struct hci_dev *hdev, struct sk_buff *skb)
1916{
1917 struct btusb_data *data = hci_get_drvdata(hdev);
1918
1919 if (test_bit(BTUSB_BOOTLOADER, &data->flags)) {
1920 struct hci_event_hdr *hdr = (void *)skb->data;
1921
ccd6da2a
MH		 1922 if (skb->len > HCI_EVENT_HDR_SIZE && hdr->evt == 0xff &&
1923 hdr->plen > 0) {
1924 const void *ptr = skb->data + HCI_EVENT_HDR_SIZE + 1;
1925 unsigned int len = skb->len - HCI_EVENT_HDR_SIZE - 1;
1926
1927 switch (skb->data[2]) {
1928 case 0x02:
1929 /* When switching to the operational firmware
1930 * the device sends a vendor specific event
1931 * indicating that the bootup completed.
1932 */
1933 btusb_intel_bootup(data, ptr, len);
1934 break;
1935 case 0x06:
1936 /* When the firmware loading completes the
1937 * device sends out a vendor specific event
1938 * indicating the result of the firmware
1939 * loading.
1940 */
1941 btusb_intel_secure_send_result(data, ptr, len);
1942 break;
fad70972 1943 }
cda0dd78
MH		 1944 }
1945 }
1946
1947 return hci_recv_frame(hdev, skb);
1948}
1949
1950static int btusb_send_frame_intel(struct hci_dev *hdev, struct sk_buff *skb)
1951{
1952 struct btusb_data *data = hci_get_drvdata(hdev);
1953 struct urb *urb;
1954
1955 BT_DBG("%s", hdev->name);
1956
618e8bc2 1957 switch (hci_skb_pkt_type(skb)) {
cda0dd78
MH		 1958 case HCI_COMMAND_PKT:
1959 if (test_bit(BTUSB_BOOTLOADER, &data->flags)) {
1960 struct hci_command_hdr *cmd = (void *)skb->data;
1961 __u16 opcode = le16_to_cpu(cmd->opcode);
1962
1963 /* When in bootloader mode and the command 0xfc09
1964 * is received, it needs to be send down the
1965 * bulk endpoint. So allocate a bulk URB instead.
1966 */
1967 if (opcode == 0xfc09)
1968 urb = alloc_bulk_urb(hdev, skb);
1969 else
1970 urb = alloc_ctrl_urb(hdev, skb);
1971
1972 /* When the 0xfc01 command is issued to boot into
1973 * the operational firmware, it will actually not
1974 * send a command complete event. To keep the flow
1975 * control working inject that event here.
1976 */
1977 if (opcode == 0xfc01)
1978 inject_cmd_complete(hdev, opcode);
1979 } else {
1980 urb = alloc_ctrl_urb(hdev, skb);
1981 }
1982 if (IS_ERR(urb))
1983 return PTR_ERR(urb);
1984
1985 hdev->stat.cmd_tx++;
1986 return submit_or_queue_tx_urb(hdev, urb);
1987
1988 case HCI_ACLDATA_PKT:
1989 urb = alloc_bulk_urb(hdev, skb);
1990 if (IS_ERR(urb))
1991 return PTR_ERR(urb);
1992
1993 hdev->stat.acl_tx++;
1994 return submit_or_queue_tx_urb(hdev, urb);
1995
1996 case HCI_SCODATA_PKT:
1997 if (hci_conn_num(hdev, SCO_LINK) < 1)
1998 return -ENODEV;
1999
2000 urb = alloc_isoc_urb(hdev, skb);
2001 if (IS_ERR(urb))
2002 return PTR_ERR(urb);
2003
2004 hdev->stat.sco_tx++;
2005 return submit_tx_urb(hdev, urb);
2006 }
2007
2008 return -EILSEQ;
2009}
2010
cda0dd78
MH		 2011static int btusb_setup_intel_new(struct hci_dev *hdev)
2012{
cda0dd78 2013 struct btusb_data *data = hci_get_drvdata(hdev);
6c483de1 2014 struct intel_version ver;
faf174d2 2015 struct intel_boot_params params;
cda0dd78 2016 const struct firmware *fw;
e5889af6 2017 u32 boot_param;
cda0dd78
MH		 2018 char fwname[64];
2019 ktime_t calltime, delta, rettime;
2020 unsigned long long duration;
2021 int err;
2022
2023 BT_DBG("%s", hdev->name);
2024
04d729b8
THJA		 2025 /* Set the default boot parameter to 0x0 and it is updated to
2026 * SKU specific boot parameter after reading Intel_Write_Boot_Params
2027 * command while downloading the firmware.
2028 */
2029 boot_param = 0x00000000;
e5889af6 2030
cda0dd78
MH		 2031 calltime = ktime_get();
2032
2033 /* Read the Intel version information to determine if the device
2034 * is in bootloader mode or if it already has operational firmware
2035 * loaded.
2036 */
6c483de1
LP		 2037 err = btintel_read_version(hdev, &ver);
2038 if (err)
2039 return err;
cda0dd78
MH		 2040
2041 /* The hardware platform number has a fixed value of 0x37 and
2042 * for now only accept this single value.
2043 */
6c483de1 2044 if (ver.hw_platform != 0x37) {
cda0dd78 2045 BT_ERR("%s: Unsupported Intel hardware platform (%u)",
6c483de1 2046 hdev->name, ver.hw_platform);
cda0dd78
MH		 2047 return -EINVAL;
2048 }
2049
9268834b
THJA		 2050 /* Check for supported iBT hardware variants of this firmware
2051 * loading method.
a0af53b5
THJA		 2052 *
2053 * This check has been put in place to ensure correct forward
2054 * compatibility options when newer hardware variants come along.
cda0dd78 2055 */
9268834b
THJA		 2056 switch (ver.hw_variant) {
2057 case 0x0b: /* SfP */
2058 case 0x0c: /* WsP */
86a6129a 2059 case 0x11: /* JfP */
de766142 2060 case 0x12: /* ThP */
1ce0cec1
THJA		 2061 case 0x13: /* HrP */
2062 case 0x14: /* QnJ, IcP */
9268834b
THJA		 2063 break;
2064 default:
cda0dd78 2065 BT_ERR("%s: Unsupported Intel hardware variant (%u)",
6c483de1 2066 hdev->name, ver.hw_variant);
cda0dd78
MH		 2067 return -EINVAL;
2068 }
2069
6c483de1 2070 btintel_version_info(hdev, &ver);
cda0dd78
MH		 2071
2072 /* The firmware variant determines if the device is in bootloader
2073 * mode or is running operational firmware. The value 0x06 identifies
2074 * the bootloader and the value 0x23 identifies the operational
2075 * firmware.
2076 *
2077 * When the operational firmware is already present, then only
2078 * the check for valid Bluetooth device address is needed. This
2079 * determines if the device will be added as configured or
2080 * unconfigured controller.
2081 *
2082 * It is not possible to use the Secure Boot Parameters in this
2083 * case since that command is only available in bootloader mode.
2084 */
6c483de1 2085 if (ver.fw_variant == 0x23) {
cda0dd78 2086 clear_bit(BTUSB_BOOTLOADER, &data->flags);
4185a0f5 2087 btintel_check_bdaddr(hdev);
cda0dd78
MH		 2088 return 0;
2089 }
2090
2091 /* If the device is not in bootloader mode, then the only possible
2092 * choice is to return an error and abort the device initialization.
2093 */
6c483de1 2094 if (ver.fw_variant != 0x06) {
cda0dd78 2095 BT_ERR("%s: Unsupported Intel firmware variant (%u)",
6c483de1 2096 hdev->name, ver.fw_variant);
cda0dd78
MH		 2097 return -ENODEV;
2098 }
2099
cda0dd78
MH		 2100 /* Read the secure boot parameters to identify the operating
2101 * details of the bootloader.
2102 */
faf174d2
THJA		 2103 err = btintel_read_boot_params(hdev, &params);
2104 if (err)
2105 return err;
cda0dd78
MH		 2106
2107 /* It is required that every single firmware fragment is acknowledged
2108 * with a command complete event. If the boot parameters indicate
2109 * that this bootloader does not send them, then abort the setup.
2110 */
faf174d2 2111 if (params.limited_cce != 0x00) {
cda0dd78 2112 BT_ERR("%s: Unsupported Intel firmware loading method (%u)",
faf174d2 2113 hdev->name, params.limited_cce);
cda0dd78
MH		 2114 return -EINVAL;
2115 }
2116
2117 /* If the OTP has no valid Bluetooth device address, then there will
2118 * also be no valid address for the operational firmware.
2119 */
faf174d2 2120 if (!bacmp(&params.otp_bdaddr, BDADDR_ANY)) {
2064ee33 2121 bt_dev_info(hdev, "No device address configured");
cda0dd78
MH		 2122 set_bit(HCI_QUIRK_INVALID_BDADDR, &hdev->quirks);
2123 }
2124
2125 /* With this Intel bootloader only the hardware variant and device
af3715e5
J		 2126 * revision information are used to select the right firmware for SfP
2127 * and WsP.
cda0dd78 2128 *
230b04ac
THJA		 2129 * The firmware filename is ibt-<hw_variant>-<dev_revid>.sfi.
2130 *
2131 * Currently the supported hardware variants are:
2132 * 11 (0x0b) for iBT3.0 (LnP/SfP)
2133 * 12 (0x0c) for iBT3.5 (WsP)
af3715e5
J		 2134 *
2135 * For ThP/JfP and for future SKU's, the FW name varies based on HW
2136 * variant, HW revision and FW revision, as these are dependent on CNVi
2137 * and RF Combination.
2138 *
86a6129a
THJA		 2139 * 17 (0x11) for iBT3.5 (JfP)
2140 * 18 (0x12) for iBT3.5 (ThP)
af3715e5
J		 2141 *
2142 * The firmware file name for these will be
2143 * ibt-<hw_variant>-<hw_revision>-<fw_revision>.sfi.
2144 *
cda0dd78 2145 */
af3715e5
J		 2146 switch (ver.hw_variant) {
2147 case 0x0b: /* SfP */
2148 case 0x0c: /* WsP */
2149 snprintf(fwname, sizeof(fwname), "intel/ibt-%u-%u.sfi",
2150 le16_to_cpu(ver.hw_variant),
faf174d2 2151 le16_to_cpu(params.dev_revid));
af3715e5
J		 2152 break;
2153 case 0x11: /* JfP */
2154 case 0x12: /* ThP */
1ce0cec1
THJA		 2155 case 0x13: /* HrP */
2156 case 0x14: /* QnJ, IcP */
af3715e5
J		 2157 snprintf(fwname, sizeof(fwname), "intel/ibt-%u-%u-%u.sfi",
2158 le16_to_cpu(ver.hw_variant),
2159 le16_to_cpu(ver.hw_revision),
2160 le16_to_cpu(ver.fw_revision));
2161 break;
2162 default:
2163 BT_ERR("%s: Unsupported Intel firmware naming", hdev->name);
2164 return -EINVAL;
2165 }
cda0dd78
MH		 2166
2167 err = request_firmware(&fw, fwname, &hdev->dev);
2168 if (err < 0) {
2169 BT_ERR("%s: Failed to load Intel firmware file (%d)",
2170 hdev->name, err);
cda0dd78
MH		 2171 return err;
2172 }
2173
2064ee33 2174 bt_dev_info(hdev, "Found device firmware: %s", fwname);
cda0dd78 2175
52cc9168
THJA		 2176 /* Save the DDC file name for later use to apply once the firmware
2177 * downloading is done.
2178 */
af3715e5
J		 2179 switch (ver.hw_variant) {
2180 case 0x0b: /* SfP */
2181 case 0x0c: /* WsP */
2182 snprintf(fwname, sizeof(fwname), "intel/ibt-%u-%u.ddc",
2183 le16_to_cpu(ver.hw_variant),
faf174d2 2184 le16_to_cpu(params.dev_revid));
af3715e5
J		 2185 break;
2186 case 0x11: /* JfP */
2187 case 0x12: /* ThP */
1ce0cec1
THJA		 2188 case 0x13: /* HrP */
2189 case 0x14: /* QnJ, IcP */
af3715e5
J		 2190 snprintf(fwname, sizeof(fwname), "intel/ibt-%u-%u-%u.ddc",
2191 le16_to_cpu(ver.hw_variant),
2192 le16_to_cpu(ver.hw_revision),
2193 le16_to_cpu(ver.fw_revision));
2194 break;
2195 default:
2196 BT_ERR("%s: Unsupported Intel firmware naming", hdev->name);
2197 return -EINVAL;
2198 }
52cc9168 2199
cda0dd78
MH		 2200 if (fw->size < 644) {
2201 BT_ERR("%s: Invalid size of firmware file (%zu)",
2202 hdev->name, fw->size);
2203 err = -EBADF;
2204 goto done;
2205 }
2206
2207 set_bit(BTUSB_DOWNLOADING, &data->flags);
2208
fbbe83c5
THJA		 2209 /* Start firmware downloading and get boot parameter */
2210 err = btintel_download_firmware(hdev, fw, &boot_param);
2211 if (err < 0)
cda0dd78 2212 goto done;
cda0dd78 2213
ce6bb929
MH		 2214 set_bit(BTUSB_FIRMWARE_LOADED, &data->flags);
2215
2064ee33 2216 bt_dev_info(hdev, "Waiting for firmware download to complete");
a087a98e 2217
cda0dd78
MH		 2218 /* Before switching the device into operational mode and with that
2219 * booting the loaded firmware, wait for the bootloader notification
2220 * that all fragments have been successfully received.
2221 *
a087a98e
JH		 2222 * When the event processing receives the notification, then the
2223 * BTUSB_DOWNLOADING flag will be cleared.
2224 *
2225 * The firmware loading should not take longer than 5 seconds
2226 * and thus just timeout if that happens and fail the setup
2227 * of this device.
cda0dd78 2228 */
129a7693
JH		 2229 err = wait_on_bit_timeout(&data->flags, BTUSB_DOWNLOADING,
2230 TASK_INTERRUPTIBLE,
2231 msecs_to_jiffies(5000));
f0a70a04 2232 if (err == -EINTR) {
a087a98e 2233 BT_ERR("%s: Firmware loading interrupted", hdev->name);
a087a98e
JH		 2234 goto done;
2235 }
cda0dd78 2236
a087a98e
JH		 2237 if (err) {
2238 BT_ERR("%s: Firmware loading timeout", hdev->name);
2239 err = -ETIMEDOUT;
2240 goto done;
cda0dd78
MH		 2241 }
2242
2243 if (test_bit(BTUSB_FIRMWARE_FAILED, &data->flags)) {
2244 BT_ERR("%s: Firmware loading failed", hdev->name);
2245 err = -ENOEXEC;
2246 goto done;
2247 }
2248
2249 rettime = ktime_get();
2250 delta = ktime_sub(rettime, calltime);
2251 duration = (unsigned long long) ktime_to_ns(delta) >> 10;
2252
2064ee33 2253 bt_dev_info(hdev, "Firmware loaded in %llu usecs", duration);
cda0dd78
MH		 2254
2255done:
2256 release_firmware(fw);
2257
2258 if (err < 0)
2259 return err;
2260
2261 calltime = ktime_get();
2262
2263 set_bit(BTUSB_BOOTING, &data->flags);
2264
e5889af6
THJA		 2265 err = btintel_send_intel_reset(hdev, boot_param);
2266 if (err)
2267 return err;
cda0dd78
MH		 2268
2269 /* The bootloader will not indicate when the device is ready. This
2270 * is done by the operational firmware sending bootup notification.
fad70972
JH		 2271 *
2272 * Booting into operational firmware should not take longer than
2273 * 1 second. However if that happens, then just fail the setup
2274 * since something went wrong.
cda0dd78 2275 */
2064ee33 2276 bt_dev_info(hdev, "Waiting for device to boot");
cda0dd78 2277
129a7693
JH		 2278 err = wait_on_bit_timeout(&data->flags, BTUSB_BOOTING,
2279 TASK_INTERRUPTIBLE,
2280 msecs_to_jiffies(1000));
cda0dd78 2281
f0a70a04 2282 if (err == -EINTR) {
fad70972
JH		 2283 BT_ERR("%s: Device boot interrupted", hdev->name);
2284 return -EINTR;
2285 }
cda0dd78 2286
fad70972
JH		 2287 if (err) {
2288 BT_ERR("%s: Device boot timeout", hdev->name);
2289 return -ETIMEDOUT;
cda0dd78
MH		 2290 }
2291
2292 rettime = ktime_get();
2293 delta = ktime_sub(rettime, calltime);
2294 duration = (unsigned long long) ktime_to_ns(delta) >> 10;
2295
2064ee33 2296 bt_dev_info(hdev, "Device booted in %llu usecs", duration);
cda0dd78
MH		 2297
2298 clear_bit(BTUSB_BOOTLOADER, &data->flags);
2299
52cc9168
THJA		 2300 /* Once the device is running in operational mode, it needs to apply
2301 * the device configuration (DDC) parameters.
2302 *
2303 * The device can work without DDC parameters, so even if it fails
2304 * to load the file, no need to fail the setup.
2305 */
e924d3d6 2306 btintel_load_ddc_config(hdev, fwname);
52cc9168 2307
213445b2
MH		 2308 /* Set the event mask for Intel specific vendor events. This enables
2309 * a few extra events that are useful during general operation. It
2310 * does not enable any debugging related events.
2311 *
2312 * The device will function correctly without these events enabled
2313 * and thus no need to fail the setup.
2314 */
2315 btintel_set_event_mask(hdev, false);
2316
cda0dd78
MH		 2317 return 0;
2318}
2319
bfbd45e9
THJA		 2320static int btusb_shutdown_intel(struct hci_dev *hdev)
2321{
2322 struct sk_buff *skb;
2323 long ret;
2324
2325 /* Some platforms have an issue with BT LED when the interface is
2326 * down or BT radio is turned off, which takes 5 seconds to BT LED
2327 * goes off. This command turns off the BT LED immediately.
2328 */
2329 skb = __hci_cmd_sync(hdev, 0xfc3f, 0, NULL, HCI_INIT_TIMEOUT);
2330 if (IS_ERR(skb)) {
2331 ret = PTR_ERR(skb);
2332 BT_ERR("%s: turning off Intel device LED failed (%ld)",
2333 hdev->name, ret);
2334 return ret;
2335 }
2336 kfree_skb(skb);
2337
2338 return 0;
2339}
2340
a4ccc9e3
RJ		 2341#ifdef CONFIG_PM
2342/* Configure an out-of-band gpio as wake-up pin, if specified in device tree */
2343static int marvell_config_oob_wake(struct hci_dev *hdev)
2344{
2345 struct sk_buff *skb;
2346 struct btusb_data *data = hci_get_drvdata(hdev);
2347 struct device *dev = &data->udev->dev;
2348 u16 pin, gap, opcode;
2349 int ret;
2350 u8 cmd[5];
2351
2352 /* Move on if no wakeup pin specified */
2353 if (of_property_read_u16(dev->of_node, "marvell,wakeup-pin", &pin) ||
2354 of_property_read_u16(dev->of_node, "marvell,wakeup-gap-ms", &gap))
2355 return 0;
2356
2357 /* Vendor specific command to configure a GPIO as wake-up pin */
2358 opcode = hci_opcode_pack(0x3F, 0x59);
2359 cmd[0] = opcode & 0xFF;
2360 cmd[1] = opcode >> 8;
2361 cmd[2] = 2; /* length of parameters that follow */
2362 cmd[3] = pin;
2363 cmd[4] = gap; /* time in ms, for which wakeup pin should be asserted */
2364
2365 skb = bt_skb_alloc(sizeof(cmd), GFP_KERNEL);
2366 if (!skb) {
2367 bt_dev_err(hdev, "%s: No memory\n", __func__);
2368 return -ENOMEM;
2369 }
2370
59ae1d12 2371 skb_put_data(skb, cmd, sizeof(cmd));
a4ccc9e3
RJ		 2372 hci_skb_pkt_type(skb) = HCI_COMMAND_PKT;
2373
2374 ret = btusb_send_frame(hdev, skb);
2375 if (ret) {
2376 bt_dev_err(hdev, "%s: configuration failed\n", __func__);
2377 kfree_skb(skb);
2378 return ret;
2379 }
2380
2381 return 0;
2382}
2383#endif
2384
ae8df494
AK		 2385static int btusb_set_bdaddr_marvell(struct hci_dev *hdev,
2386 const bdaddr_t *bdaddr)
2387{
2388 struct sk_buff *skb;
2389 u8 buf[8];
2390 long ret;
2391
2392 buf[0] = 0xfe;
2393 buf[1] = sizeof(bdaddr_t);
2394 memcpy(buf + 2, bdaddr, sizeof(bdaddr_t));
2395
2396 skb = __hci_cmd_sync(hdev, 0xfc22, sizeof(buf), buf, HCI_INIT_TIMEOUT);
2397 if (IS_ERR(skb)) {
2398 ret = PTR_ERR(skb);
2064ee33
MH		 2399 bt_dev_err(hdev, "changing Marvell device address failed (%ld)",
2400 ret);
ae8df494
AK		 2401 return ret;
2402 }
2403 kfree_skb(skb);
2404
2405 return 0;
2406}
2407
5859223e
TK		 2408static int btusb_set_bdaddr_ath3012(struct hci_dev *hdev,
2409 const bdaddr_t *bdaddr)
2410{
2411 struct sk_buff *skb;
2412 u8 buf[10];
2413 long ret;
2414
2415 buf[0] = 0x01;
2416 buf[1] = 0x01;
2417 buf[2] = 0x00;
2418 buf[3] = sizeof(bdaddr_t);
2419 memcpy(buf + 4, bdaddr, sizeof(bdaddr_t));
2420
2421 skb = __hci_cmd_sync(hdev, 0xfc0b, sizeof(buf), buf, HCI_INIT_TIMEOUT);
2422 if (IS_ERR(skb)) {
2423 ret = PTR_ERR(skb);
2064ee33 2424 bt_dev_err(hdev, "Change address command failed (%ld)", ret);
5859223e
TK		 2425 return ret;
2426 }
2427 kfree_skb(skb);
2428
2429 return 0;
2430}
2431
3267c884
KBYT		 2432#define QCA_DFU_PACKET_LEN 4096
2433
2434#define QCA_GET_TARGET_VERSION 0x09
2435#define QCA_CHECK_STATUS 0x05
2436#define QCA_DFU_DOWNLOAD 0x01
2437
2438#define QCA_SYSCFG_UPDATED 0x40
2439#define QCA_PATCH_UPDATED 0x80
2440#define QCA_DFU_TIMEOUT 3000
2441
2442struct qca_version {
2443 __le32 rom_version;
2444 __le32 patch_version;
2445 __le32 ram_version;
2446 __le32 ref_clock;
2447 __u8 reserved[4];
2448} __packed;
2449
2450struct qca_rampatch_version {
2451 __le16 rom_version;
2452 __le16 patch_version;
2453} __packed;
2454
2455struct qca_device_info {
bf906b3d
KBYT		 2456 u32 rom_version;
2457 u8 rampatch_hdr; /* length of header in rampatch */
2458 u8 nvm_hdr; /* length of header in NVM */
2459 u8 ver_offset; /* offset of version structure in rampatch */
3267c884
KBYT		 2460};
2461
2462static const struct qca_device_info qca_devices_table[] = {
2463 { 0x00000100, 20, 4, 10 }, /* Rome 1.0 */
2464 { 0x00000101, 20, 4, 10 }, /* Rome 1.1 */
7f6e6363 2465 { 0x00000200, 28, 4, 18 }, /* Rome 2.0 */
3267c884
KBYT		 2466 { 0x00000201, 28, 4, 18 }, /* Rome 2.1 */
2467 { 0x00000300, 28, 4, 18 }, /* Rome 3.0 */
2468 { 0x00000302, 28, 4, 18 }, /* Rome 3.2 */
2469};
2470
2471static int btusb_qca_send_vendor_req(struct hci_dev *hdev, u8 request,
2472 void *data, u16 size)
2473{
2474 struct btusb_data *btdata = hci_get_drvdata(hdev);
2475 struct usb_device *udev = btdata->udev;
2476 int pipe, err;
2477 u8 *buf;
2478
2479 buf = kmalloc(size, GFP_KERNEL);
2480 if (!buf)
2481 return -ENOMEM;
2482
2483 /* Found some of USB hosts have IOT issues with ours so that we should
2484 * not wait until HCI layer is ready.
2485 */
2486 pipe = usb_rcvctrlpipe(udev, 0);
2487 err = usb_control_msg(udev, pipe, request, USB_TYPE_VENDOR | USB_DIR_IN,
2488 0, 0, buf, size, USB_CTRL_SET_TIMEOUT);
2489 if (err < 0) {
2064ee33 2490 bt_dev_err(hdev, "Failed to access otp area (%d)", err);
3267c884
KBYT		 2491 goto done;
2492 }
2493
2494 memcpy(data, buf, size);
2495
2496done:
2497 kfree(buf);
2498
2499 return err;
2500}
2501
2502static int btusb_setup_qca_download_fw(struct hci_dev *hdev,
2503 const struct firmware *firmware,
2504 size_t hdr_size)
2505{
2506 struct btusb_data *btdata = hci_get_drvdata(hdev);
2507 struct usb_device *udev = btdata->udev;
2508 size_t count, size, sent = 0;
2509 int pipe, len, err;
2510 u8 *buf;
2511
2512 buf = kmalloc(QCA_DFU_PACKET_LEN, GFP_KERNEL);
2513 if (!buf)
2514 return -ENOMEM;
2515
2516 count = firmware->size;
2517
2518 size = min_t(size_t, count, hdr_size);
2519 memcpy(buf, firmware->data, size);
2520
2521 /* USB patches should go down to controller through USB path
2522 * because binary format fits to go down through USB channel.
2523 * USB control path is for patching headers and USB bulk is for
2524 * patch body.
2525 */
2526 pipe = usb_sndctrlpipe(udev, 0);
2527 err = usb_control_msg(udev, pipe, QCA_DFU_DOWNLOAD, USB_TYPE_VENDOR,
2528 0, 0, buf, size, USB_CTRL_SET_TIMEOUT);
2529 if (err < 0) {
2064ee33 2530 bt_dev_err(hdev, "Failed to send headers (%d)", err);
3267c884
KBYT		 2531 goto done;
2532 }
2533
2534 sent += size;
2535 count -= size;
2536
2537 while (count) {
2538 size = min_t(size_t, count, QCA_DFU_PACKET_LEN);
2539
2540 memcpy(buf, firmware->data + sent, size);
2541
2542 pipe = usb_sndbulkpipe(udev, 0x02);
2543 err = usb_bulk_msg(udev, pipe, buf, size, &len,
2544 QCA_DFU_TIMEOUT);
2545 if (err < 0) {
2064ee33
MH		 2546 bt_dev_err(hdev, "Failed to send body at %zd of %zd (%d)",
2547 sent, firmware->size, err);
3267c884
KBYT		 2548 break;
2549 }
2550
2551 if (size != len) {
2064ee33 2552 bt_dev_err(hdev, "Failed to get bulk buffer");
3267c884
KBYT		 2553 err = -EILSEQ;
2554 break;
2555 }
2556
2557 sent += size;
2558 count -= size;
2559 }
2560
2561done:
2562 kfree(buf);
2563 return err;
2564}
2565
2566static int btusb_setup_qca_load_rampatch(struct hci_dev *hdev,
2567 struct qca_version *ver,
2568 const struct qca_device_info *info)
2569{
2570 struct qca_rampatch_version *rver;
2571 const struct firmware *fw;
bf906b3d
KBYT		 2572 u32 ver_rom, ver_patch;
2573 u16 rver_rom, rver_patch;
3267c884
KBYT		 2574 char fwname[64];
2575 int err;
2576
bf906b3d
KBYT		 2577 ver_rom = le32_to_cpu(ver->rom_version);
2578 ver_patch = le32_to_cpu(ver->patch_version);
2579
2580 snprintf(fwname, sizeof(fwname), "qca/rampatch_usb_%08x.bin", ver_rom);
3267c884
KBYT		 2581
2582 err = request_firmware(&fw, fwname, &hdev->dev);
2583 if (err) {
2064ee33
MH		 2584 bt_dev_err(hdev, "failed to request rampatch file: %s (%d)",
2585 fwname, err);
3267c884
KBYT		 2586 return err;
2587 }
2588
2064ee33 2589 bt_dev_info(hdev, "using rampatch file: %s", fwname);
bf906b3d 2590
3267c884 2591 rver = (struct qca_rampatch_version *)(fw->data + info->ver_offset);
bf906b3d
KBYT		 2592 rver_rom = le16_to_cpu(rver->rom_version);
2593 rver_patch = le16_to_cpu(rver->patch_version);
2594
2064ee33
MH		 2595 bt_dev_info(hdev, "QCA: patch rome 0x%x build 0x%x, "
2596 "firmware rome 0x%x build 0x%x",
2597 rver_rom, rver_patch, ver_rom, ver_patch);
3267c884 2598
bf906b3d 2599 if (rver_rom != ver_rom || rver_patch <= ver_patch) {
2064ee33 2600 bt_dev_err(hdev, "rampatch file version did not match with firmware");
3267c884
KBYT		 2601 err = -EINVAL;
2602 goto done;
2603 }
2604
2605 err = btusb_setup_qca_download_fw(hdev, fw, info->rampatch_hdr);
2606
2607done:
2608 release_firmware(fw);
2609
2610 return err;
2611}
2612
2613static int btusb_setup_qca_load_nvm(struct hci_dev *hdev,
2614 struct qca_version *ver,
2615 const struct qca_device_info *info)
2616{
2617 const struct firmware *fw;
2618 char fwname[64];
2619 int err;
2620
2621 snprintf(fwname, sizeof(fwname), "qca/nvm_usb_%08x.bin",
2622 le32_to_cpu(ver->rom_version));
2623
2624 err = request_firmware(&fw, fwname, &hdev->dev);
2625 if (err) {
2064ee33
MH		 2626 bt_dev_err(hdev, "failed to request NVM file: %s (%d)",
2627 fwname, err);
3267c884
KBYT		 2628 return err;
2629 }
2630
2064ee33 2631 bt_dev_info(hdev, "using NVM file: %s", fwname);
3267c884
KBYT		 2632
2633 err = btusb_setup_qca_download_fw(hdev, fw, info->nvm_hdr);
2634
2635 release_firmware(fw);
2636
2637 return err;
2638}
2639
2640static int btusb_setup_qca(struct hci_dev *hdev)
2641{
2642 const struct qca_device_info *info = NULL;
2643 struct qca_version ver;
bf906b3d 2644 u32 ver_rom;
3267c884
KBYT		 2645 u8 status;
2646 int i, err;
2647
2648 err = btusb_qca_send_vendor_req(hdev, QCA_GET_TARGET_VERSION, &ver,
eb50042f 2649 sizeof(ver));
3267c884
KBYT		 2650 if (err < 0)
2651 return err;
2652
bf906b3d 2653 ver_rom = le32_to_cpu(ver.rom_version);
3267c884 2654 for (i = 0; i < ARRAY_SIZE(qca_devices_table); i++) {
bf906b3d 2655 if (ver_rom == qca_devices_table[i].rom_version)
3267c884
KBYT		 2656 info = &qca_devices_table[i];
2657 }
2658 if (!info) {
2064ee33 2659 bt_dev_err(hdev, "don't support firmware rome 0x%x", ver_rom);
3267c884
KBYT		 2660 return -ENODEV;
2661 }
2662
2663 err = btusb_qca_send_vendor_req(hdev, QCA_CHECK_STATUS, &status,
2664 sizeof(status));
2665 if (err < 0)
2666 return err;
2667
2668 if (!(status & QCA_PATCH_UPDATED)) {
2669 err = btusb_setup_qca_load_rampatch(hdev, &ver, info);
2670 if (err < 0)
2671 return err;
2672 }
2673
2674 if (!(status & QCA_SYSCFG_UPDATED)) {
2675 err = btusb_setup_qca_load_nvm(hdev, &ver, info);
2676 if (err < 0)
2677 return err;
2678 }
2679
2680 return 0;
2681}
2682
9d08f504
MH		 2683#ifdef CONFIG_BT_HCIBTUSB_BCM
2684static inline int __set_diag_interface(struct hci_dev *hdev)
2685{
2686 struct btusb_data *data = hci_get_drvdata(hdev);
2687 struct usb_interface *intf = data->diag;
2688 int i;
2689
2690 if (!data->diag)
2691 return -ENODEV;
2692
2693 data->diag_tx_ep = NULL;
2694 data->diag_rx_ep = NULL;
2695
2696 for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++) {
2697 struct usb_endpoint_descriptor *ep_desc;
2698
2699 ep_desc = &intf->cur_altsetting->endpoint[i].desc;
2700
2701 if (!data->diag_tx_ep && usb_endpoint_is_bulk_out(ep_desc)) {
2702 data->diag_tx_ep = ep_desc;
2703 continue;
2704 }
2705
2706 if (!data->diag_rx_ep && usb_endpoint_is_bulk_in(ep_desc)) {
2707 data->diag_rx_ep = ep_desc;
2708 continue;
2709 }
2710 }
2711
2712 if (!data->diag_tx_ep || !data->diag_rx_ep) {
2064ee33 2713 bt_dev_err(hdev, "invalid diagnostic descriptors");
9d08f504
MH		 2714 return -ENODEV;
2715 }
2716
2717 return 0;
2718}
2719
2720static struct urb *alloc_diag_urb(struct hci_dev *hdev, bool enable)
2721{
2722 struct btusb_data *data = hci_get_drvdata(hdev);
2723 struct sk_buff *skb;
2724 struct urb *urb;
2725 unsigned int pipe;
2726
2727 if (!data->diag_tx_ep)
2728 return ERR_PTR(-ENODEV);
2729
2730 urb = usb_alloc_urb(0, GFP_KERNEL);
2731 if (!urb)
2732 return ERR_PTR(-ENOMEM);
2733
2734 skb = bt_skb_alloc(2, GFP_KERNEL);
2735 if (!skb) {
2736 usb_free_urb(urb);
2737 return ERR_PTR(-ENOMEM);
2738 }
2739
634fef61
JB		 2740 skb_put_u8(skb, 0xf0);
2741 skb_put_u8(skb, enable);
9d08f504
MH		 2742
2743 pipe = usb_sndbulkpipe(data->udev, data->diag_tx_ep->bEndpointAddress);
2744
2745 usb_fill_bulk_urb(urb, data->udev, pipe,
2746 skb->data, skb->len, btusb_tx_complete, skb);
2747
2748 skb->dev = (void *)hdev;
2749
2750 return urb;
2751}
2752
2753static int btusb_bcm_set_diag(struct hci_dev *hdev, bool enable)
2754{
2755 struct btusb_data *data = hci_get_drvdata(hdev);
2756 struct urb *urb;
2757
2758 if (!data->diag)
2759 return -ENODEV;
2760
2761 if (!test_bit(HCI_RUNNING, &hdev->flags))
2762 return -ENETDOWN;
2763
2764 urb = alloc_diag_urb(hdev, enable);
2765 if (IS_ERR(urb))
2766 return PTR_ERR(urb);
2767
2768 return submit_or_queue_tx_urb(hdev, urb);
2769}
2770#endif
2771
fd913ef7
RJ		 2772#ifdef CONFIG_PM
2773static irqreturn_t btusb_oob_wake_handler(int irq, void *priv)
2774{
2775 struct btusb_data *data = priv;
2776
2777 pm_wakeup_event(&data->udev->dev, 0);
017789f3 2778 pm_system_wakeup();
fd913ef7
RJ		 2779
2780 /* Disable only if not already disabled (keep it balanced) */
2781 if (test_and_clear_bit(BTUSB_OOB_WAKE_ENABLED, &data->flags)) {
2782 disable_irq_nosync(irq);
2783 disable_irq_wake(irq);
2784 }
2785 return IRQ_HANDLED;
2786}
2787
2788static const struct of_device_id btusb_match_table[] = {
2789 { .compatible = "usb1286,204e" },
2790 { }
2791};
2792MODULE_DEVICE_TABLE(of, btusb_match_table);
2793
2794/* Use an oob wakeup pin? */
2795static int btusb_config_oob_wake(struct hci_dev *hdev)
2796{
2797 struct btusb_data *data = hci_get_drvdata(hdev);
2798 struct device *dev = &data->udev->dev;
2799 int irq, ret;
2800
2801 clear_bit(BTUSB_OOB_WAKE_ENABLED, &data->flags);
2802
2803 if (!of_match_device(btusb_match_table, dev))
2804 return 0;
2805
2806 /* Move on if no IRQ specified */
2807 irq = of_irq_get_byname(dev->of_node, "wakeup");
2808 if (irq <= 0) {
2809 bt_dev_dbg(hdev, "%s: no OOB Wakeup IRQ in DT", __func__);
2810 return 0;
2811 }
2812
2813 ret = devm_request_irq(&hdev->dev, irq, btusb_oob_wake_handler,
2814 0, "OOB Wake-on-BT", data);
2815 if (ret) {
2816 bt_dev_err(hdev, "%s: IRQ request failed", __func__);
2817 return ret;
2818 }
2819
2820 ret = device_init_wakeup(dev, true);
2821 if (ret) {
2822 bt_dev_err(hdev, "%s: failed to init_wakeup", __func__);
2823 return ret;
2824 }
2825
2826 data->oob_wake_irq = irq;
2827 disable_irq(irq);
2828 bt_dev_info(hdev, "OOB Wake-on-BT configured at IRQ %u", irq);
2829 return 0;
2830}
2831#endif
2832
5e23b923 2833static int btusb_probe(struct usb_interface *intf,
89e7533d 2834 const struct usb_device_id *id)
5e23b923
MH		 2835{
2836 struct usb_endpoint_descriptor *ep_desc;
2837 struct btusb_data *data;
2838 struct hci_dev *hdev;
22f8e9db 2839 unsigned ifnum_base;
5e23b923
MH		 2840 int i, err;
2841
2842 BT_DBG("intf %p id %p", intf, id);
2843
cfeb4145 2844 /* interface numbers are hardcoded in the spec */
22f8e9db
MH		 2845 if (intf->cur_altsetting->desc.bInterfaceNumber != 0) {
2846 if (!(id->driver_info & BTUSB_IFNUM_2))
2847 return -ENODEV;
2848 if (intf->cur_altsetting->desc.bInterfaceNumber != 2)
2849 return -ENODEV;
2850 }
2851
2852 ifnum_base = intf->cur_altsetting->desc.bInterfaceNumber;
5e23b923
MH		 2853
2854 if (!id->driver_info) {
2855 const struct usb_device_id *match;
89e7533d 2856
5e23b923
MH		 2857 match = usb_match_id(intf, blacklist_table);
2858 if (match)
2859 id = match;
2860 }
2861
cfeb4145
MH		 2862 if (id->driver_info == BTUSB_IGNORE)
2863 return -ENODEV;
2864
2d25f8b4
SL		 2865 if (id->driver_info & BTUSB_ATH3012) {
2866 struct usb_device *udev = interface_to_usbdev(intf);
2867
2868 /* Old firmware would otherwise let ath3k driver load
d98422cb
DR		 2869 * patch and sysconfig files
2870 */
2d25f8b4
SL		 2871 if (le16_to_cpu(udev->descriptor.bcdDevice) <= 0x0001)
2872 return -ENODEV;
2873 }
2874
98921dbd 2875 data = devm_kzalloc(&intf->dev, sizeof(*data), GFP_KERNEL);
5e23b923
MH		 2876 if (!data)
2877 return -ENOMEM;
2878
2879 for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++) {
2880 ep_desc = &intf->cur_altsetting->endpoint[i].desc;
2881
2882 if (!data->intr_ep && usb_endpoint_is_int_in(ep_desc)) {
2883 data->intr_ep = ep_desc;
2884 continue;
2885 }
2886
2887 if (!data->bulk_tx_ep && usb_endpoint_is_bulk_out(ep_desc)) {
2888 data->bulk_tx_ep = ep_desc;
2889 continue;
2890 }
2891
2892 if (!data->bulk_rx_ep && usb_endpoint_is_bulk_in(ep_desc)) {
2893 data->bulk_rx_ep = ep_desc;
2894 continue;
2895 }
2896 }
2897
98921dbd 2898 if (!data->intr_ep || !data->bulk_tx_ep || !data->bulk_rx_ep)
5e23b923 2899 return -ENODEV;
5e23b923 2900
893ba544
MH		 2901 if (id->driver_info & BTUSB_AMP) {
2902 data->cmdreq_type = USB_TYPE_CLASS | 0x01;
2903 data->cmdreq = 0x2b;
2904 } else {
2905 data->cmdreq_type = USB_TYPE_CLASS;
2906 data->cmdreq = 0x00;
2907 }
7a9d4020 2908
5e23b923 2909 data->udev = interface_to_usbdev(intf);
5fbcd260 2910 data->intf = intf;
5e23b923 2911
5e23b923 2912 INIT_WORK(&data->work, btusb_work);
7bee549e 2913 INIT_WORK(&data->waker, btusb_waker);
803b5836
MH		 2914 init_usb_anchor(&data->deferred);
2915 init_usb_anchor(&data->tx_anchor);
7bee549e 2916 spin_lock_init(&data->txlock);
5e23b923 2917
5e23b923
MH		 2918 init_usb_anchor(&data->intr_anchor);
2919 init_usb_anchor(&data->bulk_anchor);
9bfa35fe 2920 init_usb_anchor(&data->isoc_anchor);
9d08f504 2921 init_usb_anchor(&data->diag_anchor);
803b5836 2922 spin_lock_init(&data->rxlock);
5e23b923 2923
cda0dd78
MH		 2924 if (id->driver_info & BTUSB_INTEL_NEW) {
2925 data->recv_event = btusb_recv_event_intel;
2926 data->recv_bulk = btusb_recv_bulk_intel;
2927 set_bit(BTUSB_BOOTLOADER, &data->flags);
2928 } else {
2929 data->recv_event = hci_recv_frame;
2930 data->recv_bulk = btusb_recv_bulk;
2931 }
2cbd3f5c 2932
5e23b923 2933 hdev = hci_alloc_dev();
98921dbd 2934 if (!hdev)
5e23b923 2935 return -ENOMEM;
5e23b923 2936
c13854ce 2937 hdev->bus = HCI_USB;
155961e8 2938 hci_set_drvdata(hdev, data);
5e23b923 2939
893ba544
MH		 2940 if (id->driver_info & BTUSB_AMP)
2941 hdev->dev_type = HCI_AMP;
2942 else
ca8bee5d 2943 hdev->dev_type = HCI_PRIMARY;
893ba544 2944
5e23b923
MH		 2945 data->hdev = hdev;
2946
2947 SET_HCIDEV_DEV(hdev, &intf->dev);
2948
9f8f962c
MH		 2949 hdev->open = btusb_open;
2950 hdev->close = btusb_close;
2951 hdev->flush = btusb_flush;
2952 hdev->send = btusb_send_frame;
2953 hdev->notify = btusb_notify;
2954
fd913ef7
RJ		 2955#ifdef CONFIG_PM
2956 err = btusb_config_oob_wake(hdev);
2957 if (err)
2958 goto out_free_dev;
a4ccc9e3
RJ		 2959
2960 /* Marvell devices may need a specific chip configuration */
2961 if (id->driver_info & BTUSB_MARVELL && data->oob_wake_irq) {
2962 err = marvell_config_oob_wake(hdev);
2963 if (err)
2964 goto out_free_dev;
2965 }
fd913ef7 2966#endif
418678b0
SJ		 2967 if (id->driver_info & BTUSB_CW6622)
2968 set_bit(HCI_QUIRK_BROKEN_STORED_LINK_KEY, &hdev->quirks);
2969
6c9d435d
MH		 2970 if (id->driver_info & BTUSB_BCM2045)
2971 set_bit(HCI_QUIRK_BROKEN_STORED_LINK_KEY, &hdev->quirks);
2972
9f8f962c
MH		 2973 if (id->driver_info & BTUSB_BCM92035)
2974 hdev->setup = btusb_setup_bcm92035;
5e23b923 2975
c2bfb100 2976#ifdef CONFIG_BT_HCIBTUSB_BCM
abbaf50e 2977 if (id->driver_info & BTUSB_BCM_PATCHRAM) {
49a5f782 2978 hdev->manufacturer = 15;
c2bfb100 2979 hdev->setup = btbcm_setup_patchram;
9d08f504 2980 hdev->set_diag = btusb_bcm_set_diag;
1df1f591 2981 hdev->set_bdaddr = btbcm_set_bdaddr;
9d08f504
MH		 2982
2983 /* Broadcom LM_DIAG Interface numbers are hardcoded */
22f8e9db 2984 data->diag = usb_ifnum_to_if(data->udev, ifnum_base + 2);
abbaf50e 2985 }
10d4c673 2986
9d08f504 2987 if (id->driver_info & BTUSB_BCM_APPLE) {
49a5f782 2988 hdev->manufacturer = 15;
c2bfb100 2989 hdev->setup = btbcm_setup_apple;
9d08f504
MH		 2990 hdev->set_diag = btusb_bcm_set_diag;
2991
2992 /* Broadcom LM_DIAG Interface numbers are hardcoded */
22f8e9db 2993 data->diag = usb_ifnum_to_if(data->udev, ifnum_base + 2);
9d08f504 2994 }
c2bfb100 2995#endif
17b2772b 2996
cb8d6597 2997 if (id->driver_info & BTUSB_INTEL) {
49a5f782 2998 hdev->manufacturer = 2;
dffd30ee 2999 hdev->setup = btusb_setup_intel;
bfbd45e9 3000 hdev->shutdown = btusb_shutdown_intel;
3e24767b 3001 hdev->set_diag = btintel_set_diag_mfg;
4185a0f5 3002 hdev->set_bdaddr = btintel_set_bdaddr;
c33fb9b4 3003 set_bit(HCI_QUIRK_STRICT_DUPLICATE_FILTER, &hdev->quirks);
c1154842 3004 set_bit(HCI_QUIRK_SIMULTANEOUS_DISCOVERY, &hdev->quirks);
3e24767b 3005 set_bit(HCI_QUIRK_NON_PERSISTENT_DIAG, &hdev->quirks);
cb8d6597 3006 }
dffd30ee 3007
cda0dd78 3008 if (id->driver_info & BTUSB_INTEL_NEW) {
49a5f782 3009 hdev->manufacturer = 2;
cda0dd78
MH		 3010 hdev->send = btusb_send_frame_intel;
3011 hdev->setup = btusb_setup_intel_new;
eeb6abe9 3012 hdev->hw_error = btintel_hw_error;
6d2e50d2 3013 hdev->set_diag = btintel_set_diag;
4185a0f5 3014 hdev->set_bdaddr = btintel_set_bdaddr;
b970c5ba 3015 set_bit(HCI_QUIRK_STRICT_DUPLICATE_FILTER, &hdev->quirks);
d8270fbb 3016 set_bit(HCI_QUIRK_NON_PERSISTENT_DIAG, &hdev->quirks);
cda0dd78
MH		 3017 }
3018
ae8df494
AK		 3019 if (id->driver_info & BTUSB_MARVELL)
3020 hdev->set_bdaddr = btusb_set_bdaddr_marvell;
3021
661cf88a
MH		 3022 if (id->driver_info & BTUSB_SWAVE) {
3023 set_bit(HCI_QUIRK_FIXUP_INQUIRY_MODE, &hdev->quirks);
d57dbe77 3024 set_bit(HCI_QUIRK_BROKEN_LOCAL_COMMANDS, &hdev->quirks);
661cf88a 3025 }
d57dbe77 3026
e4c534bb
MH		 3027 if (id->driver_info & BTUSB_INTEL_BOOT) {
3028 hdev->manufacturer = 2;
40df783d 3029 set_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks);
e4c534bb 3030 }
40df783d 3031
79f0c87d 3032 if (id->driver_info & BTUSB_ATH3012) {
5859223e 3033 hdev->set_bdaddr = btusb_set_bdaddr_ath3012;
3d50d51a 3034 set_bit(HCI_QUIRK_SIMULTANEOUS_DISCOVERY, &hdev->quirks);
79f0c87d
JP		 3035 set_bit(HCI_QUIRK_STRICT_DUPLICATE_FILTER, &hdev->quirks);
3036 }
5859223e 3037
3267c884
KBYT		 3038 if (id->driver_info & BTUSB_QCA_ROME) {
3039 data->setup_on_usb = btusb_setup_qca;
3040 hdev->set_bdaddr = btusb_set_bdaddr_ath3012;
61f5acea
HG		 3041
3042 /* QCA Rome devices lose their updated firmware over suspend,
3043 * but the USB hub doesn't notice any status change.
3044 * explicitly request a device reset on resume.
3045 */
3046 interface_to_usbdev(intf)->quirks |= USB_QUIRK_RESET_RESUME;
3267c884
KBYT		 3047 }
3048
db33c77d 3049#ifdef CONFIG_BT_HCIBTUSB_RTL
04b8c814 3050 if (id->driver_info & BTUSB_REALTEK) {
db33c77d 3051 hdev->setup = btrtl_setup_realtek;
04b8c814
DD		 3052
3053 /* Realtek devices lose their updated firmware over suspend,
3054 * but the USB hub doesn't notice any status change.
3055 * Explicitly request a device reset on resume.
3056 */
61f5acea 3057 interface_to_usbdev(intf)->quirks |= USB_QUIRK_RESET_RESUME;
04b8c814 3058 }
db33c77d 3059#endif
a2698a9b 3060
893ba544
MH		 3061 if (id->driver_info & BTUSB_AMP) {
3062 /* AMP controllers do not support SCO packets */
3063 data->isoc = NULL;
3064 } else {
22f8e9db
MH		 3065 /* Interface orders are hardcoded in the specification */
3066 data->isoc = usb_ifnum_to_if(data->udev, ifnum_base + 1);
459232fc 3067 data->isoc_ifnum = ifnum_base + 1;
893ba544 3068 }
9bfa35fe 3069
7a9d4020 3070 if (!reset)
a6c511c6 3071 set_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks);
cfeb4145
MH		 3072
3073 if (force_scofix || id->driver_info & BTUSB_WRONG_SCO_MTU) {
3074 if (!disable_scofix)
3075 set_bit(HCI_QUIRK_FIXUP_BUFFER_SIZE, &hdev->quirks);
3076 }
3077
9bfa35fe
MH		 3078 if (id->driver_info & BTUSB_BROKEN_ISOC)
3079 data->isoc = NULL;
3080
7a9d4020
MH		 3081 if (id->driver_info & BTUSB_DIGIANSWER) {
3082 data->cmdreq_type = USB_TYPE_VENDOR;
a6c511c6 3083 set_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks);
7a9d4020
MH		 3084 }
3085
3086 if (id->driver_info & BTUSB_CSR) {
3087 struct usb_device *udev = data->udev;
81cac64b 3088 u16 bcdDevice = le16_to_cpu(udev->descriptor.bcdDevice);
7a9d4020
MH		 3089
3090 /* Old firmware would otherwise execute USB reset */
81cac64b 3091 if (bcdDevice < 0x117)
a6c511c6 3092 set_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks);
81cac64b
MH		 3093
3094 /* Fake CSR devices with broken commands */
6cafcd95 3095 if (bcdDevice <= 0x100 || bcdDevice == 0x134)
81cac64b 3096 hdev->setup = btusb_setup_csr;
49c989a0
JP		 3097
3098 set_bit(HCI_QUIRK_SIMULTANEOUS_DISCOVERY, &hdev->quirks);
7a9d4020
MH		 3099 }
3100
cfeb4145 3101 if (id->driver_info & BTUSB_SNIFFER) {
9bfa35fe 3102 struct usb_device *udev = data->udev;
cfeb4145 3103
7a9d4020 3104 /* New sniffer firmware has crippled HCI interface */
cfeb4145
MH		 3105 if (le16_to_cpu(udev->descriptor.bcdDevice) > 0x997)
3106 set_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks);
3107 }
3108
3a5ef20c
MH		 3109 if (id->driver_info & BTUSB_INTEL_BOOT) {
3110 /* A bug in the bootloader causes that interrupt interface is
3111 * only enabled after receiving SetInterface(0, AltSetting=0).
3112 */
3113 err = usb_set_interface(data->udev, 0, 0);
3114 if (err < 0) {
3115 BT_ERR("failed to set interface 0, alt 0 %d", err);
10ab133b 3116 goto out_free_dev;
3a5ef20c
MH		 3117 }
3118 }
3119
9bfa35fe
MH		 3120 if (data->isoc) {
3121 err = usb_driver_claim_interface(&btusb_driver,
89e7533d 3122 data->isoc, data);
10ab133b
RJ		 3123 if (err < 0)
3124 goto out_free_dev;
9bfa35fe
MH		 3125 }
3126
9d08f504
MH		 3127#ifdef CONFIG_BT_HCIBTUSB_BCM
3128 if (data->diag) {
3129 if (!usb_driver_claim_interface(&btusb_driver,
3130 data->diag, data))
3131 __set_diag_interface(hdev);
3132 else
3133 data->diag = NULL;
3134 }
3135#endif
3136
eff2d68c
HG		 3137 if (enable_autosuspend)
3138 usb_enable_autosuspend(data->udev);
3139
5e23b923 3140 err = hci_register_dev(hdev);
10ab133b
RJ		 3141 if (err < 0)
3142 goto out_free_dev;
5e23b923
MH		 3143
3144 usb_set_intfdata(intf, data);
3145
3146 return 0;
10ab133b
RJ		 3147
3148out_free_dev:
3149 hci_free_dev(hdev);
3150 return err;
5e23b923
MH		 3151}
3152
3153static void btusb_disconnect(struct usb_interface *intf)
3154{
3155 struct btusb_data *data = usb_get_intfdata(intf);
3156 struct hci_dev *hdev;
3157
3158 BT_DBG("intf %p", intf);
3159
3160 if (!data)
3161 return;
3162
3163 hdev = data->hdev;
5fbcd260
MH		 3164 usb_set_intfdata(data->intf, NULL);
3165
3166 if (data->isoc)
3167 usb_set_intfdata(data->isoc, NULL);
5e23b923 3168
9d08f504
MH		 3169 if (data->diag)
3170 usb_set_intfdata(data->diag, NULL);
3171
5e23b923
MH		 3172 hci_unregister_dev(hdev);
3173
9d08f504
MH		 3174 if (intf == data->intf) {
3175 if (data->isoc)
3176 usb_driver_release_interface(&btusb_driver, data->isoc);
3177 if (data->diag)
3178 usb_driver_release_interface(&btusb_driver, data->diag);
3179 } else if (intf == data->isoc) {
3180 if (data->diag)
3181 usb_driver_release_interface(&btusb_driver, data->diag);
5fbcd260 3182 usb_driver_release_interface(&btusb_driver, data->intf);
9d08f504
MH		 3183 } else if (intf == data->diag) {
3184 usb_driver_release_interface(&btusb_driver, data->intf);
3185 if (data->isoc)
3186 usb_driver_release_interface(&btusb_driver, data->isoc);
3187 }
5fbcd260 3188
fd913ef7
RJ		 3189 if (data->oob_wake_irq)
3190 device_init_wakeup(&data->udev->dev, false);
3191
5e23b923
MH		 3192 hci_free_dev(hdev);
3193}
3194
7bee549e 3195#ifdef CONFIG_PM
6a88adf2
MH		 3196static int btusb_suspend(struct usb_interface *intf, pm_message_t message)
3197{
3198 struct btusb_data *data = usb_get_intfdata(intf);
3199
3200 BT_DBG("intf %p", intf);
3201
3202 if (data->suspend_count++)
3203 return 0;
3204
7bee549e 3205 spin_lock_irq(&data->txlock);
5b1b0b81 3206 if (!(PMSG_IS_AUTO(message) && data->tx_in_flight)) {
7bee549e
ON		 3207 set_bit(BTUSB_SUSPENDING, &data->flags);
3208 spin_unlock_irq(&data->txlock);
3209 } else {
3210 spin_unlock_irq(&data->txlock);
3211 data->suspend_count--;
3212 return -EBUSY;
3213 }
3214
6a88adf2
MH		 3215 cancel_work_sync(&data->work);
3216
7bee549e 3217 btusb_stop_traffic(data);
6a88adf2
MH		 3218 usb_kill_anchored_urbs(&data->tx_anchor);
3219
fd913ef7
RJ		 3220 if (data->oob_wake_irq && device_may_wakeup(&data->udev->dev)) {
3221 set_bit(BTUSB_OOB_WAKE_ENABLED, &data->flags);
3222 enable_irq_wake(data->oob_wake_irq);
3223 enable_irq(data->oob_wake_irq);
3224 }
3225
6a88adf2
MH		 3226 return 0;
3227}
3228
7bee549e
ON		 3229static void play_deferred(struct btusb_data *data)
3230{
3231 struct urb *urb;
3232 int err;
3233
3234 while ((urb = usb_get_from_anchor(&data->deferred))) {
19cfe912
JC		 3235 usb_anchor_urb(urb, &data->tx_anchor);
3236
7bee549e 3237 err = usb_submit_urb(urb, GFP_ATOMIC);
19cfe912
JC		 3238 if (err < 0) {
3239 if (err != -EPERM && err != -ENODEV)
3240 BT_ERR("%s urb %p submission failed (%d)",
3241 data->hdev->name, urb, -err);
3242 kfree(urb->setup_packet);
3243 usb_unanchor_urb(urb);
3244 usb_free_urb(urb);
7bee549e 3245 break;
19cfe912 3246 }
7bee549e
ON		 3247
3248 data->tx_in_flight++;
19cfe912
JC		 3249 usb_free_urb(urb);
3250 }
3251
3252 /* Cleanup the rest deferred urbs. */
3253 while ((urb = usb_get_from_anchor(&data->deferred))) {
3254 kfree(urb->setup_packet);
3255 usb_free_urb(urb);
7bee549e 3256 }
7bee549e
ON		 3257}
3258
6a88adf2
MH		 3259static int btusb_resume(struct usb_interface *intf)
3260{
3261 struct btusb_data *data = usb_get_intfdata(intf);
3262 struct hci_dev *hdev = data->hdev;
7bee549e 3263 int err = 0;
6a88adf2
MH		 3264
3265 BT_DBG("intf %p", intf);
3266
3267 if (--data->suspend_count)
3268 return 0;
3269
fd913ef7
RJ		 3270 /* Disable only if not already disabled (keep it balanced) */
3271 if (test_and_clear_bit(BTUSB_OOB_WAKE_ENABLED, &data->flags)) {
3272 disable_irq(data->oob_wake_irq);
3273 disable_irq_wake(data->oob_wake_irq);
3274 }
3275
6a88adf2 3276 if (!test_bit(HCI_RUNNING, &hdev->flags))
7bee549e 3277 goto done;
6a88adf2
MH		 3278
3279 if (test_bit(BTUSB_INTR_RUNNING, &data->flags)) {
3280 err = btusb_submit_intr_urb(hdev, GFP_NOIO);
3281 if (err < 0) {
3282 clear_bit(BTUSB_INTR_RUNNING, &data->flags);
7bee549e 3283 goto failed;
6a88adf2
MH		 3284 }
3285 }
3286
3287 if (test_bit(BTUSB_BULK_RUNNING, &data->flags)) {
43c2e57f
MH		 3288 err = btusb_submit_bulk_urb(hdev, GFP_NOIO);
3289 if (err < 0) {
6a88adf2 3290 clear_bit(BTUSB_BULK_RUNNING, &data->flags);
7bee549e
ON		 3291 goto failed;
3292 }
3293
3294 btusb_submit_bulk_urb(hdev, GFP_NOIO);
6a88adf2
MH		 3295 }
3296
3297 if (test_bit(BTUSB_ISOC_RUNNING, &data->flags)) {
3298 if (btusb_submit_isoc_urb(hdev, GFP_NOIO) < 0)
3299 clear_bit(BTUSB_ISOC_RUNNING, &data->flags);
3300 else
3301 btusb_submit_isoc_urb(hdev, GFP_NOIO);
3302 }
3303
7bee549e
ON		 3304 spin_lock_irq(&data->txlock);
3305 play_deferred(data);
3306 clear_bit(BTUSB_SUSPENDING, &data->flags);
3307 spin_unlock_irq(&data->txlock);
3308 schedule_work(&data->work);
3309
6a88adf2 3310 return 0;
7bee549e
ON		 3311
3312failed:
3313 usb_scuttle_anchored_urbs(&data->deferred);
3314done:
3315 spin_lock_irq(&data->txlock);
3316 clear_bit(BTUSB_SUSPENDING, &data->flags);
3317 spin_unlock_irq(&data->txlock);
3318
3319 return err;
6a88adf2 3320}
7bee549e 3321#endif
6a88adf2 3322
5e23b923
MH		 3323static struct usb_driver btusb_driver = {
3324 .name = "btusb",
3325 .probe = btusb_probe,
3326 .disconnect = btusb_disconnect,
7bee549e 3327#ifdef CONFIG_PM
6a88adf2
MH		 3328 .suspend = btusb_suspend,
3329 .resume = btusb_resume,
7bee549e 3330#endif
5e23b923 3331 .id_table = btusb_table,
7bee549e 3332 .supports_autosuspend = 1,
e1f12eb6 3333 .disable_hub_initiated_lpm = 1,
5e23b923
MH		 3334};
3335
93f1508c 3336module_usb_driver(btusb_driver);
5e23b923 3337
cfeb4145
MH		 3338module_param(disable_scofix, bool, 0644);
3339MODULE_PARM_DESC(disable_scofix, "Disable fixup of wrong SCO buffer size");
3340
3341module_param(force_scofix, bool, 0644);
3342MODULE_PARM_DESC(force_scofix, "Force fixup of wrong SCO buffers size");
3343
eff2d68c
HG		 3344module_param(enable_autosuspend, bool, 0644);
3345MODULE_PARM_DESC(enable_autosuspend, "Enable USB autosuspend by default");
3346
cfeb4145
MH		 3347module_param(reset, bool, 0644);
3348MODULE_PARM_DESC(reset, "Send HCI reset command on initialization");
3349
5e23b923
MH		 3350MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
3351MODULE_DESCRIPTION("Generic Bluetooth USB driver ver " VERSION);
3352MODULE_VERSION(VERSION);
3353MODULE_LICENSE("GPL");
Ubuntu Hirsute Linux kernel mirror