mt76/mt7615/sdio_mcu.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 /* Copyright (C) 2020 MediaTek Inc.
0003  *
0004  * Author: Felix Fietkau <nbd@nbd.name>
0005  *     Lorenzo Bianconi <lorenzo@kernel.org>
0006  *     Sean Wang <sean.wang@mediatek.com>
0007  */
0008 #include <linux/kernel.h>
0009 #include <linux/mmc/sdio_func.h>
0010 #include <linux/module.h>
0011 #include <linux/iopoll.h>
0012
0013 #include "../sdio.h"
0014 #include "mt7615.h"
0015 #include "mac.h"
0016 #include "mcu.h"
0017 #include "regs.h"
0018
0019 static int mt7663s_mcu_init_sched(struct mt7615_dev *dev)
0020 {
0021     struct mt76_sdio *sdio = &dev->mt76.sdio;
0022     u32 txdwcnt;
0023
0024     sdio->sched.pse_data_quota = mt76_get_field(dev, MT_PSE_PG_HIF0_GROUP,
0025                             MT_HIF0_MIN_QUOTA);
0026     sdio->sched.pse_mcu_quota = mt76_get_field(dev, MT_PSE_PG_HIF1_GROUP,
0027                            MT_HIF1_MIN_QUOTA);
0028     sdio->sched.ple_data_quota = mt76_get_field(dev, MT_PLE_PG_HIF0_GROUP,
0029                             MT_HIF0_MIN_QUOTA);
0030     sdio->sched.pse_page_size = MT_PSE_PAGE_SZ;
0031     txdwcnt = mt76_get_field(dev, MT_PP_TXDWCNT,
0032                  MT_PP_TXDWCNT_TX1_ADD_DW_CNT);
0033     sdio->sched.deficit = txdwcnt << 2;
0034
0035     return 0;
0036 }
0037
0038 static int
0039 mt7663s_mcu_send_message(struct mt76_dev *mdev, struct sk_buff *skb,
0040              int cmd, int *seq)
0041 {
0042     struct mt7615_dev *dev = container_of(mdev, struct mt7615_dev, mt76);
0043     int ret;
0044
0045     mt7615_mcu_fill_msg(dev, skb, cmd, seq);
0046     ret = mt76_tx_queue_skb_raw(dev, mdev->q_mcu[MT_MCUQ_WM], skb, 0);
0047     if (ret)
0048         return ret;
0049
0050     mt76_queue_kick(dev, mdev->q_mcu[MT_MCUQ_WM]);
0051
0052     return ret;
0053 }
0054
0055 static int __mt7663s_mcu_drv_pmctrl(struct mt7615_dev *dev)
0056 {
0057     struct sdio_func *func = dev->mt76.sdio.func;
0058     struct mt76_phy *mphy = &dev->mt76.phy;
0059     struct mt76_connac_pm *pm = &dev->pm;
0060     u32 status;
0061     int ret;
0062
0063     sdio_claim_host(func);
0064
0065     sdio_writel(func, WHLPCR_FW_OWN_REQ_CLR, MCR_WHLPCR, NULL);
0066
0067     ret = readx_poll_timeout(mt76s_read_pcr, &dev->mt76, status,
0068                  status & WHLPCR_IS_DRIVER_OWN, 2000, 1000000);
0069     if (ret < 0) {
0070         dev_err(dev->mt76.dev, "Cannot get ownership from device");
0071     } else {
0072         clear_bit(MT76_STATE_PM, &mphy->state);
0073
0074         pm->stats.last_wake_event = jiffies;
0075         pm->stats.doze_time += pm->stats.last_wake_event -
0076                        pm->stats.last_doze_event;
0077     }
0078     sdio_release_host(func);
0079
0080     return ret;
0081 }
0082
0083 static int mt7663s_mcu_drv_pmctrl(struct mt7615_dev *dev)
0084 {
0085     struct mt76_phy *mphy = &dev->mt76.phy;
0086     int ret = 0;
0087
0088     mutex_lock(&dev->pm.mutex);
0089
0090     if (test_bit(MT76_STATE_PM, &mphy->state))
0091         ret = __mt7663s_mcu_drv_pmctrl(dev);
0092
0093     mutex_unlock(&dev->pm.mutex);
0094
0095     return ret;
0096 }
0097
0098 static int mt7663s_mcu_fw_pmctrl(struct mt7615_dev *dev)
0099 {
0100     struct sdio_func *func = dev->mt76.sdio.func;
0101     struct mt76_phy *mphy = &dev->mt76.phy;
0102     struct mt76_connac_pm *pm = &dev->pm;
0103     int ret = 0;
0104     u32 status;
0105
0106     mutex_lock(&pm->mutex);
0107
0108     if (mt76_connac_skip_fw_pmctrl(mphy, pm))
0109         goto out;
0110
0111     sdio_claim_host(func);
0112
0113     sdio_writel(func, WHLPCR_FW_OWN_REQ_SET, MCR_WHLPCR, NULL);
0114
0115     ret = readx_poll_timeout(mt76s_read_pcr, &dev->mt76, status,
0116                  !(status & WHLPCR_IS_DRIVER_OWN), 2000, 1000000);
0117     if (ret < 0) {
0118         dev_err(dev->mt76.dev, "Cannot set ownership to device");
0119         clear_bit(MT76_STATE_PM, &mphy->state);
0120     } else {
0121         pm->stats.last_doze_event = jiffies;
0122         pm->stats.awake_time += pm->stats.last_doze_event -
0123                     pm->stats.last_wake_event;
0124     }
0125
0126     sdio_release_host(func);
0127 out:
0128     mutex_unlock(&pm->mutex);
0129
0130     return ret;
0131 }
0132
0133 int mt7663s_mcu_init(struct mt7615_dev *dev)
0134 {
0135     static const struct mt76_mcu_ops mt7663s_mcu_ops = {
0136         .headroom = sizeof(struct mt7615_mcu_txd),
0137         .tailroom = MT_USB_TAIL_SIZE,
0138         .mcu_skb_send_msg = mt7663s_mcu_send_message,
0139         .mcu_parse_response = mt7615_mcu_parse_response,
0140         .mcu_restart = mt7615_mcu_restart,
0141         .mcu_rr = mt76_connac_mcu_reg_rr,
0142         .mcu_wr = mt76_connac_mcu_reg_wr,
0143     };
0144     struct mt7615_mcu_ops *mcu_ops;
0145     int ret;
0146
0147     ret = __mt7663s_mcu_drv_pmctrl(dev);
0148     if (ret)
0149         return ret;
0150
0151     dev->mt76.mcu_ops = &mt7663s_mcu_ops,
0152
0153     ret = mt76_get_field(dev, MT_CONN_ON_MISC, MT_TOP_MISC2_FW_N9_RDY);
0154     if (ret) {
0155         mt7615_mcu_restart(&dev->mt76);
0156         if (!mt76_poll_msec(dev, MT_CONN_ON_MISC,
0157                     MT_TOP_MISC2_FW_N9_RDY, 0, 500))
0158             return -EIO;
0159     }
0160
0161     ret = __mt7663_load_firmware(dev);
0162     if (ret)
0163         return ret;
0164
0165     mcu_ops = devm_kmemdup(dev->mt76.dev, dev->mcu_ops, sizeof(*mcu_ops),
0166                    GFP_KERNEL);
0167     if (!mcu_ops)
0168         return -ENOMEM;
0169
0170     mcu_ops->set_drv_ctrl = mt7663s_mcu_drv_pmctrl;
0171     mcu_ops->set_fw_ctrl = mt7663s_mcu_fw_pmctrl;
0172     dev->mcu_ops = mcu_ops;
0173
0174     ret = mt7663s_mcu_init_sched(dev);
0175     if (ret)
0176         return ret;
0177
0178     set_bit(MT76_STATE_MCU_RUNNING, &dev->mphy.state);
0179
0180     return 0;
0181 }