?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
printf: Remove unused 'bprintf'
[drm/drm-misc.git] / drivers / bluetooth / btmtk.c
blob8a3f7c3fcfec87d2eb991f0931bdc8af77f5983e
1 // SPDX-License-Identifier: ISC
2 /* Copyright (C) 2021 MediaTek Inc.
3 *
4 */
5 #include <linux/module.h>
6 #include <linux/firmware.h>
7 #include <linux/usb.h>
8 #include <linux/iopoll.h>
9 #include <linux/unaligned.h>
10
11 #include <net/bluetooth/bluetooth.h>
12 #include <net/bluetooth/hci_core.h>
13
14 #include "btmtk.h"
15
16 #define VERSION "0.1"
17
18 /* It is for mt79xx download rom patch*/
19 #define MTK_FW_ROM_PATCH_HEADER_SIZE 32
20 #define MTK_FW_ROM_PATCH_GD_SIZE 64
21 #define MTK_FW_ROM_PATCH_SEC_MAP_SIZE 64
22 #define MTK_SEC_MAP_COMMON_SIZE 12
23 #define MTK_SEC_MAP_NEED_SEND_SIZE 52
24
25 /* It is for mt79xx iso data transmission setting */
26 #define MTK_ISO_THRESHOLD 264
27
28 struct btmtk_patch_header {
29 u8 datetime[16];
30 u8 platform[4];
31 __le16 hwver;
32 __le16 swver;
33 __le32 magicnum;
34 } __packed;
35
36 struct btmtk_global_desc {
37 __le32 patch_ver;
38 __le32 sub_sys;
39 __le32 feature_opt;
40 __le32 section_num;
41 } __packed;
42
43 struct btmtk_section_map {
44 __le32 sectype;
45 __le32 secoffset;
46 __le32 secsize;
47 union {
48 __le32 u4SecSpec[13];
49 struct {
50 __le32 dlAddr;
51 __le32 dlsize;
52 __le32 seckeyidx;
53 __le32 alignlen;
54 __le32 sectype;
55 __le32 dlmodecrctype;
56 __le32 crc;
57 __le32 reserved[6];
58 } bin_info_spec;
59 };
60 } __packed;
61
62 static void btmtk_coredump(struct hci_dev *hdev)
63 {
64 int err;
65
66 err = __hci_cmd_send(hdev, 0xfd5b, 0, NULL);
67 if (err < 0)
68 bt_dev_err(hdev, "Coredump failed (%d)", err);
69 }
70
71 static void btmtk_coredump_hdr(struct hci_dev *hdev, struct sk_buff *skb)
72 {
73 struct btmtk_data *data = hci_get_priv(hdev);
74 char buf[80];
75
76 snprintf(buf, sizeof(buf), "Controller Name: 0x%X\n",
77 data->dev_id);
78 skb_put_data(skb, buf, strlen(buf));
79
80 snprintf(buf, sizeof(buf), "Firmware Version: 0x%X\n",
81 data->cd_info.fw_version);
82 skb_put_data(skb, buf, strlen(buf));
83
84 snprintf(buf, sizeof(buf), "Driver: %s\n",
85 data->cd_info.driver_name);
86 skb_put_data(skb, buf, strlen(buf));
87
88 snprintf(buf, sizeof(buf), "Vendor: MediaTek\n");
89 skb_put_data(skb, buf, strlen(buf));
90 }
91
92 static void btmtk_coredump_notify(struct hci_dev *hdev, int state)
93 {
94 struct btmtk_data *data = hci_get_priv(hdev);
95
96 switch (state) {
97 case HCI_DEVCOREDUMP_IDLE:
98 data->cd_info.state = HCI_DEVCOREDUMP_IDLE;
99 break;
100 case HCI_DEVCOREDUMP_ACTIVE:
101 data->cd_info.state = HCI_DEVCOREDUMP_ACTIVE;
102 break;
103 case HCI_DEVCOREDUMP_TIMEOUT:
104 case HCI_DEVCOREDUMP_ABORT:
105 case HCI_DEVCOREDUMP_DONE:
106 data->cd_info.state = HCI_DEVCOREDUMP_IDLE;
107 btmtk_reset_sync(hdev);
108 break;
109 }
110 }
111
112 void btmtk_fw_get_filename(char *buf, size_t size, u32 dev_id, u32 fw_ver,
113 u32 fw_flavor)
114 {
115 if (dev_id == 0x7925)
116 snprintf(buf, size,
117 "mediatek/mt%04x/BT_RAM_CODE_MT%04x_1_%x_hdr.bin",
118 dev_id & 0xffff, dev_id & 0xffff, (fw_ver & 0xff) + 1);
119 else if (dev_id == 0x7961 && fw_flavor)
120 snprintf(buf, size,
121 "mediatek/BT_RAM_CODE_MT%04x_1a_%x_hdr.bin",
122 dev_id & 0xffff, (fw_ver & 0xff) + 1);
123 else
124 snprintf(buf, size,
125 "mediatek/BT_RAM_CODE_MT%04x_1_%x_hdr.bin",
126 dev_id & 0xffff, (fw_ver & 0xff) + 1);
127 }
128 EXPORT_SYMBOL_GPL(btmtk_fw_get_filename);
129
130 int btmtk_setup_firmware_79xx(struct hci_dev *hdev, const char *fwname,
131 wmt_cmd_sync_func_t wmt_cmd_sync)
132 {
133 struct btmtk_hci_wmt_params wmt_params;
134 struct btmtk_patch_header *hdr;
135 struct btmtk_global_desc *globaldesc = NULL;
136 struct btmtk_section_map *sectionmap;
137 const struct firmware *fw;
138 const u8 *fw_ptr;
139 const u8 *fw_bin_ptr;
140 int err, dlen, i, status;
141 u8 flag, first_block, retry;
142 u32 section_num, dl_size, section_offset;
143 u8 cmd[64];
144
145 err = request_firmware(&fw, fwname, &hdev->dev);
146 if (err < 0) {
147 bt_dev_err(hdev, "Failed to load firmware file (%d)", err);
148 return err;
149 }
150
151 fw_ptr = fw->data;
152 fw_bin_ptr = fw_ptr;
153 hdr = (struct btmtk_patch_header *)fw_ptr;
154 globaldesc = (struct btmtk_global_desc *)(fw_ptr + MTK_FW_ROM_PATCH_HEADER_SIZE);
155 section_num = le32_to_cpu(globaldesc->section_num);
156
157 bt_dev_info(hdev, "HW/SW Version: 0x%04x%04x, Build Time: %s",
158 le16_to_cpu(hdr->hwver), le16_to_cpu(hdr->swver), hdr->datetime);
159
160 for (i = 0; i < section_num; i++) {
161 first_block = 1;
162 fw_ptr = fw_bin_ptr;
163 sectionmap = (struct btmtk_section_map *)(fw_ptr + MTK_FW_ROM_PATCH_HEADER_SIZE +
164 MTK_FW_ROM_PATCH_GD_SIZE + MTK_FW_ROM_PATCH_SEC_MAP_SIZE * i);
165
166 section_offset = le32_to_cpu(sectionmap->secoffset);
167 dl_size = le32_to_cpu(sectionmap->bin_info_spec.dlsize);
168
169 if (dl_size > 0) {
170 retry = 20;
171 while (retry > 0) {
172 cmd[0] = 0; /* 0 means legacy dl mode. */
173 memcpy(cmd + 1,
174 fw_ptr + MTK_FW_ROM_PATCH_HEADER_SIZE +
175 MTK_FW_ROM_PATCH_GD_SIZE +
176 MTK_FW_ROM_PATCH_SEC_MAP_SIZE * i +
177 MTK_SEC_MAP_COMMON_SIZE,
178 MTK_SEC_MAP_NEED_SEND_SIZE + 1);
179
180 wmt_params.op = BTMTK_WMT_PATCH_DWNLD;
181 wmt_params.status = &status;
182 wmt_params.flag = 0;
183 wmt_params.dlen = MTK_SEC_MAP_NEED_SEND_SIZE + 1;
184 wmt_params.data = &cmd;
185
186 err = wmt_cmd_sync(hdev, &wmt_params);
187 if (err < 0) {
188 bt_dev_err(hdev, "Failed to send wmt patch dwnld (%d)",
189 err);
190 goto err_release_fw;
191 }
192
193 if (status == BTMTK_WMT_PATCH_UNDONE) {
194 break;
195 } else if (status == BTMTK_WMT_PATCH_PROGRESS) {
196 msleep(100);
197 retry--;
198 } else if (status == BTMTK_WMT_PATCH_DONE) {
199 goto next_section;
200 } else {
201 bt_dev_err(hdev, "Failed wmt patch dwnld status (%d)",
202 status);
203 err = -EIO;
204 goto err_release_fw;
205 }
206 }
207
208 fw_ptr += section_offset;
209 wmt_params.op = BTMTK_WMT_PATCH_DWNLD;
210 wmt_params.status = NULL;
211
212 while (dl_size > 0) {
213 dlen = min_t(int, 250, dl_size);
214 if (first_block == 1) {
215 flag = 1;
216 first_block = 0;
217 } else if (dl_size - dlen <= 0) {
218 flag = 3;
219 } else {
220 flag = 2;
221 }
222
223 wmt_params.flag = flag;
224 wmt_params.dlen = dlen;
225 wmt_params.data = fw_ptr;
226
227 err = wmt_cmd_sync(hdev, &wmt_params);
228 if (err < 0) {
229 bt_dev_err(hdev, "Failed to send wmt patch dwnld (%d)",
230 err);
231 goto err_release_fw;
232 }
233
234 dl_size -= dlen;
235 fw_ptr += dlen;
236 }
237 }
238 next_section:
239 continue;
240 }
241 /* Wait a few moments for firmware activation done */
242 usleep_range(100000, 120000);
243
244 err_release_fw:
245 release_firmware(fw);
246
247 return err;
248 }
249 EXPORT_SYMBOL_GPL(btmtk_setup_firmware_79xx);
250
251 int btmtk_setup_firmware(struct hci_dev *hdev, const char *fwname,
252 wmt_cmd_sync_func_t wmt_cmd_sync)
253 {
254 struct btmtk_hci_wmt_params wmt_params;
255 const struct firmware *fw;
256 const u8 *fw_ptr;
257 size_t fw_size;
258 int err, dlen;
259 u8 flag, param;
260
261 err = request_firmware(&fw, fwname, &hdev->dev);
262 if (err < 0) {
263 bt_dev_err(hdev, "Failed to load firmware file (%d)", err);
264 return err;
265 }
266
267 /* Power on data RAM the firmware relies on. */
268 param = 1;
269 wmt_params.op = BTMTK_WMT_FUNC_CTRL;
270 wmt_params.flag = 3;
271 wmt_params.dlen = sizeof(param);
272 wmt_params.data = &param;
273 wmt_params.status = NULL;
274
275 err = wmt_cmd_sync(hdev, &wmt_params);
276 if (err < 0) {
277 bt_dev_err(hdev, "Failed to power on data RAM (%d)", err);
278 goto err_release_fw;
279 }
280
281 fw_ptr = fw->data;
282 fw_size = fw->size;
283
284 /* The size of patch header is 30 bytes, should be skip */
285 if (fw_size < 30) {
286 err = -EINVAL;
287 goto err_release_fw;
288 }
289
290 fw_size -= 30;
291 fw_ptr += 30;
292 flag = 1;
293
294 wmt_params.op = BTMTK_WMT_PATCH_DWNLD;
295 wmt_params.status = NULL;
296
297 while (fw_size > 0) {
298 dlen = min_t(int, 250, fw_size);
299
300 /* Tell device the position in sequence */
301 if (fw_size - dlen <= 0)
302 flag = 3;
303 else if (fw_size < fw->size - 30)
304 flag = 2;
305
306 wmt_params.flag = flag;
307 wmt_params.dlen = dlen;
308 wmt_params.data = fw_ptr;
309
310 err = wmt_cmd_sync(hdev, &wmt_params);
311 if (err < 0) {
312 bt_dev_err(hdev, "Failed to send wmt patch dwnld (%d)",
313 err);
314 goto err_release_fw;
315 }
316
317 fw_size -= dlen;
318 fw_ptr += dlen;
319 }
320
321 wmt_params.op = BTMTK_WMT_RST;
322 wmt_params.flag = 4;
323 wmt_params.dlen = 0;
324 wmt_params.data = NULL;
325 wmt_params.status = NULL;
326
327 /* Activate function the firmware providing to */
328 err = wmt_cmd_sync(hdev, &wmt_params);
329 if (err < 0) {
330 bt_dev_err(hdev, "Failed to send wmt rst (%d)", err);
331 goto err_release_fw;
332 }
333
334 /* Wait a few moments for firmware activation done */
335 usleep_range(10000, 12000);
336
337 err_release_fw:
338 release_firmware(fw);
339
340 return err;
341 }
342 EXPORT_SYMBOL_GPL(btmtk_setup_firmware);
343
344 int btmtk_set_bdaddr(struct hci_dev *hdev, const bdaddr_t *bdaddr)
345 {
346 struct sk_buff *skb;
347 long ret;
348
349 skb = __hci_cmd_sync(hdev, 0xfc1a, 6, bdaddr, HCI_INIT_TIMEOUT);
350 if (IS_ERR(skb)) {
351 ret = PTR_ERR(skb);
352 bt_dev_err(hdev, "changing Mediatek device address failed (%ld)",
353 ret);
354 return ret;
355 }
356 kfree_skb(skb);
357
358 return 0;
359 }
360 EXPORT_SYMBOL_GPL(btmtk_set_bdaddr);
361
362 void btmtk_reset_sync(struct hci_dev *hdev)
363 {
364 struct btmtk_data *reset_work = hci_get_priv(hdev);
365 int err;
366
367 hci_dev_lock(hdev);
368
369 err = hci_cmd_sync_queue(hdev, reset_work->reset_sync, NULL, NULL);
370 if (err)
371 bt_dev_err(hdev, "failed to reset (%d)", err);
372
373 hci_dev_unlock(hdev);
374 }
375 EXPORT_SYMBOL_GPL(btmtk_reset_sync);
376
377 int btmtk_register_coredump(struct hci_dev *hdev, const char *name,
378 u32 fw_version)
379 {
380 struct btmtk_data *data = hci_get_priv(hdev);
381
382 if (!IS_ENABLED(CONFIG_DEV_COREDUMP))
383 return -EOPNOTSUPP;
384
385 data->cd_info.fw_version = fw_version;
386 data->cd_info.state = HCI_DEVCOREDUMP_IDLE;
387 data->cd_info.driver_name = name;
388
389 return hci_devcd_register(hdev, btmtk_coredump, btmtk_coredump_hdr,
390 btmtk_coredump_notify);
391 }
392 EXPORT_SYMBOL_GPL(btmtk_register_coredump);
393
394 int btmtk_process_coredump(struct hci_dev *hdev, struct sk_buff *skb)
395 {
396 struct btmtk_data *data = hci_get_priv(hdev);
397 int err;
398
399 if (!IS_ENABLED(CONFIG_DEV_COREDUMP)) {
400 kfree_skb(skb);
401 return 0;
402 }
403
404 switch (data->cd_info.state) {
405 case HCI_DEVCOREDUMP_IDLE:
406 err = hci_devcd_init(hdev, MTK_COREDUMP_SIZE);
407 if (err < 0) {
408 kfree_skb(skb);
409 break;
410 }
411 data->cd_info.cnt = 0;
412
413 /* It is supposed coredump can be done within 5 seconds */
414 schedule_delayed_work(&hdev->dump.dump_timeout,
415 msecs_to_jiffies(5000));
416 fallthrough;
417 case HCI_DEVCOREDUMP_ACTIVE:
418 default:
419 err = hci_devcd_append(hdev, skb);
420 if (err < 0)
421 break;
422 data->cd_info.cnt++;
423
424 /* Mediatek coredump data would be more than MTK_COREDUMP_NUM */
425 if (data->cd_info.cnt > MTK_COREDUMP_NUM &&
426 skb->len > MTK_COREDUMP_END_LEN)
427 if (!memcmp((char *)&skb->data[skb->len - MTK_COREDUMP_END_LEN],
428 MTK_COREDUMP_END, MTK_COREDUMP_END_LEN - 1)) {
429 bt_dev_info(hdev, "Mediatek coredump end");
430 hci_devcd_complete(hdev);
431 }
432
433 break;
434 }
435
436 return err;
437 }
438 EXPORT_SYMBOL_GPL(btmtk_process_coredump);
439
440 #if IS_ENABLED(CONFIG_BT_HCIBTUSB_MTK)
441 static void btmtk_usb_wmt_recv(struct urb *urb)
442 {
443 struct hci_dev *hdev = urb->context;
444 struct btmtk_data *data = hci_get_priv(hdev);
445 struct sk_buff *skb;
446 int err;
447
448 if (urb->status == 0 && urb->actual_length > 0) {
449 hdev->stat.byte_rx += urb->actual_length;
450
451 /* WMT event shouldn't be fragmented and the size should be
452 * less than HCI_WMT_MAX_EVENT_SIZE.
453 */
454 skb = bt_skb_alloc(HCI_WMT_MAX_EVENT_SIZE, GFP_ATOMIC);
455 if (!skb) {
456 hdev->stat.err_rx++;
457 kfree(urb->setup_packet);
458 return;
459 }
460
461 hci_skb_pkt_type(skb) = HCI_EVENT_PKT;
462 skb_put_data(skb, urb->transfer_buffer, urb->actual_length);
463
464 /* When someone waits for the WMT event, the skb is being cloned
465 * and being processed the events from there then.
466 */
467 if (test_bit(BTMTK_TX_WAIT_VND_EVT, &data->flags)) {
468 data->evt_skb = skb_clone(skb, GFP_ATOMIC);
469 if (!data->evt_skb) {
470 kfree_skb(skb);
471 kfree(urb->setup_packet);
472 return;
473 }
474 }
475
476 err = hci_recv_frame(hdev, skb);
477 if (err < 0) {
478 kfree_skb(data->evt_skb);
479 data->evt_skb = NULL;
480 kfree(urb->setup_packet);
481 return;
482 }
483
484 if (test_and_clear_bit(BTMTK_TX_WAIT_VND_EVT,
485 &data->flags)) {
486 /* Barrier to sync with other CPUs */
487 smp_mb__after_atomic();
488 wake_up_bit(&data->flags,
489 BTMTK_TX_WAIT_VND_EVT);
490 }
491 kfree(urb->setup_packet);
492 return;
493 } else if (urb->status == -ENOENT) {
494 /* Avoid suspend failed when usb_kill_urb */
495 return;
496 }
497
498 usb_mark_last_busy(data->udev);
499
500 /* The URB complete handler is still called with urb->actual_length = 0
501 * when the event is not available, so we should keep re-submitting
502 * URB until WMT event returns, Also, It's necessary to wait some time
503 * between the two consecutive control URBs to relax the target device
504 * to generate the event. Otherwise, the WMT event cannot return from
505 * the device successfully.
506 */
507 udelay(500);
508
509 usb_anchor_urb(urb, data->ctrl_anchor);
510 err = usb_submit_urb(urb, GFP_ATOMIC);
511 if (err < 0) {
512 kfree(urb->setup_packet);
513 /* -EPERM: urb is being killed;
514 * -ENODEV: device got disconnected
515 */
516 if (err != -EPERM && err != -ENODEV)
517 bt_dev_err(hdev, "urb %p failed to resubmit (%d)",
518 urb, -err);
519 usb_unanchor_urb(urb);
520 }
521 }
522
523 static int btmtk_usb_submit_wmt_recv_urb(struct hci_dev *hdev)
524 {
525 struct btmtk_data *data = hci_get_priv(hdev);
526 struct usb_ctrlrequest *dr;
527 unsigned char *buf;
528 int err, size = 64;
529 unsigned int pipe;
530 struct urb *urb;
531
532 urb = usb_alloc_urb(0, GFP_KERNEL);
533 if (!urb)
534 return -ENOMEM;
535
536 dr = kmalloc(sizeof(*dr), GFP_KERNEL);
537 if (!dr) {
538 usb_free_urb(urb);
539 return -ENOMEM;
540 }
541
542 dr->bRequestType = USB_TYPE_VENDOR | USB_DIR_IN;
543 dr->bRequest = 1;
544 dr->wIndex = cpu_to_le16(0);
545 dr->wValue = cpu_to_le16(48);
546 dr->wLength = cpu_to_le16(size);
547
548 buf = kmalloc(size, GFP_KERNEL);
549 if (!buf) {
550 kfree(dr);
551 usb_free_urb(urb);
552 return -ENOMEM;
553 }
554
555 pipe = usb_rcvctrlpipe(data->udev, 0);
556
557 usb_fill_control_urb(urb, data->udev, pipe, (void *)dr,
558 buf, size, btmtk_usb_wmt_recv, hdev);
559
560 urb->transfer_flags |= URB_FREE_BUFFER;
561
562 usb_anchor_urb(urb, data->ctrl_anchor);
563 err = usb_submit_urb(urb, GFP_KERNEL);
564 if (err < 0) {
565 if (err != -EPERM && err != -ENODEV)
566 bt_dev_err(hdev, "urb %p submission failed (%d)",
567 urb, -err);
568 usb_unanchor_urb(urb);
569 }
570
571 usb_free_urb(urb);
572
573 return err;
574 }
575
576 static int btmtk_usb_hci_wmt_sync(struct hci_dev *hdev,
577 struct btmtk_hci_wmt_params *wmt_params)
578 {
579 struct btmtk_data *data = hci_get_priv(hdev);
580 struct btmtk_hci_wmt_evt_funcc *wmt_evt_funcc;
581 u32 hlen, status = BTMTK_WMT_INVALID;
582 struct btmtk_hci_wmt_evt *wmt_evt;
583 struct btmtk_hci_wmt_cmd *wc;
584 struct btmtk_wmt_hdr *hdr;
585 int err;
586
587 /* Send the WMT command and wait until the WMT event returns */
588 hlen = sizeof(*hdr) + wmt_params->dlen;
589 if (hlen > 255)
590 return -EINVAL;
591
592 wc = kzalloc(hlen, GFP_KERNEL);
593 if (!wc)
594 return -ENOMEM;
595
596 hdr = &wc->hdr;
597 hdr->dir = 1;
598 hdr->op = wmt_params->op;
599 hdr->dlen = cpu_to_le16(wmt_params->dlen + 1);
600 hdr->flag = wmt_params->flag;
601 memcpy(wc->data, wmt_params->data, wmt_params->dlen);
602
603 set_bit(BTMTK_TX_WAIT_VND_EVT, &data->flags);
604
605 /* WMT cmd/event doesn't follow up the generic HCI cmd/event handling,
606 * it needs constantly polling control pipe until the host received the
607 * WMT event, thus, we should require to specifically acquire PM counter
608 * on the USB to prevent the interface from entering auto suspended
609 * while WMT cmd/event in progress.
610 */
611 err = usb_autopm_get_interface(data->intf);
612 if (err < 0)
613 goto err_free_wc;
614
615 err = __hci_cmd_send(hdev, 0xfc6f, hlen, wc);
616
617 if (err < 0) {
618 clear_bit(BTMTK_TX_WAIT_VND_EVT, &data->flags);
619 usb_autopm_put_interface(data->intf);
620 goto err_free_wc;
621 }
622
623 /* Submit control IN URB on demand to process the WMT event */
624 err = btmtk_usb_submit_wmt_recv_urb(hdev);
625
626 usb_autopm_put_interface(data->intf);
627
628 if (err < 0)
629 goto err_free_wc;
630
631 /* The vendor specific WMT commands are all answered by a vendor
632 * specific event and will have the Command Status or Command
633 * Complete as with usual HCI command flow control.
634 *
635 * After sending the command, wait for BTUSB_TX_WAIT_VND_EVT
636 * state to be cleared. The driver specific event receive routine
637 * will clear that state and with that indicate completion of the
638 * WMT command.
639 */
640 err = wait_on_bit_timeout(&data->flags, BTMTK_TX_WAIT_VND_EVT,
641 TASK_INTERRUPTIBLE, HCI_INIT_TIMEOUT);
642 if (err == -EINTR) {
643 bt_dev_err(hdev, "Execution of wmt command interrupted");
644 clear_bit(BTMTK_TX_WAIT_VND_EVT, &data->flags);
645 goto err_free_wc;
646 }
647
648 if (err) {
649 bt_dev_err(hdev, "Execution of wmt command timed out");
650 clear_bit(BTMTK_TX_WAIT_VND_EVT, &data->flags);
651 err = -ETIMEDOUT;
652 goto err_free_wc;
653 }
654
655 if (data->evt_skb == NULL)
656 goto err_free_wc;
657
658 /* Parse and handle the return WMT event */
659 wmt_evt = (struct btmtk_hci_wmt_evt *)data->evt_skb->data;
660 if (wmt_evt->whdr.op != hdr->op) {
661 bt_dev_err(hdev, "Wrong op received %d expected %d",
662 wmt_evt->whdr.op, hdr->op);
663 err = -EIO;
664 goto err_free_skb;
665 }
666
667 switch (wmt_evt->whdr.op) {
668 case BTMTK_WMT_SEMAPHORE:
669 if (wmt_evt->whdr.flag == 2)
670 status = BTMTK_WMT_PATCH_UNDONE;
671 else
672 status = BTMTK_WMT_PATCH_DONE;
673 break;
674 case BTMTK_WMT_FUNC_CTRL:
675 wmt_evt_funcc = (struct btmtk_hci_wmt_evt_funcc *)wmt_evt;
676 if (be16_to_cpu(wmt_evt_funcc->status) == 0x404)
677 status = BTMTK_WMT_ON_DONE;
678 else if (be16_to_cpu(wmt_evt_funcc->status) == 0x420)
679 status = BTMTK_WMT_ON_PROGRESS;
680 else
681 status = BTMTK_WMT_ON_UNDONE;
682 break;
683 case BTMTK_WMT_PATCH_DWNLD:
684 if (wmt_evt->whdr.flag == 2)
685 status = BTMTK_WMT_PATCH_DONE;
686 else if (wmt_evt->whdr.flag == 1)
687 status = BTMTK_WMT_PATCH_PROGRESS;
688 else
689 status = BTMTK_WMT_PATCH_UNDONE;
690 break;
691 }
692
693 if (wmt_params->status)
694 *wmt_params->status = status;
695
696 err_free_skb:
697 kfree_skb(data->evt_skb);
698 data->evt_skb = NULL;
699 err_free_wc:
700 kfree(wc);
701 return err;
702 }
703
704 static int btmtk_usb_func_query(struct hci_dev *hdev)
705 {
706 struct btmtk_hci_wmt_params wmt_params;
707 int status, err;
708 u8 param = 0;
709
710 /* Query whether the function is enabled */
711 wmt_params.op = BTMTK_WMT_FUNC_CTRL;
712 wmt_params.flag = 4;
713 wmt_params.dlen = sizeof(param);
714 wmt_params.data = &param;
715 wmt_params.status = &status;
716
717 err = btmtk_usb_hci_wmt_sync(hdev, &wmt_params);
718 if (err < 0) {
719 bt_dev_err(hdev, "Failed to query function status (%d)", err);
720 return err;
721 }
722
723 return status;
724 }
725
726 static int btmtk_usb_uhw_reg_write(struct hci_dev *hdev, u32 reg, u32 val)
727 {
728 struct btmtk_data *data = hci_get_priv(hdev);
729 int pipe, err;
730 void *buf;
731
732 buf = kzalloc(4, GFP_KERNEL);
733 if (!buf)
734 return -ENOMEM;
735
736 put_unaligned_le32(val, buf);
737
738 pipe = usb_sndctrlpipe(data->udev, 0);
739 err = usb_control_msg(data->udev, pipe, 0x02,
740 0x5E,
741 reg >> 16, reg & 0xffff,
742 buf, 4, USB_CTRL_SET_TIMEOUT);
743 if (err < 0)
744 bt_dev_err(hdev, "Failed to write uhw reg(%d)", err);
745
746 kfree(buf);
747
748 return err;
749 }
750
751 static int btmtk_usb_uhw_reg_read(struct hci_dev *hdev, u32 reg, u32 *val)
752 {
753 struct btmtk_data *data = hci_get_priv(hdev);
754 int pipe, err;
755 void *buf;
756
757 buf = kzalloc(4, GFP_KERNEL);
758 if (!buf)
759 return -ENOMEM;
760
761 pipe = usb_rcvctrlpipe(data->udev, 0);
762 err = usb_control_msg(data->udev, pipe, 0x01,
763 0xDE,
764 reg >> 16, reg & 0xffff,
765 buf, 4, USB_CTRL_GET_TIMEOUT);
766 if (err < 0) {
767 bt_dev_err(hdev, "Failed to read uhw reg(%d)", err);
768 goto err_free_buf;
769 }
770
771 *val = get_unaligned_le32(buf);
772 bt_dev_dbg(hdev, "reg=%x, value=0x%08x", reg, *val);
773
774 err_free_buf:
775 kfree(buf);
776
777 return err;
778 }
779
780 static int btmtk_usb_reg_read(struct hci_dev *hdev, u32 reg, u32 *val)
781 {
782 struct btmtk_data *data = hci_get_priv(hdev);
783 int pipe, err, size = sizeof(u32);
784 void *buf;
785
786 buf = kzalloc(size, GFP_KERNEL);
787 if (!buf)
788 return -ENOMEM;
789
790 pipe = usb_rcvctrlpipe(data->udev, 0);
791 err = usb_control_msg(data->udev, pipe, 0x63,
792 USB_TYPE_VENDOR | USB_DIR_IN,
793 reg >> 16, reg & 0xffff,
794 buf, size, USB_CTRL_GET_TIMEOUT);
795 if (err < 0)
796 goto err_free_buf;
797
798 *val = get_unaligned_le32(buf);
799
800 err_free_buf:
801 kfree(buf);
802
803 return err;
804 }
805
806 static int btmtk_usb_id_get(struct hci_dev *hdev, u32 reg, u32 *id)
807 {
808 return btmtk_usb_reg_read(hdev, reg, id);
809 }
810
811 static u32 btmtk_usb_reset_done(struct hci_dev *hdev)
812 {
813 u32 val = 0;
814
815 btmtk_usb_uhw_reg_read(hdev, MTK_BT_MISC, &val);
816
817 return val & MTK_BT_RST_DONE;
818 }
819
820 int btmtk_usb_subsys_reset(struct hci_dev *hdev, u32 dev_id)
821 {
822 u32 val;
823 int err;
824
825 if (dev_id == 0x7922) {
826 err = btmtk_usb_uhw_reg_read(hdev, MTK_BT_SUBSYS_RST, &val);
827 if (err < 0)
828 return err;
829 val |= 0x00002020;
830 err = btmtk_usb_uhw_reg_write(hdev, MTK_BT_SUBSYS_RST, val);
831 if (err < 0)
832 return err;
833 err = btmtk_usb_uhw_reg_write(hdev, MTK_EP_RST_OPT, 0x00010001);
834 if (err < 0)
835 return err;
836 err = btmtk_usb_uhw_reg_read(hdev, MTK_BT_SUBSYS_RST, &val);
837 if (err < 0)
838 return err;
839 val |= BIT(0);
840 err = btmtk_usb_uhw_reg_write(hdev, MTK_BT_SUBSYS_RST, val);
841 if (err < 0)
842 return err;
843 msleep(100);
844 } else if (dev_id == 0x7925) {
845 err = btmtk_usb_uhw_reg_read(hdev, MTK_BT_RESET_REG_CONNV3, &val);
846 if (err < 0)
847 return err;
848 val |= (1 << 5);
849 err = btmtk_usb_uhw_reg_write(hdev, MTK_BT_RESET_REG_CONNV3, val);
850 if (err < 0)
851 return err;
852 err = btmtk_usb_uhw_reg_read(hdev, MTK_BT_RESET_REG_CONNV3, &val);
853 if (err < 0)
854 return err;
855 val &= 0xFFFF00FF;
856 val |= (1 << 13);
857 err = btmtk_usb_uhw_reg_write(hdev, MTK_BT_RESET_REG_CONNV3, val);
858 if (err < 0)
859 return err;
860 err = btmtk_usb_uhw_reg_write(hdev, MTK_EP_RST_OPT, 0x00010001);
861 if (err < 0)
862 return err;
863 err = btmtk_usb_uhw_reg_read(hdev, MTK_BT_RESET_REG_CONNV3, &val);
864 if (err < 0)
865 return err;
866 val |= (1 << 0);
867 err = btmtk_usb_uhw_reg_write(hdev, MTK_BT_RESET_REG_CONNV3, val);
868 if (err < 0)
869 return err;
870 err = btmtk_usb_uhw_reg_write(hdev, MTK_UDMA_INT_STA_BT, 0x000000FF);
871 if (err < 0)
872 return err;
873 err = btmtk_usb_uhw_reg_read(hdev, MTK_UDMA_INT_STA_BT, &val);
874 if (err < 0)
875 return err;
876 err = btmtk_usb_uhw_reg_write(hdev, MTK_UDMA_INT_STA_BT1, 0x000000FF);
877 if (err < 0)
878 return err;
879 err = btmtk_usb_uhw_reg_read(hdev, MTK_UDMA_INT_STA_BT1, &val);
880 if (err < 0)
881 return err;
882 msleep(100);
883 } else {
884 /* It's Device EndPoint Reset Option Register */
885 bt_dev_dbg(hdev, "Initiating reset mechanism via uhw");
886 err = btmtk_usb_uhw_reg_write(hdev, MTK_EP_RST_OPT, MTK_EP_RST_IN_OUT_OPT);
887 if (err < 0)
888 return err;
889 err = btmtk_usb_uhw_reg_read(hdev, MTK_BT_WDT_STATUS, &val);
890 if (err < 0)
891 return err;
892 /* Reset the bluetooth chip via USB interface. */
893 err = btmtk_usb_uhw_reg_write(hdev, MTK_BT_SUBSYS_RST, 1);
894 if (err < 0)
895 return err;
896 err = btmtk_usb_uhw_reg_write(hdev, MTK_UDMA_INT_STA_BT, 0x000000FF);
897 if (err < 0)
898 return err;
899 err = btmtk_usb_uhw_reg_read(hdev, MTK_UDMA_INT_STA_BT, &val);
900 if (err < 0)
901 return err;
902 err = btmtk_usb_uhw_reg_write(hdev, MTK_UDMA_INT_STA_BT1, 0x000000FF);
903 if (err < 0)
904 return err;
905 err = btmtk_usb_uhw_reg_read(hdev, MTK_UDMA_INT_STA_BT1, &val);
906 if (err < 0)
907 return err;
908 /* MT7921 need to delay 20ms between toggle reset bit */
909 msleep(20);
910 err = btmtk_usb_uhw_reg_write(hdev, MTK_BT_SUBSYS_RST, 0);
911 if (err < 0)
912 return err;
913 err = btmtk_usb_uhw_reg_read(hdev, MTK_BT_SUBSYS_RST, &val);
914 if (err < 0)
915 return err;
916 }
917
918 err = readx_poll_timeout(btmtk_usb_reset_done, hdev, val,
919 val & MTK_BT_RST_DONE, 20000, 1000000);
920 if (err < 0)
921 bt_dev_err(hdev, "Reset timeout");
922
923 if (dev_id == 0x7922) {
924 err = btmtk_usb_uhw_reg_write(hdev, MTK_UDMA_INT_STA_BT, 0x000000FF);
925 if (err < 0)
926 return err;
927 }
928
929 err = btmtk_usb_id_get(hdev, 0x70010200, &val);
930 if (err < 0 || !val)
931 bt_dev_err(hdev, "Can't get device id, subsys reset fail.");
932
933 return err;
934 }
935 EXPORT_SYMBOL_GPL(btmtk_usb_subsys_reset);
936
937 int btmtk_usb_recv_acl(struct hci_dev *hdev, struct sk_buff *skb)
938 {
939 struct btmtk_data *data = hci_get_priv(hdev);
940 u16 handle = le16_to_cpu(hci_acl_hdr(skb)->handle);
941
942 switch (handle) {
943 case 0xfc6f: /* Firmware dump from device */
944 /* When the firmware hangs, the device can no longer
945 * suspend and thus disable auto-suspend.
946 */
947 usb_disable_autosuspend(data->udev);
948
949 /* We need to forward the diagnostic packet to userspace daemon
950 * for backward compatibility, so we have to clone the packet
951 * extraly for the in-kernel coredump support.
952 */
953 if (IS_ENABLED(CONFIG_DEV_COREDUMP)) {
954 struct sk_buff *skb_cd = skb_clone(skb, GFP_ATOMIC);
955
956 if (skb_cd)
957 btmtk_process_coredump(hdev, skb_cd);
958 }
959
960 fallthrough;
961 case 0x05ff: /* Firmware debug logging 1 */
962 case 0x05fe: /* Firmware debug logging 2 */
963 return hci_recv_diag(hdev, skb);
964 }
965
966 return hci_recv_frame(hdev, skb);
967 }
968 EXPORT_SYMBOL_GPL(btmtk_usb_recv_acl);
969
970 static int btmtk_isopkt_pad(struct hci_dev *hdev, struct sk_buff *skb)
971 {
972 if (skb->len > MTK_ISO_THRESHOLD)
973 return -EINVAL;
974
975 if (skb_pad(skb, MTK_ISO_THRESHOLD - skb->len))
976 return -ENOMEM;
977
978 __skb_put(skb, MTK_ISO_THRESHOLD - skb->len);
979
980 return 0;
981 }
982
983 static int __set_mtk_intr_interface(struct hci_dev *hdev)
984 {
985 struct btmtk_data *btmtk_data = hci_get_priv(hdev);
986 struct usb_interface *intf = btmtk_data->isopkt_intf;
987 int i, err;
988
989 if (!btmtk_data->isopkt_intf)
990 return -ENODEV;
991
992 err = usb_set_interface(btmtk_data->udev, MTK_ISO_IFNUM, 1);
993 if (err < 0) {
994 bt_dev_err(hdev, "setting interface failed (%d)", -err);
995 return err;
996 }
997
998 btmtk_data->isopkt_tx_ep = NULL;
999 btmtk_data->isopkt_rx_ep = NULL;
1000
1001 for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++) {
1002 struct usb_endpoint_descriptor *ep_desc;
1003
1004 ep_desc = &intf->cur_altsetting->endpoint[i].desc;
1005
1006 if (!btmtk_data->isopkt_tx_ep &&
1007 usb_endpoint_is_int_out(ep_desc)) {
1008 btmtk_data->isopkt_tx_ep = ep_desc;
1009 continue;
1010 }
1011
1012 if (!btmtk_data->isopkt_rx_ep &&
1013 usb_endpoint_is_int_in(ep_desc)) {
1014 btmtk_data->isopkt_rx_ep = ep_desc;
1015 continue;
1016 }
1017 }
1018
1019 if (!btmtk_data->isopkt_tx_ep ||
1020 !btmtk_data->isopkt_rx_ep) {
1021 bt_dev_err(hdev, "invalid interrupt descriptors");
1022 return -ENODEV;
1023 }
1024
1025 return 0;
1026 }
1027
1028 struct urb *alloc_mtk_intr_urb(struct hci_dev *hdev, struct sk_buff *skb,
1029 usb_complete_t tx_complete)
1030 {
1031 struct btmtk_data *btmtk_data = hci_get_priv(hdev);
1032 struct urb *urb;
1033 unsigned int pipe;
1034
1035 if (!btmtk_data->isopkt_tx_ep)
1036 return ERR_PTR(-ENODEV);
1037
1038 urb = usb_alloc_urb(0, GFP_KERNEL);
1039 if (!urb)
1040 return ERR_PTR(-ENOMEM);
1041
1042 if (btmtk_isopkt_pad(hdev, skb))
1043 return ERR_PTR(-EINVAL);
1044
1045 pipe = usb_sndintpipe(btmtk_data->udev,
1046 btmtk_data->isopkt_tx_ep->bEndpointAddress);
1047
1048 usb_fill_int_urb(urb, btmtk_data->udev, pipe,
1049 skb->data, skb->len, tx_complete,
1050 skb, btmtk_data->isopkt_tx_ep->bInterval);
1051
1052 skb->dev = (void *)hdev;
1053
1054 return urb;
1055 }
1056 EXPORT_SYMBOL_GPL(alloc_mtk_intr_urb);
1057
1058 static int btmtk_recv_isopkt(struct hci_dev *hdev, void *buffer, int count)
1059 {
1060 struct btmtk_data *btmtk_data = hci_get_priv(hdev);
1061 struct sk_buff *skb;
1062 unsigned long flags;
1063 int err = 0;
1064
1065 spin_lock_irqsave(&btmtk_data->isorxlock, flags);
1066 skb = btmtk_data->isopkt_skb;
1067
1068 while (count) {
1069 int len;
1070
1071 if (!skb) {
1072 skb = bt_skb_alloc(HCI_MAX_ISO_SIZE, GFP_ATOMIC);
1073 if (!skb) {
1074 err = -ENOMEM;
1075 break;
1076 }
1077
1078 hci_skb_pkt_type(skb) = HCI_ISODATA_PKT;
1079 hci_skb_expect(skb) = HCI_ISO_HDR_SIZE;
1080 }
1081
1082 len = min_t(uint, hci_skb_expect(skb), count);
1083 skb_put_data(skb, buffer, len);
1084
1085 count -= len;
1086 buffer += len;
1087 hci_skb_expect(skb) -= len;
1088
1089 if (skb->len == HCI_ISO_HDR_SIZE) {
1090 __le16 dlen = ((struct hci_iso_hdr *)skb->data)->dlen;
1091
1092 /* Complete ISO header */
1093 hci_skb_expect(skb) = __le16_to_cpu(dlen);
1094
1095 if (skb_tailroom(skb) < hci_skb_expect(skb)) {
1096 kfree_skb(skb);
1097 skb = NULL;
1098
1099 err = -EILSEQ;
1100 break;
1101 }
1102 }
1103
1104 if (!hci_skb_expect(skb)) {
1105 /* Complete frame */
1106 hci_recv_frame(hdev, skb);
1107 skb = NULL;
1108 }
1109 }
1110
1111 btmtk_data->isopkt_skb = skb;
1112 spin_unlock_irqrestore(&btmtk_data->isorxlock, flags);
1113
1114 return err;
1115 }
1116
1117 static void btmtk_intr_complete(struct urb *urb)
1118 {
1119 struct hci_dev *hdev = urb->context;
1120 struct btmtk_data *btmtk_data = hci_get_priv(hdev);
1121 int err;
1122
1123 BT_DBG("%s urb %p status %d count %d", hdev->name, urb, urb->status,
1124 urb->actual_length);
1125
1126 if (!test_bit(HCI_RUNNING, &hdev->flags))
1127 return;
1128
1129 if (hdev->suspended)
1130 return;
1131
1132 if (urb->status == 0) {
1133 hdev->stat.byte_rx += urb->actual_length;
1134
1135 if (btmtk_recv_isopkt(hdev, urb->transfer_buffer,
1136 urb->actual_length) < 0) {
1137 bt_dev_err(hdev, "corrupted iso packet");
1138 hdev->stat.err_rx++;
1139 }
1140 } else if (urb->status == -ENOENT) {
1141 /* Avoid suspend failed when usb_kill_urb */
1142 return;
1143 }
1144
1145 usb_mark_last_busy(btmtk_data->udev);
1146 usb_anchor_urb(urb, &btmtk_data->isopkt_anchor);
1147
1148 err = usb_submit_urb(urb, GFP_ATOMIC);
1149 if (err < 0) {
1150 /* -EPERM: urb is being killed;
1151 * -ENODEV: device got disconnected
1152 */
1153 if (err != -EPERM && err != -ENODEV)
1154 bt_dev_err(hdev, "urb %p failed to resubmit (%d)",
1155 urb, -err);
1156 if (err != -EPERM)
1157 hci_cmd_sync_cancel(hdev, -err);
1158 usb_unanchor_urb(urb);
1159 }
1160 }
1161
1162 static int btmtk_submit_intr_urb(struct hci_dev *hdev, gfp_t mem_flags)
1163 {
1164 struct btmtk_data *btmtk_data = hci_get_priv(hdev);
1165 unsigned char *buf;
1166 unsigned int pipe;
1167 struct urb *urb;
1168 int err, size;
1169
1170 BT_DBG("%s", hdev->name);
1171
1172 if (!btmtk_data->isopkt_rx_ep)
1173 return -ENODEV;
1174
1175 urb = usb_alloc_urb(0, mem_flags);
1176 if (!urb)
1177 return -ENOMEM;
1178 size = le16_to_cpu(btmtk_data->isopkt_rx_ep->wMaxPacketSize);
1179
1180 buf = kmalloc(size, mem_flags);
1181 if (!buf) {
1182 usb_free_urb(urb);
1183 return -ENOMEM;
1184 }
1185
1186 pipe = usb_rcvintpipe(btmtk_data->udev,
1187 btmtk_data->isopkt_rx_ep->bEndpointAddress);
1188
1189 usb_fill_int_urb(urb, btmtk_data->udev, pipe, buf, size,
1190 btmtk_intr_complete, hdev,
1191 btmtk_data->isopkt_rx_ep->bInterval);
1192
1193 urb->transfer_flags |= URB_FREE_BUFFER;
1194
1195 usb_mark_last_busy(btmtk_data->udev);
1196 usb_anchor_urb(urb, &btmtk_data->isopkt_anchor);
1197
1198 err = usb_submit_urb(urb, mem_flags);
1199 if (err < 0) {
1200 if (err != -EPERM && err != -ENODEV)
1201 bt_dev_err(hdev, "urb %p submission failed (%d)",
1202 urb, -err);
1203 usb_unanchor_urb(urb);
1204 }
1205
1206 usb_free_urb(urb);
1207
1208 return err;
1209 }
1210
1211 static int btmtk_usb_isointf_init(struct hci_dev *hdev)
1212 {
1213 struct btmtk_data *btmtk_data = hci_get_priv(hdev);
1214 u8 iso_param[2] = { 0x08, 0x01 };
1215 struct sk_buff *skb;
1216 int err;
1217
1218 spin_lock_init(&btmtk_data->isorxlock);
1219
1220 __set_mtk_intr_interface(hdev);
1221
1222 err = btmtk_submit_intr_urb(hdev, GFP_KERNEL);
1223 if (err < 0) {
1224 usb_kill_anchored_urbs(&btmtk_data->isopkt_anchor);
1225 bt_dev_err(hdev, "ISO intf not support (%d)", err);
1226 return err;
1227 }
1228
1229 skb = __hci_cmd_sync(hdev, 0xfd98, sizeof(iso_param), iso_param,
1230 HCI_INIT_TIMEOUT);
1231 if (IS_ERR(skb)) {
1232 bt_dev_err(hdev, "Failed to apply iso setting (%ld)", PTR_ERR(skb));
1233 return PTR_ERR(skb);
1234 }
1235 kfree_skb(skb);
1236
1237 return 0;
1238 }
1239
1240 int btmtk_usb_resume(struct hci_dev *hdev)
1241 {
1242 /* This function describes the specific additional steps taken by MediaTek
1243 * when Bluetooth usb driver's resume function is called.
1244 */
1245 struct btmtk_data *btmtk_data = hci_get_priv(hdev);
1246
1247 /* Resubmit urb for iso data transmission */
1248 if (test_bit(BTMTK_ISOPKT_RUNNING, &btmtk_data->flags)) {
1249 if (btmtk_submit_intr_urb(hdev, GFP_NOIO) < 0)
1250 clear_bit(BTMTK_ISOPKT_RUNNING, &btmtk_data->flags);
1251 }
1252
1253 return 0;
1254 }
1255 EXPORT_SYMBOL_GPL(btmtk_usb_resume);
1256
1257 int btmtk_usb_suspend(struct hci_dev *hdev)
1258 {
1259 /* This function describes the specific additional steps taken by MediaTek
1260 * when Bluetooth usb driver's suspend function is called.
1261 */
1262 struct btmtk_data *btmtk_data = hci_get_priv(hdev);
1263
1264 /* Stop urb anchor for iso data transmission */
1265 if (test_bit(BTMTK_ISOPKT_RUNNING, &btmtk_data->flags))
1266 usb_kill_anchored_urbs(&btmtk_data->isopkt_anchor);
1267
1268 return 0;
1269 }
1270 EXPORT_SYMBOL_GPL(btmtk_usb_suspend);
1271
1272 int btmtk_usb_setup(struct hci_dev *hdev)
1273 {
1274 struct btmtk_data *btmtk_data = hci_get_priv(hdev);
1275 struct btmtk_hci_wmt_params wmt_params;
1276 ktime_t calltime, delta, rettime;
1277 struct btmtk_tci_sleep tci_sleep;
1278 unsigned long long duration;
1279 struct sk_buff *skb;
1280 const char *fwname;
1281 int err, status;
1282 u32 dev_id = 0;
1283 char fw_bin_name[64];
1284 u32 fw_version = 0, fw_flavor = 0;
1285 u8 param;
1286
1287 calltime = ktime_get();
1288
1289 err = btmtk_usb_id_get(hdev, 0x80000008, &dev_id);
1290 if (err < 0) {
1291 bt_dev_err(hdev, "Failed to get device id (%d)", err);
1292 return err;
1293 }
1294
1295 if (!dev_id || dev_id != 0x7663) {
1296 err = btmtk_usb_id_get(hdev, 0x70010200, &dev_id);
1297 if (err < 0) {
1298 bt_dev_err(hdev, "Failed to get device id (%d)", err);
1299 return err;
1300 }
1301 err = btmtk_usb_id_get(hdev, 0x80021004, &fw_version);
1302 if (err < 0) {
1303 bt_dev_err(hdev, "Failed to get fw version (%d)", err);
1304 return err;
1305 }
1306 err = btmtk_usb_id_get(hdev, 0x70010020, &fw_flavor);
1307 if (err < 0) {
1308 bt_dev_err(hdev, "Failed to get fw flavor (%d)", err);
1309 return err;
1310 }
1311 fw_flavor = (fw_flavor & 0x00000080) >> 7;
1312 }
1313
1314 btmtk_data->dev_id = dev_id;
1315
1316 err = btmtk_register_coredump(hdev, btmtk_data->drv_name, fw_version);
1317 if (err < 0)
1318 bt_dev_err(hdev, "Failed to register coredump (%d)", err);
1319
1320 switch (dev_id) {
1321 case 0x7663:
1322 fwname = FIRMWARE_MT7663;
1323 break;
1324 case 0x7668:
1325 fwname = FIRMWARE_MT7668;
1326 break;
1327 case 0x7922:
1328 case 0x7961:
1329 case 0x7925:
1330 /* Reset the device to ensure it's in the initial state before
1331 * downloading the firmware to ensure.
1332 */
1333
1334 if (!test_bit(BTMTK_FIRMWARE_LOADED, &btmtk_data->flags))
1335 btmtk_usb_subsys_reset(hdev, dev_id);
1336
1337 btmtk_fw_get_filename(fw_bin_name, sizeof(fw_bin_name), dev_id,
1338 fw_version, fw_flavor);
1339
1340 err = btmtk_setup_firmware_79xx(hdev, fw_bin_name,
1341 btmtk_usb_hci_wmt_sync);
1342 if (err < 0) {
1343 bt_dev_err(hdev, "Failed to set up firmware (%d)", err);
1344 clear_bit(BTMTK_FIRMWARE_LOADED, &btmtk_data->flags);
1345 return err;
1346 }
1347
1348 set_bit(BTMTK_FIRMWARE_LOADED, &btmtk_data->flags);
1349
1350 /* It's Device EndPoint Reset Option Register */
1351 err = btmtk_usb_uhw_reg_write(hdev, MTK_EP_RST_OPT,
1352 MTK_EP_RST_IN_OUT_OPT);
1353 if (err < 0)
1354 return err;
1355
1356 /* Enable Bluetooth protocol */
1357 param = 1;
1358 wmt_params.op = BTMTK_WMT_FUNC_CTRL;
1359 wmt_params.flag = 0;
1360 wmt_params.dlen = sizeof(param);
1361 wmt_params.data = &param;
1362 wmt_params.status = NULL;
1363
1364 err = btmtk_usb_hci_wmt_sync(hdev, &wmt_params);
1365 if (err < 0) {
1366 bt_dev_err(hdev, "Failed to send wmt func ctrl (%d)", err);
1367 return err;
1368 }
1369
1370 hci_set_msft_opcode(hdev, 0xFD30);
1371 hci_set_aosp_capable(hdev);
1372
1373 /* Set up ISO interface after protocol enabled */
1374 if (test_bit(BTMTK_ISOPKT_OVER_INTR, &btmtk_data->flags)) {
1375 if (!btmtk_usb_isointf_init(hdev))
1376 set_bit(BTMTK_ISOPKT_RUNNING, &btmtk_data->flags);
1377 }
1378
1379 goto done;
1380 default:
1381 bt_dev_err(hdev, "Unsupported hardware variant (%08x)",
1382 dev_id);
1383 return -ENODEV;
1384 }
1385
1386 /* Query whether the firmware is already download */
1387 wmt_params.op = BTMTK_WMT_SEMAPHORE;
1388 wmt_params.flag = 1;
1389 wmt_params.dlen = 0;
1390 wmt_params.data = NULL;
1391 wmt_params.status = &status;
1392
1393 err = btmtk_usb_hci_wmt_sync(hdev, &wmt_params);
1394 if (err < 0) {
1395 bt_dev_err(hdev, "Failed to query firmware status (%d)", err);
1396 return err;
1397 }
1398
1399 if (status == BTMTK_WMT_PATCH_DONE) {
1400 bt_dev_info(hdev, "firmware already downloaded");
1401 goto ignore_setup_fw;
1402 }
1403
1404 /* Setup a firmware which the device definitely requires */
1405 err = btmtk_setup_firmware(hdev, fwname,
1406 btmtk_usb_hci_wmt_sync);
1407 if (err < 0)
1408 return err;
1409
1410 ignore_setup_fw:
1411 err = readx_poll_timeout(btmtk_usb_func_query, hdev, status,
1412 status < 0 || status != BTMTK_WMT_ON_PROGRESS,
1413 2000, 5000000);
1414 /* -ETIMEDOUT happens */
1415 if (err < 0)
1416 return err;
1417
1418 /* The other errors happen in btmtk_usb_func_query */
1419 if (status < 0)
1420 return status;
1421
1422 if (status == BTMTK_WMT_ON_DONE) {
1423 bt_dev_info(hdev, "function already on");
1424 goto ignore_func_on;
1425 }
1426
1427 /* Enable Bluetooth protocol */
1428 param = 1;
1429 wmt_params.op = BTMTK_WMT_FUNC_CTRL;
1430 wmt_params.flag = 0;
1431 wmt_params.dlen = sizeof(param);
1432 wmt_params.data = &param;
1433 wmt_params.status = NULL;
1434
1435 err = btmtk_usb_hci_wmt_sync(hdev, &wmt_params);
1436 if (err < 0) {
1437 bt_dev_err(hdev, "Failed to send wmt func ctrl (%d)", err);
1438 return err;
1439 }
1440
1441 ignore_func_on:
1442 /* Apply the low power environment setup */
1443 tci_sleep.mode = 0x5;
1444 tci_sleep.duration = cpu_to_le16(0x640);
1445 tci_sleep.host_duration = cpu_to_le16(0x640);
1446 tci_sleep.host_wakeup_pin = 0;
1447 tci_sleep.time_compensation = 0;
1448
1449 skb = __hci_cmd_sync(hdev, 0xfc7a, sizeof(tci_sleep), &tci_sleep,
1450 HCI_INIT_TIMEOUT);
1451 if (IS_ERR(skb)) {
1452 err = PTR_ERR(skb);
1453 bt_dev_err(hdev, "Failed to apply low power setting (%d)", err);
1454 return err;
1455 }
1456 kfree_skb(skb);
1457
1458 done:
1459 rettime = ktime_get();
1460 delta = ktime_sub(rettime, calltime);
1461 duration = (unsigned long long)ktime_to_ns(delta) >> 10;
1462
1463 bt_dev_info(hdev, "Device setup in %llu usecs", duration);
1464
1465 return 0;
1466 }
1467 EXPORT_SYMBOL_GPL(btmtk_usb_setup);
1468
1469 int btmtk_usb_shutdown(struct hci_dev *hdev)
1470 {
1471 struct btmtk_hci_wmt_params wmt_params;
1472 u8 param = 0;
1473 int err;
1474
1475 /* Disable the device */
1476 wmt_params.op = BTMTK_WMT_FUNC_CTRL;
1477 wmt_params.flag = 0;
1478 wmt_params.dlen = sizeof(param);
1479 wmt_params.data = &param;
1480 wmt_params.status = NULL;
1481
1482 err = btmtk_usb_hci_wmt_sync(hdev, &wmt_params);
1483 if (err < 0) {
1484 bt_dev_err(hdev, "Failed to send wmt func ctrl (%d)", err);
1485 return err;
1486 }
1487
1488 return 0;
1489 }
1490 EXPORT_SYMBOL_GPL(btmtk_usb_shutdown);
1491 #endif
1492
1493 MODULE_AUTHOR("Sean Wang <sean.wang@mediatek.com>");
1494 MODULE_AUTHOR("Mark Chen <mark-yw.chen@mediatek.com>");
1495 MODULE_DESCRIPTION("Bluetooth support for MediaTek devices ver " VERSION);
1496 MODULE_VERSION(VERSION);
1497 MODULE_LICENSE("GPL");
1498 MODULE_FIRMWARE(FIRMWARE_MT7622);
1499 MODULE_FIRMWARE(FIRMWARE_MT7663);
1500 MODULE_FIRMWARE(FIRMWARE_MT7668);
1501 MODULE_FIRMWARE(FIRMWARE_MT7922);
1502 MODULE_FIRMWARE(FIRMWARE_MT7961);
1503 MODULE_FIRMWARE(FIRMWARE_MT7925);
Kernel DRM miscellaneous fixes and cross-tree changes