drivers/bluetooth/btbcm.c

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