projects/linux·blob master · refs

1015 lines · 24.4 KiB

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