btbcm.c 15 KB

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