3 * Bluetooth support for Broadcom devices
5 * Copyright (C) 2015 Intel Corporation
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.
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.
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
24 #include <linux/module.h>
25 #include <linux/firmware.h>
26 #include <asm/unaligned.h>
28 #include <net/bluetooth/bluetooth.h>
29 #include <net/bluetooth/hci_core.h>
35 #define BDADDR_BCM20702A0 (&(bdaddr_t) {{0x00, 0xa0, 0x02, 0x70, 0x20, 0x00}})
36 #define BDADDR_BCM20702A1 (&(bdaddr_t) {{0x00, 0x00, 0xa0, 0x02, 0x70, 0x20}})
37 #define BDADDR_BCM2076B1 (&(bdaddr_t) {{0x79, 0x56, 0x00, 0xa0, 0x76, 0x20}})
38 #define BDADDR_BCM43430A0 (&(bdaddr_t) {{0xac, 0x1f, 0x12, 0xa0, 0x43, 0x43}})
39 #define BDADDR_BCM4324B3 (&(bdaddr_t) {{0x00, 0x00, 0x00, 0xb3, 0x24, 0x43}})
40 #define BDADDR_BCM4330B1 (&(bdaddr_t) {{0x00, 0x00, 0x00, 0xb1, 0x30, 0x43}})
41 #define BDADDR_BCM43341B (&(bdaddr_t) {{0xac, 0x1f, 0x00, 0x1b, 0x34, 0x43}})
43 int btbcm_check_bdaddr(struct hci_dev *hdev)
45 struct hci_rp_read_bd_addr *bda;
48 skb = __hci_cmd_sync(hdev, HCI_OP_READ_BD_ADDR, 0, NULL,
51 int err = PTR_ERR(skb);
52 bt_dev_err(hdev, "BCM: Reading device address failed (%d)", err);
56 if (skb->len != sizeof(*bda)) {
57 bt_dev_err(hdev, "BCM: Device address length mismatch");
62 bda = (struct hci_rp_read_bd_addr *)skb->data;
64 /* Check if the address indicates a controller with either an
65 * invalid or default address. In both cases the device needs
66 * to be marked as not having a valid address.
68 * The address 00:20:70:02:A0:00 indicates a BCM20702A0 controller
69 * with no configured address.
71 * The address 20:70:02:A0:00:00 indicates a BCM20702A1 controller
72 * with no configured address.
74 * The address 20:76:A0:00:56:79 indicates a BCM2076B1 controller
75 * with no configured address.
77 * The address 43:24:B3:00:00:00 indicates a BCM4324B3 controller
78 * with waiting for configuration state.
80 * The address 43:30:B1:00:00:00 indicates a BCM4330B1 controller
81 * with waiting for configuration state.
83 * The address 43:43:A0:12:1F:AC indicates a BCM43430A0 controller
84 * with no configured address.
86 if (!bacmp(&bda->bdaddr, BDADDR_BCM20702A0) ||
87 !bacmp(&bda->bdaddr, BDADDR_BCM20702A1) ||
88 !bacmp(&bda->bdaddr, BDADDR_BCM2076B1) ||
89 !bacmp(&bda->bdaddr, BDADDR_BCM4324B3) ||
90 !bacmp(&bda->bdaddr, BDADDR_BCM4330B1) ||
91 !bacmp(&bda->bdaddr, BDADDR_BCM43430A0) ||
92 !bacmp(&bda->bdaddr, BDADDR_BCM43341B)) {
93 bt_dev_info(hdev, "BCM: Using default device address (%pMR)",
95 set_bit(HCI_QUIRK_INVALID_BDADDR, &hdev->quirks);
102 EXPORT_SYMBOL_GPL(btbcm_check_bdaddr);
104 int btbcm_set_bdaddr(struct hci_dev *hdev, const bdaddr_t *bdaddr)
109 skb = __hci_cmd_sync(hdev, 0xfc01, 6, bdaddr, HCI_INIT_TIMEOUT);
112 bt_dev_err(hdev, "BCM: Change address command failed (%d)", err);
119 EXPORT_SYMBOL_GPL(btbcm_set_bdaddr);
121 int btbcm_patchram(struct hci_dev *hdev, const struct firmware *fw)
123 const struct hci_command_hdr *cmd;
131 skb = __hci_cmd_sync(hdev, 0xfc2e, 0, NULL, HCI_INIT_TIMEOUT);
134 bt_dev_err(hdev, "BCM: Download Minidrv command failed (%d)",
140 /* 50 msec delay after Download Minidrv completes */
146 while (fw_size >= sizeof(*cmd)) {
149 cmd = (struct hci_command_hdr *)fw_ptr;
150 fw_ptr += sizeof(*cmd);
151 fw_size -= sizeof(*cmd);
153 if (fw_size < cmd->plen) {
154 bt_dev_err(hdev, "BCM: Patch is corrupted");
161 fw_size -= cmd->plen;
163 opcode = le16_to_cpu(cmd->opcode);
165 skb = __hci_cmd_sync(hdev, opcode, cmd->plen, cmd_param,
169 bt_dev_err(hdev, "BCM: Patch command %04x failed (%d)",
176 /* 250 msec delay after Launch Ram completes */
182 EXPORT_SYMBOL(btbcm_patchram);
184 static int btbcm_reset(struct hci_dev *hdev)
188 skb = __hci_cmd_sync(hdev, HCI_OP_RESET, 0, NULL, HCI_INIT_TIMEOUT);
190 int err = PTR_ERR(skb);
191 bt_dev_err(hdev, "BCM: Reset failed (%d)", err);
196 /* 100 msec delay for module to complete reset process */
202 static struct sk_buff *btbcm_read_local_name(struct hci_dev *hdev)
206 skb = __hci_cmd_sync(hdev, HCI_OP_READ_LOCAL_NAME, 0, NULL,
209 bt_dev_err(hdev, "BCM: Reading local name failed (%ld)",
214 if (skb->len != sizeof(struct hci_rp_read_local_name)) {
215 bt_dev_err(hdev, "BCM: Local name length mismatch");
217 return ERR_PTR(-EIO);
223 static struct sk_buff *btbcm_read_local_version(struct hci_dev *hdev)
227 skb = __hci_cmd_sync(hdev, HCI_OP_READ_LOCAL_VERSION, 0, NULL,
230 bt_dev_err(hdev, "BCM: Reading local version info failed (%ld)",
235 if (skb->len != sizeof(struct hci_rp_read_local_version)) {
236 bt_dev_err(hdev, "BCM: Local version length mismatch");
238 return ERR_PTR(-EIO);
244 static struct sk_buff *btbcm_read_verbose_config(struct hci_dev *hdev)
248 skb = __hci_cmd_sync(hdev, 0xfc79, 0, NULL, HCI_INIT_TIMEOUT);
250 bt_dev_err(hdev, "BCM: Read verbose config info failed (%ld)",
256 bt_dev_err(hdev, "BCM: Verbose config length mismatch");
258 return ERR_PTR(-EIO);
264 static struct sk_buff *btbcm_read_controller_features(struct hci_dev *hdev)
268 skb = __hci_cmd_sync(hdev, 0xfc6e, 0, NULL, HCI_INIT_TIMEOUT);
270 bt_dev_err(hdev, "BCM: Read controller features failed (%ld)",
276 bt_dev_err(hdev, "BCM: Controller features length mismatch");
278 return ERR_PTR(-EIO);
284 static struct sk_buff *btbcm_read_usb_product(struct hci_dev *hdev)
288 skb = __hci_cmd_sync(hdev, 0xfc5a, 0, NULL, HCI_INIT_TIMEOUT);
290 bt_dev_err(hdev, "BCM: Read USB product info failed (%ld)",
296 bt_dev_err(hdev, "BCM: USB product length mismatch");
298 return ERR_PTR(-EIO);
304 static int btbcm_read_info(struct hci_dev *hdev)
308 /* Read Verbose Config Version Info */
309 skb = btbcm_read_verbose_config(hdev);
313 bt_dev_info(hdev, "BCM: chip id %u", skb->data[1]);
316 /* Read Controller Features */
317 skb = btbcm_read_controller_features(hdev);
321 bt_dev_info(hdev, "BCM: features 0x%2.2x", skb->data[1]);
324 /* Read Local Name */
325 skb = btbcm_read_local_name(hdev);
329 bt_dev_info(hdev, "%s", (char *)(skb->data + 1));
335 struct bcm_subver_table {
340 static const struct bcm_subver_table bcm_uart_subver_table[] = {
341 { 0x4103, "BCM4330B1" }, /* 002.001.003 */
342 { 0x410e, "BCM43341B0" }, /* 002.001.014 */
343 { 0x4204, "BCM2076B1" }, /* 002.002.004 */
344 { 0x4406, "BCM4324B3" }, /* 002.004.006 */
345 { 0x6109, "BCM4335C0" }, /* 003.001.009 */
346 { 0x610c, "BCM4354" }, /* 003.001.012 */
347 { 0x2122, "BCM4343A0" }, /* 001.001.034 */
348 { 0x2209, "BCM43430A1" }, /* 001.002.009 */
349 { 0x6119, "BCM4345C0" }, /* 003.001.025 */
350 { 0x230f, "BCM4356A2" }, /* 001.003.015 */
351 { 0x220e, "BCM20702A1" }, /* 001.002.014 */
352 { 0x4217, "BCM4329B1" }, /* 002.002.023 */
356 static const struct bcm_subver_table bcm_usb_subver_table[] = {
357 { 0x210b, "BCM43142A0" }, /* 001.001.011 */
358 { 0x2112, "BCM4314A0" }, /* 001.001.018 */
359 { 0x2118, "BCM20702A0" }, /* 001.001.024 */
360 { 0x2126, "BCM4335A0" }, /* 001.001.038 */
361 { 0x220e, "BCM20702A1" }, /* 001.002.014 */
362 { 0x230f, "BCM4354A2" }, /* 001.003.015 */
363 { 0x4106, "BCM4335B0" }, /* 002.001.006 */
364 { 0x410e, "BCM20702B0" }, /* 002.001.014 */
365 { 0x6109, "BCM4335C0" }, /* 003.001.009 */
366 { 0x610c, "BCM4354" }, /* 003.001.012 */
370 int btbcm_initialize(struct hci_dev *hdev, char *fw_name, size_t len,
373 u16 subver, rev, pid, vid;
374 const char *hw_name = "BCM";
376 struct hci_rp_read_local_version *ver;
377 const struct bcm_subver_table *bcm_subver_table;
381 err = btbcm_reset(hdev);
385 /* Read Local Version Info */
386 skb = btbcm_read_local_version(hdev);
390 ver = (struct hci_rp_read_local_version *)skb->data;
391 rev = le16_to_cpu(ver->hci_rev);
392 subver = le16_to_cpu(ver->lmp_subver);
395 /* Read controller information */
397 err = btbcm_read_info(hdev);
402 /* Upper nibble of rev should be between 0 and 3? */
403 if (((rev & 0xf000) >> 12) > 3)
406 bcm_subver_table = (hdev->bus == HCI_USB) ? bcm_usb_subver_table :
407 bcm_uart_subver_table;
409 for (i = 0; bcm_subver_table[i].name; i++) {
410 if (subver == bcm_subver_table[i].subver) {
411 hw_name = bcm_subver_table[i].name;
416 if (hdev->bus == HCI_USB) {
417 /* Read USB Product Info */
418 skb = btbcm_read_usb_product(hdev);
422 vid = get_unaligned_le16(skb->data + 1);
423 pid = get_unaligned_le16(skb->data + 3);
426 snprintf(fw_name, len, "brcm/%s-%4.4x-%4.4x.hcd",
429 snprintf(fw_name, len, "brcm/%s.hcd", hw_name);
432 bt_dev_info(hdev, "%s (%3.3u.%3.3u.%3.3u) build %4.4u",
433 hw_name, (subver & 0xe000) >> 13,
434 (subver & 0x1f00) >> 8, (subver & 0x00ff), rev & 0x0fff);
438 EXPORT_SYMBOL_GPL(btbcm_initialize);
440 int btbcm_finalize(struct hci_dev *hdev)
446 err = btbcm_initialize(hdev, fw_name, sizeof(fw_name), true);
450 btbcm_check_bdaddr(hdev);
452 set_bit(HCI_QUIRK_STRICT_DUPLICATE_FILTER, &hdev->quirks);
456 EXPORT_SYMBOL_GPL(btbcm_finalize);
458 int btbcm_setup_patchram(struct hci_dev *hdev)
461 const struct firmware *fw;
466 err = btbcm_initialize(hdev, fw_name, sizeof(fw_name), false);
470 err = request_firmware(&fw, fw_name, &hdev->dev);
472 bt_dev_info(hdev, "BCM: Patch %s not found", fw_name);
476 btbcm_patchram(hdev, fw);
478 release_firmware(fw);
481 err = btbcm_initialize(hdev, fw_name, sizeof(fw_name), true);
485 /* Read Local Name */
486 skb = btbcm_read_local_name(hdev);
490 bt_dev_info(hdev, "%s", (char *)(skb->data + 1));
494 btbcm_check_bdaddr(hdev);
496 set_bit(HCI_QUIRK_STRICT_DUPLICATE_FILTER, &hdev->quirks);
500 EXPORT_SYMBOL_GPL(btbcm_setup_patchram);
502 int btbcm_setup_apple(struct hci_dev *hdev)
508 err = btbcm_reset(hdev);
512 /* Read Verbose Config Version Info */
513 skb = btbcm_read_verbose_config(hdev);
515 bt_dev_info(hdev, "BCM: chip id %u build %4.4u",
516 skb->data[1], get_unaligned_le16(skb->data + 5));
520 /* Read USB Product Info */
521 skb = btbcm_read_usb_product(hdev);
523 bt_dev_info(hdev, "BCM: product %4.4x:%4.4x",
524 get_unaligned_le16(skb->data + 1),
525 get_unaligned_le16(skb->data + 3));
529 /* Read Controller Features */
530 skb = btbcm_read_controller_features(hdev);
532 bt_dev_info(hdev, "BCM: features 0x%2.2x", skb->data[1]);
536 /* Read Local Name */
537 skb = btbcm_read_local_name(hdev);
539 bt_dev_info(hdev, "%s", (char *)(skb->data + 1));
543 set_bit(HCI_QUIRK_STRICT_DUPLICATE_FILTER, &hdev->quirks);
547 EXPORT_SYMBOL_GPL(btbcm_setup_apple);
549 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
550 MODULE_DESCRIPTION("Bluetooth support for Broadcom devices ver " VERSION);
551 MODULE_VERSION(VERSION);
552 MODULE_LICENSE("GPL");