19aebfd4aSSean Wang // SPDX-License-Identifier: GPL-2.0 29aebfd4aSSean Wang // Copyright (c) 2019 MediaTek Inc. 39aebfd4aSSean Wang 49aebfd4aSSean Wang /* 59aebfd4aSSean Wang * Bluetooth support for MediaTek SDIO devices 69aebfd4aSSean Wang * 79aebfd4aSSean Wang * This file is written based on btsdio.c and btmtkuart.c. 89aebfd4aSSean Wang * 99aebfd4aSSean Wang * Author: Sean Wang <sean.wang@mediatek.com> 109aebfd4aSSean Wang * 119aebfd4aSSean Wang */ 129aebfd4aSSean Wang 139aebfd4aSSean Wang #include <asm/unaligned.h> 149aebfd4aSSean Wang #include <linux/atomic.h> 159aebfd4aSSean Wang #include <linux/init.h> 169aebfd4aSSean Wang #include <linux/iopoll.h> 179aebfd4aSSean Wang #include <linux/kernel.h> 189aebfd4aSSean Wang #include <linux/module.h> 197f3c563cSSean Wang #include <linux/pm_runtime.h> 209aebfd4aSSean Wang #include <linux/skbuff.h> 219aebfd4aSSean Wang 229aebfd4aSSean Wang #include <linux/mmc/host.h> 239aebfd4aSSean Wang #include <linux/mmc/sdio_ids.h> 249aebfd4aSSean Wang #include <linux/mmc/sdio_func.h> 259aebfd4aSSean Wang 269aebfd4aSSean Wang #include <net/bluetooth/bluetooth.h> 279aebfd4aSSean Wang #include <net/bluetooth/hci_core.h> 289aebfd4aSSean Wang 299aebfd4aSSean Wang #include "h4_recv.h" 303a722044SSean Wang #include "btmtk.h" 319aebfd4aSSean Wang 329aebfd4aSSean Wang #define VERSION "0.1" 339aebfd4aSSean Wang 347f3c563cSSean Wang #define MTKBTSDIO_AUTOSUSPEND_DELAY 8000 357f3c563cSSean Wang 367f3c563cSSean Wang static bool enable_autosuspend; 377f3c563cSSean Wang 389aebfd4aSSean Wang struct btmtksdio_data { 399aebfd4aSSean Wang const char *fwname; 40c603bf1fSSean Wang u16 chipid; 419aebfd4aSSean Wang }; 429aebfd4aSSean Wang 439aebfd4aSSean Wang static const struct btmtksdio_data mt7663_data = { 449aebfd4aSSean Wang .fwname = FIRMWARE_MT7663, 45c603bf1fSSean Wang .chipid = 0x7663, 469aebfd4aSSean Wang }; 479aebfd4aSSean Wang 489aebfd4aSSean Wang static const struct btmtksdio_data mt7668_data = { 499aebfd4aSSean Wang .fwname = FIRMWARE_MT7668, 50c603bf1fSSean Wang .chipid = 0x7668, 51c603bf1fSSean Wang }; 52c603bf1fSSean Wang 53c603bf1fSSean Wang static const struct btmtksdio_data mt7921_data = { 54c603bf1fSSean Wang .fwname = FIRMWARE_MT7961, 55c603bf1fSSean Wang .chipid = 0x7921, 569aebfd4aSSean Wang }; 579aebfd4aSSean Wang 589aebfd4aSSean Wang static const struct sdio_device_id btmtksdio_table[] = { 59baaa110dSPali Rohár {SDIO_DEVICE(SDIO_VENDOR_ID_MEDIATEK, SDIO_DEVICE_ID_MEDIATEK_MT7663), 609aebfd4aSSean Wang .driver_data = (kernel_ulong_t)&mt7663_data }, 61baaa110dSPali Rohár {SDIO_DEVICE(SDIO_VENDOR_ID_MEDIATEK, SDIO_DEVICE_ID_MEDIATEK_MT7668), 629aebfd4aSSean Wang .driver_data = (kernel_ulong_t)&mt7668_data }, 63c603bf1fSSean Wang {SDIO_DEVICE(SDIO_VENDOR_ID_MEDIATEK, SDIO_DEVICE_ID_MEDIATEK_MT7961), 64c603bf1fSSean Wang .driver_data = (kernel_ulong_t)&mt7921_data }, 659aebfd4aSSean Wang { } /* Terminating entry */ 669aebfd4aSSean Wang }; 6753121a7cSBartosz Golaszewski MODULE_DEVICE_TABLE(sdio, btmtksdio_table); 689aebfd4aSSean Wang 699aebfd4aSSean Wang #define MTK_REG_CHLPCR 0x4 /* W1S */ 709aebfd4aSSean Wang #define C_INT_EN_SET BIT(0) 719aebfd4aSSean Wang #define C_INT_EN_CLR BIT(1) 722e47cc2bSSean Wang #define C_FW_OWN_REQ_SET BIT(8) /* For write */ 732e47cc2bSSean Wang #define C_COM_DRV_OWN BIT(8) /* For read */ 749aebfd4aSSean Wang #define C_FW_OWN_REQ_CLR BIT(9) 759aebfd4aSSean Wang 769aebfd4aSSean Wang #define MTK_REG_CSDIOCSR 0x8 779aebfd4aSSean Wang #define SDIO_RE_INIT_EN BIT(0) 789aebfd4aSSean Wang #define SDIO_INT_CTL BIT(2) 799aebfd4aSSean Wang 809aebfd4aSSean Wang #define MTK_REG_CHCR 0xc 819aebfd4aSSean Wang #define C_INT_CLR_CTRL BIT(1) 829aebfd4aSSean Wang 839aebfd4aSSean Wang /* CHISR have the same bits field definition with CHIER */ 849aebfd4aSSean Wang #define MTK_REG_CHISR 0x10 859aebfd4aSSean Wang #define MTK_REG_CHIER 0x14 869aebfd4aSSean Wang #define FW_OWN_BACK_INT BIT(0) 879aebfd4aSSean Wang #define RX_DONE_INT BIT(1) 889aebfd4aSSean Wang #define TX_EMPTY BIT(2) 899aebfd4aSSean Wang #define TX_FIFO_OVERFLOW BIT(8) 909aebfd4aSSean Wang #define RX_PKT_LEN GENMASK(31, 16) 919aebfd4aSSean Wang 929aebfd4aSSean Wang #define MTK_REG_CTDR 0x18 939aebfd4aSSean Wang 949aebfd4aSSean Wang #define MTK_REG_CRDR 0x1c 959aebfd4aSSean Wang 96184ea403SSean Wang #define MTK_REG_CRPLR 0x24 97184ea403SSean Wang 989aebfd4aSSean Wang #define MTK_SDIO_BLOCK_SIZE 256 999aebfd4aSSean Wang 1009aebfd4aSSean Wang #define BTMTKSDIO_TX_WAIT_VND_EVT 1 101*d555b1f2SSean Wang #define BTMTKSDIO_HW_TX_READY 2 1029aebfd4aSSean Wang 1039aebfd4aSSean Wang struct mtkbtsdio_hdr { 1049aebfd4aSSean Wang __le16 len; 1059aebfd4aSSean Wang __le16 reserved; 1069aebfd4aSSean Wang u8 bt_type; 1079aebfd4aSSean Wang } __packed; 1089aebfd4aSSean Wang 1099aebfd4aSSean Wang struct btmtksdio_dev { 1109aebfd4aSSean Wang struct hci_dev *hdev; 1119aebfd4aSSean Wang struct sdio_func *func; 1127f3c563cSSean Wang struct device *dev; 1139aebfd4aSSean Wang 11426270bc1SSean Wang struct work_struct txrx_work; 1159aebfd4aSSean Wang unsigned long tx_state; 1169aebfd4aSSean Wang struct sk_buff_head txq; 1179aebfd4aSSean Wang 1189aebfd4aSSean Wang struct sk_buff *evt_skb; 1199aebfd4aSSean Wang 1209aebfd4aSSean Wang const struct btmtksdio_data *data; 1219aebfd4aSSean Wang }; 1229aebfd4aSSean Wang 1239aebfd4aSSean Wang static int mtk_hci_wmt_sync(struct hci_dev *hdev, 1249aebfd4aSSean Wang struct btmtk_hci_wmt_params *wmt_params) 1259aebfd4aSSean Wang { 1269aebfd4aSSean Wang struct btmtksdio_dev *bdev = hci_get_drvdata(hdev); 1279aebfd4aSSean Wang struct btmtk_hci_wmt_evt_funcc *wmt_evt_funcc; 128c603bf1fSSean Wang struct btmtk_hci_wmt_evt_reg *wmt_evt_reg; 1299aebfd4aSSean Wang u32 hlen, status = BTMTK_WMT_INVALID; 1309aebfd4aSSean Wang struct btmtk_hci_wmt_evt *wmt_evt; 1313a722044SSean Wang struct btmtk_hci_wmt_cmd *wc; 1323a722044SSean Wang struct btmtk_wmt_hdr *hdr; 1339aebfd4aSSean Wang int err; 1349aebfd4aSSean Wang 1353a722044SSean Wang /* Send the WMT command and wait until the WMT event returns */ 1369aebfd4aSSean Wang hlen = sizeof(*hdr) + wmt_params->dlen; 1379aebfd4aSSean Wang if (hlen > 255) 1389aebfd4aSSean Wang return -EINVAL; 1399aebfd4aSSean Wang 1403a722044SSean Wang wc = kzalloc(hlen, GFP_KERNEL); 1413a722044SSean Wang if (!wc) 1423a722044SSean Wang return -ENOMEM; 1433a722044SSean Wang 1443a722044SSean Wang hdr = &wc->hdr; 1459aebfd4aSSean Wang hdr->dir = 1; 1469aebfd4aSSean Wang hdr->op = wmt_params->op; 1479aebfd4aSSean Wang hdr->dlen = cpu_to_le16(wmt_params->dlen + 1); 1489aebfd4aSSean Wang hdr->flag = wmt_params->flag; 1493a722044SSean Wang memcpy(wc->data, wmt_params->data, wmt_params->dlen); 1509aebfd4aSSean Wang 1519aebfd4aSSean Wang set_bit(BTMTKSDIO_TX_WAIT_VND_EVT, &bdev->tx_state); 1529aebfd4aSSean Wang 1533a722044SSean Wang err = __hci_cmd_send(hdev, 0xfc6f, hlen, wc); 1549aebfd4aSSean Wang if (err < 0) { 1559aebfd4aSSean Wang clear_bit(BTMTKSDIO_TX_WAIT_VND_EVT, &bdev->tx_state); 1563a722044SSean Wang goto err_free_wc; 1579aebfd4aSSean Wang } 1589aebfd4aSSean Wang 1599aebfd4aSSean Wang /* The vendor specific WMT commands are all answered by a vendor 1609aebfd4aSSean Wang * specific event and will not have the Command Status or Command 1619aebfd4aSSean Wang * Complete as with usual HCI command flow control. 1629aebfd4aSSean Wang * 1639aebfd4aSSean Wang * After sending the command, wait for BTMTKSDIO_TX_WAIT_VND_EVT 1649aebfd4aSSean Wang * state to be cleared. The driver specific event receive routine 1659aebfd4aSSean Wang * will clear that state and with that indicate completion of the 1669aebfd4aSSean Wang * WMT command. 1679aebfd4aSSean Wang */ 1689aebfd4aSSean Wang err = wait_on_bit_timeout(&bdev->tx_state, BTMTKSDIO_TX_WAIT_VND_EVT, 1699aebfd4aSSean Wang TASK_INTERRUPTIBLE, HCI_INIT_TIMEOUT); 1709aebfd4aSSean Wang if (err == -EINTR) { 1719aebfd4aSSean Wang bt_dev_err(hdev, "Execution of wmt command interrupted"); 1729aebfd4aSSean Wang clear_bit(BTMTKSDIO_TX_WAIT_VND_EVT, &bdev->tx_state); 1733a722044SSean Wang goto err_free_wc; 1749aebfd4aSSean Wang } 1759aebfd4aSSean Wang 1769aebfd4aSSean Wang if (err) { 1779aebfd4aSSean Wang bt_dev_err(hdev, "Execution of wmt command timed out"); 1789aebfd4aSSean Wang clear_bit(BTMTKSDIO_TX_WAIT_VND_EVT, &bdev->tx_state); 1793a722044SSean Wang err = -ETIMEDOUT; 1803a722044SSean Wang goto err_free_wc; 1819aebfd4aSSean Wang } 1829aebfd4aSSean Wang 1839aebfd4aSSean Wang /* Parse and handle the return WMT event */ 1849aebfd4aSSean Wang wmt_evt = (struct btmtk_hci_wmt_evt *)bdev->evt_skb->data; 1859aebfd4aSSean Wang if (wmt_evt->whdr.op != hdr->op) { 1869aebfd4aSSean Wang bt_dev_err(hdev, "Wrong op received %d expected %d", 1879aebfd4aSSean Wang wmt_evt->whdr.op, hdr->op); 1889aebfd4aSSean Wang err = -EIO; 1899aebfd4aSSean Wang goto err_free_skb; 1909aebfd4aSSean Wang } 1919aebfd4aSSean Wang 1929aebfd4aSSean Wang switch (wmt_evt->whdr.op) { 1933a722044SSean Wang case BTMTK_WMT_SEMAPHORE: 1949aebfd4aSSean Wang if (wmt_evt->whdr.flag == 2) 1959aebfd4aSSean Wang status = BTMTK_WMT_PATCH_UNDONE; 1969aebfd4aSSean Wang else 1979aebfd4aSSean Wang status = BTMTK_WMT_PATCH_DONE; 1989aebfd4aSSean Wang break; 1993a722044SSean Wang case BTMTK_WMT_FUNC_CTRL: 2009aebfd4aSSean Wang wmt_evt_funcc = (struct btmtk_hci_wmt_evt_funcc *)wmt_evt; 2019aebfd4aSSean Wang if (be16_to_cpu(wmt_evt_funcc->status) == 0x404) 2029aebfd4aSSean Wang status = BTMTK_WMT_ON_DONE; 2039aebfd4aSSean Wang else if (be16_to_cpu(wmt_evt_funcc->status) == 0x420) 2049aebfd4aSSean Wang status = BTMTK_WMT_ON_PROGRESS; 2059aebfd4aSSean Wang else 2069aebfd4aSSean Wang status = BTMTK_WMT_ON_UNDONE; 2079aebfd4aSSean Wang break; 208c603bf1fSSean Wang case BTMTK_WMT_PATCH_DWNLD: 209c603bf1fSSean Wang if (wmt_evt->whdr.flag == 2) 210c603bf1fSSean Wang status = BTMTK_WMT_PATCH_DONE; 211c603bf1fSSean Wang else if (wmt_evt->whdr.flag == 1) 212c603bf1fSSean Wang status = BTMTK_WMT_PATCH_PROGRESS; 213c603bf1fSSean Wang else 214c603bf1fSSean Wang status = BTMTK_WMT_PATCH_UNDONE; 215c603bf1fSSean Wang break; 216c603bf1fSSean Wang case BTMTK_WMT_REGISTER: 217c603bf1fSSean Wang wmt_evt_reg = (struct btmtk_hci_wmt_evt_reg *)wmt_evt; 218c603bf1fSSean Wang if (le16_to_cpu(wmt_evt->whdr.dlen) == 12) 219c603bf1fSSean Wang status = le32_to_cpu(wmt_evt_reg->val); 220c603bf1fSSean Wang break; 2219aebfd4aSSean Wang } 2229aebfd4aSSean Wang 2239aebfd4aSSean Wang if (wmt_params->status) 2249aebfd4aSSean Wang *wmt_params->status = status; 2259aebfd4aSSean Wang 2269aebfd4aSSean Wang err_free_skb: 2279aebfd4aSSean Wang kfree_skb(bdev->evt_skb); 2289aebfd4aSSean Wang bdev->evt_skb = NULL; 2293a722044SSean Wang err_free_wc: 2303a722044SSean Wang kfree(wc); 2319aebfd4aSSean Wang 2329aebfd4aSSean Wang return err; 2339aebfd4aSSean Wang } 2349aebfd4aSSean Wang 2359aebfd4aSSean Wang static int btmtksdio_tx_packet(struct btmtksdio_dev *bdev, 2369aebfd4aSSean Wang struct sk_buff *skb) 2379aebfd4aSSean Wang { 2389aebfd4aSSean Wang struct mtkbtsdio_hdr *sdio_hdr; 2399aebfd4aSSean Wang int err; 2409aebfd4aSSean Wang 2419aebfd4aSSean Wang /* Make sure that there are enough rooms for SDIO header */ 2429aebfd4aSSean Wang if (unlikely(skb_headroom(skb) < sizeof(*sdio_hdr))) { 2439aebfd4aSSean Wang err = pskb_expand_head(skb, sizeof(*sdio_hdr), 0, 2449aebfd4aSSean Wang GFP_ATOMIC); 2459aebfd4aSSean Wang if (err < 0) 2469aebfd4aSSean Wang return err; 2479aebfd4aSSean Wang } 2489aebfd4aSSean Wang 2499aebfd4aSSean Wang /* Prepend MediaTek SDIO Specific Header */ 2509aebfd4aSSean Wang skb_push(skb, sizeof(*sdio_hdr)); 2519aebfd4aSSean Wang 2529aebfd4aSSean Wang sdio_hdr = (void *)skb->data; 2539aebfd4aSSean Wang sdio_hdr->len = cpu_to_le16(skb->len); 2549aebfd4aSSean Wang sdio_hdr->reserved = cpu_to_le16(0); 2559aebfd4aSSean Wang sdio_hdr->bt_type = hci_skb_pkt_type(skb); 2569aebfd4aSSean Wang 257*d555b1f2SSean Wang clear_bit(BTMTKSDIO_HW_TX_READY, &bdev->tx_state); 2589aebfd4aSSean Wang err = sdio_writesb(bdev->func, MTK_REG_CTDR, skb->data, 2599aebfd4aSSean Wang round_up(skb->len, MTK_SDIO_BLOCK_SIZE)); 2609aebfd4aSSean Wang if (err < 0) 2619aebfd4aSSean Wang goto err_skb_pull; 2629aebfd4aSSean Wang 2639aebfd4aSSean Wang bdev->hdev->stat.byte_tx += skb->len; 2649aebfd4aSSean Wang 2659aebfd4aSSean Wang kfree_skb(skb); 2669aebfd4aSSean Wang 2679aebfd4aSSean Wang return 0; 2689aebfd4aSSean Wang 2699aebfd4aSSean Wang err_skb_pull: 2709aebfd4aSSean Wang skb_pull(skb, sizeof(*sdio_hdr)); 2719aebfd4aSSean Wang 2729aebfd4aSSean Wang return err; 2739aebfd4aSSean Wang } 2749aebfd4aSSean Wang 2759aebfd4aSSean Wang static u32 btmtksdio_drv_own_query(struct btmtksdio_dev *bdev) 2769aebfd4aSSean Wang { 2779aebfd4aSSean Wang return sdio_readl(bdev->func, MTK_REG_CHLPCR, NULL); 2789aebfd4aSSean Wang } 2799aebfd4aSSean Wang 2809aebfd4aSSean Wang static int btmtksdio_recv_event(struct hci_dev *hdev, struct sk_buff *skb) 2819aebfd4aSSean Wang { 2829aebfd4aSSean Wang struct btmtksdio_dev *bdev = hci_get_drvdata(hdev); 2839aebfd4aSSean Wang struct hci_event_hdr *hdr = (void *)skb->data; 2849aebfd4aSSean Wang int err; 2859aebfd4aSSean Wang 2869aebfd4aSSean Wang /* Fix up the vendor event id with 0xff for vendor specific instead 2879aebfd4aSSean Wang * of 0xe4 so that event send via monitoring socket can be parsed 2889aebfd4aSSean Wang * properly. 2899aebfd4aSSean Wang */ 2909aebfd4aSSean Wang if (hdr->evt == 0xe4) 2919aebfd4aSSean Wang hdr->evt = HCI_EV_VENDOR; 2929aebfd4aSSean Wang 2939aebfd4aSSean Wang /* When someone waits for the WMT event, the skb is being cloned 2949aebfd4aSSean Wang * and being processed the events from there then. 2959aebfd4aSSean Wang */ 2969aebfd4aSSean Wang if (test_bit(BTMTKSDIO_TX_WAIT_VND_EVT, &bdev->tx_state)) { 2979aebfd4aSSean Wang bdev->evt_skb = skb_clone(skb, GFP_KERNEL); 2989aebfd4aSSean Wang if (!bdev->evt_skb) { 2999aebfd4aSSean Wang err = -ENOMEM; 3009aebfd4aSSean Wang goto err_out; 3019aebfd4aSSean Wang } 3029aebfd4aSSean Wang } 3039aebfd4aSSean Wang 3049aebfd4aSSean Wang err = hci_recv_frame(hdev, skb); 3059aebfd4aSSean Wang if (err < 0) 3069aebfd4aSSean Wang goto err_free_skb; 3079aebfd4aSSean Wang 3089aebfd4aSSean Wang if (hdr->evt == HCI_EV_VENDOR) { 3099aebfd4aSSean Wang if (test_and_clear_bit(BTMTKSDIO_TX_WAIT_VND_EVT, 3109aebfd4aSSean Wang &bdev->tx_state)) { 3119aebfd4aSSean Wang /* Barrier to sync with other CPUs */ 3129aebfd4aSSean Wang smp_mb__after_atomic(); 3139aebfd4aSSean Wang wake_up_bit(&bdev->tx_state, BTMTKSDIO_TX_WAIT_VND_EVT); 3149aebfd4aSSean Wang } 3159aebfd4aSSean Wang } 3169aebfd4aSSean Wang 3179aebfd4aSSean Wang return 0; 3189aebfd4aSSean Wang 3199aebfd4aSSean Wang err_free_skb: 3209aebfd4aSSean Wang kfree_skb(bdev->evt_skb); 3219aebfd4aSSean Wang bdev->evt_skb = NULL; 3229aebfd4aSSean Wang 3239aebfd4aSSean Wang err_out: 3249aebfd4aSSean Wang return err; 3259aebfd4aSSean Wang } 3269aebfd4aSSean Wang 327db57b625SSean Wang static int btmtksdio_recv_acl(struct hci_dev *hdev, struct sk_buff *skb) 328db57b625SSean Wang { 329db57b625SSean Wang struct btmtksdio_dev *bdev = hci_get_drvdata(hdev); 330db57b625SSean Wang u16 handle = le16_to_cpu(hci_acl_hdr(skb)->handle); 331db57b625SSean Wang 332db57b625SSean Wang switch (handle) { 333db57b625SSean Wang case 0xfc6f: 334db57b625SSean Wang /* Firmware dump from device: when the firmware hangs, the 335db57b625SSean Wang * device can no longer suspend and thus disable auto-suspend. 336db57b625SSean Wang */ 337db57b625SSean Wang pm_runtime_forbid(bdev->dev); 338db57b625SSean Wang fallthrough; 339db57b625SSean Wang case 0x05ff: 340db57b625SSean Wang case 0x05fe: 341db57b625SSean Wang /* Firmware debug logging */ 342db57b625SSean Wang return hci_recv_diag(hdev, skb); 343db57b625SSean Wang } 344db57b625SSean Wang 345db57b625SSean Wang return hci_recv_frame(hdev, skb); 346db57b625SSean Wang } 347db57b625SSean Wang 3489aebfd4aSSean Wang static const struct h4_recv_pkt mtk_recv_pkts[] = { 349db57b625SSean Wang { H4_RECV_ACL, .recv = btmtksdio_recv_acl }, 3509aebfd4aSSean Wang { H4_RECV_SCO, .recv = hci_recv_frame }, 3519aebfd4aSSean Wang { H4_RECV_EVENT, .recv = btmtksdio_recv_event }, 3529aebfd4aSSean Wang }; 3539aebfd4aSSean Wang 3549aebfd4aSSean Wang static int btmtksdio_rx_packet(struct btmtksdio_dev *bdev, u16 rx_size) 3559aebfd4aSSean Wang { 3569aebfd4aSSean Wang const struct h4_recv_pkt *pkts = mtk_recv_pkts; 3579aebfd4aSSean Wang int pkts_count = ARRAY_SIZE(mtk_recv_pkts); 3589aebfd4aSSean Wang struct mtkbtsdio_hdr *sdio_hdr; 3599aebfd4aSSean Wang int err, i, pad_size; 3609aebfd4aSSean Wang struct sk_buff *skb; 3619aebfd4aSSean Wang u16 dlen; 3629aebfd4aSSean Wang 3639aebfd4aSSean Wang if (rx_size < sizeof(*sdio_hdr)) 3649aebfd4aSSean Wang return -EILSEQ; 3659aebfd4aSSean Wang 3669aebfd4aSSean Wang /* A SDIO packet is exactly containing a Bluetooth packet */ 3679aebfd4aSSean Wang skb = bt_skb_alloc(rx_size, GFP_KERNEL); 3689aebfd4aSSean Wang if (!skb) 3699aebfd4aSSean Wang return -ENOMEM; 3709aebfd4aSSean Wang 3719aebfd4aSSean Wang skb_put(skb, rx_size); 3729aebfd4aSSean Wang 3739aebfd4aSSean Wang err = sdio_readsb(bdev->func, skb->data, MTK_REG_CRDR, rx_size); 3749aebfd4aSSean Wang if (err < 0) 3759aebfd4aSSean Wang goto err_kfree_skb; 3769aebfd4aSSean Wang 3779aebfd4aSSean Wang sdio_hdr = (void *)skb->data; 3789aebfd4aSSean Wang 3799aebfd4aSSean Wang /* We assume the default error as -EILSEQ simply to make the error path 3809aebfd4aSSean Wang * be cleaner. 3819aebfd4aSSean Wang */ 3829aebfd4aSSean Wang err = -EILSEQ; 3839aebfd4aSSean Wang 3849aebfd4aSSean Wang if (rx_size != le16_to_cpu(sdio_hdr->len)) { 3859aebfd4aSSean Wang bt_dev_err(bdev->hdev, "Rx size in sdio header is mismatched "); 3869aebfd4aSSean Wang goto err_kfree_skb; 3879aebfd4aSSean Wang } 3889aebfd4aSSean Wang 3899aebfd4aSSean Wang hci_skb_pkt_type(skb) = sdio_hdr->bt_type; 3909aebfd4aSSean Wang 3919aebfd4aSSean Wang /* Remove MediaTek SDIO header */ 3929aebfd4aSSean Wang skb_pull(skb, sizeof(*sdio_hdr)); 3939aebfd4aSSean Wang 3949aebfd4aSSean Wang /* We have to dig into the packet to get payload size and then know how 3959aebfd4aSSean Wang * many padding bytes at the tail, these padding bytes should be removed 3969aebfd4aSSean Wang * before the packet is indicated to the core layer. 3979aebfd4aSSean Wang */ 3989aebfd4aSSean Wang for (i = 0; i < pkts_count; i++) { 3999aebfd4aSSean Wang if (sdio_hdr->bt_type == (&pkts[i])->type) 4009aebfd4aSSean Wang break; 4019aebfd4aSSean Wang } 4029aebfd4aSSean Wang 4039aebfd4aSSean Wang if (i >= pkts_count) { 4049aebfd4aSSean Wang bt_dev_err(bdev->hdev, "Invalid bt type 0x%02x", 4059aebfd4aSSean Wang sdio_hdr->bt_type); 4069aebfd4aSSean Wang goto err_kfree_skb; 4079aebfd4aSSean Wang } 4089aebfd4aSSean Wang 4099aebfd4aSSean Wang /* Remaining bytes cannot hold a header*/ 4109aebfd4aSSean Wang if (skb->len < (&pkts[i])->hlen) { 4119aebfd4aSSean Wang bt_dev_err(bdev->hdev, "The size of bt header is mismatched"); 4129aebfd4aSSean Wang goto err_kfree_skb; 4139aebfd4aSSean Wang } 4149aebfd4aSSean Wang 4159aebfd4aSSean Wang switch ((&pkts[i])->lsize) { 4169aebfd4aSSean Wang case 1: 4179aebfd4aSSean Wang dlen = skb->data[(&pkts[i])->loff]; 4189aebfd4aSSean Wang break; 4199aebfd4aSSean Wang case 2: 4209aebfd4aSSean Wang dlen = get_unaligned_le16(skb->data + 4219aebfd4aSSean Wang (&pkts[i])->loff); 4229aebfd4aSSean Wang break; 4239aebfd4aSSean Wang default: 4249aebfd4aSSean Wang goto err_kfree_skb; 4259aebfd4aSSean Wang } 4269aebfd4aSSean Wang 4279aebfd4aSSean Wang pad_size = skb->len - (&pkts[i])->hlen - dlen; 4289aebfd4aSSean Wang 4299aebfd4aSSean Wang /* Remaining bytes cannot hold a payload */ 4309aebfd4aSSean Wang if (pad_size < 0) { 4319aebfd4aSSean Wang bt_dev_err(bdev->hdev, "The size of bt payload is mismatched"); 4329aebfd4aSSean Wang goto err_kfree_skb; 4339aebfd4aSSean Wang } 4349aebfd4aSSean Wang 4359aebfd4aSSean Wang /* Remove padding bytes */ 4369aebfd4aSSean Wang skb_trim(skb, skb->len - pad_size); 4379aebfd4aSSean Wang 4389aebfd4aSSean Wang /* Complete frame */ 4399aebfd4aSSean Wang (&pkts[i])->recv(bdev->hdev, skb); 4409aebfd4aSSean Wang 441bcaa7d72SSean Wang bdev->hdev->stat.byte_rx += rx_size; 442bcaa7d72SSean Wang 4439aebfd4aSSean Wang return 0; 4449aebfd4aSSean Wang 4459aebfd4aSSean Wang err_kfree_skb: 4469aebfd4aSSean Wang kfree_skb(skb); 4479aebfd4aSSean Wang 4489aebfd4aSSean Wang return err; 4499aebfd4aSSean Wang } 4509aebfd4aSSean Wang 45126270bc1SSean Wang static void btmtksdio_txrx_work(struct work_struct *work) 4529aebfd4aSSean Wang { 45326270bc1SSean Wang struct btmtksdio_dev *bdev = container_of(work, struct btmtksdio_dev, 45426270bc1SSean Wang txrx_work); 45526270bc1SSean Wang unsigned long txrx_timeout; 456184ea403SSean Wang u32 int_status, rx_size; 45726270bc1SSean Wang struct sk_buff *skb; 45826270bc1SSean Wang int err; 4597f3c563cSSean Wang 4607f3c563cSSean Wang pm_runtime_get_sync(bdev->dev); 4617f3c563cSSean Wang 4627f3c563cSSean Wang sdio_claim_host(bdev->func); 4637f3c563cSSean Wang 4649aebfd4aSSean Wang /* Disable interrupt */ 46526270bc1SSean Wang sdio_writel(bdev->func, C_INT_EN_CLR, MTK_REG_CHLPCR, 0); 4669aebfd4aSSean Wang 46726270bc1SSean Wang txrx_timeout = jiffies + 5 * HZ; 46826270bc1SSean Wang 46926270bc1SSean Wang do { 47026270bc1SSean Wang int_status = sdio_readl(bdev->func, MTK_REG_CHISR, NULL); 4719aebfd4aSSean Wang 4729aebfd4aSSean Wang /* Ack an interrupt as soon as possible before any operation on 4739aebfd4aSSean Wang * hardware. 4749aebfd4aSSean Wang * 4759aebfd4aSSean Wang * Note that we don't ack any status during operations to avoid race 4769aebfd4aSSean Wang * condition between the host and the device such as it's possible to 4779aebfd4aSSean Wang * mistakenly ack RX_DONE for the next packet and then cause interrupts 4789aebfd4aSSean Wang * not be raised again but there is still pending data in the hardware 4799aebfd4aSSean Wang * FIFO. 4809aebfd4aSSean Wang */ 48126270bc1SSean Wang sdio_writel(bdev->func, int_status, MTK_REG_CHISR, NULL); 4829aebfd4aSSean Wang 4839aebfd4aSSean Wang if (int_status & FW_OWN_BACK_INT) 484e1052fb2SSean Wang bt_dev_dbg(bdev->hdev, "Get fw own back"); 4859aebfd4aSSean Wang 4869aebfd4aSSean Wang if (int_status & TX_EMPTY) 487*d555b1f2SSean Wang set_bit(BTMTKSDIO_HW_TX_READY, &bdev->tx_state); 488*d555b1f2SSean Wang 4899aebfd4aSSean Wang else if (unlikely(int_status & TX_FIFO_OVERFLOW)) 490e1052fb2SSean Wang bt_dev_warn(bdev->hdev, "Tx fifo overflow"); 4919aebfd4aSSean Wang 492*d555b1f2SSean Wang if (test_bit(BTMTKSDIO_HW_TX_READY, &bdev->tx_state)) { 49310fe40e1SMark-yw Chen skb = skb_dequeue(&bdev->txq); 49410fe40e1SMark-yw Chen if (skb) { 49510fe40e1SMark-yw Chen err = btmtksdio_tx_packet(bdev, skb); 49610fe40e1SMark-yw Chen if (err < 0) { 49710fe40e1SMark-yw Chen bdev->hdev->stat.err_tx++; 49810fe40e1SMark-yw Chen skb_queue_head(&bdev->txq, skb); 49910fe40e1SMark-yw Chen } 50010fe40e1SMark-yw Chen } 50110fe40e1SMark-yw Chen } 50210fe40e1SMark-yw Chen 5039aebfd4aSSean Wang if (int_status & RX_DONE_INT) { 504184ea403SSean Wang rx_size = sdio_readl(bdev->func, MTK_REG_CRPLR, NULL); 505184ea403SSean Wang rx_size = (rx_size & RX_PKT_LEN) >> 16; 5069aebfd4aSSean Wang if (btmtksdio_rx_packet(bdev, rx_size) < 0) 5079aebfd4aSSean Wang bdev->hdev->stat.err_rx++; 5089aebfd4aSSean Wang } 50926270bc1SSean Wang } while (int_status || time_is_before_jiffies(txrx_timeout)); 51026270bc1SSean Wang 5119aebfd4aSSean Wang /* Enable interrupt */ 51226270bc1SSean Wang sdio_writel(bdev->func, C_INT_EN_SET, MTK_REG_CHLPCR, 0); 51326270bc1SSean Wang 51426270bc1SSean Wang sdio_release_host(bdev->func); 5157f3c563cSSean Wang 5167f3c563cSSean Wang pm_runtime_mark_last_busy(bdev->dev); 5177f3c563cSSean Wang pm_runtime_put_autosuspend(bdev->dev); 5189aebfd4aSSean Wang } 5199aebfd4aSSean Wang 52026270bc1SSean Wang static void btmtksdio_interrupt(struct sdio_func *func) 52126270bc1SSean Wang { 52226270bc1SSean Wang struct btmtksdio_dev *bdev = sdio_get_drvdata(func); 52326270bc1SSean Wang 52426270bc1SSean Wang /* Disable interrupt */ 52526270bc1SSean Wang sdio_writel(bdev->func, C_INT_EN_CLR, MTK_REG_CHLPCR, 0); 52626270bc1SSean Wang 52726270bc1SSean Wang schedule_work(&bdev->txrx_work); 52826270bc1SSean Wang } 52926270bc1SSean Wang 5309aebfd4aSSean Wang static int btmtksdio_open(struct hci_dev *hdev) 5319aebfd4aSSean Wang { 5329aebfd4aSSean Wang struct btmtksdio_dev *bdev = hci_get_drvdata(hdev); 53377b210d1SSean Wang u32 status, val; 5349aebfd4aSSean Wang int err; 5359aebfd4aSSean Wang 5369aebfd4aSSean Wang sdio_claim_host(bdev->func); 5379aebfd4aSSean Wang 5389aebfd4aSSean Wang err = sdio_enable_func(bdev->func); 5399aebfd4aSSean Wang if (err < 0) 5409aebfd4aSSean Wang goto err_release_host; 5419aebfd4aSSean Wang 5429aebfd4aSSean Wang /* Get ownership from the device */ 5439aebfd4aSSean Wang sdio_writel(bdev->func, C_FW_OWN_REQ_CLR, MTK_REG_CHLPCR, &err); 5449aebfd4aSSean Wang if (err < 0) 5459aebfd4aSSean Wang goto err_disable_func; 5469aebfd4aSSean Wang 5479aebfd4aSSean Wang err = readx_poll_timeout(btmtksdio_drv_own_query, bdev, status, 5482e47cc2bSSean Wang status & C_COM_DRV_OWN, 2000, 1000000); 5499aebfd4aSSean Wang if (err < 0) { 5509aebfd4aSSean Wang bt_dev_err(bdev->hdev, "Cannot get ownership from device"); 5519aebfd4aSSean Wang goto err_disable_func; 5529aebfd4aSSean Wang } 5539aebfd4aSSean Wang 5549aebfd4aSSean Wang /* Disable interrupt & mask out all interrupt sources */ 5559aebfd4aSSean Wang sdio_writel(bdev->func, C_INT_EN_CLR, MTK_REG_CHLPCR, &err); 5569aebfd4aSSean Wang if (err < 0) 5579aebfd4aSSean Wang goto err_disable_func; 5589aebfd4aSSean Wang 5599aebfd4aSSean Wang sdio_writel(bdev->func, 0, MTK_REG_CHIER, &err); 5609aebfd4aSSean Wang if (err < 0) 5619aebfd4aSSean Wang goto err_disable_func; 5629aebfd4aSSean Wang 5639aebfd4aSSean Wang err = sdio_claim_irq(bdev->func, btmtksdio_interrupt); 5649aebfd4aSSean Wang if (err < 0) 5659aebfd4aSSean Wang goto err_disable_func; 5669aebfd4aSSean Wang 5679aebfd4aSSean Wang err = sdio_set_block_size(bdev->func, MTK_SDIO_BLOCK_SIZE); 5689aebfd4aSSean Wang if (err < 0) 5699aebfd4aSSean Wang goto err_release_irq; 5709aebfd4aSSean Wang 5719aebfd4aSSean Wang /* SDIO CMD 5 allows the SDIO device back to idle state an 5729aebfd4aSSean Wang * synchronous interrupt is supported in SDIO 4-bit mode 5739aebfd4aSSean Wang */ 5745b23ac1aSSean Wang val = sdio_readl(bdev->func, MTK_REG_CSDIOCSR, &err); 5755b23ac1aSSean Wang if (err < 0) 5765b23ac1aSSean Wang goto err_release_irq; 5775b23ac1aSSean Wang 5785b23ac1aSSean Wang val |= SDIO_INT_CTL; 5795b23ac1aSSean Wang sdio_writel(bdev->func, val, MTK_REG_CSDIOCSR, &err); 5809aebfd4aSSean Wang if (err < 0) 5819aebfd4aSSean Wang goto err_release_irq; 5829aebfd4aSSean Wang 58377b210d1SSean Wang /* Explitly set write-1-clear method */ 58477b210d1SSean Wang val = sdio_readl(bdev->func, MTK_REG_CHCR, &err); 58577b210d1SSean Wang if (err < 0) 58677b210d1SSean Wang goto err_release_irq; 58777b210d1SSean Wang 58877b210d1SSean Wang val |= C_INT_CLR_CTRL; 58977b210d1SSean Wang sdio_writel(bdev->func, val, MTK_REG_CHCR, &err); 5909aebfd4aSSean Wang if (err < 0) 5919aebfd4aSSean Wang goto err_release_irq; 5929aebfd4aSSean Wang 5939aebfd4aSSean Wang /* Setup interrupt sources */ 5949aebfd4aSSean Wang sdio_writel(bdev->func, RX_DONE_INT | TX_EMPTY | TX_FIFO_OVERFLOW, 5959aebfd4aSSean Wang MTK_REG_CHIER, &err); 5969aebfd4aSSean Wang if (err < 0) 5979aebfd4aSSean Wang goto err_release_irq; 5989aebfd4aSSean Wang 5999aebfd4aSSean Wang /* Enable interrupt */ 6009aebfd4aSSean Wang sdio_writel(bdev->func, C_INT_EN_SET, MTK_REG_CHLPCR, &err); 6019aebfd4aSSean Wang if (err < 0) 6029aebfd4aSSean Wang goto err_release_irq; 6039aebfd4aSSean Wang 6049aebfd4aSSean Wang sdio_release_host(bdev->func); 6059aebfd4aSSean Wang 6069aebfd4aSSean Wang return 0; 6079aebfd4aSSean Wang 6089aebfd4aSSean Wang err_release_irq: 6099aebfd4aSSean Wang sdio_release_irq(bdev->func); 6109aebfd4aSSean Wang 6119aebfd4aSSean Wang err_disable_func: 6129aebfd4aSSean Wang sdio_disable_func(bdev->func); 6139aebfd4aSSean Wang 6149aebfd4aSSean Wang err_release_host: 6159aebfd4aSSean Wang sdio_release_host(bdev->func); 6169aebfd4aSSean Wang 6179aebfd4aSSean Wang return err; 6189aebfd4aSSean Wang } 6199aebfd4aSSean Wang 6209aebfd4aSSean Wang static int btmtksdio_close(struct hci_dev *hdev) 6219aebfd4aSSean Wang { 6229aebfd4aSSean Wang struct btmtksdio_dev *bdev = hci_get_drvdata(hdev); 6239aebfd4aSSean Wang u32 status; 6249aebfd4aSSean Wang int err; 6259aebfd4aSSean Wang 6269aebfd4aSSean Wang sdio_claim_host(bdev->func); 6279aebfd4aSSean Wang 6289aebfd4aSSean Wang /* Disable interrupt */ 6299aebfd4aSSean Wang sdio_writel(bdev->func, C_INT_EN_CLR, MTK_REG_CHLPCR, NULL); 6309aebfd4aSSean Wang 6319aebfd4aSSean Wang sdio_release_irq(bdev->func); 6329aebfd4aSSean Wang 63326270bc1SSean Wang cancel_work_sync(&bdev->txrx_work); 63426270bc1SSean Wang 6359aebfd4aSSean Wang /* Return ownership to the device */ 6369aebfd4aSSean Wang sdio_writel(bdev->func, C_FW_OWN_REQ_SET, MTK_REG_CHLPCR, NULL); 6379aebfd4aSSean Wang 6389aebfd4aSSean Wang err = readx_poll_timeout(btmtksdio_drv_own_query, bdev, status, 6392e47cc2bSSean Wang !(status & C_COM_DRV_OWN), 2000, 1000000); 6409aebfd4aSSean Wang if (err < 0) 6419aebfd4aSSean Wang bt_dev_err(bdev->hdev, "Cannot return ownership to device"); 6429aebfd4aSSean Wang 6439aebfd4aSSean Wang sdio_disable_func(bdev->func); 6449aebfd4aSSean Wang 6459aebfd4aSSean Wang sdio_release_host(bdev->func); 6469aebfd4aSSean Wang 6479aebfd4aSSean Wang return 0; 6489aebfd4aSSean Wang } 6499aebfd4aSSean Wang 6509aebfd4aSSean Wang static int btmtksdio_flush(struct hci_dev *hdev) 6519aebfd4aSSean Wang { 6529aebfd4aSSean Wang struct btmtksdio_dev *bdev = hci_get_drvdata(hdev); 6539aebfd4aSSean Wang 6549aebfd4aSSean Wang skb_queue_purge(&bdev->txq); 6559aebfd4aSSean Wang 65626270bc1SSean Wang cancel_work_sync(&bdev->txrx_work); 6579aebfd4aSSean Wang 6589aebfd4aSSean Wang return 0; 6599aebfd4aSSean Wang } 6609aebfd4aSSean Wang 6619aebfd4aSSean Wang static int btmtksdio_func_query(struct hci_dev *hdev) 6629aebfd4aSSean Wang { 6639aebfd4aSSean Wang struct btmtk_hci_wmt_params wmt_params; 6649aebfd4aSSean Wang int status, err; 6659aebfd4aSSean Wang u8 param = 0; 6669aebfd4aSSean Wang 6679aebfd4aSSean Wang /* Query whether the function is enabled */ 6683a722044SSean Wang wmt_params.op = BTMTK_WMT_FUNC_CTRL; 6699aebfd4aSSean Wang wmt_params.flag = 4; 6709aebfd4aSSean Wang wmt_params.dlen = sizeof(param); 6719aebfd4aSSean Wang wmt_params.data = ¶m; 6729aebfd4aSSean Wang wmt_params.status = &status; 6739aebfd4aSSean Wang 6749aebfd4aSSean Wang err = mtk_hci_wmt_sync(hdev, &wmt_params); 6759aebfd4aSSean Wang if (err < 0) { 6769aebfd4aSSean Wang bt_dev_err(hdev, "Failed to query function status (%d)", err); 6779aebfd4aSSean Wang return err; 6789aebfd4aSSean Wang } 6799aebfd4aSSean Wang 6809aebfd4aSSean Wang return status; 6819aebfd4aSSean Wang } 6829aebfd4aSSean Wang 683c603bf1fSSean Wang static int mt76xx_setup(struct hci_dev *hdev, const char *fwname) 6849aebfd4aSSean Wang { 6859aebfd4aSSean Wang struct btmtk_hci_wmt_params wmt_params; 6869aebfd4aSSean Wang struct btmtk_tci_sleep tci_sleep; 6879aebfd4aSSean Wang struct sk_buff *skb; 6889aebfd4aSSean Wang int err, status; 6899aebfd4aSSean Wang u8 param = 0x1; 6909aebfd4aSSean Wang 6919aebfd4aSSean Wang /* Query whether the firmware is already download */ 6923a722044SSean Wang wmt_params.op = BTMTK_WMT_SEMAPHORE; 6939aebfd4aSSean Wang wmt_params.flag = 1; 6949aebfd4aSSean Wang wmt_params.dlen = 0; 6959aebfd4aSSean Wang wmt_params.data = NULL; 6969aebfd4aSSean Wang wmt_params.status = &status; 6979aebfd4aSSean Wang 6989aebfd4aSSean Wang err = mtk_hci_wmt_sync(hdev, &wmt_params); 6999aebfd4aSSean Wang if (err < 0) { 7009aebfd4aSSean Wang bt_dev_err(hdev, "Failed to query firmware status (%d)", err); 7019aebfd4aSSean Wang return err; 7029aebfd4aSSean Wang } 7039aebfd4aSSean Wang 7049aebfd4aSSean Wang if (status == BTMTK_WMT_PATCH_DONE) { 7059aebfd4aSSean Wang bt_dev_info(hdev, "Firmware already downloaded"); 7069aebfd4aSSean Wang goto ignore_setup_fw; 7079aebfd4aSSean Wang } 7089aebfd4aSSean Wang 7099aebfd4aSSean Wang /* Setup a firmware which the device definitely requires */ 710c603bf1fSSean Wang err = btmtk_setup_firmware(hdev, fwname, mtk_hci_wmt_sync); 7119aebfd4aSSean Wang if (err < 0) 7129aebfd4aSSean Wang return err; 7139aebfd4aSSean Wang 7149aebfd4aSSean Wang ignore_setup_fw: 7159aebfd4aSSean Wang /* Query whether the device is already enabled */ 7169aebfd4aSSean Wang err = readx_poll_timeout(btmtksdio_func_query, hdev, status, 7179aebfd4aSSean Wang status < 0 || status != BTMTK_WMT_ON_PROGRESS, 7189aebfd4aSSean Wang 2000, 5000000); 7199aebfd4aSSean Wang /* -ETIMEDOUT happens */ 7209aebfd4aSSean Wang if (err < 0) 7219aebfd4aSSean Wang return err; 7229aebfd4aSSean Wang 7239aebfd4aSSean Wang /* The other errors happen in btusb_mtk_func_query */ 7249aebfd4aSSean Wang if (status < 0) 7259aebfd4aSSean Wang return status; 7269aebfd4aSSean Wang 7279aebfd4aSSean Wang if (status == BTMTK_WMT_ON_DONE) { 7289aebfd4aSSean Wang bt_dev_info(hdev, "function already on"); 7299aebfd4aSSean Wang goto ignore_func_on; 7309aebfd4aSSean Wang } 7319aebfd4aSSean Wang 7329aebfd4aSSean Wang /* Enable Bluetooth protocol */ 7333a722044SSean Wang wmt_params.op = BTMTK_WMT_FUNC_CTRL; 7349aebfd4aSSean Wang wmt_params.flag = 0; 7359aebfd4aSSean Wang wmt_params.dlen = sizeof(param); 7369aebfd4aSSean Wang wmt_params.data = ¶m; 7379aebfd4aSSean Wang wmt_params.status = NULL; 7389aebfd4aSSean Wang 7399aebfd4aSSean Wang err = mtk_hci_wmt_sync(hdev, &wmt_params); 7409aebfd4aSSean Wang if (err < 0) { 7419aebfd4aSSean Wang bt_dev_err(hdev, "Failed to send wmt func ctrl (%d)", err); 7429aebfd4aSSean Wang return err; 7439aebfd4aSSean Wang } 7449aebfd4aSSean Wang 7459aebfd4aSSean Wang ignore_func_on: 7469aebfd4aSSean Wang /* Apply the low power environment setup */ 7479aebfd4aSSean Wang tci_sleep.mode = 0x5; 7489aebfd4aSSean Wang tci_sleep.duration = cpu_to_le16(0x640); 7499aebfd4aSSean Wang tci_sleep.host_duration = cpu_to_le16(0x640); 7509aebfd4aSSean Wang tci_sleep.host_wakeup_pin = 0; 7519aebfd4aSSean Wang tci_sleep.time_compensation = 0; 7529aebfd4aSSean Wang 7539aebfd4aSSean Wang skb = __hci_cmd_sync(hdev, 0xfc7a, sizeof(tci_sleep), &tci_sleep, 7549aebfd4aSSean Wang HCI_INIT_TIMEOUT); 7559aebfd4aSSean Wang if (IS_ERR(skb)) { 7569aebfd4aSSean Wang err = PTR_ERR(skb); 7579aebfd4aSSean Wang bt_dev_err(hdev, "Failed to apply low power setting (%d)", err); 7589aebfd4aSSean Wang return err; 7599aebfd4aSSean Wang } 7609aebfd4aSSean Wang kfree_skb(skb); 7619aebfd4aSSean Wang 762c603bf1fSSean Wang return 0; 763c603bf1fSSean Wang } 764c603bf1fSSean Wang 765c603bf1fSSean Wang static int mt79xx_setup(struct hci_dev *hdev, const char *fwname) 766c603bf1fSSean Wang { 767c603bf1fSSean Wang struct btmtk_hci_wmt_params wmt_params; 768c603bf1fSSean Wang u8 param = 0x1; 769c603bf1fSSean Wang int err; 770c603bf1fSSean Wang 771c603bf1fSSean Wang err = btmtk_setup_firmware_79xx(hdev, fwname, mtk_hci_wmt_sync); 772c603bf1fSSean Wang if (err < 0) { 773c603bf1fSSean Wang bt_dev_err(hdev, "Failed to setup 79xx firmware (%d)", err); 774c603bf1fSSean Wang return err; 775c603bf1fSSean Wang } 776c603bf1fSSean Wang 777c603bf1fSSean Wang /* Enable Bluetooth protocol */ 778c603bf1fSSean Wang wmt_params.op = BTMTK_WMT_FUNC_CTRL; 779c603bf1fSSean Wang wmt_params.flag = 0; 780c603bf1fSSean Wang wmt_params.dlen = sizeof(param); 781c603bf1fSSean Wang wmt_params.data = ¶m; 782c603bf1fSSean Wang wmt_params.status = NULL; 783c603bf1fSSean Wang 784c603bf1fSSean Wang err = mtk_hci_wmt_sync(hdev, &wmt_params); 785c603bf1fSSean Wang if (err < 0) { 786c603bf1fSSean Wang bt_dev_err(hdev, "Failed to send wmt func ctrl (%d)", err); 787c603bf1fSSean Wang return err; 788c603bf1fSSean Wang } 789c603bf1fSSean Wang 790c603bf1fSSean Wang return err; 791c603bf1fSSean Wang } 792c603bf1fSSean Wang 793c603bf1fSSean Wang static int btsdio_mtk_reg_read(struct hci_dev *hdev, u32 reg, u32 *val) 794c603bf1fSSean Wang { 795c603bf1fSSean Wang struct btmtk_hci_wmt_params wmt_params; 796c603bf1fSSean Wang struct reg_read_cmd { 797c603bf1fSSean Wang u8 type; 798c603bf1fSSean Wang u8 rsv; 799c603bf1fSSean Wang u8 num; 800c603bf1fSSean Wang __le32 addr; 801c603bf1fSSean Wang } __packed reg_read = { 802c603bf1fSSean Wang .type = 1, 803c603bf1fSSean Wang .num = 1, 804c603bf1fSSean Wang }; 805c603bf1fSSean Wang u32 status; 806c603bf1fSSean Wang int err; 807c603bf1fSSean Wang 808c603bf1fSSean Wang reg_read.addr = cpu_to_le32(reg); 809c603bf1fSSean Wang wmt_params.op = BTMTK_WMT_REGISTER; 810c603bf1fSSean Wang wmt_params.flag = BTMTK_WMT_REG_READ; 811c603bf1fSSean Wang wmt_params.dlen = sizeof(reg_read); 812c603bf1fSSean Wang wmt_params.data = ®_read; 813c603bf1fSSean Wang wmt_params.status = &status; 814c603bf1fSSean Wang 815c603bf1fSSean Wang err = mtk_hci_wmt_sync(hdev, &wmt_params); 816c603bf1fSSean Wang if (err < 0) { 817c603bf1fSSean Wang bt_dev_err(hdev, "Failed to read reg(%d)", err); 818c603bf1fSSean Wang return err; 819c603bf1fSSean Wang } 820c603bf1fSSean Wang 821c603bf1fSSean Wang *val = status; 822c603bf1fSSean Wang 823c603bf1fSSean Wang return err; 824c603bf1fSSean Wang } 825c603bf1fSSean Wang 826c603bf1fSSean Wang static int btmtksdio_setup(struct hci_dev *hdev) 827c603bf1fSSean Wang { 828c603bf1fSSean Wang struct btmtksdio_dev *bdev = hci_get_drvdata(hdev); 829c603bf1fSSean Wang ktime_t calltime, delta, rettime; 830c603bf1fSSean Wang unsigned long long duration; 831c603bf1fSSean Wang char fwname[64]; 832c603bf1fSSean Wang int err, dev_id; 833c603bf1fSSean Wang u32 fw_version = 0; 834c603bf1fSSean Wang 835c603bf1fSSean Wang calltime = ktime_get(); 836*d555b1f2SSean Wang set_bit(BTMTKSDIO_HW_TX_READY, &bdev->tx_state); 837c603bf1fSSean Wang 838c603bf1fSSean Wang switch (bdev->data->chipid) { 839c603bf1fSSean Wang case 0x7921: 840c603bf1fSSean Wang err = btsdio_mtk_reg_read(hdev, 0x70010200, &dev_id); 841c603bf1fSSean Wang if (err < 0) { 842c603bf1fSSean Wang bt_dev_err(hdev, "Failed to get device id (%d)", err); 843c603bf1fSSean Wang return err; 844c603bf1fSSean Wang } 845c603bf1fSSean Wang 846c603bf1fSSean Wang err = btsdio_mtk_reg_read(hdev, 0x80021004, &fw_version); 847c603bf1fSSean Wang if (err < 0) { 848c603bf1fSSean Wang bt_dev_err(hdev, "Failed to get fw version (%d)", err); 849c603bf1fSSean Wang return err; 850c603bf1fSSean Wang } 851c603bf1fSSean Wang 852c603bf1fSSean Wang snprintf(fwname, sizeof(fwname), 853c603bf1fSSean Wang "mediatek/BT_RAM_CODE_MT%04x_1_%x_hdr.bin", 854c603bf1fSSean Wang dev_id & 0xffff, (fw_version & 0xff) + 1); 855c603bf1fSSean Wang err = mt79xx_setup(hdev, fwname); 856c603bf1fSSean Wang if (err < 0) 857c603bf1fSSean Wang return err; 858c603bf1fSSean Wang break; 859c603bf1fSSean Wang case 0x7663: 860c603bf1fSSean Wang case 0x7668: 861c603bf1fSSean Wang err = mt76xx_setup(hdev, bdev->data->fwname); 862c603bf1fSSean Wang if (err < 0) 863c603bf1fSSean Wang return err; 864c603bf1fSSean Wang break; 865c603bf1fSSean Wang default: 866c603bf1fSSean Wang return -ENODEV; 867c603bf1fSSean Wang } 868c603bf1fSSean Wang 8699aebfd4aSSean Wang rettime = ktime_get(); 8709aebfd4aSSean Wang delta = ktime_sub(rettime, calltime); 8719aebfd4aSSean Wang duration = (unsigned long long)ktime_to_ns(delta) >> 10; 8729aebfd4aSSean Wang 8737f3c563cSSean Wang pm_runtime_set_autosuspend_delay(bdev->dev, 8747f3c563cSSean Wang MTKBTSDIO_AUTOSUSPEND_DELAY); 8757f3c563cSSean Wang pm_runtime_use_autosuspend(bdev->dev); 8767f3c563cSSean Wang 8777f3c563cSSean Wang err = pm_runtime_set_active(bdev->dev); 8787f3c563cSSean Wang if (err < 0) 8797f3c563cSSean Wang return err; 8807f3c563cSSean Wang 8817f3c563cSSean Wang /* Default forbid runtime auto suspend, that can be allowed by 8827f3c563cSSean Wang * enable_autosuspend flag or the PM runtime entry under sysfs. 8837f3c563cSSean Wang */ 8847f3c563cSSean Wang pm_runtime_forbid(bdev->dev); 8857f3c563cSSean Wang pm_runtime_enable(bdev->dev); 8867f3c563cSSean Wang 8877f3c563cSSean Wang if (enable_autosuspend) 8887f3c563cSSean Wang pm_runtime_allow(bdev->dev); 8897f3c563cSSean Wang 8909aebfd4aSSean Wang bt_dev_info(hdev, "Device setup in %llu usecs", duration); 8919aebfd4aSSean Wang 8929aebfd4aSSean Wang return 0; 8939aebfd4aSSean Wang } 8949aebfd4aSSean Wang 8959aebfd4aSSean Wang static int btmtksdio_shutdown(struct hci_dev *hdev) 8969aebfd4aSSean Wang { 8977f3c563cSSean Wang struct btmtksdio_dev *bdev = hci_get_drvdata(hdev); 8989aebfd4aSSean Wang struct btmtk_hci_wmt_params wmt_params; 8999aebfd4aSSean Wang u8 param = 0x0; 9009aebfd4aSSean Wang int err; 9019aebfd4aSSean Wang 9027f3c563cSSean Wang /* Get back the state to be consistent with the state 9037f3c563cSSean Wang * in btmtksdio_setup. 9047f3c563cSSean Wang */ 9057f3c563cSSean Wang pm_runtime_get_sync(bdev->dev); 9067f3c563cSSean Wang 9079aebfd4aSSean Wang /* Disable the device */ 9083a722044SSean Wang wmt_params.op = BTMTK_WMT_FUNC_CTRL; 9099aebfd4aSSean Wang wmt_params.flag = 0; 9109aebfd4aSSean Wang wmt_params.dlen = sizeof(param); 9119aebfd4aSSean Wang wmt_params.data = ¶m; 9129aebfd4aSSean Wang wmt_params.status = NULL; 9139aebfd4aSSean Wang 9149aebfd4aSSean Wang err = mtk_hci_wmt_sync(hdev, &wmt_params); 9159aebfd4aSSean Wang if (err < 0) { 9169aebfd4aSSean Wang bt_dev_err(hdev, "Failed to send wmt func ctrl (%d)", err); 9179aebfd4aSSean Wang return err; 9189aebfd4aSSean Wang } 9199aebfd4aSSean Wang 9207f3c563cSSean Wang pm_runtime_put_noidle(bdev->dev); 9217f3c563cSSean Wang pm_runtime_disable(bdev->dev); 9227f3c563cSSean Wang 9239aebfd4aSSean Wang return 0; 9249aebfd4aSSean Wang } 9259aebfd4aSSean Wang 9269aebfd4aSSean Wang static int btmtksdio_send_frame(struct hci_dev *hdev, struct sk_buff *skb) 9279aebfd4aSSean Wang { 9289aebfd4aSSean Wang struct btmtksdio_dev *bdev = hci_get_drvdata(hdev); 9299aebfd4aSSean Wang 9309aebfd4aSSean Wang switch (hci_skb_pkt_type(skb)) { 9319aebfd4aSSean Wang case HCI_COMMAND_PKT: 9329aebfd4aSSean Wang hdev->stat.cmd_tx++; 9339aebfd4aSSean Wang break; 9349aebfd4aSSean Wang 9359aebfd4aSSean Wang case HCI_ACLDATA_PKT: 9369aebfd4aSSean Wang hdev->stat.acl_tx++; 9379aebfd4aSSean Wang break; 9389aebfd4aSSean Wang 9399aebfd4aSSean Wang case HCI_SCODATA_PKT: 9409aebfd4aSSean Wang hdev->stat.sco_tx++; 9419aebfd4aSSean Wang break; 9429aebfd4aSSean Wang 9439aebfd4aSSean Wang default: 9449aebfd4aSSean Wang return -EILSEQ; 9459aebfd4aSSean Wang } 9469aebfd4aSSean Wang 9479aebfd4aSSean Wang skb_queue_tail(&bdev->txq, skb); 9489aebfd4aSSean Wang 94926270bc1SSean Wang schedule_work(&bdev->txrx_work); 9509aebfd4aSSean Wang 9519aebfd4aSSean Wang return 0; 9529aebfd4aSSean Wang } 9539aebfd4aSSean Wang 9549aebfd4aSSean Wang static int btmtksdio_probe(struct sdio_func *func, 9559aebfd4aSSean Wang const struct sdio_device_id *id) 9569aebfd4aSSean Wang { 9579aebfd4aSSean Wang struct btmtksdio_dev *bdev; 9589aebfd4aSSean Wang struct hci_dev *hdev; 9599aebfd4aSSean Wang int err; 9609aebfd4aSSean Wang 9619aebfd4aSSean Wang bdev = devm_kzalloc(&func->dev, sizeof(*bdev), GFP_KERNEL); 9629aebfd4aSSean Wang if (!bdev) 9639aebfd4aSSean Wang return -ENOMEM; 9649aebfd4aSSean Wang 9659aebfd4aSSean Wang bdev->data = (void *)id->driver_data; 9669aebfd4aSSean Wang if (!bdev->data) 9679aebfd4aSSean Wang return -ENODEV; 9689aebfd4aSSean Wang 9697f3c563cSSean Wang bdev->dev = &func->dev; 9709aebfd4aSSean Wang bdev->func = func; 9719aebfd4aSSean Wang 97226270bc1SSean Wang INIT_WORK(&bdev->txrx_work, btmtksdio_txrx_work); 9739aebfd4aSSean Wang skb_queue_head_init(&bdev->txq); 9749aebfd4aSSean Wang 9759aebfd4aSSean Wang /* Initialize and register HCI device */ 9769aebfd4aSSean Wang hdev = hci_alloc_dev(); 9779aebfd4aSSean Wang if (!hdev) { 9789aebfd4aSSean Wang dev_err(&func->dev, "Can't allocate HCI device\n"); 9799aebfd4aSSean Wang return -ENOMEM; 9809aebfd4aSSean Wang } 9819aebfd4aSSean Wang 9829aebfd4aSSean Wang bdev->hdev = hdev; 9839aebfd4aSSean Wang 9849aebfd4aSSean Wang hdev->bus = HCI_SDIO; 9859aebfd4aSSean Wang hci_set_drvdata(hdev, bdev); 9869aebfd4aSSean Wang 9879aebfd4aSSean Wang hdev->open = btmtksdio_open; 9889aebfd4aSSean Wang hdev->close = btmtksdio_close; 9899aebfd4aSSean Wang hdev->flush = btmtksdio_flush; 9909aebfd4aSSean Wang hdev->setup = btmtksdio_setup; 9919aebfd4aSSean Wang hdev->shutdown = btmtksdio_shutdown; 9929aebfd4aSSean Wang hdev->send = btmtksdio_send_frame; 993877ec9e1SSean Wang hdev->set_bdaddr = btmtk_set_bdaddr; 994877ec9e1SSean Wang 9959aebfd4aSSean Wang SET_HCIDEV_DEV(hdev, &func->dev); 9969aebfd4aSSean Wang 9979aebfd4aSSean Wang hdev->manufacturer = 70; 9989aebfd4aSSean Wang set_bit(HCI_QUIRK_NON_PERSISTENT_SETUP, &hdev->quirks); 9999aebfd4aSSean Wang 10009aebfd4aSSean Wang err = hci_register_dev(hdev); 10019aebfd4aSSean Wang if (err < 0) { 10029aebfd4aSSean Wang dev_err(&func->dev, "Can't register HCI device\n"); 10039aebfd4aSSean Wang hci_free_dev(hdev); 10049aebfd4aSSean Wang return err; 10059aebfd4aSSean Wang } 10069aebfd4aSSean Wang 10079aebfd4aSSean Wang sdio_set_drvdata(func, bdev); 10089aebfd4aSSean Wang 10097f3c563cSSean Wang /* pm_runtime_enable would be done after the firmware is being 10107f3c563cSSean Wang * downloaded because the core layer probably already enables 10117f3c563cSSean Wang * runtime PM for this func such as the case host->caps & 10127f3c563cSSean Wang * MMC_CAP_POWER_OFF_CARD. 10137f3c563cSSean Wang */ 10147f3c563cSSean Wang if (pm_runtime_enabled(bdev->dev)) 10157f3c563cSSean Wang pm_runtime_disable(bdev->dev); 10167f3c563cSSean Wang 10177f3c563cSSean Wang /* As explaination in drivers/mmc/core/sdio_bus.c tells us: 10187f3c563cSSean Wang * Unbound SDIO functions are always suspended. 10197f3c563cSSean Wang * During probe, the function is set active and the usage count 10207f3c563cSSean Wang * is incremented. If the driver supports runtime PM, 10217f3c563cSSean Wang * it should call pm_runtime_put_noidle() in its probe routine and 10227f3c563cSSean Wang * pm_runtime_get_noresume() in its remove routine. 10237f3c563cSSean Wang * 10247f3c563cSSean Wang * So, put a pm_runtime_put_noidle here ! 10257f3c563cSSean Wang */ 10267f3c563cSSean Wang pm_runtime_put_noidle(bdev->dev); 10277f3c563cSSean Wang 10289aebfd4aSSean Wang return 0; 10299aebfd4aSSean Wang } 10309aebfd4aSSean Wang 10319aebfd4aSSean Wang static void btmtksdio_remove(struct sdio_func *func) 10329aebfd4aSSean Wang { 10339aebfd4aSSean Wang struct btmtksdio_dev *bdev = sdio_get_drvdata(func); 10349aebfd4aSSean Wang struct hci_dev *hdev; 10359aebfd4aSSean Wang 10369aebfd4aSSean Wang if (!bdev) 10379aebfd4aSSean Wang return; 10389aebfd4aSSean Wang 10397f3c563cSSean Wang /* Be consistent the state in btmtksdio_probe */ 10407f3c563cSSean Wang pm_runtime_get_noresume(bdev->dev); 10417f3c563cSSean Wang 10429aebfd4aSSean Wang hdev = bdev->hdev; 10439aebfd4aSSean Wang 10449aebfd4aSSean Wang sdio_set_drvdata(func, NULL); 10459aebfd4aSSean Wang hci_unregister_dev(hdev); 10469aebfd4aSSean Wang hci_free_dev(hdev); 10479aebfd4aSSean Wang } 10489aebfd4aSSean Wang 10497f3c563cSSean Wang #ifdef CONFIG_PM 10507f3c563cSSean Wang static int btmtksdio_runtime_suspend(struct device *dev) 10517f3c563cSSean Wang { 10527f3c563cSSean Wang struct sdio_func *func = dev_to_sdio_func(dev); 10537f3c563cSSean Wang struct btmtksdio_dev *bdev; 10547f3c563cSSean Wang u32 status; 10557f3c563cSSean Wang int err; 10567f3c563cSSean Wang 10577f3c563cSSean Wang bdev = sdio_get_drvdata(func); 10587f3c563cSSean Wang if (!bdev) 10597f3c563cSSean Wang return 0; 10607f3c563cSSean Wang 10617f3c563cSSean Wang sdio_claim_host(bdev->func); 10627f3c563cSSean Wang 10637f3c563cSSean Wang sdio_writel(bdev->func, C_FW_OWN_REQ_SET, MTK_REG_CHLPCR, &err); 10647f3c563cSSean Wang if (err < 0) 10657f3c563cSSean Wang goto out; 10667f3c563cSSean Wang 10677f3c563cSSean Wang err = readx_poll_timeout(btmtksdio_drv_own_query, bdev, status, 10687f3c563cSSean Wang !(status & C_COM_DRV_OWN), 2000, 1000000); 10697f3c563cSSean Wang out: 10707f3c563cSSean Wang bt_dev_info(bdev->hdev, "status (%d) return ownership to device", err); 10717f3c563cSSean Wang 10727f3c563cSSean Wang sdio_release_host(bdev->func); 10737f3c563cSSean Wang 10747f3c563cSSean Wang return err; 10757f3c563cSSean Wang } 10767f3c563cSSean Wang 10777f3c563cSSean Wang static int btmtksdio_runtime_resume(struct device *dev) 10787f3c563cSSean Wang { 10797f3c563cSSean Wang struct sdio_func *func = dev_to_sdio_func(dev); 10807f3c563cSSean Wang struct btmtksdio_dev *bdev; 10817f3c563cSSean Wang u32 status; 10827f3c563cSSean Wang int err; 10837f3c563cSSean Wang 10847f3c563cSSean Wang bdev = sdio_get_drvdata(func); 10857f3c563cSSean Wang if (!bdev) 10867f3c563cSSean Wang return 0; 10877f3c563cSSean Wang 10887f3c563cSSean Wang sdio_claim_host(bdev->func); 10897f3c563cSSean Wang 10907f3c563cSSean Wang sdio_writel(bdev->func, C_FW_OWN_REQ_CLR, MTK_REG_CHLPCR, &err); 10917f3c563cSSean Wang if (err < 0) 10927f3c563cSSean Wang goto out; 10937f3c563cSSean Wang 10947f3c563cSSean Wang err = readx_poll_timeout(btmtksdio_drv_own_query, bdev, status, 10957f3c563cSSean Wang status & C_COM_DRV_OWN, 2000, 1000000); 10967f3c563cSSean Wang out: 10977f3c563cSSean Wang bt_dev_info(bdev->hdev, "status (%d) get ownership from device", err); 10987f3c563cSSean Wang 10997f3c563cSSean Wang sdio_release_host(bdev->func); 11007f3c563cSSean Wang 11017f3c563cSSean Wang return err; 11027f3c563cSSean Wang } 11037f3c563cSSean Wang 11047f3c563cSSean Wang static UNIVERSAL_DEV_PM_OPS(btmtksdio_pm_ops, btmtksdio_runtime_suspend, 11057f3c563cSSean Wang btmtksdio_runtime_resume, NULL); 11067f3c563cSSean Wang #define BTMTKSDIO_PM_OPS (&btmtksdio_pm_ops) 11077f3c563cSSean Wang #else /* CONFIG_PM */ 11087f3c563cSSean Wang #define BTMTKSDIO_PM_OPS NULL 11097f3c563cSSean Wang #endif /* CONFIG_PM */ 11107f3c563cSSean Wang 11119aebfd4aSSean Wang static struct sdio_driver btmtksdio_driver = { 11129aebfd4aSSean Wang .name = "btmtksdio", 11139aebfd4aSSean Wang .probe = btmtksdio_probe, 11149aebfd4aSSean Wang .remove = btmtksdio_remove, 11159aebfd4aSSean Wang .id_table = btmtksdio_table, 11167f3c563cSSean Wang .drv = { 11177f3c563cSSean Wang .owner = THIS_MODULE, 11187f3c563cSSean Wang .pm = BTMTKSDIO_PM_OPS, 11197f3c563cSSean Wang } 11209aebfd4aSSean Wang }; 11219aebfd4aSSean Wang 1122a6094a46SSean Wang module_sdio_driver(btmtksdio_driver); 11239aebfd4aSSean Wang 11247f3c563cSSean Wang module_param(enable_autosuspend, bool, 0644); 11257f3c563cSSean Wang MODULE_PARM_DESC(enable_autosuspend, "Enable autosuspend by default"); 11267f3c563cSSean Wang 11279aebfd4aSSean Wang MODULE_AUTHOR("Sean Wang <sean.wang@mediatek.com>"); 11289aebfd4aSSean Wang MODULE_DESCRIPTION("MediaTek Bluetooth SDIO driver ver " VERSION); 11299aebfd4aSSean Wang MODULE_VERSION(VERSION); 11309aebfd4aSSean Wang MODULE_LICENSE("GPL"); 1131