Doug / smarc-fsl-linux-kernel

1

/*

1

/*

2

*

2

*

3

* Generic Bluetooth USB driver

3

* Generic Bluetooth USB driver

4

*

4

*

5

6

*

6

*

7

*

7

*

8

* This program is free software; you can redistribute it and/or modify

8

* This program is free software; you can redistribute it and/or modify

9

* it under the terms of the GNU General Public License as published by

9

* it under the terms of the GNU General Public License as published by

10

* the Free Software Foundation; either version 2 of the License, or

10

* the Free Software Foundation; either version 2 of the License, or

11

* (at your option) any later version.

11

* (at your option) any later version.

12

*

12

*

13

* This program is distributed in the hope that it will be useful,

13

* This program is distributed in the hope that it will be useful,

14

* but WITHOUT ANY WARRANTY; without even the implied warranty of

14

* but WITHOUT ANY WARRANTY; without even the implied warranty of

15

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

15

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

16

* GNU General Public License for more details.

16

* GNU General Public License for more details.

17

*

17

*

18

* You should have received a copy of the GNU General Public License

18

* You should have received a copy of the GNU General Public License

19

* along with this program; if not, write to the Free Software

19

* along with this program; if not, write to the Free Software

20

* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

20

* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

21

*

21

*

22

*/

22

*/

23

24

#include <linux/module.h>

24

#include <linux/module.h>

25

#include <linux/usb.h>

25

#include <linux/usb.h>

26

#include <linux/firmware.h>

26

#include <linux/firmware.h>

27

28

#include <net/bluetooth/bluetooth.h>

28

#include <net/bluetooth/bluetooth.h>

29

#include <net/bluetooth/hci_core.h>

29

#include <net/bluetooth/hci_core.h>

30

31

#define VERSION "0.6"

31

#define VERSION "0.6"

32

33

static bool ignore_dga;

33

static bool ignore_dga;

34

static bool ignore_csr;

34

static bool ignore_csr;

35

static bool ignore_sniffer;

35

static bool ignore_sniffer;

36

static bool disable_scofix;

36

static bool disable_scofix;

37

static bool force_scofix;

37

static bool force_scofix;

38

39

static bool reset = 1;

39

static bool reset = 1;

40

41

static struct usb_driver btusb_driver;

41

static struct usb_driver btusb_driver;

42

43

#define BTUSB_IGNORE 0x01

43

#define BTUSB_IGNORE 0x01

44

#define BTUSB_DIGIANSWER 0x02

44

#define BTUSB_DIGIANSWER 0x02

45

#define BTUSB_CSR 0x04

45

#define BTUSB_CSR 0x04

46

#define BTUSB_SNIFFER 0x08

46

#define BTUSB_SNIFFER 0x08

47

#define BTUSB_BCM92035 0x10

47

#define BTUSB_BCM92035 0x10

48

#define BTUSB_BROKEN_ISOC 0x20

48

#define BTUSB_BROKEN_ISOC 0x20

49

#define BTUSB_WRONG_SCO_MTU 0x40

49

#define BTUSB_WRONG_SCO_MTU 0x40

50

#define BTUSB_ATH3012 0x80

50

#define BTUSB_ATH3012 0x80

51

#define BTUSB_INTEL 0x100

51

#define BTUSB_INTEL 0x100

52

53

static struct usb_device_id btusb_table[] = {

53

static struct usb_device_id btusb_table[] = {

54

/* Generic Bluetooth USB device */

54

/* Generic Bluetooth USB device */

55

{ USB_DEVICE_INFO(0xe0, 0x01, 0x01) },

55

{ USB_DEVICE_INFO(0xe0, 0x01, 0x01) },

56

57

/* Apple-specific (Broadcom) devices */

57

/* Apple-specific (Broadcom) devices */

58

{ USB_VENDOR_AND_INTERFACE_INFO(0x05ac, 0xff, 0x01, 0x01) },

58

{ USB_VENDOR_AND_INTERFACE_INFO(0x05ac, 0xff, 0x01, 0x01) },

59

60

/* MediaTek MT76x0E */

61

{ USB_DEVICE(0x0e8d, 0x763f) },

62

60

/* Broadcom SoftSailing reporting vendor specific */

63

/* Broadcom SoftSailing reporting vendor specific */

61

{ USB_DEVICE(0x0a5c, 0x21e1) },

64

{ USB_DEVICE(0x0a5c, 0x21e1) },

62

65

63

/* Apple MacBookPro 7,1 */

66

/* Apple MacBookPro 7,1 */

64

{ USB_DEVICE(0x05ac, 0x8213) },

67

{ USB_DEVICE(0x05ac, 0x8213) },

65

68

66

/* Apple iMac11,1 */

69

/* Apple iMac11,1 */

67

{ USB_DEVICE(0x05ac, 0x8215) },

70

{ USB_DEVICE(0x05ac, 0x8215) },

68

71

69

/* Apple MacBookPro6,2 */

72

/* Apple MacBookPro6,2 */

70

{ USB_DEVICE(0x05ac, 0x8218) },

73

{ USB_DEVICE(0x05ac, 0x8218) },

71

74

72

/* Apple MacBookAir3,1, MacBookAir3,2 */

75

/* Apple MacBookAir3,1, MacBookAir3,2 */

73

{ USB_DEVICE(0x05ac, 0x821b) },

76

{ USB_DEVICE(0x05ac, 0x821b) },

74

77

75

/* Apple MacBookAir4,1 */

78

/* Apple MacBookAir4,1 */

76

{ USB_DEVICE(0x05ac, 0x821f) },

79

{ USB_DEVICE(0x05ac, 0x821f) },

77

80

78

/* Apple MacBookPro8,2 */

81

/* Apple MacBookPro8,2 */

79

{ USB_DEVICE(0x05ac, 0x821a) },

82

{ USB_DEVICE(0x05ac, 0x821a) },

80

83

81

/* Apple MacMini5,1 */

84

/* Apple MacMini5,1 */

82

{ USB_DEVICE(0x05ac, 0x8281) },

85

{ USB_DEVICE(0x05ac, 0x8281) },

83

86

84

/* AVM BlueFRITZ! USB v2.0 */

87

/* AVM BlueFRITZ! USB v2.0 */

85

{ USB_DEVICE(0x057c, 0x3800) },

88

{ USB_DEVICE(0x057c, 0x3800) },

86

89

87

/* Bluetooth Ultraport Module from IBM */

90

/* Bluetooth Ultraport Module from IBM */

88

{ USB_DEVICE(0x04bf, 0x030a) },

91

{ USB_DEVICE(0x04bf, 0x030a) },

89

92

90

/* ALPS Modules with non-standard id */

93

/* ALPS Modules with non-standard id */

91

{ USB_DEVICE(0x044e, 0x3001) },

94

{ USB_DEVICE(0x044e, 0x3001) },

92

{ USB_DEVICE(0x044e, 0x3002) },

95

{ USB_DEVICE(0x044e, 0x3002) },

93

96

94

/* Ericsson with non-standard id */

97

/* Ericsson with non-standard id */

95

{ USB_DEVICE(0x0bdb, 0x1002) },

98

{ USB_DEVICE(0x0bdb, 0x1002) },

96

99

97

/* Canyon CN-BTU1 with HID interfaces */

100

/* Canyon CN-BTU1 with HID interfaces */

98

{ USB_DEVICE(0x0c10, 0x0000) },

101

{ USB_DEVICE(0x0c10, 0x0000) },

99

102

100

/* Broadcom BCM20702A0 */

103

/* Broadcom BCM20702A0 */

101

{ USB_DEVICE(0x0b05, 0x17b5) },

104

{ USB_DEVICE(0x0b05, 0x17b5) },

102

{ USB_DEVICE(0x04ca, 0x2003) },

105

{ USB_DEVICE(0x04ca, 0x2003) },

103

{ USB_DEVICE(0x0489, 0xe042) },

106

{ USB_DEVICE(0x0489, 0xe042) },

104

{ USB_DEVICE(0x413c, 0x8197) },

107

{ USB_DEVICE(0x413c, 0x8197) },

105

108

106

/* Foxconn - Hon Hai */

109

/* Foxconn - Hon Hai */

107

{ USB_VENDOR_AND_INTERFACE_INFO(0x0489, 0xff, 0x01, 0x01) },

110

{ USB_VENDOR_AND_INTERFACE_INFO(0x0489, 0xff, 0x01, 0x01) },

108

111

109

/*Broadcom devices with vendor specific id */

112

/*Broadcom devices with vendor specific id */

110

{ USB_VENDOR_AND_INTERFACE_INFO(0x0a5c, 0xff, 0x01, 0x01) },

113

{ USB_VENDOR_AND_INTERFACE_INFO(0x0a5c, 0xff, 0x01, 0x01) },

111

114

112

{ } /* Terminating entry */

115

{ } /* Terminating entry */

113

};

116

};

114

117

115

MODULE_DEVICE_TABLE(usb, btusb_table);

118

MODULE_DEVICE_TABLE(usb, btusb_table);

116

119

117

static struct usb_device_id blacklist_table[] = {

120

static struct usb_device_id blacklist_table[] = {

118

/* CSR BlueCore devices */

121

/* CSR BlueCore devices */

119

{ USB_DEVICE(0x0a12, 0x0001), .driver_info = BTUSB_CSR },

122

{ USB_DEVICE(0x0a12, 0x0001), .driver_info = BTUSB_CSR },

120

123

121

/* Broadcom BCM2033 without firmware */

124

/* Broadcom BCM2033 without firmware */

122

{ USB_DEVICE(0x0a5c, 0x2033), .driver_info = BTUSB_IGNORE },

125

{ USB_DEVICE(0x0a5c, 0x2033), .driver_info = BTUSB_IGNORE },

123

126

124

/* Atheros 3011 with sflash firmware */

127

/* Atheros 3011 with sflash firmware */

125

{ USB_DEVICE(0x0cf3, 0x3002), .driver_info = BTUSB_IGNORE },

128

{ USB_DEVICE(0x0cf3, 0x3002), .driver_info = BTUSB_IGNORE },

126

{ USB_DEVICE(0x0cf3, 0xe019), .driver_info = BTUSB_IGNORE },

129

{ USB_DEVICE(0x0cf3, 0xe019), .driver_info = BTUSB_IGNORE },

127

{ USB_DEVICE(0x13d3, 0x3304), .driver_info = BTUSB_IGNORE },

130

{ USB_DEVICE(0x13d3, 0x3304), .driver_info = BTUSB_IGNORE },

128

{ USB_DEVICE(0x0930, 0x0215), .driver_info = BTUSB_IGNORE },

131

{ USB_DEVICE(0x0930, 0x0215), .driver_info = BTUSB_IGNORE },

129

{ USB_DEVICE(0x0489, 0xe03d), .driver_info = BTUSB_IGNORE },

132

{ USB_DEVICE(0x0489, 0xe03d), .driver_info = BTUSB_IGNORE },

130

{ USB_DEVICE(0x0489, 0xe027), .driver_info = BTUSB_IGNORE },

133

{ USB_DEVICE(0x0489, 0xe027), .driver_info = BTUSB_IGNORE },

131

134

132

/* Atheros AR9285 Malbec with sflash firmware */

135

/* Atheros AR9285 Malbec with sflash firmware */

133

{ USB_DEVICE(0x03f0, 0x311d), .driver_info = BTUSB_IGNORE },

136

{ USB_DEVICE(0x03f0, 0x311d), .driver_info = BTUSB_IGNORE },

134

137

135

/* Atheros 3012 with sflash firmware */

138

/* Atheros 3012 with sflash firmware */

136

{ USB_DEVICE(0x0cf3, 0x0036), .driver_info = BTUSB_ATH3012 },

139

{ USB_DEVICE(0x0cf3, 0x0036), .driver_info = BTUSB_ATH3012 },

137

{ USB_DEVICE(0x0cf3, 0x3004), .driver_info = BTUSB_ATH3012 },

140

{ USB_DEVICE(0x0cf3, 0x3004), .driver_info = BTUSB_ATH3012 },

138

{ USB_DEVICE(0x0cf3, 0x3008), .driver_info = BTUSB_ATH3012 },

141

{ USB_DEVICE(0x0cf3, 0x3008), .driver_info = BTUSB_ATH3012 },

139

{ USB_DEVICE(0x0cf3, 0x311d), .driver_info = BTUSB_ATH3012 },

142

{ USB_DEVICE(0x0cf3, 0x311d), .driver_info = BTUSB_ATH3012 },

140

{ USB_DEVICE(0x0cf3, 0x817a), .driver_info = BTUSB_ATH3012 },

143

{ USB_DEVICE(0x0cf3, 0x817a), .driver_info = BTUSB_ATH3012 },

141

{ USB_DEVICE(0x13d3, 0x3375), .driver_info = BTUSB_ATH3012 },

144

{ USB_DEVICE(0x13d3, 0x3375), .driver_info = BTUSB_ATH3012 },

142

{ USB_DEVICE(0x04ca, 0x3004), .driver_info = BTUSB_ATH3012 },

145

{ USB_DEVICE(0x04ca, 0x3004), .driver_info = BTUSB_ATH3012 },

143

{ USB_DEVICE(0x04ca, 0x3005), .driver_info = BTUSB_ATH3012 },

146

{ USB_DEVICE(0x04ca, 0x3005), .driver_info = BTUSB_ATH3012 },

144

{ USB_DEVICE(0x04ca, 0x3006), .driver_info = BTUSB_ATH3012 },

147

{ USB_DEVICE(0x04ca, 0x3006), .driver_info = BTUSB_ATH3012 },

145

{ USB_DEVICE(0x04ca, 0x3008), .driver_info = BTUSB_ATH3012 },

148

{ USB_DEVICE(0x04ca, 0x3008), .driver_info = BTUSB_ATH3012 },

146

{ USB_DEVICE(0x13d3, 0x3362), .driver_info = BTUSB_ATH3012 },

149

{ USB_DEVICE(0x13d3, 0x3362), .driver_info = BTUSB_ATH3012 },

147

{ USB_DEVICE(0x0cf3, 0xe004), .driver_info = BTUSB_ATH3012 },

150

{ USB_DEVICE(0x0cf3, 0xe004), .driver_info = BTUSB_ATH3012 },

148

{ USB_DEVICE(0x0930, 0x0219), .driver_info = BTUSB_ATH3012 },

151

{ USB_DEVICE(0x0930, 0x0219), .driver_info = BTUSB_ATH3012 },

149

{ USB_DEVICE(0x0489, 0xe057), .driver_info = BTUSB_ATH3012 },

152

{ USB_DEVICE(0x0489, 0xe057), .driver_info = BTUSB_ATH3012 },

150

{ USB_DEVICE(0x13d3, 0x3393), .driver_info = BTUSB_ATH3012 },

153

{ USB_DEVICE(0x13d3, 0x3393), .driver_info = BTUSB_ATH3012 },

151

{ USB_DEVICE(0x0489, 0xe04e), .driver_info = BTUSB_ATH3012 },

154

{ USB_DEVICE(0x0489, 0xe04e), .driver_info = BTUSB_ATH3012 },

152

{ USB_DEVICE(0x0489, 0xe056), .driver_info = BTUSB_ATH3012 },

155

{ USB_DEVICE(0x0489, 0xe056), .driver_info = BTUSB_ATH3012 },

153

{ USB_DEVICE(0x0489, 0xe04d), .driver_info = BTUSB_ATH3012 },

156

{ USB_DEVICE(0x0489, 0xe04d), .driver_info = BTUSB_ATH3012 },

154

157

155

/* Atheros AR5BBU12 with sflash firmware */

158

/* Atheros AR5BBU12 with sflash firmware */

156

{ USB_DEVICE(0x0489, 0xe02c), .driver_info = BTUSB_IGNORE },

159

{ USB_DEVICE(0x0489, 0xe02c), .driver_info = BTUSB_IGNORE },

157

160

158

/* Atheros AR5BBU12 with sflash firmware */

161

/* Atheros AR5BBU12 with sflash firmware */

159

{ USB_DEVICE(0x0489, 0xe03c), .driver_info = BTUSB_ATH3012 },

162

{ USB_DEVICE(0x0489, 0xe03c), .driver_info = BTUSB_ATH3012 },

160

{ USB_DEVICE(0x0489, 0xe036), .driver_info = BTUSB_ATH3012 },

163

{ USB_DEVICE(0x0489, 0xe036), .driver_info = BTUSB_ATH3012 },

161

164

162

/* Broadcom BCM2035 */

165

/* Broadcom BCM2035 */

163

{ USB_DEVICE(0x0a5c, 0x2035), .driver_info = BTUSB_WRONG_SCO_MTU },

166

{ USB_DEVICE(0x0a5c, 0x2035), .driver_info = BTUSB_WRONG_SCO_MTU },

164

{ USB_DEVICE(0x0a5c, 0x200a), .driver_info = BTUSB_WRONG_SCO_MTU },

167

{ USB_DEVICE(0x0a5c, 0x200a), .driver_info = BTUSB_WRONG_SCO_MTU },

165

{ USB_DEVICE(0x0a5c, 0x2009), .driver_info = BTUSB_BCM92035 },

168

{ USB_DEVICE(0x0a5c, 0x2009), .driver_info = BTUSB_BCM92035 },

166

169

167

/* Broadcom BCM2045 */

170

/* Broadcom BCM2045 */

168

{ USB_DEVICE(0x0a5c, 0x2039), .driver_info = BTUSB_WRONG_SCO_MTU },

171

{ USB_DEVICE(0x0a5c, 0x2039), .driver_info = BTUSB_WRONG_SCO_MTU },

169

{ USB_DEVICE(0x0a5c, 0x2101), .driver_info = BTUSB_WRONG_SCO_MTU },

172

{ USB_DEVICE(0x0a5c, 0x2101), .driver_info = BTUSB_WRONG_SCO_MTU },

170

173

171

/* IBM/Lenovo ThinkPad with Broadcom chip */

174

/* IBM/Lenovo ThinkPad with Broadcom chip */

172

{ USB_DEVICE(0x0a5c, 0x201e), .driver_info = BTUSB_WRONG_SCO_MTU },

175

{ USB_DEVICE(0x0a5c, 0x201e), .driver_info = BTUSB_WRONG_SCO_MTU },

173

{ USB_DEVICE(0x0a5c, 0x2110), .driver_info = BTUSB_WRONG_SCO_MTU },

176

{ USB_DEVICE(0x0a5c, 0x2110), .driver_info = BTUSB_WRONG_SCO_MTU },

174

177

175

/* HP laptop with Broadcom chip */

178

/* HP laptop with Broadcom chip */

176

{ USB_DEVICE(0x03f0, 0x171d), .driver_info = BTUSB_WRONG_SCO_MTU },

179

{ USB_DEVICE(0x03f0, 0x171d), .driver_info = BTUSB_WRONG_SCO_MTU },

177

180

178

/* Dell laptop with Broadcom chip */

181

/* Dell laptop with Broadcom chip */

179

{ USB_DEVICE(0x413c, 0x8126), .driver_info = BTUSB_WRONG_SCO_MTU },

182

{ USB_DEVICE(0x413c, 0x8126), .driver_info = BTUSB_WRONG_SCO_MTU },

180

183

181

/* Dell Wireless 370 and 410 devices */

184

/* Dell Wireless 370 and 410 devices */

182

{ USB_DEVICE(0x413c, 0x8152), .driver_info = BTUSB_WRONG_SCO_MTU },

185

{ USB_DEVICE(0x413c, 0x8152), .driver_info = BTUSB_WRONG_SCO_MTU },

183

{ USB_DEVICE(0x413c, 0x8156), .driver_info = BTUSB_WRONG_SCO_MTU },

186

{ USB_DEVICE(0x413c, 0x8156), .driver_info = BTUSB_WRONG_SCO_MTU },

184

187

185

/* Belkin F8T012 and F8T013 devices */

188

/* Belkin F8T012 and F8T013 devices */

186

{ USB_DEVICE(0x050d, 0x0012), .driver_info = BTUSB_WRONG_SCO_MTU },

189

{ USB_DEVICE(0x050d, 0x0012), .driver_info = BTUSB_WRONG_SCO_MTU },

187

{ USB_DEVICE(0x050d, 0x0013), .driver_info = BTUSB_WRONG_SCO_MTU },

190

{ USB_DEVICE(0x050d, 0x0013), .driver_info = BTUSB_WRONG_SCO_MTU },

188

191

189

/* Asus WL-BTD202 device */

192

/* Asus WL-BTD202 device */

190

{ USB_DEVICE(0x0b05, 0x1715), .driver_info = BTUSB_WRONG_SCO_MTU },

193

{ USB_DEVICE(0x0b05, 0x1715), .driver_info = BTUSB_WRONG_SCO_MTU },

191

194

192

/* Kensington Bluetooth USB adapter */

195

/* Kensington Bluetooth USB adapter */

193

{ USB_DEVICE(0x047d, 0x105e), .driver_info = BTUSB_WRONG_SCO_MTU },

196

{ USB_DEVICE(0x047d, 0x105e), .driver_info = BTUSB_WRONG_SCO_MTU },

194

197

195

/* RTX Telecom based adapters with buggy SCO support */

198

/* RTX Telecom based adapters with buggy SCO support */

196

{ USB_DEVICE(0x0400, 0x0807), .driver_info = BTUSB_BROKEN_ISOC },

199

{ USB_DEVICE(0x0400, 0x0807), .driver_info = BTUSB_BROKEN_ISOC },

197

{ USB_DEVICE(0x0400, 0x080a), .driver_info = BTUSB_BROKEN_ISOC },

200

{ USB_DEVICE(0x0400, 0x080a), .driver_info = BTUSB_BROKEN_ISOC },

198

201

199

/* CONWISE Technology based adapters with buggy SCO support */

202

/* CONWISE Technology based adapters with buggy SCO support */

200

{ USB_DEVICE(0x0e5e, 0x6622), .driver_info = BTUSB_BROKEN_ISOC },

203

{ USB_DEVICE(0x0e5e, 0x6622), .driver_info = BTUSB_BROKEN_ISOC },

201

204

202

/* Digianswer devices */

205

/* Digianswer devices */

203

{ USB_DEVICE(0x08fd, 0x0001), .driver_info = BTUSB_DIGIANSWER },

206

{ USB_DEVICE(0x08fd, 0x0001), .driver_info = BTUSB_DIGIANSWER },

204

{ USB_DEVICE(0x08fd, 0x0002), .driver_info = BTUSB_IGNORE },

207

{ USB_DEVICE(0x08fd, 0x0002), .driver_info = BTUSB_IGNORE },

205

208

206

/* CSR BlueCore Bluetooth Sniffer */

209

/* CSR BlueCore Bluetooth Sniffer */

207

{ USB_DEVICE(0x0a12, 0x0002), .driver_info = BTUSB_SNIFFER },

210

{ USB_DEVICE(0x0a12, 0x0002), .driver_info = BTUSB_SNIFFER },

208

211

209

/* Frontline ComProbe Bluetooth Sniffer */

212

/* Frontline ComProbe Bluetooth Sniffer */

210

{ USB_DEVICE(0x16d3, 0x0002), .driver_info = BTUSB_SNIFFER },

213

{ USB_DEVICE(0x16d3, 0x0002), .driver_info = BTUSB_SNIFFER },

211

214

212

/* Intel Bluetooth device */

215

/* Intel Bluetooth device */

213

{ USB_DEVICE(0x8087, 0x07dc), .driver_info = BTUSB_INTEL },

216

{ USB_DEVICE(0x8087, 0x07dc), .driver_info = BTUSB_INTEL },

214

217

215

{ } /* Terminating entry */

218

{ } /* Terminating entry */

216

};

219

};

