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 */ 34typedef char bcm_fw_name[BCM_FW_NAME_LEN]; 35 36#ifdef CONFIG_EFI 37static 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 67static int btbcm_set_bdaddr_from_efi(struct hci_dev *hdev) 68{ 69 return -EOPNOTSUPP; 70} 71#endif 72 73int 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} 138EXPORT_SYMBOL_GPL(btbcm_check_bdaddr); 139 140int 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} 155EXPORT_SYMBOL_GPL(btbcm_set_bdaddr); 156 157int 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} 183EXPORT_SYMBOL_GPL(btbcm_read_pcm_int_params); 184 185int 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} 201EXPORT_SYMBOL_GPL(btbcm_write_pcm_int_params); 202 203int 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 261done: 262 return err; 263} 264EXPORT_SYMBOL(btbcm_patchram); 265 266static 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 285static 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 306static 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 327static 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 347static 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 367static 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 387static 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 410static 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 425struct bcm_subver_table { 426 u16 subver; 427 const char *name; 428}; 429 430static 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 453static 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 469int 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 "brcm/%s%s.hcd", hw_name, postfix); 544 fw_name_count++; 545 } 546 547 snprintf(fw_name[fw_name_count], BCM_FW_NAME_LEN, 548 "brcm/BCM%s.hcd", postfix); 549 fw_name_count++; 550 551 for (i = 0; i < fw_name_count; i++) { 552 err = firmware_request_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} 576EXPORT_SYMBOL_GPL(btbcm_initialize); 577 578int 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} 595EXPORT_SYMBOL_GPL(btbcm_finalize); 596 597int 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} 610EXPORT_SYMBOL_GPL(btbcm_setup_patchram); 611 612int 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} 657EXPORT_SYMBOL_GPL(btbcm_setup_apple); 658 659MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>"); 660MODULE_DESCRIPTION("Bluetooth support for Broadcom devices ver " VERSION); 661MODULE_VERSION(VERSION); 662MODULE_LICENSE("GPL"); 663