1 // SPDX-License-Identifier: ISC 2 /* Copyright (C) 2020 MediaTek Inc. */ 3 4 #include <linux/firmware.h> 5 #include <linux/fs.h> 6 #include "mt7921.h" 7 #include "mt7921_trace.h" 8 #include "mcu.h" 9 #include "mac.h" 10 11 struct mt7921_patch_hdr { 12 char build_date[16]; 13 char platform[4]; 14 __be32 hw_sw_ver; 15 __be32 patch_ver; 16 __be16 checksum; 17 u16 reserved; 18 struct { 19 __be32 patch_ver; 20 __be32 subsys; 21 __be32 feature; 22 __be32 n_region; 23 __be32 crc; 24 u32 reserved[11]; 25 } desc; 26 } __packed; 27 28 struct mt7921_patch_sec { 29 __be32 type; 30 __be32 offs; 31 __be32 size; 32 union { 33 __be32 spec[13]; 34 struct { 35 __be32 addr; 36 __be32 len; 37 __be32 sec_key_idx; 38 __be32 align_len; 39 u32 reserved[9]; 40 } info; 41 }; 42 } __packed; 43 44 struct mt7921_fw_trailer { 45 u8 chip_id; 46 u8 eco_code; 47 u8 n_region; 48 u8 format_ver; 49 u8 format_flag; 50 u8 reserved[2]; 51 char fw_ver[10]; 52 char build_date[15]; 53 u32 crc; 54 } __packed; 55 56 struct mt7921_fw_region { 57 __le32 decomp_crc; 58 __le32 decomp_len; 59 __le32 decomp_blk_sz; 60 u8 reserved[4]; 61 __le32 addr; 62 __le32 len; 63 u8 feature_set; 64 u8 reserved1[15]; 65 } __packed; 66 67 #define MT_STA_BFER BIT(0) 68 #define MT_STA_BFEE BIT(1) 69 70 #define FW_FEATURE_SET_ENCRYPT BIT(0) 71 #define FW_FEATURE_SET_KEY_IDX GENMASK(2, 1) 72 #define FW_FEATURE_ENCRY_MODE BIT(4) 73 #define FW_FEATURE_OVERRIDE_ADDR BIT(5) 74 75 #define DL_MODE_ENCRYPT BIT(0) 76 #define DL_MODE_KEY_IDX GENMASK(2, 1) 77 #define DL_MODE_RESET_SEC_IV BIT(3) 78 #define DL_MODE_WORKING_PDA_CR4 BIT(4) 79 #define DL_CONFIG_ENCRY_MODE_SEL BIT(6) 80 #define DL_MODE_NEED_RSP BIT(31) 81 82 #define FW_START_OVERRIDE BIT(0) 83 #define FW_START_WORKING_PDA_CR4 BIT(2) 84 85 #define PATCH_SEC_TYPE_MASK GENMASK(15, 0) 86 #define PATCH_SEC_TYPE_INFO 0x2 87 88 #define to_wcid_lo(id) FIELD_GET(GENMASK(7, 0), (u16)id) 89 #define to_wcid_hi(id) FIELD_GET(GENMASK(9, 8), (u16)id) 90 91 static enum mt7921_cipher_type 92 mt7921_mcu_get_cipher(int cipher) 93 { 94 switch (cipher) { 95 case WLAN_CIPHER_SUITE_WEP40: 96 return MT_CIPHER_WEP40; 97 case WLAN_CIPHER_SUITE_WEP104: 98 return MT_CIPHER_WEP104; 99 case WLAN_CIPHER_SUITE_TKIP: 100 return MT_CIPHER_TKIP; 101 case WLAN_CIPHER_SUITE_AES_CMAC: 102 return MT_CIPHER_BIP_CMAC_128; 103 case WLAN_CIPHER_SUITE_CCMP: 104 return MT_CIPHER_AES_CCMP; 105 case WLAN_CIPHER_SUITE_CCMP_256: 106 return MT_CIPHER_CCMP_256; 107 case WLAN_CIPHER_SUITE_GCMP: 108 return MT_CIPHER_GCMP; 109 case WLAN_CIPHER_SUITE_GCMP_256: 110 return MT_CIPHER_GCMP_256; 111 case WLAN_CIPHER_SUITE_SMS4: 112 return MT_CIPHER_WAPI; 113 default: 114 return MT_CIPHER_NONE; 115 } 116 } 117 118 static u8 mt7921_mcu_chan_bw(struct cfg80211_chan_def *chandef) 119 { 120 static const u8 width_to_bw[] = { 121 [NL80211_CHAN_WIDTH_40] = CMD_CBW_40MHZ, 122 [NL80211_CHAN_WIDTH_80] = CMD_CBW_80MHZ, 123 [NL80211_CHAN_WIDTH_80P80] = CMD_CBW_8080MHZ, 124 [NL80211_CHAN_WIDTH_160] = CMD_CBW_160MHZ, 125 [NL80211_CHAN_WIDTH_5] = CMD_CBW_5MHZ, 126 [NL80211_CHAN_WIDTH_10] = CMD_CBW_10MHZ, 127 [NL80211_CHAN_WIDTH_20] = CMD_CBW_20MHZ, 128 [NL80211_CHAN_WIDTH_20_NOHT] = CMD_CBW_20MHZ, 129 }; 130 131 if (chandef->width >= ARRAY_SIZE(width_to_bw)) 132 return 0; 133 134 return width_to_bw[chandef->width]; 135 } 136 137 static int 138 mt7921_mcu_parse_eeprom(struct mt76_dev *dev, struct sk_buff *skb) 139 { 140 struct mt7921_mcu_eeprom_info *res; 141 u8 *buf; 142 143 if (!skb) 144 return -EINVAL; 145 146 skb_pull(skb, sizeof(struct mt7921_mcu_rxd)); 147 148 res = (struct mt7921_mcu_eeprom_info *)skb->data; 149 buf = dev->eeprom.data + le32_to_cpu(res->addr); 150 memcpy(buf, res->data, 16); 151 152 return 0; 153 } 154 155 static int 156 mt7921_mcu_parse_response(struct mt76_dev *mdev, int cmd, 157 struct sk_buff *skb, int seq) 158 { 159 struct mt7921_mcu_rxd *rxd; 160 int ret = 0; 161 162 if (!skb) { 163 dev_err(mdev->dev, "Message %08x (seq %d) timeout\n", 164 cmd, seq); 165 mt7921_reset(mdev); 166 167 return -ETIMEDOUT; 168 } 169 170 rxd = (struct mt7921_mcu_rxd *)skb->data; 171 if (seq != rxd->seq) 172 return -EAGAIN; 173 174 switch (cmd) { 175 case MCU_CMD_PATCH_SEM_CONTROL: 176 skb_pull(skb, sizeof(*rxd) - 4); 177 ret = *skb->data; 178 break; 179 case MCU_EXT_CMD_GET_TEMP: 180 skb_pull(skb, sizeof(*rxd) + 4); 181 ret = le32_to_cpu(*(__le32 *)skb->data); 182 break; 183 case MCU_EXT_CMD_EFUSE_ACCESS: 184 ret = mt7921_mcu_parse_eeprom(mdev, skb); 185 break; 186 case MCU_UNI_CMD_DEV_INFO_UPDATE: 187 case MCU_UNI_CMD_BSS_INFO_UPDATE: 188 case MCU_UNI_CMD_STA_REC_UPDATE: 189 case MCU_UNI_CMD_HIF_CTRL: 190 case MCU_UNI_CMD_OFFLOAD: 191 case MCU_UNI_CMD_SUSPEND: { 192 struct mt7921_mcu_uni_event *event; 193 194 skb_pull(skb, sizeof(*rxd)); 195 event = (struct mt7921_mcu_uni_event *)skb->data; 196 ret = le32_to_cpu(event->status); 197 break; 198 } 199 case MCU_CMD_REG_READ: { 200 struct mt7921_mcu_reg_event *event; 201 202 skb_pull(skb, sizeof(*rxd)); 203 event = (struct mt7921_mcu_reg_event *)skb->data; 204 ret = (int)le32_to_cpu(event->val); 205 break; 206 } 207 default: 208 skb_pull(skb, sizeof(struct mt7921_mcu_rxd)); 209 break; 210 } 211 212 return ret; 213 } 214 215 static int 216 mt7921_mcu_send_message(struct mt76_dev *mdev, struct sk_buff *skb, 217 int cmd, int *wait_seq) 218 { 219 struct mt7921_dev *dev = container_of(mdev, struct mt7921_dev, mt76); 220 int txd_len, mcu_cmd = cmd & MCU_CMD_MASK; 221 enum mt76_mcuq_id txq = MT_MCUQ_WM; 222 struct mt7921_uni_txd *uni_txd; 223 struct mt7921_mcu_txd *mcu_txd; 224 __le32 *txd; 225 u32 val; 226 u8 seq; 227 228 switch (cmd) { 229 case MCU_UNI_CMD_HIF_CTRL: 230 case MCU_UNI_CMD_SUSPEND: 231 case MCU_UNI_CMD_OFFLOAD: 232 mdev->mcu.timeout = HZ / 3; 233 break; 234 default: 235 mdev->mcu.timeout = 3 * HZ; 236 break; 237 } 238 239 seq = ++dev->mt76.mcu.msg_seq & 0xf; 240 if (!seq) 241 seq = ++dev->mt76.mcu.msg_seq & 0xf; 242 243 if (cmd == MCU_CMD_FW_SCATTER) { 244 txq = MT_MCUQ_FWDL; 245 goto exit; 246 } 247 248 txd_len = cmd & MCU_UNI_PREFIX ? sizeof(*uni_txd) : sizeof(*mcu_txd); 249 txd = (__le32 *)skb_push(skb, txd_len); 250 251 val = FIELD_PREP(MT_TXD0_TX_BYTES, skb->len) | 252 FIELD_PREP(MT_TXD0_PKT_FMT, MT_TX_TYPE_CMD) | 253 FIELD_PREP(MT_TXD0_Q_IDX, MT_TX_MCU_PORT_RX_Q0); 254 txd[0] = cpu_to_le32(val); 255 256 val = MT_TXD1_LONG_FORMAT | 257 FIELD_PREP(MT_TXD1_HDR_FORMAT, MT_HDR_FORMAT_CMD); 258 txd[1] = cpu_to_le32(val); 259 260 if (cmd & MCU_UNI_PREFIX) { 261 uni_txd = (struct mt7921_uni_txd *)txd; 262 uni_txd->len = cpu_to_le16(skb->len - sizeof(uni_txd->txd)); 263 uni_txd->option = MCU_CMD_UNI_EXT_ACK; 264 uni_txd->cid = cpu_to_le16(mcu_cmd); 265 uni_txd->s2d_index = MCU_S2D_H2N; 266 uni_txd->pkt_type = MCU_PKT_ID; 267 uni_txd->seq = seq; 268 269 goto exit; 270 } 271 272 mcu_txd = (struct mt7921_mcu_txd *)txd; 273 mcu_txd->len = cpu_to_le16(skb->len - sizeof(mcu_txd->txd)); 274 mcu_txd->pq_id = cpu_to_le16(MCU_PQ_ID(MT_TX_PORT_IDX_MCU, 275 MT_TX_MCU_PORT_RX_Q0)); 276 mcu_txd->pkt_type = MCU_PKT_ID; 277 mcu_txd->seq = seq; 278 279 switch (cmd & ~MCU_CMD_MASK) { 280 case MCU_FW_PREFIX: 281 mcu_txd->set_query = MCU_Q_NA; 282 mcu_txd->cid = mcu_cmd; 283 break; 284 case MCU_CE_PREFIX: 285 if (cmd & MCU_QUERY_MASK) 286 mcu_txd->set_query = MCU_Q_QUERY; 287 else 288 mcu_txd->set_query = MCU_Q_SET; 289 mcu_txd->cid = mcu_cmd; 290 break; 291 default: 292 mcu_txd->cid = MCU_CMD_EXT_CID; 293 if (cmd & MCU_QUERY_PREFIX || cmd == MCU_EXT_CMD_EFUSE_ACCESS) 294 mcu_txd->set_query = MCU_Q_QUERY; 295 else 296 mcu_txd->set_query = MCU_Q_SET; 297 mcu_txd->ext_cid = mcu_cmd; 298 mcu_txd->ext_cid_ack = 1; 299 break; 300 } 301 302 mcu_txd->s2d_index = MCU_S2D_H2N; 303 WARN_ON(cmd == MCU_EXT_CMD_EFUSE_ACCESS && 304 mcu_txd->set_query != MCU_Q_QUERY); 305 306 exit: 307 if (wait_seq) 308 *wait_seq = seq; 309 310 return mt76_tx_queue_skb_raw(dev, mdev->q_mcu[txq], skb, 0); 311 } 312 313 static void 314 mt7921_mcu_tx_rate_parse(struct mt76_phy *mphy, 315 struct mt7921_mcu_peer_cap *peer, 316 struct rate_info *rate, u16 r) 317 { 318 struct ieee80211_supported_band *sband; 319 u16 flags = 0; 320 u8 txmode = FIELD_GET(MT_WTBL_RATE_TX_MODE, r); 321 u8 gi = 0; 322 u8 bw = 0; 323 324 rate->mcs = FIELD_GET(MT_WTBL_RATE_MCS, r); 325 rate->nss = FIELD_GET(MT_WTBL_RATE_NSS, r) + 1; 326 327 switch (peer->bw) { 328 case IEEE80211_STA_RX_BW_160: 329 gi = peer->g16; 330 break; 331 case IEEE80211_STA_RX_BW_80: 332 gi = peer->g8; 333 break; 334 case IEEE80211_STA_RX_BW_40: 335 gi = peer->g4; 336 break; 337 default: 338 gi = peer->g2; 339 break; 340 } 341 342 gi = txmode >= MT_PHY_TYPE_HE_SU ? 343 FIELD_GET(MT_WTBL_RATE_HE_GI, gi) : 344 FIELD_GET(MT_WTBL_RATE_GI, gi); 345 346 switch (txmode) { 347 case MT_PHY_TYPE_CCK: 348 case MT_PHY_TYPE_OFDM: 349 if (mphy->chandef.chan->band == NL80211_BAND_5GHZ) 350 sband = &mphy->sband_5g.sband; 351 else 352 sband = &mphy->sband_2g.sband; 353 354 rate->legacy = sband->bitrates[rate->mcs].bitrate; 355 break; 356 case MT_PHY_TYPE_HT: 357 case MT_PHY_TYPE_HT_GF: 358 flags |= RATE_INFO_FLAGS_MCS; 359 360 if (gi) 361 flags |= RATE_INFO_FLAGS_SHORT_GI; 362 break; 363 case MT_PHY_TYPE_VHT: 364 flags |= RATE_INFO_FLAGS_VHT_MCS; 365 366 if (gi) 367 flags |= RATE_INFO_FLAGS_SHORT_GI; 368 break; 369 case MT_PHY_TYPE_HE_SU: 370 case MT_PHY_TYPE_HE_EXT_SU: 371 case MT_PHY_TYPE_HE_TB: 372 case MT_PHY_TYPE_HE_MU: 373 rate->he_gi = gi; 374 rate->he_dcm = FIELD_GET(MT_RA_RATE_DCM_EN, r); 375 376 flags |= RATE_INFO_FLAGS_HE_MCS; 377 break; 378 default: 379 break; 380 } 381 rate->flags = flags; 382 383 bw = mt7921_mcu_chan_bw(&mphy->chandef) - FIELD_GET(MT_RA_RATE_BW, r); 384 385 switch (bw) { 386 case IEEE80211_STA_RX_BW_160: 387 rate->bw = RATE_INFO_BW_160; 388 break; 389 case IEEE80211_STA_RX_BW_80: 390 rate->bw = RATE_INFO_BW_80; 391 break; 392 case IEEE80211_STA_RX_BW_40: 393 rate->bw = RATE_INFO_BW_40; 394 break; 395 default: 396 rate->bw = RATE_INFO_BW_20; 397 break; 398 } 399 } 400 401 static void 402 mt7921_mcu_tx_rate_report(struct mt7921_dev *dev, struct sk_buff *skb, 403 u16 wlan_idx) 404 { 405 struct mt7921_mcu_wlan_info_event *wtbl_info; 406 struct mt76_phy *mphy = &dev->mphy; 407 struct mt7921_sta_stats *stats; 408 struct rate_info rate = {}; 409 struct mt7921_sta *msta; 410 struct mt76_wcid *wcid; 411 u8 idx; 412 413 if (wlan_idx >= MT76_N_WCIDS) 414 return; 415 416 wtbl_info = (struct mt7921_mcu_wlan_info_event *)skb->data; 417 idx = wtbl_info->rate_info.rate_idx; 418 if (idx >= ARRAY_SIZE(wtbl_info->rate_info.rate)) 419 return; 420 421 rcu_read_lock(); 422 423 wcid = rcu_dereference(dev->mt76.wcid[wlan_idx]); 424 if (!wcid) 425 goto out; 426 427 msta = container_of(wcid, struct mt7921_sta, wcid); 428 stats = &msta->stats; 429 430 /* current rate */ 431 mt7921_mcu_tx_rate_parse(mphy, &wtbl_info->peer_cap, &rate, 432 le16_to_cpu(wtbl_info->rate_info.rate[idx])); 433 stats->tx_rate = rate; 434 out: 435 rcu_read_unlock(); 436 } 437 438 static void 439 mt7921_mcu_scan_event(struct mt7921_dev *dev, struct sk_buff *skb) 440 { 441 struct mt76_phy *mphy = &dev->mt76.phy; 442 struct mt7921_phy *phy = (struct mt7921_phy *)mphy->priv; 443 444 spin_lock_bh(&dev->mt76.lock); 445 __skb_queue_tail(&phy->scan_event_list, skb); 446 spin_unlock_bh(&dev->mt76.lock); 447 448 ieee80211_queue_delayed_work(mphy->hw, &phy->scan_work, 449 MT7921_HW_SCAN_TIMEOUT); 450 } 451 452 static void 453 mt7921_mcu_beacon_loss_event(struct mt7921_dev *dev, struct sk_buff *skb) 454 { 455 struct mt76_connac_beacon_loss_event *event; 456 struct mt76_phy *mphy; 457 u8 band_idx = 0; /* DBDC support */ 458 459 skb_pull(skb, sizeof(struct mt7921_mcu_rxd)); 460 event = (struct mt76_connac_beacon_loss_event *)skb->data; 461 if (band_idx && dev->mt76.phy2) 462 mphy = dev->mt76.phy2; 463 else 464 mphy = &dev->mt76.phy; 465 466 ieee80211_iterate_active_interfaces_atomic(mphy->hw, 467 IEEE80211_IFACE_ITER_RESUME_ALL, 468 mt76_connac_mcu_beacon_loss_iter, event); 469 } 470 471 static void 472 mt7921_mcu_bss_event(struct mt7921_dev *dev, struct sk_buff *skb) 473 { 474 struct mt76_phy *mphy = &dev->mt76.phy; 475 struct mt76_connac_mcu_bss_event *event; 476 477 skb_pull(skb, sizeof(struct mt7921_mcu_rxd)); 478 event = (struct mt76_connac_mcu_bss_event *)skb->data; 479 if (event->is_absent) 480 ieee80211_stop_queues(mphy->hw); 481 else 482 ieee80211_wake_queues(mphy->hw); 483 } 484 485 static void 486 mt7921_mcu_debug_msg_event(struct mt7921_dev *dev, struct sk_buff *skb) 487 { 488 struct mt7921_debug_msg { 489 __le16 id; 490 u8 type; 491 u8 flag; 492 __le32 value; 493 __le16 len; 494 u8 content[512]; 495 } __packed * msg; 496 497 skb_pull(skb, sizeof(struct mt7921_mcu_rxd)); 498 msg = (struct mt7921_debug_msg *)skb->data; 499 500 if (msg->type == 3) { /* fw log */ 501 u16 len = min_t(u16, le16_to_cpu(msg->len), 512); 502 int i; 503 504 for (i = 0 ; i < len; i++) { 505 if (!msg->content[i]) 506 msg->content[i] = ' '; 507 } 508 wiphy_info(mt76_hw(dev)->wiphy, "%.*s", len, msg->content); 509 } 510 } 511 512 static void 513 mt7921_mcu_low_power_event(struct mt7921_dev *dev, struct sk_buff *skb) 514 { 515 struct mt7921_mcu_lp_event { 516 u8 state; 517 u8 reserved[3]; 518 } __packed * event; 519 520 skb_pull(skb, sizeof(struct mt7921_mcu_rxd)); 521 event = (struct mt7921_mcu_lp_event *)skb->data; 522 523 trace_lp_event(dev, event->state); 524 } 525 526 static void 527 mt7921_mcu_rx_unsolicited_event(struct mt7921_dev *dev, struct sk_buff *skb) 528 { 529 struct mt7921_mcu_rxd *rxd = (struct mt7921_mcu_rxd *)skb->data; 530 531 switch (rxd->eid) { 532 case MCU_EVENT_BSS_BEACON_LOSS: 533 mt7921_mcu_beacon_loss_event(dev, skb); 534 break; 535 case MCU_EVENT_SCHED_SCAN_DONE: 536 case MCU_EVENT_SCAN_DONE: 537 mt7921_mcu_scan_event(dev, skb); 538 return; 539 case MCU_EVENT_BSS_ABSENCE: 540 mt7921_mcu_bss_event(dev, skb); 541 break; 542 case MCU_EVENT_DBG_MSG: 543 mt7921_mcu_debug_msg_event(dev, skb); 544 break; 545 case MCU_EVENT_COREDUMP: 546 mt76_connac_mcu_coredump_event(&dev->mt76, skb, 547 &dev->coredump); 548 return; 549 case MCU_EVENT_LP_INFO: 550 mt7921_mcu_low_power_event(dev, skb); 551 break; 552 default: 553 break; 554 } 555 dev_kfree_skb(skb); 556 } 557 558 void mt7921_mcu_rx_event(struct mt7921_dev *dev, struct sk_buff *skb) 559 { 560 struct mt7921_mcu_rxd *rxd = (struct mt7921_mcu_rxd *)skb->data; 561 562 if (rxd->eid == 0x6) { 563 mt76_mcu_rx_event(&dev->mt76, skb); 564 return; 565 } 566 567 if (rxd->ext_eid == MCU_EXT_EVENT_RATE_REPORT || 568 rxd->eid == MCU_EVENT_BSS_BEACON_LOSS || 569 rxd->eid == MCU_EVENT_SCHED_SCAN_DONE || 570 rxd->eid == MCU_EVENT_BSS_ABSENCE || 571 rxd->eid == MCU_EVENT_SCAN_DONE || 572 rxd->eid == MCU_EVENT_DBG_MSG || 573 rxd->eid == MCU_EVENT_COREDUMP || 574 rxd->eid == MCU_EVENT_LP_INFO || 575 !rxd->seq) 576 mt7921_mcu_rx_unsolicited_event(dev, skb); 577 else 578 mt76_mcu_rx_event(&dev->mt76, skb); 579 } 580 581 /** starec & wtbl **/ 582 static int 583 mt7921_mcu_sta_key_tlv(struct mt7921_sta *msta, struct sk_buff *skb, 584 struct ieee80211_key_conf *key, enum set_key_cmd cmd) 585 { 586 struct mt7921_sta_key_conf *bip = &msta->bip; 587 struct sta_rec_sec *sec; 588 struct tlv *tlv; 589 u32 len = sizeof(*sec); 590 591 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_KEY_V2, sizeof(*sec)); 592 593 sec = (struct sta_rec_sec *)tlv; 594 sec->add = cmd; 595 596 if (cmd == SET_KEY) { 597 struct sec_key *sec_key; 598 u8 cipher; 599 600 cipher = mt7921_mcu_get_cipher(key->cipher); 601 if (cipher == MT_CIPHER_NONE) 602 return -EOPNOTSUPP; 603 604 sec_key = &sec->key[0]; 605 sec_key->cipher_len = sizeof(*sec_key); 606 607 if (cipher == MT_CIPHER_BIP_CMAC_128) { 608 sec_key->cipher_id = MT_CIPHER_AES_CCMP; 609 sec_key->key_id = bip->keyidx; 610 sec_key->key_len = 16; 611 memcpy(sec_key->key, bip->key, 16); 612 613 sec_key = &sec->key[1]; 614 sec_key->cipher_id = MT_CIPHER_BIP_CMAC_128; 615 sec_key->cipher_len = sizeof(*sec_key); 616 sec_key->key_len = 16; 617 memcpy(sec_key->key, key->key, 16); 618 619 sec->n_cipher = 2; 620 } else { 621 sec_key->cipher_id = cipher; 622 sec_key->key_id = key->keyidx; 623 sec_key->key_len = key->keylen; 624 memcpy(sec_key->key, key->key, key->keylen); 625 626 if (cipher == MT_CIPHER_TKIP) { 627 /* Rx/Tx MIC keys are swapped */ 628 memcpy(sec_key->key + 16, key->key + 24, 8); 629 memcpy(sec_key->key + 24, key->key + 16, 8); 630 } 631 632 /* store key_conf for BIP batch update */ 633 if (cipher == MT_CIPHER_AES_CCMP) { 634 memcpy(bip->key, key->key, key->keylen); 635 bip->keyidx = key->keyidx; 636 } 637 638 len -= sizeof(*sec_key); 639 sec->n_cipher = 1; 640 } 641 } else { 642 len -= sizeof(sec->key); 643 sec->n_cipher = 0; 644 } 645 sec->len = cpu_to_le16(len); 646 647 return 0; 648 } 649 650 int mt7921_mcu_add_key(struct mt7921_dev *dev, struct ieee80211_vif *vif, 651 struct mt7921_sta *msta, struct ieee80211_key_conf *key, 652 enum set_key_cmd cmd) 653 { 654 struct mt7921_vif *mvif = (struct mt7921_vif *)vif->drv_priv; 655 struct sk_buff *skb; 656 int ret; 657 658 skb = mt76_connac_mcu_alloc_sta_req(&dev->mt76, &mvif->mt76, 659 &msta->wcid); 660 if (IS_ERR(skb)) 661 return PTR_ERR(skb); 662 663 ret = mt7921_mcu_sta_key_tlv(msta, skb, key, cmd); 664 if (ret) 665 return ret; 666 667 return mt76_mcu_skb_send_msg(&dev->mt76, skb, 668 MCU_UNI_CMD_STA_REC_UPDATE, true); 669 } 670 671 int mt7921_mcu_uni_tx_ba(struct mt7921_dev *dev, 672 struct ieee80211_ampdu_params *params, 673 bool enable) 674 { 675 struct mt7921_sta *msta = (struct mt7921_sta *)params->sta->drv_priv; 676 677 if (enable && !params->amsdu) 678 msta->wcid.amsdu = false; 679 680 return mt76_connac_mcu_sta_ba(&dev->mt76, &msta->vif->mt76, params, 681 enable, true); 682 } 683 684 int mt7921_mcu_uni_rx_ba(struct mt7921_dev *dev, 685 struct ieee80211_ampdu_params *params, 686 bool enable) 687 { 688 struct mt7921_sta *msta = (struct mt7921_sta *)params->sta->drv_priv; 689 690 return mt76_connac_mcu_sta_ba(&dev->mt76, &msta->vif->mt76, params, 691 enable, false); 692 } 693 694 static int mt7921_mcu_restart(struct mt76_dev *dev) 695 { 696 struct { 697 u8 power_mode; 698 u8 rsv[3]; 699 } req = { 700 .power_mode = 1, 701 }; 702 703 return mt76_mcu_send_msg(dev, MCU_CMD_NIC_POWER_CTRL, &req, 704 sizeof(req), false); 705 } 706 707 static int mt7921_driver_own(struct mt7921_dev *dev) 708 { 709 u32 reg = mt7921_reg_map_l1(dev, MT_TOP_LPCR_HOST_BAND0); 710 711 mt76_wr(dev, reg, MT_TOP_LPCR_HOST_DRV_OWN); 712 if (!mt76_poll_msec(dev, reg, MT_TOP_LPCR_HOST_FW_OWN, 713 0, 500)) { 714 dev_err(dev->mt76.dev, "Timeout for driver own\n"); 715 return -EIO; 716 } 717 718 return 0; 719 } 720 721 static int mt7921_load_patch(struct mt7921_dev *dev) 722 { 723 const struct mt7921_patch_hdr *hdr; 724 const struct firmware *fw = NULL; 725 int i, ret, sem; 726 727 sem = mt76_connac_mcu_patch_sem_ctrl(&dev->mt76, true); 728 switch (sem) { 729 case PATCH_IS_DL: 730 return 0; 731 case PATCH_NOT_DL_SEM_SUCCESS: 732 break; 733 default: 734 dev_err(dev->mt76.dev, "Failed to get patch semaphore\n"); 735 return -EAGAIN; 736 } 737 738 ret = request_firmware(&fw, MT7921_ROM_PATCH, dev->mt76.dev); 739 if (ret) 740 goto out; 741 742 if (!fw || !fw->data || fw->size < sizeof(*hdr)) { 743 dev_err(dev->mt76.dev, "Invalid firmware\n"); 744 ret = -EINVAL; 745 goto out; 746 } 747 748 hdr = (const struct mt7921_patch_hdr *)(fw->data); 749 750 dev_info(dev->mt76.dev, "HW/SW Version: 0x%x, Build Time: %.16s\n", 751 be32_to_cpu(hdr->hw_sw_ver), hdr->build_date); 752 753 for (i = 0; i < be32_to_cpu(hdr->desc.n_region); i++) { 754 struct mt7921_patch_sec *sec; 755 const u8 *dl; 756 u32 len, addr; 757 758 sec = (struct mt7921_patch_sec *)(fw->data + sizeof(*hdr) + 759 i * sizeof(*sec)); 760 if ((be32_to_cpu(sec->type) & PATCH_SEC_TYPE_MASK) != 761 PATCH_SEC_TYPE_INFO) { 762 ret = -EINVAL; 763 goto out; 764 } 765 766 addr = be32_to_cpu(sec->info.addr); 767 len = be32_to_cpu(sec->info.len); 768 dl = fw->data + be32_to_cpu(sec->offs); 769 770 ret = mt76_connac_mcu_init_download(&dev->mt76, addr, len, 771 DL_MODE_NEED_RSP); 772 if (ret) { 773 dev_err(dev->mt76.dev, "Download request failed\n"); 774 goto out; 775 } 776 777 ret = mt76_mcu_send_firmware(&dev->mt76, MCU_CMD_FW_SCATTER, 778 dl, len); 779 if (ret) { 780 dev_err(dev->mt76.dev, "Failed to send patch\n"); 781 goto out; 782 } 783 } 784 785 ret = mt76_connac_mcu_start_patch(&dev->mt76); 786 if (ret) 787 dev_err(dev->mt76.dev, "Failed to start patch\n"); 788 789 out: 790 sem = mt76_connac_mcu_patch_sem_ctrl(&dev->mt76, false); 791 switch (sem) { 792 case PATCH_REL_SEM_SUCCESS: 793 break; 794 default: 795 ret = -EAGAIN; 796 dev_err(dev->mt76.dev, "Failed to release patch semaphore\n"); 797 goto out; 798 } 799 release_firmware(fw); 800 801 return ret; 802 } 803 804 static u32 mt7921_mcu_gen_dl_mode(u8 feature_set, bool is_wa) 805 { 806 u32 ret = 0; 807 808 ret |= (feature_set & FW_FEATURE_SET_ENCRYPT) ? 809 (DL_MODE_ENCRYPT | DL_MODE_RESET_SEC_IV) : 0; 810 ret |= (feature_set & FW_FEATURE_ENCRY_MODE) ? 811 DL_CONFIG_ENCRY_MODE_SEL : 0; 812 ret |= FIELD_PREP(DL_MODE_KEY_IDX, 813 FIELD_GET(FW_FEATURE_SET_KEY_IDX, feature_set)); 814 ret |= DL_MODE_NEED_RSP; 815 ret |= is_wa ? DL_MODE_WORKING_PDA_CR4 : 0; 816 817 return ret; 818 } 819 820 static int 821 mt7921_mcu_send_ram_firmware(struct mt7921_dev *dev, 822 const struct mt7921_fw_trailer *hdr, 823 const u8 *data, bool is_wa) 824 { 825 int i, offset = 0; 826 u32 override = 0, option = 0; 827 828 for (i = 0; i < hdr->n_region; i++) { 829 const struct mt7921_fw_region *region; 830 int err; 831 u32 len, addr, mode; 832 833 region = (const struct mt7921_fw_region *)((const u8 *)hdr - 834 (hdr->n_region - i) * sizeof(*region)); 835 mode = mt7921_mcu_gen_dl_mode(region->feature_set, is_wa); 836 len = le32_to_cpu(region->len); 837 addr = le32_to_cpu(region->addr); 838 839 if (region->feature_set & FW_FEATURE_OVERRIDE_ADDR) 840 override = addr; 841 842 err = mt76_connac_mcu_init_download(&dev->mt76, addr, len, 843 mode); 844 if (err) { 845 dev_err(dev->mt76.dev, "Download request failed\n"); 846 return err; 847 } 848 849 err = mt76_mcu_send_firmware(&dev->mt76, MCU_CMD_FW_SCATTER, 850 data + offset, len); 851 if (err) { 852 dev_err(dev->mt76.dev, "Failed to send firmware.\n"); 853 return err; 854 } 855 856 offset += len; 857 } 858 859 if (override) 860 option |= FW_START_OVERRIDE; 861 862 if (is_wa) 863 option |= FW_START_WORKING_PDA_CR4; 864 865 return mt76_connac_mcu_start_firmware(&dev->mt76, override, option); 866 } 867 868 static int mt7921_load_ram(struct mt7921_dev *dev) 869 { 870 const struct mt7921_fw_trailer *hdr; 871 const struct firmware *fw; 872 int ret; 873 874 ret = request_firmware(&fw, MT7921_FIRMWARE_WM, dev->mt76.dev); 875 if (ret) 876 return ret; 877 878 if (!fw || !fw->data || fw->size < sizeof(*hdr)) { 879 dev_err(dev->mt76.dev, "Invalid firmware\n"); 880 ret = -EINVAL; 881 goto out; 882 } 883 884 hdr = (const struct mt7921_fw_trailer *)(fw->data + fw->size - 885 sizeof(*hdr)); 886 887 dev_info(dev->mt76.dev, "WM Firmware Version: %.10s, Build Time: %.15s\n", 888 hdr->fw_ver, hdr->build_date); 889 890 ret = mt7921_mcu_send_ram_firmware(dev, hdr, fw->data, false); 891 if (ret) { 892 dev_err(dev->mt76.dev, "Failed to start WM firmware\n"); 893 goto out; 894 } 895 896 snprintf(dev->mt76.hw->wiphy->fw_version, 897 sizeof(dev->mt76.hw->wiphy->fw_version), 898 "%.10s-%.15s", hdr->fw_ver, hdr->build_date); 899 900 out: 901 release_firmware(fw); 902 903 return ret; 904 } 905 906 static int mt7921_load_firmware(struct mt7921_dev *dev) 907 { 908 int ret; 909 910 ret = mt76_get_field(dev, MT_CONN_ON_MISC, MT_TOP_MISC2_FW_N9_RDY); 911 if (ret) { 912 dev_dbg(dev->mt76.dev, "Firmware is already download\n"); 913 return -EIO; 914 } 915 916 ret = mt7921_load_patch(dev); 917 if (ret) 918 return ret; 919 920 ret = mt7921_load_ram(dev); 921 if (ret) 922 return ret; 923 924 if (!mt76_poll_msec(dev, MT_CONN_ON_MISC, MT_TOP_MISC2_FW_N9_RDY, 925 MT_TOP_MISC2_FW_N9_RDY, 1500)) { 926 dev_err(dev->mt76.dev, "Timeout for initializing firmware\n"); 927 928 return -EIO; 929 } 930 931 mt76_queue_tx_cleanup(dev, dev->mt76.q_mcu[MT_MCUQ_FWDL], false); 932 933 #ifdef CONFIG_PM 934 dev->mt76.hw->wiphy->wowlan = &mt76_connac_wowlan_support; 935 #endif /* CONFIG_PM */ 936 937 clear_bit(MT76_STATE_PM, &dev->mphy.state); 938 939 dev_err(dev->mt76.dev, "Firmware init done\n"); 940 941 return 0; 942 } 943 944 int mt7921_mcu_fw_log_2_host(struct mt7921_dev *dev, u8 ctrl) 945 { 946 struct { 947 u8 ctrl_val; 948 u8 pad[3]; 949 } data = { 950 .ctrl_val = ctrl 951 }; 952 953 return mt76_mcu_send_msg(&dev->mt76, MCU_CMD_FWLOG_2_HOST, &data, 954 sizeof(data), false); 955 } 956 957 int mt7921_run_firmware(struct mt7921_dev *dev) 958 { 959 int err; 960 961 err = mt7921_driver_own(dev); 962 if (err) 963 return err; 964 965 err = mt7921_load_firmware(dev); 966 if (err) 967 return err; 968 969 set_bit(MT76_STATE_MCU_RUNNING, &dev->mphy.state); 970 mt7921_mcu_fw_log_2_host(dev, 1); 971 972 return 0; 973 } 974 975 int mt7921_mcu_init(struct mt7921_dev *dev) 976 { 977 static const struct mt76_mcu_ops mt7921_mcu_ops = { 978 .headroom = sizeof(struct mt7921_mcu_txd), 979 .mcu_skb_send_msg = mt7921_mcu_send_message, 980 .mcu_parse_response = mt7921_mcu_parse_response, 981 .mcu_restart = mt7921_mcu_restart, 982 }; 983 984 dev->mt76.mcu_ops = &mt7921_mcu_ops; 985 986 return mt7921_run_firmware(dev); 987 } 988 989 void mt7921_mcu_exit(struct mt7921_dev *dev) 990 { 991 mt7921_wfsys_reset(dev); 992 skb_queue_purge(&dev->mt76.mcu.res_q); 993 } 994 995 int mt7921_mcu_set_tx(struct mt7921_dev *dev, struct ieee80211_vif *vif) 996 { 997 #define WMM_AIFS_SET BIT(0) 998 #define WMM_CW_MIN_SET BIT(1) 999 #define WMM_CW_MAX_SET BIT(2) 1000 #define WMM_TXOP_SET BIT(3) 1001 #define WMM_PARAM_SET GENMASK(3, 0) 1002 #define TX_CMD_MODE 1 1003 struct edca { 1004 u8 queue; 1005 u8 set; 1006 u8 aifs; 1007 u8 cw_min; 1008 __le16 cw_max; 1009 __le16 txop; 1010 }; 1011 struct mt7921_mcu_tx { 1012 u8 total; 1013 u8 action; 1014 u8 valid; 1015 u8 mode; 1016 1017 struct edca edca[IEEE80211_NUM_ACS]; 1018 } __packed req = { 1019 .valid = true, 1020 .mode = TX_CMD_MODE, 1021 .total = IEEE80211_NUM_ACS, 1022 }; 1023 struct mt7921_vif *mvif = (struct mt7921_vif *)vif->drv_priv; 1024 int ac; 1025 1026 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) { 1027 struct ieee80211_tx_queue_params *q = &mvif->queue_params[ac]; 1028 struct edca *e = &req.edca[ac]; 1029 1030 e->set = WMM_PARAM_SET; 1031 e->queue = ac + mvif->mt76.wmm_idx * MT7921_MAX_WMM_SETS; 1032 e->aifs = q->aifs; 1033 e->txop = cpu_to_le16(q->txop); 1034 1035 if (q->cw_min) 1036 e->cw_min = fls(q->cw_min); 1037 else 1038 e->cw_min = 5; 1039 1040 if (q->cw_max) 1041 e->cw_max = cpu_to_le16(fls(q->cw_max)); 1042 else 1043 e->cw_max = cpu_to_le16(10); 1044 } 1045 return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD_EDCA_UPDATE, &req, 1046 sizeof(req), true); 1047 } 1048 1049 int mt7921_mcu_set_chan_info(struct mt7921_phy *phy, int cmd) 1050 { 1051 struct mt7921_dev *dev = phy->dev; 1052 struct cfg80211_chan_def *chandef = &phy->mt76->chandef; 1053 int freq1 = chandef->center_freq1; 1054 struct { 1055 u8 control_ch; 1056 u8 center_ch; 1057 u8 bw; 1058 u8 tx_streams_num; 1059 u8 rx_streams; /* mask or num */ 1060 u8 switch_reason; 1061 u8 band_idx; 1062 u8 center_ch2; /* for 80+80 only */ 1063 __le16 cac_case; 1064 u8 channel_band; 1065 u8 rsv0; 1066 __le32 outband_freq; 1067 u8 txpower_drop; 1068 u8 ap_bw; 1069 u8 ap_center_ch; 1070 u8 rsv1[57]; 1071 } __packed req = { 1072 .control_ch = chandef->chan->hw_value, 1073 .center_ch = ieee80211_frequency_to_channel(freq1), 1074 .bw = mt7921_mcu_chan_bw(chandef), 1075 .tx_streams_num = hweight8(phy->mt76->antenna_mask), 1076 .rx_streams = phy->mt76->antenna_mask, 1077 .band_idx = phy != &dev->phy, 1078 .channel_band = chandef->chan->band, 1079 }; 1080 1081 if (dev->mt76.hw->conf.flags & IEEE80211_CONF_OFFCHANNEL) 1082 req.switch_reason = CH_SWITCH_SCAN_BYPASS_DPD; 1083 else if ((chandef->chan->flags & IEEE80211_CHAN_RADAR) && 1084 chandef->chan->dfs_state != NL80211_DFS_AVAILABLE) 1085 req.switch_reason = CH_SWITCH_DFS; 1086 else 1087 req.switch_reason = CH_SWITCH_NORMAL; 1088 1089 if (cmd == MCU_EXT_CMD_CHANNEL_SWITCH) 1090 req.rx_streams = hweight8(req.rx_streams); 1091 1092 if (chandef->width == NL80211_CHAN_WIDTH_80P80) { 1093 int freq2 = chandef->center_freq2; 1094 1095 req.center_ch2 = ieee80211_frequency_to_channel(freq2); 1096 } 1097 1098 return mt76_mcu_send_msg(&dev->mt76, cmd, &req, sizeof(req), true); 1099 } 1100 1101 int mt7921_mcu_set_eeprom(struct mt7921_dev *dev) 1102 { 1103 struct req_hdr { 1104 u8 buffer_mode; 1105 u8 format; 1106 __le16 len; 1107 } __packed req = { 1108 .buffer_mode = EE_MODE_EFUSE, 1109 .format = EE_FORMAT_WHOLE, 1110 }; 1111 1112 return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD_EFUSE_BUFFER_MODE, 1113 &req, sizeof(req), true); 1114 } 1115 1116 int mt7921_mcu_get_eeprom(struct mt7921_dev *dev, u32 offset) 1117 { 1118 struct mt7921_mcu_eeprom_info req = { 1119 .addr = cpu_to_le32(round_down(offset, 16)), 1120 }; 1121 struct mt7921_mcu_eeprom_info *res; 1122 struct sk_buff *skb; 1123 int ret; 1124 u8 *buf; 1125 1126 ret = mt76_mcu_send_and_get_msg(&dev->mt76, MCU_EXT_CMD_EFUSE_ACCESS, &req, 1127 sizeof(req), true, &skb); 1128 if (ret) 1129 return ret; 1130 1131 res = (struct mt7921_mcu_eeprom_info *)skb->data; 1132 buf = dev->mt76.eeprom.data + le32_to_cpu(res->addr); 1133 memcpy(buf, res->data, 16); 1134 dev_kfree_skb(skb); 1135 1136 return 0; 1137 } 1138 1139 u32 mt7921_get_wtbl_info(struct mt7921_dev *dev, u32 wlan_idx) 1140 { 1141 struct mt7921_mcu_wlan_info wtbl_info = { 1142 .wlan_idx = cpu_to_le32(wlan_idx), 1143 }; 1144 struct sk_buff *skb; 1145 int ret; 1146 1147 ret = mt76_mcu_send_and_get_msg(&dev->mt76, MCU_CMD_GET_WTBL, 1148 &wtbl_info, sizeof(wtbl_info), true, 1149 &skb); 1150 if (ret) 1151 return ret; 1152 1153 mt7921_mcu_tx_rate_report(dev, skb, wlan_idx); 1154 dev_kfree_skb(skb); 1155 1156 return 0; 1157 } 1158 1159 int mt7921_mcu_uni_bss_ps(struct mt7921_dev *dev, struct ieee80211_vif *vif) 1160 { 1161 struct mt7921_vif *mvif = (struct mt7921_vif *)vif->drv_priv; 1162 struct { 1163 struct { 1164 u8 bss_idx; 1165 u8 pad[3]; 1166 } __packed hdr; 1167 struct ps_tlv { 1168 __le16 tag; 1169 __le16 len; 1170 u8 ps_state; /* 0: device awake 1171 * 1: static power save 1172 * 2: dynamic power saving 1173 * 3: enter TWT power saving 1174 * 4: leave TWT power saving 1175 */ 1176 u8 pad[3]; 1177 } __packed ps; 1178 } __packed ps_req = { 1179 .hdr = { 1180 .bss_idx = mvif->mt76.idx, 1181 }, 1182 .ps = { 1183 .tag = cpu_to_le16(UNI_BSS_INFO_PS), 1184 .len = cpu_to_le16(sizeof(struct ps_tlv)), 1185 .ps_state = vif->bss_conf.ps ? 2 : 0, 1186 }, 1187 }; 1188 1189 if (vif->type != NL80211_IFTYPE_STATION) 1190 return -EOPNOTSUPP; 1191 1192 return mt76_mcu_send_msg(&dev->mt76, MCU_UNI_CMD_BSS_INFO_UPDATE, 1193 &ps_req, sizeof(ps_req), true); 1194 } 1195 1196 int mt7921_mcu_uni_bss_bcnft(struct mt7921_dev *dev, struct ieee80211_vif *vif, 1197 bool enable) 1198 { 1199 struct mt7921_vif *mvif = (struct mt7921_vif *)vif->drv_priv; 1200 struct { 1201 struct { 1202 u8 bss_idx; 1203 u8 pad[3]; 1204 } __packed hdr; 1205 struct bcnft_tlv { 1206 __le16 tag; 1207 __le16 len; 1208 __le16 bcn_interval; 1209 u8 dtim_period; 1210 u8 pad; 1211 } __packed bcnft; 1212 } __packed bcnft_req = { 1213 .hdr = { 1214 .bss_idx = mvif->mt76.idx, 1215 }, 1216 .bcnft = { 1217 .tag = cpu_to_le16(UNI_BSS_INFO_BCNFT), 1218 .len = cpu_to_le16(sizeof(struct bcnft_tlv)), 1219 .bcn_interval = cpu_to_le16(vif->bss_conf.beacon_int), 1220 .dtim_period = vif->bss_conf.dtim_period, 1221 }, 1222 }; 1223 1224 if (vif->type != NL80211_IFTYPE_STATION) 1225 return 0; 1226 1227 return mt76_mcu_send_msg(&dev->mt76, MCU_UNI_CMD_BSS_INFO_UPDATE, 1228 &bcnft_req, sizeof(bcnft_req), true); 1229 } 1230 1231 int mt7921_mcu_set_bss_pm(struct mt7921_dev *dev, struct ieee80211_vif *vif, 1232 bool enable) 1233 { 1234 struct mt7921_vif *mvif = (struct mt7921_vif *)vif->drv_priv; 1235 struct { 1236 u8 bss_idx; 1237 u8 dtim_period; 1238 __le16 aid; 1239 __le16 bcn_interval; 1240 __le16 atim_window; 1241 u8 uapsd; 1242 u8 bmc_delivered_ac; 1243 u8 bmc_triggered_ac; 1244 u8 pad; 1245 } req = { 1246 .bss_idx = mvif->mt76.idx, 1247 .aid = cpu_to_le16(vif->bss_conf.aid), 1248 .dtim_period = vif->bss_conf.dtim_period, 1249 .bcn_interval = cpu_to_le16(vif->bss_conf.beacon_int), 1250 }; 1251 struct { 1252 u8 bss_idx; 1253 u8 pad[3]; 1254 } req_hdr = { 1255 .bss_idx = mvif->mt76.idx, 1256 }; 1257 int err; 1258 1259 if (vif->type != NL80211_IFTYPE_STATION) 1260 return 0; 1261 1262 err = mt76_mcu_send_msg(&dev->mt76, MCU_CMD_SET_BSS_ABORT, &req_hdr, 1263 sizeof(req_hdr), false); 1264 if (err < 0 || !enable) 1265 return err; 1266 1267 return mt76_mcu_send_msg(&dev->mt76, MCU_CMD_SET_BSS_CONNECTED, &req, 1268 sizeof(req), false); 1269 } 1270 1271 int mt7921_mcu_sta_add(struct mt7921_dev *dev, struct ieee80211_sta *sta, 1272 struct ieee80211_vif *vif, bool enable) 1273 { 1274 struct mt7921_vif *mvif = (struct mt7921_vif *)vif->drv_priv; 1275 int rssi = -ewma_rssi_read(&mvif->rssi); 1276 struct mt76_sta_cmd_info info = { 1277 .sta = sta, 1278 .vif = vif, 1279 .enable = enable, 1280 .cmd = MCU_UNI_CMD_STA_REC_UPDATE, 1281 .rcpi = to_rcpi(rssi), 1282 }; 1283 struct mt7921_sta *msta; 1284 1285 msta = sta ? (struct mt7921_sta *)sta->drv_priv : NULL; 1286 info.wcid = msta ? &msta->wcid : &mvif->sta.wcid; 1287 1288 return mt76_connac_mcu_add_sta_cmd(&dev->mphy, &info); 1289 } 1290 1291 int mt7921_mcu_drv_pmctrl(struct mt7921_dev *dev) 1292 { 1293 struct mt76_phy *mphy = &dev->mt76.phy; 1294 struct mt76_connac_pm *pm = &dev->pm; 1295 int i, err = 0; 1296 1297 mutex_lock(&pm->mutex); 1298 1299 if (!test_bit(MT76_STATE_PM, &mphy->state)) 1300 goto out; 1301 1302 for (i = 0; i < MT7921_DRV_OWN_RETRY_COUNT; i++) { 1303 mt76_wr(dev, MT_CONN_ON_LPCTL, PCIE_LPCR_HOST_CLR_OWN); 1304 if (mt76_poll_msec(dev, MT_CONN_ON_LPCTL, 1305 PCIE_LPCR_HOST_OWN_SYNC, 0, 50)) 1306 break; 1307 } 1308 1309 if (i == MT7921_DRV_OWN_RETRY_COUNT) { 1310 dev_err(dev->mt76.dev, "driver own failed\n"); 1311 err = -EIO; 1312 goto out; 1313 } 1314 1315 mt7921_wpdma_reinit_cond(dev); 1316 clear_bit(MT76_STATE_PM, &mphy->state); 1317 1318 pm->stats.last_wake_event = jiffies; 1319 pm->stats.doze_time += pm->stats.last_wake_event - 1320 pm->stats.last_doze_event; 1321 out: 1322 mutex_unlock(&pm->mutex); 1323 1324 if (err) 1325 mt7921_reset(&dev->mt76); 1326 1327 return err; 1328 } 1329 1330 int mt7921_mcu_fw_pmctrl(struct mt7921_dev *dev) 1331 { 1332 struct mt76_phy *mphy = &dev->mt76.phy; 1333 struct mt76_connac_pm *pm = &dev->pm; 1334 int i, err = 0; 1335 1336 mutex_lock(&pm->mutex); 1337 1338 if (mt76_connac_skip_fw_pmctrl(mphy, pm)) 1339 goto out; 1340 1341 for (i = 0; i < MT7921_DRV_OWN_RETRY_COUNT; i++) { 1342 mt76_wr(dev, MT_CONN_ON_LPCTL, PCIE_LPCR_HOST_SET_OWN); 1343 if (mt76_poll_msec(dev, MT_CONN_ON_LPCTL, 1344 PCIE_LPCR_HOST_OWN_SYNC, 4, 50)) 1345 break; 1346 } 1347 1348 if (i == MT7921_DRV_OWN_RETRY_COUNT) { 1349 dev_err(dev->mt76.dev, "firmware own failed\n"); 1350 clear_bit(MT76_STATE_PM, &mphy->state); 1351 err = -EIO; 1352 } 1353 1354 pm->stats.last_doze_event = jiffies; 1355 pm->stats.awake_time += pm->stats.last_doze_event - 1356 pm->stats.last_wake_event; 1357 out: 1358 mutex_unlock(&pm->mutex); 1359 1360 if (err) 1361 mt7921_reset(&dev->mt76); 1362 1363 return err; 1364 } 1365 1366 void 1367 mt7921_pm_interface_iter(void *priv, u8 *mac, struct ieee80211_vif *vif) 1368 { 1369 struct mt7921_phy *phy = priv; 1370 struct mt7921_dev *dev = phy->dev; 1371 int ret; 1372 1373 if (dev->pm.enable) 1374 ret = mt7921_mcu_uni_bss_bcnft(dev, vif, true); 1375 else 1376 ret = mt7921_mcu_set_bss_pm(dev, vif, false); 1377 1378 if (ret) 1379 return; 1380 1381 if (dev->pm.enable) { 1382 vif->driver_flags |= IEEE80211_VIF_BEACON_FILTER; 1383 mt76_set(dev, MT_WF_RFCR(0), MT_WF_RFCR_DROP_OTHER_BEACON); 1384 } else { 1385 vif->driver_flags &= ~IEEE80211_VIF_BEACON_FILTER; 1386 mt76_clear(dev, MT_WF_RFCR(0), MT_WF_RFCR_DROP_OTHER_BEACON); 1387 } 1388 } 1389 1390 int mt7921_get_txpwr_info(struct mt7921_dev *dev, struct mt7921_txpwr *txpwr) 1391 { 1392 struct mt7921_txpwr_event *event; 1393 struct mt7921_txpwr_req req = { 1394 .dbdc_idx = 0, 1395 }; 1396 struct sk_buff *skb; 1397 int ret; 1398 1399 ret = mt76_mcu_send_and_get_msg(&dev->mt76, MCU_CMD_GET_TXPWR, 1400 &req, sizeof(req), true, &skb); 1401 if (ret) 1402 return ret; 1403 1404 event = (struct mt7921_txpwr_event *)skb->data; 1405 WARN_ON(skb->len != le16_to_cpu(event->len)); 1406 memcpy(txpwr, &event->txpwr, sizeof(event->txpwr)); 1407 1408 dev_kfree_skb(skb); 1409 1410 return 0; 1411 } 1412