217

220

218

#define BTUSB_MAX_ISOC_FRAMES 10

221

#define BTUSB_MAX_ISOC_FRAMES 10

219

222

220

#define BTUSB_INTR_RUNNING 0

223

#define BTUSB_INTR_RUNNING 0

221

#define BTUSB_BULK_RUNNING 1

224

#define BTUSB_BULK_RUNNING 1

222

#define BTUSB_ISOC_RUNNING 2

225

#define BTUSB_ISOC_RUNNING 2

223

#define BTUSB_SUSPENDING 3

226

#define BTUSB_SUSPENDING 3

224

#define BTUSB_DID_ISO_RESUME 4

227

#define BTUSB_DID_ISO_RESUME 4

225

228

226

struct btusb_data {

229

struct btusb_data {

227

struct hci_dev *hdev;

230

struct hci_dev *hdev;

228

struct usb_device *udev;

231

struct usb_device *udev;

229

struct usb_interface *intf;

232

struct usb_interface *intf;

230

struct usb_interface *isoc;

233

struct usb_interface *isoc;

231

234

232

spinlock_t lock;

235

spinlock_t lock;

233

236

234

unsigned long flags;

237

unsigned long flags;

235

238

236

struct work_struct work;

239

struct work_struct work;

237

struct work_struct waker;

240

struct work_struct waker;

238

241

239

struct usb_anchor tx_anchor;

242

struct usb_anchor tx_anchor;

240

struct usb_anchor intr_anchor;

243

struct usb_anchor intr_anchor;

241

struct usb_anchor bulk_anchor;

244

struct usb_anchor bulk_anchor;

242

struct usb_anchor isoc_anchor;

245

struct usb_anchor isoc_anchor;

243

struct usb_anchor deferred;

246

struct usb_anchor deferred;

244

int tx_in_flight;

247

int tx_in_flight;

245

spinlock_t txlock;

248

spinlock_t txlock;

246

249

247

struct usb_endpoint_descriptor *intr_ep;

250

struct usb_endpoint_descriptor *intr_ep;

248

struct usb_endpoint_descriptor *bulk_tx_ep;

251

struct usb_endpoint_descriptor *bulk_tx_ep;

249

struct usb_endpoint_descriptor *bulk_rx_ep;

252

struct usb_endpoint_descriptor *bulk_rx_ep;

250

struct usb_endpoint_descriptor *isoc_tx_ep;

253

struct usb_endpoint_descriptor *isoc_tx_ep;

251

struct usb_endpoint_descriptor *isoc_rx_ep;

254

struct usb_endpoint_descriptor *isoc_rx_ep;

252

255

253

__u8 cmdreq_type;

256

__u8 cmdreq_type;

254

257

255

unsigned int sco_num;

258

unsigned int sco_num;

256

int isoc_altsetting;

259

int isoc_altsetting;

257

int suspend_count;

260

int suspend_count;

258

};

261

};

259

262

260

static int inc_tx(struct btusb_data *data)

263

static int inc_tx(struct btusb_data *data)

261

{

264

{

262

unsigned long flags;

265

unsigned long flags;

263

int rv;

266

int rv;

264

267

265

spin_lock_irqsave(&data->txlock, flags);

268

spin_lock_irqsave(&data->txlock, flags);

266

rv = test_bit(BTUSB_SUSPENDING, &data->flags);

269

rv = test_bit(BTUSB_SUSPENDING, &data->flags);

267

if (!rv)

270

if (!rv)

268

data->tx_in_flight++;

271

data->tx_in_flight++;

269

spin_unlock_irqrestore(&data->txlock, flags);

272

spin_unlock_irqrestore(&data->txlock, flags);

270

273

271

return rv;

274

return rv;

272

}

275

}

273

276

274

static void btusb_intr_complete(struct urb *urb)

277

static void btusb_intr_complete(struct urb *urb)

275

{

278

{

276

struct hci_dev *hdev = urb->context;

279

struct hci_dev *hdev = urb->context;

277

struct btusb_data *data = hci_get_drvdata(hdev);

280

struct btusb_data *data = hci_get_drvdata(hdev);

278

int err;

281

int err;

279

282

280

BT_DBG("%s urb %p status %d count %d", hdev->name,

283

BT_DBG("%s urb %p status %d count %d", hdev->name,

281

urb, urb->status, urb->actual_length);

284

urb, urb->status, urb->actual_length);

282

285

283

if (!test_bit(HCI_RUNNING, &hdev->flags))

286

if (!test_bit(HCI_RUNNING, &hdev->flags))

284

return;

287

return;

285

288

286

if (urb->status == 0) {

289

if (urb->status == 0) {

287

hdev->stat.byte_rx += urb->actual_length;

290

hdev->stat.byte_rx += urb->actual_length;

288

291

289

if (hci_recv_fragment(hdev, HCI_EVENT_PKT,

292

if (hci_recv_fragment(hdev, HCI_EVENT_PKT,

290

urb->transfer_buffer,

293

urb->transfer_buffer,

291

urb->actual_length) < 0) {

294

urb->actual_length) < 0) {

292

BT_ERR("%s corrupted event packet", hdev->name);

295

BT_ERR("%s corrupted event packet", hdev->name);

293

hdev->stat.err_rx++;

296

hdev->stat.err_rx++;

294

}

297

}

295

}

298

}

296

299

297

if (!test_bit(BTUSB_INTR_RUNNING, &data->flags))

300

if (!test_bit(BTUSB_INTR_RUNNING, &data->flags))

298

return;

301

return;

299

302

300

usb_mark_last_busy(data->udev);

303

usb_mark_last_busy(data->udev);

301

usb_anchor_urb(urb, &data->intr_anchor);

304

usb_anchor_urb(urb, &data->intr_anchor);

302

305

303

err = usb_submit_urb(urb, GFP_ATOMIC);

306

err = usb_submit_urb(urb, GFP_ATOMIC);

304

if (err < 0) {

307

if (err < 0) {

305

/* -EPERM: urb is being killed;

308

/* -EPERM: urb is being killed;

306

* -ENODEV: device got disconnected */

309

* -ENODEV: device got disconnected */

307

if (err != -EPERM && err != -ENODEV)

310

if (err != -EPERM && err != -ENODEV)

308

BT_ERR("%s urb %p failed to resubmit (%d)",

311

BT_ERR("%s urb %p failed to resubmit (%d)",

309

hdev->name, urb, -err);

312

hdev->name, urb, -err);

310

usb_unanchor_urb(urb);

313

usb_unanchor_urb(urb);

311

}

314

}

312

}

315

}

313

316

314

static int btusb_submit_intr_urb(struct hci_dev *hdev, gfp_t mem_flags)

317

static int btusb_submit_intr_urb(struct hci_dev *hdev, gfp_t mem_flags)

315

{

318

{

316

struct btusb_data *data = hci_get_drvdata(hdev);

319

struct btusb_data *data = hci_get_drvdata(hdev);

317

struct urb *urb;

320

struct urb *urb;

318

unsigned char *buf;

321

unsigned char *buf;

319

unsigned int pipe;

322

unsigned int pipe;

320

int err, size;

323

int err, size;

321

324

322

BT_DBG("%s", hdev->name);

325

BT_DBG("%s", hdev->name);

323

326

324

if (!data->intr_ep)

327

if (!data->intr_ep)

325

return -ENODEV;

328

return -ENODEV;

326

329

327

urb = usb_alloc_urb(0, mem_flags);

330

urb = usb_alloc_urb(0, mem_flags);

328

if (!urb)

331

if (!urb)

329

return -ENOMEM;

332

return -ENOMEM;

330

333

331

size = le16_to_cpu(data->intr_ep->wMaxPacketSize);

334

size = le16_to_cpu(data->intr_ep->wMaxPacketSize);

332

335

333

buf = kmalloc(size, mem_flags);

336

buf = kmalloc(size, mem_flags);

334

if (!buf) {

337

if (!buf) {

335

usb_free_urb(urb);

338

usb_free_urb(urb);

336

return -ENOMEM;

339

return -ENOMEM;

337

}

340

}

338

341

339

pipe = usb_rcvintpipe(data->udev, data->intr_ep->bEndpointAddress);

342

pipe = usb_rcvintpipe(data->udev, data->intr_ep->bEndpointAddress);

340

343

341

usb_fill_int_urb(urb, data->udev, pipe, buf, size,

344

usb_fill_int_urb(urb, data->udev, pipe, buf, size,

342

btusb_intr_complete, hdev,

345

btusb_intr_complete, hdev,

343

data->intr_ep->bInterval);

346

data->intr_ep->bInterval);

344

347

345

urb->transfer_flags |= URB_FREE_BUFFER;

348

urb->transfer_flags |= URB_FREE_BUFFER;

346

349

347

usb_anchor_urb(urb, &data->intr_anchor);

350

usb_anchor_urb(urb, &data->intr_anchor);

348

351

349

err = usb_submit_urb(urb, mem_flags);

352

err = usb_submit_urb(urb, mem_flags);

350

if (err < 0) {

353

if (err < 0) {

351

if (err != -EPERM && err != -ENODEV)

354

if (err != -EPERM && err != -ENODEV)

352

BT_ERR("%s urb %p submission failed (%d)",

355

BT_ERR("%s urb %p submission failed (%d)",

353

hdev->name, urb, -err);

356

hdev->name, urb, -err);

354

usb_unanchor_urb(urb);

357

usb_unanchor_urb(urb);

355

}

358

}

356

359

357

usb_free_urb(urb);

360

usb_free_urb(urb);

358

361

359

return err;

362

return err;

360

}

363

}

361

364

362

static void btusb_bulk_complete(struct urb *urb)

365

static void btusb_bulk_complete(struct urb *urb)

363

{

366

{

364

struct hci_dev *hdev = urb->context;

367

struct hci_dev *hdev = urb->context;

365

struct btusb_data *data = hci_get_drvdata(hdev);

368

struct btusb_data *data = hci_get_drvdata(hdev);

366

int err;

369

int err;

367

370

368

BT_DBG("%s urb %p status %d count %d", hdev->name,

371

BT_DBG("%s urb %p status %d count %d", hdev->name,

369

urb, urb->status, urb->actual_length);

372

urb, urb->status, urb->actual_length);

370

373

371

if (!test_bit(HCI_RUNNING, &hdev->flags))

374

if (!test_bit(HCI_RUNNING, &hdev->flags))

372

return;

375

return;

373

376

374

if (urb->status == 0) {

377

if (urb->status == 0) {

375

hdev->stat.byte_rx += urb->actual_length;

378

hdev->stat.byte_rx += urb->actual_length;

376

379

377

if (hci_recv_fragment(hdev, HCI_ACLDATA_PKT,

380

if (hci_recv_fragment(hdev, HCI_ACLDATA_PKT,

378

urb->transfer_buffer,

381

urb->transfer_buffer,

379

urb->actual_length) < 0) {

382

urb->actual_length) < 0) {

380

BT_ERR("%s corrupted ACL packet", hdev->name);

383

BT_ERR("%s corrupted ACL packet", hdev->name);

381

hdev->stat.err_rx++;

384

hdev->stat.err_rx++;

382

}

385

}

383

}

386

}

384

387

385

if (!test_bit(BTUSB_BULK_RUNNING, &data->flags))

388

if (!test_bit(BTUSB_BULK_RUNNING, &data->flags))

386

return;

389

return;

387

390

388

usb_anchor_urb(urb, &data->bulk_anchor);

391

usb_anchor_urb(urb, &data->bulk_anchor);

389

usb_mark_last_busy(data->udev);

392

usb_mark_last_busy(data->udev);

390

393

391

err = usb_submit_urb(urb, GFP_ATOMIC);

394

err = usb_submit_urb(urb, GFP_ATOMIC);

392

if (err < 0) {

395

if (err < 0) {

393

/* -EPERM: urb is being killed;

396

/* -EPERM: urb is being killed;

394

* -ENODEV: device got disconnected */

397

* -ENODEV: device got disconnected */

395

if (err != -EPERM && err != -ENODEV)

398

if (err != -EPERM && err != -ENODEV)

396

BT_ERR("%s urb %p failed to resubmit (%d)",

399

BT_ERR("%s urb %p failed to resubmit (%d)",

397

hdev->name, urb, -err);

400

hdev->name, urb, -err);

398

usb_unanchor_urb(urb);

401

usb_unanchor_urb(urb);

399

}

402

}

400

}

403

}

401

404

402

static int btusb_submit_bulk_urb(struct hci_dev *hdev, gfp_t mem_flags)

405

static int btusb_submit_bulk_urb(struct hci_dev *hdev, gfp_t mem_flags)

403

{

406

{

404

struct btusb_data *data = hci_get_drvdata(hdev);

407

struct btusb_data *data = hci_get_drvdata(hdev);

405

struct urb *urb;

408

struct urb *urb;

406

unsigned char *buf;

409

unsigned char *buf;

407

unsigned int pipe;

410

unsigned int pipe;

408

int err, size = HCI_MAX_FRAME_SIZE;

411

int err, size = HCI_MAX_FRAME_SIZE;

409

412

410

BT_DBG("%s", hdev->name);

413

BT_DBG("%s", hdev->name);

411

414

412

if (!data->bulk_rx_ep)

415

if (!data->bulk_rx_ep)

413

return -ENODEV;

416

return -ENODEV;

414

417

415

urb = usb_alloc_urb(0, mem_flags);

418

urb = usb_alloc_urb(0, mem_flags);

416

if (!urb)

419

if (!urb)

417

return -ENOMEM;

420

return -ENOMEM;

418

421

419

buf = kmalloc(size, mem_flags);

422

buf = kmalloc(size, mem_flags);

420

if (!buf) {

423

if (!buf) {

421

usb_free_urb(urb);

424

usb_free_urb(urb);

422

return -ENOMEM;

425

return -ENOMEM;

423

}

426

}

424

427

425

pipe = usb_rcvbulkpipe(data->udev, data->bulk_rx_ep->bEndpointAddress);

428

pipe = usb_rcvbulkpipe(data->udev, data->bulk_rx_ep->bEndpointAddress);

426

429

427

usb_fill_bulk_urb(urb, data->udev, pipe,

430

usb_fill_bulk_urb(urb, data->udev, pipe,

428

buf, size, btusb_bulk_complete, hdev);

431

buf, size, btusb_bulk_complete, hdev);

429

432

430

urb->transfer_flags |= URB_FREE_BUFFER;

433

urb->transfer_flags |= URB_FREE_BUFFER;

431

434

432

usb_mark_last_busy(data->udev);

435

usb_mark_last_busy(data->udev);

433

usb_anchor_urb(urb, &data->bulk_anchor);

436

usb_anchor_urb(urb, &data->bulk_anchor);

434

437

435

err = usb_submit_urb(urb, mem_flags);

438

err = usb_submit_urb(urb, mem_flags);

436

if (err < 0) {

439

if (err < 0) {

437

if (err != -EPERM && err != -ENODEV)

440

if (err != -EPERM && err != -ENODEV)

438

BT_ERR("%s urb %p submission failed (%d)",

441

BT_ERR("%s urb %p submission failed (%d)",

439

hdev->name, urb, -err);

442

hdev->name, urb, -err);

440

usb_unanchor_urb(urb);

443

usb_unanchor_urb(urb);

441

}

444

}

442

445

443

usb_free_urb(urb);

446

usb_free_urb(urb);

444

447

445

return err;

448

return err;

446

}

449

}

447

450

448

static void btusb_isoc_complete(struct urb *urb)

451

static void btusb_isoc_complete(struct urb *urb)

449

{

452

{

450

struct hci_dev *hdev = urb->context;

453

struct hci_dev *hdev = urb->context;

451

struct btusb_data *data = hci_get_drvdata(hdev);

454

struct btusb_data *data = hci_get_drvdata(hdev);

452

int i, err;

455

int i, err;

453

456

454

BT_DBG("%s urb %p status %d count %d", hdev->name,

457

BT_DBG("%s urb %p status %d count %d", hdev->name,

455

urb, urb->status, urb->actual_length);

458

urb, urb->status, urb->actual_length);

456

459

457

if (!test_bit(HCI_RUNNING, &hdev->flags))

460

if (!test_bit(HCI_RUNNING, &hdev->flags))

458

return;

461

return;

459

462

460

if (urb->status == 0) {

463

if (urb->status == 0) {

461

for (i = 0; i < urb->number_of_packets; i++) {

464

for (i = 0; i < urb->number_of_packets; i++) {

462

unsigned int offset = urb->iso_frame_desc[i].offset;

465

unsigned int offset = urb->iso_frame_desc[i].offset;

463

unsigned int length = urb->iso_frame_desc[i].actual_length;

466

unsigned int length = urb->iso_frame_desc[i].actual_length;

464

467

465

if (urb->iso_frame_desc[i].status)

468

if (urb->iso_frame_desc[i].status)

466

continue;

469

continue;

467

470

468

hdev->stat.byte_rx += length;

471

hdev->stat.byte_rx += length;

469

472

470

if (hci_recv_fragment(hdev, HCI_SCODATA_PKT,

473

if (hci_recv_fragment(hdev, HCI_SCODATA_PKT,

471

urb->transfer_buffer + offset,

474

urb->transfer_buffer + offset,

472

length) < 0) {

475

length) < 0) {

473

BT_ERR("%s corrupted SCO packet", hdev->name);

476

BT_ERR("%s corrupted SCO packet", hdev->name);

474

hdev->stat.err_rx++;

477

hdev->stat.err_rx++;

475

}

478

}

476

}

479

}

477

}

480

}

478

481

479

if (!test_bit(BTUSB_ISOC_RUNNING, &data->flags))

482

if (!test_bit(BTUSB_ISOC_RUNNING, &data->flags))

480

return;

483

return;

481

484

482

usb_anchor_urb(urb, &data->isoc_anchor);

485

usb_anchor_urb(urb, &data->isoc_anchor);

483

486

484

err = usb_submit_urb(urb, GFP_ATOMIC);

487

err = usb_submit_urb(urb, GFP_ATOMIC);

485

if (err < 0) {

488

if (err < 0) {

486

/* -EPERM: urb is being killed;

489

/* -EPERM: urb is being killed;

487

* -ENODEV: device got disconnected */

490

* -ENODEV: device got disconnected */

488

if (err != -EPERM && err != -ENODEV)

491

if (err != -EPERM && err != -ENODEV)

489

BT_ERR("%s urb %p failed to resubmit (%d)",

492

BT_ERR("%s urb %p failed to resubmit (%d)",

490

hdev->name, urb, -err);

493

hdev->name, urb, -err);

491

usb_unanchor_urb(urb);

494

usb_unanchor_urb(urb);

492

}

495

}

493

}

496

}

494

497

495

static inline void __fill_isoc_descriptor(struct urb *urb, int len, int mtu)

498

static inline void __fill_isoc_descriptor(struct urb *urb, int len, int mtu)

496

{

499

{

497

int i, offset = 0;

500

int i, offset = 0;

498

501

499

BT_DBG("len %d mtu %d", len, mtu);

502

BT_DBG("len %d mtu %d", len, mtu);

500

503

501

for (i = 0; i < BTUSB_MAX_ISOC_FRAMES && len >= mtu;

504

for (i = 0; i < BTUSB_MAX_ISOC_FRAMES && len >= mtu;

502

i++, offset += mtu, len -= mtu) {

505

i++, offset += mtu, len -= mtu) {

503

urb->iso_frame_desc[i].offset = offset;

506

urb->iso_frame_desc[i].offset = offset;

504

urb->iso_frame_desc[i].length = mtu;

507

urb->iso_frame_desc[i].length = mtu;

505

}

508

}

506

509

507

if (len && i < BTUSB_MAX_ISOC_FRAMES) {

510

if (len && i < BTUSB_MAX_ISOC_FRAMES) {

508

urb->iso_frame_desc[i].offset = offset;

511

urb->iso_frame_desc[i].offset = offset;

509

urb->iso_frame_desc[i].length = len;

512

urb->iso_frame_desc[i].length = len;

510

i++;

513

i++;

511

}

514

}

512

515

513

urb->number_of_packets = i;

516

urb->number_of_packets = i;

514

}

517

}

515

518

516

static int btusb_submit_isoc_urb(struct hci_dev *hdev, gfp_t mem_flags)

519

static int btusb_submit_isoc_urb(struct hci_dev *hdev, gfp_t mem_flags)

517

{

520

{

518

struct btusb_data *data = hci_get_drvdata(hdev);

521

struct btusb_data *data = hci_get_drvdata(hdev);

519

struct urb *urb;

522

struct urb *urb;

520

unsigned char *buf;

523

unsigned char *buf;

521

unsigned int pipe;

524

unsigned int pipe;

522

int err, size;

525

int err, size;

523

526

524

BT_DBG("%s", hdev->name);

527

BT_DBG("%s", hdev->name);

525

528

526

if (!data->isoc_rx_ep)

529

if (!data->isoc_rx_ep)

527

return -ENODEV;

530

return -ENODEV;

528

531

529

urb = usb_alloc_urb(BTUSB_MAX_ISOC_FRAMES, mem_flags);

532

urb = usb_alloc_urb(BTUSB_MAX_ISOC_FRAMES, mem_flags);

530

if (!urb)

533

if (!urb)

531

return -ENOMEM;

534

return -ENOMEM;

532

535

533

size = le16_to_cpu(data->isoc_rx_ep->wMaxPacketSize) *

536

size = le16_to_cpu(data->isoc_rx_ep->wMaxPacketSize) *

534

BTUSB_MAX_ISOC_FRAMES;

537

BTUSB_MAX_ISOC_FRAMES;

535

538

536

buf = kmalloc(size, mem_flags);

539

buf = kmalloc(size, mem_flags);

537

if (!buf) {

540

if (!buf) {

538

usb_free_urb(urb);

541

usb_free_urb(urb);

539

return -ENOMEM;

542

return -ENOMEM;

540

}

543

}

541

544

542

pipe = usb_rcvisocpipe(data->udev, data->isoc_rx_ep->bEndpointAddress);

545

pipe = usb_rcvisocpipe(data->udev, data->isoc_rx_ep->bEndpointAddress);

543

546

544

usb_fill_int_urb(urb, data->udev, pipe, buf, size, btusb_isoc_complete,

547

usb_fill_int_urb(urb, data->udev, pipe, buf, size, btusb_isoc_complete,

545

hdev, data->isoc_rx_ep->bInterval);

548

hdev, data->isoc_rx_ep->bInterval);

546

549

547

urb->transfer_flags = URB_FREE_BUFFER | URB_ISO_ASAP;

550

urb->transfer_flags = URB_FREE_BUFFER | URB_ISO_ASAP;

548

551

549

__fill_isoc_descriptor(urb, size,

552

__fill_isoc_descriptor(urb, size,

550

le16_to_cpu(data->isoc_rx_ep->wMaxPacketSize));

553

le16_to_cpu(data->isoc_rx_ep->wMaxPacketSize));

551

554

552

usb_anchor_urb(urb, &data->isoc_anchor);

555

usb_anchor_urb(urb, &data->isoc_anchor);

553

556

554

err = usb_submit_urb(urb, mem_flags);

557

err = usb_submit_urb(urb, mem_flags);

555

if (err < 0) {

558

if (err < 0) {

556

if (err != -EPERM && err != -ENODEV)

559

if (err != -EPERM && err != -ENODEV)

557

BT_ERR("%s urb %p submission failed (%d)",

560

BT_ERR("%s urb %p submission failed (%d)",

558

hdev->name, urb, -err);

561

hdev->name, urb, -err);

559

usb_unanchor_urb(urb);

562

usb_unanchor_urb(urb);

560

}

563

}

561

564

562

usb_free_urb(urb);

565

usb_free_urb(urb);

563

566

564

return err;

567

return err;

565

}

568

}

