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