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 44 struct mtk_stp_hdr { 45 u8 prefix; 46 __be16 dlen; 47 u8 cs; 48 } __packed; 49 50 struct btmtkuart_data { 51 unsigned int flags; 52 const char *fwname; 53 }; 54 55 struct 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 90 static 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 = (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 183 err_free_wc: 184 kfree(wc); 185 err_free_skb: 186 kfree_skb(bdev->evt_skb); 187 bdev->evt_skb = NULL; 188 189 return err; 190 } 191 192 static 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 &bdev->tx_state)) { 216 /* Barrier to sync with other CPUs */ 217 smp_mb__after_atomic(); 218 wake_up_bit(&bdev->tx_state, BTMTKUART_TX_WAIT_VND_EVT); 219 } 220 } 221 222 return 0; 223 224 err_free_skb: 225 kfree_skb(bdev->evt_skb); 226 bdev->evt_skb = NULL; 227 228 err_out: 229 return err; 230 } 231 232 static 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 238 static 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, &bdev->tx_state); 247 248 while (1) { 249 struct sk_buff *skb = skb_dequeue(&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(&bdev->txq, 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, &bdev->tx_state); 285 } 286 287 static void btmtkuart_tx_wakeup(struct btmtkuart_dev *bdev) 288 { 289 if (test_and_set_bit(BTMTKUART_TX_STATE_ACTIVE, &bdev->tx_state)) 290 set_bit(BTMTKUART_TX_STATE_WAKEUP, &bdev->tx_state); 291 292 schedule_work(&bdev->tx_work); 293 } 294 295 static const unsigned char * 296 mtk_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 341 static 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, p_left, sz_left, &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(&bdev->hu, bdev->rx_skb, p_h4, 373 sz_h4, mtk_recv_pkts, 374 ARRAY_SIZE(mtk_recv_pkts)); 375 if (IS_ERR(bdev->rx_skb)) { 376 err = PTR_ERR(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 388 static 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(bdev->hdev, data, count); 394 395 bdev->hdev->stat.byte_rx += count; 396 397 return count; 398 } 399 400 static 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 407 static const struct serdev_device_ops btmtkuart_client_ops = { 408 .receive_buf = btmtkuart_receive_buf, 409 .write_wakeup = btmtkuart_write_wakeup, 410 }; 411 412 static 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(bdev->clk); 454 if (err < 0) 455 goto err_put_rpm; 456 457 return 0; 458 459 err_put_rpm: 460 pm_runtime_put_sync(dev); 461 err_disable_rpm: 462 pm_runtime_disable(dev); 463 err_serdev_close: 464 serdev_device_close(bdev->serdev); 465 err_open: 466 return err; 467 } 468 469 static 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(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 484 static 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(&bdev->txq); 491 492 cancel_work_sync(&bdev->tx_work); 493 494 kfree_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 503 static 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 = ¶m; 514 wmt_params.status = &status; 515 516 err = mtk_hci_wmt_sync(hdev, &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 525 static 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); 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, ¶m, 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(20000, 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); 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 589 static 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); 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, &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); 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, bdev->data->fwname, mtk_hci_wmt_sync); 644 if (err < 0) 645 return err; 646 647 ignore_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 = ¶m; 670 wmt_params.status = NULL; 671 672 err = mtk_hci_wmt_sync(hdev, &wmt_params); 673 if (err < 0) { 674 bt_dev_err(hdev, "Failed to send wmt func ctrl (%d)", err); 675 return err; 676 } 677 678 ignore_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, 0xfc7a, sizeof(tci_sleep), &tci_sleep, 687 HCI_INIT_TIMEOUT); 688 if (IS_ERR(skb)) { 689 err = PTR_ERR(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(delta) >> 10; 698 699 bt_dev_info(hdev, "Device setup in %llu usecs", duration); 700 701 return 0; 702 } 703 704 static 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 = ¶m; 715 wmt_params.status = NULL; 716 717 err = mtk_hci_wmt_sync(hdev, &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 726 static 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, 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, 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(&bdev->txq, skb); 755 756 btmtkuart_tx_wakeup(bdev); 757 return 0; 758 } 759 760 static 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(node, "current-speed", &speed); 769 770 bdev->desired_speed = speed; 771 772 bdev->vcc = devm_regulator_get(&serdev->dev, "vcc"); 773 if (IS_ERR(bdev->vcc)) { 774 err = PTR_ERR(bdev->vcc); 775 return err; 776 } 777 778 bdev->osc = devm_clk_get_optional(&serdev->dev, "osc"); 779 if (IS_ERR(bdev->osc)) { 780 err = PTR_ERR(bdev->osc); 781 return err; 782 } 783 784 bdev->boot = devm_gpiod_get_optional(&serdev->dev, "boot", 785 GPIOD_OUT_LOW); 786 if (IS_ERR(bdev->boot)) { 787 err = PTR_ERR(bdev->boot); 788 return err; 789 } 790 791 bdev->pinctrl = devm_pinctrl_get(&serdev->dev); 792 if (IS_ERR(bdev->pinctrl)) { 793 err = PTR_ERR(bdev->pinctrl); 794 return err; 795 } 796 797 bdev->pins_boot = pinctrl_lookup_state(bdev->pinctrl, 798 "default"); 799 if (IS_ERR(bdev->pins_boot) && !bdev->boot) { 800 err = PTR_ERR(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(bdev->pinctrl, 807 "runtime"); 808 if (IS_ERR(bdev->pins_runtime)) { 809 err = PTR_ERR(bdev->pins_runtime); 810 return err; 811 } 812 813 bdev->reset = devm_gpiod_get_optional(&serdev->dev, "reset", 814 GPIOD_OUT_LOW); 815 if (IS_ERR(bdev->reset)) { 816 err = PTR_ERR(bdev->reset); 817 return err; 818 } 819 } else if (btmtkuart_is_builtin_soc(bdev)) { 820 bdev->clk = devm_clk_get(&serdev->dev, "ref"); 821 if (IS_ERR(bdev->clk)) 822 return PTR_ERR(bdev->clk); 823 } 824 825 return 0; 826 } 827 828 static 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(&serdev->dev, sizeof(*bdev), GFP_KERNEL); 835 if (!bdev) 836 return -ENOMEM; 837 838 bdev->data = of_device_get_match_data(&serdev->dev); 839 if (!bdev->data) 840 return -ENODEV; 841 842 bdev->serdev = serdev; 843 serdev_device_set_drvdata(serdev, bdev); 844 845 serdev_device_set_client_ops(serdev, &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(&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, 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(bdev->osc); 881 if (err < 0) 882 goto err_hci_free_dev; 883 884 if (bdev->boot) { 885 gpiod_set_value_cansleep(bdev->boot, 1); 886 } else { 887 /* Switch to the specific pin state for the booting 888 * requires. 889 */ 890 pinctrl_select_state(bdev->pinctrl, bdev->pins_boot); 891 } 892 893 /* Power on */ 894 err = regulator_enable(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(bdev->reset, 1); 903 usleep_range(1000, 2000); 904 gpiod_set_value_cansleep(bdev->reset, 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(50); 911 912 if (bdev->boot) 913 devm_gpiod_put(&serdev->dev, bdev->boot); 914 915 pinctrl_select_state(bdev->pinctrl, 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(&serdev->dev); 921 922 set_bit(BTMTKUART_REQUIRED_WAKEUP, &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 933 err_regulator_disable: 934 if (btmtkuart_is_standalone(bdev)) 935 regulator_disable(bdev->vcc); 936 err_clk_disable_unprepare: 937 if (btmtkuart_is_standalone(bdev)) 938 clk_disable_unprepare(bdev->osc); 939 err_hci_free_dev: 940 hci_free_dev(hdev); 941 942 return err; 943 } 944 945 static 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(bdev->vcc); 952 clk_disable_unprepare(bdev->osc); 953 } 954 955 hci_unregister_dev(hdev); 956 hci_free_dev(hdev); 957 } 958 959 static const struct btmtkuart_data mt7622_data __maybe_unused = { 960 .fwname = FIRMWARE_MT7622, 961 }; 962 963 static const struct btmtkuart_data mt7663_data __maybe_unused = { 964 .flags = BTMTKUART_FLAG_STANDALONE_HW, 965 .fwname = FIRMWARE_MT7663, 966 }; 967 968 static const struct btmtkuart_data mt7668_data __maybe_unused = { 969 .flags = BTMTKUART_FLAG_STANDALONE_HW, 970 .fwname = FIRMWARE_MT7668, 971 }; 972 973 #ifdef CONFIG_OF 974 static 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 }; 980 MODULE_DEVICE_TABLE(of, mtk_of_match_table); 981 #endif 982 983 static 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 992 module_serdev_device_driver(btmtkuart_driver); 993 994 MODULE_AUTHOR("Sean Wang <sean.wang@mediatek.com>"); 995 MODULE_DESCRIPTION("MediaTek Bluetooth Serial driver ver " VERSION); 996 MODULE_VERSION(VERSION); 997 MODULE_LICENSE("GPL"); 998