566

569

567

static void btusb_tx_complete(struct urb *urb)

570

static void btusb_tx_complete(struct urb *urb)

568

{

571

{

569

struct sk_buff *skb = urb->context;

572

struct sk_buff *skb = urb->context;

570

struct hci_dev *hdev = (struct hci_dev *) skb->dev;

573

struct hci_dev *hdev = (struct hci_dev *) skb->dev;

571

struct btusb_data *data = hci_get_drvdata(hdev);

574

struct btusb_data *data = hci_get_drvdata(hdev);

572

575

573

BT_DBG("%s urb %p status %d count %d", hdev->name,

576

BT_DBG("%s urb %p status %d count %d", hdev->name,

574

urb, urb->status, urb->actual_length);

577

urb, urb->status, urb->actual_length);

575

578

576

if (!test_bit(HCI_RUNNING, &hdev->flags))

579

if (!test_bit(HCI_RUNNING, &hdev->flags))

577

goto done;

580

goto done;

578

581

579

if (!urb->status)

582

if (!urb->status)

580

hdev->stat.byte_tx += urb->transfer_buffer_length;

583

hdev->stat.byte_tx += urb->transfer_buffer_length;

581

else

584

else

582

hdev->stat.err_tx++;

585

hdev->stat.err_tx++;

583

586

584

done:

587

done:

585

spin_lock(&data->txlock);

588

spin_lock(&data->txlock);

586

data->tx_in_flight--;

589

data->tx_in_flight--;

587

spin_unlock(&data->txlock);

590

spin_unlock(&data->txlock);

588

591

589

kfree(urb->setup_packet);

592

kfree(urb->setup_packet);

590

593

591

kfree_skb(skb);

594

kfree_skb(skb);

592

}

595

}

593

596

594

static void btusb_isoc_tx_complete(struct urb *urb)

597

static void btusb_isoc_tx_complete(struct urb *urb)

595

{

598

{

596

struct sk_buff *skb = urb->context;

599

struct sk_buff *skb = urb->context;

597

struct hci_dev *hdev = (struct hci_dev *) skb->dev;

600

struct hci_dev *hdev = (struct hci_dev *) skb->dev;

598

601

599

BT_DBG("%s urb %p status %d count %d", hdev->name,

602

BT_DBG("%s urb %p status %d count %d", hdev->name,

600

urb, urb->status, urb->actual_length);

603

urb, urb->status, urb->actual_length);

601

604

602

if (!test_bit(HCI_RUNNING, &hdev->flags))

605

if (!test_bit(HCI_RUNNING, &hdev->flags))

603

goto done;

606

goto done;

604

607

605

if (!urb->status)

608

if (!urb->status)

606

hdev->stat.byte_tx += urb->transfer_buffer_length;

609

hdev->stat.byte_tx += urb->transfer_buffer_length;

607

else

610

else

608

hdev->stat.err_tx++;

611

hdev->stat.err_tx++;

609

612

610

done:

613

done:

611

kfree(urb->setup_packet);

614

kfree(urb->setup_packet);

612

615

613

kfree_skb(skb);

616

kfree_skb(skb);

614

}

617

}

615

618

616

static int btusb_open(struct hci_dev *hdev)

619

static int btusb_open(struct hci_dev *hdev)

617

{

620

{

618

struct btusb_data *data = hci_get_drvdata(hdev);

621

struct btusb_data *data = hci_get_drvdata(hdev);

619

int err;

622

int err;

620

623

621

BT_DBG("%s", hdev->name);

624

BT_DBG("%s", hdev->name);

622

625

623

err = usb_autopm_get_interface(data->intf);

626

err = usb_autopm_get_interface(data->intf);

624

if (err < 0)

627

if (err < 0)

625

return err;

628

return err;

626

629

627

data->intf->needs_remote_wakeup = 1;

630

data->intf->needs_remote_wakeup = 1;

628

631

629

if (test_and_set_bit(HCI_RUNNING, &hdev->flags))

632

if (test_and_set_bit(HCI_RUNNING, &hdev->flags))

630

goto done;

633

goto done;

631

634

632

if (test_and_set_bit(BTUSB_INTR_RUNNING, &data->flags))

635

if (test_and_set_bit(BTUSB_INTR_RUNNING, &data->flags))

633

goto done;

636

goto done;

634

637

635

err = btusb_submit_intr_urb(hdev, GFP_KERNEL);

638

err = btusb_submit_intr_urb(hdev, GFP_KERNEL);

636

if (err < 0)

639

if (err < 0)

637

goto failed;

640

goto failed;

638

641

639

err = btusb_submit_bulk_urb(hdev, GFP_KERNEL);

642

err = btusb_submit_bulk_urb(hdev, GFP_KERNEL);

640

if (err < 0) {

643

if (err < 0) {

641

usb_kill_anchored_urbs(&data->intr_anchor);

644

usb_kill_anchored_urbs(&data->intr_anchor);

642

goto failed;

645

goto failed;

643

}

646

}

644

647

645

set_bit(BTUSB_BULK_RUNNING, &data->flags);

648

set_bit(BTUSB_BULK_RUNNING, &data->flags);

646

btusb_submit_bulk_urb(hdev, GFP_KERNEL);

649

btusb_submit_bulk_urb(hdev, GFP_KERNEL);

647

650

648

done:

651

done:

649

usb_autopm_put_interface(data->intf);

652

usb_autopm_put_interface(data->intf);

650

return 0;

653

return 0;

651

654

652

failed:

655

failed:

653

clear_bit(BTUSB_INTR_RUNNING, &data->flags);

656

clear_bit(BTUSB_INTR_RUNNING, &data->flags);

654

clear_bit(HCI_RUNNING, &hdev->flags);

657

clear_bit(HCI_RUNNING, &hdev->flags);

655

usb_autopm_put_interface(data->intf);

658

usb_autopm_put_interface(data->intf);

656

return err;

659

return err;

657

}

660

}

658

661

659

static void btusb_stop_traffic(struct btusb_data *data)

662

static void btusb_stop_traffic(struct btusb_data *data)

660

{

663

{

661

usb_kill_anchored_urbs(&data->intr_anchor);

664

usb_kill_anchored_urbs(&data->intr_anchor);

662

usb_kill_anchored_urbs(&data->bulk_anchor);

665

usb_kill_anchored_urbs(&data->bulk_anchor);

663

usb_kill_anchored_urbs(&data->isoc_anchor);

666

usb_kill_anchored_urbs(&data->isoc_anchor);

664

}

667

}

665

668

666

static int btusb_close(struct hci_dev *hdev)

669

static int btusb_close(struct hci_dev *hdev)

667

{

670

{

668

struct btusb_data *data = hci_get_drvdata(hdev);

671

struct btusb_data *data = hci_get_drvdata(hdev);

669

int err;

672

int err;

670

673

671

BT_DBG("%s", hdev->name);

674

BT_DBG("%s", hdev->name);

672

675

673

if (!test_and_clear_bit(HCI_RUNNING, &hdev->flags))

676

if (!test_and_clear_bit(HCI_RUNNING, &hdev->flags))

674

return 0;

677

return 0;

675

678

676

cancel_work_sync(&data->work);

679

cancel_work_sync(&data->work);

677

cancel_work_sync(&data->waker);

680

cancel_work_sync(&data->waker);

678

681

679

clear_bit(BTUSB_ISOC_RUNNING, &data->flags);

682

clear_bit(BTUSB_ISOC_RUNNING, &data->flags);

680

clear_bit(BTUSB_BULK_RUNNING, &data->flags);

683

clear_bit(BTUSB_BULK_RUNNING, &data->flags);

681

clear_bit(BTUSB_INTR_RUNNING, &data->flags);

684

clear_bit(BTUSB_INTR_RUNNING, &data->flags);

682

685

683

btusb_stop_traffic(data);

686

btusb_stop_traffic(data);

684

err = usb_autopm_get_interface(data->intf);

687

err = usb_autopm_get_interface(data->intf);

685

if (err < 0)

688

if (err < 0)

686

goto failed;

689

goto failed;

687

690

688

data->intf->needs_remote_wakeup = 0;

691

data->intf->needs_remote_wakeup = 0;

689

usb_autopm_put_interface(data->intf);

692

usb_autopm_put_interface(data->intf);

690

693

691

failed:

694

failed:

692

usb_scuttle_anchored_urbs(&data->deferred);

695

usb_scuttle_anchored_urbs(&data->deferred);

693

return 0;

696

return 0;

694

}

697

}

695

698

696

static int btusb_flush(struct hci_dev *hdev)

699

static int btusb_flush(struct hci_dev *hdev)

697

{

700

{

698

struct btusb_data *data = hci_get_drvdata(hdev);

701

struct btusb_data *data = hci_get_drvdata(hdev);

699

702

700

BT_DBG("%s", hdev->name);

703

BT_DBG("%s", hdev->name);

701

704

702

usb_kill_anchored_urbs(&data->tx_anchor);

705

usb_kill_anchored_urbs(&data->tx_anchor);

703

706

704

return 0;

707

return 0;

705

}

708

}

706

709

707

static int btusb_send_frame(struct sk_buff *skb)

710

static int btusb_send_frame(struct sk_buff *skb)

708

{

711

{

709

struct hci_dev *hdev = (struct hci_dev *) skb->dev;

712

struct hci_dev *hdev = (struct hci_dev *) skb->dev;

710

struct btusb_data *data = hci_get_drvdata(hdev);

713

struct btusb_data *data = hci_get_drvdata(hdev);

711

struct usb_ctrlrequest *dr;

714

struct usb_ctrlrequest *dr;

712

struct urb *urb;

715

struct urb *urb;

713

unsigned int pipe;

716

unsigned int pipe;

714

int err;

717

int err;

715

718

716

BT_DBG("%s", hdev->name);

719

BT_DBG("%s", hdev->name);

717

720

718

if (!test_bit(HCI_RUNNING, &hdev->flags))

721

if (!test_bit(HCI_RUNNING, &hdev->flags))

719

return -EBUSY;

722

return -EBUSY;

720

723

721

switch (bt_cb(skb)->pkt_type) {

724

switch (bt_cb(skb)->pkt_type) {

722

case HCI_COMMAND_PKT:

725

case HCI_COMMAND_PKT:

723

urb = usb_alloc_urb(0, GFP_ATOMIC);

726

urb = usb_alloc_urb(0, GFP_ATOMIC);

724

if (!urb)

727

if (!urb)

725

return -ENOMEM;

728

return -ENOMEM;

726

729

727

dr = kmalloc(sizeof(*dr), GFP_ATOMIC);

730

dr = kmalloc(sizeof(*dr), GFP_ATOMIC);

728

if (!dr) {

731

if (!dr) {

729

usb_free_urb(urb);

732

usb_free_urb(urb);

730

return -ENOMEM;

733

return -ENOMEM;

731

}

734

}

732

735

733

dr->bRequestType = data->cmdreq_type;

736

dr->bRequestType = data->cmdreq_type;

734

dr->bRequest = 0;

737

dr->bRequest = 0;

735

dr->wIndex = 0;

738

dr->wIndex = 0;

736

dr->wValue = 0;

739

dr->wValue = 0;

737

dr->wLength = __cpu_to_le16(skb->len);

740

dr->wLength = __cpu_to_le16(skb->len);

738

741

739

pipe = usb_sndctrlpipe(data->udev, 0x00);

742

pipe = usb_sndctrlpipe(data->udev, 0x00);

740

743

741

usb_fill_control_urb(urb, data->udev, pipe, (void *) dr,

744

usb_fill_control_urb(urb, data->udev, pipe, (void *) dr,

742

skb->data, skb->len, btusb_tx_complete, skb);

745

skb->data, skb->len, btusb_tx_complete, skb);

743

746

744

hdev->stat.cmd_tx++;

747

hdev->stat.cmd_tx++;

745

break;

748

break;

746

749

747

case HCI_ACLDATA_PKT:

750

case HCI_ACLDATA_PKT:

748

if (!data->bulk_tx_ep)

751

if (!data->bulk_tx_ep)

749

return -ENODEV;

752

return -ENODEV;

750

753

751

urb = usb_alloc_urb(0, GFP_ATOMIC);

754

urb = usb_alloc_urb(0, GFP_ATOMIC);

752

if (!urb)

755

if (!urb)

753

return -ENOMEM;

756

return -ENOMEM;

754

757

755

pipe = usb_sndbulkpipe(data->udev,

758

pipe = usb_sndbulkpipe(data->udev,

756

data->bulk_tx_ep->bEndpointAddress);

759

data->bulk_tx_ep->bEndpointAddress);

757

760

758

usb_fill_bulk_urb(urb, data->udev, pipe,

761

usb_fill_bulk_urb(urb, data->udev, pipe,

759

skb->data, skb->len, btusb_tx_complete, skb);

762

skb->data, skb->len, btusb_tx_complete, skb);

760

763

761

hdev->stat.acl_tx++;

764

hdev->stat.acl_tx++;

762

break;

765

break;

763

766

764

case HCI_SCODATA_PKT:

767

case HCI_SCODATA_PKT:

765

if (!data->isoc_tx_ep || hdev->conn_hash.sco_num < 1)

768

if (!data->isoc_tx_ep || hdev->conn_hash.sco_num < 1)

766

return -ENODEV;

769

return -ENODEV;

767

770

768

urb = usb_alloc_urb(BTUSB_MAX_ISOC_FRAMES, GFP_ATOMIC);

771

urb = usb_alloc_urb(BTUSB_MAX_ISOC_FRAMES, GFP_ATOMIC);

769

if (!urb)

772

if (!urb)

770

return -ENOMEM;

773

return -ENOMEM;

771

774

772

pipe = usb_sndisocpipe(data->udev,

775

pipe = usb_sndisocpipe(data->udev,

773

data->isoc_tx_ep->bEndpointAddress);

776

data->isoc_tx_ep->bEndpointAddress);

774

777

775

usb_fill_int_urb(urb, data->udev, pipe,

778

usb_fill_int_urb(urb, data->udev, pipe,

776

skb->data, skb->len, btusb_isoc_tx_complete,

779

skb->data, skb->len, btusb_isoc_tx_complete,

777

skb, data->isoc_tx_ep->bInterval);

780

skb, data->isoc_tx_ep->bInterval);

778

781

779

urb->transfer_flags = URB_ISO_ASAP;

782

urb->transfer_flags = URB_ISO_ASAP;

780

783

781

__fill_isoc_descriptor(urb, skb->len,

784

__fill_isoc_descriptor(urb, skb->len,

782

le16_to_cpu(data->isoc_tx_ep->wMaxPacketSize));

785

le16_to_cpu(data->isoc_tx_ep->wMaxPacketSize));

783

786

784

hdev->stat.sco_tx++;

787

hdev->stat.sco_tx++;

785

goto skip_waking;

788

goto skip_waking;

786

789

787

default:

790

default:

788

return -EILSEQ;

791

return -EILSEQ;

789

}

792

}

790

793

791

err = inc_tx(data);

794

err = inc_tx(data);

792

if (err) {

795

if (err) {

793

usb_anchor_urb(urb, &data->deferred);

796

usb_anchor_urb(urb, &data->deferred);

794

schedule_work(&data->waker);

797

schedule_work(&data->waker);

795

err = 0;

798

err = 0;

796

goto done;

799

goto done;

797

}

800

}

798

801

799

skip_waking:

802

skip_waking:

800

usb_anchor_urb(urb, &data->tx_anchor);

803

usb_anchor_urb(urb, &data->tx_anchor);

801

804

802

err = usb_submit_urb(urb, GFP_ATOMIC);

805

err = usb_submit_urb(urb, GFP_ATOMIC);

803

if (err < 0) {

806

if (err < 0) {

804

if (err != -EPERM && err != -ENODEV)

807

if (err != -EPERM && err != -ENODEV)

805

BT_ERR("%s urb %p submission failed (%d)",

808

BT_ERR("%s urb %p submission failed (%d)",

806

hdev->name, urb, -err);

809

hdev->name, urb, -err);

807

kfree(urb->setup_packet);

810

kfree(urb->setup_packet);

808

usb_unanchor_urb(urb);

811

usb_unanchor_urb(urb);

809

} else {

812

} else {

810

usb_mark_last_busy(data->udev);

813

usb_mark_last_busy(data->udev);

811

}

814

}

812

815

813

done:

816

done:

814

usb_free_urb(urb);

817

usb_free_urb(urb);

815

return err;

818

return err;

816

}

819

}

817

820

818

static void btusb_notify(struct hci_dev *hdev, unsigned int evt)

821

static void btusb_notify(struct hci_dev *hdev, unsigned int evt)

819

{

822

{

820

struct btusb_data *data = hci_get_drvdata(hdev);

823

struct btusb_data *data = hci_get_drvdata(hdev);

821

824

822

BT_DBG("%s evt %d", hdev->name, evt);

825

BT_DBG("%s evt %d", hdev->name, evt);

823

826

824

if (hdev->conn_hash.sco_num != data->sco_num) {

827

if (hdev->conn_hash.sco_num != data->sco_num) {

825

data->sco_num = hdev->conn_hash.sco_num;

828

data->sco_num = hdev->conn_hash.sco_num;

826

schedule_work(&data->work);

829

schedule_work(&data->work);

827

}

830

}

828

}

831

}

829

832

830

static inline int __set_isoc_interface(struct hci_dev *hdev, int altsetting)

833

static inline int __set_isoc_interface(struct hci_dev *hdev, int altsetting)

831

{

834

{

832

struct btusb_data *data = hci_get_drvdata(hdev);

835

struct btusb_data *data = hci_get_drvdata(hdev);

833

struct usb_interface *intf = data->isoc;

836

struct usb_interface *intf = data->isoc;

834

struct usb_endpoint_descriptor *ep_desc;

837

struct usb_endpoint_descriptor *ep_desc;

835

int i, err;

838

int i, err;

836

839

837

if (!data->isoc)

840

if (!data->isoc)

838

return -ENODEV;

841

return -ENODEV;

839

842

840

err = usb_set_interface(data->udev, 1, altsetting);

843

err = usb_set_interface(data->udev, 1, altsetting);

841

if (err < 0) {

844

if (err < 0) {

842

BT_ERR("%s setting interface failed (%d)", hdev->name, -err);

845

BT_ERR("%s setting interface failed (%d)", hdev->name, -err);

843

return err;

846

return err;

844

}

847

}

845

848

846

data->isoc_altsetting = altsetting;

849

data->isoc_altsetting = altsetting;

847

850

848

data->isoc_tx_ep = NULL;

851

data->isoc_tx_ep = NULL;

849

data->isoc_rx_ep = NULL;

852

data->isoc_rx_ep = NULL;

850

853

851

for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++) {

854

for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++) {

852

ep_desc = &intf->cur_altsetting->endpoint[i].desc;

855

ep_desc = &intf->cur_altsetting->endpoint[i].desc;

853

856

854

if (!data->isoc_tx_ep && usb_endpoint_is_isoc_out(ep_desc)) {

857

if (!data->isoc_tx_ep && usb_endpoint_is_isoc_out(ep_desc)) {

855

data->isoc_tx_ep = ep_desc;

858

data->isoc_tx_ep = ep_desc;

856

continue;

859

continue;

857

}

860

}

858

861

859

if (!data->isoc_rx_ep && usb_endpoint_is_isoc_in(ep_desc)) {

862

if (!data->isoc_rx_ep && usb_endpoint_is_isoc_in(ep_desc)) {

860

data->isoc_rx_ep = ep_desc;

863

data->isoc_rx_ep = ep_desc;

861

continue;

864

continue;

862

}

865

}

863

}

866

}

864

867

865

if (!data->isoc_tx_ep || !data->isoc_rx_ep) {

868

if (!data->isoc_tx_ep || !data->isoc_rx_ep) {

866

BT_ERR("%s invalid SCO descriptors", hdev->name);

869

BT_ERR("%s invalid SCO descriptors", hdev->name);

867

return -ENODEV;

870

return -ENODEV;

868

}

871

}

869

872

870

return 0;

873

return 0;

871

}

874

}

872

875

873

static void btusb_work(struct work_struct *work)

876

static void btusb_work(struct work_struct *work)

874

{

877

{

875

struct btusb_data *data = container_of(work, struct btusb_data, work);

878

struct btusb_data *data = container_of(work, struct btusb_data, work);

876

struct hci_dev *hdev = data->hdev;

879

struct hci_dev *hdev = data->hdev;

877

int new_alts;

880

int new_alts;

878

int err;

881

int err;

879

882

880

if (hdev->conn_hash.sco_num > 0) {

883

if (hdev->conn_hash.sco_num > 0) {

881

if (!test_bit(BTUSB_DID_ISO_RESUME, &data->flags)) {

884

if (!test_bit(BTUSB_DID_ISO_RESUME, &data->flags)) {

882

err = usb_autopm_get_interface(data->isoc ? data->isoc : data->intf);

885

err = usb_autopm_get_interface(data->isoc ? data->isoc : data->intf);

883

if (err < 0) {

886

if (err < 0) {

884

clear_bit(BTUSB_ISOC_RUNNING, &data->flags);

887

clear_bit(BTUSB_ISOC_RUNNING, &data->flags);

885

usb_kill_anchored_urbs(&data->isoc_anchor);

888

usb_kill_anchored_urbs(&data->isoc_anchor);

886

return;

889

return;

887

}

890

}

888

891

889

set_bit(BTUSB_DID_ISO_RESUME, &data->flags);

892

set_bit(BTUSB_DID_ISO_RESUME, &data->flags);

890

}

893

}

891

894

892

if (hdev->voice_setting & 0x0020) {

895

if (hdev->voice_setting & 0x0020) {

893

static const int alts[3] = { 2, 4, 5 };

896

static const int alts[3] = { 2, 4, 5 };

894

new_alts = alts[hdev->conn_hash.sco_num - 1];

897

new_alts = alts[hdev->conn_hash.sco_num - 1];

895

} else {

898

} else {

896

new_alts = hdev->conn_hash.sco_num;

899

new_alts = hdev->conn_hash.sco_num;

897

}

900

}

898

901

899

if (data->isoc_altsetting != new_alts) {

902

if (data->isoc_altsetting != new_alts) {

900

clear_bit(BTUSB_ISOC_RUNNING, &data->flags);

903

clear_bit(BTUSB_ISOC_RUNNING, &data->flags);

901

usb_kill_anchored_urbs(&data->isoc_anchor);

904

usb_kill_anchored_urbs(&data->isoc_anchor);

902

905

903

if (__set_isoc_interface(hdev, new_alts) < 0)

906

if (__set_isoc_interface(hdev, new_alts) < 0)

904

return;

907

return;

905

}

908

}

906

909

907

if (!test_and_set_bit(BTUSB_ISOC_RUNNING, &data->flags)) {

910

if (!test_and_set_bit(BTUSB_ISOC_RUNNING, &data->flags)) {

908

if (btusb_submit_isoc_urb(hdev, GFP_KERNEL) < 0)

911

if (btusb_submit_isoc_urb(hdev, GFP_KERNEL) < 0)

909

clear_bit(BTUSB_ISOC_RUNNING, &data->flags);

912

clear_bit(BTUSB_ISOC_RUNNING, &data->flags);

910

else

913

else

911

btusb_submit_isoc_urb(hdev, GFP_KERNEL);

914

btusb_submit_isoc_urb(hdev, GFP_KERNEL);

912

}

915

}

913

} else {

916

} else {

914

clear_bit(BTUSB_ISOC_RUNNING, &data->flags);

917

clear_bit(BTUSB_ISOC_RUNNING, &data->flags);

915

usb_kill_anchored_urbs(&data->isoc_anchor);

918

usb_kill_anchored_urbs(&data->isoc_anchor);

916

919

917

__set_isoc_interface(hdev, 0);

920

__set_isoc_interface(hdev, 0);

918

if (test_and_clear_bit(BTUSB_DID_ISO_RESUME, &data->flags))

921

if (test_and_clear_bit(BTUSB_DID_ISO_RESUME, &data->flags))

919

usb_autopm_put_interface(data->isoc ? data->isoc : data->intf);

922

usb_autopm_put_interface(data->isoc ? data->isoc : data->intf);

920

}

923

}

921

}

924

}

