0001
0002
0003 #include <linux/firmware.h>
0004 #include "mt7603.h"
0005 #include "mcu.h"
0006 #include "eeprom.h"
0007
0008 #define MCU_SKB_RESERVE 8
0009
0010 struct mt7603_fw_trailer {
0011 char fw_ver[10];
0012 char build_date[15];
0013 __le32 dl_len;
0014 } __packed;
0015
0016 static int
0017 mt7603_mcu_parse_response(struct mt76_dev *mdev, int cmd,
0018 struct sk_buff *skb, int seq)
0019 {
0020 struct mt7603_dev *dev = container_of(mdev, struct mt7603_dev, mt76);
0021 struct mt7603_mcu_rxd *rxd;
0022
0023 if (!skb) {
0024 dev_err(mdev->dev, "MCU message %02x (seq %d) timed out\n",
0025 abs(cmd), seq);
0026 dev->mcu_hang = MT7603_WATCHDOG_TIMEOUT;
0027 return -ETIMEDOUT;
0028 }
0029
0030 rxd = (struct mt7603_mcu_rxd *)skb->data;
0031 if (seq != rxd->seq)
0032 return -EAGAIN;
0033
0034 return 0;
0035 }
0036
0037 static int
0038 mt7603_mcu_skb_send_msg(struct mt76_dev *mdev, struct sk_buff *skb,
0039 int cmd, int *wait_seq)
0040 {
0041 struct mt7603_dev *dev = container_of(mdev, struct mt7603_dev, mt76);
0042 int hdrlen = dev->mcu_running ? sizeof(struct mt7603_mcu_txd) : 12;
0043 struct mt7603_mcu_txd *txd;
0044 u8 seq;
0045
0046 mdev->mcu.timeout = 3 * HZ;
0047
0048 seq = ++mdev->mcu.msg_seq & 0xf;
0049 if (!seq)
0050 seq = ++mdev->mcu.msg_seq & 0xf;
0051
0052 txd = (struct mt7603_mcu_txd *)skb_push(skb, hdrlen);
0053
0054 txd->len = cpu_to_le16(skb->len);
0055 if (cmd == -MCU_CMD_FW_SCATTER)
0056 txd->pq_id = cpu_to_le16(MCU_PORT_QUEUE_FW);
0057 else
0058 txd->pq_id = cpu_to_le16(MCU_PORT_QUEUE);
0059 txd->pkt_type = MCU_PKT_ID;
0060 txd->seq = seq;
0061
0062 if (cmd < 0) {
0063 txd->cid = -cmd;
0064 txd->set_query = MCU_Q_NA;
0065 } else {
0066 txd->cid = MCU_CMD_EXT_CID;
0067 txd->ext_cid = cmd;
0068 txd->set_query = MCU_Q_SET;
0069 txd->ext_cid_ack = 1;
0070 }
0071
0072 if (wait_seq)
0073 *wait_seq = seq;
0074
0075 return mt76_tx_queue_skb_raw(dev, mdev->q_mcu[MT_MCUQ_WM], skb, 0);
0076 }
0077
0078 static int
0079 mt7603_mcu_init_download(struct mt7603_dev *dev, u32 addr, u32 len)
0080 {
0081 struct {
0082 __le32 addr;
0083 __le32 len;
0084 __le32 mode;
0085 } req = {
0086 .addr = cpu_to_le32(addr),
0087 .len = cpu_to_le32(len),
0088 .mode = cpu_to_le32(BIT(31)),
0089 };
0090
0091 return mt76_mcu_send_msg(&dev->mt76, -MCU_CMD_TARGET_ADDRESS_LEN_REQ,
0092 &req, sizeof(req), true);
0093 }
0094
0095 static int
0096 mt7603_mcu_start_firmware(struct mt7603_dev *dev, u32 addr)
0097 {
0098 struct {
0099 __le32 override;
0100 __le32 addr;
0101 } req = {
0102 .override = cpu_to_le32(addr ? 1 : 0),
0103 .addr = cpu_to_le32(addr),
0104 };
0105
0106 return mt76_mcu_send_msg(&dev->mt76, -MCU_CMD_FW_START_REQ, &req,
0107 sizeof(req), true);
0108 }
0109
0110 static int
0111 mt7603_mcu_restart(struct mt76_dev *dev)
0112 {
0113 return mt76_mcu_send_msg(dev, -MCU_CMD_RESTART_DL_REQ, NULL, 0, true);
0114 }
0115
0116 static int mt7603_load_firmware(struct mt7603_dev *dev)
0117 {
0118 const struct firmware *fw;
0119 const struct mt7603_fw_trailer *hdr;
0120 const char *firmware;
0121 int dl_len;
0122 u32 addr, val;
0123 int ret;
0124
0125 if (is_mt7628(dev)) {
0126 if (mt76xx_rev(dev) == MT7628_REV_E1)
0127 firmware = MT7628_FIRMWARE_E1;
0128 else
0129 firmware = MT7628_FIRMWARE_E2;
0130 } else {
0131 if (mt76xx_rev(dev) < MT7603_REV_E2)
0132 firmware = MT7603_FIRMWARE_E1;
0133 else
0134 firmware = MT7603_FIRMWARE_E2;
0135 }
0136
0137 ret = request_firmware(&fw, firmware, dev->mt76.dev);
0138 if (ret)
0139 return ret;
0140
0141 if (!fw || !fw->data || fw->size < sizeof(*hdr)) {
0142 dev_err(dev->mt76.dev, "Invalid firmware\n");
0143 ret = -EINVAL;
0144 goto out;
0145 }
0146
0147 hdr = (const struct mt7603_fw_trailer *)(fw->data + fw->size -
0148 sizeof(*hdr));
0149
0150 dev_info(dev->mt76.dev, "Firmware Version: %.10s\n", hdr->fw_ver);
0151 dev_info(dev->mt76.dev, "Build Time: %.15s\n", hdr->build_date);
0152
0153 addr = mt7603_reg_map(dev, 0x50012498);
0154 mt76_wr(dev, addr, 0x5);
0155 mt76_wr(dev, addr, 0x5);
0156 udelay(1);
0157
0158
0159 mt76_rmw(dev, MT_SCH_4, MT_SCH_4_FORCE_QID,
0160 MT_SCH_4_BYPASS | FIELD_PREP(MT_SCH_4_FORCE_QID, 5));
0161
0162 val = mt76_rr(dev, MT_TOP_MISC2);
0163 if (val & BIT(1)) {
0164 dev_info(dev->mt76.dev, "Firmware already running...\n");
0165 goto running;
0166 }
0167
0168 if (!mt76_poll_msec(dev, MT_TOP_MISC2, BIT(0) | BIT(1), BIT(0), 500)) {
0169 dev_err(dev->mt76.dev, "Timeout waiting for ROM code to become ready\n");
0170 ret = -EIO;
0171 goto out;
0172 }
0173
0174 dl_len = le32_to_cpu(hdr->dl_len) + 4;
0175 ret = mt7603_mcu_init_download(dev, MCU_FIRMWARE_ADDRESS, dl_len);
0176 if (ret) {
0177 dev_err(dev->mt76.dev, "Download request failed\n");
0178 goto out;
0179 }
0180
0181 ret = mt76_mcu_send_firmware(&dev->mt76, -MCU_CMD_FW_SCATTER,
0182 fw->data, dl_len);
0183 if (ret) {
0184 dev_err(dev->mt76.dev, "Failed to send firmware to device\n");
0185 goto out;
0186 }
0187
0188 ret = mt7603_mcu_start_firmware(dev, MCU_FIRMWARE_ADDRESS);
0189 if (ret) {
0190 dev_err(dev->mt76.dev, "Failed to start firmware\n");
0191 goto out;
0192 }
0193
0194 if (!mt76_poll_msec(dev, MT_TOP_MISC2, BIT(1), BIT(1), 500)) {
0195 dev_err(dev->mt76.dev, "Timeout waiting for firmware to initialize\n");
0196 ret = -EIO;
0197 goto out;
0198 }
0199
0200 running:
0201 mt76_clear(dev, MT_SCH_4, MT_SCH_4_FORCE_QID | MT_SCH_4_BYPASS);
0202
0203 mt76_set(dev, MT_SCH_4, BIT(8));
0204 mt76_clear(dev, MT_SCH_4, BIT(8));
0205
0206 dev->mcu_running = true;
0207 snprintf(dev->mt76.hw->wiphy->fw_version,
0208 sizeof(dev->mt76.hw->wiphy->fw_version),
0209 "%.10s-%.15s", hdr->fw_ver, hdr->build_date);
0210 dev_info(dev->mt76.dev, "firmware init done\n");
0211
0212 out:
0213 release_firmware(fw);
0214
0215 return ret;
0216 }
0217
0218 int mt7603_mcu_init(struct mt7603_dev *dev)
0219 {
0220 static const struct mt76_mcu_ops mt7603_mcu_ops = {
0221 .headroom = sizeof(struct mt7603_mcu_txd),
0222 .mcu_skb_send_msg = mt7603_mcu_skb_send_msg,
0223 .mcu_parse_response = mt7603_mcu_parse_response,
0224 .mcu_restart = mt7603_mcu_restart,
0225 };
0226
0227 dev->mt76.mcu_ops = &mt7603_mcu_ops;
0228 return mt7603_load_firmware(dev);
0229 }
0230
0231 void mt7603_mcu_exit(struct mt7603_dev *dev)
0232 {
0233 __mt76_mcu_restart(&dev->mt76);
0234 skb_queue_purge(&dev->mt76.mcu.res_q);
0235 }
0236
0237 int mt7603_mcu_set_eeprom(struct mt7603_dev *dev)
0238 {
0239 static const u16 req_fields[] = {
0240 #define WORD(_start) \
0241 _start, \
0242 _start + 1
0243 #define GROUP_2G(_start) \
0244 WORD(_start), \
0245 WORD(_start + 2), \
0246 WORD(_start + 4)
0247
0248 MT_EE_NIC_CONF_0 + 1,
0249 WORD(MT_EE_NIC_CONF_1),
0250 MT_EE_WIFI_RF_SETTING,
0251 MT_EE_TX_POWER_DELTA_BW40,
0252 MT_EE_TX_POWER_DELTA_BW80 + 1,
0253 MT_EE_TX_POWER_EXT_PA_5G,
0254 MT_EE_TEMP_SENSOR_CAL,
0255 GROUP_2G(MT_EE_TX_POWER_0_START_2G),
0256 GROUP_2G(MT_EE_TX_POWER_1_START_2G),
0257 WORD(MT_EE_TX_POWER_CCK),
0258 WORD(MT_EE_TX_POWER_OFDM_2G_6M),
0259 WORD(MT_EE_TX_POWER_OFDM_2G_24M),
0260 WORD(MT_EE_TX_POWER_OFDM_2G_54M),
0261 WORD(MT_EE_TX_POWER_HT_BPSK_QPSK),
0262 WORD(MT_EE_TX_POWER_HT_16_64_QAM),
0263 WORD(MT_EE_TX_POWER_HT_64_QAM),
0264 MT_EE_ELAN_RX_MODE_GAIN,
0265 MT_EE_ELAN_RX_MODE_NF,
0266 MT_EE_ELAN_RX_MODE_P1DB,
0267 MT_EE_ELAN_BYPASS_MODE_GAIN,
0268 MT_EE_ELAN_BYPASS_MODE_NF,
0269 MT_EE_ELAN_BYPASS_MODE_P1DB,
0270 WORD(MT_EE_STEP_NUM_NEG_6_7),
0271 WORD(MT_EE_STEP_NUM_NEG_4_5),
0272 WORD(MT_EE_STEP_NUM_NEG_2_3),
0273 WORD(MT_EE_STEP_NUM_NEG_0_1),
0274 WORD(MT_EE_REF_STEP_24G),
0275 WORD(MT_EE_STEP_NUM_PLUS_1_2),
0276 WORD(MT_EE_STEP_NUM_PLUS_3_4),
0277 WORD(MT_EE_STEP_NUM_PLUS_5_6),
0278 MT_EE_STEP_NUM_PLUS_7,
0279 MT_EE_XTAL_FREQ_OFFSET,
0280 MT_EE_XTAL_TRIM_2_COMP,
0281 MT_EE_XTAL_TRIM_3_COMP,
0282 MT_EE_XTAL_WF_RFCAL,
0283
0284
0285 WORD(0x24),
0286 0x34,
0287 0x39,
0288 0x3b,
0289 WORD(0x42),
0290 WORD(0x9e),
0291 0xf2,
0292 WORD(0xf8),
0293 0xfa,
0294 0x12e,
0295 WORD(0x130), WORD(0x132), WORD(0x134), WORD(0x136),
0296 WORD(0x138), WORD(0x13a), WORD(0x13c), WORD(0x13e),
0297
0298 #undef GROUP_2G
0299 #undef WORD
0300
0301 };
0302 struct req_data {
0303 __le16 addr;
0304 u8 val;
0305 u8 pad;
0306 } __packed;
0307 struct {
0308 u8 buffer_mode;
0309 u8 len;
0310 u8 pad[2];
0311 } req_hdr = {
0312 .buffer_mode = 1,
0313 .len = ARRAY_SIZE(req_fields) - 1,
0314 };
0315 const int size = 0xff * sizeof(struct req_data);
0316 u8 *req, *eep = (u8 *)dev->mt76.eeprom.data;
0317 int i, ret, len = sizeof(req_hdr) + size;
0318 struct req_data *data;
0319
0320 BUILD_BUG_ON(ARRAY_SIZE(req_fields) * sizeof(*data) > size);
0321
0322 req = kmalloc(len, GFP_KERNEL);
0323 if (!req)
0324 return -ENOMEM;
0325
0326 memcpy(req, &req_hdr, sizeof(req_hdr));
0327 data = (struct req_data *)(req + sizeof(req_hdr));
0328 memset(data, 0, size);
0329 for (i = 0; i < ARRAY_SIZE(req_fields); i++) {
0330 data[i].addr = cpu_to_le16(req_fields[i]);
0331 data[i].val = eep[req_fields[i]];
0332 }
0333
0334 ret = mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD_EFUSE_BUFFER_MODE,
0335 req, len, true);
0336 kfree(req);
0337
0338 return ret;
0339 }
0340
0341 static int mt7603_mcu_set_tx_power(struct mt7603_dev *dev)
0342 {
0343 struct {
0344 u8 center_channel;
0345 u8 tssi;
0346 u8 temp_comp;
0347 u8 target_power[2];
0348 u8 rate_power_delta[14];
0349 u8 bw_power_delta;
0350 u8 ch_power_delta[6];
0351 u8 temp_comp_power[17];
0352 u8 reserved;
0353 } req = {
0354 .center_channel = dev->mphy.chandef.chan->hw_value,
0355 #define EEP_VAL(n) ((u8 *)dev->mt76.eeprom.data)[n]
0356 .tssi = EEP_VAL(MT_EE_NIC_CONF_1 + 1),
0357 .temp_comp = EEP_VAL(MT_EE_NIC_CONF_1),
0358 .target_power = {
0359 EEP_VAL(MT_EE_TX_POWER_0_START_2G + 2),
0360 EEP_VAL(MT_EE_TX_POWER_1_START_2G + 2)
0361 },
0362 .bw_power_delta = EEP_VAL(MT_EE_TX_POWER_DELTA_BW40),
0363 .ch_power_delta = {
0364 EEP_VAL(MT_EE_TX_POWER_0_START_2G + 3),
0365 EEP_VAL(MT_EE_TX_POWER_0_START_2G + 4),
0366 EEP_VAL(MT_EE_TX_POWER_0_START_2G + 5),
0367 EEP_VAL(MT_EE_TX_POWER_1_START_2G + 3),
0368 EEP_VAL(MT_EE_TX_POWER_1_START_2G + 4),
0369 EEP_VAL(MT_EE_TX_POWER_1_START_2G + 5)
0370 },
0371 #undef EEP_VAL
0372 };
0373 u8 *eep = (u8 *)dev->mt76.eeprom.data;
0374
0375 memcpy(req.rate_power_delta, eep + MT_EE_TX_POWER_CCK,
0376 sizeof(req.rate_power_delta));
0377
0378 memcpy(req.temp_comp_power, eep + MT_EE_STEP_NUM_NEG_6_7,
0379 sizeof(req.temp_comp_power));
0380
0381 return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD_SET_TX_POWER_CTRL,
0382 &req, sizeof(req), true);
0383 }
0384
0385 int mt7603_mcu_set_channel(struct mt7603_dev *dev)
0386 {
0387 struct cfg80211_chan_def *chandef = &dev->mphy.chandef;
0388 struct ieee80211_hw *hw = mt76_hw(dev);
0389 int n_chains = hweight8(dev->mphy.antenna_mask);
0390 struct {
0391 u8 control_chan;
0392 u8 center_chan;
0393 u8 bw;
0394 u8 tx_streams;
0395 u8 rx_streams;
0396 u8 _res0[7];
0397 u8 txpower[21];
0398 u8 _res1[3];
0399 } req = {
0400 .control_chan = chandef->chan->hw_value,
0401 .center_chan = chandef->chan->hw_value,
0402 .bw = MT_BW_20,
0403 .tx_streams = n_chains,
0404 .rx_streams = n_chains,
0405 };
0406 s8 tx_power = hw->conf.power_level * 2;
0407 int i, ret;
0408
0409 if (dev->mphy.chandef.width == NL80211_CHAN_WIDTH_40) {
0410 req.bw = MT_BW_40;
0411 if (chandef->center_freq1 > chandef->chan->center_freq)
0412 req.center_chan += 2;
0413 else
0414 req.center_chan -= 2;
0415 }
0416
0417 tx_power = mt76_get_sar_power(&dev->mphy, chandef->chan, tx_power);
0418 if (dev->mphy.antenna_mask == 3)
0419 tx_power -= 6;
0420 tx_power = min(tx_power, dev->tx_power_limit);
0421
0422 dev->mphy.txpower_cur = tx_power;
0423
0424 for (i = 0; i < ARRAY_SIZE(req.txpower); i++)
0425 req.txpower[i] = tx_power;
0426
0427 ret = mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD_CHANNEL_SWITCH, &req,
0428 sizeof(req), true);
0429 if (ret)
0430 return ret;
0431
0432 return mt7603_mcu_set_tx_power(dev);
0433 }
