Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 // Copyright (c) 2019 MediaTek Inc.
0003 
0004 /*
0005  * Bluetooth support for MediaTek SDIO devices
0006  *
0007  * This file is written based on btsdio.c and btmtkuart.c.
0008  *
0009  * Author: Sean Wang <sean.wang@mediatek.com>
0010  *
0011  */
0012 
0013 #include <asm/unaligned.h>
0014 #include <linux/atomic.h>
0015 #include <linux/gpio/consumer.h>
0016 #include <linux/init.h>
0017 #include <linux/iopoll.h>
0018 #include <linux/kernel.h>
0019 #include <linux/module.h>
0020 #include <linux/of.h>
0021 #include <linux/pm_runtime.h>
0022 #include <linux/skbuff.h>
0023 
0024 #include <linux/mmc/host.h>
0025 #include <linux/mmc/sdio_ids.h>
0026 #include <linux/mmc/sdio_func.h>
0027 
0028 #include <net/bluetooth/bluetooth.h>
0029 #include <net/bluetooth/hci_core.h>
0030 
0031 #include "h4_recv.h"
0032 #include "btmtk.h"
0033 
0034 #define VERSION "0.1"
0035 
0036 #define MTKBTSDIO_AUTOSUSPEND_DELAY 1000
0037 
0038 static bool enable_autosuspend = true;
0039 
0040 struct btmtksdio_data {
0041     const char *fwname;
0042     u16 chipid;
0043     bool lp_mbox_supported;
0044 };
0045 
0046 static const struct btmtksdio_data mt7663_data = {
0047     .fwname = FIRMWARE_MT7663,
0048     .chipid = 0x7663,
0049     .lp_mbox_supported = false,
0050 };
0051 
0052 static const struct btmtksdio_data mt7668_data = {
0053     .fwname = FIRMWARE_MT7668,
0054     .chipid = 0x7668,
0055     .lp_mbox_supported = false,
0056 };
0057 
0058 static const struct btmtksdio_data mt7921_data = {
0059     .fwname = FIRMWARE_MT7961,
0060     .chipid = 0x7921,
0061     .lp_mbox_supported = true,
0062 };
0063 
0064 static const struct sdio_device_id btmtksdio_table[] = {
0065     {SDIO_DEVICE(SDIO_VENDOR_ID_MEDIATEK, SDIO_DEVICE_ID_MEDIATEK_MT7663),
0066      .driver_data = (kernel_ulong_t)&mt7663_data },
0067     {SDIO_DEVICE(SDIO_VENDOR_ID_MEDIATEK, SDIO_DEVICE_ID_MEDIATEK_MT7668),
0068      .driver_data = (kernel_ulong_t)&mt7668_data },
0069     {SDIO_DEVICE(SDIO_VENDOR_ID_MEDIATEK, SDIO_DEVICE_ID_MEDIATEK_MT7961),
0070      .driver_data = (kernel_ulong_t)&mt7921_data },
0071     { } /* Terminating entry */
0072 };
0073 MODULE_DEVICE_TABLE(sdio, btmtksdio_table);
0074 
0075 #define MTK_REG_CHLPCR      0x4 /* W1S */
0076 #define C_INT_EN_SET        BIT(0)
0077 #define C_INT_EN_CLR        BIT(1)
0078 #define C_FW_OWN_REQ_SET    BIT(8)  /* For write */
0079 #define C_COM_DRV_OWN       BIT(8)  /* For read */
0080 #define C_FW_OWN_REQ_CLR    BIT(9)
0081 
0082 #define MTK_REG_CSDIOCSR    0x8
0083 #define SDIO_RE_INIT_EN     BIT(0)
0084 #define SDIO_INT_CTL        BIT(2)
0085 
0086 #define MTK_REG_CHCR        0xc
0087 #define C_INT_CLR_CTRL      BIT(1)
0088 #define BT_RST_DONE     BIT(8)
0089 
0090 /* CHISR have the same bits field definition with CHIER */
0091 #define MTK_REG_CHISR       0x10
0092 #define MTK_REG_CHIER       0x14
0093 #define FW_OWN_BACK_INT     BIT(0)
0094 #define RX_DONE_INT     BIT(1)
0095 #define TX_EMPTY        BIT(2)
0096 #define TX_FIFO_OVERFLOW    BIT(8)
0097 #define FW_MAILBOX_INT      BIT(15)
0098 #define INT_MASK        GENMASK(15, 0)
0099 #define RX_PKT_LEN      GENMASK(31, 16)
0100 
0101 #define MTK_REG_CSICR       0xc0
0102 #define CSICR_CLR_MBOX_ACK BIT(0)
0103 #define MTK_REG_PH2DSM0R    0xc4
0104 #define PH2DSM0R_DRIVER_OWN BIT(0)
0105 #define MTK_REG_PD2HRM0R    0xdc
0106 #define PD2HRM0R_DRV_OWN    BIT(0)
0107 
0108 #define MTK_REG_CTDR        0x18
0109 
0110 #define MTK_REG_CRDR        0x1c
0111 
0112 #define MTK_REG_CRPLR       0x24
0113 
0114 #define MTK_SDIO_BLOCK_SIZE 256
0115 
0116 #define BTMTKSDIO_TX_WAIT_VND_EVT   1
0117 #define BTMTKSDIO_HW_TX_READY       2
0118 #define BTMTKSDIO_FUNC_ENABLED      3
0119 #define BTMTKSDIO_PATCH_ENABLED     4
0120 #define BTMTKSDIO_HW_RESET_ACTIVE   5
0121 
0122 struct mtkbtsdio_hdr {
0123     __le16  len;
0124     __le16  reserved;
0125     u8  bt_type;
0126 } __packed;
0127 
0128 struct btmtksdio_dev {
0129     struct hci_dev *hdev;
0130     struct sdio_func *func;
0131     struct device *dev;
0132 
0133     struct work_struct txrx_work;
0134     unsigned long tx_state;
0135     struct sk_buff_head txq;
0136 
0137     struct sk_buff *evt_skb;
0138 
0139     const struct btmtksdio_data *data;
0140 
0141     struct gpio_desc *reset;
0142 };
0143 
0144 static int mtk_hci_wmt_sync(struct hci_dev *hdev,
0145                 struct btmtk_hci_wmt_params *wmt_params)
0146 {
0147     struct btmtksdio_dev *bdev = hci_get_drvdata(hdev);
0148     struct btmtk_hci_wmt_evt_funcc *wmt_evt_funcc;
0149     struct btmtk_hci_wmt_evt_reg *wmt_evt_reg;
0150     u32 hlen, status = BTMTK_WMT_INVALID;
0151     struct btmtk_hci_wmt_evt *wmt_evt;
0152     struct btmtk_hci_wmt_cmd *wc;
0153     struct btmtk_wmt_hdr *hdr;
0154     int err;
0155 
0156     /* Send the WMT command and wait until the WMT event returns */
0157     hlen = sizeof(*hdr) + wmt_params->dlen;
0158     if (hlen > 255)
0159         return -EINVAL;
0160 
0161     wc = kzalloc(hlen, GFP_KERNEL);
0162     if (!wc)
0163         return -ENOMEM;
0164 
0165     hdr = &wc->hdr;
0166     hdr->dir = 1;
0167     hdr->op = wmt_params->op;
0168     hdr->dlen = cpu_to_le16(wmt_params->dlen + 1);
0169     hdr->flag = wmt_params->flag;
0170     memcpy(wc->data, wmt_params->data, wmt_params->dlen);
0171 
0172     set_bit(BTMTKSDIO_TX_WAIT_VND_EVT, &bdev->tx_state);
0173 
0174     err = __hci_cmd_send(hdev, 0xfc6f, hlen, wc);
0175     if (err < 0) {
0176         clear_bit(BTMTKSDIO_TX_WAIT_VND_EVT, &bdev->tx_state);
0177         goto err_free_wc;
0178     }
0179 
0180     /* The vendor specific WMT commands are all answered by a vendor
0181      * specific event and will not have the Command Status or Command
0182      * Complete as with usual HCI command flow control.
0183      *
0184      * After sending the command, wait for BTMTKSDIO_TX_WAIT_VND_EVT
0185      * state to be cleared. The driver specific event receive routine
0186      * will clear that state and with that indicate completion of the
0187      * WMT command.
0188      */
0189     err = wait_on_bit_timeout(&bdev->tx_state, BTMTKSDIO_TX_WAIT_VND_EVT,
0190                   TASK_INTERRUPTIBLE, HCI_INIT_TIMEOUT);
0191     if (err == -EINTR) {
0192         bt_dev_err(hdev, "Execution of wmt command interrupted");
0193         clear_bit(BTMTKSDIO_TX_WAIT_VND_EVT, &bdev->tx_state);
0194         goto err_free_wc;
0195     }
0196 
0197     if (err) {
0198         bt_dev_err(hdev, "Execution of wmt command timed out");
0199         clear_bit(BTMTKSDIO_TX_WAIT_VND_EVT, &bdev->tx_state);
0200         err = -ETIMEDOUT;
0201         goto err_free_wc;
0202     }
0203 
0204     /* Parse and handle the return WMT event */
0205     wmt_evt = (struct btmtk_hci_wmt_evt *)bdev->evt_skb->data;
0206     if (wmt_evt->whdr.op != hdr->op) {
0207         bt_dev_err(hdev, "Wrong op received %d expected %d",
0208                wmt_evt->whdr.op, hdr->op);
0209         err = -EIO;
0210         goto err_free_skb;
0211     }
0212 
0213     switch (wmt_evt->whdr.op) {
0214     case BTMTK_WMT_SEMAPHORE:
0215         if (wmt_evt->whdr.flag == 2)
0216             status = BTMTK_WMT_PATCH_UNDONE;
0217         else
0218             status = BTMTK_WMT_PATCH_DONE;
0219         break;
0220     case BTMTK_WMT_FUNC_CTRL:
0221         wmt_evt_funcc = (struct btmtk_hci_wmt_evt_funcc *)wmt_evt;
0222         if (be16_to_cpu(wmt_evt_funcc->status) == 0x404)
0223             status = BTMTK_WMT_ON_DONE;
0224         else if (be16_to_cpu(wmt_evt_funcc->status) == 0x420)
0225             status = BTMTK_WMT_ON_PROGRESS;
0226         else
0227             status = BTMTK_WMT_ON_UNDONE;
0228         break;
0229     case BTMTK_WMT_PATCH_DWNLD:
0230         if (wmt_evt->whdr.flag == 2)
0231             status = BTMTK_WMT_PATCH_DONE;
0232         else if (wmt_evt->whdr.flag == 1)
0233             status = BTMTK_WMT_PATCH_PROGRESS;
0234         else
0235             status = BTMTK_WMT_PATCH_UNDONE;
0236         break;
0237     case BTMTK_WMT_REGISTER:
0238         wmt_evt_reg = (struct btmtk_hci_wmt_evt_reg *)wmt_evt;
0239         if (le16_to_cpu(wmt_evt->whdr.dlen) == 12)
0240             status = le32_to_cpu(wmt_evt_reg->val);
0241         break;
0242     }
0243 
0244     if (wmt_params->status)
0245         *wmt_params->status = status;
0246 
0247 err_free_skb:
0248     kfree_skb(bdev->evt_skb);
0249     bdev->evt_skb = NULL;
0250 err_free_wc:
0251     kfree(wc);
0252 
0253     return err;
0254 }
0255 
0256 static int btmtksdio_tx_packet(struct btmtksdio_dev *bdev,
0257                    struct sk_buff *skb)
0258 {
0259     struct mtkbtsdio_hdr *sdio_hdr;
0260     int err;
0261 
0262     /* Make sure that there are enough rooms for SDIO header */
0263     if (unlikely(skb_headroom(skb) < sizeof(*sdio_hdr))) {
0264         err = pskb_expand_head(skb, sizeof(*sdio_hdr), 0,
0265                        GFP_ATOMIC);
0266         if (err < 0)
0267             return err;
0268     }
0269 
0270     /* Prepend MediaTek SDIO Specific Header */
0271     skb_push(skb, sizeof(*sdio_hdr));
0272 
0273     sdio_hdr = (void *)skb->data;
0274     sdio_hdr->len = cpu_to_le16(skb->len);
0275     sdio_hdr->reserved = cpu_to_le16(0);
0276     sdio_hdr->bt_type = hci_skb_pkt_type(skb);
0277 
0278     clear_bit(BTMTKSDIO_HW_TX_READY, &bdev->tx_state);
0279     err = sdio_writesb(bdev->func, MTK_REG_CTDR, skb->data,
0280                round_up(skb->len, MTK_SDIO_BLOCK_SIZE));
0281     if (err < 0)
0282         goto err_skb_pull;
0283 
0284     bdev->hdev->stat.byte_tx += skb->len;
0285 
0286     kfree_skb(skb);
0287 
0288     return 0;
0289 
0290 err_skb_pull:
0291     skb_pull(skb, sizeof(*sdio_hdr));
0292 
0293     return err;
0294 }
0295 
0296 static u32 btmtksdio_drv_own_query(struct btmtksdio_dev *bdev)
0297 {
0298     return sdio_readl(bdev->func, MTK_REG_CHLPCR, NULL);
0299 }
0300 
0301 static u32 btmtksdio_drv_own_query_79xx(struct btmtksdio_dev *bdev)
0302 {
0303     return sdio_readl(bdev->func, MTK_REG_PD2HRM0R, NULL);
0304 }
0305 
0306 static u32 btmtksdio_chcr_query(struct btmtksdio_dev *bdev)
0307 {
0308     return sdio_readl(bdev->func, MTK_REG_CHCR, NULL);
0309 }
0310 
0311 static int btmtksdio_fw_pmctrl(struct btmtksdio_dev *bdev)
0312 {
0313     u32 status;
0314     int err;
0315 
0316     sdio_claim_host(bdev->func);
0317 
0318     if (bdev->data->lp_mbox_supported &&
0319         test_bit(BTMTKSDIO_PATCH_ENABLED, &bdev->tx_state)) {
0320         sdio_writel(bdev->func, CSICR_CLR_MBOX_ACK, MTK_REG_CSICR,
0321                 &err);
0322         err = readx_poll_timeout(btmtksdio_drv_own_query_79xx, bdev,
0323                      status, !(status & PD2HRM0R_DRV_OWN),
0324                      2000, 1000000);
0325         if (err < 0) {
0326             bt_dev_err(bdev->hdev, "mailbox ACK not cleared");
0327             goto out;
0328         }
0329     }
0330 
0331     /* Return ownership to the device */
0332     sdio_writel(bdev->func, C_FW_OWN_REQ_SET, MTK_REG_CHLPCR, &err);
0333     if (err < 0)
0334         goto out;
0335 
0336     err = readx_poll_timeout(btmtksdio_drv_own_query, bdev, status,
0337                  !(status & C_COM_DRV_OWN), 2000, 1000000);
0338 
0339 out:
0340     sdio_release_host(bdev->func);
0341 
0342     if (err < 0)
0343         bt_dev_err(bdev->hdev, "Cannot return ownership to device");
0344 
0345     return err;
0346 }
0347 
0348 static int btmtksdio_drv_pmctrl(struct btmtksdio_dev *bdev)
0349 {
0350     u32 status;
0351     int err;
0352 
0353     sdio_claim_host(bdev->func);
0354 
0355     /* Get ownership from the device */
0356     sdio_writel(bdev->func, C_FW_OWN_REQ_CLR, MTK_REG_CHLPCR, &err);
0357     if (err < 0)
0358         goto out;
0359 
0360     err = readx_poll_timeout(btmtksdio_drv_own_query, bdev, status,
0361                  status & C_COM_DRV_OWN, 2000, 1000000);
0362 
0363     if (!err && bdev->data->lp_mbox_supported &&
0364         test_bit(BTMTKSDIO_PATCH_ENABLED, &bdev->tx_state))
0365         err = readx_poll_timeout(btmtksdio_drv_own_query_79xx, bdev,
0366                      status, status & PD2HRM0R_DRV_OWN,
0367                      2000, 1000000);
0368 
0369 out:
0370     sdio_release_host(bdev->func);
0371 
0372     if (err < 0)
0373         bt_dev_err(bdev->hdev, "Cannot get ownership from device");
0374 
0375     return err;
0376 }
0377 
0378 static int btmtksdio_recv_event(struct hci_dev *hdev, struct sk_buff *skb)
0379 {
0380     struct btmtksdio_dev *bdev = hci_get_drvdata(hdev);
0381     struct hci_event_hdr *hdr = (void *)skb->data;
0382     u8 evt = hdr->evt;
0383     int err;
0384 
0385     /* When someone waits for the WMT event, the skb is being cloned
0386      * and being processed the events from there then.
0387      */
0388     if (test_bit(BTMTKSDIO_TX_WAIT_VND_EVT, &bdev->tx_state)) {
0389         bdev->evt_skb = skb_clone(skb, GFP_KERNEL);
0390         if (!bdev->evt_skb) {
0391             err = -ENOMEM;
0392             goto err_out;
0393         }
0394     }
0395 
0396     err = hci_recv_frame(hdev, skb);
0397     if (err < 0)
0398         goto err_free_skb;
0399 
0400     if (evt == HCI_EV_WMT) {
0401         if (test_and_clear_bit(BTMTKSDIO_TX_WAIT_VND_EVT,
0402                        &bdev->tx_state)) {
0403             /* Barrier to sync with other CPUs */
0404             smp_mb__after_atomic();
0405             wake_up_bit(&bdev->tx_state, BTMTKSDIO_TX_WAIT_VND_EVT);
0406         }
0407     }
0408 
0409     return 0;
0410 
0411 err_free_skb:
0412     kfree_skb(bdev->evt_skb);
0413     bdev->evt_skb = NULL;
0414 
0415 err_out:
0416     return err;
0417 }
0418 
0419 static int btmtksdio_recv_acl(struct hci_dev *hdev, struct sk_buff *skb)
0420 {
0421     struct btmtksdio_dev *bdev = hci_get_drvdata(hdev);
0422     u16 handle = le16_to_cpu(hci_acl_hdr(skb)->handle);
0423 
0424     switch (handle) {
0425     case 0xfc6f:
0426         /* Firmware dump from device: when the firmware hangs, the
0427          * device can no longer suspend and thus disable auto-suspend.
0428          */
0429         pm_runtime_forbid(bdev->dev);
0430         fallthrough;
0431     case 0x05ff:
0432     case 0x05fe:
0433         /* Firmware debug logging */
0434         return hci_recv_diag(hdev, skb);
0435     }
0436 
0437     return hci_recv_frame(hdev, skb);
0438 }
0439 
0440 static const struct h4_recv_pkt mtk_recv_pkts[] = {
0441     { H4_RECV_ACL,      .recv = btmtksdio_recv_acl },
0442     { H4_RECV_SCO,      .recv = hci_recv_frame },
0443     { H4_RECV_EVENT,    .recv = btmtksdio_recv_event },
0444 };
0445 
0446 static int btmtksdio_rx_packet(struct btmtksdio_dev *bdev, u16 rx_size)
0447 {
0448     const struct h4_recv_pkt *pkts = mtk_recv_pkts;
0449     int pkts_count = ARRAY_SIZE(mtk_recv_pkts);
0450     struct mtkbtsdio_hdr *sdio_hdr;
0451     int err, i, pad_size;
0452     struct sk_buff *skb;
0453     u16 dlen;
0454 
0455     if (rx_size < sizeof(*sdio_hdr))
0456         return -EILSEQ;
0457 
0458     /* A SDIO packet is exactly containing a Bluetooth packet */
0459     skb = bt_skb_alloc(rx_size, GFP_KERNEL);
0460     if (!skb)
0461         return -ENOMEM;
0462 
0463     skb_put(skb, rx_size);
0464 
0465     err = sdio_readsb(bdev->func, skb->data, MTK_REG_CRDR, rx_size);
0466     if (err < 0)
0467         goto err_kfree_skb;
0468 
0469     sdio_hdr = (void *)skb->data;
0470 
0471     /* We assume the default error as -EILSEQ simply to make the error path
0472      * be cleaner.
0473      */
0474     err = -EILSEQ;
0475 
0476     if (rx_size != le16_to_cpu(sdio_hdr->len)) {
0477         bt_dev_err(bdev->hdev, "Rx size in sdio header is mismatched ");
0478         goto err_kfree_skb;
0479     }
0480 
0481     hci_skb_pkt_type(skb) = sdio_hdr->bt_type;
0482 
0483     /* Remove MediaTek SDIO header */
0484     skb_pull(skb, sizeof(*sdio_hdr));
0485 
0486     /* We have to dig into the packet to get payload size and then know how
0487      * many padding bytes at the tail, these padding bytes should be removed
0488      * before the packet is indicated to the core layer.
0489      */
0490     for (i = 0; i < pkts_count; i++) {
0491         if (sdio_hdr->bt_type == (&pkts[i])->type)
0492             break;
0493     }
0494 
0495     if (i >= pkts_count) {
0496         bt_dev_err(bdev->hdev, "Invalid bt type 0x%02x",
0497                sdio_hdr->bt_type);
0498         goto err_kfree_skb;
0499     }
0500 
0501     /* Remaining bytes cannot hold a header*/
0502     if (skb->len < (&pkts[i])->hlen) {
0503         bt_dev_err(bdev->hdev, "The size of bt header is mismatched");
0504         goto err_kfree_skb;
0505     }
0506 
0507     switch ((&pkts[i])->lsize) {
0508     case 1:
0509         dlen = skb->data[(&pkts[i])->loff];
0510         break;
0511     case 2:
0512         dlen = get_unaligned_le16(skb->data +
0513                           (&pkts[i])->loff);
0514         break;
0515     default:
0516         goto err_kfree_skb;
0517     }
0518 
0519     pad_size = skb->len - (&pkts[i])->hlen -  dlen;
0520 
0521     /* Remaining bytes cannot hold a payload */
0522     if (pad_size < 0) {
0523         bt_dev_err(bdev->hdev, "The size of bt payload is mismatched");
0524         goto err_kfree_skb;
0525     }
0526 
0527     /* Remove padding bytes */
0528     skb_trim(skb, skb->len - pad_size);
0529 
0530     /* Complete frame */
0531     (&pkts[i])->recv(bdev->hdev, skb);
0532 
0533     bdev->hdev->stat.byte_rx += rx_size;
0534 
0535     return 0;
0536 
0537 err_kfree_skb:
0538     kfree_skb(skb);
0539 
0540     return err;
0541 }
0542 
0543 static void btmtksdio_txrx_work(struct work_struct *work)
0544 {
0545     struct btmtksdio_dev *bdev = container_of(work, struct btmtksdio_dev,
0546                           txrx_work);
0547     unsigned long txrx_timeout;
0548     u32 int_status, rx_size;
0549     struct sk_buff *skb;
0550     int err;
0551 
0552     pm_runtime_get_sync(bdev->dev);
0553 
0554     sdio_claim_host(bdev->func);
0555 
0556     /* Disable interrupt */
0557     sdio_writel(bdev->func, C_INT_EN_CLR, MTK_REG_CHLPCR, 0);
0558 
0559     txrx_timeout = jiffies + 5 * HZ;
0560 
0561     do {
0562         int_status = sdio_readl(bdev->func, MTK_REG_CHISR, NULL);
0563 
0564         /* Ack an interrupt as soon as possible before any operation on
0565          * hardware.
0566          *
0567          * Note that we don't ack any status during operations to avoid race
0568          * condition between the host and the device such as it's possible to
0569          * mistakenly ack RX_DONE for the next packet and then cause interrupts
0570          * not be raised again but there is still pending data in the hardware
0571          * FIFO.
0572          */
0573         sdio_writel(bdev->func, int_status, MTK_REG_CHISR, NULL);
0574         int_status &= INT_MASK;
0575 
0576         if ((int_status & FW_MAILBOX_INT) &&
0577             bdev->data->chipid == 0x7921) {
0578             sdio_writel(bdev->func, PH2DSM0R_DRIVER_OWN,
0579                     MTK_REG_PH2DSM0R, 0);
0580         }
0581 
0582         if (int_status & FW_OWN_BACK_INT)
0583             bt_dev_dbg(bdev->hdev, "Get fw own back");
0584 
0585         if (int_status & TX_EMPTY)
0586             set_bit(BTMTKSDIO_HW_TX_READY, &bdev->tx_state);
0587 
0588         else if (unlikely(int_status & TX_FIFO_OVERFLOW))
0589             bt_dev_warn(bdev->hdev, "Tx fifo overflow");
0590 
0591         if (test_bit(BTMTKSDIO_HW_TX_READY, &bdev->tx_state)) {
0592             skb = skb_dequeue(&bdev->txq);
0593             if (skb) {
0594                 err = btmtksdio_tx_packet(bdev, skb);
0595                 if (err < 0) {
0596                     bdev->hdev->stat.err_tx++;
0597                     skb_queue_head(&bdev->txq, skb);
0598                 }
0599             }
0600         }
0601 
0602         if (int_status & RX_DONE_INT) {
0603             rx_size = sdio_readl(bdev->func, MTK_REG_CRPLR, NULL);
0604             rx_size = (rx_size & RX_PKT_LEN) >> 16;
0605             if (btmtksdio_rx_packet(bdev, rx_size) < 0)
0606                 bdev->hdev->stat.err_rx++;
0607         }
0608     } while (int_status || time_is_before_jiffies(txrx_timeout));
0609 
0610     /* Enable interrupt */
0611     sdio_writel(bdev->func, C_INT_EN_SET, MTK_REG_CHLPCR, 0);
0612 
0613     sdio_release_host(bdev->func);
0614 
0615     pm_runtime_mark_last_busy(bdev->dev);
0616     pm_runtime_put_autosuspend(bdev->dev);
0617 }
0618 
0619 static void btmtksdio_interrupt(struct sdio_func *func)
0620 {
0621     struct btmtksdio_dev *bdev = sdio_get_drvdata(func);
0622 
0623     /* Disable interrupt */
0624     sdio_writel(bdev->func, C_INT_EN_CLR, MTK_REG_CHLPCR, 0);
0625 
0626     schedule_work(&bdev->txrx_work);
0627 }
0628 
0629 static int btmtksdio_open(struct hci_dev *hdev)
0630 {
0631     struct btmtksdio_dev *bdev = hci_get_drvdata(hdev);
0632     u32 val;
0633     int err;
0634 
0635     sdio_claim_host(bdev->func);
0636 
0637     err = sdio_enable_func(bdev->func);
0638     if (err < 0)
0639         goto err_release_host;
0640 
0641     set_bit(BTMTKSDIO_FUNC_ENABLED, &bdev->tx_state);
0642 
0643     err = btmtksdio_drv_pmctrl(bdev);
0644     if (err < 0)
0645         goto err_disable_func;
0646 
0647     /* Disable interrupt & mask out all interrupt sources */
0648     sdio_writel(bdev->func, C_INT_EN_CLR, MTK_REG_CHLPCR, &err);
0649     if (err < 0)
0650         goto err_disable_func;
0651 
0652     sdio_writel(bdev->func, 0, MTK_REG_CHIER, &err);
0653     if (err < 0)
0654         goto err_disable_func;
0655 
0656     err = sdio_claim_irq(bdev->func, btmtksdio_interrupt);
0657     if (err < 0)
0658         goto err_disable_func;
0659 
0660     err = sdio_set_block_size(bdev->func, MTK_SDIO_BLOCK_SIZE);
0661     if (err < 0)
0662         goto err_release_irq;
0663 
0664     /* SDIO CMD 5 allows the SDIO device back to idle state an
0665      * synchronous interrupt is supported in SDIO 4-bit mode
0666      */
0667     val = sdio_readl(bdev->func, MTK_REG_CSDIOCSR, &err);
0668     if (err < 0)
0669         goto err_release_irq;
0670 
0671     val |= SDIO_INT_CTL;
0672     sdio_writel(bdev->func, val, MTK_REG_CSDIOCSR, &err);
0673     if (err < 0)
0674         goto err_release_irq;
0675 
0676     /* Explitly set write-1-clear method */
0677     val = sdio_readl(bdev->func, MTK_REG_CHCR, &err);
0678     if (err < 0)
0679         goto err_release_irq;
0680 
0681     val |= C_INT_CLR_CTRL;
0682     sdio_writel(bdev->func, val, MTK_REG_CHCR, &err);
0683     if (err < 0)
0684         goto err_release_irq;
0685 
0686     /* Setup interrupt sources */
0687     sdio_writel(bdev->func, RX_DONE_INT | TX_EMPTY | TX_FIFO_OVERFLOW,
0688             MTK_REG_CHIER, &err);
0689     if (err < 0)
0690         goto err_release_irq;
0691 
0692     /* Enable interrupt */
0693     sdio_writel(bdev->func, C_INT_EN_SET, MTK_REG_CHLPCR, &err);
0694     if (err < 0)
0695         goto err_release_irq;
0696 
0697     sdio_release_host(bdev->func);
0698 
0699     return 0;
0700 
0701 err_release_irq:
0702     sdio_release_irq(bdev->func);
0703 
0704 err_disable_func:
0705     sdio_disable_func(bdev->func);
0706 
0707 err_release_host:
0708     sdio_release_host(bdev->func);
0709 
0710     return err;
0711 }
0712 
0713 static int btmtksdio_close(struct hci_dev *hdev)
0714 {
0715     struct btmtksdio_dev *bdev = hci_get_drvdata(hdev);
0716 
0717     sdio_claim_host(bdev->func);
0718 
0719     /* Disable interrupt */
0720     sdio_writel(bdev->func, C_INT_EN_CLR, MTK_REG_CHLPCR, NULL);
0721 
0722     sdio_release_irq(bdev->func);
0723 
0724     cancel_work_sync(&bdev->txrx_work);
0725 
0726     btmtksdio_fw_pmctrl(bdev);
0727 
0728     clear_bit(BTMTKSDIO_FUNC_ENABLED, &bdev->tx_state);
0729     sdio_disable_func(bdev->func);
0730 
0731     sdio_release_host(bdev->func);
0732 
0733     return 0;
0734 }
0735 
0736 static int btmtksdio_flush(struct hci_dev *hdev)
0737 {
0738     struct btmtksdio_dev *bdev = hci_get_drvdata(hdev);
0739 
0740     skb_queue_purge(&bdev->txq);
0741 
0742     cancel_work_sync(&bdev->txrx_work);
0743 
0744     return 0;
0745 }
0746 
0747 static int btmtksdio_func_query(struct hci_dev *hdev)
0748 {
0749     struct btmtk_hci_wmt_params wmt_params;
0750     int status, err;
0751     u8 param = 0;
0752 
0753     /* Query whether the function is enabled */
0754     wmt_params.op = BTMTK_WMT_FUNC_CTRL;
0755     wmt_params.flag = 4;
0756     wmt_params.dlen = sizeof(param);
0757     wmt_params.data = &param;
0758     wmt_params.status = &status;
0759 
0760     err = mtk_hci_wmt_sync(hdev, &wmt_params);
0761     if (err < 0) {
0762         bt_dev_err(hdev, "Failed to query function status (%d)", err);
0763         return err;
0764     }
0765 
0766     return status;
0767 }
0768 
0769 static int mt76xx_setup(struct hci_dev *hdev, const char *fwname)
0770 {
0771     struct btmtksdio_dev *bdev = hci_get_drvdata(hdev);
0772     struct btmtk_hci_wmt_params wmt_params;
0773     struct btmtk_tci_sleep tci_sleep;
0774     struct sk_buff *skb;
0775     int err, status;
0776     u8 param = 0x1;
0777 
0778     /* Query whether the firmware is already download */
0779     wmt_params.op = BTMTK_WMT_SEMAPHORE;
0780     wmt_params.flag = 1;
0781     wmt_params.dlen = 0;
0782     wmt_params.data = NULL;
0783     wmt_params.status = &status;
0784 
0785     err = mtk_hci_wmt_sync(hdev, &wmt_params);
0786     if (err < 0) {
0787         bt_dev_err(hdev, "Failed to query firmware status (%d)", err);
0788         return err;
0789     }
0790 
0791     if (status == BTMTK_WMT_PATCH_DONE) {
0792         bt_dev_info(hdev, "Firmware already downloaded");
0793         goto ignore_setup_fw;
0794     }
0795 
0796     /* Setup a firmware which the device definitely requires */
0797     err = btmtk_setup_firmware(hdev, fwname, mtk_hci_wmt_sync);
0798     if (err < 0)
0799         return err;
0800 
0801 ignore_setup_fw:
0802     /* Query whether the device is already enabled */
0803     err = readx_poll_timeout(btmtksdio_func_query, hdev, status,
0804                  status < 0 || status != BTMTK_WMT_ON_PROGRESS,
0805                  2000, 5000000);
0806     /* -ETIMEDOUT happens */
0807     if (err < 0)
0808         return err;
0809 
0810     /* The other errors happen in btusb_mtk_func_query */
0811     if (status < 0)
0812         return status;
0813 
0814     if (status == BTMTK_WMT_ON_DONE) {
0815         bt_dev_info(hdev, "function already on");
0816         goto ignore_func_on;
0817     }
0818 
0819     /* Enable Bluetooth protocol */
0820     wmt_params.op = BTMTK_WMT_FUNC_CTRL;
0821     wmt_params.flag = 0;
0822     wmt_params.dlen = sizeof(param);
0823     wmt_params.data = &param;
0824     wmt_params.status = NULL;
0825 
0826     err = mtk_hci_wmt_sync(hdev, &wmt_params);
0827     if (err < 0) {
0828         bt_dev_err(hdev, "Failed to send wmt func ctrl (%d)", err);
0829         return err;
0830     }
0831 
0832     set_bit(BTMTKSDIO_PATCH_ENABLED, &bdev->tx_state);
0833 
0834 ignore_func_on:
0835     /* Apply the low power environment setup */
0836     tci_sleep.mode = 0x5;
0837     tci_sleep.duration = cpu_to_le16(0x640);
0838     tci_sleep.host_duration = cpu_to_le16(0x640);
0839     tci_sleep.host_wakeup_pin = 0;
0840     tci_sleep.time_compensation = 0;
0841 
0842     skb = __hci_cmd_sync(hdev, 0xfc7a, sizeof(tci_sleep), &tci_sleep,
0843                  HCI_INIT_TIMEOUT);
0844     if (IS_ERR(skb)) {
0845         err = PTR_ERR(skb);
0846         bt_dev_err(hdev, "Failed to apply low power setting (%d)", err);
0847         return err;
0848     }
0849     kfree_skb(skb);
0850 
0851     return 0;
0852 }
0853 
0854 static int mt79xx_setup(struct hci_dev *hdev, const char *fwname)
0855 {
0856     struct btmtksdio_dev *bdev = hci_get_drvdata(hdev);
0857     struct btmtk_hci_wmt_params wmt_params;
0858     u8 param = 0x1;
0859     int err;
0860 
0861     err = btmtk_setup_firmware_79xx(hdev, fwname, mtk_hci_wmt_sync);
0862     if (err < 0) {
0863         bt_dev_err(hdev, "Failed to setup 79xx firmware (%d)", err);
0864         return err;
0865     }
0866 
0867     err = btmtksdio_fw_pmctrl(bdev);
0868     if (err < 0)
0869         return err;
0870 
0871     err = btmtksdio_drv_pmctrl(bdev);
0872     if (err < 0)
0873         return err;
0874 
0875     /* Enable Bluetooth protocol */
0876     wmt_params.op = BTMTK_WMT_FUNC_CTRL;
0877     wmt_params.flag = 0;
0878     wmt_params.dlen = sizeof(param);
0879     wmt_params.data = &param;
0880     wmt_params.status = NULL;
0881 
0882     err = mtk_hci_wmt_sync(hdev, &wmt_params);
0883     if (err < 0) {
0884         bt_dev_err(hdev, "Failed to send wmt func ctrl (%d)", err);
0885         return err;
0886     }
0887 
0888     hci_set_msft_opcode(hdev, 0xFD30);
0889     hci_set_aosp_capable(hdev);
0890     set_bit(BTMTKSDIO_PATCH_ENABLED, &bdev->tx_state);
0891 
0892     return err;
0893 }
0894 
0895 static int btmtksdio_mtk_reg_read(struct hci_dev *hdev, u32 reg, u32 *val)
0896 {
0897     struct btmtk_hci_wmt_params wmt_params;
0898     struct reg_read_cmd reg_read = {
0899         .type = 1,
0900         .num = 1,
0901     };
0902     u32 status;
0903     int err;
0904 
0905     reg_read.addr = cpu_to_le32(reg);
0906     wmt_params.op = BTMTK_WMT_REGISTER;
0907     wmt_params.flag = BTMTK_WMT_REG_READ;
0908     wmt_params.dlen = sizeof(reg_read);
0909     wmt_params.data = &reg_read;
0910     wmt_params.status = &status;
0911 
0912     err = mtk_hci_wmt_sync(hdev, &wmt_params);
0913     if (err < 0) {
0914         bt_dev_err(hdev, "Failed to read reg (%d)", err);
0915         return err;
0916     }
0917 
0918     *val = status;
0919 
0920     return err;
0921 }
0922 
0923 static int btmtksdio_mtk_reg_write(struct hci_dev *hdev, u32 reg, u32 val, u32 mask)
0924 {
0925     struct btmtk_hci_wmt_params wmt_params;
0926     const struct reg_write_cmd reg_write = {
0927         .type = 1,
0928         .num = 1,
0929         .addr = cpu_to_le32(reg),
0930         .data = cpu_to_le32(val),
0931         .mask = cpu_to_le32(mask),
0932     };
0933     int err, status;
0934 
0935     wmt_params.op = BTMTK_WMT_REGISTER;
0936     wmt_params.flag = BTMTK_WMT_REG_WRITE;
0937     wmt_params.dlen = sizeof(reg_write);
0938     wmt_params.data = &reg_write;
0939     wmt_params.status = &status;
0940 
0941     err = mtk_hci_wmt_sync(hdev, &wmt_params);
0942     if (err < 0)
0943         bt_dev_err(hdev, "Failed to write reg (%d)", err);
0944 
0945     return err;
0946 }
0947 
0948 static int btmtksdio_get_data_path_id(struct hci_dev *hdev, __u8 *data_path_id)
0949 {
0950     /* uses 1 as data path id for all the usecases */
0951     *data_path_id = 1;
0952     return 0;
0953 }
0954 
0955 static int btmtksdio_get_codec_config_data(struct hci_dev *hdev,
0956                        __u8 link, struct bt_codec *codec,
0957                        __u8 *ven_len, __u8 **ven_data)
0958 {
0959     int err = 0;
0960 
0961     if (!ven_data || !ven_len)
0962         return -EINVAL;
0963 
0964     *ven_len = 0;
0965     *ven_data = NULL;
0966 
0967     if (link != ESCO_LINK) {
0968         bt_dev_err(hdev, "Invalid link type(%u)", link);
0969         return -EINVAL;
0970     }
0971 
0972     *ven_data = kmalloc(sizeof(__u8), GFP_KERNEL);
0973     if (!*ven_data) {
0974         err = -ENOMEM;
0975         goto error;
0976     }
0977 
0978     /* supports only CVSD and mSBC offload codecs */
0979     switch (codec->id) {
0980     case 0x02:
0981         **ven_data = 0x00;
0982         break;
0983     case 0x05:
0984         **ven_data = 0x01;
0985         break;
0986     default:
0987         err = -EINVAL;
0988         bt_dev_err(hdev, "Invalid codec id(%u)", codec->id);
0989         goto error;
0990     }
0991     /* codec and its capabilities are pre-defined to ids
0992      * preset id = 0x00 represents CVSD codec with sampling rate 8K
0993      * preset id = 0x01 represents mSBC codec with sampling rate 16K
0994      */
0995     *ven_len = sizeof(__u8);
0996     return err;
0997 
0998 error:
0999     kfree(*ven_data);
1000     *ven_data = NULL;
1001     return err;
1002 }
1003 
1004 static int btmtksdio_sco_setting(struct hci_dev *hdev)
1005 {
1006     const struct btmtk_sco sco_setting = {
1007         .clock_config = 0x49,
1008         .channel_format_config = 0x80,
1009     };
1010     struct sk_buff *skb;
1011     u32 val;
1012     int err;
1013 
1014     /* Enable SCO over I2S/PCM for MediaTek chipset */
1015     skb =  __hci_cmd_sync(hdev, 0xfc72, sizeof(sco_setting),
1016                   &sco_setting, HCI_CMD_TIMEOUT);
1017     if (IS_ERR(skb))
1018         return PTR_ERR(skb);
1019 
1020     kfree_skb(skb);
1021 
1022     err = btmtksdio_mtk_reg_read(hdev, MT7921_PINMUX_0, &val);
1023     if (err < 0)
1024         return err;
1025 
1026     val |= 0x11000000;
1027     err = btmtksdio_mtk_reg_write(hdev, MT7921_PINMUX_0, val, ~0);
1028     if (err < 0)
1029         return err;
1030 
1031     err = btmtksdio_mtk_reg_read(hdev, MT7921_PINMUX_1, &val);
1032     if (err < 0)
1033         return err;
1034 
1035     val |= 0x00000101;
1036     err =  btmtksdio_mtk_reg_write(hdev, MT7921_PINMUX_1, val, ~0);
1037     if (err < 0)
1038         return err;
1039 
1040     hdev->get_data_path_id = btmtksdio_get_data_path_id;
1041     hdev->get_codec_config_data = btmtksdio_get_codec_config_data;
1042 
1043     return err;
1044 }
1045 
1046 static int btmtksdio_reset_setting(struct hci_dev *hdev)
1047 {
1048     int err;
1049     u32 val;
1050 
1051     err = btmtksdio_mtk_reg_read(hdev, MT7921_PINMUX_1, &val);
1052     if (err < 0)
1053         return err;
1054 
1055     val |= 0x20; /* set the pin (bit field 11:8) work as GPIO mode */
1056     err = btmtksdio_mtk_reg_write(hdev, MT7921_PINMUX_1, val, ~0);
1057     if (err < 0)
1058         return err;
1059 
1060     err = btmtksdio_mtk_reg_read(hdev, MT7921_BTSYS_RST, &val);
1061     if (err < 0)
1062         return err;
1063 
1064     val |= MT7921_BTSYS_RST_WITH_GPIO;
1065     return btmtksdio_mtk_reg_write(hdev, MT7921_BTSYS_RST, val, ~0);
1066 }
1067 
1068 static int btmtksdio_setup(struct hci_dev *hdev)
1069 {
1070     struct btmtksdio_dev *bdev = hci_get_drvdata(hdev);
1071     ktime_t calltime, delta, rettime;
1072     unsigned long long duration;
1073     char fwname[64];
1074     int err, dev_id;
1075     u32 fw_version = 0, val;
1076 
1077     calltime = ktime_get();
1078     set_bit(BTMTKSDIO_HW_TX_READY, &bdev->tx_state);
1079 
1080     switch (bdev->data->chipid) {
1081     case 0x7921:
1082         if (test_bit(BTMTKSDIO_HW_RESET_ACTIVE, &bdev->tx_state)) {
1083             err = btmtksdio_mtk_reg_read(hdev, MT7921_DLSTATUS,
1084                              &val);
1085             if (err < 0)
1086                 return err;
1087 
1088             val &= ~BT_DL_STATE;
1089             err = btmtksdio_mtk_reg_write(hdev, MT7921_DLSTATUS,
1090                               val, ~0);
1091             if (err < 0)
1092                 return err;
1093 
1094             btmtksdio_fw_pmctrl(bdev);
1095             msleep(20);
1096             btmtksdio_drv_pmctrl(bdev);
1097 
1098             clear_bit(BTMTKSDIO_HW_RESET_ACTIVE, &bdev->tx_state);
1099         }
1100 
1101         err = btmtksdio_mtk_reg_read(hdev, 0x70010200, &dev_id);
1102         if (err < 0) {
1103             bt_dev_err(hdev, "Failed to get device id (%d)", err);
1104             return err;
1105         }
1106 
1107         err = btmtksdio_mtk_reg_read(hdev, 0x80021004, &fw_version);
1108         if (err < 0) {
1109             bt_dev_err(hdev, "Failed to get fw version (%d)", err);
1110             return err;
1111         }
1112 
1113         snprintf(fwname, sizeof(fwname),
1114              "mediatek/BT_RAM_CODE_MT%04x_1_%x_hdr.bin",
1115              dev_id & 0xffff, (fw_version & 0xff) + 1);
1116         err = mt79xx_setup(hdev, fwname);
1117         if (err < 0)
1118             return err;
1119 
1120         /* Enable SCO over I2S/PCM */
1121         err = btmtksdio_sco_setting(hdev);
1122         if (err < 0) {
1123             bt_dev_err(hdev, "Failed to enable SCO setting (%d)", err);
1124             return err;
1125         }
1126 
1127         /* Enable WBS with mSBC codec */
1128         set_bit(HCI_QUIRK_WIDEBAND_SPEECH_SUPPORTED, &hdev->quirks);
1129 
1130         /* Enable GPIO reset mechanism */
1131         if (bdev->reset) {
1132             err = btmtksdio_reset_setting(hdev);
1133             if (err < 0) {
1134                 bt_dev_err(hdev, "Failed to enable Reset setting (%d)", err);
1135                 devm_gpiod_put(bdev->dev, bdev->reset);
1136                 bdev->reset = NULL;
1137             }
1138         }
1139 
1140         /* Valid LE States quirk for MediaTek 7921 */
1141         set_bit(HCI_QUIRK_VALID_LE_STATES, &hdev->quirks);
1142 
1143         break;
1144     case 0x7663:
1145     case 0x7668:
1146         err = mt76xx_setup(hdev, bdev->data->fwname);
1147         if (err < 0)
1148             return err;
1149         break;
1150     default:
1151         return -ENODEV;
1152     }
1153 
1154     rettime = ktime_get();
1155     delta = ktime_sub(rettime, calltime);
1156     duration = (unsigned long long)ktime_to_ns(delta) >> 10;
1157 
1158     pm_runtime_set_autosuspend_delay(bdev->dev,
1159                      MTKBTSDIO_AUTOSUSPEND_DELAY);
1160     pm_runtime_use_autosuspend(bdev->dev);
1161 
1162     err = pm_runtime_set_active(bdev->dev);
1163     if (err < 0)
1164         return err;
1165 
1166     /* Default forbid runtime auto suspend, that can be allowed by
1167      * enable_autosuspend flag or the PM runtime entry under sysfs.
1168      */
1169     pm_runtime_forbid(bdev->dev);
1170     pm_runtime_enable(bdev->dev);
1171 
1172     if (enable_autosuspend)
1173         pm_runtime_allow(bdev->dev);
1174 
1175     bt_dev_info(hdev, "Device setup in %llu usecs", duration);
1176 
1177     return 0;
1178 }
1179 
1180 static int btmtksdio_shutdown(struct hci_dev *hdev)
1181 {
1182     struct btmtksdio_dev *bdev = hci_get_drvdata(hdev);
1183     struct btmtk_hci_wmt_params wmt_params;
1184     u8 param = 0x0;
1185     int err;
1186 
1187     /* Get back the state to be consistent with the state
1188      * in btmtksdio_setup.
1189      */
1190     pm_runtime_get_sync(bdev->dev);
1191 
1192     /* wmt command only works until the reset is complete */
1193     if (test_bit(BTMTKSDIO_HW_RESET_ACTIVE, &bdev->tx_state))
1194         goto ignore_wmt_cmd;
1195 
1196     /* Disable the device */
1197     wmt_params.op = BTMTK_WMT_FUNC_CTRL;
1198     wmt_params.flag = 0;
1199     wmt_params.dlen = sizeof(param);
1200     wmt_params.data = &param;
1201     wmt_params.status = NULL;
1202 
1203     err = mtk_hci_wmt_sync(hdev, &wmt_params);
1204     if (err < 0) {
1205         bt_dev_err(hdev, "Failed to send wmt func ctrl (%d)", err);
1206         return err;
1207     }
1208 
1209 ignore_wmt_cmd:
1210     pm_runtime_put_noidle(bdev->dev);
1211     pm_runtime_disable(bdev->dev);
1212 
1213     return 0;
1214 }
1215 
1216 static int btmtksdio_send_frame(struct hci_dev *hdev, struct sk_buff *skb)
1217 {
1218     struct btmtksdio_dev *bdev = hci_get_drvdata(hdev);
1219 
1220     switch (hci_skb_pkt_type(skb)) {
1221     case HCI_COMMAND_PKT:
1222         hdev->stat.cmd_tx++;
1223         break;
1224 
1225     case HCI_ACLDATA_PKT:
1226         hdev->stat.acl_tx++;
1227         break;
1228 
1229     case HCI_SCODATA_PKT:
1230         hdev->stat.sco_tx++;
1231         break;
1232 
1233     default:
1234         return -EILSEQ;
1235     }
1236 
1237     skb_queue_tail(&bdev->txq, skb);
1238 
1239     schedule_work(&bdev->txrx_work);
1240 
1241     return 0;
1242 }
1243 
1244 static void btmtksdio_cmd_timeout(struct hci_dev *hdev)
1245 {
1246     struct btmtksdio_dev *bdev = hci_get_drvdata(hdev);
1247     u32 status;
1248     int err;
1249 
1250     if (!bdev->reset || bdev->data->chipid != 0x7921)
1251         return;
1252 
1253     pm_runtime_get_sync(bdev->dev);
1254 
1255     if (test_and_set_bit(BTMTKSDIO_HW_RESET_ACTIVE, &bdev->tx_state))
1256         return;
1257 
1258     sdio_claim_host(bdev->func);
1259 
1260     sdio_writel(bdev->func, C_INT_EN_CLR, MTK_REG_CHLPCR, NULL);
1261     skb_queue_purge(&bdev->txq);
1262     cancel_work_sync(&bdev->txrx_work);
1263 
1264     gpiod_set_value_cansleep(bdev->reset, 1);
1265     msleep(100);
1266     gpiod_set_value_cansleep(bdev->reset, 0);
1267 
1268     err = readx_poll_timeout(btmtksdio_chcr_query, bdev, status,
1269                  status & BT_RST_DONE, 100000, 2000000);
1270     if (err < 0) {
1271         bt_dev_err(hdev, "Failed to reset (%d)", err);
1272         goto err;
1273     }
1274 
1275     clear_bit(BTMTKSDIO_PATCH_ENABLED, &bdev->tx_state);
1276 err:
1277     sdio_release_host(bdev->func);
1278 
1279     pm_runtime_put_noidle(bdev->dev);
1280     pm_runtime_disable(bdev->dev);
1281 
1282     hci_reset_dev(hdev);
1283 }
1284 
1285 static bool btmtksdio_sdio_inband_wakeup(struct hci_dev *hdev)
1286 {
1287     struct btmtksdio_dev *bdev = hci_get_drvdata(hdev);
1288 
1289     return device_may_wakeup(bdev->dev);
1290 }
1291 
1292 static bool btmtksdio_sdio_wakeup(struct hci_dev *hdev)
1293 {
1294     struct btmtksdio_dev *bdev = hci_get_drvdata(hdev);
1295     bool may_wakeup = device_may_wakeup(bdev->dev);
1296     const struct btmtk_wakeon bt_awake = {
1297         .mode = 0x1,
1298         .gpo = 0,
1299         .active_high = 0x1,
1300         .enable_delay = cpu_to_le16(0xc80),
1301         .wakeup_delay = cpu_to_le16(0x20),
1302     };
1303 
1304     if (may_wakeup && bdev->data->chipid == 0x7921) {
1305         struct sk_buff *skb;
1306 
1307         skb =  __hci_cmd_sync(hdev, 0xfc27, sizeof(bt_awake),
1308                       &bt_awake, HCI_CMD_TIMEOUT);
1309         if (IS_ERR(skb))
1310             may_wakeup = false;
1311         else
1312             kfree_skb(skb);
1313     }
1314 
1315     return may_wakeup;
1316 }
1317 
1318 static int btmtksdio_probe(struct sdio_func *func,
1319                const struct sdio_device_id *id)
1320 {
1321     struct btmtksdio_dev *bdev;
1322     struct hci_dev *hdev;
1323     int err;
1324 
1325     bdev = devm_kzalloc(&func->dev, sizeof(*bdev), GFP_KERNEL);
1326     if (!bdev)
1327         return -ENOMEM;
1328 
1329     bdev->data = (void *)id->driver_data;
1330     if (!bdev->data)
1331         return -ENODEV;
1332 
1333     bdev->dev = &func->dev;
1334     bdev->func = func;
1335 
1336     INIT_WORK(&bdev->txrx_work, btmtksdio_txrx_work);
1337     skb_queue_head_init(&bdev->txq);
1338 
1339     /* Initialize and register HCI device */
1340     hdev = hci_alloc_dev();
1341     if (!hdev) {
1342         dev_err(&func->dev, "Can't allocate HCI device\n");
1343         return -ENOMEM;
1344     }
1345 
1346     bdev->hdev = hdev;
1347 
1348     hdev->bus = HCI_SDIO;
1349     hci_set_drvdata(hdev, bdev);
1350 
1351     hdev->open     = btmtksdio_open;
1352     hdev->close    = btmtksdio_close;
1353     hdev->cmd_timeout = btmtksdio_cmd_timeout;
1354     hdev->flush    = btmtksdio_flush;
1355     hdev->setup    = btmtksdio_setup;
1356     hdev->shutdown = btmtksdio_shutdown;
1357     hdev->send     = btmtksdio_send_frame;
1358     hdev->wakeup   = btmtksdio_sdio_wakeup;
1359     /*
1360      * If SDIO controller supports wake on Bluetooth, sending a wakeon
1361      * command is not necessary.
1362      */
1363     if (device_can_wakeup(func->card->host->parent))
1364         hdev->wakeup = btmtksdio_sdio_inband_wakeup;
1365     else
1366         hdev->wakeup = btmtksdio_sdio_wakeup;
1367     hdev->set_bdaddr = btmtk_set_bdaddr;
1368 
1369     SET_HCIDEV_DEV(hdev, &func->dev);
1370 
1371     hdev->manufacturer = 70;
1372     set_bit(HCI_QUIRK_NON_PERSISTENT_SETUP, &hdev->quirks);
1373 
1374     sdio_set_drvdata(func, bdev);
1375 
1376     err = hci_register_dev(hdev);
1377     if (err < 0) {
1378         dev_err(&func->dev, "Can't register HCI device\n");
1379         hci_free_dev(hdev);
1380         return err;
1381     }
1382 
1383     /* pm_runtime_enable would be done after the firmware is being
1384      * downloaded because the core layer probably already enables
1385      * runtime PM for this func such as the case host->caps &
1386      * MMC_CAP_POWER_OFF_CARD.
1387      */
1388     if (pm_runtime_enabled(bdev->dev))
1389         pm_runtime_disable(bdev->dev);
1390 
1391     /* As explaination in drivers/mmc/core/sdio_bus.c tells us:
1392      * Unbound SDIO functions are always suspended.
1393      * During probe, the function is set active and the usage count
1394      * is incremented.  If the driver supports runtime PM,
1395      * it should call pm_runtime_put_noidle() in its probe routine and
1396      * pm_runtime_get_noresume() in its remove routine.
1397      *
1398      * So, put a pm_runtime_put_noidle here !
1399      */
1400     pm_runtime_put_noidle(bdev->dev);
1401 
1402     err = device_init_wakeup(bdev->dev, true);
1403     if (err)
1404         bt_dev_err(hdev, "failed to initialize device wakeup");
1405 
1406     bdev->dev->of_node = of_find_compatible_node(NULL, NULL,
1407                              "mediatek,mt7921s-bluetooth");
1408     bdev->reset = devm_gpiod_get_optional(bdev->dev, "reset",
1409                           GPIOD_OUT_LOW);
1410     if (IS_ERR(bdev->reset))
1411         err = PTR_ERR(bdev->reset);
1412 
1413     return err;
1414 }
1415 
1416 static void btmtksdio_remove(struct sdio_func *func)
1417 {
1418     struct btmtksdio_dev *bdev = sdio_get_drvdata(func);
1419     struct hci_dev *hdev;
1420 
1421     if (!bdev)
1422         return;
1423 
1424     /* Be consistent the state in btmtksdio_probe */
1425     pm_runtime_get_noresume(bdev->dev);
1426 
1427     hdev = bdev->hdev;
1428 
1429     sdio_set_drvdata(func, NULL);
1430     hci_unregister_dev(hdev);
1431     hci_free_dev(hdev);
1432 }
1433 
1434 #ifdef CONFIG_PM
1435 static int btmtksdio_runtime_suspend(struct device *dev)
1436 {
1437     struct sdio_func *func = dev_to_sdio_func(dev);
1438     struct btmtksdio_dev *bdev;
1439     int err;
1440 
1441     bdev = sdio_get_drvdata(func);
1442     if (!bdev)
1443         return 0;
1444 
1445     if (!test_bit(BTMTKSDIO_FUNC_ENABLED, &bdev->tx_state))
1446         return 0;
1447 
1448     sdio_set_host_pm_flags(func, MMC_PM_KEEP_POWER);
1449 
1450     err = btmtksdio_fw_pmctrl(bdev);
1451 
1452     bt_dev_dbg(bdev->hdev, "status (%d) return ownership to device", err);
1453 
1454     return err;
1455 }
1456 
1457 static int btmtksdio_runtime_resume(struct device *dev)
1458 {
1459     struct sdio_func *func = dev_to_sdio_func(dev);
1460     struct btmtksdio_dev *bdev;
1461     int err;
1462 
1463     bdev = sdio_get_drvdata(func);
1464     if (!bdev)
1465         return 0;
1466 
1467     if (!test_bit(BTMTKSDIO_FUNC_ENABLED, &bdev->tx_state))
1468         return 0;
1469 
1470     err = btmtksdio_drv_pmctrl(bdev);
1471 
1472     bt_dev_dbg(bdev->hdev, "status (%d) get ownership from device", err);
1473 
1474     return err;
1475 }
1476 
1477 static UNIVERSAL_DEV_PM_OPS(btmtksdio_pm_ops, btmtksdio_runtime_suspend,
1478                 btmtksdio_runtime_resume, NULL);
1479 #define BTMTKSDIO_PM_OPS (&btmtksdio_pm_ops)
1480 #else   /* CONFIG_PM */
1481 #define BTMTKSDIO_PM_OPS NULL
1482 #endif  /* CONFIG_PM */
1483 
1484 static struct sdio_driver btmtksdio_driver = {
1485     .name       = "btmtksdio",
1486     .probe      = btmtksdio_probe,
1487     .remove     = btmtksdio_remove,
1488     .id_table   = btmtksdio_table,
1489     .drv = {
1490         .owner = THIS_MODULE,
1491         .pm = BTMTKSDIO_PM_OPS,
1492     }
1493 };
1494 
1495 module_sdio_driver(btmtksdio_driver);
1496 
1497 module_param(enable_autosuspend, bool, 0644);
1498 MODULE_PARM_DESC(enable_autosuspend, "Enable autosuspend by default");
1499 
1500 MODULE_AUTHOR("Sean Wang <sean.wang@mediatek.com>");
1501 MODULE_DESCRIPTION("MediaTek Bluetooth SDIO driver ver " VERSION);
1502 MODULE_VERSION(VERSION);
1503 MODULE_LICENSE("GPL");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!