922

925

923

static void btusb_waker(struct work_struct *work)

926

static void btusb_waker(struct work_struct *work)

924

{

927

{

925

struct btusb_data *data = container_of(work, struct btusb_data, waker);

928

struct btusb_data *data = container_of(work, struct btusb_data, waker);

926

int err;

929

int err;

927

930

928

err = usb_autopm_get_interface(data->intf);

931

err = usb_autopm_get_interface(data->intf);

929

if (err < 0)

932

if (err < 0)

930

return;

933

return;

931

934

932

usb_autopm_put_interface(data->intf);

935

usb_autopm_put_interface(data->intf);

933

}

936

}

934

937

935

static int btusb_setup_bcm92035(struct hci_dev *hdev)

938

static int btusb_setup_bcm92035(struct hci_dev *hdev)

936

{

939

{

937

struct sk_buff *skb;

940

struct sk_buff *skb;

938

u8 val = 0x00;

941

u8 val = 0x00;

939

942

940

BT_DBG("%s", hdev->name);

943

BT_DBG("%s", hdev->name);

941

944

942

skb = __hci_cmd_sync(hdev, 0xfc3b, 1, &val, HCI_INIT_TIMEOUT);

945

skb = __hci_cmd_sync(hdev, 0xfc3b, 1, &val, HCI_INIT_TIMEOUT);

943

if (IS_ERR(skb))

946

if (IS_ERR(skb))

944

BT_ERR("BCM92035 command failed (%ld)", -PTR_ERR(skb));

947

BT_ERR("BCM92035 command failed (%ld)", -PTR_ERR(skb));

945

else

948

else

946

kfree_skb(skb);

949

kfree_skb(skb);

947

950

948

return 0;

951

return 0;

949

}

952

}

950

953

951

struct intel_version {

954

struct intel_version {

952

u8 status;

955

u8 status;

953

u8 hw_platform;

956

u8 hw_platform;

954

u8 hw_variant;

957

u8 hw_variant;

955

u8 hw_revision;

958

u8 hw_revision;

956

u8 fw_variant;

959

u8 fw_variant;

957

u8 fw_revision;

960

u8 fw_revision;

958

u8 fw_build_num;

961

u8 fw_build_num;

959

u8 fw_build_ww;

962

u8 fw_build_ww;

960

u8 fw_build_yy;

963

u8 fw_build_yy;

961

u8 fw_patch_num;

964

u8 fw_patch_num;

962

} __packed;

965

} __packed;

963

966

964

static const struct firmware *btusb_setup_intel_get_fw(struct hci_dev *hdev,

967

static const struct firmware *btusb_setup_intel_get_fw(struct hci_dev *hdev,

965

struct intel_version *ver)

968

struct intel_version *ver)

966

{

969

{

967

const struct firmware *fw;

970

const struct firmware *fw;

968

char fwname[64];

971

char fwname[64];

969

int ret;

972

int ret;

970

973

971

snprintf(fwname, sizeof(fwname),

974

snprintf(fwname, sizeof(fwname),

972

"intel/ibt-hw-%x.%x.%x-fw-%x.%x.%x.%x.%x.bseq",

975

"intel/ibt-hw-%x.%x.%x-fw-%x.%x.%x.%x.%x.bseq",

973

ver->hw_platform, ver->hw_variant, ver->hw_revision,

976

ver->hw_platform, ver->hw_variant, ver->hw_revision,

974

ver->fw_variant, ver->fw_revision, ver->fw_build_num,

977

ver->fw_variant, ver->fw_revision, ver->fw_build_num,

975

ver->fw_build_ww, ver->fw_build_yy);

978

ver->fw_build_ww, ver->fw_build_yy);

976

979

977

ret = request_firmware(&fw, fwname, &hdev->dev);

980

ret = request_firmware(&fw, fwname, &hdev->dev);

978

if (ret < 0) {

981

if (ret < 0) {

979

if (ret == -EINVAL) {

982

if (ret == -EINVAL) {

980

BT_ERR("%s Intel firmware file request failed (%d)",

983

BT_ERR("%s Intel firmware file request failed (%d)",

981

hdev->name, ret);

984

hdev->name, ret);

982

return NULL;

985

return NULL;

983

}

986

}

984

987

985

BT_ERR("%s failed to open Intel firmware file: %s(%d)",

988

BT_ERR("%s failed to open Intel firmware file: %s(%d)",

986

hdev->name, fwname, ret);

989

hdev->name, fwname, ret);

987

990

988

/* If the correct firmware patch file is not found, use the

991

/* If the correct firmware patch file is not found, use the

989

* default firmware patch file instead

992

* default firmware patch file instead

990

*/

993

*/

991

snprintf(fwname, sizeof(fwname), "intel/ibt-hw-%x.%x.bseq",

994

snprintf(fwname, sizeof(fwname), "intel/ibt-hw-%x.%x.bseq",

992

ver->hw_platform, ver->hw_variant);

995

ver->hw_platform, ver->hw_variant);

993

if (request_firmware(&fw, fwname, &hdev->dev) < 0) {

996

if (request_firmware(&fw, fwname, &hdev->dev) < 0) {

994

BT_ERR("%s failed to open default Intel fw file: %s",

997

BT_ERR("%s failed to open default Intel fw file: %s",

995

hdev->name, fwname);

998

hdev->name, fwname);

996

return NULL;

999

return NULL;

997

}

1000

}

998

}

1001

}

999

1002

1000

BT_INFO("%s: Intel Bluetooth firmware file: %s", hdev->name, fwname);

1003

BT_INFO("%s: Intel Bluetooth firmware file: %s", hdev->name, fwname);

1001

1004

1002

return fw;

1005

return fw;

1003

}

1006

}

1004

1007

1005

static int btusb_setup_intel_patching(struct hci_dev *hdev,

1008

static int btusb_setup_intel_patching(struct hci_dev *hdev,

1006

const struct firmware *fw,

1009

const struct firmware *fw,

1007

const u8 **fw_ptr, int *disable_patch)

1010

const u8 **fw_ptr, int *disable_patch)

1008

{

1011

{

1009

struct sk_buff *skb;

1012

struct sk_buff *skb;

1010

struct hci_command_hdr *cmd;

1013

struct hci_command_hdr *cmd;

1011

const u8 *cmd_param;

1014

const u8 *cmd_param;

1012

struct hci_event_hdr *evt = NULL;

1015

struct hci_event_hdr *evt = NULL;

1013

const u8 *evt_param = NULL;

1016

const u8 *evt_param = NULL;

1014

int remain = fw->size - (*fw_ptr - fw->data);

1017

int remain = fw->size - (*fw_ptr - fw->data);

1015

1018

1016

/* The first byte indicates the types of the patch command or event.

1019

/* The first byte indicates the types of the patch command or event.

1017

* 0x01 means HCI command and 0x02 is HCI event. If the first bytes

1020

* 0x01 means HCI command and 0x02 is HCI event. If the first bytes

1018

* in the current firmware buffer doesn't start with 0x01 or

1021

* in the current firmware buffer doesn't start with 0x01 or

1019

* the size of remain buffer is smaller than HCI command header,

1022

* the size of remain buffer is smaller than HCI command header,

1020

* the firmware file is corrupted and it should stop the patching

1023

* the firmware file is corrupted and it should stop the patching

1021

* process.

1024

* process.

1022

*/

1025

*/

1023

if (remain > HCI_COMMAND_HDR_SIZE && *fw_ptr[0] != 0x01) {

1026

if (remain > HCI_COMMAND_HDR_SIZE && *fw_ptr[0] != 0x01) {

1024

BT_ERR("%s Intel fw corrupted: invalid cmd read", hdev->name);

1027

BT_ERR("%s Intel fw corrupted: invalid cmd read", hdev->name);

1025

return -EINVAL;

1028

return -EINVAL;

1026

}

1029

}

1027

(*fw_ptr)++;

1030

(*fw_ptr)++;

1028

remain--;

1031

remain--;

1029

1032

1030

cmd = (struct hci_command_hdr *)(*fw_ptr);

1033

cmd = (struct hci_command_hdr *)(*fw_ptr);

1031

*fw_ptr += sizeof(*cmd);

1034

*fw_ptr += sizeof(*cmd);

1032

remain -= sizeof(*cmd);

1035

remain -= sizeof(*cmd);

1033

1036

1034

/* Ensure that the remain firmware data is long enough than the length

1037

/* Ensure that the remain firmware data is long enough than the length

1035

* of command parameter. If not, the firmware file is corrupted.

1038

* of command parameter. If not, the firmware file is corrupted.

1036

*/

1039

*/

1037

if (remain < cmd->plen) {

1040

if (remain < cmd->plen) {

1038

BT_ERR("%s Intel fw corrupted: invalid cmd len", hdev->name);

1041

BT_ERR("%s Intel fw corrupted: invalid cmd len", hdev->name);

1039

return -EFAULT;

1042

return -EFAULT;

1040

}

1043

}

1041

1044

1042

/* If there is a command that loads a patch in the firmware

1045

/* If there is a command that loads a patch in the firmware

1043

* file, then enable the patch upon success, otherwise just

1046

* file, then enable the patch upon success, otherwise just

1044

* disable the manufacturer mode, for example patch activation

1047

* disable the manufacturer mode, for example patch activation

1045

* is not required when the default firmware patch file is used

1048

* is not required when the default firmware patch file is used

1046

* because there are no patch data to load.

1049

* because there are no patch data to load.

1047

*/

1050

*/

1048

if (*disable_patch && le16_to_cpu(cmd->opcode) == 0xfc8e)

1051

if (*disable_patch && le16_to_cpu(cmd->opcode) == 0xfc8e)

1049

*disable_patch = 0;

1052

*disable_patch = 0;

1050

1053

1051

cmd_param = *fw_ptr;

1054

cmd_param = *fw_ptr;

1052

*fw_ptr += cmd->plen;

1055

*fw_ptr += cmd->plen;

1053

remain -= cmd->plen;

1056

remain -= cmd->plen;

1054

1057

1055

/* This reads the expected events when the above command is sent to the

1058

/* This reads the expected events when the above command is sent to the

1056

* device. Some vendor commands expects more than one events, for

1059

* device. Some vendor commands expects more than one events, for

1057

* example command status event followed by vendor specific event.

1060

* example command status event followed by vendor specific event.

1058

* For this case, it only keeps the last expected event. so the command

1061

* For this case, it only keeps the last expected event. so the command

1059

* can be sent with __hci_cmd_sync_ev() which returns the sk_buff of

1062

* can be sent with __hci_cmd_sync_ev() which returns the sk_buff of

1060

* last expected event.

1063

* last expected event.

1061

*/

1064

*/

1062

while (remain > HCI_EVENT_HDR_SIZE && *fw_ptr[0] == 0x02) {

1065

while (remain > HCI_EVENT_HDR_SIZE && *fw_ptr[0] == 0x02) {

1063

(*fw_ptr)++;

1066

(*fw_ptr)++;

1064

remain--;

1067

remain--;

1065

1068

1066

evt = (struct hci_event_hdr *)(*fw_ptr);

1069

evt = (struct hci_event_hdr *)(*fw_ptr);

1067

*fw_ptr += sizeof(*evt);

1070

*fw_ptr += sizeof(*evt);

1068

remain -= sizeof(*evt);

1071

remain -= sizeof(*evt);

1069

1072

1070

if (remain < evt->plen) {

1073

if (remain < evt->plen) {

1071

BT_ERR("%s Intel fw corrupted: invalid evt len",

1074

BT_ERR("%s Intel fw corrupted: invalid evt len",

1072

hdev->name);

1075

hdev->name);

1073

return -EFAULT;

1076

return -EFAULT;

1074

}

1077

}

1075

1078

1076

evt_param = *fw_ptr;

1079

evt_param = *fw_ptr;

1077

*fw_ptr += evt->plen;

1080

*fw_ptr += evt->plen;

1078

remain -= evt->plen;

1081

remain -= evt->plen;

1079

}

1082

}

1080

1083

1081

/* Every HCI commands in the firmware file has its correspond event.

1084

/* Every HCI commands in the firmware file has its correspond event.

1082

* If event is not found or remain is smaller than zero, the firmware

1085

* If event is not found or remain is smaller than zero, the firmware

1083

* file is corrupted.

1086

* file is corrupted.

1084

*/

1087

*/

1085

if (!evt || !evt_param || remain < 0) {

1088

if (!evt || !evt_param || remain < 0) {

1086

BT_ERR("%s Intel fw corrupted: invalid evt read", hdev->name);

1089

BT_ERR("%s Intel fw corrupted: invalid evt read", hdev->name);

1087

return -EFAULT;

1090

return -EFAULT;

1088

}

1091

}

1089

1092

1090

skb = __hci_cmd_sync_ev(hdev, le16_to_cpu(cmd->opcode), cmd->plen,

1093

skb = __hci_cmd_sync_ev(hdev, le16_to_cpu(cmd->opcode), cmd->plen,

1091

cmd_param, evt->evt, HCI_INIT_TIMEOUT);

1094

cmd_param, evt->evt, HCI_INIT_TIMEOUT);

1092

if (IS_ERR(skb)) {

1095

if (IS_ERR(skb)) {

1093

BT_ERR("%s sending Intel patch command (0x%4.4x) failed (%ld)",

1096

BT_ERR("%s sending Intel patch command (0x%4.4x) failed (%ld)",

1094

hdev->name, cmd->opcode, PTR_ERR(skb));

1097

hdev->name, cmd->opcode, PTR_ERR(skb));

1095

return -PTR_ERR(skb);

1098

return -PTR_ERR(skb);

1096

}

1099

}

1097

1100

1098

/* It ensures that the returned event matches the event data read from

1101

/* It ensures that the returned event matches the event data read from

1099

* the firmware file. At fist, it checks the length and then

1102

* the firmware file. At fist, it checks the length and then

1100

* the contents of the event.

1103

* the contents of the event.

1101

*/

1104

*/

1102

if (skb->len != evt->plen) {

1105

if (skb->len != evt->plen) {

1103

BT_ERR("%s mismatch event length (opcode 0x%4.4x)", hdev->name,

1106

BT_ERR("%s mismatch event length (opcode 0x%4.4x)", hdev->name,

1104

le16_to_cpu(cmd->opcode));

1107

le16_to_cpu(cmd->opcode));

1105

kfree_skb(skb);

1108

kfree_skb(skb);

1106

return -EFAULT;

1109

return -EFAULT;

1107

}

1110

}

1108

1111

1109

if (memcmp(skb->data, evt_param, evt->plen)) {

1112

if (memcmp(skb->data, evt_param, evt->plen)) {

1110

BT_ERR("%s mismatch event parameter (opcode 0x%4.4x)",

1113

BT_ERR("%s mismatch event parameter (opcode 0x%4.4x)",

1111

hdev->name, le16_to_cpu(cmd->opcode));

1114

hdev->name, le16_to_cpu(cmd->opcode));

1112

kfree_skb(skb);

1115

kfree_skb(skb);

1113

return -EFAULT;

1116

return -EFAULT;

1114

}

1117

}

1115

kfree_skb(skb);

1118

kfree_skb(skb);

1116

1119

1117

return 0;

1120

return 0;

1118

}

1121

}

1119

1122

1120

static int btusb_setup_intel(struct hci_dev *hdev)

1123

static int btusb_setup_intel(struct hci_dev *hdev)

1121

