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