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