xref: /openbmc/linux/drivers/bluetooth/btmtkuart.c (revision 9726bfcd)
1 // SPDX-License-Identifier: GPL-2.0
2 // Copyright (c) 2018 MediaTek Inc.
3 
4 /*
5  * Bluetooth support for MediaTek serial devices
6  *
7  * Author: Sean Wang <sean.wang@mediatek.com>
8  *
9  */
10 
11 #include <asm/unaligned.h>
12 #include <linux/atomic.h>
13 #include <linux/clk.h>
14 #include <linux/firmware.h>
15 #include <linux/gpio/consumer.h>
16 #include <linux/iopoll.h>
17 #include <linux/kernel.h>
18 #include <linux/module.h>
19 #include <linux/of.h>
20 #include <linux/of_device.h>
21 #include <linux/pinctrl/consumer.h>
22 #include <linux/pm_runtime.h>
23 #include <linux/regulator/consumer.h>
24 #include <linux/serdev.h>
25 #include <linux/skbuff.h>
26 
27 #include <net/bluetooth/bluetooth.h>
28 #include <net/bluetooth/hci_core.h>
29 
30 #include "h4_recv.h"
31 
32 #define VERSION "0.2"
33 
34 #define FIRMWARE_MT7622		"mediatek/mt7622pr2h.bin"
35 #define FIRMWARE_MT7663		"mediatek/mt7663pr2h.bin"
36 #define FIRMWARE_MT7668		"mediatek/mt7668pr2h.bin"
37 
38 #define MTK_STP_TLR_SIZE	2
39 
40 #define BTMTKUART_TX_STATE_ACTIVE	1
41 #define BTMTKUART_TX_STATE_WAKEUP	2
42 #define BTMTKUART_TX_WAIT_VND_EVT	3
43 #define BTMTKUART_REQUIRED_WAKEUP	4
44 
45 #define BTMTKUART_FLAG_STANDALONE_HW	 BIT(0)
46 
47 enum {
48 	MTK_WMT_PATCH_DWNLD = 0x1,
49 	MTK_WMT_TEST = 0x2,
50 	MTK_WMT_WAKEUP = 0x3,
51 	MTK_WMT_HIF = 0x4,
52 	MTK_WMT_FUNC_CTRL = 0x6,
53 	MTK_WMT_RST = 0x7,
54 	MTK_WMT_SEMAPHORE = 0x17,
55 };
56 
57 enum {
58 	BTMTK_WMT_INVALID,
59 	BTMTK_WMT_PATCH_UNDONE,
60 	BTMTK_WMT_PATCH_DONE,
61 	BTMTK_WMT_ON_UNDONE,
62 	BTMTK_WMT_ON_DONE,
63 	BTMTK_WMT_ON_PROGRESS,
64 };
65 
66 struct mtk_stp_hdr {
67 	u8	prefix;
68 	__be16	dlen;
69 	u8	cs;
70 } __packed;
71 
72 struct btmtkuart_data {
73 	unsigned int flags;
74 	const char *fwname;
75 };
76 
77 struct mtk_wmt_hdr {
78 	u8	dir;
79 	u8	op;
80 	__le16	dlen;
81 	u8	flag;
82 } __packed;
83 
84 struct mtk_hci_wmt_cmd {
85 	struct mtk_wmt_hdr hdr;
86 	u8 data[256];
87 } __packed;
88 
89 struct btmtk_hci_wmt_evt {
90 	struct hci_event_hdr hhdr;
91 	struct mtk_wmt_hdr whdr;
92 } __packed;
93 
94 struct btmtk_hci_wmt_evt_funcc {
95 	struct btmtk_hci_wmt_evt hwhdr;
96 	__be16 status;
97 } __packed;
98 
99 struct btmtk_tci_sleep {
100 	u8 mode;
101 	__le16 duration;
102 	__le16 host_duration;
103 	u8 host_wakeup_pin;
104 	u8 time_compensation;
105 } __packed;
106 
107 struct btmtk_hci_wmt_params {
108 	u8 op;
109 	u8 flag;
110 	u16 dlen;
111 	const void *data;
112 	u32 *status;
113 };
114 
115 struct btmtkuart_dev {
116 	struct hci_dev *hdev;
117 	struct serdev_device *serdev;
118 
119 	struct clk *clk;
120 	struct clk *osc;
121 	struct regulator *vcc;
122 	struct gpio_desc *reset;
123 	struct gpio_desc *boot;
124 	struct pinctrl *pinctrl;
125 	struct pinctrl_state *pins_runtime;
126 	struct pinctrl_state *pins_boot;
127 	speed_t	desired_speed;
128 	speed_t	curr_speed;
129 
130 	struct work_struct tx_work;
131 	unsigned long tx_state;
132 	struct sk_buff_head txq;
133 
134 	struct sk_buff *rx_skb;
135 	struct sk_buff *evt_skb;
136 
137 	u8	stp_pad[6];
138 	u8	stp_cursor;
139 	u16	stp_dlen;
140 
141 	const struct btmtkuart_data *data;
142 };
143 
144 #define btmtkuart_is_standalone(bdev)	\
145 	((bdev)->data->flags & BTMTKUART_FLAG_STANDALONE_HW)
146 #define btmtkuart_is_builtin_soc(bdev)	\
147 	!((bdev)->data->flags & BTMTKUART_FLAG_STANDALONE_HW)
148 
149 static int mtk_hci_wmt_sync(struct hci_dev *hdev,
150 			    struct btmtk_hci_wmt_params *wmt_params)
151 {
152 	struct btmtkuart_dev *bdev = hci_get_drvdata(hdev);
153 	struct btmtk_hci_wmt_evt_funcc *wmt_evt_funcc;
154 	u32 hlen, status = BTMTK_WMT_INVALID;
155 	struct btmtk_hci_wmt_evt *wmt_evt;
156 	struct mtk_hci_wmt_cmd wc;
157 	struct mtk_wmt_hdr *hdr;
158 	int err;
159 
160 	hlen = sizeof(*hdr) + wmt_params->dlen;
161 	if (hlen > 255)
162 		return -EINVAL;
163 
164 	hdr = (struct mtk_wmt_hdr *)&wc;
165 	hdr->dir = 1;
166 	hdr->op = wmt_params->op;
167 	hdr->dlen = cpu_to_le16(wmt_params->dlen + 1);
168 	hdr->flag = wmt_params->flag;
169 	memcpy(wc.data, wmt_params->data, wmt_params->dlen);
170 
171 	set_bit(BTMTKUART_TX_WAIT_VND_EVT, &bdev->tx_state);
172 
173 	err = __hci_cmd_send(hdev, 0xfc6f, hlen, &wc);
174 	if (err < 0) {
175 		clear_bit(BTMTKUART_TX_WAIT_VND_EVT, &bdev->tx_state);
176 		return err;
177 	}
178 
179 	/* The vendor specific WMT commands are all answered by a vendor
180 	 * specific event and will not have the Command Status or Command
181 	 * Complete as with usual HCI command flow control.
182 	 *
183 	 * After sending the command, wait for BTMTKUART_TX_WAIT_VND_EVT
184 	 * state to be cleared. The driver specific event receive routine
185 	 * will clear that state and with that indicate completion of the
186 	 * WMT command.
187 	 */
188 	err = wait_on_bit_timeout(&bdev->tx_state, BTMTKUART_TX_WAIT_VND_EVT,
189 				  TASK_INTERRUPTIBLE, HCI_INIT_TIMEOUT);
190 	if (err == -EINTR) {
191 		bt_dev_err(hdev, "Execution of wmt command interrupted");
192 		clear_bit(BTMTKUART_TX_WAIT_VND_EVT, &bdev->tx_state);
193 		return err;
194 	}
195 
196 	if (err) {
197 		bt_dev_err(hdev, "Execution of wmt command timed out");
198 		clear_bit(BTMTKUART_TX_WAIT_VND_EVT, &bdev->tx_state);
199 		return -ETIMEDOUT;
200 	}
201 
202 	/* Parse and handle the return WMT event */
203 	wmt_evt = (struct btmtk_hci_wmt_evt *)bdev->evt_skb->data;
204 	if (wmt_evt->whdr.op != hdr->op) {
205 		bt_dev_err(hdev, "Wrong op received %d expected %d",
206 			   wmt_evt->whdr.op, hdr->op);
207 		err = -EIO;
208 		goto err_free_skb;
209 	}
210 
211 	switch (wmt_evt->whdr.op) {
212 	case MTK_WMT_SEMAPHORE:
213 		if (wmt_evt->whdr.flag == 2)
214 			status = BTMTK_WMT_PATCH_UNDONE;
215 		else
216 			status = BTMTK_WMT_PATCH_DONE;
217 		break;
218 	case MTK_WMT_FUNC_CTRL:
219 		wmt_evt_funcc = (struct btmtk_hci_wmt_evt_funcc *)wmt_evt;
220 		if (be16_to_cpu(wmt_evt_funcc->status) == 0x404)
221 			status = BTMTK_WMT_ON_DONE;
222 		else if (be16_to_cpu(wmt_evt_funcc->status) == 0x420)
223 			status = BTMTK_WMT_ON_PROGRESS;
224 		else
225 			status = BTMTK_WMT_ON_UNDONE;
226 		break;
227 	}
228 
229 	if (wmt_params->status)
230 		*wmt_params->status = status;
231 
232 err_free_skb:
233 	kfree_skb(bdev->evt_skb);
234 	bdev->evt_skb = NULL;
235 
236 	return err;
237 }
238 
239 static int mtk_setup_firmware(struct hci_dev *hdev, const char *fwname)
240 {
241 	struct btmtk_hci_wmt_params wmt_params;
242 	const struct firmware *fw;
243 	const u8 *fw_ptr;
244 	size_t fw_size;
245 	int err, dlen;
246 	u8 flag;
247 
248 	err = request_firmware(&fw, fwname, &hdev->dev);
249 	if (err < 0) {
250 		bt_dev_err(hdev, "Failed to load firmware file (%d)", err);
251 		return err;
252 	}
253 
254 	fw_ptr = fw->data;
255 	fw_size = fw->size;
256 
257 	/* The size of patch header is 30 bytes, should be skip */
258 	if (fw_size < 30) {
259 		err = -EINVAL;
260 		goto free_fw;
261 	}
262 
263 	fw_size -= 30;
264 	fw_ptr += 30;
265 	flag = 1;
266 
267 	wmt_params.op = MTK_WMT_PATCH_DWNLD;
268 	wmt_params.status = NULL;
269 
270 	while (fw_size > 0) {
271 		dlen = min_t(int, 250, fw_size);
272 
273 		/* Tell device the position in sequence */
274 		if (fw_size - dlen <= 0)
275 			flag = 3;
276 		else if (fw_size < fw->size - 30)
277 			flag = 2;
278 
279 		wmt_params.flag = flag;
280 		wmt_params.dlen = dlen;
281 		wmt_params.data = fw_ptr;
282 
283 		err = mtk_hci_wmt_sync(hdev, &wmt_params);
284 		if (err < 0) {
285 			bt_dev_err(hdev, "Failed to send wmt patch dwnld (%d)",
286 				   err);
287 			goto free_fw;
288 		}
289 
290 		fw_size -= dlen;
291 		fw_ptr += dlen;
292 	}
293 
294 	wmt_params.op = MTK_WMT_RST;
295 	wmt_params.flag = 4;
296 	wmt_params.dlen = 0;
297 	wmt_params.data = NULL;
298 	wmt_params.status = NULL;
299 
300 	/* Activate funciton the firmware providing to */
301 	err = mtk_hci_wmt_sync(hdev, &wmt_params);
302 	if (err < 0) {
303 		bt_dev_err(hdev, "Failed to send wmt rst (%d)", err);
304 		goto free_fw;
305 	}
306 
307 	/* Wait a few moments for firmware activation done */
308 	usleep_range(10000, 12000);
309 
310 free_fw:
311 	release_firmware(fw);
312 	return err;
313 }
314 
315 static int btmtkuart_recv_event(struct hci_dev *hdev, struct sk_buff *skb)
316 {
317 	struct btmtkuart_dev *bdev = hci_get_drvdata(hdev);
318 	struct hci_event_hdr *hdr = (void *)skb->data;
319 	int err;
320 
321 	/* Fix up the vendor event id with 0xff for vendor specific instead
322 	 * of 0xe4 so that event send via monitoring socket can be parsed
323 	 * properly.
324 	 */
325 	if (hdr->evt == 0xe4)
326 		hdr->evt = HCI_EV_VENDOR;
327 
328 	/* When someone waits for the WMT event, the skb is being cloned
329 	 * and being processed the events from there then.
330 	 */
331 	if (test_bit(BTMTKUART_TX_WAIT_VND_EVT, &bdev->tx_state)) {
332 		bdev->evt_skb = skb_clone(skb, GFP_KERNEL);
333 		if (!bdev->evt_skb) {
334 			err = -ENOMEM;
335 			goto err_out;
336 		}
337 	}
338 
339 	err = hci_recv_frame(hdev, skb);
340 	if (err < 0)
341 		goto err_free_skb;
342 
343 	if (hdr->evt == HCI_EV_VENDOR) {
344 		if (test_and_clear_bit(BTMTKUART_TX_WAIT_VND_EVT,
345 				       &bdev->tx_state)) {
346 			/* Barrier to sync with other CPUs */
347 			smp_mb__after_atomic();
348 			wake_up_bit(&bdev->tx_state, BTMTKUART_TX_WAIT_VND_EVT);
349 		}
350 	}
351 
352 	return 0;
353 
354 err_free_skb:
355 	kfree_skb(bdev->evt_skb);
356 	bdev->evt_skb = NULL;
357 
358 err_out:
359 	return err;
360 }
361 
362 static const struct h4_recv_pkt mtk_recv_pkts[] = {
363 	{ H4_RECV_ACL,      .recv = hci_recv_frame },
364 	{ H4_RECV_SCO,      .recv = hci_recv_frame },
365 	{ H4_RECV_EVENT,    .recv = btmtkuart_recv_event },
366 };
367 
368 static void btmtkuart_tx_work(struct work_struct *work)
369 {
370 	struct btmtkuart_dev *bdev = container_of(work, struct btmtkuart_dev,
371 						   tx_work);
372 	struct serdev_device *serdev = bdev->serdev;
373 	struct hci_dev *hdev = bdev->hdev;
374 
375 	while (1) {
376 		clear_bit(BTMTKUART_TX_STATE_WAKEUP, &bdev->tx_state);
377 
378 		while (1) {
379 			struct sk_buff *skb = skb_dequeue(&bdev->txq);
380 			int len;
381 
382 			if (!skb)
383 				break;
384 
385 			len = serdev_device_write_buf(serdev, skb->data,
386 						      skb->len);
387 			hdev->stat.byte_tx += len;
388 
389 			skb_pull(skb, len);
390 			if (skb->len > 0) {
391 				skb_queue_head(&bdev->txq, skb);
392 				break;
393 			}
394 
395 			switch (hci_skb_pkt_type(skb)) {
396 			case HCI_COMMAND_PKT:
397 				hdev->stat.cmd_tx++;
398 				break;
399 			case HCI_ACLDATA_PKT:
400 				hdev->stat.acl_tx++;
401 				break;
402 			case HCI_SCODATA_PKT:
403 				hdev->stat.sco_tx++;
404 				break;
405 			}
406 
407 			kfree_skb(skb);
408 		}
409 
410 		if (!test_bit(BTMTKUART_TX_STATE_WAKEUP, &bdev->tx_state))
411 			break;
412 	}
413 
414 	clear_bit(BTMTKUART_TX_STATE_ACTIVE, &bdev->tx_state);
415 }
416 
417 static void btmtkuart_tx_wakeup(struct btmtkuart_dev *bdev)
418 {
419 	if (test_and_set_bit(BTMTKUART_TX_STATE_ACTIVE, &bdev->tx_state))
420 		set_bit(BTMTKUART_TX_STATE_WAKEUP, &bdev->tx_state);
421 
422 	schedule_work(&bdev->tx_work);
423 }
424 
425 static const unsigned char *
426 mtk_stp_split(struct btmtkuart_dev *bdev, const unsigned char *data, int count,
427 	      int *sz_h4)
428 {
429 	struct mtk_stp_hdr *shdr;
430 
431 	/* The cursor is reset when all the data of STP is consumed out */
432 	if (!bdev->stp_dlen && bdev->stp_cursor >= 6)
433 		bdev->stp_cursor = 0;
434 
435 	/* Filling pad until all STP info is obtained */
436 	while (bdev->stp_cursor < 6 && count > 0) {
437 		bdev->stp_pad[bdev->stp_cursor] = *data;
438 		bdev->stp_cursor++;
439 		data++;
440 		count--;
441 	}
442 
443 	/* Retrieve STP info and have a sanity check */
444 	if (!bdev->stp_dlen && bdev->stp_cursor >= 6) {
445 		shdr = (struct mtk_stp_hdr *)&bdev->stp_pad[2];
446 		bdev->stp_dlen = be16_to_cpu(shdr->dlen) & 0x0fff;
447 
448 		/* Resync STP when unexpected data is being read */
449 		if (shdr->prefix != 0x80 || bdev->stp_dlen > 2048) {
450 			bt_dev_err(bdev->hdev, "stp format unexpect (%d, %d)",
451 				   shdr->prefix, bdev->stp_dlen);
452 			bdev->stp_cursor = 2;
453 			bdev->stp_dlen = 0;
454 		}
455 	}
456 
457 	/* Directly quit when there's no data found for H4 can process */
458 	if (count <= 0)
459 		return NULL;
460 
461 	/* Tranlate to how much the size of data H4 can handle so far */
462 	*sz_h4 = min_t(int, count, bdev->stp_dlen);
463 
464 	/* Update the remaining size of STP packet */
465 	bdev->stp_dlen -= *sz_h4;
466 
467 	/* Data points to STP payload which can be handled by H4 */
468 	return data;
469 }
470 
471 static int btmtkuart_recv(struct hci_dev *hdev, const u8 *data, size_t count)
472 {
473 	struct btmtkuart_dev *bdev = hci_get_drvdata(hdev);
474 	const unsigned char *p_left = data, *p_h4;
475 	int sz_left = count, sz_h4, adv;
476 	int err;
477 
478 	while (sz_left > 0) {
479 		/*  The serial data received from MT7622 BT controller is
480 		 *  at all time padded around with the STP header and tailer.
481 		 *
482 		 *  A full STP packet is looking like
483 		 *   -----------------------------------
484 		 *  | STP header  |  H:4   | STP tailer |
485 		 *   -----------------------------------
486 		 *  but it doesn't guarantee to contain a full H:4 packet which
487 		 *  means that it's possible for multiple STP packets forms a
488 		 *  full H:4 packet that means extra STP header + length doesn't
489 		 *  indicate a full H:4 frame, things can fragment. Whose length
490 		 *  recorded in STP header just shows up the most length the
491 		 *  H:4 engine can handle currently.
492 		 */
493 
494 		p_h4 = mtk_stp_split(bdev, p_left, sz_left, &sz_h4);
495 		if (!p_h4)
496 			break;
497 
498 		adv = p_h4 - p_left;
499 		sz_left -= adv;
500 		p_left += adv;
501 
502 		bdev->rx_skb = h4_recv_buf(bdev->hdev, bdev->rx_skb, p_h4,
503 					   sz_h4, mtk_recv_pkts,
504 					   ARRAY_SIZE(mtk_recv_pkts));
505 		if (IS_ERR(bdev->rx_skb)) {
506 			err = PTR_ERR(bdev->rx_skb);
507 			bt_dev_err(bdev->hdev,
508 				   "Frame reassembly failed (%d)", err);
509 			bdev->rx_skb = NULL;
510 			return err;
511 		}
512 
513 		sz_left -= sz_h4;
514 		p_left += sz_h4;
515 	}
516 
517 	return 0;
518 }
519 
520 static int btmtkuart_receive_buf(struct serdev_device *serdev, const u8 *data,
521 				 size_t count)
522 {
523 	struct btmtkuart_dev *bdev = serdev_device_get_drvdata(serdev);
524 	int err;
525 
526 	err = btmtkuart_recv(bdev->hdev, data, count);
527 	if (err < 0)
528 		return err;
529 
530 	bdev->hdev->stat.byte_rx += count;
531 
532 	return count;
533 }
534 
535 static void btmtkuart_write_wakeup(struct serdev_device *serdev)
536 {
537 	struct btmtkuart_dev *bdev = serdev_device_get_drvdata(serdev);
538 
539 	btmtkuart_tx_wakeup(bdev);
540 }
541 
542 static const struct serdev_device_ops btmtkuart_client_ops = {
543 	.receive_buf = btmtkuart_receive_buf,
544 	.write_wakeup = btmtkuart_write_wakeup,
545 };
546 
547 static int btmtkuart_open(struct hci_dev *hdev)
548 {
549 	struct btmtkuart_dev *bdev = hci_get_drvdata(hdev);
550 	struct device *dev;
551 	int err;
552 
553 	err = serdev_device_open(bdev->serdev);
554 	if (err) {
555 		bt_dev_err(hdev, "Unable to open UART device %s",
556 			   dev_name(&bdev->serdev->dev));
557 		goto err_open;
558 	}
559 
560 	if (btmtkuart_is_standalone(bdev)) {
561 		if (bdev->curr_speed != bdev->desired_speed)
562 			err = serdev_device_set_baudrate(bdev->serdev,
563 							 115200);
564 		else
565 			err = serdev_device_set_baudrate(bdev->serdev,
566 							 bdev->desired_speed);
567 
568 		if (err < 0) {
569 			bt_dev_err(hdev, "Unable to set baudrate UART device %s",
570 				   dev_name(&bdev->serdev->dev));
571 			goto  err_serdev_close;
572 		}
573 
574 		serdev_device_set_flow_control(bdev->serdev, false);
575 	}
576 
577 	bdev->stp_cursor = 2;
578 	bdev->stp_dlen = 0;
579 
580 	dev = &bdev->serdev->dev;
581 
582 	/* Enable the power domain and clock the device requires */
583 	pm_runtime_enable(dev);
584 	err = pm_runtime_get_sync(dev);
585 	if (err < 0) {
586 		pm_runtime_put_noidle(dev);
587 		goto err_disable_rpm;
588 	}
589 
590 	err = clk_prepare_enable(bdev->clk);
591 	if (err < 0)
592 		goto err_put_rpm;
593 
594 	return 0;
595 
596 err_put_rpm:
597 	pm_runtime_put_sync(dev);
598 err_disable_rpm:
599 	pm_runtime_disable(dev);
600 err_serdev_close:
601 	serdev_device_close(bdev->serdev);
602 err_open:
603 	return err;
604 }
605 
606 static int btmtkuart_close(struct hci_dev *hdev)
607 {
608 	struct btmtkuart_dev *bdev = hci_get_drvdata(hdev);
609 	struct device *dev = &bdev->serdev->dev;
610 
611 	/* Shutdown the clock and power domain the device requires */
612 	clk_disable_unprepare(bdev->clk);
613 	pm_runtime_put_sync(dev);
614 	pm_runtime_disable(dev);
615 
616 	serdev_device_close(bdev->serdev);
617 
618 	return 0;
619 }
620 
621 static int btmtkuart_flush(struct hci_dev *hdev)
622 {
623 	struct btmtkuart_dev *bdev = hci_get_drvdata(hdev);
624 
625 	/* Flush any pending characters */
626 	serdev_device_write_flush(bdev->serdev);
627 	skb_queue_purge(&bdev->txq);
628 
629 	cancel_work_sync(&bdev->tx_work);
630 
631 	kfree_skb(bdev->rx_skb);
632 	bdev->rx_skb = NULL;
633 
634 	bdev->stp_cursor = 2;
635 	bdev->stp_dlen = 0;
636 
637 	return 0;
638 }
639 
640 static int btmtkuart_func_query(struct hci_dev *hdev)
641 {
642 	struct btmtk_hci_wmt_params wmt_params;
643 	int status, err;
644 	u8 param = 0;
645 
646 	/* Query whether the function is enabled */
647 	wmt_params.op = MTK_WMT_FUNC_CTRL;
648 	wmt_params.flag = 4;
649 	wmt_params.dlen = sizeof(param);
650 	wmt_params.data = &param;
651 	wmt_params.status = &status;
652 
653 	err = mtk_hci_wmt_sync(hdev, &wmt_params);
654 	if (err < 0) {
655 		bt_dev_err(hdev, "Failed to query function status (%d)", err);
656 		return err;
657 	}
658 
659 	return status;
660 }
661 
662 static int btmtkuart_change_baudrate(struct hci_dev *hdev)
663 {
664 	struct btmtkuart_dev *bdev = hci_get_drvdata(hdev);
665 	struct btmtk_hci_wmt_params wmt_params;
666 	__le32 baudrate;
667 	u8 param;
668 	int err;
669 
670 	/* Indicate the device to enter the probe state the host is
671 	 * ready to change a new baudrate.
672 	 */
673 	baudrate = cpu_to_le32(bdev->desired_speed);
674 	wmt_params.op = MTK_WMT_HIF;
675 	wmt_params.flag = 1;
676 	wmt_params.dlen = 4;
677 	wmt_params.data = &baudrate;
678 	wmt_params.status = NULL;
679 
680 	err = mtk_hci_wmt_sync(hdev, &wmt_params);
681 	if (err < 0) {
682 		bt_dev_err(hdev, "Failed to device baudrate (%d)", err);
683 		return err;
684 	}
685 
686 	err = serdev_device_set_baudrate(bdev->serdev,
687 					 bdev->desired_speed);
688 	if (err < 0) {
689 		bt_dev_err(hdev, "Failed to set up host baudrate (%d)",
690 			   err);
691 		return err;
692 	}
693 
694 	serdev_device_set_flow_control(bdev->serdev, false);
695 
696 	/* Send a dummy byte 0xff to activate the new baudrate */
697 	param = 0xff;
698 	err = serdev_device_write(bdev->serdev, &param, sizeof(param),
699 				  MAX_SCHEDULE_TIMEOUT);
700 	if (err < 0 || err < sizeof(param))
701 		return err;
702 
703 	serdev_device_wait_until_sent(bdev->serdev, 0);
704 
705 	/* Wait some time for the device changing baudrate done */
706 	usleep_range(20000, 22000);
707 
708 	/* Test the new baudrate */
709 	wmt_params.op = MTK_WMT_TEST;
710 	wmt_params.flag = 7;
711 	wmt_params.dlen = 0;
712 	wmt_params.data = NULL;
713 	wmt_params.status = NULL;
714 
715 	err = mtk_hci_wmt_sync(hdev, &wmt_params);
716 	if (err < 0) {
717 		bt_dev_err(hdev, "Failed to test new baudrate (%d)",
718 			   err);
719 		return err;
720 	}
721 
722 	bdev->curr_speed = bdev->desired_speed;
723 
724 	return 0;
725 }
726 
727 static int btmtkuart_setup(struct hci_dev *hdev)
728 {
729 	struct btmtkuart_dev *bdev = hci_get_drvdata(hdev);
730 	struct btmtk_hci_wmt_params wmt_params;
731 	ktime_t calltime, delta, rettime;
732 	struct btmtk_tci_sleep tci_sleep;
733 	unsigned long long duration;
734 	struct sk_buff *skb;
735 	int err, status;
736 	u8 param = 0x1;
737 
738 	calltime = ktime_get();
739 
740 	/* Wakeup MCUSYS is required for certain devices before we start to
741 	 * do any setups.
742 	 */
743 	if (test_bit(BTMTKUART_REQUIRED_WAKEUP, &bdev->tx_state)) {
744 		wmt_params.op = MTK_WMT_WAKEUP;
745 		wmt_params.flag = 3;
746 		wmt_params.dlen = 0;
747 		wmt_params.data = NULL;
748 		wmt_params.status = NULL;
749 
750 		err = mtk_hci_wmt_sync(hdev, &wmt_params);
751 		if (err < 0) {
752 			bt_dev_err(hdev, "Failed to wakeup the chip (%d)", err);
753 			return err;
754 		}
755 
756 		clear_bit(BTMTKUART_REQUIRED_WAKEUP, &bdev->tx_state);
757 	}
758 
759 	if (btmtkuart_is_standalone(bdev))
760 		btmtkuart_change_baudrate(hdev);
761 
762 	/* Query whether the firmware is already download */
763 	wmt_params.op = MTK_WMT_SEMAPHORE;
764 	wmt_params.flag = 1;
765 	wmt_params.dlen = 0;
766 	wmt_params.data = NULL;
767 	wmt_params.status = &status;
768 
769 	err = mtk_hci_wmt_sync(hdev, &wmt_params);
770 	if (err < 0) {
771 		bt_dev_err(hdev, "Failed to query firmware status (%d)", err);
772 		return err;
773 	}
774 
775 	if (status == BTMTK_WMT_PATCH_DONE) {
776 		bt_dev_info(hdev, "Firmware already downloaded");
777 		goto ignore_setup_fw;
778 	}
779 
780 	/* Setup a firmware which the device definitely requires */
781 	err = mtk_setup_firmware(hdev, bdev->data->fwname);
782 	if (err < 0)
783 		return err;
784 
785 ignore_setup_fw:
786 	/* Query whether the device is already enabled */
787 	err = readx_poll_timeout(btmtkuart_func_query, hdev, status,
788 				 status < 0 || status != BTMTK_WMT_ON_PROGRESS,
789 				 2000, 5000000);
790 	/* -ETIMEDOUT happens */
791 	if (err < 0)
792 		return err;
793 
794 	/* The other errors happen in btusb_mtk_func_query */
795 	if (status < 0)
796 		return status;
797 
798 	if (status == BTMTK_WMT_ON_DONE) {
799 		bt_dev_info(hdev, "function already on");
800 		goto ignore_func_on;
801 	}
802 
803 	/* Enable Bluetooth protocol */
804 	wmt_params.op = MTK_WMT_FUNC_CTRL;
805 	wmt_params.flag = 0;
806 	wmt_params.dlen = sizeof(param);
807 	wmt_params.data = &param;
808 	wmt_params.status = NULL;
809 
810 	err = mtk_hci_wmt_sync(hdev, &wmt_params);
811 	if (err < 0) {
812 		bt_dev_err(hdev, "Failed to send wmt func ctrl (%d)", err);
813 		return err;
814 	}
815 
816 ignore_func_on:
817 	/* Apply the low power environment setup */
818 	tci_sleep.mode = 0x5;
819 	tci_sleep.duration = cpu_to_le16(0x640);
820 	tci_sleep.host_duration = cpu_to_le16(0x640);
821 	tci_sleep.host_wakeup_pin = 0;
822 	tci_sleep.time_compensation = 0;
823 
824 	skb = __hci_cmd_sync(hdev, 0xfc7a, sizeof(tci_sleep), &tci_sleep,
825 			     HCI_INIT_TIMEOUT);
826 	if (IS_ERR(skb)) {
827 		err = PTR_ERR(skb);
828 		bt_dev_err(hdev, "Failed to apply low power setting (%d)", err);
829 		return err;
830 	}
831 	kfree_skb(skb);
832 
833 	rettime = ktime_get();
834 	delta = ktime_sub(rettime, calltime);
835 	duration = (unsigned long long)ktime_to_ns(delta) >> 10;
836 
837 	bt_dev_info(hdev, "Device setup in %llu usecs", duration);
838 
839 	return 0;
840 }
841 
842 static int btmtkuart_shutdown(struct hci_dev *hdev)
843 {
844 	struct btmtk_hci_wmt_params wmt_params;
845 	u8 param = 0x0;
846 	int err;
847 
848 	/* Disable the device */
849 	wmt_params.op = MTK_WMT_FUNC_CTRL;
850 	wmt_params.flag = 0;
851 	wmt_params.dlen = sizeof(param);
852 	wmt_params.data = &param;
853 	wmt_params.status = NULL;
854 
855 	err = mtk_hci_wmt_sync(hdev, &wmt_params);
856 	if (err < 0) {
857 		bt_dev_err(hdev, "Failed to send wmt func ctrl (%d)", err);
858 		return err;
859 	}
860 
861 	return 0;
862 }
863 
864 static int btmtkuart_send_frame(struct hci_dev *hdev, struct sk_buff *skb)
865 {
866 	struct btmtkuart_dev *bdev = hci_get_drvdata(hdev);
867 	struct mtk_stp_hdr *shdr;
868 	int err, dlen, type = 0;
869 
870 	/* Prepend skb with frame type */
871 	memcpy(skb_push(skb, 1), &hci_skb_pkt_type(skb), 1);
872 
873 	/* Make sure that there is enough rooms for STP header and trailer */
874 	if (unlikely(skb_headroom(skb) < sizeof(*shdr)) ||
875 	    (skb_tailroom(skb) < MTK_STP_TLR_SIZE)) {
876 		err = pskb_expand_head(skb, sizeof(*shdr), MTK_STP_TLR_SIZE,
877 				       GFP_ATOMIC);
878 		if (err < 0)
879 			return err;
880 	}
881 
882 	/* Add the STP header */
883 	dlen = skb->len;
884 	shdr = skb_push(skb, sizeof(*shdr));
885 	shdr->prefix = 0x80;
886 	shdr->dlen = cpu_to_be16((dlen & 0x0fff) | (type << 12));
887 	shdr->cs = 0;		/* MT7622 doesn't care about checksum value */
888 
889 	/* Add the STP trailer */
890 	skb_put_zero(skb, MTK_STP_TLR_SIZE);
891 
892 	skb_queue_tail(&bdev->txq, skb);
893 
894 	btmtkuart_tx_wakeup(bdev);
895 	return 0;
896 }
897 
898 static int btmtkuart_parse_dt(struct serdev_device *serdev)
899 {
900 	struct btmtkuart_dev *bdev = serdev_device_get_drvdata(serdev);
901 	struct device_node *node = serdev->dev.of_node;
902 	u32 speed = 921600;
903 	int err;
904 
905 	if (btmtkuart_is_standalone(bdev)) {
906 		of_property_read_u32(node, "current-speed", &speed);
907 
908 		bdev->desired_speed = speed;
909 
910 		bdev->vcc = devm_regulator_get(&serdev->dev, "vcc");
911 		if (IS_ERR(bdev->vcc)) {
912 			err = PTR_ERR(bdev->vcc);
913 			return err;
914 		}
915 
916 		bdev->osc = devm_clk_get_optional(&serdev->dev, "osc");
917 		if (IS_ERR(bdev->osc)) {
918 			err = PTR_ERR(bdev->osc);
919 			return err;
920 		}
921 
922 		bdev->boot = devm_gpiod_get_optional(&serdev->dev, "boot",
923 						     GPIOD_OUT_LOW);
924 		if (IS_ERR(bdev->boot)) {
925 			err = PTR_ERR(bdev->boot);
926 			return err;
927 		}
928 
929 		bdev->pinctrl = devm_pinctrl_get(&serdev->dev);
930 		if (IS_ERR(bdev->pinctrl)) {
931 			err = PTR_ERR(bdev->pinctrl);
932 			return err;
933 		}
934 
935 		bdev->pins_boot = pinctrl_lookup_state(bdev->pinctrl,
936 						       "default");
937 		if (IS_ERR(bdev->pins_boot) && !bdev->boot) {
938 			err = PTR_ERR(bdev->pins_boot);
939 			dev_err(&serdev->dev,
940 				"Should assign RXD to LOW at boot stage\n");
941 			return err;
942 		}
943 
944 		bdev->pins_runtime = pinctrl_lookup_state(bdev->pinctrl,
945 							  "runtime");
946 		if (IS_ERR(bdev->pins_runtime)) {
947 			err = PTR_ERR(bdev->pins_runtime);
948 			return err;
949 		}
950 
951 		bdev->reset = devm_gpiod_get_optional(&serdev->dev, "reset",
952 						      GPIOD_OUT_LOW);
953 		if (IS_ERR(bdev->reset)) {
954 			err = PTR_ERR(bdev->reset);
955 			return err;
956 		}
957 	} else if (btmtkuart_is_builtin_soc(bdev)) {
958 		bdev->clk = devm_clk_get(&serdev->dev, "ref");
959 		if (IS_ERR(bdev->clk))
960 			return PTR_ERR(bdev->clk);
961 	}
962 
963 	return 0;
964 }
965 
966 static int btmtkuart_probe(struct serdev_device *serdev)
967 {
968 	struct btmtkuart_dev *bdev;
969 	struct hci_dev *hdev;
970 	int err;
971 
972 	bdev = devm_kzalloc(&serdev->dev, sizeof(*bdev), GFP_KERNEL);
973 	if (!bdev)
974 		return -ENOMEM;
975 
976 	bdev->data = of_device_get_match_data(&serdev->dev);
977 	if (!bdev->data)
978 		return -ENODEV;
979 
980 	bdev->serdev = serdev;
981 	serdev_device_set_drvdata(serdev, bdev);
982 
983 	serdev_device_set_client_ops(serdev, &btmtkuart_client_ops);
984 
985 	err = btmtkuart_parse_dt(serdev);
986 	if (err < 0)
987 		return err;
988 
989 	INIT_WORK(&bdev->tx_work, btmtkuart_tx_work);
990 	skb_queue_head_init(&bdev->txq);
991 
992 	/* Initialize and register HCI device */
993 	hdev = hci_alloc_dev();
994 	if (!hdev) {
995 		dev_err(&serdev->dev, "Can't allocate HCI device\n");
996 		return -ENOMEM;
997 	}
998 
999 	bdev->hdev = hdev;
1000 
1001 	hdev->bus = HCI_UART;
1002 	hci_set_drvdata(hdev, bdev);
1003 
1004 	hdev->open     = btmtkuart_open;
1005 	hdev->close    = btmtkuart_close;
1006 	hdev->flush    = btmtkuart_flush;
1007 	hdev->setup    = btmtkuart_setup;
1008 	hdev->shutdown = btmtkuart_shutdown;
1009 	hdev->send     = btmtkuart_send_frame;
1010 	SET_HCIDEV_DEV(hdev, &serdev->dev);
1011 
1012 	hdev->manufacturer = 70;
1013 	set_bit(HCI_QUIRK_NON_PERSISTENT_SETUP, &hdev->quirks);
1014 
1015 	if (btmtkuart_is_standalone(bdev)) {
1016 		err = clk_prepare_enable(bdev->osc);
1017 		if (err < 0)
1018 			return err;
1019 
1020 		if (bdev->boot) {
1021 			gpiod_set_value_cansleep(bdev->boot, 1);
1022 		} else {
1023 			/* Switch to the specific pin state for the booting
1024 			 * requires.
1025 			 */
1026 			pinctrl_select_state(bdev->pinctrl, bdev->pins_boot);
1027 		}
1028 
1029 		/* Power on */
1030 		err = regulator_enable(bdev->vcc);
1031 		if (err < 0) {
1032 			clk_disable_unprepare(bdev->osc);
1033 			return err;
1034 		}
1035 
1036 		/* Reset if the reset-gpios is available otherwise the board
1037 		 * -level design should be guaranteed.
1038 		 */
1039 		if (bdev->reset) {
1040 			gpiod_set_value_cansleep(bdev->reset, 1);
1041 			usleep_range(1000, 2000);
1042 			gpiod_set_value_cansleep(bdev->reset, 0);
1043 		}
1044 
1045 		/* Wait some time until device got ready and switch to the pin
1046 		 * mode the device requires for UART transfers.
1047 		 */
1048 		msleep(50);
1049 
1050 		if (bdev->boot)
1051 			devm_gpiod_put(&serdev->dev, bdev->boot);
1052 
1053 		pinctrl_select_state(bdev->pinctrl, bdev->pins_runtime);
1054 
1055 		/* A standalone device doesn't depends on power domain on SoC,
1056 		 * so mark it as no callbacks.
1057 		 */
1058 		pm_runtime_no_callbacks(&serdev->dev);
1059 
1060 		set_bit(BTMTKUART_REQUIRED_WAKEUP, &bdev->tx_state);
1061 	}
1062 
1063 	err = hci_register_dev(hdev);
1064 	if (err < 0) {
1065 		dev_err(&serdev->dev, "Can't register HCI device\n");
1066 		hci_free_dev(hdev);
1067 		goto err_regulator_disable;
1068 	}
1069 
1070 	return 0;
1071 
1072 err_regulator_disable:
1073 	if (btmtkuart_is_standalone(bdev))
1074 		regulator_disable(bdev->vcc);
1075 
1076 	return err;
1077 }
1078 
1079 static void btmtkuart_remove(struct serdev_device *serdev)
1080 {
1081 	struct btmtkuart_dev *bdev = serdev_device_get_drvdata(serdev);
1082 	struct hci_dev *hdev = bdev->hdev;
1083 
1084 	if (btmtkuart_is_standalone(bdev)) {
1085 		regulator_disable(bdev->vcc);
1086 		clk_disable_unprepare(bdev->osc);
1087 	}
1088 
1089 	hci_unregister_dev(hdev);
1090 	hci_free_dev(hdev);
1091 }
1092 
1093 static const struct btmtkuart_data mt7622_data = {
1094 	.fwname = FIRMWARE_MT7622,
1095 };
1096 
1097 static const struct btmtkuart_data mt7663_data = {
1098 	.flags = BTMTKUART_FLAG_STANDALONE_HW,
1099 	.fwname = FIRMWARE_MT7663,
1100 };
1101 
1102 static const struct btmtkuart_data mt7668_data = {
1103 	.flags = BTMTKUART_FLAG_STANDALONE_HW,
1104 	.fwname = FIRMWARE_MT7668,
1105 };
1106 
1107 #ifdef CONFIG_OF
1108 static const struct of_device_id mtk_of_match_table[] = {
1109 	{ .compatible = "mediatek,mt7622-bluetooth", .data = &mt7622_data},
1110 	{ .compatible = "mediatek,mt7663u-bluetooth", .data = &mt7663_data},
1111 	{ .compatible = "mediatek,mt7668u-bluetooth", .data = &mt7668_data},
1112 	{ }
1113 };
1114 MODULE_DEVICE_TABLE(of, mtk_of_match_table);
1115 #endif
1116 
1117 static struct serdev_device_driver btmtkuart_driver = {
1118 	.probe = btmtkuart_probe,
1119 	.remove = btmtkuart_remove,
1120 	.driver = {
1121 		.name = "btmtkuart",
1122 		.of_match_table = of_match_ptr(mtk_of_match_table),
1123 	},
1124 };
1125 
1126 module_serdev_device_driver(btmtkuart_driver);
1127 
1128 MODULE_AUTHOR("Sean Wang <sean.wang@mediatek.com>");
1129 MODULE_DESCRIPTION("MediaTek Bluetooth Serial driver ver " VERSION);
1130 MODULE_VERSION(VERSION);
1131 MODULE_LICENSE("GPL");
1132 MODULE_FIRMWARE(FIRMWARE_MT7622);
1133 MODULE_FIRMWARE(FIRMWARE_MT7663);
1134 MODULE_FIRMWARE(FIRMWARE_MT7668);
1135