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, MT_TXQ_MCU, 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_send_firmware(struct mt7603_dev *dev, const void *data, int len) 98 { 99 int cur_len, ret = 0; 100 101 while (len > 0) { 102 cur_len = min_t(int, 4096 - sizeof(struct mt7603_mcu_txd), 103 len); 104 105 ret = mt76_mcu_send_msg(&dev->mt76, -MCU_CMD_FW_SCATTER, data, 106 cur_len, false); 107 if (ret) 108 break; 109 110 data += cur_len; 111 len -= cur_len; 112 } 113 114 return ret; 115 } 116 117 static int 118 mt7603_mcu_start_firmware(struct mt7603_dev *dev, u32 addr) 119 { 120 struct { 121 __le32 override; 122 __le32 addr; 123 } req = { 124 .override = cpu_to_le32(addr ? 1 : 0), 125 .addr = cpu_to_le32(addr), 126 }; 127 128 return mt76_mcu_send_msg(&dev->mt76, -MCU_CMD_FW_START_REQ, &req, 129 sizeof(req), true); 130 } 131 132 static int 133 mt7603_mcu_restart(struct mt76_dev *dev) 134 { 135 return mt76_mcu_send_msg(dev, -MCU_CMD_RESTART_DL_REQ, NULL, 0, true); 136 } 137 138 static int mt7603_load_firmware(struct mt7603_dev *dev) 139 { 140 const struct firmware *fw; 141 const struct mt7603_fw_trailer *hdr; 142 const char *firmware; 143 int dl_len; 144 u32 addr, val; 145 int ret; 146 147 if (is_mt7628(dev)) { 148 if (mt76xx_rev(dev) == MT7628_REV_E1) 149 firmware = MT7628_FIRMWARE_E1; 150 else 151 firmware = MT7628_FIRMWARE_E2; 152 } else { 153 if (mt76xx_rev(dev) < MT7603_REV_E2) 154 firmware = MT7603_FIRMWARE_E1; 155 else 156 firmware = MT7603_FIRMWARE_E2; 157 } 158 159 ret = request_firmware(&fw, firmware, dev->mt76.dev); 160 if (ret) 161 return ret; 162 163 if (!fw || !fw->data || fw->size < sizeof(*hdr)) { 164 dev_err(dev->mt76.dev, "Invalid firmware\n"); 165 ret = -EINVAL; 166 goto out; 167 } 168 169 hdr = (const struct mt7603_fw_trailer *)(fw->data + fw->size - 170 sizeof(*hdr)); 171 172 dev_info(dev->mt76.dev, "Firmware Version: %.10s\n", hdr->fw_ver); 173 dev_info(dev->mt76.dev, "Build Time: %.15s\n", hdr->build_date); 174 175 addr = mt7603_reg_map(dev, 0x50012498); 176 mt76_wr(dev, addr, 0x5); 177 mt76_wr(dev, addr, 0x5); 178 udelay(1); 179 180 /* switch to bypass mode */ 181 mt76_rmw(dev, MT_SCH_4, MT_SCH_4_FORCE_QID, 182 MT_SCH_4_BYPASS | FIELD_PREP(MT_SCH_4_FORCE_QID, 5)); 183 184 val = mt76_rr(dev, MT_TOP_MISC2); 185 if (val & BIT(1)) { 186 dev_info(dev->mt76.dev, "Firmware already running...\n"); 187 goto running; 188 } 189 190 if (!mt76_poll_msec(dev, MT_TOP_MISC2, BIT(0) | BIT(1), BIT(0), 500)) { 191 dev_err(dev->mt76.dev, "Timeout waiting for ROM code to become ready\n"); 192 ret = -EIO; 193 goto out; 194 } 195 196 dl_len = le32_to_cpu(hdr->dl_len) + 4; 197 ret = mt7603_mcu_init_download(dev, MCU_FIRMWARE_ADDRESS, dl_len); 198 if (ret) { 199 dev_err(dev->mt76.dev, "Download request failed\n"); 200 goto out; 201 } 202 203 ret = mt7603_mcu_send_firmware(dev, fw->data, dl_len); 204 if (ret) { 205 dev_err(dev->mt76.dev, "Failed to send firmware to device\n"); 206 goto out; 207 } 208 209 ret = mt7603_mcu_start_firmware(dev, MCU_FIRMWARE_ADDRESS); 210 if (ret) { 211 dev_err(dev->mt76.dev, "Failed to start firmware\n"); 212 goto out; 213 } 214 215 if (!mt76_poll_msec(dev, MT_TOP_MISC2, BIT(1), BIT(1), 500)) { 216 dev_err(dev->mt76.dev, "Timeout waiting for firmware to initialize\n"); 217 ret = -EIO; 218 goto out; 219 } 220 221 running: 222 mt76_clear(dev, MT_SCH_4, MT_SCH_4_FORCE_QID | MT_SCH_4_BYPASS); 223 224 mt76_set(dev, MT_SCH_4, BIT(8)); 225 mt76_clear(dev, MT_SCH_4, BIT(8)); 226 227 dev->mcu_running = true; 228 snprintf(dev->mt76.hw->wiphy->fw_version, 229 sizeof(dev->mt76.hw->wiphy->fw_version), 230 "%.10s-%.15s", hdr->fw_ver, hdr->build_date); 231 dev_info(dev->mt76.dev, "firmware init done\n"); 232 233 out: 234 release_firmware(fw); 235 236 return ret; 237 } 238 239 int mt7603_mcu_init(struct mt7603_dev *dev) 240 { 241 static const struct mt76_mcu_ops mt7603_mcu_ops = { 242 .headroom = sizeof(struct mt7603_mcu_txd), 243 .mcu_skb_send_msg = mt7603_mcu_skb_send_msg, 244 .mcu_parse_response = mt7603_mcu_parse_response, 245 .mcu_restart = mt7603_mcu_restart, 246 }; 247 248 dev->mt76.mcu_ops = &mt7603_mcu_ops; 249 return mt7603_load_firmware(dev); 250 } 251 252 void mt7603_mcu_exit(struct mt7603_dev *dev) 253 { 254 __mt76_mcu_restart(&dev->mt76); 255 skb_queue_purge(&dev->mt76.mcu.res_q); 256 } 257 258 int mt7603_mcu_set_eeprom(struct mt7603_dev *dev) 259 { 260 static const u16 req_fields[] = { 261 #define WORD(_start) \ 262 _start, \ 263 _start + 1 264 #define GROUP_2G(_start) \ 265 WORD(_start), \ 266 WORD(_start + 2), \ 267 WORD(_start + 4) 268 269 MT_EE_NIC_CONF_0 + 1, 270 WORD(MT_EE_NIC_CONF_1), 271 MT_EE_WIFI_RF_SETTING, 272 MT_EE_TX_POWER_DELTA_BW40, 273 MT_EE_TX_POWER_DELTA_BW80 + 1, 274 MT_EE_TX_POWER_EXT_PA_5G, 275 MT_EE_TEMP_SENSOR_CAL, 276 GROUP_2G(MT_EE_TX_POWER_0_START_2G), 277 GROUP_2G(MT_EE_TX_POWER_1_START_2G), 278 WORD(MT_EE_TX_POWER_CCK), 279 WORD(MT_EE_TX_POWER_OFDM_2G_6M), 280 WORD(MT_EE_TX_POWER_OFDM_2G_24M), 281 WORD(MT_EE_TX_POWER_OFDM_2G_54M), 282 WORD(MT_EE_TX_POWER_HT_BPSK_QPSK), 283 WORD(MT_EE_TX_POWER_HT_16_64_QAM), 284 WORD(MT_EE_TX_POWER_HT_64_QAM), 285 MT_EE_ELAN_RX_MODE_GAIN, 286 MT_EE_ELAN_RX_MODE_NF, 287 MT_EE_ELAN_RX_MODE_P1DB, 288 MT_EE_ELAN_BYPASS_MODE_GAIN, 289 MT_EE_ELAN_BYPASS_MODE_NF, 290 MT_EE_ELAN_BYPASS_MODE_P1DB, 291 WORD(MT_EE_STEP_NUM_NEG_6_7), 292 WORD(MT_EE_STEP_NUM_NEG_4_5), 293 WORD(MT_EE_STEP_NUM_NEG_2_3), 294 WORD(MT_EE_STEP_NUM_NEG_0_1), 295 WORD(MT_EE_REF_STEP_24G), 296 WORD(MT_EE_STEP_NUM_PLUS_1_2), 297 WORD(MT_EE_STEP_NUM_PLUS_3_4), 298 WORD(MT_EE_STEP_NUM_PLUS_5_6), 299 MT_EE_STEP_NUM_PLUS_7, 300 MT_EE_XTAL_FREQ_OFFSET, 301 MT_EE_XTAL_TRIM_2_COMP, 302 MT_EE_XTAL_TRIM_3_COMP, 303 MT_EE_XTAL_WF_RFCAL, 304 305 /* unknown fields below */ 306 WORD(0x24), 307 0x34, 308 0x39, 309 0x3b, 310 WORD(0x42), 311 WORD(0x9e), 312 0xf2, 313 WORD(0xf8), 314 0xfa, 315 0x12e, 316 WORD(0x130), WORD(0x132), WORD(0x134), WORD(0x136), 317 WORD(0x138), WORD(0x13a), WORD(0x13c), WORD(0x13e), 318 319 #undef GROUP_2G 320 #undef WORD 321 322 }; 323 struct req_data { 324 __le16 addr; 325 u8 val; 326 u8 pad; 327 } __packed; 328 struct { 329 u8 buffer_mode; 330 u8 len; 331 u8 pad[2]; 332 } req_hdr = { 333 .buffer_mode = 1, 334 .len = ARRAY_SIZE(req_fields) - 1, 335 }; 336 const int size = 0xff * sizeof(struct req_data); 337 u8 *req, *eep = (u8 *)dev->mt76.eeprom.data; 338 int i, ret, len = sizeof(req_hdr) + size; 339 struct req_data *data; 340 341 BUILD_BUG_ON(ARRAY_SIZE(req_fields) * sizeof(*data) > size); 342 343 req = kmalloc(len, GFP_KERNEL); 344 if (!req) 345 return -ENOMEM; 346 347 memcpy(req, &req_hdr, sizeof(req_hdr)); 348 data = (struct req_data *)(req + sizeof(req_hdr)); 349 memset(data, 0, size); 350 for (i = 0; i < ARRAY_SIZE(req_fields); i++) { 351 data[i].addr = cpu_to_le16(req_fields[i]); 352 data[i].val = eep[req_fields[i]]; 353 } 354 355 ret = mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD_EFUSE_BUFFER_MODE, 356 req, len, true); 357 kfree(req); 358 359 return ret; 360 } 361 362 static int mt7603_mcu_set_tx_power(struct mt7603_dev *dev) 363 { 364 struct { 365 u8 center_channel; 366 u8 tssi; 367 u8 temp_comp; 368 u8 target_power[2]; 369 u8 rate_power_delta[14]; 370 u8 bw_power_delta; 371 u8 ch_power_delta[6]; 372 u8 temp_comp_power[17]; 373 u8 reserved; 374 } req = { 375 .center_channel = dev->mphy.chandef.chan->hw_value, 376 #define EEP_VAL(n) ((u8 *)dev->mt76.eeprom.data)[n] 377 .tssi = EEP_VAL(MT_EE_NIC_CONF_1 + 1), 378 .temp_comp = EEP_VAL(MT_EE_NIC_CONF_1), 379 .target_power = { 380 EEP_VAL(MT_EE_TX_POWER_0_START_2G + 2), 381 EEP_VAL(MT_EE_TX_POWER_1_START_2G + 2) 382 }, 383 .bw_power_delta = EEP_VAL(MT_EE_TX_POWER_DELTA_BW40), 384 .ch_power_delta = { 385 EEP_VAL(MT_EE_TX_POWER_0_START_2G + 3), 386 EEP_VAL(MT_EE_TX_POWER_0_START_2G + 4), 387 EEP_VAL(MT_EE_TX_POWER_0_START_2G + 5), 388 EEP_VAL(MT_EE_TX_POWER_1_START_2G + 3), 389 EEP_VAL(MT_EE_TX_POWER_1_START_2G + 4), 390 EEP_VAL(MT_EE_TX_POWER_1_START_2G + 5) 391 }, 392 #undef EEP_VAL 393 }; 394 u8 *eep = (u8 *)dev->mt76.eeprom.data; 395 396 memcpy(req.rate_power_delta, eep + MT_EE_TX_POWER_CCK, 397 sizeof(req.rate_power_delta)); 398 399 memcpy(req.temp_comp_power, eep + MT_EE_STEP_NUM_NEG_6_7, 400 sizeof(req.temp_comp_power)); 401 402 return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD_SET_TX_POWER_CTRL, 403 &req, sizeof(req), true); 404 } 405 406 int mt7603_mcu_set_channel(struct mt7603_dev *dev) 407 { 408 struct cfg80211_chan_def *chandef = &dev->mphy.chandef; 409 struct ieee80211_hw *hw = mt76_hw(dev); 410 int n_chains = hweight8(dev->mphy.antenna_mask); 411 struct { 412 u8 control_chan; 413 u8 center_chan; 414 u8 bw; 415 u8 tx_streams; 416 u8 rx_streams; 417 u8 _res0[7]; 418 u8 txpower[21]; 419 u8 _res1[3]; 420 } req = { 421 .control_chan = chandef->chan->hw_value, 422 .center_chan = chandef->chan->hw_value, 423 .bw = MT_BW_20, 424 .tx_streams = n_chains, 425 .rx_streams = n_chains, 426 }; 427 s8 tx_power; 428 int i, ret; 429 430 if (dev->mphy.chandef.width == NL80211_CHAN_WIDTH_40) { 431 req.bw = MT_BW_40; 432 if (chandef->center_freq1 > chandef->chan->center_freq) 433 req.center_chan += 2; 434 else 435 req.center_chan -= 2; 436 } 437 438 tx_power = hw->conf.power_level * 2; 439 if (dev->mphy.antenna_mask == 3) 440 tx_power -= 6; 441 tx_power = min(tx_power, dev->tx_power_limit); 442 443 dev->mphy.txpower_cur = tx_power; 444 445 for (i = 0; i < ARRAY_SIZE(req.txpower); i++) 446 req.txpower[i] = tx_power; 447 448 ret = mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD_CHANNEL_SWITCH, &req, 449 sizeof(req), true); 450 if (ret) 451 return ret; 452 453 return mt7603_mcu_set_tx_power(dev); 454 } 455