Bluetooth: mediatek: update the common setup between MT7622 and other devices

Update the setup sequence on MT7622 to apply the same flow with MT7663U
and MT7668U USB [1] as much as possible. These additional commands are
required to parse the corresponding event to determine what current state
the Bluetooth device is on and thus it's necessary to extend
mtk_hci_wmt_sync to support the reading status in the same patch.

[1] http://lists.infradead.org/pipermail/linux-mediatek/2019-January/017074.html

Signed-off-by: Sean Wang <sean.wang@mediatek.com>
Signed-off-by: Marcel Holtmann <marcel@holtmann.org>

1 files changed, 190 insertions, 14 deletions

diff --git a/drivers/bluetooth/btmtkuart.c b/drivers/bluetooth/btmtkuart.c
index 4451b1db139a..e73b1013ba73 100644
--- a/drivers/bluetooth/btmtkuart.c
+++ b/drivers/bluetooth/btmtkuart.c
@@ -12,6 +12,7 @@
 #include <linux/atomic.h>
 #include <linux/clk.h>
 #include <linux/firmware.h>
+#include <linux/iopoll.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/of.h>
@@ -37,7 +38,17 @@
 enum {
         MTK_WMT_PATCH_DWNLD = 0x1,
         MTK_WMT_FUNC_CTRL = 0x6,
-        MTK_WMT_RST = 0x7
+        MTK_WMT_RST = 0x7,
+        MTK_WMT_SEMAPHORE = 0x17,
+};
+
+enum {
+        BTMTK_WMT_INVALID,
+        BTMTK_WMT_PATCH_UNDONE,
+        BTMTK_WMT_PATCH_DONE,
+        BTMTK_WMT_ON_UNDONE,
+        BTMTK_WMT_ON_DONE,
+        BTMTK_WMT_ON_PROGRESS,
 };
 
 struct mtk_stp_hdr {
@@ -58,6 +69,24 @@ struct mtk_hci_wmt_cmd {
         u8 data[256];
 } __packed;
 
+struct btmtk_hci_wmt_evt {
+        struct hci_event_hdr hhdr;
+        struct mtk_wmt_hdr whdr;
+} __packed;
+
+struct btmtk_hci_wmt_evt_funcc {
+        struct btmtk_hci_wmt_evt hwhdr;
+        __be16 status;
+} __packed;
+
+struct btmtk_tci_sleep {
+        u8 mode;
+        __le16 duration;
+        __le16 host_duration;
+        u8 host_wakeup_pin;
+        u8 time_compensation;
+} __packed;
+
 struct btmtk_hci_wmt_params {
         u8 op;
         u8 flag;
@@ -76,6 +105,7 @@ struct btmtkuart_dev {
         struct sk_buff_head txq;
 
         struct sk_buff *rx_skb;
+        struct sk_buff *evt_skb;
 
         u8      stp_pad[6];
         u8      stp_cursor;
@@ -86,9 +116,11 @@ static int mtk_hci_wmt_sync(struct hci_dev *hdev,
                             struct btmtk_hci_wmt_params *wmt_params)
 {
         struct btmtkuart_dev *bdev = hci_get_drvdata(hdev);
+        struct btmtk_hci_wmt_evt_funcc *wmt_evt_funcc;
+        u32 hlen, status = BTMTK_WMT_INVALID;
+        struct btmtk_hci_wmt_evt *wmt_evt;
         struct mtk_hci_wmt_cmd wc;
         struct mtk_wmt_hdr *hdr;
-        u32 hlen;
         int err;
 
         hlen = sizeof(*hdr) + wmt_params->dlen;
@@ -133,7 +165,41 @@ static int mtk_hci_wmt_sync(struct hci_dev *hdev,
                 return -ETIMEDOUT;
         }
 
-        return 0;
+        /* Parse and handle the return WMT event */
+        wmt_evt = (struct btmtk_hci_wmt_evt *)bdev->evt_skb->data;
+        if (wmt_evt->whdr.op != hdr->op) {
+                bt_dev_err(hdev, "Wrong op received %d expected %d",
+                           wmt_evt->whdr.op, hdr->op);
+                err = -EIO;
+                goto err_free_skb;
+        }
+
+        switch (wmt_evt->whdr.op) {
+        case MTK_WMT_SEMAPHORE:
+                if (wmt_evt->whdr.flag == 2)
+                        status = BTMTK_WMT_PATCH_UNDONE;
+                else
+                        status = BTMTK_WMT_PATCH_DONE;
+                break;
+        case MTK_WMT_FUNC_CTRL:
+                wmt_evt_funcc = (struct btmtk_hci_wmt_evt_funcc *)wmt_evt;
+                if (be16_to_cpu(wmt_evt_funcc->status) == 0x404)
+                        status = BTMTK_WMT_ON_DONE;
+                else if (be16_to_cpu(wmt_evt_funcc->status) == 0x420)
+                        status = BTMTK_WMT_ON_PROGRESS;
+                else
+                        status = BTMTK_WMT_ON_UNDONE;
+                break;
+        }
+
+        if (wmt_params->status)
+                *wmt_params->status = status;
+
+err_free_skb:
+        kfree_skb(bdev->evt_skb);
+        bdev->evt_skb = NULL;
+
+        return err;
 }
 
 static int mtk_setup_fw(struct hci_dev *hdev)
@@ -184,13 +250,29 @@ static int mtk_setup_fw(struct hci_dev *hdev)
                 if (err < 0) {
                         bt_dev_err(hdev, "Failed to send wmt patch dwnld (%d)",
                                    err);
-                        break;
+                        goto free_fw;
                 }
 
                 fw_size -= dlen;
                 fw_ptr += dlen;
         }
 
+        wmt_params.op = MTK_WMT_RST;
+        wmt_params.flag = 4;
+        wmt_params.dlen = 0;
+        wmt_params.data = NULL;
+        wmt_params.status = NULL;
+
+        /* Activate funciton the firmware providing to */
+        err = mtk_hci_wmt_sync(hdev, &wmt_params);
+        if (err < 0) {
+                bt_dev_err(hdev, "Failed to send wmt rst (%d)", err);
+                goto free_fw;
+        }
+
+        /* Wait a few moments for firmware activation done */
+        usleep_range(10000, 12000);
+
 free_fw:
         release_firmware(fw);
         return err;
@@ -209,7 +291,20 @@ static int btmtkuart_recv_event(struct hci_dev *hdev, struct sk_buff *skb)
         if (hdr->evt == 0xe4)
                 hdr->evt = HCI_EV_VENDOR;
 
+        /* When someone waits for the WMT event, the skb is being cloned
+         * and being processed the events from there then.
+         */
+        if (test_bit(BTMTKUART_TX_WAIT_VND_EVT, &bdev->tx_state)) {
+                bdev->evt_skb = skb_clone(skb, GFP_KERNEL);
+                if (!bdev->evt_skb) {
+                        err = -ENOMEM;
+                        goto err_out;
+                }
+        }
+
         err = hci_recv_frame(hdev, skb);
+        if (err < 0)
+                goto err_free_skb;
 
         if (hdr->evt == HCI_EV_VENDOR) {
                 if (test_and_clear_bit(BTMTKUART_TX_WAIT_VND_EVT,
@@ -220,6 +315,13 @@ static int btmtkuart_recv_event(struct hci_dev *hdev, struct sk_buff *skb)
                 }
         }
 
+        return 0;
+
+err_free_skb:
+        kfree_skb(bdev->evt_skb);
+        bdev->evt_skb = NULL;
+
+err_out:
         return err;
 }
 
@@ -482,28 +584,79 @@ static int btmtkuart_flush(struct hci_dev *hdev)
         return 0;
 }
 
+static int btmtkuart_func_query(struct hci_dev *hdev)
+{
+        struct btmtk_hci_wmt_params wmt_params;
+        int status, err;
+        u8 param = 0;
+
+        /* Query whether the function is enabled */
+        wmt_params.op = MTK_WMT_FUNC_CTRL;
+        wmt_params.flag = 4;
+        wmt_params.dlen = sizeof(param);
+        wmt_params.data = &param;
+        wmt_params.status = &status;
+
+        err = mtk_hci_wmt_sync(hdev, &wmt_params);
+        if (err < 0) {
+                bt_dev_err(hdev, "Failed to query function status (%d)", err);
+                return err;
+        }
+
+        return status;
+}
+
 static int btmtkuart_setup(struct hci_dev *hdev)
 {
         struct btmtk_hci_wmt_params wmt_params;
+        ktime_t calltime, delta, rettime;
+        struct btmtk_tci_sleep tci_sleep;
+        unsigned long long duration;
+        struct sk_buff *skb;
+        int err, status;
         u8 param = 0x1;
-        int err = 0;
 
-        /* Setup a firmware which the device definitely requires */
-        err = mtk_setup_fw(hdev);
-        if (err < 0)
-                return err;
+        calltime = ktime_get();
 
-        wmt_params.op = MTK_WMT_RST;
-        wmt_params.flag = 4;
+        /* Query whether the firmware is already download */
+        wmt_params.op = MTK_WMT_SEMAPHORE;
+        wmt_params.flag = 1;
         wmt_params.dlen = 0;
         wmt_params.data = NULL;
-        wmt_params.status = NULL;
+        wmt_params.status = &status;
 
-        /* Activate funciton the firmware providing to */
         err = mtk_hci_wmt_sync(hdev, &wmt_params);
         if (err < 0) {
-                bt_dev_err(hdev, "Failed to send wmt rst (%d)", err);
+                bt_dev_err(hdev, "Failed to query firmware status (%d)", err);
+                return err;
+        }
+
+        if (status == BTMTK_WMT_PATCH_DONE) {
+                bt_dev_info(hdev, "Firmware already downloaded");
+                goto ignore_setup_fw;
+        }
+
+        /* Setup a firmware which the device definitely requires */
+        err = mtk_setup_fw(hdev);
+        if (err < 0)
                 return err;
+
+ignore_setup_fw:
+        /* Query whether the device is already enabled */
+        err = readx_poll_timeout(btmtkuart_func_query, hdev, status,
+                                 status < 0 || status != BTMTK_WMT_ON_PROGRESS,
+                                 2000, 5000000);
+        /* -ETIMEDOUT happens */
+        if (err < 0)
+                return err;
+
+        /* The other errors happen in btusb_mtk_func_query */
+        if (status < 0)
+                return status;
+
+        if (status == BTMTK_WMT_ON_DONE) {
+                bt_dev_info(hdev, "function already on");
+                goto ignore_func_on;
         }
 
         /* Enable Bluetooth protocol */
@@ -519,6 +672,29 @@ static int btmtkuart_setup(struct hci_dev *hdev)
                 return err;
         }
 
+ignore_func_on:
+        /* Apply the low power environment setup */
+        tci_sleep.mode = 0x5;
+        tci_sleep.duration = cpu_to_le16(0x640);
+        tci_sleep.host_duration = cpu_to_le16(0x640);
+        tci_sleep.host_wakeup_pin = 0;
+        tci_sleep.time_compensation = 0;
+
+        skb = __hci_cmd_sync(hdev, 0xfc7a, sizeof(tci_sleep), &tci_sleep,
+                             HCI_INIT_TIMEOUT);
+        if (IS_ERR(skb)) {
+                err = PTR_ERR(skb);
+                bt_dev_err(hdev, "Failed to apply low power setting (%d)", err);
+                return err;
+        }
+        kfree_skb(skb);
+
+        rettime = ktime_get();
+        delta = ktime_sub(rettime, calltime);
+        duration = (unsigned long long)ktime_to_ns(delta) >> 10;
+
+        bt_dev_info(hdev, "Device setup in %llu usecs", duration);
+
         return 0;
 }