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

source code of linux/drivers/bluetooth/btmtkuart.c