?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
arm64: alternatives: add enable parameter to conditional asm macros
[linux/fpc-iii.git] / drivers / bluetooth / btbcm.c
blob9ceb8ac68fdca2518c953cb6a9a36c6fd5b5f268
1 /*
2 *
3 * Bluetooth support for Broadcom devices
4 *
5 * Copyright (C) 2015 Intel Corporation
6 *
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 *
22 */
23
24 #include <linux/module.h>
25 #include <linux/firmware.h>
26 #include <asm/unaligned.h>
27
28 #include <net/bluetooth/bluetooth.h>
29 #include <net/bluetooth/hci_core.h>
30
31 #include "btbcm.h"
32
33 #define VERSION "0.1"
34
35 #define BDADDR_BCM20702A0 (&(bdaddr_t) {{0x00, 0xa0, 0x02, 0x70, 0x20, 0x00}})
36 #define BDADDR_BCM4324B3 (&(bdaddr_t) {{0x00, 0x00, 0x00, 0xb3, 0x24, 0x43}})
37
38 int btbcm_check_bdaddr(struct hci_dev *hdev)
39 {
40 struct hci_rp_read_bd_addr *bda;
41 struct sk_buff *skb;
42
43 skb = __hci_cmd_sync(hdev, HCI_OP_READ_BD_ADDR, 0, NULL,
44 HCI_INIT_TIMEOUT);
45 if (IS_ERR(skb)) {
46 int err = PTR_ERR(skb);
47 BT_ERR("%s: BCM: Reading device address failed (%d)",
48 hdev->name, err);
49 return err;
50 }
51
52 if (skb->len != sizeof(*bda)) {
53 BT_ERR("%s: BCM: Device address length mismatch", hdev->name);
54 kfree_skb(skb);
55 return -EIO;
56 }
57
58 bda = (struct hci_rp_read_bd_addr *)skb->data;
59
60 /* Check if the address indicates a controller with either an
61 * invalid or default address. In both cases the device needs
62 * to be marked as not having a valid address.
63 *
64 * The address 00:20:70:02:A0:00 indicates a BCM20702A0 controller
65 * with no configured address.
66 *
67 * The address 43:24:B3:00:00:00 indicates a BCM4324B3 controller
68 * with waiting for configuration state.
69 */
70 if (!bacmp(&bda->bdaddr, BDADDR_BCM20702A0) ||
71 !bacmp(&bda->bdaddr, BDADDR_BCM4324B3)) {
72 BT_INFO("%s: BCM: Using default device address (%pMR)",
73 hdev->name, &bda->bdaddr);
74 set_bit(HCI_QUIRK_INVALID_BDADDR, &hdev->quirks);
75 }
76
77 kfree_skb(skb);
78
79 return 0;
80 }
81 EXPORT_SYMBOL_GPL(btbcm_check_bdaddr);
82
83 int btbcm_set_bdaddr(struct hci_dev *hdev, const bdaddr_t *bdaddr)
84 {
85 struct sk_buff *skb;
86 int err;
87
88 skb = __hci_cmd_sync(hdev, 0xfc01, 6, bdaddr, HCI_INIT_TIMEOUT);
89 if (IS_ERR(skb)) {
90 err = PTR_ERR(skb);
91 BT_ERR("%s: BCM: Change address command failed (%d)",
92 hdev->name, err);
93 return err;
94 }
95 kfree_skb(skb);
96
97 return 0;
98 }
99 EXPORT_SYMBOL_GPL(btbcm_set_bdaddr);
100
101 int btbcm_patchram(struct hci_dev *hdev, const struct firmware *fw)
102 {
103 const struct hci_command_hdr *cmd;
104 const u8 *fw_ptr;
105 size_t fw_size;
106 struct sk_buff *skb;
107 u16 opcode;
108 int err = 0;
109
110 /* Start Download */
111 skb = __hci_cmd_sync(hdev, 0xfc2e, 0, NULL, HCI_INIT_TIMEOUT);
112 if (IS_ERR(skb)) {
113 err = PTR_ERR(skb);
114 BT_ERR("%s: BCM: Download Minidrv command failed (%d)",
115 hdev->name, err);
116 goto done;
117 }
118 kfree_skb(skb);
119
120 /* 50 msec delay after Download Minidrv completes */
121 msleep(50);
122
123 fw_ptr = fw->data;
124 fw_size = fw->size;
125
126 while (fw_size >= sizeof(*cmd)) {
127 const u8 *cmd_param;
128
129 cmd = (struct hci_command_hdr *)fw_ptr;
130 fw_ptr += sizeof(*cmd);
131 fw_size -= sizeof(*cmd);
132
133 if (fw_size < cmd->plen) {
134 BT_ERR("%s: BCM: Patch is corrupted", hdev->name);
135 err = -EINVAL;
136 goto done;
137 }
138
139 cmd_param = fw_ptr;
140 fw_ptr += cmd->plen;
141 fw_size -= cmd->plen;
142
143 opcode = le16_to_cpu(cmd->opcode);
144
145 skb = __hci_cmd_sync(hdev, opcode, cmd->plen, cmd_param,
146 HCI_INIT_TIMEOUT);
147 if (IS_ERR(skb)) {
148 err = PTR_ERR(skb);
149 BT_ERR("%s: BCM: Patch command %04x failed (%d)",
150 hdev->name, opcode, err);
151 goto done;
152 }
153 kfree_skb(skb);
154 }
155
156 /* 250 msec delay after Launch Ram completes */
157 msleep(250);
158
159 done:
160 return err;
161 }
162 EXPORT_SYMBOL(btbcm_patchram);
163
164 static int btbcm_reset(struct hci_dev *hdev)
165 {
166 struct sk_buff *skb;
167
168 skb = __hci_cmd_sync(hdev, HCI_OP_RESET, 0, NULL, HCI_INIT_TIMEOUT);
169 if (IS_ERR(skb)) {
170 int err = PTR_ERR(skb);
171 BT_ERR("%s: BCM: Reset failed (%d)", hdev->name, err);
172 return err;
173 }
174 kfree_skb(skb);
175
176 return 0;
177 }
178
179 static struct sk_buff *btbcm_read_local_version(struct hci_dev *hdev)
180 {
181 struct sk_buff *skb;
182
183 skb = __hci_cmd_sync(hdev, HCI_OP_READ_LOCAL_VERSION, 0, NULL,
184 HCI_INIT_TIMEOUT);
185 if (IS_ERR(skb)) {
186 BT_ERR("%s: BCM: Reading local version info failed (%ld)",
187 hdev->name, PTR_ERR(skb));
188 return skb;
189 }
190
191 if (skb->len != sizeof(struct hci_rp_read_local_version)) {
192 BT_ERR("%s: BCM: Local version length mismatch", hdev->name);
193 kfree_skb(skb);
194 return ERR_PTR(-EIO);
195 }
196
197 return skb;
198 }
199
200 static struct sk_buff *btbcm_read_verbose_config(struct hci_dev *hdev)
201 {
202 struct sk_buff *skb;
203
204 skb = __hci_cmd_sync(hdev, 0xfc79, 0, NULL, HCI_INIT_TIMEOUT);
205 if (IS_ERR(skb)) {
206 BT_ERR("%s: BCM: Read verbose config info failed (%ld)",
207 hdev->name, PTR_ERR(skb));
208 return skb;
209 }
210
211 if (skb->len != 7) {
212 BT_ERR("%s: BCM: Verbose config length mismatch", hdev->name);
213 kfree_skb(skb);
214 return ERR_PTR(-EIO);
215 }
216
217 return skb;
218 }
219
220 static struct sk_buff *btbcm_read_usb_product(struct hci_dev *hdev)
221 {
222 struct sk_buff *skb;
223
224 skb = __hci_cmd_sync(hdev, 0xfc5a, 0, NULL, HCI_INIT_TIMEOUT);
225 if (IS_ERR(skb)) {
226 BT_ERR("%s: BCM: Read USB product info failed (%ld)",
227 hdev->name, PTR_ERR(skb));
228 return skb;
229 }
230
231 if (skb->len != 5) {
232 BT_ERR("%s: BCM: USB product length mismatch", hdev->name);
233 kfree_skb(skb);
234 return ERR_PTR(-EIO);
235 }
236
237 return skb;
238 }
239
240 static const struct {
241 u16 subver;
242 const char *name;
243 } bcm_uart_subver_table[] = {
244 { 0x410e, "BCM43341B0" }, /* 002.001.014 */
245 { 0x4406, "BCM4324B3" }, /* 002.004.006 */
246 { 0x610c, "BCM4354" }, /* 003.001.012 */
247 { }
248 };
249
250 int btbcm_initialize(struct hci_dev *hdev, char *fw_name, size_t len)
251 {
252 u16 subver, rev;
253 const char *hw_name = NULL;
254 struct sk_buff *skb;
255 struct hci_rp_read_local_version *ver;
256 int i, err;
257
258 /* Reset */
259 err = btbcm_reset(hdev);
260 if (err)
261 return err;
262
263 /* Read Local Version Info */
264 skb = btbcm_read_local_version(hdev);
265 if (IS_ERR(skb))
266 return PTR_ERR(skb);
267
268 ver = (struct hci_rp_read_local_version *)skb->data;
269 rev = le16_to_cpu(ver->hci_rev);
270 subver = le16_to_cpu(ver->lmp_subver);
271 kfree_skb(skb);
272
273 /* Read Verbose Config Version Info */
274 skb = btbcm_read_verbose_config(hdev);
275 if (IS_ERR(skb))
276 return PTR_ERR(skb);
277
278 BT_INFO("%s: BCM: chip id %u", hdev->name, skb->data[1]);
279 kfree_skb(skb);
280
281 switch ((rev & 0xf000) >> 12) {
282 case 0:
283 case 1:
284 case 3:
285 for (i = 0; bcm_uart_subver_table[i].name; i++) {
286 if (subver == bcm_uart_subver_table[i].subver) {
287 hw_name = bcm_uart_subver_table[i].name;
288 break;
289 }
290 }
291
292 snprintf(fw_name, len, "brcm/%s.hcd", hw_name ? : "BCM");
293 break;
294 default:
295 return 0;
296 }
297
298 BT_INFO("%s: %s (%3.3u.%3.3u.%3.3u) build %4.4u", hdev->name,
299 hw_name ? : "BCM", (subver & 0x7000) >> 13,
300 (subver & 0x1f00) >> 8, (subver & 0x00ff), rev & 0x0fff);
301
302 return 0;
303 }
304 EXPORT_SYMBOL_GPL(btbcm_initialize);
305
306 int btbcm_finalize(struct hci_dev *hdev)
307 {
308 struct sk_buff *skb;
309 struct hci_rp_read_local_version *ver;
310 u16 subver, rev;
311 int err;
312
313 /* Reset */
314 err = btbcm_reset(hdev);
315 if (err)
316 return err;
317
318 /* Read Local Version Info */
319 skb = btbcm_read_local_version(hdev);
320 if (IS_ERR(skb))
321 return PTR_ERR(skb);
322
323 ver = (struct hci_rp_read_local_version *)skb->data;
324 rev = le16_to_cpu(ver->hci_rev);
325 subver = le16_to_cpu(ver->lmp_subver);
326 kfree_skb(skb);
327
328 BT_INFO("%s: BCM (%3.3u.%3.3u.%3.3u) build %4.4u", hdev->name,
329 (subver & 0x7000) >> 13, (subver & 0x1f00) >> 8,
330 (subver & 0x00ff), rev & 0x0fff);
331
332 btbcm_check_bdaddr(hdev);
333
334 set_bit(HCI_QUIRK_STRICT_DUPLICATE_FILTER, &hdev->quirks);
335
336 return 0;
337 }
338 EXPORT_SYMBOL_GPL(btbcm_finalize);
339
340 static const struct {
341 u16 subver;
342 const char *name;
343 } bcm_usb_subver_table[] = {
344 { 0x210b, "BCM43142A0" }, /* 001.001.011 */
345 { 0x2112, "BCM4314A0" }, /* 001.001.018 */
346 { 0x2118, "BCM20702A0" }, /* 001.001.024 */
347 { 0x2126, "BCM4335A0" }, /* 001.001.038 */
348 { 0x220e, "BCM20702A1" }, /* 001.002.014 */
349 { 0x230f, "BCM4354A2" }, /* 001.003.015 */
350 { 0x4106, "BCM4335B0" }, /* 002.001.006 */
351 { 0x410e, "BCM20702B0" }, /* 002.001.014 */
352 { 0x6109, "BCM4335C0" }, /* 003.001.009 */
353 { 0x610c, "BCM4354" }, /* 003.001.012 */
354 { }
355 };
356
357 int btbcm_setup_patchram(struct hci_dev *hdev)
358 {
359 char fw_name[64];
360 const struct firmware *fw;
361 u16 subver, rev, pid, vid;
362 const char *hw_name = NULL;
363 struct sk_buff *skb;
364 struct hci_rp_read_local_version *ver;
365 int i, err;
366
367 /* Reset */
368 err = btbcm_reset(hdev);
369 if (err)
370 return err;
371
372 /* Read Local Version Info */
373 skb = btbcm_read_local_version(hdev);
374 if (IS_ERR(skb))
375 return PTR_ERR(skb);
376
377 ver = (struct hci_rp_read_local_version *)skb->data;
378 rev = le16_to_cpu(ver->hci_rev);
379 subver = le16_to_cpu(ver->lmp_subver);
380 kfree_skb(skb);
381
382 /* Read Verbose Config Version Info */
383 skb = btbcm_read_verbose_config(hdev);
384 if (IS_ERR(skb))
385 return PTR_ERR(skb);
386
387 BT_INFO("%s: BCM: chip id %u", hdev->name, skb->data[1]);
388 kfree_skb(skb);
389
390 switch ((rev & 0xf000) >> 12) {
391 case 0:
392 case 3:
393 for (i = 0; bcm_uart_subver_table[i].name; i++) {
394 if (subver == bcm_uart_subver_table[i].subver) {
395 hw_name = bcm_uart_subver_table[i].name;
396 break;
397 }
398 }
399
400 snprintf(fw_name, sizeof(fw_name), "brcm/%s.hcd",
401 hw_name ? : "BCM");
402 break;
403 case 1:
404 case 2:
405 /* Read USB Product Info */
406 skb = btbcm_read_usb_product(hdev);
407 if (IS_ERR(skb))
408 return PTR_ERR(skb);
409
410 vid = get_unaligned_le16(skb->data + 1);
411 pid = get_unaligned_le16(skb->data + 3);
412 kfree_skb(skb);
413
414 for (i = 0; bcm_usb_subver_table[i].name; i++) {
415 if (subver == bcm_usb_subver_table[i].subver) {
416 hw_name = bcm_usb_subver_table[i].name;
417 break;
418 }
419 }
420
421 snprintf(fw_name, sizeof(fw_name), "brcm/%s-%4.4x-%4.4x.hcd",
422 hw_name ? : "BCM", vid, pid);
423 break;
424 default:
425 return 0;
426 }
427
428 BT_INFO("%s: %s (%3.3u.%3.3u.%3.3u) build %4.4u", hdev->name,
429 hw_name ? : "BCM", (subver & 0x7000) >> 13,
430 (subver & 0x1f00) >> 8, (subver & 0x00ff), rev & 0x0fff);
431
432 err = request_firmware(&fw, fw_name, &hdev->dev);
433 if (err < 0) {
434 BT_INFO("%s: BCM: Patch %s not found", hdev->name, fw_name);
435 return 0;
436 }
437
438 btbcm_patchram(hdev, fw);
439
440 release_firmware(fw);
441
442 /* Reset */
443 err = btbcm_reset(hdev);
444 if (err)
445 return err;
446
447 /* Read Local Version Info */
448 skb = btbcm_read_local_version(hdev);
449 if (IS_ERR(skb))
450 return PTR_ERR(skb);
451
452 ver = (struct hci_rp_read_local_version *)skb->data;
453 rev = le16_to_cpu(ver->hci_rev);
454 subver = le16_to_cpu(ver->lmp_subver);
455 kfree_skb(skb);
456
457 BT_INFO("%s: %s (%3.3u.%3.3u.%3.3u) build %4.4u", hdev->name,
458 hw_name ? : "BCM", (subver & 0x7000) >> 13,
459 (subver & 0x1f00) >> 8, (subver & 0x00ff), rev & 0x0fff);
460
461 btbcm_check_bdaddr(hdev);
462
463 set_bit(HCI_QUIRK_STRICT_DUPLICATE_FILTER, &hdev->quirks);
464
465 return 0;
466 }
467 EXPORT_SYMBOL_GPL(btbcm_setup_patchram);
468
469 int btbcm_setup_apple(struct hci_dev *hdev)
470 {
471 struct sk_buff *skb;
472
473 /* Read Verbose Config Version Info */
474 skb = btbcm_read_verbose_config(hdev);
475 if (!IS_ERR(skb)) {
476 BT_INFO("%s: BCM: chip id %u build %4.4u", hdev->name, skb->data[1],
477 get_unaligned_le16(skb->data + 5));
478 kfree_skb(skb);
479 }
480
481 set_bit(HCI_QUIRK_STRICT_DUPLICATE_FILTER, &hdev->quirks);
482
483 return 0;
484 }
485 EXPORT_SYMBOL_GPL(btbcm_setup_apple);
486
487 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
488 MODULE_DESCRIPTION("Bluetooth support for Broadcom devices ver " VERSION);
489 MODULE_VERSION(VERSION);
490 MODULE_LICENSE("GPL");
Linux with added FPC-III support