GNU Linux-libre 4.9.328-gnu1
[releases.git] / drivers / bluetooth / btbcm.c
1 /*
2  *
3  *  Bluetooth support for Broadcom devices
4  *
5  *  Copyright (C) 2015  Intel Corporation
6  *
7  *
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.
12  *
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.
17  *
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
21  *
22  */
23
24 #include <linux/module.h>
25 #include <linux/firmware.h>
26 #include <asm/unaligned.h>
27
28 #include <net/bluetooth/bluetooth.h>
29 #include <net/bluetooth/hci_core.h>
30
31 #include "btbcm.h"
32
33 #define VERSION "0.1"
34
35 #define BDADDR_BCM20702A0 (&(bdaddr_t) {{0x00, 0xa0, 0x02, 0x70, 0x20, 0x00}})
36 #define BDADDR_BCM4324B3 (&(bdaddr_t) {{0x00, 0x00, 0x00, 0xb3, 0x24, 0x43}})
37 #define BDADDR_BCM4330B1 (&(bdaddr_t) {{0x00, 0x00, 0x00, 0xb1, 0x30, 0x43}})
38
39 int btbcm_check_bdaddr(struct hci_dev *hdev)
40 {
41         struct hci_rp_read_bd_addr *bda;
42         struct sk_buff *skb;
43
44         skb = __hci_cmd_sync(hdev, HCI_OP_READ_BD_ADDR, 0, NULL,
45                              HCI_INIT_TIMEOUT);
46         if (IS_ERR(skb)) {
47                 int err = PTR_ERR(skb);
48                 BT_ERR("%s: BCM: Reading device address failed (%d)",
49                        hdev->name, err);
50                 return err;
51         }
52
53         if (skb->len != sizeof(*bda)) {
54                 BT_ERR("%s: BCM: Device address length mismatch", hdev->name);
55                 kfree_skb(skb);
56                 return -EIO;
57         }
58
59         bda = (struct hci_rp_read_bd_addr *)skb->data;
60
61         /* Check if the address indicates a controller with either an
62          * invalid or default address. In both cases the device needs
63          * to be marked as not having a valid address.
64          *
65          * The address 00:20:70:02:A0:00 indicates a BCM20702A0 controller
66          * with no configured address.
67          *
68          * The address 43:24:B3:00:00:00 indicates a BCM4324B3 controller
69          * with waiting for configuration state.
70          *
71          * The address 43:30:B1:00:00:00 indicates a BCM4330B1 controller
72          * with waiting for configuration state.
73          */
74         if (!bacmp(&bda->bdaddr, BDADDR_BCM20702A0) ||
75             !bacmp(&bda->bdaddr, BDADDR_BCM4324B3) ||
76             !bacmp(&bda->bdaddr, BDADDR_BCM4330B1)) {
77                 BT_INFO("%s: BCM: Using default device address (%pMR)",
78                         hdev->name, &bda->bdaddr);
79                 set_bit(HCI_QUIRK_INVALID_BDADDR, &hdev->quirks);
80         }
81
82         kfree_skb(skb);
83
84         return 0;
85 }
86 EXPORT_SYMBOL_GPL(btbcm_check_bdaddr);
87
88 int btbcm_set_bdaddr(struct hci_dev *hdev, const bdaddr_t *bdaddr)
89 {
90         struct sk_buff *skb;
91         int err;
92
93         skb = __hci_cmd_sync(hdev, 0xfc01, 6, bdaddr, HCI_INIT_TIMEOUT);
94         if (IS_ERR(skb)) {
95                 err = PTR_ERR(skb);
96                 BT_ERR("%s: BCM: Change address command failed (%d)",
97                        hdev->name, err);
98                 return err;
99         }
100         kfree_skb(skb);
101
102         return 0;
103 }
104 EXPORT_SYMBOL_GPL(btbcm_set_bdaddr);
105
106 int btbcm_patchram(struct hci_dev *hdev, const struct firmware *fw)
107 {
108         const struct hci_command_hdr *cmd;
109         const u8 *fw_ptr;
110         size_t fw_size;
111         struct sk_buff *skb;
112         u16 opcode;
113         int err = 0;
114
115         /* Start Download */
116         skb = __hci_cmd_sync(hdev, 0xfc2e, 0, NULL, HCI_INIT_TIMEOUT);
117         if (IS_ERR(skb)) {
118                 err = PTR_ERR(skb);
119                 BT_ERR("%s: BCM: Download Minidrv command failed (%d)",
120                        hdev->name, err);
121                 goto done;
122         }
123         kfree_skb(skb);
124
125         /* 50 msec delay after Download Minidrv completes */
126         msleep(50);
127
128         fw_ptr = fw->data;
129         fw_size = fw->size;
130
131         while (fw_size >= sizeof(*cmd)) {
132                 const u8 *cmd_param;
133
134                 cmd = (struct hci_command_hdr *)fw_ptr;
135                 fw_ptr += sizeof(*cmd);
136                 fw_size -= sizeof(*cmd);
137
138                 if (fw_size < cmd->plen) {
139                         BT_ERR("%s: BCM: Patch is corrupted", hdev->name);
140                         err = -EINVAL;
141                         goto done;
142                 }
143
144                 cmd_param = fw_ptr;
145                 fw_ptr += cmd->plen;
146                 fw_size -= cmd->plen;
147
148                 opcode = le16_to_cpu(cmd->opcode);
149
150                 skb = __hci_cmd_sync(hdev, opcode, cmd->plen, cmd_param,
151                                      HCI_INIT_TIMEOUT);
152                 if (IS_ERR(skb)) {
153                         err = PTR_ERR(skb);
154                         BT_ERR("%s: BCM: Patch command %04x failed (%d)",
155                                hdev->name, opcode, err);
156                         goto done;
157                 }
158                 kfree_skb(skb);
159         }
160
161         /* 250 msec delay after Launch Ram completes */
162         msleep(250);
163
164 done:
165         return err;
166 }
167 EXPORT_SYMBOL(btbcm_patchram);
168
169 static int btbcm_reset(struct hci_dev *hdev)
170 {
171         struct sk_buff *skb;
172
173         skb = __hci_cmd_sync(hdev, HCI_OP_RESET, 0, NULL, HCI_INIT_TIMEOUT);
174         if (IS_ERR(skb)) {
175                 int err = PTR_ERR(skb);
176                 BT_ERR("%s: BCM: Reset failed (%d)", hdev->name, err);
177                 return err;
178         }
179         kfree_skb(skb);
180
181         return 0;
182 }
183
184 static struct sk_buff *btbcm_read_local_name(struct hci_dev *hdev)
185 {
186         struct sk_buff *skb;
187
188         skb = __hci_cmd_sync(hdev, HCI_OP_READ_LOCAL_NAME, 0, NULL,
189                              HCI_INIT_TIMEOUT);
190         if (IS_ERR(skb)) {
191                 BT_ERR("%s: BCM: Reading local name failed (%ld)",
192                        hdev->name, PTR_ERR(skb));
193                 return skb;
194         }
195
196         if (skb->len != sizeof(struct hci_rp_read_local_name)) {
197                 BT_ERR("%s: BCM: Local name length mismatch", hdev->name);
198                 kfree_skb(skb);
199                 return ERR_PTR(-EIO);
200         }
201
202         return skb;
203 }
204
205 static struct sk_buff *btbcm_read_local_version(struct hci_dev *hdev)
206 {
207         struct sk_buff *skb;
208
209         skb = __hci_cmd_sync(hdev, HCI_OP_READ_LOCAL_VERSION, 0, NULL,
210                              HCI_INIT_TIMEOUT);
211         if (IS_ERR(skb)) {
212                 BT_ERR("%s: BCM: Reading local version info failed (%ld)",
213                        hdev->name, PTR_ERR(skb));
214                 return skb;
215         }
216
217         if (skb->len != sizeof(struct hci_rp_read_local_version)) {
218                 BT_ERR("%s: BCM: Local version length mismatch", hdev->name);
219                 kfree_skb(skb);
220                 return ERR_PTR(-EIO);
221         }
222
223         return skb;
224 }
225
226 static struct sk_buff *btbcm_read_verbose_config(struct hci_dev *hdev)
227 {
228         struct sk_buff *skb;
229
230         skb = __hci_cmd_sync(hdev, 0xfc79, 0, NULL, HCI_INIT_TIMEOUT);
231         if (IS_ERR(skb)) {
232                 BT_ERR("%s: BCM: Read verbose config info failed (%ld)",
233                        hdev->name, PTR_ERR(skb));
234                 return skb;
235         }
236
237         if (skb->len != 7) {
238                 BT_ERR("%s: BCM: Verbose config length mismatch", hdev->name);
239                 kfree_skb(skb);
240                 return ERR_PTR(-EIO);
241         }
242
243         return skb;
244 }
245
246 static struct sk_buff *btbcm_read_usb_product(struct hci_dev *hdev)
247 {
248         struct sk_buff *skb;
249
250         skb = __hci_cmd_sync(hdev, 0xfc5a, 0, NULL, HCI_INIT_TIMEOUT);
251         if (IS_ERR(skb)) {
252                 BT_ERR("%s: BCM: Read USB product info failed (%ld)",
253                        hdev->name, PTR_ERR(skb));
254                 return skb;
255         }
256
257         if (skb->len != 5) {
258                 BT_ERR("%s: BCM: USB product length mismatch", hdev->name);
259                 kfree_skb(skb);
260                 return ERR_PTR(-EIO);
261         }
262
263         return skb;
264 }
265
266 static const struct {
267         u16 subver;
268         const char *name;
269 } bcm_uart_subver_table[] = {
270         { 0x4103, "BCM4330B1"   },      /* 002.001.003 */
271         { 0x410e, "BCM43341B0"  },      /* 002.001.014 */
272         { 0x4406, "BCM4324B3"   },      /* 002.004.006 */
273         { 0x6109, "BCM4335C0"   },      /* 003.001.009 */
274         { 0x610c, "BCM4354"     },      /* 003.001.012 */
275         { }
276 };
277
278 int btbcm_initialize(struct hci_dev *hdev, char *fw_name, size_t len)
279 {
280         u16 subver, rev;
281         const char *hw_name = NULL;
282         struct sk_buff *skb;
283         struct hci_rp_read_local_version *ver;
284         int i, err;
285
286         /* Reset */
287         err = btbcm_reset(hdev);
288         if (err)
289                 return err;
290
291         /* Read Local Version Info */
292         skb = btbcm_read_local_version(hdev);
293         if (IS_ERR(skb))
294                 return PTR_ERR(skb);
295
296         ver = (struct hci_rp_read_local_version *)skb->data;
297         rev = le16_to_cpu(ver->hci_rev);
298         subver = le16_to_cpu(ver->lmp_subver);
299         kfree_skb(skb);
300
301         /* Read Verbose Config Version Info */
302         skb = btbcm_read_verbose_config(hdev);
303         if (IS_ERR(skb))
304                 return PTR_ERR(skb);
305
306         BT_INFO("%s: BCM: chip id %u", hdev->name, skb->data[1]);
307         kfree_skb(skb);
308
309         switch ((rev & 0xf000) >> 12) {
310         case 0:
311         case 1:
312         case 3:
313                 for (i = 0; bcm_uart_subver_table[i].name; i++) {
314                         if (subver == bcm_uart_subver_table[i].subver) {
315                                 hw_name = bcm_uart_subver_table[i].name;
316                                 break;
317                         }
318                 }
319
320                 snprintf(fw_name, len, "/*(DEBLOBBED)*/", hw_name ? : "BCM");
321                 break;
322         default:
323                 return 0;
324         }
325
326         BT_INFO("%s: %s (%3.3u.%3.3u.%3.3u) build %4.4u", hdev->name,
327                 hw_name ? : "BCM", (subver & 0xe000) >> 13,
328                 (subver & 0x1f00) >> 8, (subver & 0x00ff), rev & 0x0fff);
329
330         return 0;
331 }
332 EXPORT_SYMBOL_GPL(btbcm_initialize);
333
334 int btbcm_finalize(struct hci_dev *hdev)
335 {
336         struct sk_buff *skb;
337         struct hci_rp_read_local_version *ver;
338         u16 subver, rev;
339         int err;
340
341         /* Reset */
342         err = btbcm_reset(hdev);
343         if (err)
344                 return err;
345
346         /* Read Local Version Info */
347         skb = btbcm_read_local_version(hdev);
348         if (IS_ERR(skb))
349                 return PTR_ERR(skb);
350
351         ver = (struct hci_rp_read_local_version *)skb->data;
352         rev = le16_to_cpu(ver->hci_rev);
353         subver = le16_to_cpu(ver->lmp_subver);
354         kfree_skb(skb);
355
356         BT_INFO("%s: BCM (%3.3u.%3.3u.%3.3u) build %4.4u", hdev->name,
357                 (subver & 0xe000) >> 13, (subver & 0x1f00) >> 8,
358                 (subver & 0x00ff), rev & 0x0fff);
359
360         btbcm_check_bdaddr(hdev);
361
362         set_bit(HCI_QUIRK_STRICT_DUPLICATE_FILTER, &hdev->quirks);
363
364         return 0;
365 }
366 EXPORT_SYMBOL_GPL(btbcm_finalize);
367
368 static const struct {
369         u16 subver;
370         const char *name;
371 } bcm_usb_subver_table[] = {
372         { 0x210b, "BCM43142A0"  },      /* 001.001.011 */
373         { 0x2112, "BCM4314A0"   },      /* 001.001.018 */
374         { 0x2118, "BCM20702A0"  },      /* 001.001.024 */
375         { 0x2126, "BCM4335A0"   },      /* 001.001.038 */
376         { 0x220e, "BCM20702A1"  },      /* 001.002.014 */
377         { 0x230f, "BCM4354A2"   },      /* 001.003.015 */
378         { 0x4106, "BCM4335B0"   },      /* 002.001.006 */
379         { 0x410e, "BCM20702B0"  },      /* 002.001.014 */
380         { 0x6109, "BCM4335C0"   },      /* 003.001.009 */
381         { 0x610c, "BCM4354"     },      /* 003.001.012 */
382         { }
383 };
384
385 int btbcm_setup_patchram(struct hci_dev *hdev)
386 {
387         char fw_name[64];
388         const struct firmware *fw;
389         u16 subver, rev, pid, vid;
390         const char *hw_name = NULL;
391         struct sk_buff *skb;
392         struct hci_rp_read_local_version *ver;
393         int i, err;
394
395         /* Reset */
396         err = btbcm_reset(hdev);
397         if (err)
398                 return err;
399
400         /* Read Local Version Info */
401         skb = btbcm_read_local_version(hdev);
402         if (IS_ERR(skb))
403                 return PTR_ERR(skb);
404
405         ver = (struct hci_rp_read_local_version *)skb->data;
406         rev = le16_to_cpu(ver->hci_rev);
407         subver = le16_to_cpu(ver->lmp_subver);
408         kfree_skb(skb);
409
410         /* Read Verbose Config Version Info */
411         skb = btbcm_read_verbose_config(hdev);
412         if (IS_ERR(skb))
413                 return PTR_ERR(skb);
414
415         BT_INFO("%s: BCM: chip id %u", hdev->name, skb->data[1]);
416         kfree_skb(skb);
417
418         /* Read Local Name */
419         skb = btbcm_read_local_name(hdev);
420         if (IS_ERR(skb))
421                 return PTR_ERR(skb);
422
423         BT_INFO("%s: %s", hdev->name, (char *)(skb->data + 1));
424         kfree_skb(skb);
425
426         switch ((rev & 0xf000) >> 12) {
427         case 0:
428         case 3:
429                 for (i = 0; bcm_uart_subver_table[i].name; i++) {
430                         if (subver == bcm_uart_subver_table[i].subver) {
431                                 hw_name = bcm_uart_subver_table[i].name;
432                                 break;
433                         }
434                 }
435
436                 snprintf(fw_name, sizeof(fw_name), "/*(DEBLOBBED)*/",
437                          hw_name ? : "BCM");
438                 break;
439         case 1:
440         case 2:
441                 /* Read USB Product Info */
442                 skb = btbcm_read_usb_product(hdev);
443                 if (IS_ERR(skb))
444                         return PTR_ERR(skb);
445
446                 vid = get_unaligned_le16(skb->data + 1);
447                 pid = get_unaligned_le16(skb->data + 3);
448                 kfree_skb(skb);
449
450                 for (i = 0; bcm_usb_subver_table[i].name; i++) {
451                         if (subver == bcm_usb_subver_table[i].subver) {
452                                 hw_name = bcm_usb_subver_table[i].name;
453                                 break;
454                         }
455                 }
456
457                 snprintf(fw_name, sizeof(fw_name), "/*(DEBLOBBED)*/",
458                          hw_name ? : "BCM", vid, pid);
459                 break;
460         default:
461                 return 0;
462         }
463
464         BT_INFO("%s: %s (%3.3u.%3.3u.%3.3u) build %4.4u", hdev->name,
465                 hw_name ? : "BCM", (subver & 0xe000) >> 13,
466                 (subver & 0x1f00) >> 8, (subver & 0x00ff), rev & 0x0fff);
467
468         err = reject_firmware(&fw, fw_name, &hdev->dev);
469         if (err < 0) {
470                 BT_INFO("%s: BCM: Patch %s not found", hdev->name, fw_name);
471                 goto done;
472         }
473
474         btbcm_patchram(hdev, fw);
475
476         release_firmware(fw);
477
478         /* Reset */
479         err = btbcm_reset(hdev);
480         if (err)
481                 return err;
482
483         /* Read Local Version Info */
484         skb = btbcm_read_local_version(hdev);
485         if (IS_ERR(skb))
486                 return PTR_ERR(skb);
487
488         ver = (struct hci_rp_read_local_version *)skb->data;
489         rev = le16_to_cpu(ver->hci_rev);
490         subver = le16_to_cpu(ver->lmp_subver);
491         kfree_skb(skb);
492
493         BT_INFO("%s: %s (%3.3u.%3.3u.%3.3u) build %4.4u", hdev->name,
494                 hw_name ? : "BCM", (subver & 0xe000) >> 13,
495                 (subver & 0x1f00) >> 8, (subver & 0x00ff), rev & 0x0fff);
496
497         /* Read Local Name */
498         skb = btbcm_read_local_name(hdev);
499         if (IS_ERR(skb))
500                 return PTR_ERR(skb);
501
502         BT_INFO("%s: %s", hdev->name, (char *)(skb->data + 1));
503         kfree_skb(skb);
504
505 done:
506         btbcm_check_bdaddr(hdev);
507
508         set_bit(HCI_QUIRK_STRICT_DUPLICATE_FILTER, &hdev->quirks);
509
510         return 0;
511 }
512 EXPORT_SYMBOL_GPL(btbcm_setup_patchram);
513
514 int btbcm_setup_apple(struct hci_dev *hdev)
515 {
516         struct sk_buff *skb;
517         int err;
518
519         /* Reset */
520         err = btbcm_reset(hdev);
521         if (err)
522                 return err;
523
524         /* Read Verbose Config Version Info */
525         skb = btbcm_read_verbose_config(hdev);
526         if (!IS_ERR(skb)) {
527                 BT_INFO("%s: BCM: chip id %u build %4.4u", hdev->name,
528                         skb->data[1], get_unaligned_le16(skb->data + 5));
529                 kfree_skb(skb);
530         }
531
532         /* Read USB Product Info */
533         skb = btbcm_read_usb_product(hdev);
534         if (!IS_ERR(skb)) {
535                 BT_INFO("%s: BCM: product %4.4x:%4.4x", hdev->name,
536                         get_unaligned_le16(skb->data + 1),
537                         get_unaligned_le16(skb->data + 3));
538                 kfree_skb(skb);
539         }
540
541         /* Read Local Name */
542         skb = btbcm_read_local_name(hdev);
543         if (!IS_ERR(skb)) {
544                 BT_INFO("%s: %s", hdev->name, (char *)(skb->data + 1));
545                 kfree_skb(skb);
546         }
547
548         set_bit(HCI_QUIRK_STRICT_DUPLICATE_FILTER, &hdev->quirks);
549
550         return 0;
551 }
552 EXPORT_SYMBOL_GPL(btbcm_setup_apple);
553
554 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
555 MODULE_DESCRIPTION("Bluetooth support for Broadcom devices ver " VERSION);
556 MODULE_VERSION(VERSION);
557 MODULE_LICENSE("GPL");