{

1124

{

1122

struct sk_buff *skb;

1125

struct sk_buff *skb;

1123

const struct firmware *fw;

1126

const struct firmware *fw;

1124

const u8 *fw_ptr;

1127

const u8 *fw_ptr;

1125

int disable_patch;

1128

int disable_patch;

1126

struct intel_version *ver;

1129

struct intel_version *ver;

1127

1130

1128

const u8 mfg_enable[] = { 0x01, 0x00 };

1131

const u8 mfg_enable[] = { 0x01, 0x00 };

1129

const u8 mfg_disable[] = { 0x00, 0x00 };

1132

const u8 mfg_disable[] = { 0x00, 0x00 };

1130

const u8 mfg_reset_deactivate[] = { 0x00, 0x01 };

1133

const u8 mfg_reset_deactivate[] = { 0x00, 0x01 };

1131

const u8 mfg_reset_activate[] = { 0x00, 0x02 };

1134

const u8 mfg_reset_activate[] = { 0x00, 0x02 };

1132

1135

1133

BT_DBG("%s", hdev->name);

1136

BT_DBG("%s", hdev->name);

1134

1137

1135

/* The controller has a bug with the first HCI command sent to it

1138

/* The controller has a bug with the first HCI command sent to it

1136

* returning number of completed commands as zero. This would stall the

1139

* returning number of completed commands as zero. This would stall the

1137

* command processing in the Bluetooth core.

1140

* command processing in the Bluetooth core.

1138

*

1141

*

1139

* As a workaround, send HCI Reset command first which will reset the

1142

* As a workaround, send HCI Reset command first which will reset the

1140

* number of completed commands and allow normal command processing

1143

* number of completed commands and allow normal command processing

1141

* from now on.

1144

* from now on.

1142

*/

1145

*/

1143

skb = __hci_cmd_sync(hdev, HCI_OP_RESET, 0, NULL, HCI_INIT_TIMEOUT);

1146

skb = __hci_cmd_sync(hdev, HCI_OP_RESET, 0, NULL, HCI_INIT_TIMEOUT);

1144

if (IS_ERR(skb)) {

1147

if (IS_ERR(skb)) {

1145

BT_ERR("%s sending initial HCI reset command failed (%ld)",

1148

BT_ERR("%s sending initial HCI reset command failed (%ld)",

1146

hdev->name, PTR_ERR(skb));

1149

hdev->name, PTR_ERR(skb));

1147

return -PTR_ERR(skb);

1150

return -PTR_ERR(skb);

1148

}

1151

}

1149

kfree_skb(skb);

1152

kfree_skb(skb);

1150

1153

1151

/* Read Intel specific controller version first to allow selection of

1154

/* Read Intel specific controller version first to allow selection of

1152

* which firmware file to load.

1155

* which firmware file to load.

1153

*

1156

*

1154

* The returned information are hardware variant and revision plus

1157

* The returned information are hardware variant and revision plus

1155

* firmware variant, revision and build number.

1158

* firmware variant, revision and build number.

1156

*/

1159

*/

1157

skb = __hci_cmd_sync(hdev, 0xfc05, 0, NULL, HCI_INIT_TIMEOUT);

1160

skb = __hci_cmd_sync(hdev, 0xfc05, 0, NULL, HCI_INIT_TIMEOUT);

1158

if (IS_ERR(skb)) {

1161

if (IS_ERR(skb)) {

1159

BT_ERR("%s reading Intel fw version command failed (%ld)",

1162

BT_ERR("%s reading Intel fw version command failed (%ld)",

1160

hdev->name, PTR_ERR(skb));

1163

hdev->name, PTR_ERR(skb));

1161

return -PTR_ERR(skb);

1164

return -PTR_ERR(skb);

1162

}

1165

}

1163

1166

1164

if (skb->len != sizeof(*ver)) {

1167

if (skb->len != sizeof(*ver)) {

1165

BT_ERR("%s Intel version event length mismatch", hdev->name);

1168

BT_ERR("%s Intel version event length mismatch", hdev->name);

1166

kfree_skb(skb);

1169

kfree_skb(skb);

1167

return -EIO;

1170

return -EIO;

1168

}

1171

}

1169

1172

1170

ver = (struct intel_version *)skb->data;

1173

ver = (struct intel_version *)skb->data;

1171

if (ver->status) {

1174

if (ver->status) {

1172

BT_ERR("%s Intel fw version event failed (%02x)", hdev->name,

1175

BT_ERR("%s Intel fw version event failed (%02x)", hdev->name,

1173

ver->status);

1176

ver->status);

1174

kfree_skb(skb);

1177

kfree_skb(skb);

1175

return -bt_to_errno(ver->status);

1178

return -bt_to_errno(ver->status);

1176

}

1179

}

1177

1180

1178

BT_INFO("%s: read Intel version: %02x%02x%02x%02x%02x%02x%02x%02x%02x",

1181

BT_INFO("%s: read Intel version: %02x%02x%02x%02x%02x%02x%02x%02x%02x",

1179

hdev->name, ver->hw_platform, ver->hw_variant,

1182

hdev->name, ver->hw_platform, ver->hw_variant,

1180

ver->hw_revision, ver->fw_variant, ver->fw_revision,

1183

ver->hw_revision, ver->fw_variant, ver->fw_revision,

1181

ver->fw_build_num, ver->fw_build_ww, ver->fw_build_yy,

1184

ver->fw_build_num, ver->fw_build_ww, ver->fw_build_yy,

1182

ver->fw_patch_num);

1185

ver->fw_patch_num);

1183

1186

1184

/* fw_patch_num indicates the version of patch the device currently

1187

/* fw_patch_num indicates the version of patch the device currently

1185

* have. If there is no patch data in the device, it is always 0x00.

1188

* have. If there is no patch data in the device, it is always 0x00.

1186

* So, if it is other than 0x00, no need to patch the deivce again.

1189

* So, if it is other than 0x00, no need to patch the deivce again.

1187

*/

1190

*/

1188

if (ver->fw_patch_num) {

1191

if (ver->fw_patch_num) {

1189

BT_INFO("%s: Intel device is already patched. patch num: %02x",

1192

BT_INFO("%s: Intel device is already patched. patch num: %02x",

1190

hdev->name, ver->fw_patch_num);

1193

hdev->name, ver->fw_patch_num);

1191

kfree_skb(skb);

1194

kfree_skb(skb);

1192

return 0;

1195

return 0;

1193

}

1196

}

1194

1197

1195

/* Opens the firmware patch file based on the firmware version read

1198

/* Opens the firmware patch file based on the firmware version read

1196

* from the controller. If it fails to open the matching firmware

1199

* from the controller. If it fails to open the matching firmware

1197

* patch file, it tries to open the default firmware patch file.

1200

* patch file, it tries to open the default firmware patch file.

1198

* If no patch file is found, allow the device to operate without

1201

* If no patch file is found, allow the device to operate without

1199

* a patch.

1202

* a patch.

1200

*/

1203

*/

1201

fw = btusb_setup_intel_get_fw(hdev, ver);

1204

fw = btusb_setup_intel_get_fw(hdev, ver);

1202

if (!fw) {

1205

if (!fw) {

1203

kfree_skb(skb);

1206

kfree_skb(skb);

1204

return 0;

1207

return 0;

1205

}

1208

}

1206

fw_ptr = fw->data;

1209

fw_ptr = fw->data;

1207

1210

1208

/* This Intel specific command enables the manufacturer mode of the

1211

/* This Intel specific command enables the manufacturer mode of the

1209

* controller.

1212

* controller.

1210

*

1213

*

1211

* Only while this mode is enabled, the driver can download the

1214

* Only while this mode is enabled, the driver can download the

1212

* firmware patch data and configuration parameters.

1215

* firmware patch data and configuration parameters.

1213

*/

1216

*/

1214

skb = __hci_cmd_sync(hdev, 0xfc11, 2, mfg_enable, HCI_INIT_TIMEOUT);

1217

skb = __hci_cmd_sync(hdev, 0xfc11, 2, mfg_enable, HCI_INIT_TIMEOUT);

1215

if (IS_ERR(skb)) {

1218

if (IS_ERR(skb)) {

1216

BT_ERR("%s entering Intel manufacturer mode failed (%ld)",

1219

BT_ERR("%s entering Intel manufacturer mode failed (%ld)",

1217

hdev->name, PTR_ERR(skb));

1220

hdev->name, PTR_ERR(skb));

1218

release_firmware(fw);

1221

release_firmware(fw);

1219

return -PTR_ERR(skb);

1222

return -PTR_ERR(skb);

1220

}

1223

}

1221

1224

1222

if (skb->data[0]) {

1225

if (skb->data[0]) {

1223

u8 evt_status = skb->data[0];

1226

u8 evt_status = skb->data[0];

1224

BT_ERR("%s enable Intel manufacturer mode event failed (%02x)",

1227

BT_ERR("%s enable Intel manufacturer mode event failed (%02x)",

1225

hdev->name, evt_status);

1228

hdev->name, evt_status);

1226

kfree_skb(skb);

1229

kfree_skb(skb);

1227

release_firmware(fw);

1230

release_firmware(fw);

1228

return -bt_to_errno(evt_status);

1231

return -bt_to_errno(evt_status);

1229

}

1232

}

1230

kfree_skb(skb);

1233

kfree_skb(skb);

1231

1234

1232

disable_patch = 1;

1235

disable_patch = 1;

1233

1236

1234

/* The firmware data file consists of list of Intel specific HCI

1237

/* The firmware data file consists of list of Intel specific HCI

1235

* commands and its expected events. The first byte indicates the

1238

* commands and its expected events. The first byte indicates the

1236

* type of the message, either HCI command or HCI event.

1239

* type of the message, either HCI command or HCI event.

1237

*

1240

*

1238

* It reads the command and its expected event from the firmware file,

1241

* It reads the command and its expected event from the firmware file,

1239

* and send to the controller. Once __hci_cmd_sync_ev() returns,

1242

* and send to the controller. Once __hci_cmd_sync_ev() returns,

1240

* the returned event is compared with the event read from the firmware

1243

* the returned event is compared with the event read from the firmware

1241

* file and it will continue until all the messages are downloaded to

1244

* file and it will continue until all the messages are downloaded to

1242

* the controller.

1245

* the controller.

1243

*

1246

*

1244

* Once the firmware patching is completed successfully,

1247

* Once the firmware patching is completed successfully,

1245

* the manufacturer mode is disabled with reset and activating the

1248

* the manufacturer mode is disabled with reset and activating the

1246

* downloaded patch.

1249

* downloaded patch.

1247

*

1250

*

1248

* If the firmware patching fails, the manufacturer mode is

1251

* If the firmware patching fails, the manufacturer mode is

1249

* disabled with reset and deactivating the patch.

1252

* disabled with reset and deactivating the patch.

1250

*

1253

*

1251

* If the default patch file is used, no reset is done when disabling

1254

* If the default patch file is used, no reset is done when disabling

1252

* the manufacturer.

1255

* the manufacturer.

1253

*/

1256

*/

1254

while (fw->size > fw_ptr - fw->data) {

1257

while (fw->size > fw_ptr - fw->data) {

1255

int ret;

1258

int ret;

1256

1259

1257

ret = btusb_setup_intel_patching(hdev, fw, &fw_ptr,

1260

ret = btusb_setup_intel_patching(hdev, fw, &fw_ptr,

1258

&disable_patch);

1261

&disable_patch);

1259

if (ret < 0)

1262

if (ret < 0)

1260

goto exit_mfg_deactivate;

1263

goto exit_mfg_deactivate;

1261

}

1264

}

1262

1265

1263

release_firmware(fw);

1266

release_firmware(fw);

1264

1267

1265

if (disable_patch)

1268

if (disable_patch)

1266

goto exit_mfg_disable;

1269

goto exit_mfg_disable;

1267

1270

1268

/* Patching completed successfully and disable the manufacturer mode

1271

/* Patching completed successfully and disable the manufacturer mode

1269

* with reset and activate the downloaded firmware patches.

1272

* with reset and activate the downloaded firmware patches.

1270

*/

1273

*/

1271

skb = __hci_cmd_sync(hdev, 0xfc11, sizeof(mfg_reset_activate),

1274

skb = __hci_cmd_sync(hdev, 0xfc11, sizeof(mfg_reset_activate),

1272

mfg_reset_activate, HCI_INIT_TIMEOUT);

1275

mfg_reset_activate, HCI_INIT_TIMEOUT);

1273

if (IS_ERR(skb)) {

1276

if (IS_ERR(skb)) {

1274

BT_ERR("%s exiting Intel manufacturer mode failed (%ld)",

1277

BT_ERR("%s exiting Intel manufacturer mode failed (%ld)",

1275

hdev->name, PTR_ERR(skb));

1278

hdev->name, PTR_ERR(skb));

1276

return -PTR_ERR(skb);

1279

return -PTR_ERR(skb);

1277

}

1280

}

1278

kfree_skb(skb);

1281

kfree_skb(skb);

1279

1282

1280

BT_INFO("%s: Intel Bluetooth firmware patch completed and activated",

1283

BT_INFO("%s: Intel Bluetooth firmware patch completed and activated",

1281

hdev->name);

1284

hdev->name);

1282

1285

1283

return 0;

1286

return 0;

1284

1287

1285

exit_mfg_disable:

1288

exit_mfg_disable:

1286

/* Disable the manufacturer mode without reset */

1289

/* Disable the manufacturer mode without reset */

1287

skb = __hci_cmd_sync(hdev, 0xfc11, sizeof(mfg_disable), mfg_disable,

1290

skb = __hci_cmd_sync(hdev, 0xfc11, sizeof(mfg_disable), mfg_disable,

1288

HCI_INIT_TIMEOUT);

1291

HCI_INIT_TIMEOUT);

1289

if (IS_ERR(skb)) {

1292

if (IS_ERR(skb)) {

1290

BT_ERR("%s exiting Intel manufacturer mode failed (%ld)",

1293

BT_ERR("%s exiting Intel manufacturer mode failed (%ld)",

1291

hdev->name, PTR_ERR(skb));

1294

hdev->name, PTR_ERR(skb));

1292

return -PTR_ERR(skb);

1295

return -PTR_ERR(skb);

1293

}

1296

}

1294

kfree_skb(skb);

1297

kfree_skb(skb);

1295

1298

1296

BT_INFO("%s: Intel Bluetooth firmware patch completed", hdev->name);

1299

BT_INFO("%s: Intel Bluetooth firmware patch completed", hdev->name);

1297

return 0;

1300

return 0;

1298

1301

1299

exit_mfg_deactivate:

1302

exit_mfg_deactivate:

1300

release_firmware(fw);

1303

release_firmware(fw);

1301

1304

1302

/* Patching failed. Disable the manufacturer mode with reset and

1305

/* Patching failed. Disable the manufacturer mode with reset and

1303

* deactivate the downloaded firmware patches.

1306

* deactivate the downloaded firmware patches.

1304

*/

1307

*/

1305

skb = __hci_cmd_sync(hdev, 0xfc11, sizeof(mfg_reset_deactivate),

1308

skb = __hci_cmd_sync(hdev, 0xfc11, sizeof(mfg_reset_deactivate),

1306

mfg_reset_deactivate, HCI_INIT_TIMEOUT);

1309

mfg_reset_deactivate, HCI_INIT_TIMEOUT);

1307

if (IS_ERR(skb)) {

1310

if (IS_ERR(skb)) {

1308

BT_ERR("%s exiting Intel manufacturer mode failed (%ld)",

1311

BT_ERR("%s exiting Intel manufacturer mode failed (%ld)",

1309

hdev->name, PTR_ERR(skb));

1312

hdev->name, PTR_ERR(skb));

1310

return -PTR_ERR(skb);

1313

return -PTR_ERR(skb);

1311

}

1314

}

1312

kfree_skb(skb);

1315

kfree_skb(skb);

1313

1316

1314

BT_INFO("%s: Intel Bluetooth firmware patch completed and deactivated",

1317

BT_INFO("%s: Intel Bluetooth firmware patch completed and deactivated",

1315

hdev->name);

1318

hdev->name);

1316

1319

1317

return 0;

1320

return 0;

1318

}

1321

}

1319

1322

1320

static int btusb_probe(struct usb_interface *intf,

1323

static int btusb_probe(struct usb_interface *intf,

1321

const struct usb_device_id *id)

1324

const struct usb_device_id *id)

1322

{

1325

{

1323

struct usb_endpoint_descriptor *ep_desc;

1326

struct usb_endpoint_descriptor *ep_desc;

1324

struct btusb_data *data;

1327

struct btusb_data *data;

1325

struct hci_dev *hdev;

1328

struct hci_dev *hdev;

1326

int i, err;

1329

int i, err;

1327

1330

1328

BT_DBG("intf %p id %p", intf, id);

1331

BT_DBG("intf %p id %p", intf, id);

1329

1332

1330

/* interface numbers are hardcoded in the spec */

1333

/* interface numbers are hardcoded in the spec */

1331

if (intf->cur_altsetting->desc.bInterfaceNumber != 0)

1334

if (intf->cur_altsetting->desc.bInterfaceNumber != 0)

1332

return -ENODEV;

1335

return -ENODEV;

1333

1336

1334

if (!id->driver_info) {

1337

if (!id->driver_info) {

1335

const struct usb_device_id *match;

1338

const struct usb_device_id *match;

1336

match = usb_match_id(intf, blacklist_table);

1339

match = usb_match_id(intf, blacklist_table);

1337

if (match)

1340

if (match)

1338

id = match;

1341

id = match;

1339

}

1342

}

1340

1343

1341

if (id->driver_info == BTUSB_IGNORE)

1344

if (id->driver_info == BTUSB_IGNORE)

1342

return -ENODEV;

1345

return -ENODEV;

1343

1346

1344

if (ignore_dga && id->driver_info & BTUSB_DIGIANSWER)

1347

if (ignore_dga && id->driver_info & BTUSB_DIGIANSWER)

1345

return -ENODEV;

1348

return -ENODEV;

1346

1349

1347

if (ignore_csr && id->driver_info & BTUSB_CSR)

1350

if (ignore_csr && id->driver_info & BTUSB_CSR)

1348

return -ENODEV;

1351

return -ENODEV;

1349

1352

1350

if (ignore_sniffer && id->driver_info & BTUSB_SNIFFER)

1353

if (ignore_sniffer && id->driver_info & BTUSB_SNIFFER)

1351

return -ENODEV;

1354

return -ENODEV;

1352

1355

1353

if (id->driver_info & BTUSB_ATH3012) {

1356

if (id->driver_info & BTUSB_ATH3012) {

1354

struct usb_device *udev = interface_to_usbdev(intf);

1357

struct usb_device *udev = interface_to_usbdev(intf);

1355

1358

1356

/* Old firmware would otherwise let ath3k driver load

1359

/* Old firmware would otherwise let ath3k driver load

1357

* patch and sysconfig files */

1360

* patch and sysconfig files */

1358

if (le16_to_cpu(udev->descriptor.bcdDevice) <= 0x0001)

1361

if (le16_to_cpu(udev->descriptor.bcdDevice) <= 0x0001)

1359

return -ENODEV;

1362

return -ENODEV;

1360

}

1363

}

1361

1364

1362

data = devm_kzalloc(&intf->dev, sizeof(*data), GFP_KERNEL);

1365

data = devm_kzalloc(&intf->dev, sizeof(*data), GFP_KERNEL);

1363

if (!data)

1366

if (!data)

1364

return -ENOMEM;

1367

return -ENOMEM;

1365

1368

1366

for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++) {

1369

for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++) {

1367

ep_desc = &intf->cur_altsetting->endpoint[i].desc;

1370

ep_desc = &intf->cur_altsetting->endpoint[i].desc;

1368

1371

1369

if (!data->intr_ep && usb_endpoint_is_int_in(ep_desc)) {

1372

if (!data->intr_ep && usb_endpoint_is_int_in(ep_desc)) {

1370

data->intr_ep = ep_desc;

1373

data->intr_ep = ep_desc;

1371

continue;

1374

continue;

1372

}

1375

}

1373

1376

1374

if (!data->bulk_tx_ep && usb_endpoint_is_bulk_out(ep_desc)) {

1377

if (!data->bulk_tx_ep && usb_endpoint_is_bulk_out(ep_desc)) {

1375

data->bulk_tx_ep = ep_desc;

1378

data->bulk_tx_ep = ep_desc;

1376

continue;

1379

continue;

1377

}

1380

}

1378

1381

1379

if (!data->bulk_rx_ep && usb_endpoint_is_bulk_in(ep_desc)) {

1382

if (!data->bulk_rx_ep && usb_endpoint_is_bulk_in(ep_desc)) {

1380

data->bulk_rx_ep = ep_desc;

1383

data->bulk_rx_ep = ep_desc;

1381

continue;

1384

continue;

1382

}

1385

}

1383

}

1386

}

1384

1387

1385

if (!data->intr_ep || !data->bulk_tx_ep || !data->bulk_rx_ep)

1388

if (!data->intr_ep || !data->bulk_tx_ep || !data->bulk_rx_ep)

1386

return -ENODEV;

1389

return -ENODEV;

1387

1390

1388

data->cmdreq_type = USB_TYPE_CLASS;

1391

data->cmdreq_type = USB_TYPE_CLASS;

1389

1392

1390

data->udev = interface_to_usbdev(intf);

1393

data->udev = interface_to_usbdev(intf);

1391

data->intf = intf;

1394

data->intf = intf;

1392

1395

1393

spin_lock_init(&data->lock);

1396

spin_lock_init(&data->lock);

1394

1397

1395

INIT_WORK(&data->work, btusb_work);

1398

INIT_WORK(&data->work, btusb_work);

1396

INIT_WORK(&data->waker, btusb_waker);

1399

INIT_WORK(&data->waker, btusb_waker);

1397

spin_lock_init(&data->txlock);

1400

spin_lock_init(&data->txlock);

1398

1401

1399

init_usb_anchor(&data->tx_anchor);

1402

init_usb_anchor(&data->tx_anchor);

1400

init_usb_anchor(&data->intr_anchor);

1403

init_usb_anchor(&data->intr_anchor);

1401

init_usb_anchor(&data->bulk_anchor);

1404

init_usb_anchor(&data->bulk_anchor);

1402

init_usb_anchor(&data->isoc_anchor);

1405

init_usb_anchor(&data->isoc_anchor);

1403

init_usb_anchor(&data->deferred);

1406

init_usb_anchor(&data->deferred);

1404

1407

1405

hdev = hci_alloc_dev();

1408

hdev = hci_alloc_dev();

1406

if (!hdev)

1409

if (!hdev)

1407

return -ENOMEM;

1410

return -ENOMEM;

1408

1411

1409

hdev->bus = HCI_USB;

1412

hdev->bus = HCI_USB;

1410

hci_set_drvdata(hdev, data);

1413

hci_set_drvdata(hdev, data);

1411

1414

1412

data->hdev = hdev;

1415

data->hdev = hdev;

1413

1416

1414

SET_HCIDEV_DEV(hdev, &intf->dev);

1417

SET_HCIDEV_DEV(hdev, &intf->dev);

1415

1418

1416

hdev->open = btusb_open;

1419

hdev->open = btusb_open;

1417

hdev->close = btusb_close;

1420

hdev->close = btusb_close;

1418

hdev->flush = btusb_flush;

1421

hdev->flush = btusb_flush;

1419

hdev->send = btusb_send_frame;

1422

hdev->send = btusb_send_frame;

1420

hdev->notify = btusb_notify;

1423

hdev->notify = btusb_notify;

1421

1424

1422

if (id->driver_info & BTUSB_BCM92035)

1425

if (id->driver_info & BTUSB_BCM92035)

1423

hdev->setup = btusb_setup_bcm92035;

1426

hdev->setup = btusb_setup_bcm92035;

1424

1427

1425

if (id->driver_info & BTUSB_INTEL)

1428

if (id->driver_info & BTUSB_INTEL)

1426

hdev->setup = btusb_setup_intel;

1429

hdev->setup = btusb_setup_intel;

1427

1430

1428

/* Interface numbers are hardcoded in the specification */

1431

/* Interface numbers are hardcoded in the specification */

1429

data->isoc = usb_ifnum_to_if(data->udev, 1);

1432

data->isoc = usb_ifnum_to_if(data->udev, 1);

1430

1433

1431

if (!reset)

1434

if (!reset)

1432

set_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks);

1435

set_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks);

1433

1436

1434

if (force_scofix || id->driver_info & BTUSB_WRONG_SCO_MTU) {

1437

if (force_scofix || id->driver_info & BTUSB_WRONG_SCO_MTU) {

1435

if (!disable_scofix)

1438

if (!disable_scofix)

1436

set_bit(HCI_QUIRK_FIXUP_BUFFER_SIZE, &hdev->quirks);

1439

set_bit(HCI_QUIRK_FIXUP_BUFFER_SIZE, &hdev->quirks);

1437

}

1440

}

1438

1441

1439

if (id->driver_info & BTUSB_BROKEN_ISOC)

1442

if (id->driver_info & BTUSB_BROKEN_ISOC)

1440

data->isoc = NULL;

1443

data->isoc = NULL;

1441

1444

1442

if (id->driver_info & BTUSB_DIGIANSWER) {

1445

if (id->driver_info & BTUSB_DIGIANSWER) {

1443

data->cmdreq_type = USB_TYPE_VENDOR;

1446

data->cmdreq_type = USB_TYPE_VENDOR;

1444

set_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks);

1447

set_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks);

1445

}

1448

}

1446

1449

1447

if (id->driver_info & BTUSB_CSR) {

1450

if (id->driver_info & BTUSB_CSR) {

1448

struct usb_device *udev = data->udev;

1451

struct usb_device *udev = data->udev;

1449

1452

1450

/* Old firmware would otherwise execute USB reset */

1453

/* Old firmware would otherwise execute USB reset */

1451

if (le16_to_cpu(udev->descriptor.bcdDevice) < 0x117)

1454

if (le16_to_cpu(udev->descriptor.bcdDevice) < 0x117)

1452

set_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks);

1455

set_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks);

1453

}

1456

}

1454

1457

1455

if (id->driver_info & BTUSB_SNIFFER) {

1458

if (id->driver_info & BTUSB_SNIFFER) {

1456

struct usb_device *udev = data->udev;

1459

struct usb_device *udev = data->udev;

1457

1460

1458

/* New sniffer firmware has crippled HCI interface */

1461

/* New sniffer firmware has crippled HCI interface */

1459

if (le16_to_cpu(udev->descriptor.bcdDevice) > 0x997)

1462

if (le16_to_cpu(udev->descriptor.bcdDevice) > 0x997)

1460

set_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks);

1463

set_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks);

1461

1464

1462

data->isoc = NULL;

1465

data->isoc = NULL;

1463

}

1466

}

1464

1467

1465

if (data->isoc) {

1468

if (data->isoc) {

1466

err = usb_driver_claim_interface(&btusb_driver,

1469

err = usb_driver_claim_interface(&btusb_driver,

1467

data->isoc, data);

1470

data->isoc, data);

1468

if (err < 0) {

1471

if (err < 0) {

1469

hci_free_dev(hdev);

1472

hci_free_dev(hdev);

1470

return err;

1473

return err;

1471

}

1474

}

1472

}

1475

}

1473

1476

1474

err = hci_register_dev(hdev);

1477

err = hci_register_dev(hdev);

1475

if (err < 0) {

1478

if (err < 0) {

1476

hci_free_dev(hdev);

1479

hci_free_dev(hdev);

1477

return err;

1480

return err;

1478

}

1481

}

1479

1482

1480

usb_set_intfdata(intf, data);

1483

usb_set_intfdata(intf, data);

1481

1484

1482

return 0;

1485

return 0;

1483

}

1486

}

1484

1487

1485

static void btusb_disconnect(struct usb_interface *intf)

1488

static void btusb_disconnect(struct usb_interface *intf)

1486

{

1489

{

1487

struct btusb_data *data = usb_get_intfdata(intf);

1490

struct btusb_data *data = usb_get_intfdata(intf);

1488

struct hci_dev *hdev;

1491

struct hci_dev *hdev;

1489

1492

1490

BT_DBG("intf %p", intf);

1493

BT_DBG("intf %p", intf);

1491

1494

1492

if (!data)

1495

if (!data)

1493

return;

1496

return;

1494

1497

1495

hdev = data->hdev;

1498

hdev = data->hdev;

1496

usb_set_intfdata(data->intf, NULL);

1499

usb_set_intfdata(data->intf, NULL);

1497

1500

1498

if (data->isoc)

1501

if (data->isoc)

1499

usb_set_intfdata(data->isoc, NULL);

1502

usb_set_intfdata(data->isoc, NULL);

1500

1503

1501

hci_unregister_dev(hdev);

1504

hci_unregister_dev(hdev);

1502

1505

1503

if (intf == data->isoc)

1506

if (intf == data->isoc)

1504

usb_driver_release_interface(&btusb_driver, data->intf);

1507

usb_driver_release_interface(&btusb_driver, data->intf);

1505

else if (data->isoc)

1508

else if (data->isoc)

1506

usb_driver_release_interface(&btusb_driver, data->isoc);

1509

usb_driver_release_interface(&btusb_driver, data->isoc);

1507

1510

1508

hci_free_dev(hdev);

1511

hci_free_dev(hdev);

1509

}

1512

}

1510

1513

1511

#ifdef CONFIG_PM

1514

#ifdef CONFIG_PM

1512

static int btusb_suspend(struct usb_interface *intf, pm_message_t message)

