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