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