1 // SPDX-License-Identifier: ISC 2 3 #include <linux/firmware.h> 4 #include "mt7603.h" 5 #include "mcu.h" 6 #include "eeprom.h" 7 8 #define MCU_SKB_RESERVE 8 9 10 struct mt7603_fw_trailer { 11 char fw_ver[10]; 12 char build_date[15]; 13 __le32 dl_len; 14 } __packed; 15 16 static int 17 mt7603_mcu_parse_response(struct mt76_dev *mdev, int cmd, 18 struct sk_buff *skb, int seq) 19 { 20 struct mt7603_dev *dev = container_of(mdev, struct mt7603_dev, mt76); 21 struct mt7603_mcu_rxd *rxd; 22 23 if (!skb) { 24 dev_err(mdev->dev, 25 "MCU message %d (seq %d) timed out\n", 26 cmd, seq); 27 dev->mcu_hang = MT7603_WATCHDOG_TIMEOUT; 28 return -ETIMEDOUT; 29 } 30 31 rxd = (struct mt7603_mcu_rxd *)skb->data; 32 if (seq != rxd->seq) 33 return -EAGAIN; 34 35 return 0; 36 } 37 38 static int 39 mt7603_mcu_skb_send_msg(struct mt76_dev *mdev, struct sk_buff *skb, 40 int cmd, int *wait_seq) 41 { 42 struct mt7603_dev *dev = container_of(mdev, struct mt7603_dev, mt76); 43 int hdrlen = dev->mcu_running ? sizeof(struct mt7603_mcu_txd) : 12; 44 struct mt7603_mcu_txd *txd; 45 u8 seq; 46 47 mdev->mcu.timeout = 3 * HZ; 48 49 seq = ++mdev->mcu.msg_seq & 0xf; 50 if (!seq) 51 seq = ++mdev->mcu.msg_seq & 0xf; 52 53 txd = (struct mt7603_mcu_txd *)skb_push(skb, hdrlen); 54 55 txd->len = cpu_to_le16(skb->len); 56 if (cmd == -MCU_CMD_FW_SCATTER) 57 txd->pq_id = cpu_to_le16(MCU_PORT_QUEUE_FW); 58 else 59 txd->pq_id = cpu_to_le16(MCU_PORT_QUEUE); 60 txd->pkt_type = MCU_PKT_ID; 61 txd->seq = seq; 62 63 if (cmd < 0) { 64 txd->cid = -cmd; 65 txd->set_query = MCU_Q_NA; 66 } else { 67 txd->cid = MCU_CMD_EXT_CID; 68 txd->ext_cid = cmd; 69 txd->set_query = MCU_Q_SET; 70 txd->ext_cid_ack = 1; 71 } 72 73 if (wait_seq) 74 *wait_seq = seq; 75 76 return mt76_tx_queue_skb_raw(dev, mdev->q_mcu[MT_MCUQ_WM], skb, 0); 77 } 78 79 static int 80 mt7603_mcu_init_download(struct mt7603_dev *dev, u32 addr, u32 len) 81 { 82 struct { 83 __le32 addr; 84 __le32 len; 85 __le32 mode; 86 } req = { 87 .addr = cpu_to_le32(addr), 88 .len = cpu_to_le32(len), 89 .mode = cpu_to_le32(BIT(31)), 90 }; 91 92 return mt76_mcu_send_msg(&dev->mt76, -MCU_CMD_TARGET_ADDRESS_LEN_REQ, 93 &req, sizeof(req), true); 94 } 95 96 static int 97 mt7603_mcu_start_firmware(struct mt7603_dev *dev, u32 addr) 98 { 99 struct { 100 __le32 override; 101 __le32 addr; 102 } req = { 103 .override = cpu_to_le32(addr ? 1 : 0), 104 .addr = cpu_to_le32(addr), 105 }; 106 107 return mt76_mcu_send_msg(&dev->mt76, -MCU_CMD_FW_START_REQ, &req, 108 sizeof(req), true); 109 } 110 111 static int 112 mt7603_mcu_restart(struct mt76_dev *dev) 113 { 114 return mt76_mcu_send_msg(dev, -MCU_CMD_RESTART_DL_REQ, NULL, 0, true); 115 } 116 117 static int mt7603_load_firmware(struct mt7603_dev *dev) 118 { 119 const struct firmware *fw; 120 const struct mt7603_fw_trailer *hdr; 121 const char *firmware; 122 int dl_len; 123 u32 addr, val; 124 int ret; 125 126 if (is_mt7628(dev)) { 127 if (mt76xx_rev(dev) == MT7628_REV_E1) 128 firmware = MT7628_FIRMWARE_E1; 129 else 130 firmware = MT7628_FIRMWARE_E2; 131 } else { 132 if (mt76xx_rev(dev) < MT7603_REV_E2) 133 firmware = MT7603_FIRMWARE_E1; 134 else 135 firmware = MT7603_FIRMWARE_E2; 136 } 137 138 ret = request_firmware(&fw, firmware, dev->mt76.dev); 139 if (ret) 140 return ret; 141 142 if (!fw || !fw->data || fw->size < sizeof(*hdr)) { 143 dev_err(dev->mt76.dev, "Invalid firmware\n"); 144 ret = -EINVAL; 145 goto out; 146 } 147 148 hdr = (const struct mt7603_fw_trailer *)(fw->data + fw->size - 149 sizeof(*hdr)); 150 151 dev_info(dev->mt76.dev, "Firmware Version: %.10s\n", hdr->fw_ver); 152 dev_info(dev->mt76.dev, "Build Time: %.15s\n", hdr->build_date); 153 154 addr = mt7603_reg_map(dev, 0x50012498); 155 mt76_wr(dev, addr, 0x5); 156 mt76_wr(dev, addr, 0x5); 157 udelay(1); 158 159 /* switch to bypass mode */ 160 mt76_rmw(dev, MT_SCH_4, MT_SCH_4_FORCE_QID, 161 MT_SCH_4_BYPASS | FIELD_PREP(MT_SCH_4_FORCE_QID, 5)); 162 163 val = mt76_rr(dev, MT_TOP_MISC2); 164 if (val & BIT(1)) { 165 dev_info(dev->mt76.dev, "Firmware already running...\n"); 166 goto running; 167 } 168 169 if (!mt76_poll_msec(dev, MT_TOP_MISC2, BIT(0) | BIT(1), BIT(0), 500)) { 170 dev_err(dev->mt76.dev, "Timeout waiting for ROM code to become ready\n"); 171 ret = -EIO; 172 goto out; 173 } 174 175 dl_len = le32_to_cpu(hdr->dl_len) + 4; 176 ret = mt7603_mcu_init_download(dev, MCU_FIRMWARE_ADDRESS, dl_len); 177 if (ret) { 178 dev_err(dev->mt76.dev, "Download request failed\n"); 179 goto out; 180 } 181 182 ret = mt76_mcu_send_firmware(&dev->mt76, -MCU_CMD_FW_SCATTER, 183 fw->data, dl_len); 184 if (ret) { 185 dev_err(dev->mt76.dev, "Failed to send firmware to device\n"); 186 goto out; 187 } 188 189 ret = mt7603_mcu_start_firmware(dev, MCU_FIRMWARE_ADDRESS); 190 if (ret) { 191 dev_err(dev->mt76.dev, "Failed to start firmware\n"); 192 goto out; 193 } 194 195 if (!mt76_poll_msec(dev, MT_TOP_MISC2, BIT(1), BIT(1), 500)) { 196 dev_err(dev->mt76.dev, "Timeout waiting for firmware to initialize\n"); 197 ret = -EIO; 198 goto out; 199 } 200 201 running: 202 mt76_clear(dev, MT_SCH_4, MT_SCH_4_FORCE_QID | MT_SCH_4_BYPASS); 203 204 mt76_set(dev, MT_SCH_4, BIT(8)); 205 mt76_clear(dev, MT_SCH_4, BIT(8)); 206 207 dev->mcu_running = true; 208 snprintf(dev->mt76.hw->wiphy->fw_version, 209 sizeof(dev->mt76.hw->wiphy->fw_version), 210 "%.10s-%.15s", hdr->fw_ver, hdr->build_date); 211 dev_info(dev->mt76.dev, "firmware init done\n"); 212 213 out: 214 release_firmware(fw); 215 216 return ret; 217 } 218 219 int mt7603_mcu_init(struct mt7603_dev *dev) 220 { 221 static const struct mt76_mcu_ops mt7603_mcu_ops = { 222 .headroom = sizeof(struct mt7603_mcu_txd), 223 .mcu_skb_send_msg = mt7603_mcu_skb_send_msg, 224 .mcu_parse_response = mt7603_mcu_parse_response, 225 .mcu_restart = mt7603_mcu_restart, 226 }; 227 228 dev->mt76.mcu_ops = &mt7603_mcu_ops; 229 return mt7603_load_firmware(dev); 230 } 231 232 void mt7603_mcu_exit(struct mt7603_dev *dev) 233 { 234 __mt76_mcu_restart(&dev->mt76); 235 skb_queue_purge(&dev->mt76.mcu.res_q); 236 } 237 238 int mt7603_mcu_set_eeprom(struct mt7603_dev *dev) 239 { 240 static const u16 req_fields[] = { 241 #define WORD(_start) \ 242 _start, \ 243 _start + 1 244 #define GROUP_2G(_start) \ 245 WORD(_start), \ 246 WORD(_start + 2), \ 247 WORD(_start + 4) 248 249 MT_EE_NIC_CONF_0 + 1, 250 WORD(MT_EE_NIC_CONF_1), 251 MT_EE_WIFI_RF_SETTING, 252 MT_EE_TX_POWER_DELTA_BW40, 253 MT_EE_TX_POWER_DELTA_BW80 + 1, 254 MT_EE_TX_POWER_EXT_PA_5G, 255 MT_EE_TEMP_SENSOR_CAL, 256 GROUP_2G(MT_EE_TX_POWER_0_START_2G), 257 GROUP_2G(MT_EE_TX_POWER_1_START_2G), 258 WORD(MT_EE_TX_POWER_CCK), 259 WORD(MT_EE_TX_POWER_OFDM_2G_6M), 260 WORD(MT_EE_TX_POWER_OFDM_2G_24M), 261 WORD(MT_EE_TX_POWER_OFDM_2G_54M), 262 WORD(MT_EE_TX_POWER_HT_BPSK_QPSK), 263 WORD(MT_EE_TX_POWER_HT_16_64_QAM), 264 WORD(MT_EE_TX_POWER_HT_64_QAM), 265 MT_EE_ELAN_RX_MODE_GAIN, 266 MT_EE_ELAN_RX_MODE_NF, 267 MT_EE_ELAN_RX_MODE_P1DB, 268 MT_EE_ELAN_BYPASS_MODE_GAIN, 269 MT_EE_ELAN_BYPASS_MODE_NF, 270 MT_EE_ELAN_BYPASS_MODE_P1DB, 271 WORD(MT_EE_STEP_NUM_NEG_6_7), 272 WORD(MT_EE_STEP_NUM_NEG_4_5), 273 WORD(MT_EE_STEP_NUM_NEG_2_3), 274 WORD(MT_EE_STEP_NUM_NEG_0_1), 275 WORD(MT_EE_REF_STEP_24G), 276 WORD(MT_EE_STEP_NUM_PLUS_1_2), 277 WORD(MT_EE_STEP_NUM_PLUS_3_4), 278 WORD(MT_EE_STEP_NUM_PLUS_5_6), 279 MT_EE_STEP_NUM_PLUS_7, 280 MT_EE_XTAL_FREQ_OFFSET, 281 MT_EE_XTAL_TRIM_2_COMP, 282 MT_EE_XTAL_TRIM_3_COMP, 283 MT_EE_XTAL_WF_RFCAL, 284 285 /* unknown fields below */ 286 WORD(0x24), 287 0x34, 288 0x39, 289 0x3b, 290 WORD(0x42), 291 WORD(0x9e), 292 0xf2, 293 WORD(0xf8), 294 0xfa, 295 0x12e, 296 WORD(0x130), WORD(0x132), WORD(0x134), WORD(0x136), 297 WORD(0x138), WORD(0x13a), WORD(0x13c), WORD(0x13e), 298 299 #undef GROUP_2G 300 #undef WORD 301 302 }; 303 struct req_data { 304 __le16 addr; 305 u8 val; 306 u8 pad; 307 } __packed; 308 struct { 309 u8 buffer_mode; 310 u8 len; 311 u8 pad[2]; 312 } req_hdr = { 313 .buffer_mode = 1, 314 .len = ARRAY_SIZE(req_fields) - 1, 315 }; 316 const int size = 0xff * sizeof(struct req_data); 317 u8 *req, *eep = (u8 *)dev->mt76.eeprom.data; 318 int i, ret, len = sizeof(req_hdr) + size; 319 struct req_data *data; 320 321 BUILD_BUG_ON(ARRAY_SIZE(req_fields) * sizeof(*data) > size); 322 323 req = kmalloc(len, GFP_KERNEL); 324 if (!req) 325 return -ENOMEM; 326 327 memcpy(req, &req_hdr, sizeof(req_hdr)); 328 data = (struct req_data *)(req + sizeof(req_hdr)); 329 memset(data, 0, size); 330 for (i = 0; i < ARRAY_SIZE(req_fields); i++) { 331 data[i].addr = cpu_to_le16(req_fields[i]); 332 data[i].val = eep[req_fields[i]]; 333 } 334 335 ret = mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD_EFUSE_BUFFER_MODE, 336 req, len, true); 337 kfree(req); 338 339 return ret; 340 } 341 342 static int mt7603_mcu_set_tx_power(struct mt7603_dev *dev) 343 { 344 struct { 345 u8 center_channel; 346 u8 tssi; 347 u8 temp_comp; 348 u8 target_power[2]; 349 u8 rate_power_delta[14]; 350 u8 bw_power_delta; 351 u8 ch_power_delta[6]; 352 u8 temp_comp_power[17]; 353 u8 reserved; 354 } req = { 355 .center_channel = dev->mphy.chandef.chan->hw_value, 356 #define EEP_VAL(n) ((u8 *)dev->mt76.eeprom.data)[n] 357 .tssi = EEP_VAL(MT_EE_NIC_CONF_1 + 1), 358 .temp_comp = EEP_VAL(MT_EE_NIC_CONF_1), 359 .target_power = { 360 EEP_VAL(MT_EE_TX_POWER_0_START_2G + 2), 361 EEP_VAL(MT_EE_TX_POWER_1_START_2G + 2) 362 }, 363 .bw_power_delta = EEP_VAL(MT_EE_TX_POWER_DELTA_BW40), 364 .ch_power_delta = { 365 EEP_VAL(MT_EE_TX_POWER_0_START_2G + 3), 366 EEP_VAL(MT_EE_TX_POWER_0_START_2G + 4), 367 EEP_VAL(MT_EE_TX_POWER_0_START_2G + 5), 368 EEP_VAL(MT_EE_TX_POWER_1_START_2G + 3), 369 EEP_VAL(MT_EE_TX_POWER_1_START_2G + 4), 370 EEP_VAL(MT_EE_TX_POWER_1_START_2G + 5) 371 }, 372 #undef EEP_VAL 373 }; 374 u8 *eep = (u8 *)dev->mt76.eeprom.data; 375 376 memcpy(req.rate_power_delta, eep + MT_EE_TX_POWER_CCK, 377 sizeof(req.rate_power_delta)); 378 379 memcpy(req.temp_comp_power, eep + MT_EE_STEP_NUM_NEG_6_7, 380 sizeof(req.temp_comp_power)); 381 382 return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD_SET_TX_POWER_CTRL, 383 &req, sizeof(req), true); 384 } 385 386 int mt7603_mcu_set_channel(struct mt7603_dev *dev) 387 { 388 struct cfg80211_chan_def *chandef = &dev->mphy.chandef; 389 struct ieee80211_hw *hw = mt76_hw(dev); 390 int n_chains = hweight8(dev->mphy.antenna_mask); 391 struct { 392 u8 control_chan; 393 u8 center_chan; 394 u8 bw; 395 u8 tx_streams; 396 u8 rx_streams; 397 u8 _res0[7]; 398 u8 txpower[21]; 399 u8 _res1[3]; 400 } req = { 401 .control_chan = chandef->chan->hw_value, 402 .center_chan = chandef->chan->hw_value, 403 .bw = MT_BW_20, 404 .tx_streams = n_chains, 405 .rx_streams = n_chains, 406 }; 407 s8 tx_power; 408 int i, ret; 409 410 if (dev->mphy.chandef.width == NL80211_CHAN_WIDTH_40) { 411 req.bw = MT_BW_40; 412 if (chandef->center_freq1 > chandef->chan->center_freq) 413 req.center_chan += 2; 414 else 415 req.center_chan -= 2; 416 } 417 418 tx_power = hw->conf.power_level * 2; 419 if (dev->mphy.antenna_mask == 3) 420 tx_power -= 6; 421 tx_power = min(tx_power, dev->tx_power_limit); 422 423 dev->mphy.txpower_cur = tx_power; 424 425 for (i = 0; i < ARRAY_SIZE(req.txpower); i++) 426 req.txpower[i] = tx_power; 427 428 ret = mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD_CHANNEL_SWITCH, &req, 429 sizeof(req), true); 430 if (ret) 431 return ret; 432 433 return mt7603_mcu_set_tx_power(dev); 434 } 435