projects/linux·blob master · refs

782 lines · 18.7 KiB

1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 *
4 * Bluetooth support for Broadcom devices
5 *
6 * Copyright (C) 2015 Intel Corporation
7 */
8
9#include <linux/efi.h>
10#include <linux/module.h>
11#include <linux/firmware.h>
12#include <linux/dmi.h>
13#include <linux/of.h>
14#include <linux/string.h>
15#include <linux/unaligned.h>
16
17#include <net/bluetooth/bluetooth.h>
18#include <net/bluetooth/hci_core.h>
19
20#include "btbcm.h"
21
22#define VERSION "0.1"
23
24#define BDADDR_BCM20702A0 (&(bdaddr_t) {{0x00, 0xa0, 0x02, 0x70, 0x20, 0x00}})
25#define BDADDR_BCM20702A1 (&(bdaddr_t) {{0x00, 0x00, 0xa0, 0x02, 0x70, 0x20}})
26#define BDADDR_BCM2076B1 (&(bdaddr_t) {{0x79, 0x56, 0x00, 0xa0, 0x76, 0x20}})
27#define BDADDR_BCM43430A0 (&(bdaddr_t) {{0xac, 0x1f, 0x12, 0xa0, 0x43, 0x43}})
28#define BDADDR_BCM43430A1 (&(bdaddr_t) {{0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa}})
29#define BDADDR_BCM4324B3 (&(bdaddr_t) {{0x00, 0x00, 0x00, 0xb3, 0x24, 0x43}})
30#define BDADDR_BCM4330B1 (&(bdaddr_t) {{0x00, 0x00, 0x00, 0xb1, 0x30, 0x43}})
31#define BDADDR_BCM4334B0 (&(bdaddr_t) {{0x00, 0x00, 0x00, 0xb0, 0x34, 0x43}})
32#define BDADDR_BCM4345C5 (&(bdaddr_t) {{0xac, 0x1f, 0x00, 0xc5, 0x45, 0x43}})
33#define BDADDR_BCM43341B (&(bdaddr_t) {{0xac, 0x1f, 0x00, 0x1b, 0x34, 0x43}})
34
35#define BCM_FW_NAME_LEN 64
36#define BCM_FW_NAME_COUNT_MAX 4
37/* For kmalloc-ing the fw-name array instead of putting it on the stack */
38typedef char bcm_fw_name[BCM_FW_NAME_LEN];
39
40#ifdef CONFIG_EFI
41static int btbcm_set_bdaddr_from_efi(struct hci_dev *hdev)
42{
43 efi_guid_t guid = EFI_GUID(0x74b00bd9, 0x805a, 0x4d61, 0xb5, 0x1f,
44 0x43, 0x26, 0x81, 0x23, 0xd1, 0x13);
45 bdaddr_t efi_bdaddr, bdaddr;
46 efi_status_t status;
47 unsigned long len;
48 int ret;
49
50 if (!efi_rt_services_supported(EFI_RT_SUPPORTED_GET_VARIABLE))
51 return -EOPNOTSUPP;
52
53 len = sizeof(efi_bdaddr);
54 status = efi.get_variable(L"BDADDR", &guid, NULL, &len, &efi_bdaddr);
55 if (status != EFI_SUCCESS)
56 return -ENXIO;
57
58 if (len != sizeof(efi_bdaddr))
59 return -EIO;
60
61 baswap(&bdaddr, &efi_bdaddr);
62
63 ret = btbcm_set_bdaddr(hdev, &bdaddr);
64 if (ret)
65 return ret;
66
67 bt_dev_info(hdev, "BCM: Using EFI device address (%pMR)", &bdaddr);
68 return 0;
69}
70#else
71static int btbcm_set_bdaddr_from_efi(struct hci_dev *hdev)
72{
73 return -EOPNOTSUPP;
74}
75#endif
76
77int btbcm_check_bdaddr(struct hci_dev *hdev)
78{
79 struct hci_rp_read_bd_addr *bda;
80 struct sk_buff *skb;
81
82 skb = __hci_cmd_sync(hdev, HCI_OP_READ_BD_ADDR, 0, NULL,
83 HCI_INIT_TIMEOUT);
84 if (IS_ERR(skb)) {
85 int err = PTR_ERR(skb);
86
87 bt_dev_err(hdev, "BCM: Reading device address failed (%d)", err);
88 return err;
89 }
90
91 if (skb->len != sizeof(*bda)) {
92 bt_dev_err(hdev, "BCM: Device address length mismatch");
93 kfree_skb(skb);
94 return -EIO;
95 }
96
97 bda = (struct hci_rp_read_bd_addr *)skb->data;
98
99 /* Check if the address indicates a controller with either an
100 * invalid or default address. In both cases the device needs
101 * to be marked as not having a valid address.
102 *
103 * The address 00:20:70:02:A0:00 indicates a BCM20702A0 controller
104 * with no configured address.
105 *
106 * The address 20:70:02:A0:00:00 indicates a BCM20702A1 controller
107 * with no configured address.
108 *
109 * The address 20:76:A0:00:56:79 indicates a BCM2076B1 controller
110 * with no configured address.
111 *
112 * The address 43:24:B3:00:00:00 indicates a BCM4324B3 controller
113 * with waiting for configuration state.
114 *
115 * The address 43:30:B1:00:00:00 indicates a BCM4330B1 controller
116 * with waiting for configuration state.
117 *
118 * The address 43:43:A0:12:1F:AC indicates a BCM43430A0 controller
119 * with no configured address.
120 *
121 * The address AA:AA:AA:AA:AA:AA indicates a BCM43430A1 controller
122 * with no configured address.
123 */
124 if (!bacmp(&bda->bdaddr, BDADDR_BCM20702A0) ||
125 !bacmp(&bda->bdaddr, BDADDR_BCM20702A1) ||
126 !bacmp(&bda->bdaddr, BDADDR_BCM2076B1) ||
127 !bacmp(&bda->bdaddr, BDADDR_BCM4324B3) ||
128 !bacmp(&bda->bdaddr, BDADDR_BCM4330B1) ||
129 !bacmp(&bda->bdaddr, BDADDR_BCM4334B0) ||
130 !bacmp(&bda->bdaddr, BDADDR_BCM4345C5) ||
131 !bacmp(&bda->bdaddr, BDADDR_BCM43430A0) ||
132 !bacmp(&bda->bdaddr, BDADDR_BCM43430A1) ||
133 !bacmp(&bda->bdaddr, BDADDR_BCM43341B)) {
134 /* Try falling back to BDADDR EFI variable */
135 if (btbcm_set_bdaddr_from_efi(hdev) != 0) {
136 bt_dev_info(hdev, "BCM: Using default device address (%pMR)",
137 &bda->bdaddr);
138 hci_set_quirk(hdev, HCI_QUIRK_INVALID_BDADDR);
139 }
140 }
141
142 kfree_skb(skb);
143
144 return 0;
145}
146EXPORT_SYMBOL_GPL(btbcm_check_bdaddr);
147
148int btbcm_set_bdaddr(struct hci_dev *hdev, const bdaddr_t *bdaddr)
149{
150 struct sk_buff *skb;
151 int err;
152
153 skb = __hci_cmd_sync(hdev, 0xfc01, 6, bdaddr, HCI_INIT_TIMEOUT);
154 if (IS_ERR(skb)) {
155 err = PTR_ERR(skb);
156 bt_dev_err(hdev, "BCM: Change address command failed (%d)", err);
157 return err;
158 }
159 kfree_skb(skb);
160
161 return 0;
162}
163EXPORT_SYMBOL_GPL(btbcm_set_bdaddr);
164
165int btbcm_read_pcm_int_params(struct hci_dev *hdev,
166 struct bcm_set_pcm_int_params *params)
167{
168 struct sk_buff *skb;
169 int err = 0;
170
171 skb = __hci_cmd_sync(hdev, 0xfc1d, 0, NULL, HCI_INIT_TIMEOUT);
172 if (IS_ERR(skb)) {
173 err = PTR_ERR(skb);
174 bt_dev_err(hdev, "BCM: Read PCM int params failed (%d)", err);
175 return err;
176 }
177
178 if (skb->len != 6 || skb->data[0]) {
179 bt_dev_err(hdev, "BCM: Read PCM int params length mismatch");
180 kfree_skb(skb);
181 return -EIO;
182 }
183
184 if (params)
185 memcpy(params, skb->data + 1, 5);
186
187 kfree_skb(skb);
188
189 return 0;
190}
191EXPORT_SYMBOL_GPL(btbcm_read_pcm_int_params);
192
193int btbcm_write_pcm_int_params(struct hci_dev *hdev,
194 const struct bcm_set_pcm_int_params *params)
195{
196 struct sk_buff *skb;
197 int err;
198
199 skb = __hci_cmd_sync(hdev, 0xfc1c, 5, params, HCI_INIT_TIMEOUT);
200 if (IS_ERR(skb)) {
201 err = PTR_ERR(skb);
202 bt_dev_err(hdev, "BCM: Write PCM int params failed (%d)", err);
203 return err;
204 }
205 kfree_skb(skb);
206
207 return 0;
208}
209EXPORT_SYMBOL_GPL(btbcm_write_pcm_int_params);
210
211int btbcm_patchram(struct hci_dev *hdev, const struct firmware *fw)
212{
213 const struct hci_command_hdr *cmd;
214 const u8 *fw_ptr;
215 size_t fw_size;
216 struct sk_buff *skb;
217 u16 opcode;
218 int err = 0;
219
220 /* Start Download */
221 skb = __hci_cmd_sync(hdev, 0xfc2e, 0, NULL, HCI_INIT_TIMEOUT);
222 if (IS_ERR(skb)) {
223 err = PTR_ERR(skb);
224 bt_dev_err(hdev, "BCM: Download Minidrv command failed (%d)",
225 err);
226 return err;
227 }
228 kfree_skb(skb);
229
230 /* 50 msec delay after Download Minidrv completes */
231 msleep(50);
232
233 fw_ptr = fw->data;
234 fw_size = fw->size;
235
236 while (fw_size >= sizeof(*cmd)) {
237 const u8 *cmd_param;
238
239 cmd = (struct hci_command_hdr *)fw_ptr;
240 fw_ptr += sizeof(*cmd);
241 fw_size -= sizeof(*cmd);
242
243 if (fw_size < cmd->plen) {
244 bt_dev_err(hdev, "BCM: Patch is corrupted");
245 return -EINVAL;
246 }
247
248 cmd_param = fw_ptr;
249 fw_ptr += cmd->plen;
250 fw_size -= cmd->plen;
251
252 opcode = le16_to_cpu(cmd->opcode);
253
254 skb = __hci_cmd_sync(hdev, opcode, cmd->plen, cmd_param,
255 HCI_INIT_TIMEOUT);
256 if (IS_ERR(skb)) {
257 err = PTR_ERR(skb);
258 bt_dev_err(hdev, "BCM: Patch command %04x failed (%d)",
259 opcode, err);
260 return err;
261 }
262 kfree_skb(skb);
263 }
264
265 /* 250 msec delay after Launch Ram completes */
266 msleep(250);
267
268 return 0;
269}
270EXPORT_SYMBOL(btbcm_patchram);
271
272static int btbcm_reset(struct hci_dev *hdev)
273{
274 struct sk_buff *skb;
275
276 skb = __hci_cmd_sync(hdev, HCI_OP_RESET, 0, NULL, HCI_INIT_TIMEOUT);
277 if (IS_ERR(skb)) {
278 int err = PTR_ERR(skb);
279
280 bt_dev_err(hdev, "BCM: Reset failed (%d)", err);
281 return err;
282 }
283 kfree_skb(skb);
284
285 /* 100 msec delay for module to complete reset process */
286 msleep(100);
287
288 return 0;
289}
290
291static struct sk_buff *btbcm_read_local_name(struct hci_dev *hdev)
292{
293 struct sk_buff *skb;
294
295 skb = __hci_cmd_sync(hdev, HCI_OP_READ_LOCAL_NAME, 0, NULL,
296 HCI_INIT_TIMEOUT);
297 if (IS_ERR(skb)) {
298 bt_dev_err(hdev, "BCM: Reading local name failed (%ld)",
299 PTR_ERR(skb));
300 return skb;
301 }
302
303 if (skb->len != sizeof(struct hci_rp_read_local_name)) {
304 bt_dev_err(hdev, "BCM: Local name length mismatch");
305 kfree_skb(skb);
306 return ERR_PTR(-EIO);
307 }
308
309 return skb;
310}
311
312static struct sk_buff *btbcm_read_local_version(struct hci_dev *hdev)
313{
314 struct sk_buff *skb;
315
316 skb = __hci_cmd_sync(hdev, HCI_OP_READ_LOCAL_VERSION, 0, NULL,
317 HCI_INIT_TIMEOUT);
318 if (IS_ERR(skb)) {
319 bt_dev_err(hdev, "BCM: Reading local version info failed (%ld)",
320 PTR_ERR(skb));
321 return skb;
322 }
323
324 if (skb->len != sizeof(struct hci_rp_read_local_version)) {
325 bt_dev_err(hdev, "BCM: Local version length mismatch");
326 kfree_skb(skb);
327 return ERR_PTR(-EIO);
328 }
329
330 return skb;
331}
332
333static struct sk_buff *btbcm_read_verbose_config(struct hci_dev *hdev)
334{
335 struct sk_buff *skb;
336
337 skb = __hci_cmd_sync(hdev, 0xfc79, 0, NULL, HCI_INIT_TIMEOUT);
338 if (IS_ERR(skb)) {
339 bt_dev_err(hdev, "BCM: Read verbose config info failed (%ld)",
340 PTR_ERR(skb));
341 return skb;
342 }
343
344 if (skb->len != 7) {
345 bt_dev_err(hdev, "BCM: Verbose config length mismatch");
346 kfree_skb(skb);
347 return ERR_PTR(-EIO);
348 }
349
350 return skb;
351}
352
353static struct sk_buff *btbcm_read_controller_features(struct hci_dev *hdev)
354{
355 struct sk_buff *skb;
356
357 skb = __hci_cmd_sync(hdev, 0xfc6e, 0, NULL, HCI_INIT_TIMEOUT);
358 if (IS_ERR(skb)) {
359 bt_dev_err(hdev, "BCM: Read controller features failed (%ld)",
360 PTR_ERR(skb));
361 return skb;
362 }
363
364 if (skb->len != 9) {
365 bt_dev_err(hdev, "BCM: Controller features length mismatch");
366 kfree_skb(skb);
367 return ERR_PTR(-EIO);
368 }
369
370 return skb;
371}
372
373static struct sk_buff *btbcm_read_usb_product(struct hci_dev *hdev)
374{
375 struct sk_buff *skb;
376
377 skb = __hci_cmd_sync(hdev, 0xfc5a, 0, NULL, HCI_INIT_TIMEOUT);
378 if (IS_ERR(skb)) {
379 bt_dev_err(hdev, "BCM: Read USB product info failed (%ld)",
380 PTR_ERR(skb));
381 return skb;
382 }
383
384 if (skb->len != 5) {
385 bt_dev_err(hdev, "BCM: USB product length mismatch");
386 kfree_skb(skb);
387 return ERR_PTR(-EIO);
388 }
389
390 return skb;
391}
392
393static const struct dmi_system_id disable_broken_read_transmit_power[] = {
394 {
395 .matches = {
396 DMI_MATCH(DMI_BOARD_VENDOR, "Apple Inc."),
397 DMI_MATCH(DMI_PRODUCT_NAME, "MacBookPro16,1"),
398 },
399 },
400 {
401 .matches = {
402 DMI_MATCH(DMI_BOARD_VENDOR, "Apple Inc."),
403 DMI_MATCH(DMI_PRODUCT_NAME, "MacBookPro16,2"),
404 },
405 },
406 {
407 .matches = {
408 DMI_MATCH(DMI_BOARD_VENDOR, "Apple Inc."),
409 DMI_MATCH(DMI_PRODUCT_NAME, "MacBookPro16,4"),
410 },
411 },
412 {
413 .matches = {
414 DMI_MATCH(DMI_BOARD_VENDOR, "Apple Inc."),
415 DMI_MATCH(DMI_PRODUCT_NAME, "MacBookAir8,1"),
416 },
417 },
418 {
419 .matches = {
420 DMI_MATCH(DMI_BOARD_VENDOR, "Apple Inc."),
421 DMI_MATCH(DMI_PRODUCT_NAME, "MacBookAir8,2"),
422 },
423 },
424 {
425 .matches = {
426 DMI_MATCH(DMI_BOARD_VENDOR, "Apple Inc."),
427 DMI_MATCH(DMI_PRODUCT_NAME, "iMac20,1"),
428 },
429 },
430 {
431 .matches = {
432 DMI_MATCH(DMI_BOARD_VENDOR, "Apple Inc."),
433 DMI_MATCH(DMI_PRODUCT_NAME, "iMac20,2"),
434 },
435 },
436 { }
437};
438
439static int btbcm_read_info(struct hci_dev *hdev)
440{
441 struct sk_buff *skb;
442
443 /* Read Verbose Config Version Info */
444 skb = btbcm_read_verbose_config(hdev);
445 if (IS_ERR(skb))
446 return PTR_ERR(skb);
447
448 bt_dev_info(hdev, "BCM: chip id %u", skb->data[1]);
449 kfree_skb(skb);
450
451 return 0;
452}
453
454static int btbcm_print_controller_features(struct hci_dev *hdev)
455{
456 struct sk_buff *skb;
457
458 /* Read Controller Features */
459 skb = btbcm_read_controller_features(hdev);
460 if (IS_ERR(skb))
461 return PTR_ERR(skb);
462
463 bt_dev_info(hdev, "BCM: features 0x%2.2x", skb->data[1]);
464 kfree_skb(skb);
465
466 /* Read DMI and disable broken Read LE Min/Max Tx Power */
467 if (dmi_first_match(disable_broken_read_transmit_power))
468 hci_set_quirk(hdev, HCI_QUIRK_BROKEN_READ_TRANSMIT_POWER);
469
470 return 0;
471}
472
473static int btbcm_print_local_name(struct hci_dev *hdev)
474{
475 struct sk_buff *skb;
476
477 /* Read Local Name */
478 skb = btbcm_read_local_name(hdev);
479 if (IS_ERR(skb))
480 return PTR_ERR(skb);
481
482 bt_dev_info(hdev, "%s", (char *)(skb->data + 1));
483 kfree_skb(skb);
484
485 return 0;
486}
487
488struct bcm_subver_table {
489 u16 subver;
490 const char *name;
491};
492
493static const struct bcm_subver_table bcm_uart_subver_table[] = {
494 { 0x1111, "BCM4362A2" }, /* 000.017.017 */
495 { 0x4103, "BCM4330B1" }, /* 002.001.003 */
496 { 0x410d, "BCM4334B0" }, /* 002.001.013 */
497 { 0x410e, "BCM43341B0" }, /* 002.001.014 */
498 { 0x4204, "BCM2076B1" }, /* 002.002.004 */
499 { 0x4406, "BCM4324B3" }, /* 002.004.006 */
500 { 0x4606, "BCM4324B5" }, /* 002.006.006 */
501 { 0x6109, "BCM4335C0" }, /* 003.001.009 */
502 { 0x610c, "BCM4354" }, /* 003.001.012 */
503 { 0x2122, "BCM4343A0" }, /* 001.001.034 */
504 { 0x2209, "BCM43430A1" }, /* 001.002.009 */
505 { 0x6119, "BCM4345C0" }, /* 003.001.025 */
506 { 0x6606, "BCM4345C5" }, /* 003.006.006 */
507 { 0x230f, "BCM4356A2" }, /* 001.003.015 */
508 { 0x2310, "BCM4343A2" }, /* 001.003.016 */
509 { 0x220e, "BCM20702A1" }, /* 001.002.014 */
510 { 0x420d, "BCM4349B1" }, /* 002.002.013 */
511 { 0x420e, "BCM4349B1" }, /* 002.002.014 */
512 { 0x4217, "BCM4329B1" }, /* 002.002.023 */
513 { 0x6106, "BCM4359C0" }, /* 003.001.006 */
514 { 0x4106, "BCM4335A0" }, /* 002.001.006 */
515 { 0x410c, "BCM43430B0" }, /* 002.001.012 */
516 { 0x2119, "BCM4373A0" }, /* 001.001.025 */
517 { }
518};
519
520static const struct bcm_subver_table bcm_usb_subver_table[] = {
521 { 0x2105, "BCM20703A1" }, /* 001.001.005 */
522 { 0x210b, "BCM43142A0" }, /* 001.001.011 */
523 { 0x2112, "BCM4314A0" }, /* 001.001.018 */
524 { 0x2118, "BCM20702A0" }, /* 001.001.024 */
525 { 0x2126, "BCM4335A0" }, /* 001.001.038 */
526 { 0x220e, "BCM20702A1" }, /* 001.002.014 */
527 { 0x230f, "BCM4356A2" }, /* 001.003.015 */
528 { 0x4106, "BCM4335B0" }, /* 002.001.006 */
529 { 0x410e, "BCM20702B0" }, /* 002.001.014 */
530 { 0x6109, "BCM4335C0" }, /* 003.001.009 */
531 { 0x610c, "BCM4354" }, /* 003.001.012 */
532 { 0x6607, "BCM4350C5" }, /* 003.006.007 */
533 { }
534};
535
536/*
537 * This currently only looks up the device tree board appendix,
538 * but can be expanded to other mechanisms.
539 */
540static const char *btbcm_get_board_name(struct device *dev)
541{
542#ifdef CONFIG_OF
543 struct device_node *root __free(device_node) = of_find_node_by_path("/");
544 char *board_type;
545 const char *tmp;
546
547 if (!root)
548 return NULL;
549
550 if (of_property_read_string_index(root, "compatible", 0, &tmp))
551 return NULL;
552
553 /* get rid of any '/' in the compatible string */
554 board_type = devm_kstrdup(dev, tmp, GFP_KERNEL);
555 if (!board_type)
556 return NULL;
557
558 strreplace(board_type, '/', '-');
559
560 return board_type;
561#else
562 return NULL;
563#endif
564}
565
566int btbcm_initialize(struct hci_dev *hdev, bool *fw_load_done, bool use_autobaud_mode)
567{
568 u16 subver, rev, pid, vid;
569 struct sk_buff *skb;
570 struct hci_rp_read_local_version *ver;
571 const struct bcm_subver_table *bcm_subver_table;
572 const char *hw_name = NULL;
573 const char *board_name;
574 char postfix[16] = "";
575 int fw_name_count = 0;
576 bcm_fw_name *fw_name;
577 const struct firmware *fw;
578 int i, err;
579
580 board_name = btbcm_get_board_name(&hdev->dev);
581
582 /* Reset */
583 err = btbcm_reset(hdev);
584 if (err)
585 return err;
586
587 /* Read Local Version Info */
588 skb = btbcm_read_local_version(hdev);
589 if (IS_ERR(skb))
590 return PTR_ERR(skb);
591
592 ver = (struct hci_rp_read_local_version *)skb->data;
593 rev = le16_to_cpu(ver->hci_rev);
594 subver = le16_to_cpu(ver->lmp_subver);
595 kfree_skb(skb);
596
597 /* Read controller information */
598 if (!(*fw_load_done)) {
599 err = btbcm_read_info(hdev);
600 if (err)
601 return err;
602 }
603
604 if (!use_autobaud_mode) {
605 err = btbcm_print_controller_features(hdev);
606 if (err)
607 return err;
608
609 err = btbcm_print_local_name(hdev);
610 if (err)
611 return err;
612 }
613
614 bcm_subver_table = (hdev->bus == HCI_USB) ? bcm_usb_subver_table :
615 bcm_uart_subver_table;
616
617 for (i = 0; bcm_subver_table[i].name; i++) {
618 if (subver == bcm_subver_table[i].subver) {
619 hw_name = bcm_subver_table[i].name;
620 break;
621 }
622 }
623
624 bt_dev_info(hdev, "%s (%3.3u.%3.3u.%3.3u) build %4.4u",
625 hw_name ? hw_name : "BCM", (subver & 0xe000) >> 13,
626 (subver & 0x1f00) >> 8, (subver & 0x00ff), rev & 0x0fff);
627
628 if (*fw_load_done)
629 return 0;
630
631 if (hdev->bus == HCI_USB) {
632 /* Read USB Product Info */
633 skb = btbcm_read_usb_product(hdev);
634 if (IS_ERR(skb))
635 return PTR_ERR(skb);
636
637 vid = get_unaligned_le16(skb->data + 1);
638 pid = get_unaligned_le16(skb->data + 3);
639 kfree_skb(skb);
640
641 snprintf(postfix, sizeof(postfix), "-%4.4x-%4.4x", vid, pid);
642 }
643
644 fw_name = kmalloc_array(BCM_FW_NAME_COUNT_MAX,
645 sizeof(*fw_name),
646 GFP_KERNEL);
647 if (!fw_name)
648 return -ENOMEM;
649
650 if (hw_name) {
651 if (board_name) {
652 snprintf(fw_name[fw_name_count], BCM_FW_NAME_LEN,
653 "brcm/%s%s.%s.hcd", hw_name, postfix, board_name);
654 fw_name_count++;
655 }
656 snprintf(fw_name[fw_name_count], BCM_FW_NAME_LEN,
657 "brcm/%s%s.hcd", hw_name, postfix);
658 fw_name_count++;
659 }
660
661 if (board_name) {
662 snprintf(fw_name[fw_name_count], BCM_FW_NAME_LEN,
663 "brcm/BCM%s.%s.hcd", postfix, board_name);
664 fw_name_count++;
665 }
666 snprintf(fw_name[fw_name_count], BCM_FW_NAME_LEN,
667 "brcm/BCM%s.hcd", postfix);
668 fw_name_count++;
669
670 for (i = 0; i < fw_name_count; i++) {
671 err = firmware_request_nowarn(&fw, fw_name[i], &hdev->dev);
672 if (err == 0) {
673 bt_dev_info(hdev, "%s '%s' Patch",
674 hw_name ? hw_name : "BCM", fw_name[i]);
675 *fw_load_done = true;
676 break;
677 }
678 }
679
680 if (*fw_load_done) {
681 err = btbcm_patchram(hdev, fw);
682 if (err)
683 bt_dev_info(hdev, "BCM: Patch failed (%d)", err);
684
685 release_firmware(fw);
686 } else {
687 bt_dev_err(hdev, "BCM: firmware Patch file not found, tried:");
688 for (i = 0; i < fw_name_count; i++)
689 bt_dev_err(hdev, "BCM: '%s'", fw_name[i]);
690 }
691
692 kfree(fw_name);
693 return 0;
694}
695EXPORT_SYMBOL_GPL(btbcm_initialize);
696
697int btbcm_finalize(struct hci_dev *hdev, bool *fw_load_done, bool use_autobaud_mode)
698{
699 int err;
700
701 /* Re-initialize if necessary */
702 if (*fw_load_done) {
703 err = btbcm_initialize(hdev, fw_load_done, use_autobaud_mode);
704 if (err)
705 return err;
706 }
707
708 btbcm_check_bdaddr(hdev);
709
710 hci_set_quirk(hdev, HCI_QUIRK_STRICT_DUPLICATE_FILTER);
711
712 return 0;
713}
714EXPORT_SYMBOL_GPL(btbcm_finalize);
715
716int btbcm_setup_patchram(struct hci_dev *hdev)
717{
718 bool fw_load_done = false;
719 bool use_autobaud_mode = false;
720 int err;
721
722 /* Initialize */
723 err = btbcm_initialize(hdev, &fw_load_done, use_autobaud_mode);
724 if (err)
725 return err;
726
727 /* Re-initialize after loading Patch */
728 return btbcm_finalize(hdev, &fw_load_done, use_autobaud_mode);
729}
730EXPORT_SYMBOL_GPL(btbcm_setup_patchram);
731
732int btbcm_setup_apple(struct hci_dev *hdev)
733{
734 struct sk_buff *skb;
735 int err;
736
737 /* Reset */
738 err = btbcm_reset(hdev);
739 if (err)
740 return err;
741
742 /* Read Verbose Config Version Info */
743 skb = btbcm_read_verbose_config(hdev);
744 if (!IS_ERR(skb)) {
745 bt_dev_info(hdev, "BCM: chip id %u build %4.4u",
746 skb->data[1], get_unaligned_le16(skb->data + 5));
747 kfree_skb(skb);
748 }
749
750 /* Read USB Product Info */
751 skb = btbcm_read_usb_product(hdev);
752 if (!IS_ERR(skb)) {
753 bt_dev_info(hdev, "BCM: product %4.4x:%4.4x",
754 get_unaligned_le16(skb->data + 1),
755 get_unaligned_le16(skb->data + 3));
756 kfree_skb(skb);
757 }
758
759 /* Read Controller Features */
760 skb = btbcm_read_controller_features(hdev);
761 if (!IS_ERR(skb)) {
762 bt_dev_info(hdev, "BCM: features 0x%2.2x", skb->data[1]);
763 kfree_skb(skb);
764 }
765
766 /* Read Local Name */
767 skb = btbcm_read_local_name(hdev);
768 if (!IS_ERR(skb)) {
769 bt_dev_info(hdev, "%s", (char *)(skb->data + 1));
770 kfree_skb(skb);
771 }
772
773 hci_set_quirk(hdev, HCI_QUIRK_STRICT_DUPLICATE_FILTER);
774
775 return 0;
776}
777EXPORT_SYMBOL_GPL(btbcm_setup_apple);
778
779MODULE_AUTHOR("Marcel Holtmann <[email protected]>");
780MODULE_DESCRIPTION("Bluetooth support for Broadcom devices ver " VERSION);
781MODULE_VERSION(VERSION);
782MODULE_LICENSE("GPL");