1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18#include <linux/module.h>
19#include <linux/firmware.h>
20#include <asm/unaligned.h>
21#include <linux/usb.h>
22
23#include <net/bluetooth/bluetooth.h>
24#include <net/bluetooth/hci_core.h>
25
26#include "btrtl.h"
27
28#define VERSION "0.1"
29
30#define RTL_EPATCH_SIGNATURE "Realtech"
31#define RTL_ROM_LMP_3499 0x3499
32#define RTL_ROM_LMP_8723A 0x1200
33#define RTL_ROM_LMP_8723B 0x8723
34#define RTL_ROM_LMP_8821A 0x8821
35#define RTL_ROM_LMP_8761A 0x8761
36#define RTL_ROM_LMP_8822B 0x8822
37#define RTL_CONFIG_MAGIC 0x8723ab55
38
39#define IC_MATCH_FL_LMPSUBV (1 << 0)
40#define IC_MATCH_FL_HCIREV (1 << 1)
41#define IC_MATCH_FL_HCIVER (1 << 2)
42#define IC_MATCH_FL_HCIBUS (1 << 3)
43#define IC_INFO(lmps, hcir) \
44 .match_flags = IC_MATCH_FL_LMPSUBV | IC_MATCH_FL_HCIREV, \
45 .lmp_subver = (lmps), \
46 .hci_rev = (hcir)
47
48struct id_table {
49 __u16 match_flags;
50 __u16 lmp_subver;
51 __u16 hci_rev;
52 __u8 hci_ver;
53 __u8 hci_bus;
54 bool config_needed;
55 bool has_rom_version;
56 char *fw_name;
57 char *cfg_name;
58};
59
60struct btrtl_device_info {
61 const struct id_table *ic_info;
62 u8 rom_version;
63 u8 *fw_data;
64 int fw_len;
65 u8 *cfg_data;
66 int cfg_len;
67};
68
69static const struct id_table ic_id_table[] = {
70 { IC_MATCH_FL_LMPSUBV, RTL_ROM_LMP_8723A, 0x0,
71 .config_needed = false,
72 .has_rom_version = false,
73 .fw_name = "rtl_bt/rtl8723a_fw.bin",
74 .cfg_name = NULL },
75
76 { IC_MATCH_FL_LMPSUBV, RTL_ROM_LMP_3499, 0x0,
77 .config_needed = false,
78 .has_rom_version = false,
79 .fw_name = "rtl_bt/rtl8723a_fw.bin",
80 .cfg_name = NULL },
81
82
83 { .match_flags = IC_MATCH_FL_LMPSUBV | IC_MATCH_FL_HCIREV |
84 IC_MATCH_FL_HCIVER | IC_MATCH_FL_HCIBUS,
85 .lmp_subver = RTL_ROM_LMP_8723B,
86 .hci_rev = 0xb,
87 .hci_ver = 6,
88 .hci_bus = HCI_UART,
89 .config_needed = true,
90 .has_rom_version = true,
91 .fw_name = "rtl_bt/rtl8723bs_fw.bin",
92 .cfg_name = "rtl_bt/rtl8723bs_config" },
93
94
95 { IC_INFO(RTL_ROM_LMP_8723B, 0xb),
96 .config_needed = false,
97 .has_rom_version = true,
98 .fw_name = "rtl_bt/rtl8723b_fw.bin",
99 .cfg_name = "rtl_bt/rtl8723b_config" },
100
101
102 { IC_INFO(RTL_ROM_LMP_8723B, 0xd),
103 .config_needed = true,
104 .has_rom_version = true,
105 .fw_name = "rtl_bt/rtl8723d_fw.bin",
106 .cfg_name = "rtl_bt/rtl8723d_config" },
107
108
109 { .match_flags = IC_MATCH_FL_LMPSUBV | IC_MATCH_FL_HCIREV |
110 IC_MATCH_FL_HCIVER | IC_MATCH_FL_HCIBUS,
111 .lmp_subver = RTL_ROM_LMP_8723B,
112 .hci_rev = 0xd,
113 .hci_ver = 8,
114 .hci_bus = HCI_UART,
115 .config_needed = true,
116 .has_rom_version = true,
117 .fw_name = "rtl_bt/rtl8723ds_fw.bin",
118 .cfg_name = "rtl_bt/rtl8723ds_config" },
119
120
121 { IC_INFO(RTL_ROM_LMP_8821A, 0xa),
122 .config_needed = false,
123 .has_rom_version = true,
124 .fw_name = "rtl_bt/rtl8821a_fw.bin",
125 .cfg_name = "rtl_bt/rtl8821a_config" },
126
127
128 { IC_INFO(RTL_ROM_LMP_8821A, 0xc),
129 .config_needed = false,
130 .has_rom_version = true,
131 .fw_name = "rtl_bt/rtl8821c_fw.bin",
132 .cfg_name = "rtl_bt/rtl8821c_config" },
133
134
135 { IC_MATCH_FL_LMPSUBV, RTL_ROM_LMP_8761A, 0x0,
136 .config_needed = false,
137 .has_rom_version = true,
138 .fw_name = "rtl_bt/rtl8761a_fw.bin",
139 .cfg_name = "rtl_bt/rtl8761a_config" },
140
141
142 { IC_INFO(RTL_ROM_LMP_8822B, 0xc),
143 .config_needed = false,
144 .has_rom_version = true,
145 .fw_name = "rtl_bt/rtl8822cu_fw.bin",
146 .cfg_name = "rtl_bt/rtl8822cu_config" },
147
148
149 { IC_INFO(RTL_ROM_LMP_8822B, 0xb),
150 .config_needed = true,
151 .has_rom_version = true,
152 .fw_name = "rtl_bt/rtl8822b_fw.bin",
153 .cfg_name = "rtl_bt/rtl8822b_config" },
154 };
155
156static const struct id_table *btrtl_match_ic(u16 lmp_subver, u16 hci_rev,
157 u8 hci_ver, u8 hci_bus)
158{
159 int i;
160
161 for (i = 0; i < ARRAY_SIZE(ic_id_table); i++) {
162 if ((ic_id_table[i].match_flags & IC_MATCH_FL_LMPSUBV) &&
163 (ic_id_table[i].lmp_subver != lmp_subver))
164 continue;
165 if ((ic_id_table[i].match_flags & IC_MATCH_FL_HCIREV) &&
166 (ic_id_table[i].hci_rev != hci_rev))
167 continue;
168 if ((ic_id_table[i].match_flags & IC_MATCH_FL_HCIVER) &&
169 (ic_id_table[i].hci_ver != hci_ver))
170 continue;
171 if ((ic_id_table[i].match_flags & IC_MATCH_FL_HCIBUS) &&
172 (ic_id_table[i].hci_bus != hci_bus))
173 continue;
174
175 break;
176 }
177 if (i >= ARRAY_SIZE(ic_id_table))
178 return NULL;
179
180 return &ic_id_table[i];
181}
182
183static int rtl_read_rom_version(struct hci_dev *hdev, u8 *version)
184{
185 struct rtl_rom_version_evt *rom_version;
186 struct sk_buff *skb;
187
188
189 skb = __hci_cmd_sync(hdev, 0xfc6d, 0, NULL, HCI_INIT_TIMEOUT);
190 if (IS_ERR(skb)) {
191 rtl_dev_err(hdev, "Read ROM version failed (%ld)\n",
192 PTR_ERR(skb));
193 return PTR_ERR(skb);
194 }
195
196 if (skb->len != sizeof(*rom_version)) {
197 rtl_dev_err(hdev, "RTL version event length mismatch\n");
198 kfree_skb(skb);
199 return -EIO;
200 }
201
202 rom_version = (struct rtl_rom_version_evt *)skb->data;
203 rtl_dev_info(hdev, "rom_version status=%x version=%x\n",
204 rom_version->status, rom_version->version);
205
206 *version = rom_version->version;
207
208 kfree_skb(skb);
209 return 0;
210}
211
212static int rtlbt_parse_firmware(struct hci_dev *hdev,
213 struct btrtl_device_info *btrtl_dev,
214 unsigned char **_buf)
215{
216 static const u8 extension_sig[] = { 0x51, 0x04, 0xfd, 0x77 };
217 struct rtl_epatch_header *epatch_info;
218 unsigned char *buf;
219 int i, len;
220 size_t min_size;
221 u8 opcode, length, data;
222 int project_id = -1;
223 const unsigned char *fwptr, *chip_id_base;
224 const unsigned char *patch_length_base, *patch_offset_base;
225 u32 patch_offset = 0;
226 u16 patch_length, num_patches;
227 static const struct {
228 __u16 lmp_subver;
229 __u8 id;
230 } project_id_to_lmp_subver[] = {
231 { RTL_ROM_LMP_8723A, 0 },
232 { RTL_ROM_LMP_8723B, 1 },
233 { RTL_ROM_LMP_8821A, 2 },
234 { RTL_ROM_LMP_8761A, 3 },
235 { RTL_ROM_LMP_8822B, 8 },
236 { RTL_ROM_LMP_8723B, 9 },
237 { RTL_ROM_LMP_8821A, 10 },
238 { RTL_ROM_LMP_8822B, 13 },
239 };
240
241 min_size = sizeof(struct rtl_epatch_header) + sizeof(extension_sig) + 3;
242 if (btrtl_dev->fw_len < min_size)
243 return -EINVAL;
244
245 fwptr = btrtl_dev->fw_data + btrtl_dev->fw_len - sizeof(extension_sig);
246 if (memcmp(fwptr, extension_sig, sizeof(extension_sig)) != 0) {
247 rtl_dev_err(hdev, "extension section signature mismatch\n");
248 return -EINVAL;
249 }
250
251
252
253
254
255
256
257 while (fwptr >= btrtl_dev->fw_data + (sizeof(*epatch_info) + 3)) {
258 opcode = *--fwptr;
259 length = *--fwptr;
260 data = *--fwptr;
261
262 BT_DBG("check op=%x len=%x data=%x", opcode, length, data);
263
264 if (opcode == 0xff)
265 break;
266
267 if (length == 0) {
268 rtl_dev_err(hdev, "found instruction with length 0\n");
269 return -EINVAL;
270 }
271
272 if (opcode == 0 && length == 1) {
273 project_id = data;
274 break;
275 }
276
277 fwptr -= length;
278 }
279
280 if (project_id < 0) {
281 rtl_dev_err(hdev, "failed to find version instruction\n");
282 return -EINVAL;
283 }
284
285
286 for (i = 0; i < ARRAY_SIZE(project_id_to_lmp_subver); i++) {
287 if (project_id == project_id_to_lmp_subver[i].id)
288 break;
289 }
290
291 if (i >= ARRAY_SIZE(project_id_to_lmp_subver)) {
292 rtl_dev_err(hdev, "unknown project id %d\n", project_id);
293 return -EINVAL;
294 }
295
296 if (btrtl_dev->ic_info->lmp_subver !=
297 project_id_to_lmp_subver[i].lmp_subver) {
298 rtl_dev_err(hdev, "firmware is for %x but this is a %x\n",
299 project_id_to_lmp_subver[i].lmp_subver,
300 btrtl_dev->ic_info->lmp_subver);
301 return -EINVAL;
302 }
303
304 epatch_info = (struct rtl_epatch_header *)btrtl_dev->fw_data;
305 if (memcmp(epatch_info->signature, RTL_EPATCH_SIGNATURE, 8) != 0) {
306 rtl_dev_err(hdev, "bad EPATCH signature\n");
307 return -EINVAL;
308 }
309
310 num_patches = le16_to_cpu(epatch_info->num_patches);
311 BT_DBG("fw_version=%x, num_patches=%d",
312 le32_to_cpu(epatch_info->fw_version), num_patches);
313
314
315
316
317
318
319
320 min_size += 8 * num_patches;
321 if (btrtl_dev->fw_len < min_size)
322 return -EINVAL;
323
324 chip_id_base = btrtl_dev->fw_data + sizeof(struct rtl_epatch_header);
325 patch_length_base = chip_id_base + (sizeof(u16) * num_patches);
326 patch_offset_base = patch_length_base + (sizeof(u16) * num_patches);
327 for (i = 0; i < num_patches; i++) {
328 u16 chip_id = get_unaligned_le16(chip_id_base +
329 (i * sizeof(u16)));
330 if (chip_id == btrtl_dev->rom_version + 1) {
331 patch_length = get_unaligned_le16(patch_length_base +
332 (i * sizeof(u16)));
333 patch_offset = get_unaligned_le32(patch_offset_base +
334 (i * sizeof(u32)));
335 break;
336 }
337 }
338
339 if (!patch_offset) {
340 rtl_dev_err(hdev, "didn't find patch for chip id %d",
341 btrtl_dev->rom_version);
342 return -EINVAL;
343 }
344
345 BT_DBG("length=%x offset=%x index %d", patch_length, patch_offset, i);
346 min_size = patch_offset + patch_length;
347 if (btrtl_dev->fw_len < min_size)
348 return -EINVAL;
349
350
351
352
353 len = patch_length;
354 buf = kmemdup(btrtl_dev->fw_data + patch_offset, patch_length,
355 GFP_KERNEL);
356 if (!buf)
357 return -ENOMEM;
358
359 memcpy(buf + patch_length - 4, &epatch_info->fw_version, 4);
360
361 *_buf = buf;
362 return len;
363}
364
365static int rtl_download_firmware(struct hci_dev *hdev,
366 const unsigned char *data, int fw_len)
367{
368 struct rtl_download_cmd *dl_cmd;
369 int frag_num = fw_len / RTL_FRAG_LEN + 1;
370 int frag_len = RTL_FRAG_LEN;
371 int ret = 0;
372 int i;
373
374 dl_cmd = kmalloc(sizeof(struct rtl_download_cmd), GFP_KERNEL);
375 if (!dl_cmd)
376 return -ENOMEM;
377
378 for (i = 0; i < frag_num; i++) {
379 struct sk_buff *skb;
380
381 BT_DBG("download fw (%d/%d)", i, frag_num);
382
383 dl_cmd->index = i;
384 if (i == (frag_num - 1)) {
385 dl_cmd->index |= 0x80;
386 frag_len = fw_len % RTL_FRAG_LEN;
387 }
388 memcpy(dl_cmd->data, data, frag_len);
389
390
391 skb = __hci_cmd_sync(hdev, 0xfc20, frag_len + 1, dl_cmd,
392 HCI_INIT_TIMEOUT);
393 if (IS_ERR(skb)) {
394 rtl_dev_err(hdev, "download fw command failed (%ld)\n",
395 PTR_ERR(skb));
396 ret = -PTR_ERR(skb);
397 goto out;
398 }
399
400 if (skb->len != sizeof(struct rtl_download_response)) {
401 rtl_dev_err(hdev, "download fw event length mismatch\n");
402 kfree_skb(skb);
403 ret = -EIO;
404 goto out;
405 }
406
407 kfree_skb(skb);
408 data += RTL_FRAG_LEN;
409 }
410
411out:
412 kfree(dl_cmd);
413 return ret;
414}
415
416static int rtl_load_file(struct hci_dev *hdev, const char *name, u8 **buff)
417{
418 const struct firmware *fw;
419 int ret;
420
421 rtl_dev_info(hdev, "rtl: loading %s\n", name);
422 ret = request_firmware(&fw, name, &hdev->dev);
423 if (ret < 0)
424 return ret;
425 ret = fw->size;
426 *buff = kmemdup(fw->data, ret, GFP_KERNEL);
427 if (!*buff)
428 ret = -ENOMEM;
429
430 release_firmware(fw);
431
432 return ret;
433}
434
435static int btrtl_setup_rtl8723a(struct hci_dev *hdev,
436 struct btrtl_device_info *btrtl_dev)
437{
438 if (btrtl_dev->fw_len < 8)
439 return -EINVAL;
440
441
442
443
444 if (!memcmp(btrtl_dev->fw_data, RTL_EPATCH_SIGNATURE, 8)) {
445 rtl_dev_err(hdev, "unexpected EPATCH signature!\n");
446 return -EINVAL;
447 }
448
449 return rtl_download_firmware(hdev, btrtl_dev->fw_data,
450 btrtl_dev->fw_len);
451}
452
453static int btrtl_setup_rtl8723b(struct hci_dev *hdev,
454 struct btrtl_device_info *btrtl_dev)
455{
456 unsigned char *fw_data = NULL;
457 int ret;
458 u8 *tbuff;
459
460 ret = rtlbt_parse_firmware(hdev, btrtl_dev, &fw_data);
461 if (ret < 0)
462 goto out;
463
464 if (btrtl_dev->cfg_len > 0) {
465 tbuff = kzalloc(ret + btrtl_dev->cfg_len, GFP_KERNEL);
466 if (!tbuff) {
467 ret = -ENOMEM;
468 goto out;
469 }
470
471 memcpy(tbuff, fw_data, ret);
472 kfree(fw_data);
473
474 memcpy(tbuff + ret, btrtl_dev->cfg_data, btrtl_dev->cfg_len);
475 ret += btrtl_dev->cfg_len;
476
477 fw_data = tbuff;
478 }
479
480 rtl_dev_info(hdev, "cfg_sz %d, total sz %d\n", btrtl_dev->cfg_len, ret);
481
482 ret = rtl_download_firmware(hdev, fw_data, ret);
483
484out:
485 kfree(fw_data);
486 return ret;
487}
488
489static struct sk_buff *btrtl_read_local_version(struct hci_dev *hdev)
490{
491 struct sk_buff *skb;
492
493 skb = __hci_cmd_sync(hdev, HCI_OP_READ_LOCAL_VERSION, 0, NULL,
494 HCI_INIT_TIMEOUT);
495 if (IS_ERR(skb)) {
496 rtl_dev_err(hdev, "HCI_OP_READ_LOCAL_VERSION failed (%ld)\n",
497 PTR_ERR(skb));
498 return skb;
499 }
500
501 if (skb->len != sizeof(struct hci_rp_read_local_version)) {
502 rtl_dev_err(hdev, "HCI_OP_READ_LOCAL_VERSION event length mismatch\n");
503 kfree_skb(skb);
504 return ERR_PTR(-EIO);
505 }
506
507 return skb;
508}
509
510void btrtl_free(struct btrtl_device_info *btrtl_dev)
511{
512 kfree(btrtl_dev->fw_data);
513 kfree(btrtl_dev->cfg_data);
514 kfree(btrtl_dev);
515}
516EXPORT_SYMBOL_GPL(btrtl_free);
517
518struct btrtl_device_info *btrtl_initialize(struct hci_dev *hdev,
519 const char *postfix)
520{
521 struct btrtl_device_info *btrtl_dev;
522 struct sk_buff *skb;
523 struct hci_rp_read_local_version *resp;
524 char cfg_name[40];
525 u16 hci_rev, lmp_subver;
526 u8 hci_ver;
527 int ret;
528
529 btrtl_dev = kzalloc(sizeof(*btrtl_dev), GFP_KERNEL);
530 if (!btrtl_dev) {
531 ret = -ENOMEM;
532 goto err_alloc;
533 }
534
535 skb = btrtl_read_local_version(hdev);
536 if (IS_ERR(skb)) {
537 ret = PTR_ERR(skb);
538 goto err_free;
539 }
540
541 resp = (struct hci_rp_read_local_version *)skb->data;
542 rtl_dev_info(hdev, "rtl: examining hci_ver=%02x hci_rev=%04x lmp_ver=%02x lmp_subver=%04x\n",
543 resp->hci_ver, resp->hci_rev,
544 resp->lmp_ver, resp->lmp_subver);
545
546 hci_ver = resp->hci_ver;
547 hci_rev = le16_to_cpu(resp->hci_rev);
548 lmp_subver = le16_to_cpu(resp->lmp_subver);
549 kfree_skb(skb);
550
551 btrtl_dev->ic_info = btrtl_match_ic(lmp_subver, hci_rev, hci_ver,
552 hdev->bus);
553
554 if (!btrtl_dev->ic_info) {
555 rtl_dev_err(hdev, "rtl: unknown IC info, lmp subver %04x, hci rev %04x, hci ver %04x",
556 lmp_subver, hci_rev, hci_ver);
557 ret = -EINVAL;
558 goto err_free;
559 }
560
561 if (btrtl_dev->ic_info->has_rom_version) {
562 ret = rtl_read_rom_version(hdev, &btrtl_dev->rom_version);
563 if (ret)
564 goto err_free;
565 }
566
567 btrtl_dev->fw_len = rtl_load_file(hdev, btrtl_dev->ic_info->fw_name,
568 &btrtl_dev->fw_data);
569 if (btrtl_dev->fw_len < 0) {
570 rtl_dev_err(hdev, "firmware file %s not found\n",
571 btrtl_dev->ic_info->fw_name);
572 ret = btrtl_dev->fw_len;
573 goto err_free;
574 }
575
576 if (btrtl_dev->ic_info->cfg_name) {
577 if (postfix) {
578 snprintf(cfg_name, sizeof(cfg_name), "%s-%s.bin",
579 btrtl_dev->ic_info->cfg_name, postfix);
580 } else {
581 snprintf(cfg_name, sizeof(cfg_name), "%s.bin",
582 btrtl_dev->ic_info->cfg_name);
583 }
584 btrtl_dev->cfg_len = rtl_load_file(hdev, cfg_name,
585 &btrtl_dev->cfg_data);
586 if (btrtl_dev->ic_info->config_needed &&
587 btrtl_dev->cfg_len <= 0) {
588 rtl_dev_err(hdev, "mandatory config file %s not found\n",
589 btrtl_dev->ic_info->cfg_name);
590 ret = btrtl_dev->cfg_len;
591 goto err_free;
592 }
593 }
594
595 return btrtl_dev;
596
597err_free:
598 btrtl_free(btrtl_dev);
599err_alloc:
600 return ERR_PTR(ret);
601}
602EXPORT_SYMBOL_GPL(btrtl_initialize);
603
604int btrtl_download_firmware(struct hci_dev *hdev,
605 struct btrtl_device_info *btrtl_dev)
606{
607
608
609
610
611
612
613 switch (btrtl_dev->ic_info->lmp_subver) {
614 case RTL_ROM_LMP_8723A:
615 case RTL_ROM_LMP_3499:
616 return btrtl_setup_rtl8723a(hdev, btrtl_dev);
617 case RTL_ROM_LMP_8723B:
618 case RTL_ROM_LMP_8821A:
619 case RTL_ROM_LMP_8761A:
620 case RTL_ROM_LMP_8822B:
621 return btrtl_setup_rtl8723b(hdev, btrtl_dev);
622 default:
623 rtl_dev_info(hdev, "rtl: assuming no firmware upload needed\n");
624 return 0;
625 }
626}
627EXPORT_SYMBOL_GPL(btrtl_download_firmware);
628
629int btrtl_setup_realtek(struct hci_dev *hdev)
630{
631 struct btrtl_device_info *btrtl_dev;
632 int ret;
633
634 btrtl_dev = btrtl_initialize(hdev, NULL);
635 if (IS_ERR(btrtl_dev))
636 return PTR_ERR(btrtl_dev);
637
638 ret = btrtl_download_firmware(hdev, btrtl_dev);
639
640 btrtl_free(btrtl_dev);
641
642 return ret;
643}
644EXPORT_SYMBOL_GPL(btrtl_setup_realtek);
645
646static unsigned int btrtl_convert_baudrate(u32 device_baudrate)
647{
648 switch (device_baudrate) {
649 case 0x0252a00a:
650 return 230400;
651
652 case 0x05f75004:
653 return 921600;
654
655 case 0x00005004:
656 return 1000000;
657
658 case 0x04928002:
659 case 0x01128002:
660 return 1500000;
661
662 case 0x00005002:
663 return 2000000;
664
665 case 0x0000b001:
666 return 2500000;
667
668 case 0x04928001:
669 return 3000000;
670
671 case 0x052a6001:
672 return 3500000;
673
674 case 0x00005001:
675 return 4000000;
676
677 case 0x0252c014:
678 default:
679 return 115200;
680 }
681}
682
683int btrtl_get_uart_settings(struct hci_dev *hdev,
684 struct btrtl_device_info *btrtl_dev,
685 unsigned int *controller_baudrate,
686 u32 *device_baudrate, bool *flow_control)
687{
688 struct rtl_vendor_config *config;
689 struct rtl_vendor_config_entry *entry;
690 int i, total_data_len;
691 bool found = false;
692
693 total_data_len = btrtl_dev->cfg_len - sizeof(*config);
694 if (total_data_len <= 0) {
695 rtl_dev_warn(hdev, "no config loaded\n");
696 return -EINVAL;
697 }
698
699 config = (struct rtl_vendor_config *)btrtl_dev->cfg_data;
700 if (le32_to_cpu(config->signature) != RTL_CONFIG_MAGIC) {
701 rtl_dev_err(hdev, "invalid config magic\n");
702 return -EINVAL;
703 }
704
705 if (total_data_len < le16_to_cpu(config->total_len)) {
706 rtl_dev_err(hdev, "config is too short\n");
707 return -EINVAL;
708 }
709
710 for (i = 0; i < total_data_len; ) {
711 entry = ((void *)config->entry) + i;
712
713 switch (le16_to_cpu(entry->offset)) {
714 case 0xc:
715 if (entry->len < sizeof(*device_baudrate)) {
716 rtl_dev_err(hdev, "invalid UART config entry\n");
717 return -EINVAL;
718 }
719
720 *device_baudrate = get_unaligned_le32(entry->data);
721 *controller_baudrate = btrtl_convert_baudrate(
722 *device_baudrate);
723
724 if (entry->len >= 13)
725 *flow_control = !!(entry->data[12] & BIT(2));
726 else
727 *flow_control = false;
728
729 found = true;
730 break;
731
732 default:
733 rtl_dev_dbg(hdev, "skipping config entry 0x%x (len %u)\n",
734 le16_to_cpu(entry->offset), entry->len);
735 break;
736 };
737
738 i += sizeof(*entry) + entry->len;
739 }
740
741 if (!found) {
742 rtl_dev_err(hdev, "no UART config entry found\n");
743 return -ENOENT;
744 }
745
746 rtl_dev_dbg(hdev, "device baudrate = 0x%08x\n", *device_baudrate);
747 rtl_dev_dbg(hdev, "controller baudrate = %u\n", *controller_baudrate);
748 rtl_dev_dbg(hdev, "flow control %d\n", *flow_control);
749
750 return 0;
751}
752EXPORT_SYMBOL_GPL(btrtl_get_uart_settings);
753
754MODULE_AUTHOR("Daniel Drake <drake@endlessm.com>");
755MODULE_DESCRIPTION("Bluetooth support for Realtek devices ver " VERSION);
756MODULE_VERSION(VERSION);
757MODULE_LICENSE("GPL");
758MODULE_FIRMWARE("rtl_bt/rtl8723a_fw.bin");
759MODULE_FIRMWARE("rtl_bt/rtl8723b_fw.bin");
760MODULE_FIRMWARE("rtl_bt/rtl8723b_config.bin");
761MODULE_FIRMWARE("rtl_bt/rtl8723bs_fw.bin");
762MODULE_FIRMWARE("rtl_bt/rtl8723bs_config.bin");
763MODULE_FIRMWARE("rtl_bt/rtl8723ds_fw.bin");
764MODULE_FIRMWARE("rtl_bt/rtl8723ds_config.bin");
765MODULE_FIRMWARE("rtl_bt/rtl8761a_fw.bin");
766MODULE_FIRMWARE("rtl_bt/rtl8761a_config.bin");
767MODULE_FIRMWARE("rtl_bt/rtl8821a_fw.bin");
768MODULE_FIRMWARE("rtl_bt/rtl8821a_config.bin");
769MODULE_FIRMWARE("rtl_bt/rtl8822b_fw.bin");
770MODULE_FIRMWARE("rtl_bt/rtl8822b_config.bin");
771
