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 mt76_dev *dev) 165 { 166 return __mt76_mcu_send_msg(dev, -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 .mcu_restart = mt7603_mcu_restart, 273 }; 274 275 dev->mt76.mcu_ops = &mt7603_mcu_ops; 276 return mt7603_load_firmware(dev); 277 } 278 279 void mt7603_mcu_exit(struct mt7603_dev *dev) 280 { 281 __mt76_mcu_restart(&dev->mt76); 282 skb_queue_purge(&dev->mt76.mmio.mcu.res_q); 283 } 284 285 int mt7603_mcu_set_eeprom(struct mt7603_dev *dev) 286 { 287 static const u16 req_fields[] = { 288 #define WORD(_start) \ 289 _start, \ 290 _start + 1 291 #define GROUP_2G(_start) \ 292 WORD(_start), \ 293 WORD(_start + 2), \ 294 WORD(_start + 4) 295 296 MT_EE_NIC_CONF_0 + 1, 297 WORD(MT_EE_NIC_CONF_1), 298 MT_EE_WIFI_RF_SETTING, 299 MT_EE_TX_POWER_DELTA_BW40, 300 MT_EE_TX_POWER_DELTA_BW80 + 1, 301 MT_EE_TX_POWER_EXT_PA_5G, 302 MT_EE_TEMP_SENSOR_CAL, 303 GROUP_2G(MT_EE_TX_POWER_0_START_2G), 304 GROUP_2G(MT_EE_TX_POWER_1_START_2G), 305 WORD(MT_EE_TX_POWER_CCK), 306 WORD(MT_EE_TX_POWER_OFDM_2G_6M), 307 WORD(MT_EE_TX_POWER_OFDM_2G_24M), 308 WORD(MT_EE_TX_POWER_OFDM_2G_54M), 309 WORD(MT_EE_TX_POWER_HT_BPSK_QPSK), 310 WORD(MT_EE_TX_POWER_HT_16_64_QAM), 311 WORD(MT_EE_TX_POWER_HT_64_QAM), 312 MT_EE_ELAN_RX_MODE_GAIN, 313 MT_EE_ELAN_RX_MODE_NF, 314 MT_EE_ELAN_RX_MODE_P1DB, 315 MT_EE_ELAN_BYPASS_MODE_GAIN, 316 MT_EE_ELAN_BYPASS_MODE_NF, 317 MT_EE_ELAN_BYPASS_MODE_P1DB, 318 WORD(MT_EE_STEP_NUM_NEG_6_7), 319 WORD(MT_EE_STEP_NUM_NEG_4_5), 320 WORD(MT_EE_STEP_NUM_NEG_2_3), 321 WORD(MT_EE_STEP_NUM_NEG_0_1), 322 WORD(MT_EE_REF_STEP_24G), 323 WORD(MT_EE_STEP_NUM_PLUS_1_2), 324 WORD(MT_EE_STEP_NUM_PLUS_3_4), 325 WORD(MT_EE_STEP_NUM_PLUS_5_6), 326 MT_EE_STEP_NUM_PLUS_7, 327 MT_EE_XTAL_FREQ_OFFSET, 328 MT_EE_XTAL_TRIM_2_COMP, 329 MT_EE_XTAL_TRIM_3_COMP, 330 MT_EE_XTAL_WF_RFCAL, 331 332 /* unknown fields below */ 333 WORD(0x24), 334 0x34, 335 0x39, 336 0x3b, 337 WORD(0x42), 338 WORD(0x9e), 339 0xf2, 340 WORD(0xf8), 341 0xfa, 342 0x12e, 343 WORD(0x130), WORD(0x132), WORD(0x134), WORD(0x136), 344 WORD(0x138), WORD(0x13a), WORD(0x13c), WORD(0x13e), 345 346 #undef GROUP_2G 347 #undef WORD 348 349 }; 350 struct req_data { 351 u16 addr; 352 u8 val; 353 u8 pad; 354 } __packed; 355 struct { 356 u8 buffer_mode; 357 u8 len; 358 u8 pad[2]; 359 struct req_data data[255]; 360 } req = { 361 .buffer_mode = 1, 362 .len = ARRAY_SIZE(req_fields) - 1, 363 }; 364 u8 *eep = (u8 *)dev->mt76.eeprom.data; 365 int i; 366 367 BUILD_BUG_ON(ARRAY_SIZE(req_fields) > ARRAY_SIZE(req.data)); 368 369 for (i = 0; i < ARRAY_SIZE(req_fields); i++) { 370 req.data[i].addr = cpu_to_le16(req_fields[i]); 371 req.data[i].val = eep[req_fields[i]]; 372 req.data[i].pad = 0; 373 } 374 375 return __mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD_EFUSE_BUFFER_MODE, 376 &req, sizeof(req), true); 377 } 378 379 static int mt7603_mcu_set_tx_power(struct mt7603_dev *dev) 380 { 381 struct { 382 u8 center_channel; 383 u8 tssi; 384 u8 temp_comp; 385 u8 target_power[2]; 386 u8 rate_power_delta[14]; 387 u8 bw_power_delta; 388 u8 ch_power_delta[6]; 389 u8 temp_comp_power[17]; 390 u8 reserved; 391 } req = { 392 .center_channel = dev->mt76.chandef.chan->hw_value, 393 #define EEP_VAL(n) ((u8 *)dev->mt76.eeprom.data)[n] 394 .tssi = EEP_VAL(MT_EE_NIC_CONF_1 + 1), 395 .temp_comp = EEP_VAL(MT_EE_NIC_CONF_1), 396 .target_power = { 397 EEP_VAL(MT_EE_TX_POWER_0_START_2G + 2), 398 EEP_VAL(MT_EE_TX_POWER_1_START_2G + 2) 399 }, 400 .bw_power_delta = EEP_VAL(MT_EE_TX_POWER_DELTA_BW40), 401 .ch_power_delta = { 402 EEP_VAL(MT_EE_TX_POWER_0_START_2G + 3), 403 EEP_VAL(MT_EE_TX_POWER_0_START_2G + 4), 404 EEP_VAL(MT_EE_TX_POWER_0_START_2G + 5), 405 EEP_VAL(MT_EE_TX_POWER_1_START_2G + 3), 406 EEP_VAL(MT_EE_TX_POWER_1_START_2G + 4), 407 EEP_VAL(MT_EE_TX_POWER_1_START_2G + 5) 408 }, 409 #undef EEP_VAL 410 }; 411 u8 *eep = (u8 *)dev->mt76.eeprom.data; 412 413 memcpy(req.rate_power_delta, eep + MT_EE_TX_POWER_CCK, 414 sizeof(req.rate_power_delta)); 415 416 memcpy(req.temp_comp_power, eep + MT_EE_STEP_NUM_NEG_6_7, 417 sizeof(req.temp_comp_power)); 418 419 return __mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD_SET_TX_POWER_CTRL, 420 &req, sizeof(req), true); 421 } 422 423 int mt7603_mcu_set_channel(struct mt7603_dev *dev) 424 { 425 struct cfg80211_chan_def *chandef = &dev->mt76.chandef; 426 struct ieee80211_hw *hw = mt76_hw(dev); 427 int n_chains = hweight8(dev->mt76.antenna_mask); 428 struct { 429 u8 control_chan; 430 u8 center_chan; 431 u8 bw; 432 u8 tx_streams; 433 u8 rx_streams; 434 u8 _res0[7]; 435 u8 txpower[21]; 436 u8 _res1[3]; 437 } req = { 438 .control_chan = chandef->chan->hw_value, 439 .center_chan = chandef->chan->hw_value, 440 .bw = MT_BW_20, 441 .tx_streams = n_chains, 442 .rx_streams = n_chains, 443 }; 444 s8 tx_power; 445 int i, ret; 446 447 if (dev->mt76.chandef.width == NL80211_CHAN_WIDTH_40) { 448 req.bw = MT_BW_40; 449 if (chandef->center_freq1 > chandef->chan->center_freq) 450 req.center_chan += 2; 451 else 452 req.center_chan -= 2; 453 } 454 455 tx_power = hw->conf.power_level * 2; 456 if (dev->mt76.antenna_mask == 3) 457 tx_power -= 6; 458 tx_power = min(tx_power, dev->tx_power_limit); 459 460 dev->mt76.txpower_cur = tx_power; 461 462 for (i = 0; i < ARRAY_SIZE(req.txpower); i++) 463 req.txpower[i] = tx_power; 464 465 ret = __mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD_CHANNEL_SWITCH, 466 &req, sizeof(req), true); 467 if (ret) 468 return ret; 469 470 return mt7603_mcu_set_tx_power(dev); 471 } 472