btmtkuart.c

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