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