1515

static int btusb_suspend(struct usb_interface *intf, pm_message_t message)

1513

{

1516

{

1514

struct btusb_data *data = usb_get_intfdata(intf);

1517

struct btusb_data *data = usb_get_intfdata(intf);

1515

1518

1516

BT_DBG("intf %p", intf);

1519

BT_DBG("intf %p", intf);

1517

1520

1518

if (data->suspend_count++)

1521

if (data->suspend_count++)

1519

return 0;

1522

return 0;

1520

1523

1521

spin_lock_irq(&data->txlock);

1524

spin_lock_irq(&data->txlock);

1522

if (!(PMSG_IS_AUTO(message) && data->tx_in_flight)) {

1525

if (!(PMSG_IS_AUTO(message) && data->tx_in_flight)) {

1523

set_bit(BTUSB_SUSPENDING, &data->flags);

1526

set_bit(BTUSB_SUSPENDING, &data->flags);

1524

spin_unlock_irq(&data->txlock);

1527

spin_unlock_irq(&data->txlock);

1525

} else {

1528

} else {

1526

spin_unlock_irq(&data->txlock);

1529

spin_unlock_irq(&data->txlock);

1527

data->suspend_count--;

1530

data->suspend_count--;

1528

return -EBUSY;

1531

return -EBUSY;

1529

}

1532

}

1530

1533

1531

cancel_work_sync(&data->work);

1534

cancel_work_sync(&data->work);

1532

1535

1533

btusb_stop_traffic(data);

1536

btusb_stop_traffic(data);

1534

usb_kill_anchored_urbs(&data->tx_anchor);

1537

usb_kill_anchored_urbs(&data->tx_anchor);

1535

1538

1536

return 0;

1539

return 0;

1537

}

1540

}

1538

1541

1539

static void play_deferred(struct btusb_data *data)

1542

static void play_deferred(struct btusb_data *data)

1540

{

1543

{

1541

struct urb *urb;

1544

struct urb *urb;

1542

int err;

1545

int err;

1543

1546

1544

while ((urb = usb_get_from_anchor(&data->deferred))) {

1547

while ((urb = usb_get_from_anchor(&data->deferred))) {

1545

err = usb_submit_urb(urb, GFP_ATOMIC);

1548

err = usb_submit_urb(urb, GFP_ATOMIC);

1546

if (err < 0)

1549

if (err < 0)

1547

break;

1550

break;

1548

1551

1549

data->tx_in_flight++;

1552

data->tx_in_flight++;

1550

}

1553

}

1551

usb_scuttle_anchored_urbs(&data->deferred);

1554

usb_scuttle_anchored_urbs(&data->deferred);

1552

}

1555

}

1553

1556

1554

static int btusb_resume(struct usb_interface *intf)

1557

static int btusb_resume(struct usb_interface *intf)

1555

{

1558

{

1556

struct btusb_data *data = usb_get_intfdata(intf);

1559

struct btusb_data *data = usb_get_intfdata(intf);

1557

struct hci_dev *hdev = data->hdev;

1560

struct hci_dev *hdev = data->hdev;

1558

int err = 0;

1561

int err = 0;

1559

1562

1560

BT_DBG("intf %p", intf);

1563

BT_DBG("intf %p", intf);

1561

1564

1562

if (--data->suspend_count)

1565

if (--data->suspend_count)

1563

return 0;

1566

return 0;

1564

1567

1565

if (!test_bit(HCI_RUNNING, &hdev->flags))

1568

if (!test_bit(HCI_RUNNING, &hdev->flags))

1566

goto done;

1569

goto done;

1567

1570

1568

if (test_bit(BTUSB_INTR_RUNNING, &data->flags)) {

1571

if (test_bit(BTUSB_INTR_RUNNING, &data->flags)) {

1569

err = btusb_submit_intr_urb(hdev, GFP_NOIO);

1572

err = btusb_submit_intr_urb(hdev, GFP_NOIO);

1570

if (err < 0) {

1573

if (err < 0) {

1571

clear_bit(BTUSB_INTR_RUNNING, &data->flags);

1574

clear_bit(BTUSB_INTR_RUNNING, &data->flags);

1572

goto failed;

1575

goto failed;

1573

}

1576

}

1574

}

1577

}

1575

1578

1576

if (test_bit(BTUSB_BULK_RUNNING, &data->flags)) {

1579

if (test_bit(BTUSB_BULK_RUNNING, &data->flags)) {

1577

err = btusb_submit_bulk_urb(hdev, GFP_NOIO);

1580

err = btusb_submit_bulk_urb(hdev, GFP_NOIO);

1578

if (err < 0) {

1581

if (err < 0) {

1579

clear_bit(BTUSB_BULK_RUNNING, &data->flags);

1582

clear_bit(BTUSB_BULK_RUNNING, &data->flags);

1580

goto failed;

1583

goto failed;

1581

}

1584

}

1582

1585

1583

btusb_submit_bulk_urb(hdev, GFP_NOIO);

1586

btusb_submit_bulk_urb(hdev, GFP_NOIO);

1584

}

1587

}

1585

1588

1586

if (test_bit(BTUSB_ISOC_RUNNING, &data->flags)) {

1589

if (test_bit(BTUSB_ISOC_RUNNING, &data->flags)) {

1587

if (btusb_submit_isoc_urb(hdev, GFP_NOIO) < 0)

1590

if (btusb_submit_isoc_urb(hdev, GFP_NOIO) < 0)

1588

clear_bit(BTUSB_ISOC_RUNNING, &data->flags);

1591

clear_bit(BTUSB_ISOC_RUNNING, &data->flags);

1589

else

1592

else

1590

btusb_submit_isoc_urb(hdev, GFP_NOIO);

1593

btusb_submit_isoc_urb(hdev, GFP_NOIO);

1591

}

1594

}

1592

1595

1593

spin_lock_irq(&data->txlock);

1596

spin_lock_irq(&data->txlock);

1594

play_deferred(data);

1597

play_deferred(data);

1595

clear_bit(BTUSB_SUSPENDING, &data->flags);

1598

clear_bit(BTUSB_SUSPENDING, &data->flags);

1596

spin_unlock_irq(&data->txlock);

1599

spin_unlock_irq(&data->txlock);

1597

schedule_work(&data->work);

1600

schedule_work(&data->work);

1598

1601

1599

return 0;

1602

return 0;

1600

1603

1601

failed:

1604

failed:

1602

usb_scuttle_anchored_urbs(&data->deferred);

1605

usb_scuttle_anchored_urbs(&data->deferred);

1603

done:

1606

done:

1604

spin_lock_irq(&data->txlock);

1607

spin_lock_irq(&data->txlock);

1605

clear_bit(BTUSB_SUSPENDING, &data->flags);

1608

clear_bit(BTUSB_SUSPENDING, &data->flags);

1606

spin_unlock_irq(&data->txlock);

1609

spin_unlock_irq(&data->txlock);

1607

1610

1608

return err;

1611

return err;

1609

}

1612

}

1610

#endif

1613

#endif

1611

1614

1612

static struct usb_driver btusb_driver = {

1615

static struct usb_driver btusb_driver = {

1613

.name = "btusb",

1616

.name = "btusb",

1614

.probe = btusb_probe,

1617

.probe = btusb_probe,

1615

.disconnect = btusb_disconnect,

1618

.disconnect = btusb_disconnect,

1616

#ifdef CONFIG_PM

1619

#ifdef CONFIG_PM

1617

.suspend = btusb_suspend,

1620

.suspend = btusb_suspend,

1618

.resume = btusb_resume,

1621

.resume = btusb_resume,

1619

#endif

1622

#endif

1620

.id_table = btusb_table,

1623

.id_table = btusb_table,

1621

.supports_autosuspend = 1,

1624

.supports_autosuspend = 1,

1622

.disable_hub_initiated_lpm = 1,

1625

.disable_hub_initiated_lpm = 1,

1623

};

1626

};

1624

1627

1625

module_usb_driver(btusb_driver);

1628

module_usb_driver(btusb_driver);

1626

1629

1627

module_param(ignore_dga, bool, 0644);

1630

module_param(ignore_dga, bool, 0644);

1628

MODULE_PARM_DESC(ignore_dga, "Ignore devices with id 08fd:0001");

1631

MODULE_PARM_DESC(ignore_dga, "Ignore devices with id 08fd:0001");

1629

1632

1630

module_param(ignore_csr, bool, 0644);

1633

module_param(ignore_csr, bool, 0644);

1631

MODULE_PARM_DESC(ignore_csr, "Ignore devices with id 0a12:0001");

1634

MODULE_PARM_DESC(ignore_csr, "Ignore devices with id 0a12:0001");

1632

1635

1633

module_param(ignore_sniffer, bool, 0644);

1636

module_param(ignore_sniffer, bool, 0644);

1634

MODULE_PARM_DESC(ignore_sniffer, "Ignore devices with id 0a12:0002");

1637

MODULE_PARM_DESC(ignore_sniffer, "Ignore devices with id 0a12:0002");

1635

1638

1636

module_param(disable_scofix, bool, 0644);

1639

module_param(disable_scofix, bool, 0644);

1637

MODULE_PARM_DESC(disable_scofix, "Disable fixup of wrong SCO buffer size");

1640

MODULE_PARM_DESC(disable_scofix, "Disable fixup of wrong SCO buffer size");

1638

1641

1639

module_param(force_scofix, bool, 0644);

1642

module_param(force_scofix, bool, 0644);

1640

MODULE_PARM_DESC(force_scofix, "Force fixup of wrong SCO buffers size");

1643

MODULE_PARM_DESC(force_scofix, "Force fixup of wrong SCO buffers size");

1641

1644

1642

module_param(reset, bool, 0644);

1645

module_param(reset, bool, 0644);

1643

MODULE_PARM_DESC(reset, "Send HCI reset command on initialization");

1646

MODULE_PARM_DESC(reset, "Send HCI reset command on initialization");

1644

1647

1645

MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");

1648

MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");

1646

MODULE_DESCRIPTION("Generic Bluetooth USB driver ver " VERSION);

1649

MODULE_DESCRIPTION("Generic Bluetooth USB driver ver " VERSION);

1647

MODULE_VERSION(VERSION);

1650

MODULE_VERSION(VERSION);

1648

MODULE_LICENSE("GPL");

1651

MODULE_LICENSE("GPL");

1649

1652

GITLAB

Bluetooth: Add support for Mediatek Bluetooth device [0e8d:763f]

 /*
  *
  *  Generic Bluetooth USB driver
  *
  *  Copyright (C) 2005-2008  Marcel Holtmann <marcel@holtmann.org>
  *
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  *
  */
 #include <linux/module.h>
 #include <linux/usb.h>
 #include <linux/firmware.h>
 #include <net/bluetooth/bluetooth.h>
 #include <net/bluetooth/hci_core.h>
 #define VERSION "0.6"
 static bool ignore_dga;
 static bool ignore_csr;
 static bool ignore_sniffer;
 static bool disable_scofix;
 static bool force_scofix;
 static bool reset = 1;
 static struct usb_driver btusb_driver;
 #define BTUSB_IGNORE		0x01
 #define BTUSB_DIGIANSWER	0x02
 #define BTUSB_CSR		0x04
 #define BTUSB_SNIFFER		0x08
 #define BTUSB_BCM92035		0x10
 #define BTUSB_BROKEN_ISOC	0x20
 #define BTUSB_WRONG_SCO_MTU	0x40
 #define BTUSB_ATH3012		0x80
 #define BTUSB_INTEL		0x100
 static struct usb_device_id btusb_table[] = {
 	/* Generic Bluetooth USB device */
 	{ USB_DEVICE_INFO(0xe0, 0x01, 0x01) },
 	/* Apple-specific (Broadcom) devices */
 	{ USB_VENDOR_AND_INTERFACE_INFO(0x05ac, 0xff, 0x01, 0x01) },
+	/* MediaTek MT76x0E */
+	{ USB_DEVICE(0x0e8d, 0x763f) },
 	/* Broadcom SoftSailing reporting vendor specific */
 	{ USB_DEVICE(0x0a5c, 0x21e1) },
 	/* Apple MacBookPro 7,1 */
 	{ USB_DEVICE(0x05ac, 0x8213) },
 	/* Apple iMac11,1 */
 	{ USB_DEVICE(0x05ac, 0x8215) },
 	/* Apple MacBookPro6,2 */
 	{ USB_DEVICE(0x05ac, 0x8218) },
 	/* Apple MacBookAir3,1, MacBookAir3,2 */
 	{ USB_DEVICE(0x05ac, 0x821b) },
 	/* Apple MacBookAir4,1 */
 	{ USB_DEVICE(0x05ac, 0x821f) },
 	/* Apple MacBookPro8,2 */
 	{ USB_DEVICE(0x05ac, 0x821a) },
 	/* Apple MacMini5,1 */
 	{ USB_DEVICE(0x05ac, 0x8281) },
 	/* AVM BlueFRITZ! USB v2.0 */
 	{ USB_DEVICE(0x057c, 0x3800) },
 	/* Bluetooth Ultraport Module from IBM */
 	{ USB_DEVICE(0x04bf, 0x030a) },
 	/* ALPS Modules with non-standard id */
 	{ USB_DEVICE(0x044e, 0x3001) },
 	{ USB_DEVICE(0x044e, 0x3002) },
 	/* Ericsson with non-standard id */
 	{ USB_DEVICE(0x0bdb, 0x1002) },
 	/* Canyon CN-BTU1 with HID interfaces */
 	{ USB_DEVICE(0x0c10, 0x0000) },
 	/* Broadcom BCM20702A0 */
 	{ USB_DEVICE(0x0b05, 0x17b5) },
 	{ USB_DEVICE(0x04ca, 0x2003) },
 	{ USB_DEVICE(0x0489, 0xe042) },
 	{ USB_DEVICE(0x413c, 0x8197) },
 	/* Foxconn - Hon Hai */
 	{ USB_VENDOR_AND_INTERFACE_INFO(0x0489, 0xff, 0x01, 0x01) },
 	/*Broadcom devices with vendor specific id */
 	{ USB_VENDOR_AND_INTERFACE_INFO(0x0a5c, 0xff, 0x01, 0x01) },
 	{ }	/* Terminating entry */
 };
 MODULE_DEVICE_TABLE(usb, btusb_table);
 static struct usb_device_id blacklist_table[] = {
 	/* CSR BlueCore devices */
 	{ USB_DEVICE(0x0a12, 0x0001), .driver_info = BTUSB_CSR },
 	/* Broadcom BCM2033 without firmware */
 	{ USB_DEVICE(0x0a5c, 0x2033), .driver_info = BTUSB_IGNORE },
 	/* Atheros 3011 with sflash firmware */
 	{ USB_DEVICE(0x0cf3, 0x3002), .driver_info = BTUSB_IGNORE },
 	{ USB_DEVICE(0x0cf3, 0xe019), .driver_info = BTUSB_IGNORE },
 	{ USB_DEVICE(0x13d3, 0x3304), .driver_info = BTUSB_IGNORE },
 	{ USB_DEVICE(0x0930, 0x0215), .driver_info = BTUSB_IGNORE },
 	{ USB_DEVICE(0x0489, 0xe03d), .driver_info = BTUSB_IGNORE },
 	{ USB_DEVICE(0x0489, 0xe027), .driver_info = BTUSB_IGNORE },
 	/* Atheros AR9285 Malbec with sflash firmware */
 	{ USB_DEVICE(0x03f0, 0x311d), .driver_info = BTUSB_IGNORE },
 	/* Atheros 3012 with sflash firmware */
 	{ USB_DEVICE(0x0cf3, 0x0036), .driver_info = BTUSB_ATH3012 },
 	{ USB_DEVICE(0x0cf3, 0x3004), .driver_info = BTUSB_ATH3012 },
 	{ USB_DEVICE(0x0cf3, 0x3008), .driver_info = BTUSB_ATH3012 },
 	{ USB_DEVICE(0x0cf3, 0x311d), .driver_info = BTUSB_ATH3012 },
 	{ USB_DEVICE(0x0cf3, 0x817a), .driver_info = BTUSB_ATH3012 },
 	{ USB_DEVICE(0x13d3, 0x3375), .driver_info = BTUSB_ATH3012 },
 	{ USB_DEVICE(0x04ca, 0x3004), .driver_info = BTUSB_ATH3012 },
 	{ USB_DEVICE(0x04ca, 0x3005), .driver_info = BTUSB_ATH3012 },
 	{ USB_DEVICE(0x04ca, 0x3006), .driver_info = BTUSB_ATH3012 },
 	{ USB_DEVICE(0x04ca, 0x3008), .driver_info = BTUSB_ATH3012 },
 	{ USB_DEVICE(0x13d3, 0x3362), .driver_info = BTUSB_ATH3012 },
 	{ USB_DEVICE(0x0cf3, 0xe004), .driver_info = BTUSB_ATH3012 },
 	{ USB_DEVICE(0x0930, 0x0219), .driver_info = BTUSB_ATH3012 },
 	{ USB_DEVICE(0x0489, 0xe057), .driver_info = BTUSB_ATH3012 },
 	{ USB_DEVICE(0x13d3, 0x3393), .driver_info = BTUSB_ATH3012 },
 	{ USB_DEVICE(0x0489, 0xe04e), .driver_info = BTUSB_ATH3012 },
 	{ USB_DEVICE(0x0489, 0xe056), .driver_info = BTUSB_ATH3012 },
 	{ USB_DEVICE(0x0489, 0xe04d), .driver_info = BTUSB_ATH3012 },
 	/* Atheros AR5BBU12 with sflash firmware */
 	{ USB_DEVICE(0x0489, 0xe02c), .driver_info = BTUSB_IGNORE },
 	/* Atheros AR5BBU12 with sflash firmware */
 	{ USB_DEVICE(0x0489, 0xe03c), .driver_info = BTUSB_ATH3012 },
 	{ USB_DEVICE(0x0489, 0xe036), .driver_info = BTUSB_ATH3012 },
 	/* Broadcom BCM2035 */
 	{ USB_DEVICE(0x0a5c, 0x2035), .driver_info = BTUSB_WRONG_SCO_MTU },
 	{ USB_DEVICE(0x0a5c, 0x200a), .driver_info = BTUSB_WRONG_SCO_MTU },
 	{ USB_DEVICE(0x0a5c, 0x2009), .driver_info = BTUSB_BCM92035 },
 	/* Broadcom BCM2045 */
 	{ USB_DEVICE(0x0a5c, 0x2039), .driver_info = BTUSB_WRONG_SCO_MTU },
 	{ USB_DEVICE(0x0a5c, 0x2101), .driver_info = BTUSB_WRONG_SCO_MTU },
 	/* IBM/Lenovo ThinkPad with Broadcom chip */
 	{ USB_DEVICE(0x0a5c, 0x201e), .driver_info = BTUSB_WRONG_SCO_MTU },
 	{ USB_DEVICE(0x0a5c, 0x2110), .driver_info = BTUSB_WRONG_SCO_MTU },
 	/* HP laptop with Broadcom chip */
 	{ USB_DEVICE(0x03f0, 0x171d), .driver_info = BTUSB_WRONG_SCO_MTU },
 	/* Dell laptop with Broadcom chip */
 	{ USB_DEVICE(0x413c, 0x8126), .driver_info = BTUSB_WRONG_SCO_MTU },
 	/* Dell Wireless 370 and 410 devices */
 	{ USB_DEVICE(0x413c, 0x8152), .driver_info = BTUSB_WRONG_SCO_MTU },
 	{ USB_DEVICE(0x413c, 0x8156), .driver_info = BTUSB_WRONG_SCO_MTU },
 	/* Belkin F8T012 and F8T013 devices */
 	{ USB_DEVICE(0x050d, 0x0012), .driver_info = BTUSB_WRONG_SCO_MTU },
 	{ USB_DEVICE(0x050d, 0x0013), .driver_info = BTUSB_WRONG_SCO_MTU },
 	/* Asus WL-BTD202 device */
 	{ USB_DEVICE(0x0b05, 0x1715), .driver_info = BTUSB_WRONG_SCO_MTU },
 	/* Kensington Bluetooth USB adapter */
 	{ USB_DEVICE(0x047d, 0x105e), .driver_info = BTUSB_WRONG_SCO_MTU },
 	/* RTX Telecom based adapters with buggy SCO support */
 	{ USB_DEVICE(0x0400, 0x0807), .driver_info = BTUSB_BROKEN_ISOC },
 	{ USB_DEVICE(0x0400, 0x080a), .driver_info = BTUSB_BROKEN_ISOC },
 	/* CONWISE Technology based adapters with buggy SCO support */
 	{ USB_DEVICE(0x0e5e, 0x6622), .driver_info = BTUSB_BROKEN_ISOC },
 	/* Digianswer devices */
 	{ USB_DEVICE(0x08fd, 0x0001), .driver_info = BTUSB_DIGIANSWER },
 	{ USB_DEVICE(0x08fd, 0x0002), .driver_info = BTUSB_IGNORE },
 	/* CSR BlueCore Bluetooth Sniffer */
 	{ USB_DEVICE(0x0a12, 0x0002), .driver_info = BTUSB_SNIFFER },
 	/* Frontline ComProbe Bluetooth Sniffer */
 	{ USB_DEVICE(0x16d3, 0x0002), .driver_info = BTUSB_SNIFFER },
 	/* Intel Bluetooth device */
 	{ USB_DEVICE(0x8087, 0x07dc), .driver_info = BTUSB_INTEL },
 	{ }	/* Terminating entry */
 };
 #define BTUSB_MAX_ISOC_FRAMES	10
 #define BTUSB_INTR_RUNNING	0
 #define BTUSB_BULK_RUNNING	1
 #define BTUSB_ISOC_RUNNING	2
 #define BTUSB_SUSPENDING	3
 #define BTUSB_DID_ISO_RESUME	4
 struct btusb_data {
 	struct hci_dev       *hdev;
 	struct usb_device    *udev;
 	struct usb_interface *intf;
 	struct usb_interface *isoc;
 	spinlock_t lock;
 	unsigned long flags;
 	struct work_struct work;
 	struct work_struct waker;
 	struct usb_anchor tx_anchor;
 	struct usb_anchor intr_anchor;
 	struct usb_anchor bulk_anchor;
 	struct usb_anchor isoc_anchor;
 	struct usb_anchor deferred;
 	int tx_in_flight;
 	spinlock_t txlock;
 	struct usb_endpoint_descriptor *intr_ep;
 	struct usb_endpoint_descriptor *bulk_tx_ep;
 	struct usb_endpoint_descriptor *bulk_rx_ep;
 	struct usb_endpoint_descriptor *isoc_tx_ep;
 	struct usb_endpoint_descriptor *isoc_rx_ep;
 	__u8 cmdreq_type;
 	unsigned int sco_num;
 	int isoc_altsetting;
 	int suspend_count;
 };
 static int inc_tx(struct btusb_data *data)
 {
 	unsigned long flags;
 	int rv;
 	spin_lock_irqsave(&data->txlock, flags);
 	rv = test_bit(BTUSB_SUSPENDING, &data->flags);
 	if (!rv)
 		data->tx_in_flight++;
 	spin_unlock_irqrestore(&data->txlock, flags);
 	return rv;
 }
 static void btusb_intr_complete(struct urb *urb)
 {
 	struct hci_dev *hdev = urb->context;
 	struct btusb_data *data = hci_get_drvdata(hdev);
 	int err;
 	BT_DBG("%s urb %p status %d count %d", hdev->name,
 					urb, urb->status, urb->actual_length);
 	if (!test_bit(HCI_RUNNING, &hdev->flags))
 		return;
 	if (urb->status == 0) {
 		hdev->stat.byte_rx += urb->actual_length;
 		if (hci_recv_fragment(hdev, HCI_EVENT_PKT,
 						urb->transfer_buffer,
 						urb->actual_length) < 0) {
 			BT_ERR("%s corrupted event packet", hdev->name);
 			hdev->stat.err_rx++;
 		}
 	}
 	if (!test_bit(BTUSB_INTR_RUNNING, &data->flags))
 		return;
 	usb_mark_last_busy(data->udev);
 	usb_anchor_urb(urb, &data->intr_anchor);
 	err = usb_submit_urb(urb, GFP_ATOMIC);
 	if (err < 0) {
 		/* -EPERM: urb is being killed;
 		 * -ENODEV: device got disconnected */
 		if (err != -EPERM && err != -ENODEV)
 			BT_ERR("%s urb %p failed to resubmit (%d)",
 						hdev->name, urb, -err);
 		usb_unanchor_urb(urb);
 	}
 }
 static int btusb_submit_intr_urb(struct hci_dev *hdev, gfp_t mem_flags)
 {
 	struct btusb_data *data = hci_get_drvdata(hdev);
 	struct urb *urb;
 	unsigned char *buf;
 	unsigned int pipe;
 	int err, size;
 	BT_DBG("%s", hdev->name);
 	if (!data->intr_ep)
 		return -ENODEV;
 	urb = usb_alloc_urb(0, mem_flags);
 	if (!urb)
 		return -ENOMEM;
 	size = le16_to_cpu(data->intr_ep->wMaxPacketSize);
 	buf = kmalloc(size, mem_flags);
 	if (!buf) {
 		usb_free_urb(urb);
 		return -ENOMEM;
 	}
 	pipe = usb_rcvintpipe(data->udev, data->intr_ep->bEndpointAddress);
 	usb_fill_int_urb(urb, data->udev, pipe, buf, size,
 						btusb_intr_complete, hdev,
 						data->intr_ep->bInterval);
 	urb->transfer_flags |= URB_FREE_BUFFER;
 	usb_anchor_urb(urb, &data->intr_anchor);
 	err = usb_submit_urb(urb, mem_flags);
 	if (err < 0) {
 		if (err != -EPERM && err != -ENODEV)
 			BT_ERR("%s urb %p submission failed (%d)",
 						hdev->name, urb, -err);
 		usb_unanchor_urb(urb);
 	}
 	usb_free_urb(urb);
 	return err;
 }
 static void btusb_bulk_complete(struct urb *urb)
 {
 	struct hci_dev *hdev = urb->context;
 	struct btusb_data *data = hci_get_drvdata(hdev);
 	int err;
 	BT_DBG("%s urb %p status %d count %d", hdev->name,
 					urb, urb->status, urb->actual_length);
 	if (!test_bit(HCI_RUNNING, &hdev->flags))
 		return;
 	if (urb->status == 0) {
 		hdev->stat.byte_rx += urb->actual_length;
 		if (hci_recv_fragment(hdev, HCI_ACLDATA_PKT,
 						urb->transfer_buffer,
 						urb->actual_length) < 0) {
 			BT_ERR("%s corrupted ACL packet", hdev->name);
 			hdev->stat.err_rx++;
 		}
 	}
 	if (!test_bit(BTUSB_BULK_RUNNING, &data->flags))
 		return;
 	usb_anchor_urb(urb, &data->bulk_anchor);
 	usb_mark_last_busy(data->udev);
 	err = usb_submit_urb(urb, GFP_ATOMIC);
 	if (err < 0) {
 		/* -EPERM: urb is being killed;
 		 * -ENODEV: device got disconnected */
 		if (err != -EPERM && err != -ENODEV)
 			BT_ERR("%s urb %p failed to resubmit (%d)",
 						hdev->name, urb, -err);
 		usb_unanchor_urb(urb);
 	}
 }
 static int btusb_submit_bulk_urb(struct hci_dev *hdev, gfp_t mem_flags)
 {
 	struct btusb_data *data = hci_get_drvdata(hdev);
 	struct urb *urb;
 	unsigned char *buf;
 	unsigned int pipe;
 	int err, size = HCI_MAX_FRAME_SIZE;
 	BT_DBG("%s", hdev->name);
 	if (!data->bulk_rx_ep)
 		return -ENODEV;
 	urb = usb_alloc_urb(0, mem_flags);
 	if (!urb)
 		return -ENOMEM;
 	buf = kmalloc(size, mem_flags);
 	if (!buf) {
 		usb_free_urb(urb);
 		return -ENOMEM;
 	}
 	pipe = usb_rcvbulkpipe(data->udev, data->bulk_rx_ep->bEndpointAddress);
 	usb_fill_bulk_urb(urb, data->udev, pipe,
 					buf, size, btusb_bulk_complete, hdev);
 	urb->transfer_flags |= URB_FREE_BUFFER;
 	usb_mark_last_busy(data->udev);
 	usb_anchor_urb(urb, &data->bulk_anchor);
 	err = usb_submit_urb(urb, mem_flags);
 	if (err < 0) {
 		if (err != -EPERM && err != -ENODEV)
 			BT_ERR("%s urb %p submission failed (%d)",
 						hdev->name, urb, -err);
 		usb_unanchor_urb(urb);
 	}
 	usb_free_urb(urb);
 	return err;
 }
 static void btusb_isoc_complete(struct urb *urb)
 {
 	struct hci_dev *hdev = urb->context;
 	struct btusb_data *data = hci_get_drvdata(hdev);
 	int i, err;
 	BT_DBG("%s urb %p status %d count %d", hdev->name,
 					urb, urb->status, urb->actual_length);
 	if (!test_bit(HCI_RUNNING, &hdev->flags))
 		return;
 	if (urb->status == 0) {
 		for (i = 0; i < urb->number_of_packets; i++) {
 			unsigned int offset = urb->iso_frame_desc[i].offset;
 			unsigned int length = urb->iso_frame_desc[i].actual_length;
 			if (urb->iso_frame_desc[i].status)
 				continue;
 			hdev->stat.byte_rx += length;
 			if (hci_recv_fragment(hdev, HCI_SCODATA_PKT,
 						urb->transfer_buffer + offset,
 								length) < 0) {
 				BT_ERR("%s corrupted SCO packet", hdev->name);
 				hdev->stat.err_rx++;
 			}
 		}
 	}
 	if (!test_bit(BTUSB_ISOC_RUNNING, &data->flags))
 		return;
 	usb_anchor_urb(urb, &data->isoc_anchor);
 	err = usb_submit_urb(urb, GFP_ATOMIC);
 	if (err < 0) {
 		/* -EPERM: urb is being killed;
 		 * -ENODEV: device got disconnected */
 		if (err != -EPERM && err != -ENODEV)
 			BT_ERR("%s urb %p failed to resubmit (%d)",
 						hdev->name, urb, -err);
 		usb_unanchor_urb(urb);
 	}
 }
 static inline void __fill_isoc_descriptor(struct urb *urb, int len, int mtu)
 {
 	int i, offset = 0;
 	BT_DBG("len %d mtu %d", len, mtu);
 	for (i = 0; i < BTUSB_MAX_ISOC_FRAMES && len >= mtu;
 					i++, offset += mtu, len -= mtu) {
 		urb->iso_frame_desc[i].offset = offset;
 		urb->iso_frame_desc[i].length = mtu;
 	}
 	if (len && i < BTUSB_MAX_ISOC_FRAMES) {
 		urb->iso_frame_desc[i].offset = offset;
 		urb->iso_frame_desc[i].length = len;
 		i++;
 	}
 	urb->number_of_packets = i;
 }
 static int btusb_submit_isoc_urb(struct hci_dev *hdev, gfp_t mem_flags)
 {
 	struct btusb_data *data = hci_get_drvdata(hdev);
 	struct urb *urb;
 	unsigned char *buf;
 	unsigned int pipe;
 	int err, size;
 	BT_DBG("%s", hdev->name);
 	if (!data->isoc_rx_ep)
 		return -ENODEV;
 	urb = usb_alloc_urb(BTUSB_MAX_ISOC_FRAMES, mem_flags);
 	if (!urb)
 		return -ENOMEM;
 	size = le16_to_cpu(data->isoc_rx_ep->wMaxPacketSize) *
 						BTUSB_MAX_ISOC_FRAMES;
 	buf = kmalloc(size, mem_flags);
 	if (!buf) {
 		usb_free_urb(urb);
 		return -ENOMEM;
 	}
 	pipe = usb_rcvisocpipe(data->udev, data->isoc_rx_ep->bEndpointAddress);
 	usb_fill_int_urb(urb, data->udev, pipe, buf, size, btusb_isoc_complete,
 				hdev, data->isoc_rx_ep->bInterval);
 	urb->transfer_flags  = URB_FREE_BUFFER | URB_ISO_ASAP;
 	__fill_isoc_descriptor(urb, size,
 			le16_to_cpu(data->isoc_rx_ep->wMaxPacketSize));
 	usb_anchor_urb(urb, &data->isoc_anchor);
 	err = usb_submit_urb(urb, mem_flags);
 	if (err < 0) {
 		if (err != -EPERM && err != -ENODEV)
 			BT_ERR("%s urb %p submission failed (%d)",
 						hdev->name, urb, -err);
 		usb_unanchor_urb(urb);
 	}
 	usb_free_urb(urb);
 	return err;
 }
 static void btusb_tx_complete(struct urb *urb)
 {
 	struct sk_buff *skb = urb->context;
 	struct hci_dev *hdev = (struct hci_dev *) skb->dev;
 	struct btusb_data *data = hci_get_drvdata(hdev);
 	BT_DBG("%s urb %p status %d count %d", hdev->name,
 					urb, urb->status, urb->actual_length);
 	if (!test_bit(HCI_RUNNING, &hdev->flags))
 		goto done;
 	if (!urb->status)
 		hdev->stat.byte_tx += urb->transfer_buffer_length;
 	else
 		hdev->stat.err_tx++;
 done:
 	spin_lock(&data->txlock);
 	data->tx_in_flight--;
 	spin_unlock(&data->txlock);
 	kfree(urb->setup_packet);
 	kfree_skb(skb);
 }
 static void btusb_isoc_tx_complete(struct urb *urb)
 {
 	struct sk_buff *skb = urb->context;
 	struct hci_dev *hdev = (struct hci_dev *) skb->dev;
 	BT_DBG("%s urb %p status %d count %d", hdev->name,
 					urb, urb->status, urb->actual_length);
 	if (!test_bit(HCI_RUNNING, &hdev->flags))
 		goto done;
 	if (!urb->status)
 		hdev->stat.byte_tx += urb->transfer_buffer_length;
 	else
 		hdev->stat.err_tx++;
 done:
 	kfree(urb->setup_packet);
 	kfree_skb(skb);
 }
 static int btusb_open(struct hci_dev *hdev)
 {
 	struct btusb_data *data = hci_get_drvdata(hdev);
 	int err;
 	BT_DBG("%s", hdev->name);
 	err = usb_autopm_get_interface(data->intf);
 	if (err < 0)
 		return err;
 	data->intf->needs_remote_wakeup = 1;
 	if (test_and_set_bit(HCI_RUNNING, &hdev->flags))
 		goto done;
 	if (test_and_set_bit(BTUSB_INTR_RUNNING, &data->flags))
 		goto done;
 	err = btusb_submit_intr_urb(hdev, GFP_KERNEL);
 	if (err < 0)
 		goto failed;
 	err = btusb_submit_bulk_urb(hdev, GFP_KERNEL);
 	if (err < 0) {
 		usb_kill_anchored_urbs(&data->intr_anchor);
 		goto failed;
 	}
 	set_bit(BTUSB_BULK_RUNNING, &data->flags);
 	btusb_submit_bulk_urb(hdev, GFP_KERNEL);
 done:
 	usb_autopm_put_interface(data->intf);
 	return 0;
 failed:
 	clear_bit(BTUSB_INTR_RUNNING, &data->flags);
 	clear_bit(HCI_RUNNING, &hdev->flags);
 	usb_autopm_put_interface(data->intf);
 	return err;
 }
 static void btusb_stop_traffic(struct btusb_data *data)
 {
 	usb_kill_anchored_urbs(&data->intr_anchor);
 	usb_kill_anchored_urbs(&data->bulk_anchor);
 	usb_kill_anchored_urbs(&data->isoc_anchor);
 }
 static int btusb_close(struct hci_dev *hdev)
 {
 	struct btusb_data *data = hci_get_drvdata(hdev);
 	int err;
 	BT_DBG("%s", hdev->name);
 	if (!test_and_clear_bit(HCI_RUNNING, &hdev->flags))
 		return 0;
 	cancel_work_sync(&data->work);
 	cancel_work_sync(&data->waker);
 	clear_bit(BTUSB_ISOC_RUNNING, &data->flags);
 	clear_bit(BTUSB_BULK_RUNNING, &data->flags);
 	clear_bit(BTUSB_INTR_RUNNING, &data->flags);
 	btusb_stop_traffic(data);
 	err = usb_autopm_get_interface(data->intf);
 	if (err < 0)
 		goto failed;
 	data->intf->needs_remote_wakeup = 0;
 	usb_autopm_put_interface(data->intf);
 failed:
 	usb_scuttle_anchored_urbs(&data->deferred);
 	return 0;
 }
 static int btusb_flush(struct hci_dev *hdev)
 {
 	struct btusb_data *data = hci_get_drvdata(hdev);
 	BT_DBG("%s", hdev->name);
 	usb_kill_anchored_urbs(&data->tx_anchor);
 	return 0;
 }
 static int btusb_send_frame(struct sk_buff *skb)
 {
 	struct hci_dev *hdev = (struct hci_dev *) skb->dev;
 	struct btusb_data *data = hci_get_drvdata(hdev);
 	struct usb_ctrlrequest *dr;
 	struct urb *urb;
 	unsigned int pipe;
 	int err;
 	BT_DBG("%s", hdev->name);
 	if (!test_bit(HCI_RUNNING, &hdev->flags))
 		return -EBUSY;
 	switch (bt_cb(skb)->pkt_type) {
 	case HCI_COMMAND_PKT:
 		urb = usb_alloc_urb(0, GFP_ATOMIC);
 		if (!urb)
 			return -ENOMEM;
 		dr = kmalloc(sizeof(*dr), GFP_ATOMIC);
 		if (!dr) {
 			usb_free_urb(urb);
 			return -ENOMEM;
 		}
 		dr->bRequestType = data->cmdreq_type;
 		dr->bRequest     = 0;
 		dr->wIndex       = 0;
 		dr->wValue       = 0;
 		dr->wLength      = __cpu_to_le16(skb->len);
 		pipe = usb_sndctrlpipe(data->udev, 0x00);
 		usb_fill_control_urb(urb, data->udev, pipe, (void *) dr,
 				skb->data, skb->len, btusb_tx_complete, skb);
 		hdev->stat.cmd_tx++;
 		break;
 	case HCI_ACLDATA_PKT:
 		if (!data->bulk_tx_ep)
 			return -ENODEV;
 		urb = usb_alloc_urb(0, GFP_ATOMIC);
 		if (!urb)
 			return -ENOMEM;
 		pipe = usb_sndbulkpipe(data->udev,
 					data->bulk_tx_ep->bEndpointAddress);
 		usb_fill_bulk_urb(urb, data->udev, pipe,
 				skb->data, skb->len, btusb_tx_complete, skb);
 		hdev->stat.acl_tx++;
 		break;
 	case HCI_SCODATA_PKT:
 		if (!data->isoc_tx_ep || hdev->conn_hash.sco_num < 1)
 			return -ENODEV;
 		urb = usb_alloc_urb(BTUSB_MAX_ISOC_FRAMES, GFP_ATOMIC);
 		if (!urb)
 			return -ENOMEM;
 		pipe = usb_sndisocpipe(data->udev,
 					data->isoc_tx_ep->bEndpointAddress);
 		usb_fill_int_urb(urb, data->udev, pipe,
 				skb->data, skb->len, btusb_isoc_tx_complete,
 				skb, data->isoc_tx_ep->bInterval);
 		urb->transfer_flags  = URB_ISO_ASAP;
 		__fill_isoc_descriptor(urb, skb->len,
 				le16_to_cpu(data->isoc_tx_ep->wMaxPacketSize));
 		hdev->stat.sco_tx++;
 		goto skip_waking;
 	default:
 		return -EILSEQ;
 	}
 	err = inc_tx(data);
 	if (err) {
 		usb_anchor_urb(urb, &data->deferred);
 		schedule_work(&data->waker);
 		err = 0;
 		goto done;
 	}
 skip_waking:
 	usb_anchor_urb(urb, &data->tx_anchor);
 	err = usb_submit_urb(urb, GFP_ATOMIC);
 	if (err < 0) {
 		if (err != -EPERM && err != -ENODEV)
 			BT_ERR("%s urb %p submission failed (%d)",
 						hdev->name, urb, -err);
 		kfree(urb->setup_packet);
 		usb_unanchor_urb(urb);
 	} else {
 		usb_mark_last_busy(data->udev);
 	}
 done:
 	usb_free_urb(urb);
 	return err;
 }
 static void btusb_notify(struct hci_dev *hdev, unsigned int evt)
 {
 	struct btusb_data *data = hci_get_drvdata(hdev);
 	BT_DBG("%s evt %d", hdev->name, evt);
 	if (hdev->conn_hash.sco_num != data->sco_num) {
 		data->sco_num = hdev->conn_hash.sco_num;
 		schedule_work(&data->work);
 	}
 }
 static inline int __set_isoc_interface(struct hci_dev *hdev, int altsetting)
 {
 	struct btusb_data *data = hci_get_drvdata(hdev);
 	struct usb_interface *intf = data->isoc;
 	struct usb_endpoint_descriptor *ep_desc;
 	int i, err;
 	if (!data->isoc)
 		return -ENODEV;
 	err = usb_set_interface(data->udev, 1, altsetting);
 	if (err < 0) {
 		BT_ERR("%s setting interface failed (%d)", hdev->name, -err);
 		return err;
 	}
 	data->isoc_altsetting = altsetting;
 	data->isoc_tx_ep = NULL;
 	data->isoc_rx_ep = NULL;
 	for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++) {
 		ep_desc = &intf->cur_altsetting->endpoint[i].desc;
 		if (!data->isoc_tx_ep && usb_endpoint_is_isoc_out(ep_desc)) {
 			data->isoc_tx_ep = ep_desc;
 			continue;
 		}
 		if (!data->isoc_rx_ep && usb_endpoint_is_isoc_in(ep_desc)) {
 			data->isoc_rx_ep = ep_desc;
 			continue;
 		}
 	}
 	if (!data->isoc_tx_ep || !data->isoc_rx_ep) {
 		BT_ERR("%s invalid SCO descriptors", hdev->name);
 		return -ENODEV;
 	}
 	return 0;
 }
 static void btusb_work(struct work_struct *work)
 {
 	struct btusb_data *data = container_of(work, struct btusb_data, work);
 	struct hci_dev *hdev = data->hdev;
 	int new_alts;
 	int err;
 	if (hdev->conn_hash.sco_num > 0) {
 		if (!test_bit(BTUSB_DID_ISO_RESUME, &data->flags)) {
 			err = usb_autopm_get_interface(data->isoc ? data->isoc : data->intf);
 			if (err < 0) {
 				clear_bit(BTUSB_ISOC_RUNNING, &data->flags);
 				usb_kill_anchored_urbs(&data->isoc_anchor);
 				return;
 			}
 			set_bit(BTUSB_DID_ISO_RESUME, &data->flags);
 		}
 		if (hdev->voice_setting & 0x0020) {
 			static const int alts[3] = { 2, 4, 5 };
 			new_alts = alts[hdev->conn_hash.sco_num - 1];
 		} else {
 			new_alts = hdev->conn_hash.sco_num;
 		}
 		if (data->isoc_altsetting != new_alts) {
 			clear_bit(BTUSB_ISOC_RUNNING, &data->flags);
 			usb_kill_anchored_urbs(&data->isoc_anchor);
 			if (__set_isoc_interface(hdev, new_alts) < 0)
 				return;
 		}
 		if (!test_and_set_bit(BTUSB_ISOC_RUNNING, &data->flags)) {
 			if (btusb_submit_isoc_urb(hdev, GFP_KERNEL) < 0)
 				clear_bit(BTUSB_ISOC_RUNNING, &data->flags);
 			else
 				btusb_submit_isoc_urb(hdev, GFP_KERNEL);
 		}
 	} else {
 		clear_bit(BTUSB_ISOC_RUNNING, &data->flags);
 		usb_kill_anchored_urbs(&data->isoc_anchor);
 		__set_isoc_interface(hdev, 0);
 		if (test_and_clear_bit(BTUSB_DID_ISO_RESUME, &data->flags))
 			usb_autopm_put_interface(data->isoc ? data->isoc : data->intf);
 	}
 }
 static void btusb_waker(struct work_struct *work)
 {
 	struct btusb_data *data = container_of(work, struct btusb_data, waker);
 	int err;
 	err = usb_autopm_get_interface(data->intf);
 	if (err < 0)
 		return;
 	usb_autopm_put_interface(data->intf);
 }
 static int btusb_setup_bcm92035(struct hci_dev *hdev)
 {
 	struct sk_buff *skb;
 	u8 val = 0x00;
 	BT_DBG("%s", hdev->name);
 	skb = __hci_cmd_sync(hdev, 0xfc3b, 1, &val, HCI_INIT_TIMEOUT);
 	if (IS_ERR(skb))
 		BT_ERR("BCM92035 command failed (%ld)", -PTR_ERR(skb));
 	else
 		kfree_skb(skb);
 	return 0;
 }
 struct intel_version {
 	u8 status;
 	u8 hw_platform;
 	u8 hw_variant;
 	u8 hw_revision;
 	u8 fw_variant;
 	u8 fw_revision;
 	u8 fw_build_num;
 	u8 fw_build_ww;
 	u8 fw_build_yy;
 	u8 fw_patch_num;
 } __packed;
 static const struct firmware *btusb_setup_intel_get_fw(struct hci_dev *hdev,
 						struct intel_version *ver)
 {
 	const struct firmware *fw;
 	char fwname[64];
 	int ret;
 	snprintf(fwname, sizeof(fwname),
 		 "intel/ibt-hw-%x.%x.%x-fw-%x.%x.%x.%x.%x.bseq",
 		 ver->hw_platform, ver->hw_variant, ver->hw_revision,
 		 ver->fw_variant,  ver->fw_revision, ver->fw_build_num,
 		 ver->fw_build_ww, ver->fw_build_yy);
 	ret = request_firmware(&fw, fwname, &hdev->dev);
 	if (ret < 0) {
 		if (ret == -EINVAL) {
 			BT_ERR("%s Intel firmware file request failed (%d)",
 			       hdev->name, ret);
 			return NULL;
 		}
 		BT_ERR("%s failed to open Intel firmware file: %s(%d)",
 		       hdev->name, fwname, ret);
 		/* If the correct firmware patch file is not found, use the
 		 * default firmware patch file instead
 		 */
 		snprintf(fwname, sizeof(fwname), "intel/ibt-hw-%x.%x.bseq",
 			 ver->hw_platform, ver->hw_variant);
 		if (request_firmware(&fw, fwname, &hdev->dev) < 0) {
 			BT_ERR("%s failed to open default Intel fw file: %s",
 			       hdev->name, fwname);
 			return NULL;
 		}
 	}
 	BT_INFO("%s: Intel Bluetooth firmware file: %s", hdev->name, fwname);
 	return fw;
 }
 static int btusb_setup_intel_patching(struct hci_dev *hdev,
 				      const struct firmware *fw,
 				      const u8 **fw_ptr, int *disable_patch)
 {
 	struct sk_buff *skb;
 	struct hci_command_hdr *cmd;
 	const u8 *cmd_param;
 	struct hci_event_hdr *evt = NULL;
 	const u8 *evt_param = NULL;
 	int remain = fw->size - (*fw_ptr - fw->data);
 	/* The first byte indicates the types of the patch command or event.
 	 * 0x01 means HCI command and 0x02 is HCI event. If the first bytes
 	 * in the current firmware buffer doesn't start with 0x01 or
 	 * the size of remain buffer is smaller than HCI command header,
 	 * the firmware file is corrupted and it should stop the patching
 	 * process.
 	 */
 	if (remain > HCI_COMMAND_HDR_SIZE && *fw_ptr[0] != 0x01) {
 		BT_ERR("%s Intel fw corrupted: invalid cmd read", hdev->name);
 		return -EINVAL;
 	}
 	(*fw_ptr)++;
 	remain--;
 	cmd = (struct hci_command_hdr *)(*fw_ptr);
 	*fw_ptr += sizeof(*cmd);
 	remain -= sizeof(*cmd);
 	/* Ensure that the remain firmware data is long enough than the length
 	 * of command parameter. If not, the firmware file is corrupted.
 	 */
 	if (remain < cmd->plen) {
 		BT_ERR("%s Intel fw corrupted: invalid cmd len", hdev->name);
 		return -EFAULT;
 	}
 	/* If there is a command that loads a patch in the firmware
 	 * file, then enable the patch upon success, otherwise just
 	 * disable the manufacturer mode, for example patch activation
 	 * is not required when the default firmware patch file is used
 	 * because there are no patch data to load.
 	 */
 	if (*disable_patch && le16_to_cpu(cmd->opcode) == 0xfc8e)
 		*disable_patch = 0;
 	cmd_param = *fw_ptr;
 	*fw_ptr += cmd->plen;
 	remain -= cmd->plen;
 	/* This reads the expected events when the above command is sent to the
 	 * device. Some vendor commands expects more than one events, for
 	 * example command status event followed by vendor specific event.
 	 * For this case, it only keeps the last expected event. so the command
 	 * can be sent with __hci_cmd_sync_ev() which returns the sk_buff of
 	 * last expected event.
 	 */
 	while (remain > HCI_EVENT_HDR_SIZE && *fw_ptr[0] == 0x02) {
 		(*fw_ptr)++;
 		remain--;
 		evt = (struct hci_event_hdr *)(*fw_ptr);
 		*fw_ptr += sizeof(*evt);
 		remain -= sizeof(*evt);
 		if (remain < evt->plen) {
 			BT_ERR("%s Intel fw corrupted: invalid evt len",
 			       hdev->name);
 			return -EFAULT;
 		}
 		evt_param = *fw_ptr;
 		*fw_ptr += evt->plen;
 		remain -= evt->plen;
 	}
 	/* Every HCI commands in the firmware file has its correspond event.
 	 * If event is not found or remain is smaller than zero, the firmware
 	 * file is corrupted.
 	 */
 	if (!evt || !evt_param || remain < 0) {
 		BT_ERR("%s Intel fw corrupted: invalid evt read", hdev->name);
 		return -EFAULT;
 	}
 	skb = __hci_cmd_sync_ev(hdev, le16_to_cpu(cmd->opcode), cmd->plen,
 				cmd_param, evt->evt, HCI_INIT_TIMEOUT);
 	if (IS_ERR(skb)) {
 		BT_ERR("%s sending Intel patch command (0x%4.4x) failed (%ld)",
 		       hdev->name, cmd->opcode, PTR_ERR(skb));
 		return -PTR_ERR(skb);
 	}
 	/* It ensures that the returned event matches the event data read from
 	 * the firmware file. At fist, it checks the length and then
 	 * the contents of the event.
 	 */
 	if (skb->len != evt->plen) {
 		BT_ERR("%s mismatch event length (opcode 0x%4.4x)", hdev->name,
 		       le16_to_cpu(cmd->opcode));
 		kfree_skb(skb);
 		return -EFAULT;
 	}
 	if (memcmp(skb->data, evt_param, evt->plen)) {
 		BT_ERR("%s mismatch event parameter (opcode 0x%4.4x)",
 		       hdev->name, le16_to_cpu(cmd->opcode));
 		kfree_skb(skb);
 		return -EFAULT;
 	}
 	kfree_skb(skb);
 	return 0;
 }
 static int btusb_setup_intel(struct hci_dev *hdev)
 {
 	struct sk_buff *skb;
 	const struct firmware *fw;
 	const u8 *fw_ptr;
 	int disable_patch;
 	struct intel_version *ver;
 	const u8 mfg_enable[] = { 0x01, 0x00 };
 	const u8 mfg_disable[] = { 0x00, 0x00 };
 	const u8 mfg_reset_deactivate[] = { 0x00, 0x01 };
 	const u8 mfg_reset_activate[] = { 0x00, 0x02 };
 	BT_DBG("%s", hdev->name);
 	/* The controller has a bug with the first HCI command sent to it
 	 * returning number of completed commands as zero. This would stall the
 	 * command processing in the Bluetooth core.
 	 *
 	 * As a workaround, send HCI Reset command first which will reset the
 	 * number of completed commands and allow normal command processing
 	 * from now on.
 	 */
 	skb = __hci_cmd_sync(hdev, HCI_OP_RESET, 0, NULL, HCI_INIT_TIMEOUT);
 	if (IS_ERR(skb)) {
 		BT_ERR("%s sending initial HCI reset command failed (%ld)",
 		       hdev->name, PTR_ERR(skb));
 		return -PTR_ERR(skb);
 	}
 	kfree_skb(skb);
 	/* Read Intel specific controller version first to allow selection of
 	 * which firmware file to load.
 	 *
 	 * The returned information are hardware variant and revision plus
 	 * firmware variant, revision and build number.
 	 */
 	skb = __hci_cmd_sync(hdev, 0xfc05, 0, NULL, HCI_INIT_TIMEOUT);
 	if (IS_ERR(skb)) {
 		BT_ERR("%s reading Intel fw version command failed (%ld)",
 		       hdev->name, PTR_ERR(skb));
 		return -PTR_ERR(skb);
 	}
 	if (skb->len != sizeof(*ver)) {
 		BT_ERR("%s Intel version event length mismatch", hdev->name);
 		kfree_skb(skb);
 		return -EIO;
 	}
 	ver = (struct intel_version *)skb->data;
 	if (ver->status) {
 		BT_ERR("%s Intel fw version event failed (%02x)", hdev->name,
 		       ver->status);
 		kfree_skb(skb);
 		return -bt_to_errno(ver->status);
 	}
 	BT_INFO("%s: read Intel version: %02x%02x%02x%02x%02x%02x%02x%02x%02x",
 		hdev->name, ver->hw_platform, ver->hw_variant,
 		ver->hw_revision, ver->fw_variant,  ver->fw_revision,
 		ver->fw_build_num, ver->fw_build_ww, ver->fw_build_yy,
 		ver->fw_patch_num);
 	/* fw_patch_num indicates the version of patch the device currently
 	 * have. If there is no patch data in the device, it is always 0x00.
 	 * So, if it is other than 0x00, no need to patch the deivce again.
 	 */
 	if (ver->fw_patch_num) {
 		BT_INFO("%s: Intel device is already patched. patch num: %02x",
 			hdev->name, ver->fw_patch_num);
 		kfree_skb(skb);
 		return 0;
 	}
 	/* Opens the firmware patch file based on the firmware version read
 	 * from the controller. If it fails to open the matching firmware
 	 * patch file, it tries to open the default firmware patch file.
 	 * If no patch file is found, allow the device to operate without
 	 * a patch.
 	 */
 	fw = btusb_setup_intel_get_fw(hdev, ver);
 	if (!fw) {
 		kfree_skb(skb);
 		return 0;
 	}
 	fw_ptr = fw->data;
 	/* This Intel specific command enables the manufacturer mode of the
 	 * controller.
 	 *
 	 * Only while this mode is enabled, the driver can download the
 	 * firmware patch data and configuration parameters.
 	 */
 	skb = __hci_cmd_sync(hdev, 0xfc11, 2, mfg_enable, HCI_INIT_TIMEOUT);
 	if (IS_ERR(skb)) {
 		BT_ERR("%s entering Intel manufacturer mode failed (%ld)",
 		       hdev->name, PTR_ERR(skb));
 		release_firmware(fw);
 		return -PTR_ERR(skb);
 	}
 	if (skb->data[0]) {
 		u8 evt_status = skb->data[0];
 		BT_ERR("%s enable Intel manufacturer mode event failed (%02x)",
 		       hdev->name, evt_status);
 		kfree_skb(skb);
 		release_firmware(fw);
 		return -bt_to_errno(evt_status);
 	}
 	kfree_skb(skb);
 	disable_patch = 1;
 	/* The firmware data file consists of list of Intel specific HCI
 	 * commands and its expected events. The first byte indicates the
 	 * type of the message, either HCI command or HCI event.
 	 *
 	 * It reads the command and its expected event from the firmware file,
 	 * and send to the controller. Once __hci_cmd_sync_ev() returns,
 	 * the returned event is compared with the event read from the firmware
 	 * file and it will continue until all the messages are downloaded to
 	 * the controller.
 	 *
 	 * Once the firmware patching is completed successfully,
 	 * the manufacturer mode is disabled with reset and activating the
 	 * downloaded patch.
 	 *
 	 * If the firmware patching fails, the manufacturer mode is
 	 * disabled with reset and deactivating the patch.
 	 *
 	 * If the default patch file is used, no reset is done when disabling
 	 * the manufacturer.
 	 */
 	while (fw->size > fw_ptr - fw->data) {
 		int ret;
 		ret = btusb_setup_intel_patching(hdev, fw, &fw_ptr,
 						 &disable_patch);
 		if (ret < 0)
 			goto exit_mfg_deactivate;
 	}
 	release_firmware(fw);
 	if (disable_patch)
 		goto exit_mfg_disable;
 	/* Patching completed successfully and disable the manufacturer mode
 	 * with reset and activate the downloaded firmware patches.
 	 */
 	skb = __hci_cmd_sync(hdev, 0xfc11, sizeof(mfg_reset_activate),
 			     mfg_reset_activate, HCI_INIT_TIMEOUT);
 	if (IS_ERR(skb)) {
 		BT_ERR("%s exiting Intel manufacturer mode failed (%ld)",
 		       hdev->name, PTR_ERR(skb));
 		return -PTR_ERR(skb);
 	}
 	kfree_skb(skb);
 	BT_INFO("%s: Intel Bluetooth firmware patch completed and activated",
 		hdev->name);
 	return 0;
 exit_mfg_disable:
 	/* Disable the manufacturer mode without reset */
 	skb = __hci_cmd_sync(hdev, 0xfc11, sizeof(mfg_disable), mfg_disable,
 			     HCI_INIT_TIMEOUT);
 	if (IS_ERR(skb)) {
 		BT_ERR("%s exiting Intel manufacturer mode failed (%ld)",
 		       hdev->name, PTR_ERR(skb));
 		return -PTR_ERR(skb);
 	}
 	kfree_skb(skb);
 	BT_INFO("%s: Intel Bluetooth firmware patch completed", hdev->name);
 	return 0;
 exit_mfg_deactivate:
 	release_firmware(fw);
 	/* Patching failed. Disable the manufacturer mode with reset and
 	 * deactivate the downloaded firmware patches.
 	 */
 	skb = __hci_cmd_sync(hdev, 0xfc11, sizeof(mfg_reset_deactivate),
 			     mfg_reset_deactivate, HCI_INIT_TIMEOUT);
 	if (IS_ERR(skb)) {
 		BT_ERR("%s exiting Intel manufacturer mode failed (%ld)",
 		       hdev->name, PTR_ERR(skb));
 		return -PTR_ERR(skb);
 	}
 	kfree_skb(skb);
 	BT_INFO("%s: Intel Bluetooth firmware patch completed and deactivated",
 		hdev->name);
 	return 0;
 }
 static int btusb_probe(struct usb_interface *intf,
 				const struct usb_device_id *id)
 {
 	struct usb_endpoint_descriptor *ep_desc;
 	struct btusb_data *data;
 	struct hci_dev *hdev;
 	int i, err;
 	BT_DBG("intf %p id %p", intf, id);
 	/* interface numbers are hardcoded in the spec */
 	if (intf->cur_altsetting->desc.bInterfaceNumber != 0)
 		return -ENODEV;
 	if (!id->driver_info) {
 		const struct usb_device_id *match;
 		match = usb_match_id(intf, blacklist_table);
 		if (match)
 			id = match;
 	}
 	if (id->driver_info == BTUSB_IGNORE)
 		return -ENODEV;
 	if (ignore_dga && id->driver_info & BTUSB_DIGIANSWER)
 		return -ENODEV;
 	if (ignore_csr && id->driver_info & BTUSB_CSR)
 		return -ENODEV;
 	if (ignore_sniffer && id->driver_info & BTUSB_SNIFFER)
 		return -ENODEV;
 	if (id->driver_info & BTUSB_ATH3012) {
 		struct usb_device *udev = interface_to_usbdev(intf);
 		/* Old firmware would otherwise let ath3k driver load
 		 * patch and sysconfig files */
 		if (le16_to_cpu(udev->descriptor.bcdDevice) <= 0x0001)
 			return -ENODEV;
 	}
 	data = devm_kzalloc(&intf->dev, sizeof(*data), GFP_KERNEL);
 	if (!data)
 		return -ENOMEM;
 	for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++) {
 		ep_desc = &intf->cur_altsetting->endpoint[i].desc;
 		if (!data->intr_ep && usb_endpoint_is_int_in(ep_desc)) {
 			data->intr_ep = ep_desc;
 			continue;
 		}
 		if (!data->bulk_tx_ep && usb_endpoint_is_bulk_out(ep_desc)) {
 			data->bulk_tx_ep = ep_desc;
 			continue;
 		}
 		if (!data->bulk_rx_ep && usb_endpoint_is_bulk_in(ep_desc)) {
 			data->bulk_rx_ep = ep_desc;
 			continue;
 		}
 	}
 	if (!data->intr_ep || !data->bulk_tx_ep || !data->bulk_rx_ep)
 		return -ENODEV;
 	data->cmdreq_type = USB_TYPE_CLASS;
 	data->udev = interface_to_usbdev(intf);
 	data->intf = intf;
 	spin_lock_init(&data->lock);
 	INIT_WORK(&data->work, btusb_work);
 	INIT_WORK(&data->waker, btusb_waker);
 	spin_lock_init(&data->txlock);
 	init_usb_anchor(&data->tx_anchor);
 	init_usb_anchor(&data->intr_anchor);
 	init_usb_anchor(&data->bulk_anchor);
 	init_usb_anchor(&data->isoc_anchor);
 	init_usb_anchor(&data->deferred);
 	hdev = hci_alloc_dev();
 	if (!hdev)
 		return -ENOMEM;
 	hdev->bus = HCI_USB;
 	hci_set_drvdata(hdev, data);
 	data->hdev = hdev;
 	SET_HCIDEV_DEV(hdev, &intf->dev);
 	hdev->open   = btusb_open;
 	hdev->close  = btusb_close;
 	hdev->flush  = btusb_flush;
 	hdev->send   = btusb_send_frame;
 	hdev->notify = btusb_notify;
 	if (id->driver_info & BTUSB_BCM92035)
 		hdev->setup = btusb_setup_bcm92035;
 	if (id->driver_info & BTUSB_INTEL)
 		hdev->setup = btusb_setup_intel;
 	/* Interface numbers are hardcoded in the specification */
 	data->isoc = usb_ifnum_to_if(data->udev, 1);
 	if (!reset)
 		set_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks);
 	if (force_scofix || id->driver_info & BTUSB_WRONG_SCO_MTU) {
 		if (!disable_scofix)
 			set_bit(HCI_QUIRK_FIXUP_BUFFER_SIZE, &hdev->quirks);
 	}
 	if (id->driver_info & BTUSB_BROKEN_ISOC)
 		data->isoc = NULL;
 	if (id->driver_info & BTUSB_DIGIANSWER) {
 		data->cmdreq_type = USB_TYPE_VENDOR;
 		set_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks);
 	}
 	if (id->driver_info & BTUSB_CSR) {
 		struct usb_device *udev = data->udev;
 		/* Old firmware would otherwise execute USB reset */
 		if (le16_to_cpu(udev->descriptor.bcdDevice) < 0x117)
 			set_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks);
 	}
 	if (id->driver_info & BTUSB_SNIFFER) {
 		struct usb_device *udev = data->udev;
 		/* New sniffer firmware has crippled HCI interface */
 		if (le16_to_cpu(udev->descriptor.bcdDevice) > 0x997)
 			set_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks);
 		data->isoc = NULL;
 	}
 	if (data->isoc) {
 		err = usb_driver_claim_interface(&btusb_driver,
 							data->isoc, data);
 		if (err < 0) {
 			hci_free_dev(hdev);
 			return err;
 		}
 	}
 	err = hci_register_dev(hdev);
 	if (err < 0) {
 		hci_free_dev(hdev);
 		return err;
 	}
 	usb_set_intfdata(intf, data);
 	return 0;
 }
 static void btusb_disconnect(struct usb_interface *intf)
 {
 	struct btusb_data *data = usb_get_intfdata(intf);
 	struct hci_dev *hdev;
 	BT_DBG("intf %p", intf);
 	if (!data)
 		return;
 	hdev = data->hdev;
 	usb_set_intfdata(data->intf, NULL);
 	if (data->isoc)
 		usb_set_intfdata(data->isoc, NULL);
 	hci_unregister_dev(hdev);
 	if (intf == data->isoc)
 		usb_driver_release_interface(&btusb_driver, data->intf);
 	else if (data->isoc)
 		usb_driver_release_interface(&btusb_driver, data->isoc);
 	hci_free_dev(hdev);
 }
 #ifdef CONFIG_PM
 static int btusb_suspend(struct usb_interface *intf, pm_message_t message)
 {
 	struct btusb_data *data = usb_get_intfdata(intf);
 	BT_DBG("intf %p", intf);
 	if (data->suspend_count++)
 		return 0;
 	spin_lock_irq(&data->txlock);
 	if (!(PMSG_IS_AUTO(message) && data->tx_in_flight)) {
 		set_bit(BTUSB_SUSPENDING, &data->flags);
 		spin_unlock_irq(&data->txlock);
 	} else {
 		spin_unlock_irq(&data->txlock);
 		data->suspend_count--;
 		return -EBUSY;
 	}
 	cancel_work_sync(&data->work);
 	btusb_stop_traffic(data);
 	usb_kill_anchored_urbs(&data->tx_anchor);
 	return 0;
 }
 static void play_deferred(struct btusb_data *data)
 {
 	struct urb *urb;
 	int err;
 	while ((urb = usb_get_from_anchor(&data->deferred))) {
 		err = usb_submit_urb(urb, GFP_ATOMIC);
 		if (err < 0)
 			break;
 		data->tx_in_flight++;
 	}
 	usb_scuttle_anchored_urbs(&data->deferred);
 }
 static int btusb_resume(struct usb_interface *intf)
 {
 	struct btusb_data *data = usb_get_intfdata(intf);
 	struct hci_dev *hdev = data->hdev;
 	int err = 0;
 	BT_DBG("intf %p", intf);
 	if (--data->suspend_count)
 		return 0;
 	if (!test_bit(HCI_RUNNING, &hdev->flags))
 		goto done;
 	if (test_bit(BTUSB_INTR_RUNNING, &data->flags)) {
 		err = btusb_submit_intr_urb(hdev, GFP_NOIO);
 		if (err < 0) {
 			clear_bit(BTUSB_INTR_RUNNING, &data->flags);
 			goto failed;
 		}
 	}
 	if (test_bit(BTUSB_BULK_RUNNING, &data->flags)) {
 		err = btusb_submit_bulk_urb(hdev, GFP_NOIO);
 		if (err < 0) {
 			clear_bit(BTUSB_BULK_RUNNING, &data->flags);
 			goto failed;
 		}
 		btusb_submit_bulk_urb(hdev, GFP_NOIO);
 	}
 	if (test_bit(BTUSB_ISOC_RUNNING, &data->flags)) {
 		if (btusb_submit_isoc_urb(hdev, GFP_NOIO) < 0)
 			clear_bit(BTUSB_ISOC_RUNNING, &data->flags);
 		else
 			btusb_submit_isoc_urb(hdev, GFP_NOIO);
 	}
 	spin_lock_irq(&data->txlock);
 	play_deferred(data);
 	clear_bit(BTUSB_SUSPENDING, &data->flags);
 	spin_unlock_irq(&data->txlock);
 	schedule_work(&data->work);
 	return 0;
 failed:
 	usb_scuttle_anchored_urbs(&data->deferred);
 done:
 	spin_lock_irq(&data->txlock);
 	clear_bit(BTUSB_SUSPENDING, &data->flags);
 	spin_unlock_irq(&data->txlock);
 	return err;
 }
 #endif
 static struct usb_driver btusb_driver = {
 	.name		= "btusb",
 	.probe		= btusb_probe,
 	.disconnect	= btusb_disconnect,
 #ifdef CONFIG_PM
 	.suspend	= btusb_suspend,
 	.resume		= btusb_resume,
 #endif
 	.id_table	= btusb_table,
 	.supports_autosuspend = 1,
 	.disable_hub_initiated_lpm = 1,
 };
 module_usb_driver(btusb_driver);
 module_param(ignore_dga, bool, 0644);
 MODULE_PARM_DESC(ignore_dga, "Ignore devices with id 08fd:0001");
 module_param(ignore_csr, bool, 0644);
 MODULE_PARM_DESC(ignore_csr, "Ignore devices with id 0a12:0001");
 module_param(ignore_sniffer, bool, 0644);
 MODULE_PARM_DESC(ignore_sniffer, "Ignore devices with id 0a12:0002");
 module_param(disable_scofix, bool, 0644);
 MODULE_PARM_DESC(disable_scofix, "Disable fixup of wrong SCO buffer size");
 module_param(force_scofix, bool, 0644);
 MODULE_PARM_DESC(force_scofix, "Force fixup of wrong SCO buffers size");
 module_param(reset, bool, 0644);
 MODULE_PARM_DESC(reset, "Send HCI reset command on initialization");
 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
 MODULE_DESCRIPTION("Generic Bluetooth USB driver ver " VERSION);
 MODULE_VERSION(VERSION);
 MODULE_LICENSE("GPL");