1 // SPDX-License-Identifier: BSD-3-Clause-Clear 2 /* 3 * Copyright (C) 2022 MediaTek Inc. 4 */ 5 6 #include <linux/firmware.h> 7 #include <linux/fs.h> 8 #include "mt7996.h" 9 #include "mcu.h" 10 #include "mac.h" 11 #include "eeprom.h" 12 13 #define fw_name(_dev, name, ...) ({ \ 14 char *_fw; \ 15 switch (mt76_chip(&(_dev)->mt76)) { \ 16 case MT7992_DEVICE_ID: \ 17 switch ((_dev)->var.type) { \ 18 case MT7992_VAR_TYPE_23: \ 19 _fw = MT7992_##name##_23; \ 20 break; \ 21 case MT7992_VAR_TYPE_24: \ 22 _fw = MT7992_##name##_24; \ 23 break; \ 24 default: \ 25 _fw = MT7992_##name; \ 26 } \ 27 break; \ 28 case MT7990_DEVICE_ID: \ 29 _fw = MT7990_##name; \ 30 break; \ 31 case MT7996_DEVICE_ID: \ 32 default: \ 33 switch ((_dev)->var.type) { \ 34 case MT7996_VAR_TYPE_233: \ 35 _fw = MT7996_##name##_233; \ 36 break; \ 37 default: \ 38 _fw = MT7996_##name; \ 39 } \ 40 break; \ 41 } \ 42 _fw; \ 43 }) 44 45 struct mt7996_patch_hdr { 46 char build_date[16]; 47 char platform[4]; 48 __be32 hw_sw_ver; 49 __be32 patch_ver; 50 __be16 checksum; 51 u16 reserved; 52 struct { 53 __be32 patch_ver; 54 __be32 subsys; 55 __be32 feature; 56 __be32 n_region; 57 __be32 crc; 58 u32 reserved[11]; 59 } desc; 60 } __packed; 61 62 struct mt7996_patch_sec { 63 __be32 type; 64 __be32 offs; 65 __be32 size; 66 union { 67 __be32 spec[13]; 68 struct { 69 __be32 addr; 70 __be32 len; 71 __be32 sec_key_idx; 72 __be32 align_len; 73 u32 reserved[9]; 74 } info; 75 }; 76 } __packed; 77 78 struct mt7996_fw_trailer { 79 u8 chip_id; 80 u8 eco_code; 81 u8 n_region; 82 u8 format_ver; 83 u8 format_flag; 84 u8 reserved[2]; 85 char fw_ver[10]; 86 char build_date[15]; 87 u32 crc; 88 } __packed; 89 90 struct mt7996_fw_region { 91 __le32 decomp_crc; 92 __le32 decomp_len; 93 __le32 decomp_blk_sz; 94 u8 reserved[4]; 95 __le32 addr; 96 __le32 len; 97 u8 feature_set; 98 u8 reserved1[15]; 99 } __packed; 100 101 #define MCU_PATCH_ADDRESS 0x200000 102 103 #define HE_PHY(p, c) u8_get_bits(c, IEEE80211_HE_PHY_##p) 104 #define HE_MAC(m, c) u8_get_bits(c, IEEE80211_HE_MAC_##m) 105 #define EHT_PHY(p, c) u8_get_bits(c, IEEE80211_EHT_PHY_##p) 106 107 static bool sr_scene_detect = true; 108 module_param(sr_scene_detect, bool, 0644); 109 MODULE_PARM_DESC(sr_scene_detect, "Enable firmware scene detection algorithm"); 110 111 static u8 112 mt7996_mcu_get_sta_nss(u16 mcs_map) 113 { 114 u8 nss; 115 116 for (nss = 8; nss > 0; nss--) { 117 u8 nss_mcs = (mcs_map >> (2 * (nss - 1))) & 3; 118 119 if (nss_mcs != IEEE80211_VHT_MCS_NOT_SUPPORTED) 120 break; 121 } 122 123 return nss - 1; 124 } 125 126 static void 127 mt7996_mcu_set_sta_he_mcs(struct ieee80211_link_sta *link_sta, 128 struct mt7996_vif_link *link, 129 __le16 *he_mcs, u16 mcs_map) 130 { 131 struct mt76_phy *mphy = mt76_vif_link_phy(&link->mt76); 132 int nss, max_nss = link_sta->rx_nss > 3 ? 4 : link_sta->rx_nss; 133 enum nl80211_band band; 134 const u16 *mask; 135 136 if (!mphy) 137 return; 138 139 band = mphy->chandef.chan->band; 140 mask = link->bitrate_mask.control[band].he_mcs; 141 142 for (nss = 0; nss < max_nss; nss++) { 143 int mcs; 144 145 switch ((mcs_map >> (2 * nss)) & 0x3) { 146 case IEEE80211_HE_MCS_SUPPORT_0_11: 147 mcs = GENMASK(11, 0); 148 break; 149 case IEEE80211_HE_MCS_SUPPORT_0_9: 150 mcs = GENMASK(9, 0); 151 break; 152 case IEEE80211_HE_MCS_SUPPORT_0_7: 153 mcs = GENMASK(7, 0); 154 break; 155 default: 156 mcs = 0; 157 } 158 159 mcs = mcs ? fls(mcs & mask[nss]) - 1 : -1; 160 161 switch (mcs) { 162 case 0 ... 7: 163 mcs = IEEE80211_HE_MCS_SUPPORT_0_7; 164 break; 165 case 8 ... 9: 166 mcs = IEEE80211_HE_MCS_SUPPORT_0_9; 167 break; 168 case 10 ... 11: 169 mcs = IEEE80211_HE_MCS_SUPPORT_0_11; 170 break; 171 default: 172 mcs = IEEE80211_HE_MCS_NOT_SUPPORTED; 173 break; 174 } 175 mcs_map &= ~(0x3 << (nss * 2)); 176 mcs_map |= mcs << (nss * 2); 177 } 178 179 *he_mcs = cpu_to_le16(mcs_map); 180 } 181 182 static void 183 mt7996_mcu_set_sta_vht_mcs(struct ieee80211_link_sta *link_sta, 184 __le16 *vht_mcs, const u16 *mask) 185 { 186 u16 mcs, mcs_map = le16_to_cpu(link_sta->vht_cap.vht_mcs.rx_mcs_map); 187 int nss, max_nss = link_sta->rx_nss > 3 ? 4 : link_sta->rx_nss; 188 189 for (nss = 0; nss < max_nss; nss++, mcs_map >>= 2) { 190 switch (mcs_map & 0x3) { 191 case IEEE80211_VHT_MCS_SUPPORT_0_9: 192 mcs = GENMASK(9, 0); 193 break; 194 case IEEE80211_VHT_MCS_SUPPORT_0_8: 195 mcs = GENMASK(8, 0); 196 break; 197 case IEEE80211_VHT_MCS_SUPPORT_0_7: 198 mcs = GENMASK(7, 0); 199 break; 200 default: 201 mcs = 0; 202 } 203 204 vht_mcs[nss] = cpu_to_le16(mcs & mask[nss]); 205 } 206 } 207 208 static void 209 mt7996_mcu_set_sta_ht_mcs(struct ieee80211_link_sta *link_sta, 210 u8 *ht_mcs, const u8 *mask) 211 { 212 int nss, max_nss = link_sta->rx_nss > 3 ? 4 : link_sta->rx_nss; 213 214 for (nss = 0; nss < max_nss; nss++) 215 ht_mcs[nss] = link_sta->ht_cap.mcs.rx_mask[nss] & mask[nss]; 216 } 217 218 static int 219 mt7996_mcu_parse_response(struct mt76_dev *mdev, int cmd, 220 struct sk_buff *skb, int seq) 221 { 222 struct mt7996_dev *dev = container_of(mdev, struct mt7996_dev, mt76); 223 struct mt7996_mcu_rxd *rxd; 224 struct mt7996_mcu_uni_event *event; 225 int mcu_cmd = FIELD_GET(__MCU_CMD_FIELD_ID, cmd); 226 int ret = 0; 227 228 if (!skb) { 229 dev_err(mdev->dev, "Message %08x (seq %d) timeout\n", 230 cmd, seq); 231 232 if (!test_and_set_bit(MT76_MCU_RESET, &dev->mphy.state)) { 233 dev->recovery.restart = true; 234 wake_up(&dev->mt76.mcu.wait); 235 queue_work(dev->mt76.wq, &dev->reset_work); 236 wake_up(&dev->reset_wait); 237 } 238 239 return -ETIMEDOUT; 240 } 241 242 rxd = (struct mt7996_mcu_rxd *)skb->data; 243 if (seq != rxd->seq) 244 return -EAGAIN; 245 246 if (cmd == MCU_CMD(PATCH_SEM_CONTROL)) { 247 skb_pull(skb, sizeof(*rxd) - 4); 248 ret = *skb->data; 249 } else if ((rxd->option & MCU_UNI_CMD_EVENT) && 250 rxd->eid == MCU_UNI_EVENT_RESULT) { 251 skb_pull(skb, sizeof(*rxd)); 252 event = (struct mt7996_mcu_uni_event *)skb->data; 253 ret = le32_to_cpu(event->status); 254 /* skip invalid event */ 255 if (mcu_cmd != le16_to_cpu(event->cid)) 256 ret = -EAGAIN; 257 } else { 258 skb_pull(skb, sizeof(struct mt7996_mcu_rxd)); 259 } 260 261 return ret; 262 } 263 264 static void 265 mt7996_mcu_set_timeout(struct mt76_dev *mdev, int cmd) 266 { 267 mdev->mcu.timeout = 5 * HZ; 268 269 if (!(cmd & __MCU_CMD_FIELD_UNI)) 270 return; 271 272 switch (FIELD_GET(__MCU_CMD_FIELD_ID, cmd)) { 273 case MCU_UNI_CMD_THERMAL: 274 case MCU_UNI_CMD_TWT: 275 case MCU_UNI_CMD_GET_MIB_INFO: 276 case MCU_UNI_CMD_STA_REC_UPDATE: 277 case MCU_UNI_CMD_BSS_INFO_UPDATE: 278 mdev->mcu.timeout = 2 * HZ; 279 return; 280 case MCU_UNI_CMD_EFUSE_CTRL: 281 case MCU_UNI_CMD_EXT_EEPROM_CTRL: 282 mdev->mcu.timeout = 30 * HZ; 283 return; 284 default: 285 break; 286 } 287 } 288 289 static int 290 mt7996_mcu_send_message(struct mt76_dev *mdev, struct sk_buff *skb, 291 int cmd, int *wait_seq) 292 { 293 struct mt7996_dev *dev = container_of(mdev, struct mt7996_dev, mt76); 294 int txd_len, mcu_cmd = FIELD_GET(__MCU_CMD_FIELD_ID, cmd); 295 struct mt76_connac2_mcu_uni_txd *uni_txd; 296 struct mt76_connac2_mcu_txd *mcu_txd; 297 enum mt76_mcuq_id qid; 298 __le32 *txd; 299 u32 val; 300 u8 seq; 301 302 mt7996_mcu_set_timeout(mdev, cmd); 303 304 seq = ++dev->mt76.mcu.msg_seq & 0xf; 305 if (!seq) 306 seq = ++dev->mt76.mcu.msg_seq & 0xf; 307 308 if (cmd == MCU_CMD(FW_SCATTER)) { 309 qid = MT_MCUQ_FWDL; 310 goto exit; 311 } 312 313 txd_len = cmd & __MCU_CMD_FIELD_UNI ? sizeof(*uni_txd) : sizeof(*mcu_txd); 314 txd = (__le32 *)skb_push(skb, txd_len); 315 if (test_bit(MT76_STATE_MCU_RUNNING, &dev->mphy.state) && mt7996_has_wa(dev)) 316 qid = MT_MCUQ_WA; 317 else 318 qid = MT_MCUQ_WM; 319 320 val = FIELD_PREP(MT_TXD0_TX_BYTES, skb->len) | 321 FIELD_PREP(MT_TXD0_PKT_FMT, MT_TX_TYPE_CMD) | 322 FIELD_PREP(MT_TXD0_Q_IDX, MT_TX_MCU_PORT_RX_Q0); 323 txd[0] = cpu_to_le32(val); 324 325 val = FIELD_PREP(MT_TXD1_HDR_FORMAT, MT_HDR_FORMAT_CMD); 326 txd[1] = cpu_to_le32(val); 327 328 if (cmd & __MCU_CMD_FIELD_UNI) { 329 uni_txd = (struct mt76_connac2_mcu_uni_txd *)txd; 330 uni_txd->len = cpu_to_le16(skb->len - sizeof(uni_txd->txd)); 331 uni_txd->cid = cpu_to_le16(mcu_cmd); 332 uni_txd->s2d_index = MCU_S2D_H2CN; 333 uni_txd->pkt_type = MCU_PKT_ID; 334 uni_txd->seq = seq; 335 336 uni_txd->option = MCU_CMD_UNI; 337 if (!(cmd & __MCU_CMD_FIELD_QUERY)) 338 uni_txd->option |= MCU_CMD_SET; 339 340 if (wait_seq) 341 uni_txd->option |= MCU_CMD_ACK; 342 343 if ((cmd & __MCU_CMD_FIELD_WA) && (cmd & __MCU_CMD_FIELD_WM)) 344 uni_txd->s2d_index = MCU_S2D_H2CN; 345 else if (cmd & __MCU_CMD_FIELD_WA) 346 uni_txd->s2d_index = MCU_S2D_H2C; 347 else if (cmd & __MCU_CMD_FIELD_WM) 348 uni_txd->s2d_index = MCU_S2D_H2N; 349 350 goto exit; 351 } 352 353 mcu_txd = (struct mt76_connac2_mcu_txd *)txd; 354 mcu_txd->len = cpu_to_le16(skb->len - sizeof(mcu_txd->txd)); 355 mcu_txd->pq_id = cpu_to_le16(MCU_PQ_ID(MT_TX_PORT_IDX_MCU, 356 MT_TX_MCU_PORT_RX_Q0)); 357 mcu_txd->pkt_type = MCU_PKT_ID; 358 mcu_txd->seq = seq; 359 360 mcu_txd->cid = FIELD_GET(__MCU_CMD_FIELD_ID, cmd); 361 mcu_txd->set_query = MCU_Q_NA; 362 mcu_txd->ext_cid = FIELD_GET(__MCU_CMD_FIELD_EXT_ID, cmd); 363 if (mcu_txd->ext_cid) { 364 mcu_txd->ext_cid_ack = 1; 365 366 if (cmd & __MCU_CMD_FIELD_QUERY) 367 mcu_txd->set_query = MCU_Q_QUERY; 368 else 369 mcu_txd->set_query = MCU_Q_SET; 370 } 371 372 if (cmd & __MCU_CMD_FIELD_WA) 373 mcu_txd->s2d_index = MCU_S2D_H2C; 374 else 375 mcu_txd->s2d_index = MCU_S2D_H2N; 376 377 exit: 378 if (wait_seq) 379 *wait_seq = seq; 380 381 return mt76_tx_queue_skb_raw(dev, mdev->q_mcu[qid], skb, 0); 382 } 383 384 int mt7996_mcu_wa_cmd(struct mt7996_dev *dev, int cmd, u32 a1, u32 a2, u32 a3) 385 { 386 struct { 387 u8 _rsv[4]; 388 389 __le16 tag; 390 __le16 len; 391 __le32 args[3]; 392 } __packed req = { 393 .args = { 394 cpu_to_le32(a1), 395 cpu_to_le32(a2), 396 cpu_to_le32(a3), 397 }, 398 }; 399 400 if (mt7996_has_wa(dev)) 401 return mt76_mcu_send_msg(&dev->mt76, cmd, &req.args, 402 sizeof(req.args), false); 403 404 req.tag = cpu_to_le16(cmd == MCU_WA_PARAM_CMD(QUERY) ? UNI_CMD_SDO_QUERY : 405 UNI_CMD_SDO_SET); 406 req.len = cpu_to_le16(sizeof(req) - 4); 407 408 return mt76_mcu_send_msg(&dev->mt76, MCU_WA_UNI_CMD(SDO), &req, 409 sizeof(req), false); 410 } 411 412 struct mt7996_mcu_countdown_data { 413 struct mt76_phy *mphy; 414 u8 omac_idx; 415 }; 416 417 static void 418 mt7996_mcu_csa_finish(void *priv, u8 *mac, struct ieee80211_vif *vif) 419 { 420 struct mt7996_mcu_countdown_data *cdata = (void *)priv; 421 struct mt7996_vif *mvif = (struct mt7996_vif *)vif->drv_priv; 422 struct ieee80211_bss_conf *link_conf = NULL; 423 unsigned long valid_links = vif->valid_links ?: BIT(0); 424 unsigned int link_id; 425 426 if (vif->type == NL80211_IFTYPE_STATION) 427 return; 428 429 for_each_set_bit(link_id, &valid_links, IEEE80211_MLD_MAX_NUM_LINKS) { 430 struct mt76_vif_link *mlink = 431 rcu_dereference(mvif->mt76.link[link_id]); 432 433 if (mlink && mlink->band_idx == cdata->mphy->band_idx && 434 mlink->omac_idx == cdata->omac_idx) { 435 link_conf = rcu_dereference(vif->link_conf[link_id]); 436 break; 437 } 438 } 439 440 if (!link_conf || !link_conf->csa_active) 441 return; 442 443 ieee80211_csa_finish(vif, link_conf->link_id); 444 } 445 446 static void 447 mt7996_mcu_cca_finish(void *priv, u8 *mac, struct ieee80211_vif *vif) 448 { 449 struct mt7996_mcu_countdown_data *cdata = (void *)priv; 450 struct mt7996_vif *mvif = (struct mt7996_vif *)vif->drv_priv; 451 struct ieee80211_bss_conf *link_conf = NULL; 452 unsigned long valid_links = vif->valid_links ?: BIT(0); 453 unsigned int link_id; 454 455 if (vif->type == NL80211_IFTYPE_STATION) 456 return; 457 458 for_each_set_bit(link_id, &valid_links, IEEE80211_MLD_MAX_NUM_LINKS) { 459 struct mt76_vif_link *mlink = 460 rcu_dereference(mvif->mt76.link[link_id]); 461 462 if (mlink && mlink->band_idx == cdata->mphy->band_idx && 463 mlink->omac_idx == cdata->omac_idx) { 464 link_conf = rcu_dereference(vif->link_conf[link_id]); 465 break; 466 } 467 } 468 469 if (!link_conf || !link_conf->color_change_active) 470 return; 471 472 ieee80211_color_change_finish(vif, link_conf->link_id); 473 } 474 475 static void 476 mt7996_mcu_ie_countdown(struct mt7996_dev *dev, struct sk_buff *skb) 477 { 478 #define UNI_EVENT_IE_COUNTDOWN_CSA 0 479 #define UNI_EVENT_IE_COUNTDOWN_BCC 1 480 struct header { 481 u8 band; 482 u8 rsv[3]; 483 }; 484 struct mt7996_mcu_rxd *rxd = (struct mt7996_mcu_rxd *)skb->data; 485 const char *data = (char *)&rxd[1], *tail; 486 struct header *hdr = (struct header *)data; 487 struct tlv *tlv = (struct tlv *)(data + 4); 488 struct mt7996_mcu_countdown_notify *event; 489 struct mt7996_mcu_countdown_data cdata; 490 491 if (skb->len < sizeof(*rxd) + sizeof(*hdr)) 492 return; 493 494 if (hdr->band >= ARRAY_SIZE(dev->mt76.phys)) 495 return; 496 497 cdata.mphy = dev->mt76.phys[hdr->band]; 498 if (!cdata.mphy) 499 return; 500 501 tail = skb->data + skb->len; 502 data += sizeof(*hdr); 503 while (data + sizeof(*tlv) <= tail) { 504 u16 tag_len = le16_to_cpu(tlv->len); 505 506 if (tag_len < sizeof(*tlv) + sizeof(*event) || 507 data + tag_len > tail) 508 break; 509 510 event = (struct mt7996_mcu_countdown_notify *)tlv->data; 511 cdata.omac_idx = event->omac_idx; 512 513 switch (le16_to_cpu(tlv->tag)) { 514 case UNI_EVENT_IE_COUNTDOWN_CSA: 515 ieee80211_iterate_active_interfaces_atomic(mt76_hw(dev), 516 IEEE80211_IFACE_ITER_RESUME_ALL, 517 mt7996_mcu_csa_finish, &cdata); 518 break; 519 case UNI_EVENT_IE_COUNTDOWN_BCC: 520 ieee80211_iterate_active_interfaces_atomic(mt76_hw(dev), 521 IEEE80211_IFACE_ITER_RESUME_ALL, 522 mt7996_mcu_cca_finish, &cdata); 523 break; 524 default: 525 break; 526 } 527 528 data += tag_len; 529 tlv = (struct tlv *)data; 530 } 531 } 532 533 static void 534 mt7996_mcu_rx_radar_detected(struct mt7996_dev *dev, struct sk_buff *skb) 535 { 536 struct mt76_phy *mphy = &dev->mt76.phy; 537 struct mt7996_mcu_rdd_report *r; 538 539 r = (struct mt7996_mcu_rdd_report *)skb->data; 540 541 switch (r->rdd_idx) { 542 case MT_RDD_IDX_BAND2: 543 mphy = dev->mt76.phys[MT_BAND2]; 544 break; 545 case MT_RDD_IDX_BAND1: 546 mphy = dev->mt76.phys[MT_BAND1]; 547 break; 548 case MT_RDD_IDX_BACKGROUND: 549 if (!dev->rdd2_phy) 550 goto err; 551 mphy = dev->rdd2_phy->mt76; 552 break; 553 default: 554 goto err; 555 } 556 557 if (!mphy) 558 goto err; 559 560 if (r->rdd_idx == MT_RDD_IDX_BACKGROUND) { 561 cfg80211_background_radar_event(mphy->hw->wiphy, 562 &dev->rdd2_chandef, 563 GFP_ATOMIC); 564 } else { 565 struct mt7996_phy *phy = mphy->priv; 566 567 phy->rdd_tx_paused = true; 568 ieee80211_radar_detected(mphy->hw, NULL); 569 } 570 dev->hw_pattern++; 571 572 return; 573 574 err: 575 dev_err(dev->mt76.dev, "Invalid RDD idx %d\n", r->rdd_idx); 576 } 577 578 static void 579 mt7996_mcu_rx_log_message(struct mt7996_dev *dev, struct sk_buff *skb) 580 { 581 #define UNI_EVENT_FW_LOG_FORMAT 0 582 struct mt7996_mcu_rxd *rxd = (struct mt7996_mcu_rxd *)skb->data; 583 const char *data, *type; 584 struct tlv *tlv; 585 int len; 586 587 if (skb->len < sizeof(*rxd)) 588 return; 589 590 if (!(rxd->option & MCU_UNI_CMD_EVENT)) { 591 data = (char *)&rxd[1]; 592 len = skb->len - sizeof(*rxd); 593 goto out; 594 } 595 596 if (skb->len < sizeof(*rxd) + 4 + sizeof(*tlv)) 597 return; 598 599 tlv = (struct tlv *)((char *)&rxd[1] + 4); 600 if (le16_to_cpu(tlv->tag) != UNI_EVENT_FW_LOG_FORMAT) 601 return; 602 603 if (le16_to_cpu(tlv->len) < sizeof(*tlv) + 4) 604 return; 605 606 data = (char *)tlv + sizeof(*tlv) + 4; 607 len = le16_to_cpu(tlv->len) - sizeof(*tlv) - 4; 608 len = min_t(int, len, skb->len - (int)(data - (char *)skb->data)); 609 610 out: 611 switch (rxd->s2d_index) { 612 case 0: 613 if (mt7996_debugfs_rx_log(dev, data, len)) 614 return; 615 616 type = "WM"; 617 break; 618 case 2: 619 type = "WA"; 620 break; 621 default: 622 type = "unknown"; 623 break; 624 } 625 626 wiphy_info(mt76_hw(dev)->wiphy, "%s: %.*s", type, len, data); 627 } 628 629 static int 630 mt7996_mcu_update_tx_gi(struct rate_info *rate, struct all_sta_trx_rate *mcu_rate) 631 { 632 switch (mcu_rate->tx_mode) { 633 case MT_PHY_TYPE_CCK: 634 case MT_PHY_TYPE_OFDM: 635 break; 636 case MT_PHY_TYPE_HT: 637 case MT_PHY_TYPE_HT_GF: 638 case MT_PHY_TYPE_VHT: 639 if (mcu_rate->tx_gi) 640 rate->flags |= RATE_INFO_FLAGS_SHORT_GI; 641 else 642 rate->flags &= ~RATE_INFO_FLAGS_SHORT_GI; 643 break; 644 case MT_PHY_TYPE_HE_SU: 645 case MT_PHY_TYPE_HE_EXT_SU: 646 case MT_PHY_TYPE_HE_TB: 647 case MT_PHY_TYPE_HE_MU: 648 if (mcu_rate->tx_gi > NL80211_RATE_INFO_HE_GI_3_2) 649 return -EINVAL; 650 rate->he_gi = mcu_rate->tx_gi; 651 break; 652 case MT_PHY_TYPE_EHT_SU: 653 case MT_PHY_TYPE_EHT_TRIG: 654 case MT_PHY_TYPE_EHT_MU: 655 if (mcu_rate->tx_gi > NL80211_RATE_INFO_EHT_GI_3_2) 656 return -EINVAL; 657 rate->eht_gi = mcu_rate->tx_gi; 658 break; 659 default: 660 return -EINVAL; 661 } 662 663 return 0; 664 } 665 666 static void 667 mt7996_mcu_rx_all_sta_info_event(struct mt7996_dev *dev, struct sk_buff *skb) 668 { 669 struct mt7996_mcu_all_sta_info_event *res; 670 u32 elem_size; 671 u16 sta_num; 672 u16 i; 673 674 if (skb->len < sizeof(struct mt7996_mcu_rxd)) 675 return; 676 677 skb_pull(skb, sizeof(struct mt7996_mcu_rxd)); 678 679 res = (struct mt7996_mcu_all_sta_info_event *)skb->data; 680 if (skb->len < sizeof(*res)) 681 return; 682 683 sta_num = le16_to_cpu(res->sta_num); 684 switch (le16_to_cpu(res->tag)) { 685 case UNI_ALL_STA_TXRX_RATE: 686 elem_size = sizeof(res->rate[0]); 687 break; 688 case UNI_ALL_STA_TXRX_ADM_STAT: 689 elem_size = sizeof(res->adm_stat[0]); 690 break; 691 case UNI_ALL_STA_TXRX_MSDU_COUNT: 692 elem_size = sizeof(res->msdu_cnt[0]); 693 break; 694 default: 695 return; 696 } 697 698 if (sta_num > (skb->len - sizeof(*res)) / elem_size) 699 sta_num = (skb->len - sizeof(*res)) / elem_size; 700 701 for (i = 0; i < sta_num; i++) { 702 u8 ac; 703 u16 wlan_idx; 704 struct mt76_wcid *wcid; 705 706 switch (le16_to_cpu(res->tag)) { 707 case UNI_ALL_STA_TXRX_RATE: 708 wlan_idx = le16_to_cpu(res->rate[i].wlan_idx); 709 wcid = mt76_wcid_ptr(dev, wlan_idx); 710 711 if (!wcid) 712 break; 713 714 if (mt7996_mcu_update_tx_gi(&wcid->rate, &res->rate[i])) 715 dev_err(dev->mt76.dev, "Failed to update TX GI\n"); 716 break; 717 case UNI_ALL_STA_TXRX_ADM_STAT: 718 wlan_idx = le16_to_cpu(res->adm_stat[i].wlan_idx); 719 wcid = mt76_wcid_ptr(dev, wlan_idx); 720 721 if (!wcid) 722 break; 723 724 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) { 725 wcid->stats.tx_bytes += 726 le32_to_cpu(res->adm_stat[i].tx_bytes[ac]); 727 wcid->stats.rx_bytes += 728 le32_to_cpu(res->adm_stat[i].rx_bytes[ac]); 729 } 730 break; 731 case UNI_ALL_STA_TXRX_MSDU_COUNT: 732 wlan_idx = le16_to_cpu(res->msdu_cnt[i].wlan_idx); 733 wcid = mt76_wcid_ptr(dev, wlan_idx); 734 735 if (!wcid) 736 break; 737 738 wcid->stats.tx_packets += 739 le32_to_cpu(res->msdu_cnt[i].tx_msdu_cnt); 740 wcid->stats.rx_packets += 741 le32_to_cpu(res->msdu_cnt[i].rx_msdu_cnt); 742 break; 743 default: 744 break; 745 } 746 } 747 } 748 749 static void 750 mt7996_mcu_rx_thermal_notify(struct mt7996_dev *dev, struct sk_buff *skb) 751 { 752 #define THERMAL_NOTIFY_TAG 0x4 753 #define THERMAL_NOTIFY 0x2 754 struct mt76_phy *mphy = &dev->mt76.phy; 755 struct mt7996_mcu_thermal_notify *n; 756 struct mt7996_phy *phy; 757 758 n = (struct mt7996_mcu_thermal_notify *)skb->data; 759 760 if (le16_to_cpu(n->tag) != THERMAL_NOTIFY_TAG) 761 return; 762 763 if (n->event_id != THERMAL_NOTIFY) 764 return; 765 766 if (n->band_idx > MT_BAND2) 767 return; 768 769 mphy = dev->mt76.phys[n->band_idx]; 770 if (!mphy) 771 return; 772 773 phy = (struct mt7996_phy *)mphy->priv; 774 phy->throttle_state = n->duty_percent; 775 } 776 777 static void 778 mt7996_mcu_rx_ext_event(struct mt7996_dev *dev, struct sk_buff *skb) 779 { 780 struct mt7996_mcu_rxd *rxd = (struct mt7996_mcu_rxd *)skb->data; 781 782 switch (rxd->ext_eid) { 783 case MCU_EXT_EVENT_FW_LOG_2_HOST: 784 mt7996_mcu_rx_log_message(dev, skb); 785 break; 786 default: 787 break; 788 } 789 } 790 791 static void 792 mt7996_mcu_rx_unsolicited_event(struct mt7996_dev *dev, struct sk_buff *skb) 793 { 794 struct mt7996_mcu_rxd *rxd = (struct mt7996_mcu_rxd *)skb->data; 795 796 switch (rxd->eid) { 797 case MCU_EVENT_EXT: 798 mt7996_mcu_rx_ext_event(dev, skb); 799 break; 800 case MCU_UNI_EVENT_THERMAL: 801 mt7996_mcu_rx_thermal_notify(dev, skb); 802 break; 803 default: 804 break; 805 } 806 dev_kfree_skb(skb); 807 } 808 809 static void 810 mt7996_mcu_wed_rro_event(struct mt7996_dev *dev, struct sk_buff *skb) 811 { 812 struct mt7996_mcu_wed_rro_event *event = (void *)skb->data; 813 814 if (!mt7996_has_hwrro(dev)) 815 return; 816 817 skb_pull(skb, sizeof(struct mt7996_mcu_rxd) + 4); 818 819 switch (le16_to_cpu(event->tag)) { 820 case UNI_WED_RRO_BA_SESSION_STATUS: { 821 struct mt7996_mcu_wed_rro_ba_event *e; 822 823 while (skb->len >= sizeof(*e)) { 824 struct mt76_rx_tid *tid; 825 struct mt76_wcid *wcid; 826 u16 idx; 827 828 e = (void *)skb->data; 829 idx = le16_to_cpu(e->wlan_id); 830 wcid = mt76_wcid_ptr(dev, idx); 831 if (!wcid || !wcid->sta) 832 break; 833 834 if (e->tid >= ARRAY_SIZE(wcid->aggr)) 835 break; 836 837 tid = rcu_dereference(wcid->aggr[e->tid]); 838 if (!tid) 839 break; 840 841 tid->id = le16_to_cpu(e->id); 842 skb_pull(skb, sizeof(*e)); 843 } 844 break; 845 } 846 case UNI_WED_RRO_BA_SESSION_DELETE: { 847 struct mt7996_mcu_wed_rro_ba_delete_event *e; 848 849 while (skb->len >= sizeof(*e)) { 850 struct mt7996_wed_rro_session_id *session; 851 852 e = (void *)skb->data; 853 session = kzalloc_obj(*session, GFP_ATOMIC); 854 if (!session) 855 break; 856 857 session->id = le16_to_cpu(e->session_id); 858 859 spin_lock_bh(&dev->wed_rro.lock); 860 list_add_tail(&session->list, &dev->wed_rro.poll_list); 861 spin_unlock_bh(&dev->wed_rro.lock); 862 863 ieee80211_queue_work(mt76_hw(dev), &dev->wed_rro.work); 864 skb_pull(skb, sizeof(*e)); 865 } 866 break; 867 } 868 default: 869 break; 870 } 871 } 872 873 static void 874 mt7996_mcu_ps_transition(struct mt7996_dev *dev, u16 wcid_idx, bool ps) 875 { 876 struct mt76_wcid *wcid; 877 878 wcid = mt76_wcid_ptr(dev, wcid_idx); 879 if (!wcid || !wcid_to_sta(wcid)) 880 return; 881 882 mt76_sta_ps_transition(&dev->mt76, wcid, ps); 883 } 884 885 static void 886 mt7996_mcu_rx_ps_sync(struct mt7996_dev *dev, struct sk_buff *skb) 887 { 888 struct mt7996_mcu_ps_sync_event *event = (void *)skb->data; 889 struct tlv *tlv; 890 int len; 891 892 if (skb->len < sizeof(*event)) 893 return; 894 895 skb_pull(skb, sizeof(*event)); 896 897 len = skb->len; 898 while (len >= sizeof(*tlv)) { 899 u16 tag, tag_len; 900 901 tlv = (struct tlv *)skb->data; 902 tag = le16_to_cpu(tlv->tag); 903 tag_len = le16_to_cpu(tlv->len); 904 /* a tag_len below the header size would not advance the buffer */ 905 if (tag_len < sizeof(*tlv) || tag_len > len) 906 break; 907 908 switch (tag) { 909 case UNI_PS_CLIENT_INFO: { 910 struct mt7996_mcu_ps_client_info *info = (void *)tlv; 911 912 if (tag_len < sizeof(*info)) 913 break; 914 915 mt7996_mcu_ps_transition(dev, 916 le16_to_cpu(info->wlan_idx), 917 info->ps_bit); 918 break; 919 } 920 case UNI_PS_MULTI_CLIENT_INFO: { 921 struct mt7996_mcu_ps_multi_client_info *info = (void *)tlv; 922 u16 cnt; 923 int i; 924 925 if (tag_len < sizeof(*info)) 926 break; 927 928 cnt = min_t(u16, le16_to_cpu(info->sta_cnt), 929 (tag_len - sizeof(*info)) / sizeof(info->sta_ps_info[0])); 930 for (i = 0; i < cnt; i++) { 931 u16 entry = le16_to_cpu(info->sta_ps_info[i]); 932 933 mt7996_mcu_ps_transition(dev, 934 FIELD_GET(MT7996_PS_MULTI_WCID, entry), 935 !!(entry & MT7996_PS_MULTI_PS_BIT)); 936 } 937 break; 938 } 939 case UNI_PS_MULTI_CLIENT_INFO_BITMAP: { 940 u8 *bitmap = tlv->data; 941 int bitmap_len = tag_len - sizeof(*tlv); 942 int i; 943 944 for (i = 0; i < bitmap_len * 8; i++) 945 mt7996_mcu_ps_transition(dev, i, 946 !!(bitmap[i / 8] & BIT(i % 8))); 947 break; 948 } 949 } 950 951 skb_pull(skb, tag_len); 952 len -= tag_len; 953 } 954 } 955 956 static void 957 mt7996_mcu_uni_rx_unsolicited_event(struct mt7996_dev *dev, struct sk_buff *skb) 958 { 959 struct mt7996_mcu_rxd *rxd = (struct mt7996_mcu_rxd *)skb->data; 960 961 switch (rxd->eid) { 962 case MCU_UNI_EVENT_FW_LOG_2_HOST: 963 mt7996_mcu_rx_log_message(dev, skb); 964 break; 965 case MCU_UNI_EVENT_IE_COUNTDOWN: 966 mt7996_mcu_ie_countdown(dev, skb); 967 break; 968 case MCU_UNI_EVENT_RDD_REPORT: 969 mt7996_mcu_rx_radar_detected(dev, skb); 970 break; 971 case MCU_UNI_EVENT_ALL_STA_INFO: 972 mt7996_mcu_rx_all_sta_info_event(dev, skb); 973 break; 974 case MCU_UNI_EVENT_WED_RRO: 975 mt7996_mcu_wed_rro_event(dev, skb); 976 break; 977 case MCU_UNI_EVENT_PS_SYNC: 978 mt7996_mcu_rx_ps_sync(dev, skb); 979 break; 980 default: 981 break; 982 } 983 dev_kfree_skb(skb); 984 } 985 986 void mt7996_mcu_rx_event(struct mt7996_dev *dev, struct sk_buff *skb) 987 { 988 struct mt7996_mcu_rxd *rxd = (struct mt7996_mcu_rxd *)skb->data; 989 990 if (rxd->option & MCU_UNI_CMD_UNSOLICITED_EVENT) { 991 mt7996_mcu_uni_rx_unsolicited_event(dev, skb); 992 return; 993 } 994 995 /* WA still uses legacy event*/ 996 if (rxd->ext_eid == MCU_EXT_EVENT_FW_LOG_2_HOST || 997 !rxd->seq) 998 mt7996_mcu_rx_unsolicited_event(dev, skb); 999 else 1000 mt76_mcu_rx_event(&dev->mt76, skb); 1001 } 1002 1003 static struct tlv * 1004 mt7996_mcu_add_uni_tlv(struct sk_buff *skb, u16 tag, u16 len) 1005 { 1006 struct tlv *ptlv = skb_put_zero(skb, len); 1007 1008 ptlv->tag = cpu_to_le16(tag); 1009 ptlv->len = cpu_to_le16(len); 1010 1011 return ptlv; 1012 } 1013 1014 static void 1015 mt7996_mcu_bss_rfch_tlv(struct sk_buff *skb, struct mt7996_phy *phy) 1016 { 1017 static const u8 rlm_ch_band[] = { 1018 [NL80211_BAND_2GHZ] = 1, 1019 [NL80211_BAND_5GHZ] = 2, 1020 [NL80211_BAND_6GHZ] = 3, 1021 }; 1022 struct cfg80211_chan_def *chandef = &phy->mt76->chandef; 1023 struct bss_rlm_tlv *ch; 1024 struct tlv *tlv; 1025 int freq1 = chandef->center_freq1; 1026 1027 tlv = mt7996_mcu_add_uni_tlv(skb, UNI_BSS_INFO_RLM, sizeof(*ch)); 1028 1029 ch = (struct bss_rlm_tlv *)tlv; 1030 ch->control_channel = chandef->chan->hw_value; 1031 ch->center_chan = ieee80211_frequency_to_channel(freq1); 1032 ch->bw = mt76_connac_chan_bw(chandef); 1033 ch->tx_streams = hweight8(phy->mt76->antenna_mask); 1034 ch->rx_streams = hweight8(phy->mt76->antenna_mask); 1035 ch->band = rlm_ch_band[chandef->chan->band]; 1036 1037 if (chandef->width == NL80211_CHAN_WIDTH_80P80) { 1038 int freq2 = chandef->center_freq2; 1039 1040 ch->center_chan2 = ieee80211_frequency_to_channel(freq2); 1041 } 1042 } 1043 1044 static void 1045 mt7996_mcu_bss_ra_tlv(struct sk_buff *skb, struct mt7996_phy *phy) 1046 { 1047 struct bss_ra_tlv *ra; 1048 struct tlv *tlv; 1049 1050 tlv = mt7996_mcu_add_uni_tlv(skb, UNI_BSS_INFO_RA, sizeof(*ra)); 1051 1052 ra = (struct bss_ra_tlv *)tlv; 1053 ra->short_preamble = true; 1054 } 1055 1056 static void 1057 mt7996_mcu_bss_he_tlv(struct sk_buff *skb, struct ieee80211_vif *vif, 1058 struct ieee80211_bss_conf *link_conf, 1059 struct mt7996_phy *phy) 1060 { 1061 #define DEFAULT_HE_PE_DURATION 4 1062 #define DEFAULT_HE_DURATION_RTS_THRES 1023 1063 const struct ieee80211_sta_he_cap *cap; 1064 struct bss_info_uni_he *he; 1065 struct tlv *tlv; 1066 1067 cap = mt76_connac_get_he_phy_cap(phy->mt76, vif); 1068 if (!cap) 1069 return; 1070 1071 tlv = mt7996_mcu_add_uni_tlv(skb, UNI_BSS_INFO_HE_BASIC, sizeof(*he)); 1072 1073 he = (struct bss_info_uni_he *)tlv; 1074 he->he_pe_duration = link_conf->htc_trig_based_pkt_ext; 1075 if (!he->he_pe_duration) 1076 he->he_pe_duration = DEFAULT_HE_PE_DURATION; 1077 1078 he->he_rts_thres = cpu_to_le16(link_conf->frame_time_rts_th); 1079 if (!he->he_rts_thres) 1080 he->he_rts_thres = cpu_to_le16(DEFAULT_HE_DURATION_RTS_THRES); 1081 1082 he->max_nss_mcs[CMD_HE_MCS_BW80] = cap->he_mcs_nss_supp.tx_mcs_80; 1083 he->max_nss_mcs[CMD_HE_MCS_BW160] = cap->he_mcs_nss_supp.tx_mcs_160; 1084 he->max_nss_mcs[CMD_HE_MCS_BW8080] = cap->he_mcs_nss_supp.tx_mcs_80p80; 1085 } 1086 1087 static void 1088 mt7996_mcu_bss_mbssid_tlv(struct sk_buff *skb, struct ieee80211_bss_conf *link_conf, 1089 bool enable) 1090 { 1091 struct bss_info_uni_mbssid *mbssid; 1092 struct tlv *tlv; 1093 1094 if (!link_conf->bssid_indicator && enable) 1095 return; 1096 1097 tlv = mt7996_mcu_add_uni_tlv(skb, UNI_BSS_INFO_11V_MBSSID, sizeof(*mbssid)); 1098 1099 mbssid = (struct bss_info_uni_mbssid *)tlv; 1100 1101 if (enable) { 1102 mbssid->max_indicator = link_conf->bssid_indicator; 1103 mbssid->mbss_idx = link_conf->bssid_index; 1104 mbssid->tx_bss_omac_idx = 0; 1105 } 1106 } 1107 1108 static void 1109 mt7996_mcu_bss_bmc_tlv(struct sk_buff *skb, struct mt76_vif_link *mlink, 1110 struct mt7996_phy *phy) 1111 { 1112 struct bss_rate_tlv *bmc; 1113 struct cfg80211_chan_def *chandef = &phy->mt76->chandef; 1114 enum nl80211_band band = chandef->chan->band; 1115 struct tlv *tlv; 1116 u8 idx = mlink->mcast_rates_idx ? 1117 mlink->mcast_rates_idx : mlink->basic_rates_idx; 1118 1119 tlv = mt7996_mcu_add_uni_tlv(skb, UNI_BSS_INFO_RATE, sizeof(*bmc)); 1120 1121 bmc = (struct bss_rate_tlv *)tlv; 1122 1123 bmc->short_preamble = (band == NL80211_BAND_2GHZ); 1124 bmc->bc_fixed_rate = idx; 1125 bmc->mc_fixed_rate = idx; 1126 } 1127 1128 static void 1129 mt7996_mcu_bss_txcmd_tlv(struct sk_buff *skb, bool en) 1130 { 1131 struct bss_txcmd_tlv *txcmd; 1132 struct tlv *tlv; 1133 1134 tlv = mt7996_mcu_add_uni_tlv(skb, UNI_BSS_INFO_TXCMD, sizeof(*txcmd)); 1135 1136 txcmd = (struct bss_txcmd_tlv *)tlv; 1137 txcmd->txcmd_mode = en; 1138 } 1139 1140 static void 1141 mt7996_mcu_bss_mld_tlv(struct sk_buff *skb, 1142 struct ieee80211_bss_conf *link_conf, 1143 struct mt7996_vif_link *link) 1144 { 1145 struct ieee80211_vif *vif = link_conf->vif; 1146 struct mt7996_vif *mvif = (struct mt7996_vif *)vif->drv_priv; 1147 struct bss_mld_tlv *mld; 1148 struct tlv *tlv; 1149 1150 tlv = mt7996_mcu_add_uni_tlv(skb, UNI_BSS_INFO_MLD, sizeof(*mld)); 1151 mld = (struct bss_mld_tlv *)tlv; 1152 mld->own_mld_id = link->mld_idx; 1153 mld->link_id = link_conf->link_id; 1154 1155 if (ieee80211_vif_is_mld(vif)) { 1156 mld->group_mld_id = mvif->mld_group_idx; 1157 mld->remap_idx = mvif->mld_remap_idx; 1158 memcpy(mld->mac_addr, vif->addr, ETH_ALEN); 1159 } else { 1160 mld->group_mld_id = 0xff; 1161 mld->remap_idx = 0xff; 1162 } 1163 } 1164 1165 static void 1166 mt7996_mcu_bss_sec_tlv(struct sk_buff *skb, struct mt76_vif_link *mlink) 1167 { 1168 struct bss_sec_tlv *sec; 1169 struct tlv *tlv; 1170 1171 tlv = mt7996_mcu_add_uni_tlv(skb, UNI_BSS_INFO_SEC, sizeof(*sec)); 1172 1173 sec = (struct bss_sec_tlv *)tlv; 1174 sec->cipher = mlink->cipher; 1175 } 1176 1177 static void 1178 mt7996_mcu_bss_ifs_timing_tlv(struct sk_buff *skb, struct mt7996_phy *phy) 1179 { 1180 struct bss_ifs_time_tlv *ifs_time; 1181 struct tlv *tlv; 1182 bool is_2ghz = phy->mt76->chandef.chan->band == NL80211_BAND_2GHZ; 1183 1184 tlv = mt7996_mcu_add_uni_tlv(skb, UNI_BSS_INFO_IFS_TIME, sizeof(*ifs_time)); 1185 1186 ifs_time = (struct bss_ifs_time_tlv *)tlv; 1187 ifs_time->slot_valid = true; 1188 ifs_time->sifs_valid = true; 1189 ifs_time->rifs_valid = true; 1190 ifs_time->eifs_valid = true; 1191 1192 ifs_time->slot_time = cpu_to_le16(phy->slottime); 1193 ifs_time->sifs_time = cpu_to_le16(10); 1194 ifs_time->rifs_time = cpu_to_le16(2); 1195 ifs_time->eifs_time = cpu_to_le16(is_2ghz ? 78 : 84); 1196 1197 if (is_2ghz) { 1198 ifs_time->eifs_cck_valid = true; 1199 ifs_time->eifs_cck_time = cpu_to_le16(314); 1200 } 1201 } 1202 1203 static int 1204 mt7996_mcu_bss_basic_tlv(struct sk_buff *skb, 1205 struct ieee80211_vif *vif, 1206 struct ieee80211_bss_conf *link_conf, 1207 struct mt76_vif_link *mvif, 1208 struct mt76_phy *phy, u16 wlan_idx, 1209 bool enable) 1210 { 1211 struct cfg80211_chan_def *chandef = &phy->chandef; 1212 struct mt76_connac_bss_basic_tlv *bss; 1213 u32 type = CONNECTION_INFRA_AP; 1214 u16 sta_wlan_idx = wlan_idx; 1215 struct tlv *tlv; 1216 int idx; 1217 1218 switch (vif->type) { 1219 case NL80211_IFTYPE_MESH_POINT: 1220 case NL80211_IFTYPE_AP: 1221 case NL80211_IFTYPE_MONITOR: 1222 break; 1223 case NL80211_IFTYPE_STATION: 1224 if (enable) { 1225 struct ieee80211_sta *sta; 1226 1227 rcu_read_lock(); 1228 sta = ieee80211_find_sta(vif, link_conf->bssid); 1229 if (sta) { 1230 struct mt7996_sta *msta = (void *)sta->drv_priv; 1231 struct mt7996_sta_link *msta_link; 1232 int link_id = link_conf->link_id; 1233 1234 msta_link = mt7996_sta_link(msta, link_id); 1235 if (msta_link) 1236 sta_wlan_idx = msta_link->wcid.idx; 1237 } 1238 rcu_read_unlock(); 1239 } 1240 type = CONNECTION_INFRA_STA; 1241 break; 1242 case NL80211_IFTYPE_ADHOC: 1243 type = CONNECTION_IBSS_ADHOC; 1244 break; 1245 default: 1246 WARN_ON(1); 1247 break; 1248 } 1249 1250 tlv = mt7996_mcu_add_uni_tlv(skb, UNI_BSS_INFO_BASIC, sizeof(*bss)); 1251 1252 bss = (struct mt76_connac_bss_basic_tlv *)tlv; 1253 bss->bmc_tx_wlan_idx = cpu_to_le16(wlan_idx); 1254 bss->sta_idx = cpu_to_le16(sta_wlan_idx); 1255 bss->conn_type = cpu_to_le32(type); 1256 bss->omac_idx = mvif->omac_idx; 1257 bss->band_idx = mvif->band_idx; 1258 bss->wmm_idx = mvif->wmm_idx; 1259 bss->conn_state = !enable; 1260 bss->active = enable; 1261 1262 idx = mvif->omac_idx > EXT_BSSID_START ? HW_BSSID_0 : mvif->omac_idx; 1263 bss->hw_bss_idx = idx; 1264 1265 if (vif->type == NL80211_IFTYPE_MONITOR) { 1266 memcpy(bss->bssid, phy->macaddr, ETH_ALEN); 1267 return 0; 1268 } 1269 1270 memcpy(bss->bssid, link_conf->bssid, ETH_ALEN); 1271 bss->bcn_interval = cpu_to_le16(link_conf->beacon_int); 1272 bss->dtim_period = link_conf->dtim_period; 1273 bss->phymode = mt76_connac_get_phy_mode(phy, vif, 1274 chandef->chan->band, NULL); 1275 bss->phymode_ext = mt76_connac_get_phy_mode_ext(phy, link_conf, 1276 chandef->chan->band); 1277 1278 return 0; 1279 } 1280 1281 static struct sk_buff * 1282 __mt7996_mcu_alloc_bss_req(struct mt76_dev *dev, struct mt76_vif_link *mvif, int len) 1283 { 1284 struct bss_req_hdr hdr = { 1285 .bss_idx = mvif->idx, 1286 }; 1287 struct sk_buff *skb; 1288 1289 skb = mt76_mcu_msg_alloc(dev, NULL, len); 1290 if (!skb) 1291 return ERR_PTR(-ENOMEM); 1292 1293 skb_put_data(skb, &hdr, sizeof(hdr)); 1294 1295 return skb; 1296 } 1297 1298 int mt7996_mcu_add_bss_info(struct mt7996_phy *phy, struct ieee80211_vif *vif, 1299 struct ieee80211_bss_conf *link_conf, 1300 struct mt76_vif_link *mlink, 1301 struct mt7996_sta_link *msta_link, int enable) 1302 { 1303 struct mt7996_dev *dev = phy->dev; 1304 struct sk_buff *skb; 1305 1306 skb = __mt7996_mcu_alloc_bss_req(&dev->mt76, mlink, 1307 MT7996_BSS_UPDATE_MAX_SIZE); 1308 if (IS_ERR(skb)) 1309 return PTR_ERR(skb); 1310 1311 /* bss_basic must be first */ 1312 mt7996_mcu_bss_basic_tlv(skb, vif, link_conf, mlink, phy->mt76, 1313 msta_link->wcid.idx, enable); 1314 mt7996_mcu_bss_sec_tlv(skb, mlink); 1315 1316 if (vif->type == NL80211_IFTYPE_MONITOR) 1317 goto out; 1318 1319 if (enable) { 1320 struct mt7996_vif_link *link; 1321 1322 mt7996_mcu_bss_rfch_tlv(skb, phy); 1323 mt7996_mcu_bss_bmc_tlv(skb, mlink, phy); 1324 mt7996_mcu_bss_ra_tlv(skb, phy); 1325 mt7996_mcu_bss_txcmd_tlv(skb, true); 1326 mt7996_mcu_bss_ifs_timing_tlv(skb, phy); 1327 1328 if (vif->bss_conf.he_support) 1329 mt7996_mcu_bss_he_tlv(skb, vif, link_conf, phy); 1330 1331 /* this tag is necessary no matter if the vif is MLD */ 1332 link = container_of(mlink, struct mt7996_vif_link, mt76); 1333 mt7996_mcu_bss_mld_tlv(skb, link_conf, link); 1334 } 1335 1336 mt7996_mcu_bss_mbssid_tlv(skb, link_conf, enable); 1337 1338 out: 1339 return mt76_mcu_skb_send_msg(&dev->mt76, skb, 1340 MCU_WMWA_UNI_CMD(BSS_INFO_UPDATE), true); 1341 } 1342 1343 int mt7996_mcu_update_bss_rfch(struct mt7996_phy *phy, struct mt7996_vif_link *link) 1344 { 1345 struct mt7996_dev *dev = phy->dev; 1346 struct sk_buff *skb; 1347 1348 skb = __mt7996_mcu_alloc_bss_req(&dev->mt76, &link->mt76, 1349 MT7996_BSS_UPDATE_MAX_SIZE); 1350 if (IS_ERR(skb)) 1351 return PTR_ERR(skb); 1352 1353 mt7996_mcu_bss_rfch_tlv(skb, phy); 1354 1355 return mt76_mcu_skb_send_msg(&dev->mt76, skb, 1356 MCU_WMWA_UNI_CMD(BSS_INFO_UPDATE), true); 1357 } 1358 1359 int mt7996_mcu_set_protection(struct mt7996_phy *phy, struct mt7996_vif_link *link, 1360 u8 ht_mode, bool use_cts_prot) 1361 { 1362 struct mt7996_dev *dev = phy->dev; 1363 struct bss_prot_tlv *prot; 1364 struct sk_buff *skb; 1365 struct tlv *tlv; 1366 enum { 1367 PROT_NONMEMBER = BIT(1), 1368 PROT_20MHZ = BIT(2), 1369 PROT_NONHT_MIXED = BIT(3), 1370 PROT_LEGACY_ERP = BIT(5), 1371 PROT_NONGF_STA = BIT(7), 1372 }; 1373 1374 /* The current firmware causes TX failure. Need further investigation */ 1375 if (is_mt7996(&dev->mt76)) 1376 return 0; 1377 1378 skb = __mt7996_mcu_alloc_bss_req(&dev->mt76, &link->mt76, 1379 MT7996_BSS_UPDATE_MAX_SIZE); 1380 if (IS_ERR(skb)) 1381 return PTR_ERR(skb); 1382 1383 tlv = mt7996_mcu_add_uni_tlv(skb, UNI_BSS_INFO_PROTECT_INFO, 1384 sizeof(*prot)); 1385 prot = (struct bss_prot_tlv *)tlv; 1386 1387 switch (ht_mode & IEEE80211_HT_OP_MODE_PROTECTION) { 1388 case IEEE80211_HT_OP_MODE_PROTECTION_NONMEMBER: 1389 prot->prot_mode = cpu_to_le32(PROT_NONMEMBER); 1390 break; 1391 case IEEE80211_HT_OP_MODE_PROTECTION_20MHZ: 1392 prot->prot_mode = cpu_to_le32(PROT_20MHZ); 1393 break; 1394 case IEEE80211_HT_OP_MODE_PROTECTION_NONHT_MIXED: 1395 prot->prot_mode = cpu_to_le32(PROT_NONHT_MIXED); 1396 break; 1397 } 1398 1399 if (ht_mode & IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT) 1400 prot->prot_mode |= cpu_to_le32(PROT_NONGF_STA); 1401 1402 if (use_cts_prot) 1403 prot->prot_mode |= cpu_to_le32(PROT_LEGACY_ERP); 1404 1405 return mt76_mcu_skb_send_msg(&dev->mt76, skb, 1406 MCU_WM_UNI_CMD(BSS_INFO_UPDATE), true); 1407 } 1408 1409 int mt7996_mcu_set_emlsr_mode(struct mt7996_dev *dev, 1410 struct ieee80211_vif *vif, 1411 struct ieee80211_sta *sta, 1412 struct ieee80211_eml_params *eml_params) 1413 { 1414 struct mt7996_sta *msta = (struct mt7996_sta *)sta->drv_priv; 1415 struct mt7996_sta_link *msta_link; 1416 struct sta_rec_eml_op *eml_op; 1417 struct mt7996_vif_link *link; 1418 struct sk_buff *skb; 1419 struct tlv *tlv; 1420 1421 msta_link = mt76_dereference(msta->link[eml_params->link_id], 1422 &dev->mt76); 1423 if (!msta_link) 1424 return -EINVAL; 1425 1426 link = mt7996_vif_link(dev, vif, eml_params->link_id); 1427 if (!link) 1428 return -EINVAL; 1429 1430 skb = __mt76_connac_mcu_alloc_sta_req(&dev->mt76, &link->mt76, 1431 &msta_link->wcid, 1432 MT7996_STA_UPDATE_MAX_SIZE); 1433 if (IS_ERR(skb)) 1434 return PTR_ERR(skb); 1435 1436 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_EML_OP, sizeof(*eml_op)); 1437 eml_op = (struct sta_rec_eml_op *)tlv; 1438 eml_op->link_bitmap = 0; 1439 1440 if (eml_params->control & IEEE80211_EML_CTRL_EMLSR_MODE) { 1441 unsigned long link_bitmap = eml_params->link_bitmap; 1442 unsigned int link_id; 1443 1444 for_each_set_bit(link_id, &link_bitmap, 1445 IEEE80211_MLD_MAX_NUM_LINKS) { 1446 struct mt76_phy *mphy; 1447 1448 link = mt7996_vif_link(dev, vif, link_id); 1449 if (!link) 1450 continue; 1451 1452 mphy = mt76_vif_link_phy(&link->mt76); 1453 if (!mphy) 1454 continue; 1455 1456 eml_op->link_bitmap |= BIT(mphy->band_idx); 1457 } 1458 } 1459 1460 return mt76_mcu_skb_send_msg(&dev->mt76, skb, 1461 MCU_WMWA_UNI_CMD(STA_REC_UPDATE), true); 1462 } 1463 1464 int mt7996_mcu_set_timing(struct mt7996_phy *phy, struct ieee80211_vif *vif, 1465 struct ieee80211_bss_conf *link_conf) 1466 { 1467 struct mt7996_dev *dev = phy->dev; 1468 struct mt76_vif_link *mlink = mt76_vif_conf_link(&dev->mt76, vif, link_conf); 1469 struct sk_buff *skb; 1470 1471 skb = __mt7996_mcu_alloc_bss_req(&dev->mt76, mlink, 1472 MT7996_BSS_UPDATE_MAX_SIZE); 1473 if (IS_ERR(skb)) 1474 return PTR_ERR(skb); 1475 1476 mt7996_mcu_bss_ifs_timing_tlv(skb, phy); 1477 1478 return mt76_mcu_skb_send_msg(&dev->mt76, skb, 1479 MCU_WMWA_UNI_CMD(BSS_INFO_UPDATE), true); 1480 } 1481 1482 static int 1483 mt7996_mcu_sta_ba(struct mt7996_dev *dev, struct mt76_vif_link *mvif, 1484 struct ieee80211_ampdu_params *params, 1485 struct mt76_wcid *wcid, bool enable, bool tx) 1486 { 1487 struct sta_rec_ba_uni *ba; 1488 struct sk_buff *skb; 1489 struct tlv *tlv; 1490 1491 skb = __mt76_connac_mcu_alloc_sta_req(&dev->mt76, mvif, wcid, 1492 MT7996_STA_UPDATE_MAX_SIZE); 1493 if (IS_ERR(skb)) 1494 return PTR_ERR(skb); 1495 1496 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_BA, sizeof(*ba)); 1497 1498 ba = (struct sta_rec_ba_uni *)tlv; 1499 ba->ba_type = tx ? MT_BA_TYPE_ORIGINATOR : MT_BA_TYPE_RECIPIENT; 1500 ba->winsize = cpu_to_le16(params->buf_size); 1501 ba->ssn = cpu_to_le16(params->ssn); 1502 ba->ba_en = enable << params->tid; 1503 ba->amsdu = params->amsdu; 1504 ba->tid = params->tid; 1505 ba->ba_rdd_rro = !tx && enable && mt7996_has_hwrro(dev); 1506 1507 return mt76_mcu_skb_send_msg(&dev->mt76, skb, 1508 MCU_WMWA_UNI_CMD(STA_REC_UPDATE), true); 1509 } 1510 1511 /** starec & wtbl **/ 1512 int mt7996_mcu_add_tx_ba(struct mt7996_dev *dev, 1513 struct ieee80211_ampdu_params *params, 1514 struct ieee80211_vif *vif, unsigned long links, 1515 bool enable) 1516 { 1517 struct ieee80211_sta *sta = params->sta; 1518 struct mt7996_sta *msta = (struct mt7996_sta *)sta->drv_priv; 1519 unsigned int link_id; 1520 int ret = 0; 1521 1522 for_each_set_bit(link_id, &links, IEEE80211_MLD_MAX_NUM_LINKS) { 1523 struct mt7996_sta_link *msta_link; 1524 struct mt7996_vif_link *link; 1525 1526 msta_link = mt7996_sta_link_protected(dev, msta, link_id); 1527 if (!msta_link) 1528 continue; 1529 1530 link = mt7996_vif_link(dev, vif, link_id); 1531 if (!link) 1532 continue; 1533 1534 if (enable && !params->amsdu) 1535 msta_link->wcid.amsdu = false; 1536 1537 ret = mt7996_mcu_sta_ba(dev, &link->mt76, params, 1538 &msta_link->wcid, enable, true); 1539 if (ret) 1540 break; 1541 } 1542 1543 return ret; 1544 } 1545 1546 int mt7996_mcu_add_rx_ba(struct mt7996_dev *dev, 1547 struct ieee80211_ampdu_params *params, 1548 struct ieee80211_vif *vif, unsigned long links, 1549 bool enable) 1550 { 1551 struct ieee80211_sta *sta = params->sta; 1552 struct mt7996_sta *msta = (struct mt7996_sta *)sta->drv_priv; 1553 unsigned int link_id; 1554 int ret = 0; 1555 1556 for_each_set_bit(link_id, &links, IEEE80211_MLD_MAX_NUM_LINKS) { 1557 struct mt7996_sta_link *msta_link; 1558 struct mt7996_vif_link *link; 1559 1560 msta_link = mt7996_sta_link_protected(dev, msta, link_id); 1561 if (!msta_link) 1562 continue; 1563 1564 link = mt7996_vif_link(dev, vif, link_id); 1565 if (!link) 1566 continue; 1567 1568 ret = mt7996_mcu_sta_ba(dev, &link->mt76, params, 1569 &msta_link->wcid, enable, false); 1570 if (ret) 1571 break; 1572 } 1573 1574 return ret; 1575 } 1576 1577 static void 1578 mt7996_mcu_sta_he_tlv(struct sk_buff *skb, 1579 struct ieee80211_link_sta *link_sta, 1580 struct mt7996_vif_link *link) 1581 { 1582 struct ieee80211_he_cap_elem *elem = &link_sta->he_cap.he_cap_elem; 1583 struct ieee80211_he_mcs_nss_supp mcs_map; 1584 struct sta_rec_he_v2 *he; 1585 struct tlv *tlv; 1586 int i = 0; 1587 1588 if (!link_sta->he_cap.has_he) 1589 return; 1590 1591 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_HE_V2, sizeof(*he)); 1592 1593 he = (struct sta_rec_he_v2 *)tlv; 1594 for (i = 0; i < 11; i++) { 1595 if (i < 6) 1596 he->he_mac_cap[i] = elem->mac_cap_info[i]; 1597 he->he_phy_cap[i] = elem->phy_cap_info[i]; 1598 } 1599 1600 mcs_map = link_sta->he_cap.he_mcs_nss_supp; 1601 switch (link_sta->bandwidth) { 1602 case IEEE80211_STA_RX_BW_160: 1603 if (elem->phy_cap_info[0] & 1604 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_80PLUS80_MHZ_IN_5G) 1605 mt7996_mcu_set_sta_he_mcs(link_sta, link, 1606 &he->max_nss_mcs[CMD_HE_MCS_BW8080], 1607 le16_to_cpu(mcs_map.rx_mcs_80p80)); 1608 1609 mt7996_mcu_set_sta_he_mcs(link_sta, link, 1610 &he->max_nss_mcs[CMD_HE_MCS_BW160], 1611 le16_to_cpu(mcs_map.rx_mcs_160)); 1612 fallthrough; 1613 default: 1614 mt7996_mcu_set_sta_he_mcs(link_sta, link, 1615 &he->max_nss_mcs[CMD_HE_MCS_BW80], 1616 le16_to_cpu(mcs_map.rx_mcs_80)); 1617 break; 1618 } 1619 1620 he->pkt_ext = 2; 1621 } 1622 1623 static void 1624 mt7996_mcu_sta_he_6g_tlv(struct sk_buff *skb, 1625 struct ieee80211_link_sta *link_sta) 1626 { 1627 struct sta_rec_he_6g_capa *he_6g; 1628 struct tlv *tlv; 1629 1630 if (!link_sta->he_6ghz_capa.capa) 1631 return; 1632 1633 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_HE_6G, sizeof(*he_6g)); 1634 1635 he_6g = (struct sta_rec_he_6g_capa *)tlv; 1636 he_6g->capa = link_sta->he_6ghz_capa.capa; 1637 } 1638 1639 static void 1640 mt7996_mcu_sta_eht_tlv(struct sk_buff *skb, 1641 struct ieee80211_link_sta *link_sta) 1642 { 1643 struct mt7996_sta *msta = (struct mt7996_sta *)link_sta->sta->drv_priv; 1644 struct ieee80211_vif *vif = container_of((void *)msta->vif, 1645 struct ieee80211_vif, drv_priv); 1646 struct ieee80211_eht_mcs_nss_supp *mcs_map; 1647 struct ieee80211_eht_cap_elem_fixed *elem; 1648 struct sta_rec_eht *eht; 1649 struct tlv *tlv; 1650 1651 if (!link_sta->eht_cap.has_eht) 1652 return; 1653 1654 mcs_map = &link_sta->eht_cap.eht_mcs_nss_supp; 1655 elem = &link_sta->eht_cap.eht_cap_elem; 1656 1657 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_EHT, sizeof(*eht)); 1658 1659 eht = (struct sta_rec_eht *)tlv; 1660 eht->tid_bitmap = 0xff; 1661 eht->mac_cap = cpu_to_le16(*(u16 *)elem->mac_cap_info); 1662 eht->phy_cap = cpu_to_le64(*(u64 *)elem->phy_cap_info); 1663 eht->phy_cap_ext = cpu_to_le64(elem->phy_cap_info[8]); 1664 1665 if (vif->type != NL80211_IFTYPE_STATION && 1666 (link_sta->he_cap.he_cap_elem.phy_cap_info[0] & 1667 (IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_40MHZ_IN_2G | 1668 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_40MHZ_80MHZ_IN_5G | 1669 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_160MHZ_IN_5G | 1670 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_80PLUS80_MHZ_IN_5G)) == 0) { 1671 memcpy(eht->mcs_map_bw20, &mcs_map->only_20mhz, 1672 sizeof(eht->mcs_map_bw20)); 1673 return; 1674 } 1675 1676 memcpy(eht->mcs_map_bw80, &mcs_map->bw._80, sizeof(eht->mcs_map_bw80)); 1677 memcpy(eht->mcs_map_bw160, &mcs_map->bw._160, sizeof(eht->mcs_map_bw160)); 1678 memcpy(eht->mcs_map_bw320, &mcs_map->bw._320, sizeof(eht->mcs_map_bw320)); 1679 } 1680 1681 static void 1682 mt7996_mcu_sta_ht_tlv(struct sk_buff *skb, struct ieee80211_link_sta *link_sta) 1683 { 1684 struct sta_rec_ht_uni *ht; 1685 struct tlv *tlv; 1686 1687 if (!link_sta->ht_cap.ht_supported) 1688 return; 1689 1690 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_HT, sizeof(*ht)); 1691 1692 ht = (struct sta_rec_ht_uni *)tlv; 1693 ht->ht_cap = cpu_to_le16(link_sta->ht_cap.cap); 1694 ht->ampdu_param = u8_encode_bits(link_sta->ht_cap.ampdu_factor, 1695 IEEE80211_HT_AMPDU_PARM_FACTOR) | 1696 u8_encode_bits(link_sta->ht_cap.ampdu_density, 1697 IEEE80211_HT_AMPDU_PARM_DENSITY); 1698 } 1699 1700 static void 1701 mt7996_mcu_sta_vht_tlv(struct sk_buff *skb, struct ieee80211_link_sta *link_sta) 1702 { 1703 struct sta_rec_vht *vht; 1704 struct tlv *tlv; 1705 1706 /* For 6G band, this tlv is necessary to let hw work normally */ 1707 if (!link_sta->he_6ghz_capa.capa && !link_sta->vht_cap.vht_supported) 1708 return; 1709 1710 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_VHT, sizeof(*vht)); 1711 1712 vht = (struct sta_rec_vht *)tlv; 1713 vht->vht_cap = cpu_to_le32(link_sta->vht_cap.cap); 1714 vht->vht_rx_mcs_map = link_sta->vht_cap.vht_mcs.rx_mcs_map; 1715 vht->vht_tx_mcs_map = link_sta->vht_cap.vht_mcs.tx_mcs_map; 1716 } 1717 1718 static void 1719 mt7996_mcu_sta_amsdu_tlv(struct mt7996_dev *dev, struct sk_buff *skb, 1720 struct ieee80211_vif *vif, 1721 struct ieee80211_link_sta *link_sta, 1722 struct mt7996_sta_link *msta_link) 1723 { 1724 struct sta_rec_amsdu *amsdu; 1725 struct tlv *tlv; 1726 1727 if (vif->type != NL80211_IFTYPE_STATION && 1728 vif->type != NL80211_IFTYPE_MESH_POINT && 1729 vif->type != NL80211_IFTYPE_AP) 1730 return; 1731 1732 if (!link_sta->agg.max_amsdu_len) 1733 return; 1734 1735 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_HW_AMSDU, sizeof(*amsdu)); 1736 amsdu = (struct sta_rec_amsdu *)tlv; 1737 amsdu->max_amsdu_num = 8; 1738 amsdu->amsdu_en = true; 1739 msta_link->wcid.amsdu = true; 1740 1741 switch (link_sta->agg.max_amsdu_len) { 1742 case IEEE80211_MAX_MPDU_LEN_VHT_11454: 1743 amsdu->max_mpdu_size = 1744 IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_11454; 1745 return; 1746 case IEEE80211_MAX_MPDU_LEN_HT_7935: 1747 case IEEE80211_MAX_MPDU_LEN_VHT_7991: 1748 amsdu->max_mpdu_size = IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_7991; 1749 return; 1750 default: 1751 amsdu->max_mpdu_size = IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_3895; 1752 return; 1753 } 1754 } 1755 1756 static void 1757 mt7996_mcu_sta_muru_tlv(struct mt7996_dev *dev, struct sk_buff *skb, 1758 struct ieee80211_bss_conf *link_conf, 1759 struct ieee80211_link_sta *link_sta) 1760 { 1761 struct ieee80211_he_cap_elem *elem = &link_sta->he_cap.he_cap_elem; 1762 struct sta_rec_muru *muru; 1763 struct tlv *tlv; 1764 1765 if (link_conf->vif->type != NL80211_IFTYPE_STATION && 1766 link_conf->vif->type != NL80211_IFTYPE_AP) 1767 return; 1768 1769 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_MURU, sizeof(*muru)); 1770 1771 muru = (struct sta_rec_muru *)tlv; 1772 muru->cfg.mimo_dl_en = link_conf->eht_mu_beamformer || 1773 link_conf->he_mu_beamformer || 1774 link_conf->vht_mu_beamformer || 1775 link_conf->vht_mu_beamformee; 1776 muru->cfg.ofdma_dl_en = true; 1777 1778 if (link_sta->vht_cap.vht_supported) 1779 muru->mimo_dl.vht_mu_bfee = 1780 !!(link_sta->vht_cap.cap & IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE); 1781 1782 if (!link_sta->he_cap.has_he) 1783 return; 1784 1785 muru->mimo_dl.partial_bw_dl_mimo = 1786 HE_PHY(CAP6_PARTIAL_BANDWIDTH_DL_MUMIMO, elem->phy_cap_info[6]); 1787 1788 muru->mimo_ul.full_ul_mimo = 1789 HE_PHY(CAP2_UL_MU_FULL_MU_MIMO, elem->phy_cap_info[2]); 1790 muru->mimo_ul.partial_ul_mimo = 1791 HE_PHY(CAP2_UL_MU_PARTIAL_MU_MIMO, elem->phy_cap_info[2]); 1792 1793 muru->ofdma_dl.punc_pream_rx = 1794 HE_PHY(CAP1_PREAMBLE_PUNC_RX_MASK, elem->phy_cap_info[1]); 1795 muru->ofdma_dl.he_20m_in_40m_2g = 1796 HE_PHY(CAP8_20MHZ_IN_40MHZ_HE_PPDU_IN_2G, elem->phy_cap_info[8]); 1797 muru->ofdma_dl.he_20m_in_160m = 1798 HE_PHY(CAP8_20MHZ_IN_160MHZ_HE_PPDU, elem->phy_cap_info[8]); 1799 muru->ofdma_dl.he_80m_in_160m = 1800 HE_PHY(CAP8_80MHZ_IN_160MHZ_HE_PPDU, elem->phy_cap_info[8]); 1801 1802 muru->ofdma_ul.t_frame_dur = 1803 HE_MAC(CAP1_TF_MAC_PAD_DUR_MASK, elem->mac_cap_info[1]); 1804 muru->ofdma_ul.mu_cascading = 1805 HE_MAC(CAP2_MU_CASCADING, elem->mac_cap_info[2]); 1806 muru->ofdma_ul.uo_ra = 1807 HE_MAC(CAP3_OFDMA_RA, elem->mac_cap_info[3]); 1808 muru->ofdma_ul.rx_ctrl_frame_to_mbss = 1809 HE_MAC(CAP3_RX_CTRL_FRAME_TO_MULTIBSS, elem->mac_cap_info[3]); 1810 } 1811 1812 static inline bool 1813 mt7996_is_ebf_supported(struct mt7996_phy *phy, 1814 struct ieee80211_bss_conf *link_conf, 1815 struct ieee80211_link_sta *link_sta, bool bfee) 1816 { 1817 int sts = hweight16(phy->mt76->chainmask); 1818 1819 if (link_conf->vif->type != NL80211_IFTYPE_STATION && 1820 link_conf->vif->type != NL80211_IFTYPE_AP) 1821 return false; 1822 1823 if (!bfee && sts < 2) 1824 return false; 1825 1826 if (link_sta->eht_cap.has_eht) { 1827 struct ieee80211_sta_eht_cap *pc = &link_sta->eht_cap; 1828 struct ieee80211_eht_cap_elem_fixed *pe = &pc->eht_cap_elem; 1829 1830 if (bfee) 1831 return link_conf->eht_su_beamformee && 1832 EHT_PHY(CAP0_SU_BEAMFORMER, pe->phy_cap_info[0]); 1833 else 1834 return link_conf->eht_su_beamformer && 1835 EHT_PHY(CAP0_SU_BEAMFORMEE, pe->phy_cap_info[0]); 1836 } 1837 1838 if (link_sta->he_cap.has_he) { 1839 struct ieee80211_he_cap_elem *pe = &link_sta->he_cap.he_cap_elem; 1840 1841 if (bfee) 1842 return link_conf->he_su_beamformee && 1843 HE_PHY(CAP3_SU_BEAMFORMER, pe->phy_cap_info[3]); 1844 else 1845 return link_conf->he_su_beamformer && 1846 HE_PHY(CAP4_SU_BEAMFORMEE, pe->phy_cap_info[4]); 1847 } 1848 1849 if (link_sta->vht_cap.vht_supported) { 1850 u32 cap = link_sta->vht_cap.cap; 1851 1852 if (bfee) 1853 return link_conf->vht_su_beamformee && 1854 (cap & IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE); 1855 else 1856 return link_conf->vht_su_beamformer && 1857 (cap & IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE); 1858 } 1859 1860 return false; 1861 } 1862 1863 static void 1864 mt7996_mcu_sta_sounding_rate(struct sta_rec_bf *bf, struct mt7996_phy *phy) 1865 { 1866 bf->sounding_phy = MT_PHY_TYPE_OFDM; 1867 bf->ndp_rate = 0; /* mcs0 */ 1868 if (is_mt7996(phy->mt76->dev)) 1869 bf->ndpa_rate = MT7996_CFEND_RATE_DEFAULT; /* ofdm 24m */ 1870 else 1871 bf->ndpa_rate = MT7992_CFEND_RATE_DEFAULT; /* ofdm 6m */ 1872 1873 bf->rept_poll_rate = MT7996_CFEND_RATE_DEFAULT; /* ofdm 24m */ 1874 } 1875 1876 static void 1877 mt7996_mcu_sta_bfer_ht(struct ieee80211_link_sta *link_sta, 1878 struct mt7996_phy *phy, struct sta_rec_bf *bf, 1879 bool explicit) 1880 { 1881 struct ieee80211_mcs_info *mcs = &link_sta->ht_cap.mcs; 1882 u8 n = 0; 1883 1884 bf->tx_mode = MT_PHY_TYPE_HT; 1885 1886 if ((mcs->tx_params & IEEE80211_HT_MCS_TX_RX_DIFF) && 1887 (mcs->tx_params & IEEE80211_HT_MCS_TX_DEFINED)) 1888 n = FIELD_GET(IEEE80211_HT_MCS_TX_MAX_STREAMS_MASK, 1889 mcs->tx_params); 1890 else if (mcs->rx_mask[3]) 1891 n = 3; 1892 else if (mcs->rx_mask[2]) 1893 n = 2; 1894 else if (mcs->rx_mask[1]) 1895 n = 1; 1896 1897 bf->nrow = hweight8(phy->mt76->antenna_mask) - 1; 1898 bf->ncol = min_t(u8, bf->nrow, n); 1899 bf->ibf_ncol = explicit ? min_t(u8, MT7996_IBF_MAX_NC, bf->ncol) : 1900 min_t(u8, MT7996_IBF_MAX_NC, n); 1901 } 1902 1903 static void 1904 mt7996_mcu_sta_bfer_vht(struct ieee80211_link_sta *link_sta, 1905 struct mt7996_phy *phy, struct sta_rec_bf *bf, 1906 bool explicit) 1907 { 1908 struct ieee80211_sta_vht_cap *pc = &link_sta->vht_cap; 1909 struct ieee80211_sta_vht_cap *vc = &phy->mt76->sband_5g.sband.vht_cap; 1910 u16 mcs_map = le16_to_cpu(pc->vht_mcs.rx_mcs_map); 1911 u8 nss_mcs = mt7996_mcu_get_sta_nss(mcs_map); 1912 u8 tx_ant = hweight8(phy->mt76->antenna_mask) - 1; 1913 1914 bf->tx_mode = MT_PHY_TYPE_VHT; 1915 1916 if (explicit) { 1917 u8 sts, snd_dim; 1918 1919 mt7996_mcu_sta_sounding_rate(bf, phy); 1920 1921 sts = FIELD_GET(IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK, 1922 pc->cap); 1923 snd_dim = FIELD_GET(IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK, 1924 vc->cap); 1925 bf->nrow = min_t(u8, min_t(u8, snd_dim, sts), tx_ant); 1926 bf->ncol = min_t(u8, nss_mcs, bf->nrow); 1927 bf->ibf_ncol = min_t(u8, MT7996_IBF_MAX_NC, bf->ncol); 1928 1929 if (link_sta->bandwidth == IEEE80211_STA_RX_BW_160) 1930 bf->nrow = 1; 1931 } else { 1932 bf->nrow = tx_ant; 1933 bf->ncol = min_t(u8, nss_mcs, bf->nrow); 1934 bf->ibf_ncol = min_t(u8, MT7996_IBF_MAX_NC, nss_mcs); 1935 1936 if (link_sta->bandwidth == IEEE80211_STA_RX_BW_160) 1937 bf->ibf_nrow = 1; 1938 } 1939 } 1940 1941 static void 1942 mt7996_mcu_sta_bfer_he(struct ieee80211_link_sta *link_sta, 1943 struct ieee80211_vif *vif, struct mt7996_phy *phy, 1944 struct sta_rec_bf *bf, bool explicit) 1945 { 1946 struct ieee80211_sta_he_cap *pc = &link_sta->he_cap; 1947 struct ieee80211_he_cap_elem *pe = &pc->he_cap_elem; 1948 u16 mcs_map = le16_to_cpu(pc->he_mcs_nss_supp.rx_mcs_80); 1949 u8 nss_mcs = mt7996_mcu_get_sta_nss(mcs_map); 1950 const struct ieee80211_he_cap_elem *ve; 1951 const struct ieee80211_sta_he_cap *vc; 1952 u8 snd_dim, sts; 1953 1954 vc = mt76_connac_get_he_phy_cap(phy->mt76, vif); 1955 if (!vc) 1956 return; 1957 1958 bf->tx_mode = MT_PHY_TYPE_HE_SU; 1959 ve = &vc->he_cap_elem; 1960 1961 mt7996_mcu_sta_sounding_rate(bf, phy); 1962 1963 bf->trigger_su = HE_PHY(CAP6_TRIG_SU_BEAMFORMING_FB, 1964 pe->phy_cap_info[6]); 1965 bf->trigger_mu = HE_PHY(CAP6_TRIG_MU_BEAMFORMING_PARTIAL_BW_FB, 1966 pe->phy_cap_info[6]); 1967 snd_dim = HE_PHY(CAP5_BEAMFORMEE_NUM_SND_DIM_UNDER_80MHZ_MASK, 1968 ve->phy_cap_info[5]); 1969 sts = HE_PHY(CAP4_BEAMFORMEE_MAX_STS_UNDER_80MHZ_MASK, 1970 pe->phy_cap_info[4]); 1971 bf->nrow = min_t(u8, snd_dim, sts); 1972 bf->ncol = min_t(u8, nss_mcs, bf->nrow); 1973 bf->ibf_ncol = explicit ? min_t(u8, MT7996_IBF_MAX_NC, bf->ncol) : 1974 min_t(u8, MT7996_IBF_MAX_NC, nss_mcs); 1975 1976 if (link_sta->bandwidth != IEEE80211_STA_RX_BW_160) 1977 return; 1978 1979 /* go over for 160MHz and 80p80 */ 1980 if (pe->phy_cap_info[0] & 1981 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_160MHZ_IN_5G) { 1982 mcs_map = le16_to_cpu(pc->he_mcs_nss_supp.rx_mcs_160); 1983 nss_mcs = mt7996_mcu_get_sta_nss(mcs_map); 1984 1985 bf->ncol_gt_bw80 = nss_mcs; 1986 } 1987 1988 if (pe->phy_cap_info[0] & 1989 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_80PLUS80_MHZ_IN_5G) { 1990 mcs_map = le16_to_cpu(pc->he_mcs_nss_supp.rx_mcs_80p80); 1991 nss_mcs = mt7996_mcu_get_sta_nss(mcs_map); 1992 1993 if (bf->ncol_gt_bw80) 1994 bf->ncol_gt_bw80 = min_t(u8, bf->ncol_gt_bw80, nss_mcs); 1995 else 1996 bf->ncol_gt_bw80 = nss_mcs; 1997 } 1998 1999 snd_dim = HE_PHY(CAP5_BEAMFORMEE_NUM_SND_DIM_ABOVE_80MHZ_MASK, 2000 ve->phy_cap_info[5]); 2001 sts = HE_PHY(CAP4_BEAMFORMEE_MAX_STS_ABOVE_80MHZ_MASK, 2002 pe->phy_cap_info[4]); 2003 2004 bf->nrow_gt_bw80 = min_t(int, snd_dim, sts); 2005 } 2006 2007 static void 2008 mt7996_mcu_sta_bfer_eht(struct ieee80211_link_sta *link_sta, 2009 struct ieee80211_vif *vif, struct mt7996_phy *phy, 2010 struct sta_rec_bf *bf, bool explicit) 2011 { 2012 struct ieee80211_sta_eht_cap *pc = &link_sta->eht_cap; 2013 struct ieee80211_eht_cap_elem_fixed *pe = &pc->eht_cap_elem; 2014 struct ieee80211_eht_mcs_nss_supp *eht_nss = &pc->eht_mcs_nss_supp; 2015 u8 nss_mcs = u8_get_bits(eht_nss->bw._80.rx_tx_mcs9_max_nss, 2016 IEEE80211_EHT_MCS_NSS_RX) - 1; 2017 const struct ieee80211_eht_cap_elem_fixed *ve; 2018 const struct ieee80211_sta_eht_cap *vc; 2019 u8 snd_dim, sts; 2020 2021 vc = mt76_connac_get_eht_phy_cap(phy->mt76, vif); 2022 if (!vc) 2023 return; 2024 2025 bf->tx_mode = MT_PHY_TYPE_EHT_MU; 2026 ve = &vc->eht_cap_elem; 2027 2028 mt7996_mcu_sta_sounding_rate(bf, phy); 2029 2030 bf->trigger_su = EHT_PHY(CAP3_TRIG_SU_BF_FDBK, pe->phy_cap_info[3]); 2031 bf->trigger_mu = EHT_PHY(CAP3_TRIG_MU_BF_PART_BW_FDBK, pe->phy_cap_info[3]); 2032 snd_dim = EHT_PHY(CAP2_SOUNDING_DIM_80MHZ_MASK, ve->phy_cap_info[2]); 2033 sts = EHT_PHY(CAP0_BEAMFORMEE_SS_80MHZ_MASK, pe->phy_cap_info[0]) + 2034 (EHT_PHY(CAP1_BEAMFORMEE_SS_80MHZ_MASK, pe->phy_cap_info[1]) << 1); 2035 bf->nrow = min_t(u8, snd_dim, sts); 2036 bf->ncol = min_t(u8, nss_mcs, bf->nrow); 2037 bf->ibf_ncol = explicit ? min_t(u8, MT7996_IBF_MAX_NC, bf->ncol) : 2038 min_t(u8, MT7996_IBF_MAX_NC, nss_mcs); 2039 2040 if (link_sta->bandwidth < IEEE80211_STA_RX_BW_160) 2041 return; 2042 2043 switch (link_sta->bandwidth) { 2044 case IEEE80211_STA_RX_BW_160: 2045 snd_dim = EHT_PHY(CAP2_SOUNDING_DIM_160MHZ_MASK, ve->phy_cap_info[2]); 2046 sts = EHT_PHY(CAP1_BEAMFORMEE_SS_160MHZ_MASK, pe->phy_cap_info[1]); 2047 nss_mcs = u8_get_bits(eht_nss->bw._160.rx_tx_mcs9_max_nss, 2048 IEEE80211_EHT_MCS_NSS_RX) - 1; 2049 2050 bf->nrow_gt_bw80 = min_t(u8, snd_dim, sts); 2051 bf->ncol_gt_bw80 = nss_mcs; 2052 break; 2053 case IEEE80211_STA_RX_BW_320: 2054 snd_dim = EHT_PHY(CAP2_SOUNDING_DIM_320MHZ_MASK, ve->phy_cap_info[2]) + 2055 (EHT_PHY(CAP3_SOUNDING_DIM_320MHZ_MASK, 2056 ve->phy_cap_info[3]) << 1); 2057 sts = EHT_PHY(CAP1_BEAMFORMEE_SS_320MHZ_MASK, pe->phy_cap_info[1]); 2058 nss_mcs = u8_get_bits(eht_nss->bw._320.rx_tx_mcs9_max_nss, 2059 IEEE80211_EHT_MCS_NSS_RX) - 1; 2060 2061 bf->nrow_gt_bw80 = min_t(u8, snd_dim, sts) << 4; 2062 bf->ncol_gt_bw80 = nss_mcs << 4; 2063 break; 2064 default: 2065 break; 2066 } 2067 } 2068 2069 static void 2070 mt7996_mcu_sta_bfer_tlv(struct mt7996_dev *dev, struct sk_buff *skb, 2071 struct ieee80211_bss_conf *link_conf, 2072 struct ieee80211_link_sta *link_sta, 2073 struct mt7996_vif_link *link) 2074 { 2075 #define EBF_MODE BIT(0) 2076 #define IBF_MODE BIT(1) 2077 #define BF_MAT_ORDER 4 2078 struct mt7996_phy *phy = mt7996_vif_link_phy(link); 2079 struct ieee80211_vif *vif = link_conf->vif; 2080 struct sta_rec_bf *bf; 2081 struct tlv *tlv; 2082 static const u8 matrix[BF_MAT_ORDER][BF_MAT_ORDER] = { 2083 {0, 0, 0, 0}, 2084 {1, 1, 0, 0}, /* 2x1, 2x2, 2x3, 2x4 */ 2085 {2, 4, 4, 0}, /* 3x1, 3x2, 3x3, 3x4 */ 2086 {3, 5, 6, 0} /* 4x1, 4x2, 4x3, 4x4 */ 2087 }; 2088 int tx_ant; 2089 bool ebf; 2090 2091 if (!phy) 2092 return; 2093 2094 if (!(link_sta->ht_cap.ht_supported || link_sta->he_cap.has_he)) 2095 return; 2096 2097 ebf = mt7996_is_ebf_supported(phy, link_conf, link_sta, false); 2098 if (!ebf && !dev->ibf) 2099 return; 2100 2101 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_BF, sizeof(*bf)); 2102 bf = (struct sta_rec_bf *)tlv; 2103 2104 /* he/eht: eBF only, except mt7992 that has 5T on 5GHz also supports iBF 2105 * vht: support eBF and iBF 2106 * ht: iBF only, since mac80211 lacks of eBF support 2107 */ 2108 if (link_sta->eht_cap.has_eht) 2109 mt7996_mcu_sta_bfer_eht(link_sta, vif, phy, bf, ebf); 2110 else if (link_sta->he_cap.has_he) 2111 mt7996_mcu_sta_bfer_he(link_sta, vif, phy, bf, ebf); 2112 else if (link_sta->vht_cap.vht_supported) 2113 mt7996_mcu_sta_bfer_vht(link_sta, phy, bf, ebf); 2114 else if (link_sta->ht_cap.ht_supported) 2115 mt7996_mcu_sta_bfer_ht(link_sta, phy, bf, ebf); 2116 else 2117 return; 2118 2119 bf->bf_cap = ebf ? EBF_MODE : (dev->ibf ? IBF_MODE : 0); 2120 tx_ant = hweight16(phy->mt76->chainmask) - 1; 2121 if (is_mt7992(&dev->mt76) && tx_ant == 4) 2122 bf->bf_cap |= IBF_MODE; 2123 2124 bf->bw = link_sta->bandwidth; 2125 bf->ibf_dbw = link_sta->bandwidth; 2126 bf->ibf_nrow = tx_ant; 2127 2128 if (link_sta->eht_cap.has_eht || link_sta->he_cap.has_he) 2129 bf->ibf_timeout = is_mt7992(&dev->mt76) ? MT7992_IBF_TIMEOUT : 2130 MT7996_IBF_TIMEOUT; 2131 else if (!ebf && link_sta->bandwidth <= IEEE80211_STA_RX_BW_40 && !bf->ncol) 2132 bf->ibf_timeout = MT7996_IBF_TIMEOUT_LEGACY; 2133 else 2134 bf->ibf_timeout = MT7996_IBF_TIMEOUT; 2135 2136 if (bf->ncol < BF_MAT_ORDER) { 2137 if (ebf) 2138 bf->mem_20m = tx_ant < BF_MAT_ORDER ? 2139 matrix[tx_ant][bf->ncol] : 0; 2140 else 2141 bf->mem_20m = bf->nrow < BF_MAT_ORDER ? 2142 matrix[bf->nrow][bf->ncol] : 0; 2143 } 2144 } 2145 2146 static void 2147 mt7996_mcu_sta_bfee_tlv(struct mt7996_dev *dev, struct sk_buff *skb, 2148 struct ieee80211_bss_conf *link_conf, 2149 struct ieee80211_link_sta *link_sta, 2150 struct mt7996_vif_link *link) 2151 { 2152 struct mt7996_phy *phy = mt7996_vif_link_phy(link); 2153 struct sta_rec_bfee *bfee; 2154 struct tlv *tlv; 2155 u8 nrow = 0; 2156 int tx_ant; 2157 2158 if (!phy) 2159 return; 2160 2161 if (!(link_sta->vht_cap.vht_supported || link_sta->he_cap.has_he)) 2162 return; 2163 2164 if (!mt7996_is_ebf_supported(phy, link_conf, link_sta, true)) 2165 return; 2166 2167 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_BFEE, sizeof(*bfee)); 2168 bfee = (struct sta_rec_bfee *)tlv; 2169 2170 if (link_sta->he_cap.has_he) { 2171 struct ieee80211_he_cap_elem *pe = &link_sta->he_cap.he_cap_elem; 2172 2173 nrow = HE_PHY(CAP5_BEAMFORMEE_NUM_SND_DIM_UNDER_80MHZ_MASK, 2174 pe->phy_cap_info[5]); 2175 } else if (link_sta->vht_cap.vht_supported) { 2176 struct ieee80211_sta_vht_cap *pc = &link_sta->vht_cap; 2177 2178 nrow = FIELD_GET(IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK, 2179 pc->cap); 2180 } 2181 2182 /* reply with identity matrix to avoid 2x2 BF negative gain */ 2183 tx_ant = hweight8(phy->mt76->antenna_mask) - 1; 2184 bfee->fb_identity_matrix = (nrow == 1 && tx_ant == 2); 2185 } 2186 2187 static void 2188 mt7996_mcu_sta_tx_proc_tlv(struct sk_buff *skb) 2189 { 2190 struct sta_rec_tx_proc *tx_proc; 2191 struct tlv *tlv; 2192 2193 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_TX_PROC, sizeof(*tx_proc)); 2194 2195 tx_proc = (struct sta_rec_tx_proc *)tlv; 2196 tx_proc->flag = cpu_to_le32(0); 2197 } 2198 2199 static void 2200 mt7996_mcu_sta_hdrt_tlv(struct mt7996_dev *dev, struct sk_buff *skb) 2201 { 2202 struct sta_rec_hdrt *hdrt; 2203 struct tlv *tlv; 2204 2205 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_HDRT, sizeof(*hdrt)); 2206 2207 hdrt = (struct sta_rec_hdrt *)tlv; 2208 hdrt->hdrt_mode = 1; 2209 } 2210 2211 static void 2212 mt7996_mcu_sta_hdr_trans_tlv(struct mt7996_dev *dev, struct sk_buff *skb, 2213 struct ieee80211_vif *vif, struct mt76_wcid *wcid) 2214 { 2215 struct sta_rec_hdr_trans *hdr_trans; 2216 struct tlv *tlv; 2217 2218 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_HDR_TRANS, sizeof(*hdr_trans)); 2219 hdr_trans = (struct sta_rec_hdr_trans *)tlv; 2220 hdr_trans->dis_rx_hdr_tran = true; 2221 2222 if (vif->type == NL80211_IFTYPE_STATION) 2223 hdr_trans->to_ds = true; 2224 else 2225 hdr_trans->from_ds = true; 2226 2227 if (!wcid) 2228 return; 2229 2230 hdr_trans->dis_rx_hdr_tran = !test_bit(MT_WCID_FLAG_HDR_TRANS, &wcid->flags); 2231 if (test_bit(MT_WCID_FLAG_4ADDR, &wcid->flags)) { 2232 hdr_trans->to_ds = true; 2233 hdr_trans->from_ds = true; 2234 } 2235 2236 if (vif->type == NL80211_IFTYPE_MESH_POINT) { 2237 hdr_trans->to_ds = true; 2238 hdr_trans->from_ds = true; 2239 hdr_trans->mesh = true; 2240 } 2241 2242 if (test_bit(MT_WCID_FLAG_TDLS_PEER, &wcid->flags)) { 2243 hdr_trans->to_ds = false; 2244 hdr_trans->from_ds = false; 2245 } 2246 } 2247 2248 static enum mcu_mmps_mode 2249 mt7996_mcu_get_mmps_mode(enum ieee80211_smps_mode smps) 2250 { 2251 switch (smps) { 2252 case IEEE80211_SMPS_OFF: 2253 return MCU_MMPS_DISABLE; 2254 case IEEE80211_SMPS_STATIC: 2255 return MCU_MMPS_STATIC; 2256 case IEEE80211_SMPS_DYNAMIC: 2257 return MCU_MMPS_DYNAMIC; 2258 default: 2259 return MCU_MMPS_DISABLE; 2260 } 2261 } 2262 2263 int mt7996_mcu_set_fixed_rate_ctrl(struct mt7996_dev *dev, 2264 void *data, u16 version) 2265 { 2266 struct uni_header hdr = {}; 2267 struct ra_fixed_rate *req; 2268 struct sk_buff *skb; 2269 struct tlv *tlv; 2270 int len; 2271 2272 len = sizeof(hdr) + sizeof(*req); 2273 2274 skb = mt76_mcu_msg_alloc(&dev->mt76, NULL, len); 2275 if (!skb) 2276 return -ENOMEM; 2277 2278 skb_put_data(skb, &hdr, sizeof(hdr)); 2279 2280 tlv = mt7996_mcu_add_uni_tlv(skb, UNI_RA_FIXED_RATE, sizeof(*req)); 2281 req = (struct ra_fixed_rate *)tlv; 2282 req->version = cpu_to_le16(version); 2283 memcpy(&req->rate, data, sizeof(req->rate)); 2284 2285 return mt76_mcu_skb_send_msg(&dev->mt76, skb, 2286 MCU_WM_UNI_CMD(RA), true); 2287 } 2288 2289 int mt7996_mcu_set_fixed_field(struct mt7996_dev *dev, struct mt7996_sta *msta, 2290 void *data, u8 link_id, u32 field) 2291 { 2292 struct mt7996_vif *mvif = msta->vif; 2293 struct mt7996_sta_link *msta_link; 2294 struct sta_rec_ra_fixed_uni *ra; 2295 struct sta_phy_uni *phy = data; 2296 struct mt76_vif_link *mlink; 2297 struct sk_buff *skb; 2298 int err = -ENODEV; 2299 struct tlv *tlv; 2300 2301 rcu_read_lock(); 2302 2303 mlink = rcu_dereference(mvif->mt76.link[link_id]); 2304 if (!mlink) 2305 goto error_unlock; 2306 2307 msta_link = mt7996_sta_link(msta, link_id); 2308 if (!msta_link) 2309 goto error_unlock; 2310 2311 skb = __mt76_connac_mcu_alloc_sta_req(&dev->mt76, mlink, 2312 &msta_link->wcid, 2313 MT7996_STA_UPDATE_MAX_SIZE); 2314 if (IS_ERR(skb)) { 2315 err = PTR_ERR(skb); 2316 goto error_unlock; 2317 } 2318 2319 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_RA_UPDATE, sizeof(*ra)); 2320 ra = (struct sta_rec_ra_fixed_uni *)tlv; 2321 2322 switch (field) { 2323 case RATE_PARAM_AUTO: 2324 break; 2325 case RATE_PARAM_FIXED: 2326 case RATE_PARAM_FIXED_MCS: 2327 case RATE_PARAM_FIXED_GI: 2328 case RATE_PARAM_FIXED_HE_LTF: 2329 if (phy) 2330 ra->phy = *phy; 2331 break; 2332 case RATE_PARAM_MMPS_UPDATE: { 2333 struct ieee80211_sta *sta = wcid_to_sta(&msta_link->wcid); 2334 struct ieee80211_link_sta *link_sta; 2335 2336 link_sta = rcu_dereference(sta->link[link_id]); 2337 if (!link_sta) { 2338 dev_kfree_skb(skb); 2339 goto error_unlock; 2340 } 2341 2342 ra->mmps_mode = mt7996_mcu_get_mmps_mode(link_sta->smps_mode); 2343 break; 2344 } 2345 default: 2346 break; 2347 } 2348 ra->field = cpu_to_le32(field); 2349 2350 rcu_read_unlock(); 2351 2352 return mt76_mcu_skb_send_msg(&dev->mt76, skb, 2353 MCU_WMWA_UNI_CMD(STA_REC_UPDATE), true); 2354 error_unlock: 2355 rcu_read_unlock(); 2356 2357 return err; 2358 } 2359 2360 static int 2361 mt7996_mcu_add_rate_ctrl_fixed(struct mt7996_dev *dev, struct mt7996_sta *msta, 2362 struct ieee80211_vif *vif, u8 link_id) 2363 { 2364 struct ieee80211_link_sta *link_sta; 2365 struct cfg80211_bitrate_mask mask; 2366 struct mt7996_sta_link *msta_link; 2367 struct mt7996_vif_link *link; 2368 struct sta_phy_uni phy = {}; 2369 struct ieee80211_sta *sta; 2370 int ret, nrates = 0, idx; 2371 enum nl80211_band band; 2372 struct mt76_phy *mphy; 2373 bool has_he; 2374 2375 #define __sta_phy_bitrate_mask_check(_mcs, _gi, _ht, _he) \ 2376 do { \ 2377 u8 i, gi = mask.control[band]._gi; \ 2378 gi = (_he) ? gi : gi == NL80211_TXRATE_FORCE_SGI; \ 2379 phy.sgi = gi; \ 2380 phy.he_ltf = mask.control[band].he_ltf; \ 2381 for (i = 0; i < ARRAY_SIZE(mask.control[band]._mcs); i++) { \ 2382 if (!mask.control[band]._mcs[i]) \ 2383 continue; \ 2384 nrates += hweight16(mask.control[band]._mcs[i]); \ 2385 phy.mcs = ffs(mask.control[band]._mcs[i]) - 1; \ 2386 if (_ht) \ 2387 phy.mcs += 8 * i; \ 2388 } \ 2389 } while (0) 2390 2391 rcu_read_lock(); 2392 2393 link = mt7996_vif_link(dev, vif, link_id); 2394 if (!link) 2395 goto error_unlock; 2396 2397 msta_link = mt7996_sta_link(msta, link_id); 2398 if (!msta_link) 2399 goto error_unlock; 2400 2401 sta = wcid_to_sta(&msta_link->wcid); 2402 link_sta = rcu_dereference(sta->link[link_id]); 2403 if (!link_sta) 2404 goto error_unlock; 2405 2406 mphy = mt76_vif_link_phy(&link->mt76); 2407 if (!mphy) 2408 goto error_unlock; 2409 2410 band = mphy->chandef.chan->band; 2411 has_he = link_sta->he_cap.has_he; 2412 mask = link->bitrate_mask; 2413 idx = msta_link->wcid.idx; 2414 2415 if (has_he) { 2416 __sta_phy_bitrate_mask_check(he_mcs, he_gi, 0, 1); 2417 } else if (link_sta->vht_cap.vht_supported) { 2418 __sta_phy_bitrate_mask_check(vht_mcs, gi, 0, 0); 2419 } else if (link_sta->ht_cap.ht_supported) { 2420 __sta_phy_bitrate_mask_check(ht_mcs, gi, 1, 0); 2421 } else { 2422 nrates = hweight32(mask.control[band].legacy); 2423 phy.mcs = ffs(mask.control[band].legacy) - 1; 2424 } 2425 2426 rcu_read_unlock(); 2427 2428 #undef __sta_phy_bitrate_mask_check 2429 2430 /* fall back to auto rate control */ 2431 if (mask.control[band].gi == NL80211_TXRATE_DEFAULT_GI && 2432 mask.control[band].he_gi == GENMASK(7, 0) && 2433 mask.control[band].he_ltf == GENMASK(7, 0) && 2434 nrates != 1) 2435 return 0; 2436 2437 /* fixed single rate */ 2438 if (nrates == 1) { 2439 ret = mt7996_mcu_set_fixed_field(dev, msta, &phy, link_id, 2440 RATE_PARAM_FIXED_MCS); 2441 if (ret) 2442 return ret; 2443 } 2444 2445 /* fixed GI */ 2446 if (mask.control[band].gi != NL80211_TXRATE_DEFAULT_GI || 2447 mask.control[band].he_gi != GENMASK(7, 0)) { 2448 u32 addr; 2449 2450 /* firmware updates only TXCMD but doesn't take WTBL into 2451 * account, so driver should update here to reflect the 2452 * actual txrate hardware sends out. 2453 */ 2454 addr = mt7996_mac_wtbl_lmac_addr(dev, idx, 7); 2455 if (has_he) 2456 mt76_rmw_field(dev, addr, GENMASK(31, 24), phy.sgi); 2457 else 2458 mt76_rmw_field(dev, addr, GENMASK(15, 12), phy.sgi); 2459 2460 ret = mt7996_mcu_set_fixed_field(dev, msta, &phy, link_id, 2461 RATE_PARAM_FIXED_GI); 2462 if (ret) 2463 return ret; 2464 } 2465 2466 /* fixed HE_LTF */ 2467 if (mask.control[band].he_ltf != GENMASK(7, 0)) { 2468 ret = mt7996_mcu_set_fixed_field(dev, msta, &phy, link_id, 2469 RATE_PARAM_FIXED_HE_LTF); 2470 if (ret) 2471 return ret; 2472 } 2473 2474 return 0; 2475 2476 error_unlock: 2477 rcu_read_unlock(); 2478 2479 return -ENODEV; 2480 } 2481 2482 static void 2483 mt7996_mcu_sta_rate_ctrl_tlv(struct sk_buff *skb, struct mt7996_dev *dev, 2484 struct ieee80211_vif *vif, 2485 struct ieee80211_bss_conf *link_conf, 2486 struct ieee80211_link_sta *link_sta, 2487 struct mt7996_vif_link *link) 2488 { 2489 #define INIT_RCPI 180 2490 struct mt76_phy *mphy = mt76_vif_link_phy(&link->mt76); 2491 struct cfg80211_bitrate_mask *mask = &link->bitrate_mask; 2492 u32 cap = link_sta->sta->wme ? STA_CAP_WMM : 0; 2493 struct cfg80211_chan_def *chandef; 2494 struct sta_rec_ra_uni *ra; 2495 enum nl80211_band band; 2496 struct tlv *tlv; 2497 u32 supp_rate; 2498 2499 if (!mphy) 2500 return; 2501 2502 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_RA, sizeof(*ra)); 2503 ra = (struct sta_rec_ra_uni *)tlv; 2504 2505 chandef = &mphy->chandef; 2506 band = chandef->chan->band; 2507 supp_rate = link_sta->supp_rates[band]; 2508 2509 ra->valid = true; 2510 ra->auto_rate = true; 2511 ra->phy_mode = mt76_connac_get_phy_mode(mphy, vif, band, link_sta); 2512 ra->channel = chandef->chan->hw_value; 2513 ra->bw = (link_sta->bandwidth == IEEE80211_STA_RX_BW_320) ? 2514 CMD_CBW_320MHZ : link_sta->bandwidth; 2515 ra->phy.bw = ra->bw; 2516 ra->mmps_mode = mt7996_mcu_get_mmps_mode(link_sta->smps_mode); 2517 2518 if (supp_rate) { 2519 supp_rate &= mask->control[band].legacy; 2520 ra->rate_len = hweight32(supp_rate); 2521 2522 if (band == NL80211_BAND_2GHZ) { 2523 ra->supp_mode = MODE_CCK; 2524 ra->supp_cck_rate = supp_rate & GENMASK(3, 0); 2525 2526 if (ra->rate_len > 4) { 2527 ra->supp_mode |= MODE_OFDM; 2528 ra->supp_ofdm_rate = supp_rate >> 4; 2529 } 2530 } else { 2531 ra->supp_mode = MODE_OFDM; 2532 ra->supp_ofdm_rate = supp_rate; 2533 } 2534 } 2535 2536 if (link_sta->ht_cap.ht_supported) { 2537 ra->supp_mode |= MODE_HT; 2538 ra->af = link_sta->ht_cap.ampdu_factor; 2539 ra->ht_gf = !!(link_sta->ht_cap.cap & IEEE80211_HT_CAP_GRN_FLD); 2540 2541 cap |= STA_CAP_HT; 2542 if (link_sta->ht_cap.cap & IEEE80211_HT_CAP_SGI_20) 2543 cap |= STA_CAP_SGI_20; 2544 if (link_sta->ht_cap.cap & IEEE80211_HT_CAP_SGI_40) 2545 cap |= STA_CAP_SGI_40; 2546 if (link_sta->ht_cap.cap & IEEE80211_HT_CAP_TX_STBC) 2547 cap |= STA_CAP_TX_STBC; 2548 if (link_sta->ht_cap.cap & IEEE80211_HT_CAP_RX_STBC) 2549 cap |= STA_CAP_RX_STBC; 2550 if (link_conf->ht_ldpc && 2551 (link_sta->ht_cap.cap & IEEE80211_HT_CAP_LDPC_CODING)) 2552 cap |= STA_CAP_LDPC; 2553 2554 mt7996_mcu_set_sta_ht_mcs(link_sta, ra->ht_mcs, 2555 mask->control[band].ht_mcs); 2556 ra->supp_ht_mcs = *(__le32 *)ra->ht_mcs; 2557 } 2558 2559 if (link_sta->vht_cap.vht_supported) { 2560 u8 af; 2561 2562 ra->supp_mode |= MODE_VHT; 2563 af = FIELD_GET(IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK, 2564 link_sta->vht_cap.cap); 2565 ra->af = max_t(u8, ra->af, af); 2566 2567 cap |= STA_CAP_VHT; 2568 if (link_sta->vht_cap.cap & IEEE80211_VHT_CAP_SHORT_GI_80) 2569 cap |= STA_CAP_VHT_SGI_80; 2570 if (link_sta->vht_cap.cap & IEEE80211_VHT_CAP_SHORT_GI_160) 2571 cap |= STA_CAP_VHT_SGI_160; 2572 if (link_sta->vht_cap.cap & IEEE80211_VHT_CAP_TXSTBC) 2573 cap |= STA_CAP_VHT_TX_STBC; 2574 if (link_sta->vht_cap.cap & IEEE80211_VHT_CAP_RXSTBC_MASK) 2575 cap |= STA_CAP_VHT_RX_STBC; 2576 if ((vif->type != NL80211_IFTYPE_AP || link_conf->vht_ldpc) && 2577 (link_sta->vht_cap.cap & IEEE80211_VHT_CAP_RXLDPC)) 2578 cap |= STA_CAP_VHT_LDPC; 2579 2580 mt7996_mcu_set_sta_vht_mcs(link_sta, ra->supp_vht_mcs, 2581 mask->control[band].vht_mcs); 2582 } 2583 2584 if (link_sta->he_cap.has_he) { 2585 ra->supp_mode |= MODE_HE; 2586 cap |= STA_CAP_HE; 2587 2588 if (link_sta->he_6ghz_capa.capa) 2589 ra->af = le16_get_bits(link_sta->he_6ghz_capa.capa, 2590 IEEE80211_HE_6GHZ_CAP_MAX_AMPDU_LEN_EXP); 2591 } 2592 ra->sta_cap = cpu_to_le32(cap); 2593 2594 memset(ra->rx_rcpi, INIT_RCPI, sizeof(ra->rx_rcpi)); 2595 } 2596 2597 int mt7996_mcu_add_rate_ctrl(struct mt7996_dev *dev, struct mt7996_sta *msta, 2598 struct ieee80211_vif *vif, u8 link_id, 2599 bool changed) 2600 { 2601 struct ieee80211_bss_conf *link_conf; 2602 struct ieee80211_link_sta *link_sta; 2603 struct mt7996_sta_link *msta_link; 2604 struct mt7996_vif_link *link; 2605 struct ieee80211_sta *sta; 2606 struct sk_buff *skb; 2607 int ret = -ENODEV; 2608 2609 rcu_read_lock(); 2610 2611 link = mt7996_vif_link(dev, vif, link_id); 2612 if (!link) 2613 goto error_unlock; 2614 2615 msta_link = mt7996_sta_link(msta, link_id); 2616 if (!msta_link) 2617 goto error_unlock; 2618 2619 sta = wcid_to_sta(&msta_link->wcid); 2620 link_sta = rcu_dereference(sta->link[link_id]); 2621 if (!link_sta) 2622 goto error_unlock; 2623 2624 link_conf = rcu_dereference(vif->link_conf[link_id]); 2625 if (!link_conf) 2626 goto error_unlock; 2627 2628 skb = __mt76_connac_mcu_alloc_sta_req(&dev->mt76, &link->mt76, 2629 &msta_link->wcid, 2630 MT7996_STA_UPDATE_MAX_SIZE); 2631 if (IS_ERR(skb)) { 2632 ret = PTR_ERR(skb); 2633 goto error_unlock; 2634 } 2635 2636 /* firmware rc algorithm refers to sta_rec_he for HE control. 2637 * once dev->rc_work changes the settings driver should also 2638 * update sta_rec_he here. 2639 */ 2640 if (changed) 2641 mt7996_mcu_sta_he_tlv(skb, link_sta, link); 2642 2643 /* sta_rec_ra accommodates BW, NSS and only MCS range format 2644 * i.e 0-{7,8,9} for VHT. 2645 */ 2646 mt7996_mcu_sta_rate_ctrl_tlv(skb, dev, vif, link_conf, link_sta, link); 2647 2648 rcu_read_unlock(); 2649 2650 ret = mt76_mcu_skb_send_msg(&dev->mt76, skb, 2651 MCU_WMWA_UNI_CMD(STA_REC_UPDATE), true); 2652 if (ret) 2653 return ret; 2654 2655 return mt7996_mcu_add_rate_ctrl_fixed(dev, msta, vif, link_id); 2656 2657 error_unlock: 2658 rcu_read_unlock(); 2659 2660 return ret; 2661 } 2662 2663 static int 2664 mt7996_mcu_add_group(struct mt7996_dev *dev, struct mt7996_vif_link *link, 2665 struct mt76_wcid *wcid) 2666 { 2667 #define MT_STA_BSS_GROUP 1 2668 struct { 2669 u8 __rsv1[4]; 2670 2671 __le16 tag; 2672 __le16 len; 2673 __le16 wlan_idx; 2674 u8 __rsv2[2]; 2675 __le32 action; 2676 __le32 val; 2677 u8 __rsv3[8]; 2678 } __packed req = { 2679 .tag = cpu_to_le16(UNI_VOW_DRR_CTRL), 2680 .len = cpu_to_le16(sizeof(req) - 4), 2681 .action = cpu_to_le32(MT_STA_BSS_GROUP), 2682 .val = cpu_to_le32(link->mt76.idx % 16), 2683 .wlan_idx = cpu_to_le16(wcid->idx), 2684 }; 2685 2686 return mt76_mcu_send_msg(&dev->mt76, MCU_WM_UNI_CMD(VOW), &req, 2687 sizeof(req), true); 2688 } 2689 2690 int mt7996_mcu_mld_reconf_stop_link(struct mt7996_dev *dev, 2691 struct ieee80211_vif *vif, 2692 u16 removed_links) 2693 { 2694 unsigned long rem_links = removed_links; 2695 struct mld_reconf_stop_link *sl; 2696 struct mld_req_hdr hdr = {}; 2697 unsigned int link_id; 2698 struct sk_buff *skb; 2699 struct tlv *tlv; 2700 2701 skb = mt76_mcu_msg_alloc(&dev->mt76, NULL, sizeof(hdr) + sizeof(*sl)); 2702 if (!skb) 2703 return -ENOMEM; 2704 2705 memcpy(hdr.mld_addr, vif->addr, ETH_ALEN); 2706 skb_put_data(skb, &hdr, sizeof(hdr)); 2707 2708 tlv = mt7996_mcu_add_uni_tlv(skb, UNI_CMD_MLD_RECONF_STOP_LINK, 2709 sizeof(*sl)); 2710 sl = (struct mld_reconf_stop_link *)tlv; 2711 sl->link_bitmap = cpu_to_le16(removed_links); 2712 2713 for_each_set_bit(link_id, &rem_links, IEEE80211_MLD_MAX_NUM_LINKS) { 2714 struct mt7996_vif_link *link; 2715 2716 link = mt7996_vif_link(dev, vif, link_id); 2717 if (!link) 2718 continue; 2719 2720 sl->bss_idx[link_id] = link->mt76.idx; 2721 } 2722 2723 return mt76_mcu_skb_send_msg(&dev->mt76, skb, MCU_WM_UNI_CMD(MLD), 2724 true); 2725 } 2726 2727 int mt7996_mcu_mld_link_oper(struct mt7996_dev *dev, 2728 struct ieee80211_bss_conf *link_conf, 2729 struct mt7996_vif_link *link, bool add) 2730 { 2731 struct ieee80211_vif *vif = link_conf->vif; 2732 struct mt7996_vif *mvif = (struct mt7996_vif *)vif->drv_priv; 2733 struct bss_mld_link_op_tlv *mld_op; 2734 struct sk_buff *skb; 2735 struct tlv *tlv; 2736 2737 skb = __mt7996_mcu_alloc_bss_req(&dev->mt76, &link->mt76, 2738 MT7996_BSS_UPDATE_MAX_SIZE); 2739 if (IS_ERR(skb)) 2740 return PTR_ERR(skb); 2741 2742 tlv = mt7996_mcu_add_uni_tlv(skb, UNI_BSS_INFO_MLD_LINK_OP, 2743 sizeof(*mld_op)); 2744 mld_op = (struct bss_mld_link_op_tlv *)tlv; 2745 mld_op->link_operation = add; 2746 mld_op->own_mld_id = link->mld_idx; 2747 mld_op->link_id = link_conf->link_id; 2748 mld_op->group_mld_id = add ? mvif->mld_group_idx : 0xff; 2749 mld_op->remap_idx = add ? mvif->mld_remap_idx : 0xff; 2750 memcpy(mld_op->mac_addr, vif->addr, ETH_ALEN); 2751 2752 return mt76_mcu_skb_send_msg(&dev->mt76, skb, 2753 MCU_WMWA_UNI_CMD(BSS_INFO_UPDATE), true); 2754 } 2755 2756 static void 2757 mt7996_mcu_sta_mld_setup_tlv(struct mt7996_dev *dev, struct sk_buff *skb, 2758 struct ieee80211_vif *vif, 2759 struct ieee80211_sta *sta) 2760 { 2761 struct mt7996_sta *msta = (struct mt7996_sta *)sta->drv_priv; 2762 unsigned long links = mt7996_mac_sta_links(dev, vif, sta); 2763 unsigned int nlinks = hweight16(links); 2764 struct mld_setup_link *mld_setup_link; 2765 struct sta_rec_mld_setup *mld_setup; 2766 struct mt7996_sta_link *msta_link; 2767 u8 seclink_id = msta->deflink_id; 2768 unsigned int link_id; 2769 struct tlv *tlv; 2770 2771 if (!(links & BIT(msta->deflink_id))) 2772 return; 2773 2774 msta_link = mt7996_sta_link_protected(dev, msta, msta->deflink_id); 2775 2776 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_MLD, 2777 sizeof(struct sta_rec_mld_setup) + 2778 sizeof(struct mld_setup_link) * nlinks); 2779 2780 mld_setup = (struct sta_rec_mld_setup *)tlv; 2781 memcpy(mld_setup->mld_addr, sta->addr, ETH_ALEN); 2782 mld_setup->setup_wcid = cpu_to_le16(msta_link->wcid.idx); 2783 mld_setup->primary_id = cpu_to_le16(msta_link->wcid.idx); 2784 2785 if (links & BIT(msta->seclink_id)) 2786 seclink_id = msta->seclink_id; 2787 msta_link = mt7996_sta_link_protected(dev, msta, seclink_id); 2788 mld_setup->seconed_id = cpu_to_le16(msta_link->wcid.idx); 2789 mld_setup->link_num = nlinks; 2790 2791 mld_setup_link = (struct mld_setup_link *)mld_setup->link_info; 2792 for_each_set_bit(link_id, &links, IEEE80211_MLD_MAX_NUM_LINKS) { 2793 struct mt7996_vif_link *link; 2794 2795 msta_link = mt7996_sta_link_protected(dev, msta, link_id); 2796 link = mt7996_vif_link(dev, vif, link_id); 2797 2798 mld_setup_link->wcid = cpu_to_le16(msta_link->wcid.idx); 2799 mld_setup_link->bss_idx = link->mt76.idx; 2800 mld_setup_link++; 2801 } 2802 } 2803 2804 static void 2805 mt7996_mcu_sta_eht_mld_tlv(struct mt7996_dev *dev, struct sk_buff *skb, 2806 struct ieee80211_sta *sta) 2807 { 2808 struct sta_rec_eht_mld *eht_mld; 2809 struct tlv *tlv; 2810 int i; 2811 2812 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_EHT_MLD, sizeof(*eht_mld)); 2813 eht_mld = (struct sta_rec_eht_mld *)tlv; 2814 2815 for (i = 0; i < ARRAY_SIZE(eht_mld->str_cap); i++) 2816 eht_mld->str_cap[i] = 0x7; 2817 } 2818 2819 int mt7996_mcu_add_sta(struct mt7996_dev *dev, 2820 struct ieee80211_bss_conf *link_conf, 2821 struct ieee80211_link_sta *link_sta, 2822 struct mt7996_vif_link *link, 2823 struct mt7996_sta_link *msta_link, 2824 int conn_state, bool newly) 2825 { 2826 struct mt76_wcid *wcid = msta_link ? &msta_link->wcid : link->mt76.wcid; 2827 struct ieee80211_sta *sta = link_sta ? link_sta->sta : NULL; 2828 struct sk_buff *skb; 2829 int ret; 2830 2831 skb = __mt76_connac_mcu_alloc_sta_req(&dev->mt76, &link->mt76, wcid, 2832 MT7996_STA_UPDATE_MAX_SIZE); 2833 if (IS_ERR(skb)) 2834 return PTR_ERR(skb); 2835 2836 /* starec basic */ 2837 mt76_connac_mcu_sta_basic_tlv(&dev->mt76, skb, link_conf, link_sta, 2838 conn_state, newly); 2839 2840 if (conn_state == CONN_STATE_DISCONNECT) 2841 goto out; 2842 2843 /* starec hdr trans */ 2844 mt7996_mcu_sta_hdr_trans_tlv(dev, skb, link_conf->vif, wcid); 2845 /* starec tx proc */ 2846 mt7996_mcu_sta_tx_proc_tlv(skb); 2847 2848 /* tag order is in accordance with firmware dependency. */ 2849 if (link_sta) { 2850 /* starec hdrt mode */ 2851 mt7996_mcu_sta_hdrt_tlv(dev, skb); 2852 if (conn_state == CONN_STATE_CONNECT) { 2853 /* starec bfer */ 2854 mt7996_mcu_sta_bfer_tlv(dev, skb, link_conf, link_sta, 2855 link); 2856 /* starec bfee */ 2857 mt7996_mcu_sta_bfee_tlv(dev, skb, link_conf, link_sta, 2858 link); 2859 } 2860 /* starec ht */ 2861 mt7996_mcu_sta_ht_tlv(skb, link_sta); 2862 /* starec vht */ 2863 mt7996_mcu_sta_vht_tlv(skb, link_sta); 2864 /* starec uapsd */ 2865 mt76_connac_mcu_sta_uapsd(skb, link_conf->vif, sta); 2866 /* starec amsdu */ 2867 mt7996_mcu_sta_amsdu_tlv(dev, skb, link_conf->vif, link_sta, 2868 msta_link); 2869 /* starec he */ 2870 mt7996_mcu_sta_he_tlv(skb, link_sta, link); 2871 /* starec he 6g*/ 2872 mt7996_mcu_sta_he_6g_tlv(skb, link_sta); 2873 /* starec eht */ 2874 mt7996_mcu_sta_eht_tlv(skb, link_sta); 2875 /* starec muru */ 2876 mt7996_mcu_sta_muru_tlv(dev, skb, link_conf, link_sta); 2877 2878 if (sta->mlo) { 2879 mt7996_mcu_sta_mld_setup_tlv(dev, skb, link_conf->vif, 2880 sta); 2881 mt7996_mcu_sta_eht_mld_tlv(dev, skb, sta); 2882 } 2883 } 2884 2885 ret = mt7996_mcu_add_group(dev, link, wcid); 2886 if (ret) { 2887 dev_kfree_skb(skb); 2888 return ret; 2889 } 2890 out: 2891 return mt76_mcu_skb_send_msg(&dev->mt76, skb, 2892 MCU_WMWA_UNI_CMD(STA_REC_UPDATE), true); 2893 } 2894 2895 int mt7996_mcu_teardown_mld_sta(struct mt7996_dev *dev, 2896 struct mt7996_vif_link *link, 2897 struct mt7996_sta_link *msta_link) 2898 { 2899 struct sk_buff *skb; 2900 2901 skb = __mt76_connac_mcu_alloc_sta_req(&dev->mt76, &link->mt76, 2902 &msta_link->wcid, 2903 MT7996_STA_UPDATE_MAX_SIZE); 2904 if (IS_ERR(skb)) 2905 return PTR_ERR(skb); 2906 2907 mt76_connac_mcu_add_tlv(skb, STA_REC_MLD_OFF, sizeof(struct tlv)); 2908 2909 return mt76_mcu_skb_send_msg(&dev->mt76, skb, 2910 MCU_WMWA_UNI_CMD(STA_REC_UPDATE), true); 2911 } 2912 2913 int mt7996_mcu_update_mld_sta(struct mt7996_dev *dev, 2914 struct ieee80211_vif *vif, 2915 struct ieee80211_sta *sta, 2916 struct mt7996_vif_link *link, 2917 struct mt7996_sta_link *msta_link) 2918 { 2919 struct sk_buff *skb; 2920 2921 skb = __mt76_connac_mcu_alloc_sta_req(&dev->mt76, &link->mt76, 2922 &msta_link->wcid, 2923 MT7996_STA_UPDATE_MAX_SIZE); 2924 if (IS_ERR(skb)) 2925 return PTR_ERR(skb); 2926 2927 mt7996_mcu_sta_mld_setup_tlv(dev, skb, vif, sta); 2928 mt7996_mcu_sta_eht_mld_tlv(dev, skb, sta); 2929 2930 return mt76_mcu_skb_send_msg(&dev->mt76, skb, 2931 MCU_WMWA_UNI_CMD(STA_REC_UPDATE), true); 2932 } 2933 2934 void mt7996_mcu_update_sta_rec_bw(void *data, struct ieee80211_sta *sta) 2935 { 2936 struct mt7996_vif_link *link = (struct mt7996_vif_link *)data; 2937 struct mt7996_sta *msta = (struct mt7996_sta *)sta->drv_priv; 2938 struct mt7996_phy *phy = mt7996_vif_link_phy(link); 2939 struct mt7996_sta_link *msta_link; 2940 struct mt7996_dev *dev; 2941 struct ieee80211_bss_conf *link_conf; 2942 struct ieee80211_link_sta *link_sta; 2943 struct ieee80211_vif *vif; 2944 struct sk_buff *skb; 2945 int link_id; 2946 2947 if (!phy) 2948 return; 2949 2950 if (link->mt76.mvif != &msta->vif->mt76) 2951 return; 2952 2953 dev = phy->dev; 2954 link_id = link->msta_link.wcid.link_id; 2955 link_sta = link_sta_dereference_protected(sta, link_id); 2956 if (!link_sta) 2957 return; 2958 2959 msta_link = mt7996_sta_link_protected(dev, msta, link_id); 2960 if (!msta_link) 2961 return; 2962 2963 vif = container_of((void *)msta->vif, struct ieee80211_vif, drv_priv); 2964 link_conf = link_conf_dereference_protected(vif, link_id); 2965 if (!link_conf) 2966 return; 2967 2968 skb = __mt76_connac_mcu_alloc_sta_req(&dev->mt76, &link->mt76, 2969 &msta_link->wcid, 2970 MT7996_STA_UPDATE_MAX_SIZE); 2971 if (IS_ERR(skb)) 2972 return; 2973 2974 mt7996_mcu_sta_bfer_tlv(dev, skb, link_conf, link_sta, link); 2975 mt7996_mcu_sta_rate_ctrl_tlv(skb, dev, vif, link_conf, link_sta, link); 2976 2977 mt76_mcu_skb_send_msg(&dev->mt76, skb, 2978 MCU_WMWA_UNI_CMD(STA_REC_UPDATE), true); 2979 } 2980 2981 static int 2982 mt7996_mcu_sta_key_tlv(struct mt76_dev *dev, struct mt76_wcid *wcid, 2983 struct sk_buff *skb, 2984 struct ieee80211_key_conf *key, 2985 enum set_key_cmd cmd) 2986 { 2987 struct sta_rec_sec_uni *sec; 2988 struct sec_key_uni *sec_key; 2989 struct tlv *tlv; 2990 u8 cipher; 2991 2992 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_KEY_V2, sizeof(*sec)); 2993 sec = (struct sta_rec_sec_uni *)tlv; 2994 /* due to connac3 FW design, we only do remove key for BIGTK; even for 2995 * removal, the field should be filled with SET_KEY 2996 */ 2997 sec->add = SET_KEY; 2998 sec->n_cipher = 1; 2999 sec_key = &sec->key[0]; 3000 sec_key->wlan_idx = cpu_to_le16(wcid->idx); 3001 sec_key->key_id = key->keyidx; 3002 3003 if (cmd != SET_KEY) 3004 return 0; 3005 3006 cipher = mt76_connac_mcu_get_cipher(key->cipher); 3007 if (cipher == MCU_CIPHER_NONE) 3008 return -EOPNOTSUPP; 3009 3010 sec_key->mgmt_prot = 0; 3011 sec_key->cipher_id = cipher; 3012 sec_key->cipher_len = sizeof(*sec_key); 3013 sec_key->key_len = key->keylen; 3014 sec_key->need_resp = 0; 3015 memcpy(sec_key->key, key->key, key->keylen); 3016 3017 if (cipher == MCU_CIPHER_TKIP) { 3018 /* Rx/Tx MIC keys are swapped */ 3019 memcpy(sec_key->key + 16, key->key + 24, 8); 3020 memcpy(sec_key->key + 24, key->key + 16, 8); 3021 return 0; 3022 } 3023 3024 if (sec_key->key_id != 6 && sec_key->key_id != 7) 3025 return 0; 3026 3027 switch (key->cipher) { 3028 case WLAN_CIPHER_SUITE_AES_CMAC: 3029 sec_key->cipher_id = MCU_CIPHER_BCN_PROT_CMAC_128; 3030 break; 3031 case WLAN_CIPHER_SUITE_BIP_GMAC_128: 3032 sec_key->cipher_id = MCU_CIPHER_BCN_PROT_GMAC_128; 3033 break; 3034 case WLAN_CIPHER_SUITE_BIP_GMAC_256: 3035 sec_key->cipher_id = MCU_CIPHER_BCN_PROT_GMAC_256; 3036 break; 3037 case WLAN_CIPHER_SUITE_BIP_CMAC_256: 3038 if (!is_mt7990(dev)) 3039 return -EOPNOTSUPP; 3040 sec_key->cipher_id = MCU_CIPHER_BCN_PROT_CMAC_256; 3041 break; 3042 default: 3043 return -EOPNOTSUPP; 3044 } 3045 3046 sec_key->bcn_mode = is_mt7990(dev) ? BP_HW_MODE : BP_SW_MODE; 3047 3048 return 0; 3049 } 3050 3051 int mt7996_mcu_add_key(struct mt76_dev *dev, struct mt7996_vif_link *link, 3052 struct ieee80211_key_conf *key, int mcu_cmd, 3053 struct mt76_wcid *wcid, enum set_key_cmd cmd) 3054 { 3055 struct sk_buff *skb; 3056 int ret; 3057 3058 skb = __mt76_connac_mcu_alloc_sta_req(dev, (struct mt76_vif_link *)link, 3059 wcid, MT7996_STA_UPDATE_MAX_SIZE); 3060 if (IS_ERR(skb)) 3061 return PTR_ERR(skb); 3062 3063 ret = mt7996_mcu_sta_key_tlv(dev, wcid, skb, key, cmd); 3064 if (ret) { 3065 dev_kfree_skb(skb); 3066 return ret; 3067 } 3068 3069 return mt76_mcu_skb_send_msg(dev, skb, mcu_cmd, true); 3070 } 3071 3072 int mt7996_mcu_add_dev_info(struct mt7996_phy *phy, struct ieee80211_vif *vif, 3073 struct ieee80211_bss_conf *link_conf, 3074 struct mt76_vif_link *mlink, bool enable) 3075 { 3076 struct mt7996_dev *dev = phy->dev; 3077 struct { 3078 struct req_hdr { 3079 u8 omac_idx; 3080 u8 band_idx; 3081 u8 __rsv[2]; 3082 } __packed hdr; 3083 struct req_tlv { 3084 __le16 tag; 3085 __le16 len; 3086 u8 active; 3087 u8 __rsv; 3088 u8 omac_addr[ETH_ALEN]; 3089 } __packed tlv; 3090 } data = { 3091 .hdr = { 3092 .omac_idx = mlink->omac_idx, 3093 .band_idx = mlink->band_idx, 3094 }, 3095 .tlv = { 3096 .tag = cpu_to_le16(DEV_INFO_ACTIVE), 3097 .len = cpu_to_le16(sizeof(struct req_tlv)), 3098 .active = enable, 3099 }, 3100 }; 3101 3102 memcpy(data.tlv.omac_addr, link_conf->addr, ETH_ALEN); 3103 return mt76_mcu_send_msg(&dev->mt76, MCU_WMWA_UNI_CMD(DEV_INFO_UPDATE), 3104 &data, sizeof(data), true); 3105 } 3106 3107 static void 3108 mt7996_mcu_beacon_cntdwn(struct sk_buff *rskb, struct sk_buff *skb, 3109 struct ieee80211_mutable_offsets *offs, 3110 bool csa) 3111 { 3112 struct bss_bcn_cntdwn_tlv *info; 3113 struct tlv *tlv; 3114 u16 tag; 3115 3116 if (!offs->cntdwn_counter_offs[0]) 3117 return; 3118 3119 tag = csa ? UNI_BSS_INFO_BCN_CSA : UNI_BSS_INFO_BCN_BCC; 3120 3121 tlv = mt7996_mcu_add_uni_tlv(rskb, tag, sizeof(*info)); 3122 3123 info = (struct bss_bcn_cntdwn_tlv *)tlv; 3124 info->cnt = skb->data[offs->cntdwn_counter_offs[0]]; 3125 3126 /* abort the CCA countdown when starting CSA countdown */ 3127 if (csa) { 3128 struct bss_bcn_cntdwn_tlv *cca_info; 3129 3130 tlv = mt7996_mcu_add_uni_tlv(rskb, UNI_BSS_INFO_BCN_BCC, 3131 sizeof(*cca_info)); 3132 cca_info = (struct bss_bcn_cntdwn_tlv *)tlv; 3133 cca_info->cca.abort = true; 3134 } 3135 } 3136 3137 static void 3138 mt7996_mcu_beacon_mbss(struct sk_buff *rskb, struct sk_buff *skb, 3139 struct bss_bcn_content_tlv *bcn, 3140 struct ieee80211_mutable_offsets *offs) 3141 { 3142 struct bss_bcn_mbss_tlv *mbss; 3143 const struct element *elem; 3144 struct tlv *tlv; 3145 3146 tlv = mt7996_mcu_add_uni_tlv(rskb, UNI_BSS_INFO_BCN_MBSSID, sizeof(*mbss)); 3147 3148 mbss = (struct bss_bcn_mbss_tlv *)tlv; 3149 mbss->offset[0] = cpu_to_le16(offs->tim_offset); 3150 mbss->bitmap = cpu_to_le32(1); 3151 3152 for_each_element_id(elem, WLAN_EID_MULTIPLE_BSSID, 3153 &skb->data[offs->mbssid_off], 3154 skb->len - offs->mbssid_off) { 3155 const struct element *sub_elem; 3156 3157 if (elem->datalen < 2) 3158 continue; 3159 3160 for_each_element(sub_elem, elem->data + 1, elem->datalen - 1) { 3161 const struct ieee80211_bssid_index *idx; 3162 const u8 *idx_ie; 3163 3164 /* not a valid BSS profile */ 3165 if (sub_elem->id || sub_elem->datalen < 4) 3166 continue; 3167 3168 /* Find WLAN_EID_MULTI_BSSID_IDX 3169 * in the merged nontransmitted profile 3170 */ 3171 idx_ie = cfg80211_find_ie(WLAN_EID_MULTI_BSSID_IDX, 3172 sub_elem->data, sub_elem->datalen); 3173 if (!idx_ie || idx_ie[1] < sizeof(*idx)) 3174 continue; 3175 3176 idx = (void *)(idx_ie + 2); 3177 if (!idx->bssid_index || idx->bssid_index > 31) 3178 continue; 3179 3180 mbss->offset[idx->bssid_index] = cpu_to_le16(idx_ie - 3181 skb->data); 3182 mbss->bitmap |= cpu_to_le32(BIT(idx->bssid_index)); 3183 } 3184 } 3185 } 3186 3187 static void 3188 mt7996_mcu_beacon_cont(struct mt7996_dev *dev, 3189 struct ieee80211_bss_conf *link_conf, 3190 struct mt7996_vif_link *link, 3191 struct sk_buff *rskb, struct sk_buff *skb, 3192 struct bss_bcn_content_tlv *bcn, 3193 struct ieee80211_mutable_offsets *offs) 3194 { 3195 u8 *buf, keyidx = link->msta_link.wcid.hw_key_idx2; 3196 struct mt76_wcid *wcid; 3197 3198 if (is_mt7990(&dev->mt76) && (keyidx == 6 || keyidx == 7)) 3199 wcid = &link->msta_link.wcid; 3200 else 3201 wcid = &dev->mt76.global_wcid; 3202 3203 bcn->pkt_len = cpu_to_le16(MT_TXD_SIZE + skb->len); 3204 bcn->tim_ie_pos = cpu_to_le16(offs->tim_offset); 3205 3206 if (offs->cntdwn_counter_offs[0]) { 3207 u16 offset = offs->cntdwn_counter_offs[0]; 3208 3209 if (link_conf->csa_active) 3210 bcn->csa_ie_pos = cpu_to_le16(offset - 4); 3211 if (link_conf->color_change_active) 3212 bcn->bcc_ie_pos = cpu_to_le16(offset - 3); 3213 } 3214 3215 buf = (u8 *)bcn + sizeof(*bcn); 3216 mt7996_mac_write_txwi(dev, (__le32 *)buf, skb, wcid, NULL, 0, 0, 3217 BSS_CHANGED_BEACON, link_conf->link_id); 3218 3219 memcpy(buf + MT_TXD_SIZE, skb->data, skb->len); 3220 } 3221 3222 int mt7996_mcu_add_beacon(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 3223 struct ieee80211_bss_conf *link_conf, bool enabled) 3224 { 3225 struct mt7996_dev *dev = mt7996_hw_dev(hw); 3226 struct mt7996_vif_link *link = mt7996_vif_conf_link(dev, vif, link_conf); 3227 struct mt76_phy *mphy = link ? mt76_vif_link_phy(&link->mt76) : NULL; 3228 struct mt76_vif_link *mlink = link ? &link->mt76 : NULL; 3229 struct ieee80211_mutable_offsets offs; 3230 struct ieee80211_tx_info *info; 3231 struct sk_buff *skb, *rskb; 3232 struct tlv *tlv; 3233 struct bss_bcn_content_tlv *bcn; 3234 int len, extra_len = 0; 3235 3236 if (link_conf->nontransmitted) 3237 return 0; 3238 3239 if (!mlink) 3240 return -EINVAL; 3241 3242 if (mphy && mphy->offchannel) 3243 enabled = false; 3244 3245 rskb = __mt7996_mcu_alloc_bss_req(&dev->mt76, mlink, 3246 MT7996_MAX_BSS_OFFLOAD_SIZE); 3247 if (IS_ERR(rskb)) 3248 return PTR_ERR(rskb); 3249 3250 skb = ieee80211_beacon_get_template(hw, vif, &offs, link_conf->link_id); 3251 if (enabled && !skb) { 3252 dev_kfree_skb(rskb); 3253 return -EINVAL; 3254 } 3255 3256 if (skb) { 3257 if (skb->len > MT7996_MAX_BEACON_SIZE) { 3258 dev_err(dev->mt76.dev, "Bcn size limit exceed\n"); 3259 dev_kfree_skb(rskb); 3260 dev_kfree_skb(skb); 3261 return -EINVAL; 3262 } 3263 3264 extra_len = skb->len; 3265 } 3266 3267 len = ALIGN(sizeof(*bcn) + MT_TXD_SIZE + extra_len, 4); 3268 tlv = mt7996_mcu_add_uni_tlv(rskb, UNI_BSS_INFO_BCN_CONTENT, len); 3269 bcn = (struct bss_bcn_content_tlv *)tlv; 3270 bcn->enable = enabled; 3271 if (!bcn->enable) 3272 goto out; 3273 3274 info = IEEE80211_SKB_CB(skb); 3275 info->hw_queue |= FIELD_PREP(MT_TX_HW_QUEUE_PHY, mlink->band_idx); 3276 3277 mt7996_mcu_beacon_cont(dev, link_conf, link, rskb, skb, bcn, &offs); 3278 if (link_conf->bssid_indicator) 3279 mt7996_mcu_beacon_mbss(rskb, skb, bcn, &offs); 3280 mt7996_mcu_beacon_cntdwn(rskb, skb, &offs, link_conf->csa_active); 3281 out: 3282 dev_kfree_skb(skb); 3283 return mt76_mcu_skb_send_msg(&dev->mt76, rskb, 3284 MCU_WMWA_UNI_CMD(BSS_INFO_UPDATE), true); 3285 } 3286 3287 int mt7996_mcu_beacon_inband_discov(struct mt7996_dev *dev, 3288 struct ieee80211_bss_conf *link_conf, 3289 struct mt7996_vif_link *link, u32 changed) 3290 { 3291 #define OFFLOAD_TX_MODE_SU BIT(0) 3292 #define OFFLOAD_TX_MODE_MU BIT(1) 3293 struct mt76_phy *mphy = mt76_vif_link_phy(&link->mt76); 3294 struct ieee80211_vif *vif = link_conf->vif; 3295 struct ieee80211_hw *hw = mt76_hw(dev); 3296 struct mt76_wcid *wcid = &dev->mt76.global_wcid; 3297 struct bss_inband_discovery_tlv *discov; 3298 struct ieee80211_tx_info *info; 3299 struct sk_buff *rskb, *skb = NULL; 3300 struct cfg80211_chan_def *chandef; 3301 enum nl80211_band band; 3302 struct tlv *tlv; 3303 u8 *buf, interval; 3304 int len; 3305 3306 if (!mphy) 3307 return -EINVAL; 3308 3309 chandef = &mphy->chandef; 3310 band = chandef->chan->band; 3311 3312 if (link_conf->nontransmitted) 3313 return 0; 3314 3315 rskb = __mt7996_mcu_alloc_bss_req(&dev->mt76, &link->mt76, 3316 MT7996_MAX_BSS_OFFLOAD_SIZE); 3317 if (IS_ERR(rskb)) 3318 return PTR_ERR(rskb); 3319 3320 if (changed & BSS_CHANGED_FILS_DISCOVERY && 3321 link_conf->fils_discovery.max_interval) { 3322 interval = link_conf->fils_discovery.max_interval; 3323 skb = ieee80211_get_fils_discovery_tmpl(hw, vif, 3324 link_conf->link_id); 3325 } else if (changed & BSS_CHANGED_UNSOL_BCAST_PROBE_RESP && 3326 link_conf->unsol_bcast_probe_resp_interval) { 3327 interval = link_conf->unsol_bcast_probe_resp_interval; 3328 skb = ieee80211_get_unsol_bcast_probe_resp_tmpl(hw, vif, 3329 link_conf->link_id); 3330 } 3331 3332 if (!skb) { 3333 dev_kfree_skb(rskb); 3334 return -EINVAL; 3335 } 3336 3337 if (skb->len > MT7996_MAX_BEACON_SIZE) { 3338 dev_err(dev->mt76.dev, "inband discovery size limit exceed\n"); 3339 dev_kfree_skb(rskb); 3340 dev_kfree_skb(skb); 3341 return -EINVAL; 3342 } 3343 3344 info = IEEE80211_SKB_CB(skb); 3345 info->control.vif = vif; 3346 info->band = band; 3347 info->hw_queue |= FIELD_PREP(MT_TX_HW_QUEUE_PHY, mphy->band_idx); 3348 3349 len = ALIGN(sizeof(*discov) + MT_TXD_SIZE + skb->len, 4); 3350 tlv = mt7996_mcu_add_uni_tlv(rskb, UNI_BSS_INFO_OFFLOAD, len); 3351 3352 discov = (struct bss_inband_discovery_tlv *)tlv; 3353 discov->tx_mode = OFFLOAD_TX_MODE_SU; 3354 /* 0: UNSOL PROBE RESP, 1: FILS DISCOV */ 3355 discov->tx_type = !!(changed & BSS_CHANGED_FILS_DISCOVERY); 3356 discov->tx_interval = interval; 3357 discov->prob_rsp_len = cpu_to_le16(MT_TXD_SIZE + skb->len); 3358 discov->enable = true; 3359 discov->wcid = cpu_to_le16(MT7996_WTBL_RESERVED); 3360 3361 buf = (u8 *)tlv + sizeof(*discov); 3362 3363 mt7996_mac_write_txwi(dev, (__le32 *)buf, skb, wcid, NULL, 0, 0, 3364 changed, link_conf->link_id); 3365 3366 memcpy(buf + MT_TXD_SIZE, skb->data, skb->len); 3367 3368 dev_kfree_skb(skb); 3369 3370 return mt76_mcu_skb_send_msg(&dev->mt76, rskb, 3371 MCU_WMWA_UNI_CMD(BSS_INFO_UPDATE), true); 3372 } 3373 3374 static int mt7996_driver_own(struct mt7996_dev *dev, u8 band) 3375 { 3376 mt76_wr(dev, MT_TOP_LPCR_HOST_BAND(band), MT_TOP_LPCR_HOST_DRV_OWN); 3377 if (!mt76_poll_msec(dev, MT_TOP_LPCR_HOST_BAND(band), 3378 MT_TOP_LPCR_HOST_FW_OWN_STAT, 0, 500)) { 3379 dev_err(dev->mt76.dev, "Timeout for driver own\n"); 3380 return -EIO; 3381 } 3382 3383 /* clear irq when the driver own success */ 3384 mt76_wr(dev, MT_TOP_LPCR_HOST_BAND_IRQ_STAT(band), 3385 MT_TOP_LPCR_HOST_BAND_STAT); 3386 3387 return 0; 3388 } 3389 3390 static u32 mt7996_patch_sec_mode(u32 key_info) 3391 { 3392 u32 sec = u32_get_bits(key_info, MT7996_PATCH_SEC), key = 0; 3393 3394 if (key_info == GENMASK(31, 0) || sec == MT7996_SEC_MODE_PLAIN) 3395 return 0; 3396 3397 if (sec == MT7996_SEC_MODE_AES) 3398 key = u32_get_bits(key_info, MT7996_PATCH_AES_KEY); 3399 else 3400 key = u32_get_bits(key_info, MT7996_PATCH_SCRAMBLE_KEY); 3401 3402 return MT7996_SEC_ENCRYPT | MT7996_SEC_IV | 3403 u32_encode_bits(key, MT7996_SEC_KEY_IDX); 3404 } 3405 3406 static int mt7996_load_patch(struct mt7996_dev *dev) 3407 { 3408 const struct mt7996_patch_hdr *hdr; 3409 const struct firmware *fw = NULL; 3410 int i, ret, sem; 3411 3412 sem = mt76_connac_mcu_patch_sem_ctrl(&dev->mt76, 1); 3413 switch (sem) { 3414 case PATCH_IS_DL: 3415 return 0; 3416 case PATCH_NOT_DL_SEM_SUCCESS: 3417 break; 3418 default: 3419 dev_err(dev->mt76.dev, "Failed to get patch semaphore\n"); 3420 return -EAGAIN; 3421 } 3422 3423 ret = request_firmware(&fw, fw_name(dev, ROM_PATCH), dev->mt76.dev); 3424 if (ret) 3425 goto out; 3426 3427 if (!fw || !fw->data || fw->size < sizeof(*hdr)) { 3428 dev_err(dev->mt76.dev, "Invalid firmware\n"); 3429 ret = -EINVAL; 3430 goto out; 3431 } 3432 3433 hdr = (const struct mt7996_patch_hdr *)(fw->data); 3434 3435 dev_info(dev->mt76.dev, "HW/SW Version: 0x%x, Build Time: %.16s\n", 3436 be32_to_cpu(hdr->hw_sw_ver), hdr->build_date); 3437 3438 for (i = 0; i < be32_to_cpu(hdr->desc.n_region); i++) { 3439 struct mt7996_patch_sec *sec; 3440 const u8 *dl; 3441 u32 len, addr, sec_key_idx, mode = DL_MODE_NEED_RSP; 3442 3443 sec = (struct mt7996_patch_sec *)(fw->data + sizeof(*hdr) + 3444 i * sizeof(*sec)); 3445 if ((be32_to_cpu(sec->type) & PATCH_SEC_TYPE_MASK) != 3446 PATCH_SEC_TYPE_INFO) { 3447 ret = -EINVAL; 3448 goto out; 3449 } 3450 3451 addr = be32_to_cpu(sec->info.addr); 3452 len = be32_to_cpu(sec->info.len); 3453 sec_key_idx = be32_to_cpu(sec->info.sec_key_idx); 3454 dl = fw->data + be32_to_cpu(sec->offs); 3455 3456 mode |= mt7996_patch_sec_mode(sec_key_idx); 3457 3458 ret = mt76_connac_mcu_init_download(&dev->mt76, addr, len, 3459 mode); 3460 if (ret) { 3461 dev_err(dev->mt76.dev, "Download request failed\n"); 3462 goto out; 3463 } 3464 3465 ret = __mt76_mcu_send_firmware(&dev->mt76, MCU_CMD(FW_SCATTER), 3466 dl, len, 4096); 3467 if (ret) { 3468 dev_err(dev->mt76.dev, "Failed to send patch\n"); 3469 goto out; 3470 } 3471 } 3472 3473 ret = mt76_connac_mcu_start_patch(&dev->mt76); 3474 if (ret) 3475 dev_err(dev->mt76.dev, "Failed to start patch\n"); 3476 3477 out: 3478 sem = mt76_connac_mcu_patch_sem_ctrl(&dev->mt76, 0); 3479 switch (sem) { 3480 case PATCH_REL_SEM_SUCCESS: 3481 break; 3482 default: 3483 ret = -EAGAIN; 3484 dev_err(dev->mt76.dev, "Failed to release patch semaphore\n"); 3485 break; 3486 } 3487 release_firmware(fw); 3488 3489 return ret; 3490 } 3491 3492 static int 3493 mt7996_mcu_send_ram_firmware(struct mt7996_dev *dev, 3494 const struct mt7996_fw_trailer *hdr, 3495 const u8 *data, enum mt7996_ram_type type) 3496 { 3497 int i, offset = 0; 3498 u32 override = 0, option = 0; 3499 3500 for (i = 0; i < hdr->n_region; i++) { 3501 const struct mt7996_fw_region *region; 3502 int err; 3503 u32 len, addr, mode; 3504 3505 region = (const struct mt7996_fw_region *)((const u8 *)hdr - 3506 (hdr->n_region - i) * sizeof(*region)); 3507 /* DSP and WA use same mode */ 3508 mode = mt76_connac_mcu_gen_dl_mode(&dev->mt76, 3509 region->feature_set, 3510 type != MT7996_RAM_TYPE_WM); 3511 len = le32_to_cpu(region->len); 3512 addr = le32_to_cpu(region->addr); 3513 3514 if (region->feature_set & FW_FEATURE_OVERRIDE_ADDR) 3515 override = addr; 3516 3517 err = mt76_connac_mcu_init_download(&dev->mt76, addr, len, 3518 mode); 3519 if (err) { 3520 dev_err(dev->mt76.dev, "Download request failed\n"); 3521 return err; 3522 } 3523 3524 err = __mt76_mcu_send_firmware(&dev->mt76, MCU_CMD(FW_SCATTER), 3525 data + offset, len, 4096); 3526 if (err) { 3527 dev_err(dev->mt76.dev, "Failed to send firmware.\n"); 3528 return err; 3529 } 3530 3531 offset += len; 3532 } 3533 3534 if (override) 3535 option |= FW_START_OVERRIDE; 3536 3537 if (type == MT7996_RAM_TYPE_WA) 3538 option |= FW_START_WORKING_PDA_CR4; 3539 else if (type == MT7996_RAM_TYPE_DSP) 3540 option |= FW_START_WORKING_PDA_DSP; 3541 3542 return mt76_connac_mcu_start_firmware(&dev->mt76, override, option); 3543 } 3544 3545 static int __mt7996_load_ram(struct mt7996_dev *dev, const char *fw_type, 3546 const char *fw_file, enum mt7996_ram_type ram_type) 3547 { 3548 const struct mt7996_fw_trailer *hdr; 3549 const struct firmware *fw; 3550 int ret; 3551 3552 ret = request_firmware(&fw, fw_file, dev->mt76.dev); 3553 if (ret) 3554 return ret; 3555 3556 if (!fw || !fw->data || fw->size < sizeof(*hdr)) { 3557 dev_err(dev->mt76.dev, "Invalid firmware\n"); 3558 ret = -EINVAL; 3559 goto out; 3560 } 3561 3562 hdr = (const void *)(fw->data + fw->size - sizeof(*hdr)); 3563 dev_info(dev->mt76.dev, "%s Firmware Version: %.10s, Build Time: %.15s\n", 3564 fw_type, hdr->fw_ver, hdr->build_date); 3565 3566 ret = mt7996_mcu_send_ram_firmware(dev, hdr, fw->data, ram_type); 3567 if (ret) { 3568 dev_err(dev->mt76.dev, "Failed to start %s firmware\n", fw_type); 3569 goto out; 3570 } 3571 3572 snprintf(dev->mt76.hw->wiphy->fw_version, 3573 sizeof(dev->mt76.hw->wiphy->fw_version), 3574 "%.10s-%.15s", hdr->fw_ver, hdr->build_date); 3575 3576 out: 3577 release_firmware(fw); 3578 3579 return ret; 3580 } 3581 3582 static int mt7996_load_ram(struct mt7996_dev *dev) 3583 { 3584 int ret; 3585 3586 ret = __mt7996_load_ram(dev, "WM", fw_name(dev, FIRMWARE_WM), 3587 MT7996_RAM_TYPE_WM); 3588 if (ret) 3589 return ret; 3590 3591 if (!mt7996_has_wa(dev)) 3592 return 0; 3593 3594 ret = __mt7996_load_ram(dev, "DSP", fw_name(dev, FIRMWARE_DSP), 3595 MT7996_RAM_TYPE_DSP); 3596 if (ret) 3597 return ret; 3598 3599 return __mt7996_load_ram(dev, "WA", fw_name(dev, FIRMWARE_WA), 3600 MT7996_RAM_TYPE_WA); 3601 } 3602 3603 static int 3604 mt7996_firmware_state(struct mt7996_dev *dev, u8 fw_state) 3605 { 3606 u32 state = FIELD_PREP(MT_TOP_MISC_FW_STATE, fw_state); 3607 3608 if (!mt76_poll_msec(dev, MT_TOP_MISC, MT_TOP_MISC_FW_STATE, 3609 state, 1000)) { 3610 dev_err(dev->mt76.dev, "Timeout for initializing firmware\n"); 3611 return -EIO; 3612 } 3613 return 0; 3614 } 3615 3616 static int 3617 mt7996_mcu_restart(struct mt76_dev *dev) 3618 { 3619 struct { 3620 u8 __rsv1[4]; 3621 3622 __le16 tag; 3623 __le16 len; 3624 u8 power_mode; 3625 u8 __rsv2[3]; 3626 } __packed req = { 3627 .tag = cpu_to_le16(UNI_POWER_OFF), 3628 .len = cpu_to_le16(sizeof(req) - 4), 3629 .power_mode = 1, 3630 }; 3631 3632 return mt76_mcu_send_msg(dev, MCU_WM_UNI_CMD(POWER_CTRL), &req, 3633 sizeof(req), false); 3634 } 3635 3636 static int mt7996_load_firmware(struct mt7996_dev *dev) 3637 { 3638 u8 fw_state; 3639 int ret; 3640 3641 /* make sure fw is download state */ 3642 if (mt7996_firmware_state(dev, FW_STATE_FW_DOWNLOAD)) { 3643 /* restart firmware once */ 3644 mt7996_mcu_restart(&dev->mt76); 3645 ret = mt7996_firmware_state(dev, FW_STATE_FW_DOWNLOAD); 3646 if (ret) { 3647 dev_err(dev->mt76.dev, 3648 "Firmware is not ready for download\n"); 3649 return ret; 3650 } 3651 } 3652 3653 ret = mt7996_load_patch(dev); 3654 if (ret) 3655 return ret; 3656 3657 ret = mt7996_load_ram(dev); 3658 if (ret) 3659 return ret; 3660 3661 fw_state = mt7996_has_wa(dev) ? FW_STATE_RDY : FW_STATE_NORMAL_TRX; 3662 ret = mt7996_firmware_state(dev, fw_state); 3663 if (ret) 3664 return ret; 3665 3666 mt76_queue_tx_cleanup(dev, dev->mt76.q_mcu[MT_MCUQ_FWDL], false); 3667 3668 dev_dbg(dev->mt76.dev, "Firmware init done\n"); 3669 3670 return 0; 3671 } 3672 3673 int mt7996_mcu_fw_log_2_host(struct mt7996_dev *dev, u8 type, u8 ctrl) 3674 { 3675 struct { 3676 u8 _rsv[4]; 3677 3678 __le16 tag; 3679 __le16 len; 3680 u8 ctrl; 3681 u8 interval; 3682 u8 _rsv2[2]; 3683 } __packed data = { 3684 .tag = cpu_to_le16(UNI_WSYS_CONFIG_FW_LOG_CTRL), 3685 .len = cpu_to_le16(sizeof(data) - 4), 3686 .ctrl = ctrl, 3687 }; 3688 3689 if (type == MCU_FW_LOG_WA) 3690 return mt76_mcu_send_msg(&dev->mt76, MCU_WA_UNI_CMD(WSYS_CONFIG), 3691 &data, sizeof(data), true); 3692 3693 return mt76_mcu_send_msg(&dev->mt76, MCU_WM_UNI_CMD(WSYS_CONFIG), &data, 3694 sizeof(data), true); 3695 } 3696 3697 int mt7996_mcu_fw_dbg_ctrl(struct mt7996_dev *dev, u32 module, u8 level) 3698 { 3699 struct { 3700 u8 _rsv[4]; 3701 3702 __le16 tag; 3703 __le16 len; 3704 __le32 module_idx; 3705 u8 level; 3706 u8 _rsv2[3]; 3707 } data = { 3708 .tag = cpu_to_le16(UNI_WSYS_CONFIG_FW_DBG_CTRL), 3709 .len = cpu_to_le16(sizeof(data) - 4), 3710 .module_idx = cpu_to_le32(module), 3711 .level = level, 3712 }; 3713 3714 return mt76_mcu_send_msg(&dev->mt76, MCU_WM_UNI_CMD(WSYS_CONFIG), &data, 3715 sizeof(data), false); 3716 } 3717 3718 static int mt7996_mcu_set_mwds(struct mt7996_dev *dev, bool enabled) 3719 { 3720 struct { 3721 u8 enable; 3722 u8 _rsv[3]; 3723 } __packed req = { 3724 .enable = enabled 3725 }; 3726 3727 return mt76_mcu_send_msg(&dev->mt76, MCU_WA_EXT_CMD(MWDS_SUPPORT), &req, 3728 sizeof(req), false); 3729 } 3730 3731 static void mt7996_add_rx_airtime_tlv(struct sk_buff *skb, u8 band_idx) 3732 { 3733 struct vow_rx_airtime *req; 3734 struct tlv *tlv; 3735 3736 tlv = mt7996_mcu_add_uni_tlv(skb, UNI_VOW_RX_AT_AIRTIME_CLR_EN, sizeof(*req)); 3737 req = (struct vow_rx_airtime *)tlv; 3738 req->enable = true; 3739 req->band = band_idx; 3740 3741 tlv = mt7996_mcu_add_uni_tlv(skb, UNI_VOW_RX_AT_AIRTIME_EN, sizeof(*req)); 3742 req = (struct vow_rx_airtime *)tlv; 3743 req->enable = true; 3744 req->band = band_idx; 3745 } 3746 3747 static int 3748 mt7996_mcu_init_rx_airtime(struct mt7996_dev *dev) 3749 { 3750 struct uni_header hdr = {}; 3751 struct sk_buff *skb; 3752 int len, num, i; 3753 3754 num = 2 + 2 * (mt7996_band_valid(dev, MT_BAND1) + 3755 mt7996_band_valid(dev, MT_BAND2)); 3756 len = sizeof(hdr) + num * sizeof(struct vow_rx_airtime); 3757 skb = mt76_mcu_msg_alloc(&dev->mt76, NULL, len); 3758 if (!skb) 3759 return -ENOMEM; 3760 3761 skb_put_data(skb, &hdr, sizeof(hdr)); 3762 3763 for (i = 0; i < __MT_MAX_BAND; i++) { 3764 if (mt7996_band_valid(dev, i)) 3765 mt7996_add_rx_airtime_tlv(skb, i); 3766 } 3767 3768 return mt76_mcu_skb_send_msg(&dev->mt76, skb, 3769 MCU_WM_UNI_CMD(VOW), true); 3770 } 3771 3772 int mt7996_mcu_init_firmware(struct mt7996_dev *dev) 3773 { 3774 int ret; 3775 3776 /* force firmware operation mode into normal state, 3777 * which should be set before firmware download stage. 3778 */ 3779 mt76_wr(dev, MT_SWDEF_MODE, MT_SWDEF_NORMAL_MODE); 3780 3781 ret = mt7996_driver_own(dev, 0); 3782 if (ret) 3783 return ret; 3784 /* set driver own for band1 when two hif exist */ 3785 if (dev->hif2) { 3786 ret = mt7996_driver_own(dev, 1); 3787 if (ret) 3788 return ret; 3789 } 3790 3791 ret = mt7996_load_firmware(dev); 3792 if (ret) 3793 return ret; 3794 3795 set_bit(MT76_STATE_MCU_RUNNING, &dev->mphy.state); 3796 ret = mt7996_mcu_fw_log_2_host(dev, MCU_FW_LOG_WM, 0); 3797 if (ret) 3798 return ret; 3799 3800 if (mt7996_has_wa(dev)) { 3801 ret = mt7996_mcu_fw_log_2_host(dev, MCU_FW_LOG_WA, 0); 3802 if (ret) 3803 return ret; 3804 3805 ret = mt7996_mcu_set_mwds(dev, 1); 3806 if (ret) 3807 return ret; 3808 } 3809 3810 ret = mt7996_mcu_init_rx_airtime(dev); 3811 if (ret) 3812 return ret; 3813 3814 return mt7996_mcu_wa_cmd(dev, MCU_WA_PARAM_CMD(SET), 3815 MCU_WA_PARAM_RED, 0, 0); 3816 } 3817 3818 int mt7996_mcu_init(struct mt7996_dev *dev) 3819 { 3820 static const struct mt76_mcu_ops mt7996_mcu_ops = { 3821 .headroom = sizeof(struct mt76_connac2_mcu_txd), /* reuse */ 3822 .mcu_skb_send_msg = mt7996_mcu_send_message, 3823 .mcu_parse_response = mt7996_mcu_parse_response, 3824 }; 3825 3826 dev->mt76.mcu_ops = &mt7996_mcu_ops; 3827 3828 return mt7996_mcu_init_firmware(dev); 3829 } 3830 3831 void mt7996_mcu_exit(struct mt7996_dev *dev) 3832 { 3833 mt7996_mcu_restart(&dev->mt76); 3834 if (mt7996_firmware_state(dev, FW_STATE_FW_DOWNLOAD)) { 3835 dev_err(dev->mt76.dev, "Failed to exit mcu\n"); 3836 goto out; 3837 } 3838 3839 mt76_wr(dev, MT_TOP_LPCR_HOST_BAND(0), MT_TOP_LPCR_HOST_FW_OWN); 3840 if (dev->hif2) 3841 mt76_wr(dev, MT_TOP_LPCR_HOST_BAND(1), 3842 MT_TOP_LPCR_HOST_FW_OWN); 3843 out: 3844 skb_queue_purge(&dev->mt76.mcu.res_q); 3845 } 3846 3847 int mt7996_mcu_set_hdr_trans(struct mt7996_dev *dev, bool hdr_trans) 3848 { 3849 struct { 3850 u8 __rsv[4]; 3851 } __packed hdr = {}; 3852 struct hdr_trans_blacklist *req_blacklist; 3853 struct hdr_trans_en *req_en; 3854 struct sk_buff *skb; 3855 struct tlv *tlv; 3856 int len = MT7996_HDR_TRANS_MAX_SIZE + sizeof(hdr); 3857 3858 skb = mt76_mcu_msg_alloc(&dev->mt76, NULL, len); 3859 if (!skb) 3860 return -ENOMEM; 3861 3862 skb_put_data(skb, &hdr, sizeof(hdr)); 3863 3864 tlv = mt7996_mcu_add_uni_tlv(skb, UNI_HDR_TRANS_EN, sizeof(*req_en)); 3865 req_en = (struct hdr_trans_en *)tlv; 3866 req_en->enable = hdr_trans; 3867 3868 tlv = mt7996_mcu_add_uni_tlv(skb, UNI_HDR_TRANS_VLAN, 3869 sizeof(struct hdr_trans_vlan)); 3870 3871 if (hdr_trans) { 3872 tlv = mt7996_mcu_add_uni_tlv(skb, UNI_HDR_TRANS_BLACKLIST, 3873 sizeof(*req_blacklist)); 3874 req_blacklist = (struct hdr_trans_blacklist *)tlv; 3875 req_blacklist->enable = 1; 3876 req_blacklist->type = cpu_to_le16(ETH_P_PAE); 3877 } 3878 3879 return mt76_mcu_skb_send_msg(&dev->mt76, skb, 3880 MCU_WM_UNI_CMD(RX_HDR_TRANS), true); 3881 } 3882 3883 int mt7996_mcu_set_tx(struct mt7996_dev *dev, struct ieee80211_vif *vif, 3884 struct ieee80211_bss_conf *link_conf) 3885 { 3886 #define MCU_EDCA_AC_PARAM 0 3887 #define WMM_AIFS_SET BIT(0) 3888 #define WMM_CW_MIN_SET BIT(1) 3889 #define WMM_CW_MAX_SET BIT(2) 3890 #define WMM_TXOP_SET BIT(3) 3891 #define WMM_PARAM_SET (WMM_AIFS_SET | WMM_CW_MIN_SET | \ 3892 WMM_CW_MAX_SET | WMM_TXOP_SET) 3893 struct mt7996_vif_link *link = mt7996_vif_conf_link(dev, vif, link_conf); 3894 struct mt7996_vif *mvif = (struct mt7996_vif *)vif->drv_priv; 3895 unsigned int link_id = link_conf->link_id; 3896 struct mt7996_vif_link_info *link_info = &mvif->link_info[link_id]; 3897 struct { 3898 u8 bss_idx; 3899 u8 __rsv[3]; 3900 } __packed hdr = { 3901 .bss_idx = link->mt76.idx, 3902 }; 3903 struct sk_buff *skb; 3904 int len = sizeof(hdr) + IEEE80211_NUM_ACS * sizeof(struct edca); 3905 int ac; 3906 3907 skb = mt76_mcu_msg_alloc(&dev->mt76, NULL, len); 3908 if (!skb) 3909 return -ENOMEM; 3910 3911 skb_put_data(skb, &hdr, sizeof(hdr)); 3912 3913 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) { 3914 struct ieee80211_tx_queue_params *q = &link_info->queue_params[ac]; 3915 struct edca *e; 3916 struct tlv *tlv; 3917 3918 tlv = mt7996_mcu_add_uni_tlv(skb, MCU_EDCA_AC_PARAM, sizeof(*e)); 3919 3920 e = (struct edca *)tlv; 3921 e->set = WMM_PARAM_SET; 3922 e->queue = ac; 3923 e->aifs = q->aifs; 3924 e->txop = cpu_to_le16(q->txop); 3925 3926 if (q->cw_min) 3927 e->cw_min = fls(q->cw_min); 3928 else 3929 e->cw_min = 5; 3930 3931 if (q->cw_max) 3932 e->cw_max = fls(q->cw_max); 3933 else 3934 e->cw_max = 10; 3935 } 3936 3937 return mt76_mcu_skb_send_msg(&dev->mt76, skb, 3938 MCU_WM_UNI_CMD(EDCA_UPDATE), true); 3939 } 3940 3941 int mt7996_mcu_set_fcc5_lpn(struct mt7996_dev *dev, int val) 3942 { 3943 struct { 3944 u8 _rsv[4]; 3945 3946 __le16 tag; 3947 __le16 len; 3948 3949 __le32 ctrl; 3950 __le16 min_lpn; 3951 u8 rsv[2]; 3952 } __packed req = { 3953 .tag = cpu_to_le16(UNI_RDD_CTRL_SET_TH), 3954 .len = cpu_to_le16(sizeof(req) - 4), 3955 3956 .ctrl = cpu_to_le32(0x1), 3957 .min_lpn = cpu_to_le16(val), 3958 }; 3959 3960 return mt76_mcu_send_msg(&dev->mt76, MCU_WM_UNI_CMD(RDD_CTRL), 3961 &req, sizeof(req), true); 3962 } 3963 3964 int mt7996_mcu_set_pulse_th(struct mt7996_dev *dev, 3965 const struct mt7996_dfs_pulse *pulse) 3966 { 3967 struct { 3968 u8 _rsv[4]; 3969 3970 __le16 tag; 3971 __le16 len; 3972 3973 __le32 ctrl; 3974 3975 __le32 max_width; /* us */ 3976 __le32 max_pwr; /* dbm */ 3977 __le32 min_pwr; /* dbm */ 3978 __le32 min_stgr_pri; /* us */ 3979 __le32 max_stgr_pri; /* us */ 3980 __le32 min_cr_pri; /* us */ 3981 __le32 max_cr_pri; /* us */ 3982 } __packed req = { 3983 .tag = cpu_to_le16(UNI_RDD_CTRL_SET_TH), 3984 .len = cpu_to_le16(sizeof(req) - 4), 3985 3986 .ctrl = cpu_to_le32(0x3), 3987 3988 #define __req_field(field) .field = cpu_to_le32(pulse->field) 3989 __req_field(max_width), 3990 __req_field(max_pwr), 3991 __req_field(min_pwr), 3992 __req_field(min_stgr_pri), 3993 __req_field(max_stgr_pri), 3994 __req_field(min_cr_pri), 3995 __req_field(max_cr_pri), 3996 #undef __req_field 3997 }; 3998 3999 return mt76_mcu_send_msg(&dev->mt76, MCU_WM_UNI_CMD(RDD_CTRL), 4000 &req, sizeof(req), true); 4001 } 4002 4003 int mt7996_mcu_set_radar_th(struct mt7996_dev *dev, int index, 4004 const struct mt7996_dfs_pattern *pattern) 4005 { 4006 struct { 4007 u8 _rsv[4]; 4008 4009 __le16 tag; 4010 __le16 len; 4011 4012 __le32 ctrl; 4013 __le16 radar_type; 4014 4015 u8 enb; 4016 u8 stgr; 4017 u8 min_crpn; 4018 u8 max_crpn; 4019 u8 min_crpr; 4020 u8 min_pw; 4021 __le32 min_pri; 4022 __le32 max_pri; 4023 u8 max_pw; 4024 u8 min_crbn; 4025 u8 max_crbn; 4026 u8 min_stgpn; 4027 u8 max_stgpn; 4028 u8 min_stgpr; 4029 u8 rsv[2]; 4030 __le32 min_stgpr_diff; 4031 } __packed req = { 4032 .tag = cpu_to_le16(UNI_RDD_CTRL_SET_TH), 4033 .len = cpu_to_le16(sizeof(req) - 4), 4034 4035 .ctrl = cpu_to_le32(0x2), 4036 .radar_type = cpu_to_le16(index), 4037 4038 #define __req_field_u8(field) .field = pattern->field 4039 #define __req_field_u32(field) .field = cpu_to_le32(pattern->field) 4040 __req_field_u8(enb), 4041 __req_field_u8(stgr), 4042 __req_field_u8(min_crpn), 4043 __req_field_u8(max_crpn), 4044 __req_field_u8(min_crpr), 4045 __req_field_u8(min_pw), 4046 __req_field_u32(min_pri), 4047 __req_field_u32(max_pri), 4048 __req_field_u8(max_pw), 4049 __req_field_u8(min_crbn), 4050 __req_field_u8(max_crbn), 4051 __req_field_u8(min_stgpn), 4052 __req_field_u8(max_stgpn), 4053 __req_field_u8(min_stgpr), 4054 __req_field_u32(min_stgpr_diff), 4055 #undef __req_field_u8 4056 #undef __req_field_u32 4057 }; 4058 4059 return mt76_mcu_send_msg(&dev->mt76, MCU_WM_UNI_CMD(RDD_CTRL), 4060 &req, sizeof(req), true); 4061 } 4062 4063 static int 4064 mt7996_mcu_background_chain_ctrl(struct mt7996_phy *phy, 4065 struct cfg80211_chan_def *chandef, 4066 int cmd) 4067 { 4068 struct mt7996_dev *dev = phy->dev; 4069 struct mt76_phy *mphy = phy->mt76; 4070 struct ieee80211_channel *chan = mphy->chandef.chan; 4071 int freq = mphy->chandef.center_freq1; 4072 struct mt7996_mcu_background_chain_ctrl req = { 4073 .tag = cpu_to_le16(0), 4074 .len = cpu_to_le16(sizeof(req) - 4), 4075 .monitor_scan_type = 2, /* simple rx */ 4076 }; 4077 4078 if (!chandef && cmd != CH_SWITCH_BACKGROUND_SCAN_STOP) 4079 return -EINVAL; 4080 4081 if (!cfg80211_chandef_valid(&mphy->chandef)) 4082 return -EINVAL; 4083 4084 switch (cmd) { 4085 case CH_SWITCH_BACKGROUND_SCAN_START: { 4086 req.chan = chan->hw_value; 4087 req.central_chan = ieee80211_frequency_to_channel(freq); 4088 req.bw = mt76_connac_chan_bw(&mphy->chandef); 4089 req.monitor_chan = chandef->chan->hw_value; 4090 req.monitor_central_chan = 4091 ieee80211_frequency_to_channel(chandef->center_freq1); 4092 req.monitor_bw = mt76_connac_chan_bw(chandef); 4093 req.band_idx = phy->mt76->band_idx; 4094 req.scan_mode = 1; 4095 break; 4096 } 4097 case CH_SWITCH_BACKGROUND_SCAN_RUNNING: 4098 req.monitor_chan = chandef->chan->hw_value; 4099 req.monitor_central_chan = 4100 ieee80211_frequency_to_channel(chandef->center_freq1); 4101 req.band_idx = phy->mt76->band_idx; 4102 req.scan_mode = 2; 4103 break; 4104 case CH_SWITCH_BACKGROUND_SCAN_STOP: 4105 req.chan = chan->hw_value; 4106 req.central_chan = ieee80211_frequency_to_channel(freq); 4107 req.bw = mt76_connac_chan_bw(&mphy->chandef); 4108 req.tx_stream = hweight8(mphy->antenna_mask); 4109 req.rx_stream = mphy->antenna_mask; 4110 break; 4111 default: 4112 return -EINVAL; 4113 } 4114 req.band = chandef ? chandef->chan->band == NL80211_BAND_5GHZ : 1; 4115 4116 return mt76_mcu_send_msg(&dev->mt76, MCU_WM_UNI_CMD(OFFCH_SCAN_CTRL), 4117 &req, sizeof(req), false); 4118 } 4119 4120 int mt7996_mcu_rdd_background_enable(struct mt7996_phy *phy, 4121 struct cfg80211_chan_def *chandef) 4122 { 4123 struct mt7996_dev *dev = phy->dev; 4124 int err, region, rdd_idx = mt7996_get_rdd_idx(phy, true); 4125 4126 if (rdd_idx < 0) 4127 return -EINVAL; 4128 4129 if (!chandef) { /* disable offchain */ 4130 err = mt7996_mcu_rdd_cmd(dev, RDD_STOP, rdd_idx, 0); 4131 if (err) 4132 return err; 4133 4134 return mt7996_mcu_background_chain_ctrl(phy, NULL, 4135 CH_SWITCH_BACKGROUND_SCAN_STOP); 4136 } 4137 4138 err = mt7996_mcu_background_chain_ctrl(phy, chandef, 4139 CH_SWITCH_BACKGROUND_SCAN_START); 4140 if (err) 4141 return err; 4142 4143 switch (dev->mt76.region) { 4144 case NL80211_DFS_ETSI: 4145 region = 0; 4146 break; 4147 case NL80211_DFS_JP: 4148 region = 2; 4149 break; 4150 case NL80211_DFS_FCC: 4151 default: 4152 region = 1; 4153 break; 4154 } 4155 4156 return mt7996_mcu_rdd_cmd(dev, RDD_START, rdd_idx, region); 4157 } 4158 4159 int mt7996_mcu_set_chan_info(struct mt7996_phy *phy, u16 tag) 4160 { 4161 static const u8 ch_band[] = { 4162 [NL80211_BAND_2GHZ] = 0, 4163 [NL80211_BAND_5GHZ] = 1, 4164 [NL80211_BAND_6GHZ] = 2, 4165 }; 4166 struct mt7996_dev *dev = phy->dev; 4167 struct cfg80211_chan_def *chandef = &phy->mt76->chandef; 4168 int freq1 = chandef->center_freq1; 4169 u8 band_idx = phy->mt76->band_idx; 4170 struct { 4171 /* fixed field */ 4172 u8 __rsv[4]; 4173 4174 __le16 tag; 4175 __le16 len; 4176 u8 control_ch; 4177 u8 center_ch; 4178 u8 bw; 4179 u8 tx_path_num; 4180 u8 rx_path; /* mask or num */ 4181 u8 switch_reason; 4182 u8 band_idx; 4183 u8 center_ch2; /* for 80+80 only */ 4184 __le16 cac_case; 4185 u8 channel_band; 4186 u8 rsv0; 4187 __le32 outband_freq; 4188 u8 txpower_drop; 4189 u8 ap_bw; 4190 u8 ap_center_ch; 4191 u8 rsv1[53]; 4192 } __packed req = { 4193 .tag = cpu_to_le16(tag), 4194 .len = cpu_to_le16(sizeof(req) - 4), 4195 .control_ch = chandef->chan->hw_value, 4196 .center_ch = ieee80211_frequency_to_channel(freq1), 4197 .bw = mt76_connac_chan_bw(chandef), 4198 .tx_path_num = hweight16(phy->mt76->chainmask), 4199 .rx_path = mt7996_rx_chainmask(phy) >> dev->chainshift[band_idx], 4200 .band_idx = band_idx, 4201 .channel_band = ch_band[chandef->chan->band], 4202 }; 4203 4204 if (phy->mt76->hw->conf.flags & IEEE80211_CONF_MONITOR) 4205 req.switch_reason = CH_SWITCH_NORMAL; 4206 else if (phy->mt76->offchannel || !phy->mt76->chanctx) 4207 req.switch_reason = CH_SWITCH_SCAN_BYPASS_DPD; 4208 else if (!cfg80211_reg_can_beacon(phy->mt76->hw->wiphy, chandef, 4209 NL80211_IFTYPE_AP)) 4210 req.switch_reason = CH_SWITCH_DFS; 4211 else 4212 req.switch_reason = CH_SWITCH_NORMAL; 4213 4214 if (tag == UNI_CHANNEL_SWITCH) 4215 req.rx_path = hweight8(req.rx_path); 4216 4217 if (chandef->width == NL80211_CHAN_WIDTH_80P80) { 4218 int freq2 = chandef->center_freq2; 4219 4220 req.center_ch2 = ieee80211_frequency_to_channel(freq2); 4221 } 4222 4223 return mt76_mcu_send_msg(&dev->mt76, MCU_WMWA_UNI_CMD(CHANNEL_SWITCH), 4224 &req, sizeof(req), true); 4225 } 4226 4227 static int 4228 mt7996_mcu_get_cal_free_data(struct mt7996_dev *dev) 4229 { 4230 #define MT_EE_7977BN_OFFSET (0x1200 - 0x500) 4231 struct cal_free_data { 4232 u16 adie_offs; 4233 u16 eep_offs; 4234 }; 4235 static const struct cal_free_data cal_7975[] = { 4236 { 0x5cd, 0x451 }, { 0x5cf, 0x453 }, { 0x5d1, 0x455 }, 4237 { 0x5d3, 0x457 }, { 0x6c0, 0x44c }, { 0x6c1, 0x44d }, 4238 { 0x6c2, 0x44e }, { 0x6c3, 0x44f }, { 0x7a1, 0xba1 }, 4239 { 0x7a6, 0xba6 }, { 0x7a8, 0xba8 }, { 0x7aa, 0xbaa }, 4240 }; 4241 static const struct cal_free_data cal_7976[] = { 4242 { 0x4c, 0x44c }, { 0x4d, 0x44d }, { 0x4e, 0x44e }, 4243 { 0x4f, 0x44f }, { 0x50, 0x450 }, { 0x51, 0x451 }, 4244 { 0x53, 0x453 }, { 0x55, 0x455 }, { 0x57, 0x457 }, 4245 { 0x59, 0x459 }, { 0x70, 0x470 }, { 0x71, 0x471 }, 4246 { 0x790, 0xb90 }, { 0x791, 0xb91 }, { 0x794, 0xb94 }, 4247 { 0x795, 0xb95 }, { 0x7a6, 0xba6 }, { 0x7a8, 0xba8 }, 4248 { 0x7aa, 0xbaa }, 4249 }; 4250 static const struct cal_free_data cal_7977[] = { 4251 { 0x4c, 0x124c }, { 0x4d, 0x124d }, { 0x4e, 0x124e }, 4252 { 0x4f, 0x124f }, { 0x50, 0x1250 }, { 0x51, 0x1251 }, 4253 { 0x53, 0x1253 }, { 0x55, 0x1255 }, { 0x57, 0x1257 }, 4254 { 0x59, 0x1259 }, { 0x69, 0x1269 }, { 0x6a, 0x126a }, 4255 { 0x7a, 0x127a }, { 0x7b, 0x127b }, { 0x7c, 0x127c }, 4256 { 0x7d, 0x127d }, { 0x7e, 0x127e }, 4257 }; 4258 static const struct cal_free_data cal_7978[] = { 4259 { 0x91, 0xb91 }, { 0x95, 0xb95 }, { 0x100, 0x480 }, 4260 { 0x102, 0x482 }, { 0x104, 0x484 }, { 0x106, 0x486 }, 4261 { 0x107, 0x487 }, { 0x108, 0x488 }, { 0x109, 0x489 }, 4262 { 0x10a, 0x48a }, { 0x10b, 0x48b }, { 0x10c, 0x48c }, 4263 { 0x10e, 0x48e }, { 0x110, 0x490 }, 4264 }; 4265 static const struct cal_free_data cal_7979[] = { 4266 { 0x4c, 0x124c }, { 0x4d, 0x124d }, { 0x4e, 0x124e }, 4267 { 0x4f, 0x124f }, { 0x50, 0x1250 }, { 0x51, 0x1251 }, 4268 { 0x53, 0x1253 }, { 0x55, 0x1255 }, { 0x57, 0x1257 }, 4269 { 0x59, 0x1259 }, { 0x69, 0x1269 }, { 0x6a, 0x126a }, 4270 { 0x7a, 0x127a }, { 0x7b, 0x127b }, { 0x7c, 0x127c }, 4271 { 0x7e, 0x127e }, { 0x80, 0x1280 }, 4272 }; 4273 const struct cal_free_data *cal_arr[__MT_MAX_BAND]; 4274 u16 cal_arr_len[__MT_MAX_BAND] = {}; 4275 u8 *eeprom = (u8 *)dev->mt76.eeprom.data; 4276 int band, i, ret; 4277 4278 #define CAL_ARR(_band, _adie) do { \ 4279 cal_arr[_band] = cal_##_adie; \ 4280 cal_arr_len[_band] = ARRAY_SIZE(cal_##_adie); \ 4281 } while (0) 4282 4283 switch (mt76_chip(&dev->mt76)) { 4284 case MT7996_DEVICE_ID: 4285 /* adie 0 */ 4286 if (dev->var.fem == MT7996_FEM_INT && 4287 dev->var.type != MT7996_VAR_TYPE_233) 4288 CAL_ARR(0, 7975); 4289 else 4290 CAL_ARR(0, 7976); 4291 4292 /* adie 1 */ 4293 if (dev->var.type == MT7996_VAR_TYPE_444) 4294 CAL_ARR(1, 7977); 4295 4296 /* adie 2 */ 4297 CAL_ARR(2, 7977); 4298 break; 4299 case MT7992_DEVICE_ID: 4300 /* adie 0 */ 4301 if (dev->var.type == MT7992_VAR_TYPE_44 && 4302 dev->var.fem != MT7996_FEM_EXT) 4303 CAL_ARR(0, 7975); 4304 else if (dev->var.type == MT7992_VAR_TYPE_24) 4305 CAL_ARR(0, 7978); 4306 else 4307 CAL_ARR(0, 7976); 4308 4309 /* adie 1 */ 4310 if (dev->var.type == MT7992_VAR_TYPE_44 && 4311 dev->var.fem != MT7996_FEM_INT) 4312 CAL_ARR(1, 7977); 4313 else if (dev->var.type != MT7992_VAR_TYPE_23) 4314 CAL_ARR(1, 7979); 4315 break; 4316 case MT7990_DEVICE_ID: 4317 /* adie 0 */ 4318 CAL_ARR(0, 7976); 4319 break; 4320 default: 4321 return -EINVAL; 4322 } 4323 4324 for (band = 0; band < __MT_MAX_BAND; band++) { 4325 u8 buf[MT7996_EEPROM_BLOCK_SIZE]; 4326 const struct cal_free_data *cal; 4327 u16 prev_block_idx = -1; 4328 u16 adie_base; 4329 4330 if (!cal_arr_len[band]) 4331 continue; 4332 4333 if (band == MT_BAND0) 4334 adie_base = MT7996_EFUSE_BASE_OFFS_ADIE0; 4335 else if (band == MT_BAND1 && is_mt7992(&dev->mt76)) 4336 adie_base = MT7992_EFUSE_BASE_OFFS_ADIE1; 4337 else if (band == MT_BAND1) 4338 adie_base = MT7996_EFUSE_BASE_OFFS_ADIE1; 4339 else 4340 adie_base = MT7996_EFUSE_BASE_OFFS_ADIE2; 4341 4342 cal = cal_arr[band]; 4343 for (i = 0; i < cal_arr_len[band]; i++) { 4344 u16 adie_offset = cal[i].adie_offs + adie_base; 4345 u16 eep_offset = cal[i].eep_offs; 4346 u16 block_idx = adie_offset / MT7996_EEPROM_BLOCK_SIZE; 4347 u16 offset = adie_offset % MT7996_EEPROM_BLOCK_SIZE; 4348 4349 if (is_mt7996(&dev->mt76) && band == MT_BAND1 && 4350 dev->var.type == MT7996_VAR_TYPE_444) 4351 eep_offset -= MT_EE_7977BN_OFFSET; 4352 4353 if (prev_block_idx != block_idx) { 4354 memset(buf, 0, sizeof(buf)); 4355 ret = mt7996_mcu_get_eeprom(dev, adie_offset, buf, 4356 MT7996_EEPROM_BLOCK_SIZE, 4357 EEPROM_MODE_EFUSE); 4358 if (ret) { 4359 if (ret != -EINVAL) 4360 return ret; 4361 prev_block_idx = -1; 4362 continue; 4363 } 4364 } 4365 eeprom[eep_offset] = buf[offset]; 4366 prev_block_idx = block_idx; 4367 } 4368 } 4369 4370 return 0; 4371 } 4372 4373 int mt7996_mcu_set_eeprom(struct mt7996_dev *dev) 4374 { 4375 #define MAX_PAGE_IDX_MASK GENMASK(7, 5) 4376 #define PAGE_IDX_MASK GENMASK(4, 2) 4377 #define PER_PAGE_SIZE 0x400 4378 struct mt7996_mcu_eeprom_update req = { 4379 .tag = cpu_to_le16(UNI_EFUSE_BUFFER_MODE), 4380 .buffer_mode = EE_MODE_BUFFER 4381 }; 4382 u16 eeprom_size = MT7996_EEPROM_SIZE; 4383 u8 total = DIV_ROUND_UP(eeprom_size, PER_PAGE_SIZE); 4384 u8 *eep = (u8 *)dev->mt76.eeprom.data; 4385 int ret, eep_len, i; 4386 4387 ret = mt7996_mcu_get_cal_free_data(dev); 4388 if (ret) 4389 return ret; 4390 4391 for (i = 0; i < total; i++, eep += eep_len) { 4392 struct sk_buff *skb; 4393 int msg_len; 4394 4395 if (i == total - 1 && !!(eeprom_size % PER_PAGE_SIZE)) 4396 eep_len = eeprom_size % PER_PAGE_SIZE; 4397 else 4398 eep_len = PER_PAGE_SIZE; 4399 4400 msg_len = sizeof(req) + eep_len; 4401 skb = mt76_mcu_msg_alloc(&dev->mt76, NULL, msg_len); 4402 if (!skb) 4403 return -ENOMEM; 4404 4405 req.len = cpu_to_le16(msg_len - 4); 4406 req.format = FIELD_PREP(MAX_PAGE_IDX_MASK, total - 1) | 4407 FIELD_PREP(PAGE_IDX_MASK, i) | EE_FORMAT_WHOLE; 4408 req.buf_len = cpu_to_le16(eep_len); 4409 4410 skb_put_data(skb, &req, sizeof(req)); 4411 skb_put_data(skb, eep, eep_len); 4412 4413 ret = mt76_mcu_skb_send_msg(&dev->mt76, skb, 4414 MCU_WM_UNI_CMD(EFUSE_CTRL), true); 4415 if (ret) 4416 return ret; 4417 } 4418 4419 return 0; 4420 } 4421 4422 int mt7996_mcu_get_eeprom(struct mt7996_dev *dev, u32 offset, u8 *buf, u32 buf_len, 4423 enum mt7996_eeprom_mode mode) 4424 { 4425 struct mt7996_mcu_eeprom_access req = { 4426 .info.len = cpu_to_le16(sizeof(req) - 4), 4427 }; 4428 struct mt7996_mcu_eeprom_access_event *event; 4429 struct sk_buff *skb; 4430 int ret, cmd; 4431 u32 addr; 4432 4433 switch (mode) { 4434 case EEPROM_MODE_EFUSE: 4435 addr = round_down(offset, MT7996_EEPROM_BLOCK_SIZE); 4436 cmd = MCU_WM_UNI_CMD_QUERY(EFUSE_CTRL); 4437 req.info.tag = cpu_to_le16(UNI_EFUSE_ACCESS); 4438 break; 4439 case EEPROM_MODE_EXT: 4440 addr = round_down(offset, MT7996_EXT_EEPROM_BLOCK_SIZE); 4441 cmd = MCU_WM_UNI_CMD_QUERY(EXT_EEPROM_CTRL); 4442 req.info.tag = cpu_to_le16(UNI_EXT_EEPROM_ACCESS); 4443 req.eeprom.ext_eeprom.data_len = cpu_to_le32(buf_len); 4444 break; 4445 default: 4446 return -EINVAL; 4447 } 4448 4449 req.info.addr = cpu_to_le32(addr); 4450 ret = mt76_mcu_send_and_get_msg(&dev->mt76, cmd, &req, sizeof(req), 4451 true, &skb); 4452 if (ret) 4453 return ret; 4454 4455 event = (struct mt7996_mcu_eeprom_access_event *)skb->data; 4456 if (event->valid) { 4457 u32 ret_len = le32_to_cpu(event->eeprom.ext_eeprom.data_len); 4458 u32 block = mode == EEPROM_MODE_EXT ? MT7996_EXT_EEPROM_BLOCK_SIZE : 4459 MT7996_EEPROM_BLOCK_SIZE; 4460 4461 addr = le32_to_cpu(event->addr); 4462 4463 if (!buf) { 4464 if (addr > dev->mt76.eeprom.size - block) { 4465 dev_kfree_skb(skb); 4466 return -EINVAL; 4467 } 4468 buf = (u8 *)dev->mt76.eeprom.data + addr; 4469 } 4470 4471 switch (mode) { 4472 case EEPROM_MODE_EFUSE: 4473 if (!buf_len || buf_len > MT7996_EEPROM_BLOCK_SIZE) 4474 buf_len = MT7996_EEPROM_BLOCK_SIZE; 4475 4476 memcpy(buf, event->eeprom.efuse, buf_len); 4477 break; 4478 case EEPROM_MODE_EXT: 4479 if (!buf_len || buf_len > MT7996_EXT_EEPROM_BLOCK_SIZE) 4480 buf_len = MT7996_EXT_EEPROM_BLOCK_SIZE; 4481 4482 memcpy(buf, event->eeprom.ext_eeprom.data, 4483 ret_len < buf_len ? ret_len : buf_len); 4484 break; 4485 default: 4486 ret = -EINVAL; 4487 break; 4488 } 4489 } else { 4490 ret = -EINVAL; 4491 } 4492 4493 dev_kfree_skb(skb); 4494 4495 return ret; 4496 } 4497 4498 int mt7996_mcu_get_efuse_free_block(struct mt7996_dev *dev, u8 *block_num) 4499 { 4500 struct { 4501 u8 _rsv[4]; 4502 4503 __le16 tag; 4504 __le16 len; 4505 u8 num; 4506 u8 version; 4507 u8 die_idx; 4508 u8 _rsv2; 4509 } __packed req = { 4510 .tag = cpu_to_le16(UNI_EFUSE_FREE_BLOCK), 4511 .len = cpu_to_le16(sizeof(req) - 4), 4512 .version = 2, 4513 }; 4514 struct sk_buff *skb; 4515 int ret; 4516 4517 ret = mt76_mcu_send_and_get_msg(&dev->mt76, MCU_WM_UNI_CMD_QUERY(EFUSE_CTRL), &req, 4518 sizeof(req), true, &skb); 4519 if (ret) 4520 return ret; 4521 4522 *block_num = *(u8 *)(skb->data + 8); 4523 dev_kfree_skb(skb); 4524 4525 return 0; 4526 } 4527 4528 int mt7996_mcu_get_chip_config(struct mt7996_dev *dev, u32 *cap) 4529 { 4530 #define UNI_EVENT_CHIP_CONFIG_EFUSE_VERSION 0x21 4531 struct { 4532 u8 _rsv[4]; 4533 4534 __le16 tag; 4535 __le16 len; 4536 } __packed req = { 4537 .tag = cpu_to_le16(UNI_CHIP_CONFIG_NIC_CAPA), 4538 .len = cpu_to_le16(sizeof(req) - 4), 4539 }; 4540 struct sk_buff *skb; 4541 u8 *buf; 4542 int ret; 4543 4544 ret = mt76_mcu_send_and_get_msg(&dev->mt76, 4545 MCU_WM_UNI_CMD_QUERY(CHIP_CONFIG), &req, 4546 sizeof(req), true, &skb); 4547 if (ret) 4548 return ret; 4549 4550 /* fixed field */ 4551 if (skb->len < 4) { 4552 dev_kfree_skb(skb); 4553 return -EINVAL; 4554 } 4555 skb_pull(skb, 4); 4556 4557 buf = skb->data; 4558 while (buf - skb->data + sizeof(struct tlv) <= skb->len) { 4559 struct tlv *tlv = (struct tlv *)buf; 4560 u16 tlv_len = le16_to_cpu(tlv->len); 4561 4562 if (tlv_len < sizeof(*tlv) || 4563 tlv_len > skb->len - (buf - skb->data)) 4564 break; 4565 4566 switch (le16_to_cpu(tlv->tag)) { 4567 case UNI_EVENT_CHIP_CONFIG_EFUSE_VERSION: 4568 if (tlv_len >= sizeof(*tlv) + sizeof(__le32)) 4569 *cap = le32_to_cpu(*(__le32 *)(buf + sizeof(*tlv))); 4570 break; 4571 default: 4572 break; 4573 } 4574 4575 buf += tlv_len; 4576 } 4577 4578 dev_kfree_skb(skb); 4579 4580 return 0; 4581 } 4582 4583 int mt7996_mcu_get_chan_mib_info(struct mt7996_phy *phy, bool chan_switch) 4584 { 4585 enum { 4586 IDX_TX_TIME, 4587 IDX_RX_TIME, 4588 IDX_OBSS_AIRTIME, 4589 IDX_NON_WIFI_TIME, 4590 IDX_NUM 4591 }; 4592 struct { 4593 struct { 4594 u8 band; 4595 u8 __rsv[3]; 4596 } hdr; 4597 struct { 4598 __le16 tag; 4599 __le16 len; 4600 __le32 offs; 4601 } data[IDX_NUM]; 4602 } __packed req = { 4603 .hdr.band = phy->mt76->band_idx, 4604 }; 4605 static const u32 offs[] = { 4606 [IDX_TX_TIME] = UNI_MIB_TX_TIME, 4607 [IDX_RX_TIME] = UNI_MIB_RX_TIME, 4608 [IDX_OBSS_AIRTIME] = UNI_MIB_OBSS_AIRTIME, 4609 [IDX_NON_WIFI_TIME] = UNI_MIB_NON_WIFI_TIME, 4610 }; 4611 struct mt76_channel_state *state = phy->mt76->chan_state; 4612 struct mt76_channel_state *state_ts = &phy->state_ts; 4613 struct mt7996_dev *dev = phy->dev; 4614 struct mt7996_mcu_mib *res; 4615 struct sk_buff *skb; 4616 int i, ret; 4617 4618 for (i = 0; i < IDX_NUM; i++) { 4619 req.data[i].tag = cpu_to_le16(UNI_CMD_MIB_DATA); 4620 req.data[i].len = cpu_to_le16(sizeof(req.data[i])); 4621 req.data[i].offs = cpu_to_le32(offs[i]); 4622 } 4623 4624 ret = mt76_mcu_send_and_get_msg(&dev->mt76, MCU_WM_UNI_CMD_QUERY(GET_MIB_INFO), 4625 &req, sizeof(req), true, &skb); 4626 if (ret) 4627 return ret; 4628 4629 skb_pull(skb, sizeof(req.hdr)); 4630 4631 res = (struct mt7996_mcu_mib *)(skb->data); 4632 4633 if (chan_switch) 4634 goto out; 4635 4636 #define __res_u64(s) le64_to_cpu(res[s].data) 4637 state->cc_tx += __res_u64(IDX_TX_TIME) - state_ts->cc_tx; 4638 state->cc_bss_rx += __res_u64(IDX_RX_TIME) - state_ts->cc_bss_rx; 4639 state->cc_rx += __res_u64(IDX_RX_TIME) + 4640 __res_u64(IDX_OBSS_AIRTIME) - 4641 state_ts->cc_rx; 4642 state->cc_busy += __res_u64(IDX_TX_TIME) + 4643 __res_u64(IDX_RX_TIME) + 4644 __res_u64(IDX_OBSS_AIRTIME) + 4645 __res_u64(IDX_NON_WIFI_TIME) - 4646 state_ts->cc_busy; 4647 out: 4648 state_ts->cc_tx = __res_u64(IDX_TX_TIME); 4649 state_ts->cc_bss_rx = __res_u64(IDX_RX_TIME); 4650 state_ts->cc_rx = __res_u64(IDX_RX_TIME) + __res_u64(IDX_OBSS_AIRTIME); 4651 state_ts->cc_busy = __res_u64(IDX_TX_TIME) + 4652 __res_u64(IDX_RX_TIME) + 4653 __res_u64(IDX_OBSS_AIRTIME) + 4654 __res_u64(IDX_NON_WIFI_TIME); 4655 #undef __res_u64 4656 4657 dev_kfree_skb(skb); 4658 4659 return 0; 4660 } 4661 4662 int mt7996_mcu_get_temperature(struct mt7996_phy *phy) 4663 { 4664 #define TEMPERATURE_QUERY 0 4665 #define GET_TEMPERATURE 0 4666 struct { 4667 u8 _rsv[4]; 4668 4669 __le16 tag; 4670 __le16 len; 4671 4672 u8 rsv1; 4673 u8 action; 4674 u8 band_idx; 4675 u8 rsv2; 4676 } req = { 4677 .tag = cpu_to_le16(TEMPERATURE_QUERY), 4678 .len = cpu_to_le16(sizeof(req) - 4), 4679 .action = GET_TEMPERATURE, 4680 .band_idx = phy->mt76->band_idx, 4681 }; 4682 struct mt7996_mcu_thermal { 4683 u8 _rsv[4]; 4684 4685 __le16 tag; 4686 __le16 len; 4687 4688 __le32 rsv; 4689 __le32 temperature; 4690 } __packed * res; 4691 struct sk_buff *skb; 4692 int ret; 4693 u32 temp; 4694 4695 ret = mt76_mcu_send_and_get_msg(&phy->dev->mt76, MCU_WM_UNI_CMD(THERMAL), 4696 &req, sizeof(req), true, &skb); 4697 if (ret) 4698 return ret; 4699 4700 res = (void *)skb->data; 4701 temp = le32_to_cpu(res->temperature); 4702 dev_kfree_skb(skb); 4703 4704 return temp; 4705 } 4706 4707 int mt7996_mcu_set_thermal_throttling(struct mt7996_phy *phy, u8 state) 4708 { 4709 struct { 4710 u8 _rsv[4]; 4711 4712 __le16 tag; 4713 __le16 len; 4714 4715 struct mt7996_mcu_thermal_ctrl ctrl; 4716 } __packed req = { 4717 .tag = cpu_to_le16(UNI_CMD_THERMAL_PROTECT_DUTY_CONFIG), 4718 .len = cpu_to_le16(sizeof(req) - 4), 4719 .ctrl = { 4720 .band_idx = phy->mt76->band_idx, 4721 }, 4722 }; 4723 int level, ret; 4724 4725 /* set duty cycle and level */ 4726 for (level = 0; level < 4; level++) { 4727 req.ctrl.duty.duty_level = level; 4728 req.ctrl.duty.duty_cycle = state; 4729 state /= 2; 4730 4731 ret = mt76_mcu_send_msg(&phy->dev->mt76, MCU_WM_UNI_CMD(THERMAL), 4732 &req, sizeof(req), false); 4733 if (ret) 4734 return ret; 4735 } 4736 4737 return 0; 4738 } 4739 4740 int mt7996_mcu_set_thermal_protect(struct mt7996_phy *phy, bool enable) 4741 { 4742 #define SUSTAIN_PERIOD 10 4743 struct { 4744 u8 _rsv[4]; 4745 4746 __le16 tag; 4747 __le16 len; 4748 4749 struct mt7996_mcu_thermal_ctrl ctrl; 4750 struct mt7996_mcu_thermal_enable enable; 4751 } __packed req = { 4752 .len = cpu_to_le16(sizeof(req) - 4 - sizeof(req.enable)), 4753 .ctrl = { 4754 .band_idx = phy->mt76->band_idx, 4755 .type.protect_type = 1, 4756 .type.trigger_type = 1, 4757 }, 4758 }; 4759 int ret; 4760 4761 req.tag = cpu_to_le16(UNI_CMD_THERMAL_PROTECT_DISABLE); 4762 4763 ret = mt76_mcu_send_msg(&phy->dev->mt76, MCU_WM_UNI_CMD(THERMAL), 4764 &req, sizeof(req) - sizeof(req.enable), false); 4765 if (ret || !enable) 4766 return ret; 4767 4768 /* set high-temperature trigger threshold */ 4769 req.tag = cpu_to_le16(UNI_CMD_THERMAL_PROTECT_ENABLE); 4770 req.enable.restore_temp = cpu_to_le32(phy->throttle_temp[0]); 4771 req.enable.trigger_temp = cpu_to_le32(phy->throttle_temp[1]); 4772 req.enable.sustain_time = cpu_to_le16(SUSTAIN_PERIOD); 4773 4774 req.len = cpu_to_le16(sizeof(req) - 4); 4775 4776 return mt76_mcu_send_msg(&phy->dev->mt76, MCU_WM_UNI_CMD(THERMAL), 4777 &req, sizeof(req), false); 4778 } 4779 4780 int mt7996_mcu_set_ser(struct mt7996_dev *dev, u8 action, u8 val, u8 band) 4781 { 4782 struct { 4783 u8 rsv[4]; 4784 4785 __le16 tag; 4786 __le16 len; 4787 4788 union { 4789 struct { 4790 __le32 mask; 4791 } __packed set; 4792 4793 struct { 4794 u8 method; 4795 u8 band; 4796 u8 rsv2[2]; 4797 } __packed trigger; 4798 }; 4799 } __packed req = { 4800 .tag = cpu_to_le16(action), 4801 .len = cpu_to_le16(sizeof(req) - 4), 4802 }; 4803 4804 switch (action) { 4805 case UNI_CMD_SER_SET: 4806 req.set.mask = cpu_to_le32(val); 4807 break; 4808 case UNI_CMD_SER_TRIGGER: 4809 req.trigger.method = val; 4810 req.trigger.band = band; 4811 break; 4812 default: 4813 return -EINVAL; 4814 } 4815 4816 return mt76_mcu_send_msg(&dev->mt76, MCU_WM_UNI_CMD(SER), 4817 &req, sizeof(req), false); 4818 } 4819 4820 int mt7996_mcu_set_txbf(struct mt7996_dev *dev, u8 action) 4821 { 4822 #define MT7996_BF_MAX_SIZE sizeof(union bf_tag_tlv) 4823 #define BF_PROCESSING 4 4824 struct uni_header hdr; 4825 struct sk_buff *skb; 4826 struct tlv *tlv; 4827 int len = sizeof(hdr) + MT7996_BF_MAX_SIZE; 4828 4829 memset(&hdr, 0, sizeof(hdr)); 4830 4831 skb = mt76_mcu_msg_alloc(&dev->mt76, NULL, len); 4832 if (!skb) 4833 return -ENOMEM; 4834 4835 skb_put_data(skb, &hdr, sizeof(hdr)); 4836 4837 switch (action) { 4838 case BF_SOUNDING_ON: { 4839 struct bf_sounding_on *req_snd_on; 4840 4841 tlv = mt7996_mcu_add_uni_tlv(skb, action, sizeof(*req_snd_on)); 4842 req_snd_on = (struct bf_sounding_on *)tlv; 4843 req_snd_on->snd_mode = BF_PROCESSING; 4844 break; 4845 } 4846 case BF_HW_EN_UPDATE: { 4847 struct bf_hw_en_status_update *req_hw_en; 4848 4849 tlv = mt7996_mcu_add_uni_tlv(skb, action, sizeof(*req_hw_en)); 4850 req_hw_en = (struct bf_hw_en_status_update *)tlv; 4851 req_hw_en->ebf = true; 4852 req_hw_en->ibf = dev->ibf; 4853 break; 4854 } 4855 case BF_MOD_EN_CTRL: { 4856 struct bf_mod_en_ctrl *req_mod_en; 4857 4858 tlv = mt7996_mcu_add_uni_tlv(skb, action, sizeof(*req_mod_en)); 4859 req_mod_en = (struct bf_mod_en_ctrl *)tlv; 4860 req_mod_en->bf_num = mt7996_band_valid(dev, MT_BAND2) ? 3 : 2; 4861 req_mod_en->bf_bitmap = mt7996_band_valid(dev, MT_BAND2) ? 4862 GENMASK(2, 0) : GENMASK(1, 0); 4863 break; 4864 } 4865 default: 4866 return -EINVAL; 4867 } 4868 4869 return mt76_mcu_skb_send_msg(&dev->mt76, skb, MCU_WM_UNI_CMD(BF), true); 4870 } 4871 4872 static int 4873 mt7996_mcu_enable_obss_spr(struct mt7996_phy *phy, u16 action, u8 val) 4874 { 4875 struct mt7996_dev *dev = phy->dev; 4876 struct { 4877 u8 band_idx; 4878 u8 __rsv[3]; 4879 4880 __le16 tag; 4881 __le16 len; 4882 4883 __le32 val; 4884 } __packed req = { 4885 .band_idx = phy->mt76->band_idx, 4886 .tag = cpu_to_le16(action), 4887 .len = cpu_to_le16(sizeof(req) - 4), 4888 .val = cpu_to_le32(val), 4889 }; 4890 4891 return mt76_mcu_send_msg(&dev->mt76, MCU_WM_UNI_CMD(SR), 4892 &req, sizeof(req), true); 4893 } 4894 4895 static int 4896 mt7996_mcu_set_obss_spr_pd(struct mt7996_phy *phy, 4897 struct ieee80211_he_obss_pd *he_obss_pd) 4898 { 4899 struct mt7996_dev *dev = phy->dev; 4900 u8 max_th = 82, non_srg_max_th = 62; 4901 struct { 4902 u8 band_idx; 4903 u8 __rsv[3]; 4904 4905 __le16 tag; 4906 __le16 len; 4907 4908 u8 pd_th_non_srg; 4909 u8 pd_th_srg; 4910 u8 period_offs; 4911 u8 rcpi_src; 4912 __le16 obss_pd_min; 4913 __le16 obss_pd_min_srg; 4914 u8 resp_txpwr_mode; 4915 u8 txpwr_restrict_mode; 4916 u8 txpwr_ref; 4917 u8 __rsv2[3]; 4918 } __packed req = { 4919 .band_idx = phy->mt76->band_idx, 4920 .tag = cpu_to_le16(UNI_CMD_SR_SET_PARAM), 4921 .len = cpu_to_le16(sizeof(req) - 4), 4922 .obss_pd_min = cpu_to_le16(max_th), 4923 .obss_pd_min_srg = cpu_to_le16(max_th), 4924 .txpwr_restrict_mode = 2, 4925 .txpwr_ref = 21 4926 }; 4927 int ret; 4928 4929 /* disable firmware dynamical PD asjustment */ 4930 ret = mt7996_mcu_enable_obss_spr(phy, UNI_CMD_SR_ENABLE_DPD, false); 4931 if (ret) 4932 return ret; 4933 4934 if (he_obss_pd->sr_ctrl & 4935 IEEE80211_HE_SPR_NON_SRG_OBSS_PD_SR_DISALLOWED) 4936 req.pd_th_non_srg = max_th; 4937 else if (he_obss_pd->sr_ctrl & IEEE80211_HE_SPR_NON_SRG_OFFSET_PRESENT) 4938 req.pd_th_non_srg = max_th - he_obss_pd->non_srg_max_offset; 4939 else 4940 req.pd_th_non_srg = non_srg_max_th; 4941 4942 if (he_obss_pd->sr_ctrl & IEEE80211_HE_SPR_SRG_INFORMATION_PRESENT) 4943 req.pd_th_srg = max_th - he_obss_pd->max_offset; 4944 4945 return mt76_mcu_send_msg(&dev->mt76, MCU_WM_UNI_CMD(SR), 4946 &req, sizeof(req), true); 4947 } 4948 4949 static int 4950 mt7996_mcu_set_obss_spr_siga(struct mt7996_phy *phy, 4951 struct mt7996_vif_link *link, 4952 struct ieee80211_he_obss_pd *he_obss_pd) 4953 { 4954 struct mt7996_dev *dev = phy->dev; 4955 u8 omac = link->mt76.omac_idx; 4956 struct { 4957 u8 band_idx; 4958 u8 __rsv[3]; 4959 4960 __le16 tag; 4961 __le16 len; 4962 4963 u8 omac; 4964 u8 __rsv2[3]; 4965 u8 flag[20]; 4966 } __packed req = { 4967 .band_idx = phy->mt76->band_idx, 4968 .tag = cpu_to_le16(UNI_CMD_SR_SET_SIGA), 4969 .len = cpu_to_le16(sizeof(req) - 4), 4970 .omac = omac > HW_BSSID_MAX ? omac - 12 : omac, 4971 }; 4972 int ret; 4973 4974 if (he_obss_pd->sr_ctrl & IEEE80211_HE_SPR_HESIGA_SR_VAL15_ALLOWED) 4975 req.flag[req.omac] = 0xf; 4976 else 4977 return 0; 4978 4979 /* switch to normal AP mode */ 4980 ret = mt7996_mcu_enable_obss_spr(phy, UNI_CMD_SR_ENABLE_MODE, 0); 4981 if (ret) 4982 return ret; 4983 4984 return mt76_mcu_send_msg(&dev->mt76, MCU_WM_UNI_CMD(SR), 4985 &req, sizeof(req), true); 4986 } 4987 4988 static int 4989 mt7996_mcu_set_obss_spr_bitmap(struct mt7996_phy *phy, 4990 struct ieee80211_he_obss_pd *he_obss_pd) 4991 { 4992 struct mt7996_dev *dev = phy->dev; 4993 struct { 4994 u8 band_idx; 4995 u8 __rsv[3]; 4996 4997 __le16 tag; 4998 __le16 len; 4999 5000 __le32 color_l[2]; 5001 __le32 color_h[2]; 5002 __le32 bssid_l[2]; 5003 __le32 bssid_h[2]; 5004 } __packed req = { 5005 .band_idx = phy->mt76->band_idx, 5006 .tag = cpu_to_le16(UNI_CMD_SR_SET_SRG_BITMAP), 5007 .len = cpu_to_le16(sizeof(req) - 4), 5008 }; 5009 u32 bitmap; 5010 5011 memcpy(&bitmap, he_obss_pd->bss_color_bitmap, sizeof(bitmap)); 5012 req.color_l[req.band_idx] = cpu_to_le32(bitmap); 5013 5014 memcpy(&bitmap, he_obss_pd->bss_color_bitmap + 4, sizeof(bitmap)); 5015 req.color_h[req.band_idx] = cpu_to_le32(bitmap); 5016 5017 memcpy(&bitmap, he_obss_pd->partial_bssid_bitmap, sizeof(bitmap)); 5018 req.bssid_l[req.band_idx] = cpu_to_le32(bitmap); 5019 5020 memcpy(&bitmap, he_obss_pd->partial_bssid_bitmap + 4, sizeof(bitmap)); 5021 req.bssid_h[req.band_idx] = cpu_to_le32(bitmap); 5022 5023 return mt76_mcu_send_msg(&dev->mt76, MCU_WM_UNI_CMD(SR), &req, 5024 sizeof(req), true); 5025 } 5026 5027 int mt7996_mcu_add_obss_spr(struct mt7996_phy *phy, 5028 struct mt7996_vif_link *link, 5029 struct ieee80211_he_obss_pd *he_obss_pd) 5030 { 5031 int ret; 5032 5033 /* enable firmware scene detection algorithms */ 5034 ret = mt7996_mcu_enable_obss_spr(phy, UNI_CMD_SR_ENABLE_SD, 5035 sr_scene_detect); 5036 if (ret) 5037 return ret; 5038 5039 /* firmware dynamically adjusts PD threshold so skip manual control */ 5040 if (sr_scene_detect && !he_obss_pd->enable) 5041 return 0; 5042 5043 /* enable spatial reuse */ 5044 ret = mt7996_mcu_enable_obss_spr(phy, UNI_CMD_SR_ENABLE, 5045 he_obss_pd->enable); 5046 if (ret) 5047 return ret; 5048 5049 if (sr_scene_detect || !he_obss_pd->enable) 5050 return 0; 5051 5052 ret = mt7996_mcu_enable_obss_spr(phy, UNI_CMD_SR_ENABLE_TX, true); 5053 if (ret) 5054 return ret; 5055 5056 /* set SRG/non-SRG OBSS PD threshold */ 5057 ret = mt7996_mcu_set_obss_spr_pd(phy, he_obss_pd); 5058 if (ret) 5059 return ret; 5060 5061 /* Set SR prohibit */ 5062 ret = mt7996_mcu_set_obss_spr_siga(phy, link, he_obss_pd); 5063 if (ret) 5064 return ret; 5065 5066 /* set SRG BSS color/BSSID bitmap */ 5067 return mt7996_mcu_set_obss_spr_bitmap(phy, he_obss_pd); 5068 } 5069 5070 int mt7996_mcu_update_bss_color(struct mt7996_dev *dev, 5071 struct mt76_vif_link *mlink, 5072 struct cfg80211_he_bss_color *he_bss_color) 5073 { 5074 int len = sizeof(struct bss_req_hdr) + sizeof(struct bss_color_tlv); 5075 struct bss_color_tlv *bss_color; 5076 struct sk_buff *skb; 5077 struct tlv *tlv; 5078 5079 skb = __mt7996_mcu_alloc_bss_req(&dev->mt76, mlink, len); 5080 if (IS_ERR(skb)) 5081 return PTR_ERR(skb); 5082 5083 tlv = mt76_connac_mcu_add_tlv(skb, UNI_BSS_INFO_BSS_COLOR, 5084 sizeof(*bss_color)); 5085 bss_color = (struct bss_color_tlv *)tlv; 5086 bss_color->enable = he_bss_color->enabled; 5087 bss_color->color = he_bss_color->color; 5088 5089 return mt76_mcu_skb_send_msg(&dev->mt76, skb, 5090 MCU_WMWA_UNI_CMD(BSS_INFO_UPDATE), true); 5091 } 5092 5093 #define TWT_AGRT_TRIGGER BIT(0) 5094 #define TWT_AGRT_ANNOUNCE BIT(1) 5095 #define TWT_AGRT_PROTECT BIT(2) 5096 5097 int mt7996_mcu_twt_agrt_update(struct mt7996_dev *dev, 5098 struct mt7996_vif_link *link, 5099 struct mt7996_twt_flow *flow, 5100 int cmd) 5101 { 5102 struct { 5103 /* fixed field */ 5104 u8 bss; 5105 u8 _rsv[3]; 5106 5107 __le16 tag; 5108 __le16 len; 5109 u8 tbl_idx; 5110 u8 cmd; 5111 u8 own_mac_idx; 5112 u8 flowid; /* 0xff for group id */ 5113 __le16 peer_id; /* specify the peer_id (msb=0) 5114 * or group_id (msb=1) 5115 */ 5116 u8 duration; /* 256 us */ 5117 u8 bss_idx; 5118 __le64 start_tsf; 5119 __le16 mantissa; 5120 u8 exponent; 5121 u8 is_ap; 5122 u8 agrt_params; 5123 u8 __rsv2[23]; 5124 } __packed req = { 5125 .tag = cpu_to_le16(UNI_CMD_TWT_ARGT_UPDATE), 5126 .len = cpu_to_le16(sizeof(req) - 4), 5127 .tbl_idx = flow->table_id, 5128 .cmd = cmd, 5129 .own_mac_idx = link->mt76.omac_idx, 5130 .flowid = flow->id, 5131 .peer_id = cpu_to_le16(flow->wcid), 5132 .duration = flow->duration, 5133 .bss = link->mt76.idx, 5134 .bss_idx = link->mt76.idx, 5135 .start_tsf = cpu_to_le64(flow->tsf), 5136 .mantissa = flow->mantissa, 5137 .exponent = flow->exp, 5138 .is_ap = true, 5139 }; 5140 5141 if (flow->protection) 5142 req.agrt_params |= TWT_AGRT_PROTECT; 5143 if (!flow->flowtype) 5144 req.agrt_params |= TWT_AGRT_ANNOUNCE; 5145 if (flow->trigger) 5146 req.agrt_params |= TWT_AGRT_TRIGGER; 5147 5148 return mt76_mcu_send_msg(&dev->mt76, MCU_WM_UNI_CMD(TWT), 5149 &req, sizeof(req), true); 5150 } 5151 5152 int mt7996_mcu_set_bssid_mapping_addr(struct mt76_dev *dev, u8 band_idx) 5153 { 5154 enum { 5155 BSSID_MAPPING_ADDR1, 5156 BSSID_MAPPING_ADDR2, 5157 BSSID_MAPPING_ADDR3, 5158 }; 5159 struct { 5160 u8 band_idx; 5161 u8 _rsv1[3]; 5162 5163 __le16 tag; 5164 __le16 len; 5165 u8 addr; 5166 u8 _rsv2[3]; 5167 } __packed req = { 5168 .band_idx = band_idx, 5169 .tag = cpu_to_le16(UNI_BAND_CONFIG_BSSID_MAPPING_ADDR), 5170 .len = cpu_to_le16(sizeof(req) - 4), 5171 .addr = BSSID_MAPPING_ADDR1, 5172 }; 5173 5174 return mt76_mcu_send_msg(dev, MCU_WM_UNI_CMD(BAND_CONFIG), 5175 &req, sizeof(req), true); 5176 } 5177 5178 int mt7996_mcu_set_rts_thresh(struct mt7996_phy *phy, u32 val) 5179 { 5180 struct { 5181 u8 band_idx; 5182 u8 _rsv[3]; 5183 5184 __le16 tag; 5185 __le16 len; 5186 __le32 len_thresh; 5187 __le32 pkt_thresh; 5188 } __packed req = { 5189 .band_idx = phy->mt76->band_idx, 5190 .tag = cpu_to_le16(UNI_BAND_CONFIG_RTS_THRESHOLD), 5191 .len = cpu_to_le16(sizeof(req) - 4), 5192 .len_thresh = cpu_to_le32(val), 5193 .pkt_thresh = cpu_to_le32(0x2), 5194 }; 5195 5196 return mt76_mcu_send_msg(&phy->dev->mt76, MCU_WM_UNI_CMD(BAND_CONFIG), 5197 &req, sizeof(req), true); 5198 } 5199 5200 int mt7996_mcu_set_radio_en(struct mt7996_phy *phy, bool enable) 5201 { 5202 struct { 5203 u8 band_idx; 5204 u8 _rsv[3]; 5205 5206 __le16 tag; 5207 __le16 len; 5208 u8 enable; 5209 u8 _rsv2[3]; 5210 } __packed req = { 5211 .band_idx = phy->mt76->band_idx, 5212 .tag = cpu_to_le16(UNI_BAND_CONFIG_RADIO_ENABLE), 5213 .len = cpu_to_le16(sizeof(req) - 4), 5214 .enable = enable, 5215 }; 5216 5217 return mt76_mcu_send_msg(&phy->dev->mt76, MCU_WM_UNI_CMD(BAND_CONFIG), 5218 &req, sizeof(req), true); 5219 } 5220 5221 int mt7996_mcu_rdd_resume_tx(struct mt7996_phy *phy) 5222 { 5223 struct { 5224 u8 band_idx; 5225 u8 _rsv[3]; 5226 5227 __le16 tag; 5228 __le16 len; 5229 u8 mac_enable; 5230 u8 _rsv2[3]; 5231 } __packed req = { 5232 .band_idx = phy->mt76->band_idx, 5233 .tag = cpu_to_le16(UNI_BAND_CONFIG_MAC_ENABLE_CTRL), 5234 .len = cpu_to_le16(sizeof(req) - 4), 5235 .mac_enable = 2, 5236 }; 5237 int ret; 5238 5239 if (!phy->rdd_tx_paused) 5240 return 0; 5241 5242 ret = mt76_mcu_send_msg(&phy->dev->mt76, MCU_WM_UNI_CMD(BAND_CONFIG), 5243 &req, sizeof(req), true); 5244 if (!ret) 5245 phy->rdd_tx_paused = false; 5246 5247 return ret; 5248 } 5249 5250 int mt7996_mcu_rdd_cmd(struct mt7996_dev *dev, int cmd, u8 rdd_idx, u8 val) 5251 { 5252 struct { 5253 u8 _rsv[4]; 5254 5255 __le16 tag; 5256 __le16 len; 5257 5258 u8 ctrl; 5259 u8 rdd_idx; 5260 u8 rdd_rx_sel; 5261 u8 val; 5262 u8 rsv[4]; 5263 } __packed req = { 5264 .tag = cpu_to_le16(UNI_RDD_CTRL_PARM), 5265 .len = cpu_to_le16(sizeof(req) - 4), 5266 .ctrl = cmd, 5267 .rdd_idx = rdd_idx, 5268 .val = val, 5269 }; 5270 5271 return mt76_mcu_send_msg(&dev->mt76, MCU_WM_UNI_CMD(RDD_CTRL), 5272 &req, sizeof(req), true); 5273 } 5274 5275 int mt7996_mcu_wtbl_update_hdr_trans(struct mt7996_dev *dev, 5276 struct ieee80211_vif *vif, 5277 struct mt7996_vif_link *link, 5278 struct mt7996_sta_link *msta_link) 5279 { 5280 struct sk_buff *skb; 5281 5282 skb = __mt76_connac_mcu_alloc_sta_req(&dev->mt76, &link->mt76, 5283 &msta_link->wcid, 5284 MT7996_STA_UPDATE_MAX_SIZE); 5285 if (IS_ERR(skb)) 5286 return PTR_ERR(skb); 5287 5288 /* starec hdr trans */ 5289 mt7996_mcu_sta_hdr_trans_tlv(dev, skb, vif, &msta_link->wcid); 5290 return mt76_mcu_skb_send_msg(&dev->mt76, skb, 5291 MCU_WMWA_UNI_CMD(STA_REC_UPDATE), true); 5292 } 5293 5294 int mt7996_mcu_ps_leave(struct mt7996_dev *dev, struct mt7996_vif_link *link, 5295 struct mt7996_sta_link *msta_link) 5296 { 5297 struct sk_buff *skb; 5298 5299 skb = __mt76_connac_mcu_alloc_sta_req(&dev->mt76, &link->mt76, 5300 &msta_link->wcid, 5301 MT7996_STA_UPDATE_MAX_SIZE); 5302 if (IS_ERR(skb)) 5303 return PTR_ERR(skb); 5304 5305 mt76_connac_mcu_add_tlv(skb, STA_REC_PS_LEAVE, 5306 sizeof(struct sta_rec_ps_leave)); 5307 5308 return mt76_mcu_skb_send_msg(&dev->mt76, skb, 5309 MCU_WMWA_UNI_CMD(STA_REC_UPDATE), true); 5310 } 5311 5312 int mt7996_mcu_set_fixed_rate_table(struct mt7996_phy *phy, u8 table_idx, 5313 u16 rate_idx, bool beacon) 5314 { 5315 #define UNI_FIXED_RATE_TABLE_SET 0 5316 #define SPE_IXD_SELECT_TXD 0 5317 #define SPE_IXD_SELECT_BMC_WTBL 1 5318 struct mt7996_dev *dev = phy->dev; 5319 struct fixed_rate_table_ctrl req = { 5320 .tag = cpu_to_le16(UNI_FIXED_RATE_TABLE_SET), 5321 .len = cpu_to_le16(sizeof(req) - 4), 5322 .table_idx = table_idx, 5323 .rate_idx = cpu_to_le16(rate_idx), 5324 .gi = 1, 5325 .he_ltf = 1, 5326 }; 5327 u8 band_idx = phy->mt76->band_idx; 5328 5329 if (beacon) { 5330 req.spe_idx_sel = SPE_IXD_SELECT_TXD; 5331 req.spe_idx = 24 + band_idx; 5332 phy->beacon_rate = rate_idx; 5333 } else { 5334 req.spe_idx_sel = SPE_IXD_SELECT_BMC_WTBL; 5335 } 5336 5337 return mt76_mcu_send_msg(&dev->mt76, MCU_WM_UNI_CMD(FIXED_RATE_TABLE), 5338 &req, sizeof(req), false); 5339 } 5340 5341 int mt7996_mcu_rf_regval(struct mt7996_dev *dev, u32 regidx, u32 *val, bool set) 5342 { 5343 struct { 5344 u8 __rsv1[4]; 5345 5346 __le16 tag; 5347 __le16 len; 5348 __le16 idx; 5349 u8 __rsv2[2]; 5350 __le32 ofs; 5351 __le32 data; 5352 } __packed *res, req = { 5353 .tag = cpu_to_le16(UNI_CMD_ACCESS_RF_REG_BASIC), 5354 .len = cpu_to_le16(sizeof(req) - 4), 5355 5356 .idx = cpu_to_le16(u32_get_bits(regidx, GENMASK(31, 24))), 5357 .ofs = cpu_to_le32(u32_get_bits(regidx, GENMASK(23, 0))), 5358 .data = set ? cpu_to_le32(*val) : 0, 5359 }; 5360 struct sk_buff *skb; 5361 int ret; 5362 5363 if (set) 5364 return mt76_mcu_send_msg(&dev->mt76, MCU_WM_UNI_CMD(REG_ACCESS), 5365 &req, sizeof(req), true); 5366 5367 ret = mt76_mcu_send_and_get_msg(&dev->mt76, 5368 MCU_WM_UNI_CMD_QUERY(REG_ACCESS), 5369 &req, sizeof(req), true, &skb); 5370 if (ret) 5371 return ret; 5372 5373 res = (void *)skb->data; 5374 *val = le32_to_cpu(res->data); 5375 dev_kfree_skb(skb); 5376 5377 return 0; 5378 } 5379 5380 int mt7996_mcu_trigger_assert(struct mt7996_dev *dev) 5381 { 5382 struct { 5383 __le16 tag; 5384 __le16 len; 5385 u8 enable; 5386 u8 rsv[3]; 5387 } __packed req = { 5388 .len = cpu_to_le16(sizeof(req) - 4), 5389 .enable = true, 5390 }; 5391 5392 return mt76_mcu_send_msg(&dev->mt76, MCU_WM_UNI_CMD(ASSERT_DUMP), 5393 &req, sizeof(req), false); 5394 } 5395 5396 int mt7996_mcu_set_rro(struct mt7996_dev *dev, u16 tag, u16 val) 5397 { 5398 struct { 5399 u8 __rsv1[4]; 5400 __le16 tag; 5401 __le16 len; 5402 union { 5403 struct { 5404 u8 type; 5405 u8 __rsv2[3]; 5406 } __packed platform_type; 5407 struct { 5408 u8 type; 5409 u8 dest; 5410 u8 __rsv2[2]; 5411 } __packed bypass_mode; 5412 struct { 5413 u8 path; 5414 u8 __rsv2[3]; 5415 } __packed txfree_path; 5416 struct { 5417 __le16 flush_one; 5418 __le16 flush_all; 5419 u8 __rsv2[4]; 5420 } __packed timeout; 5421 }; 5422 } __packed req = { 5423 .tag = cpu_to_le16(tag), 5424 .len = cpu_to_le16(sizeof(req) - 4), 5425 }; 5426 5427 switch (tag) { 5428 case UNI_RRO_SET_PLATFORM_TYPE: 5429 req.platform_type.type = val; 5430 break; 5431 case UNI_RRO_SET_BYPASS_MODE: 5432 req.bypass_mode.type = val; 5433 break; 5434 case UNI_RRO_SET_TXFREE_PATH: 5435 req.txfree_path.path = val; 5436 break; 5437 case UNI_RRO_SET_FLUSH_TIMEOUT: 5438 req.timeout.flush_one = cpu_to_le16(val); 5439 req.timeout.flush_all = cpu_to_le16(2 * val); 5440 break; 5441 default: 5442 return -EINVAL; 5443 } 5444 5445 return mt76_mcu_send_msg(&dev->mt76, MCU_WM_UNI_CMD(RRO), &req, 5446 sizeof(req), true); 5447 } 5448 5449 int mt7996_mcu_get_all_sta_info(struct mt7996_phy *phy, u16 tag) 5450 { 5451 struct mt7996_dev *dev = phy->dev; 5452 struct { 5453 u8 _rsv[4]; 5454 5455 __le16 tag; 5456 __le16 len; 5457 } __packed req = { 5458 .tag = cpu_to_le16(tag), 5459 .len = cpu_to_le16(sizeof(req) - 4), 5460 }; 5461 5462 return mt76_mcu_send_msg(&dev->mt76, MCU_WM_UNI_CMD(ALL_STA_INFO), 5463 &req, sizeof(req), false); 5464 } 5465 5466 int mt7996_mcu_wed_rro_reset_sessions(struct mt7996_dev *dev, u16 id) 5467 { 5468 struct { 5469 u8 __rsv[4]; 5470 5471 __le16 tag; 5472 __le16 len; 5473 __le16 session_id; 5474 u8 pad[4]; 5475 } __packed req = { 5476 .tag = cpu_to_le16(UNI_RRO_DEL_BA_SESSION), 5477 .len = cpu_to_le16(sizeof(req) - 4), 5478 .session_id = cpu_to_le16(id), 5479 }; 5480 5481 return mt76_mcu_send_msg(&dev->mt76, MCU_WM_UNI_CMD(RRO), &req, 5482 sizeof(req), true); 5483 } 5484 5485 int mt7996_mcu_set_sniffer_mode(struct mt7996_phy *phy, bool enabled) 5486 { 5487 struct mt7996_dev *dev = phy->dev; 5488 struct { 5489 u8 band_idx; 5490 u8 _rsv[3]; 5491 __le16 tag; 5492 __le16 len; 5493 u8 enable; 5494 u8 _pad[3]; 5495 } __packed req = { 5496 .band_idx = phy->mt76->band_idx, 5497 .tag = 0, 5498 .len = cpu_to_le16(sizeof(req) - 4), 5499 .enable = enabled, 5500 }; 5501 5502 return mt76_mcu_send_msg(&dev->mt76, MCU_WM_UNI_CMD(SNIFFER), &req, 5503 sizeof(req), true); 5504 } 5505 5506 int mt7996_mcu_set_tx_power_ctrl(struct mt7996_phy *phy, u8 power_ctrl_id, u8 data) 5507 { 5508 struct mt7996_dev *dev = phy->dev; 5509 struct tx_power_ctrl req = { 5510 .tag = cpu_to_le16(power_ctrl_id), 5511 .len = cpu_to_le16(sizeof(req) - 4), 5512 .power_ctrl_id = power_ctrl_id, 5513 .band_idx = phy->mt76->band_idx, 5514 }; 5515 5516 switch (power_ctrl_id) { 5517 case UNI_TXPOWER_SKU_POWER_LIMIT_CTRL: 5518 req.sku_enable = !!data; 5519 break; 5520 case UNI_TXPOWER_PERCENTAGE_CTRL: 5521 req.percentage_ctrl_enable = !!data; 5522 break; 5523 case UNI_TXPOWER_PERCENTAGE_DROP_CTRL: 5524 req.power_drop_level = data; 5525 break; 5526 case UNI_TXPOWER_BACKOFF_POWER_LIMIT_CTRL: 5527 req.bf_backoff_enable = !!data; 5528 break; 5529 case UNI_TXPOWER_ATE_MODE_CTRL: 5530 req.ate_mode_enable = !!data; 5531 break; 5532 default: 5533 return -EINVAL; 5534 } 5535 5536 return mt76_mcu_send_msg(&dev->mt76, MCU_WM_UNI_CMD(TXPOWER), 5537 &req, sizeof(req), false); 5538 } 5539 5540 int mt7996_mcu_set_txpower_sku(struct mt7996_phy *phy) 5541 { 5542 #define TX_POWER_LIMIT_TABLE_RATE 0 5543 struct mt7996_dev *dev = phy->dev; 5544 struct mt76_phy *mphy = phy->mt76; 5545 struct tx_power_limit_table_ctrl { 5546 u8 __rsv1[4]; 5547 5548 __le16 tag; 5549 __le16 len; 5550 u8 power_ctrl_id; 5551 u8 power_limit_type; 5552 u8 band_idx; 5553 } __packed req = { 5554 .tag = cpu_to_le16(UNI_TXPOWER_POWER_LIMIT_TABLE_CTRL), 5555 .len = cpu_to_le16(sizeof(req) + MT7996_SKU_PATH_NUM - 4), 5556 .power_ctrl_id = UNI_TXPOWER_POWER_LIMIT_TABLE_CTRL, 5557 .power_limit_type = TX_POWER_LIMIT_TABLE_RATE, 5558 .band_idx = phy->mt76->band_idx, 5559 }; 5560 struct mt76_power_limits la = {}; 5561 struct sk_buff *skb; 5562 int i, tx_power; 5563 5564 tx_power = mt76_get_power_bound(mphy, phy->txpower); 5565 tx_power = mt76_get_rate_power_limits(mphy, mphy->chandef.chan, 5566 &la, tx_power); 5567 mphy->txpower_cur = tx_power; 5568 5569 skb = mt76_mcu_msg_alloc(&dev->mt76, NULL, 5570 sizeof(req) + MT7996_SKU_PATH_NUM); 5571 if (!skb) 5572 return -ENOMEM; 5573 5574 skb_put_data(skb, &req, sizeof(req)); 5575 /* cck and ofdm */ 5576 skb_put_data(skb, &la.cck, sizeof(la.cck)); 5577 skb_put_data(skb, &la.ofdm, sizeof(la.ofdm)); 5578 /* ht20 */ 5579 skb_put_data(skb, &la.mcs[0], 8); 5580 /* ht40 */ 5581 skb_put_data(skb, &la.mcs[1], 9); 5582 5583 /* vht */ 5584 for (i = 0; i < 4; i++) { 5585 skb_put_data(skb, &la.mcs[i], sizeof(la.mcs[i])); 5586 skb_put_zero(skb, 2); /* padding */ 5587 } 5588 5589 /* he */ 5590 skb_put_data(skb, &la.ru[0], sizeof(la.ru)); 5591 /* eht */ 5592 skb_put_data(skb, &la.eht[0], sizeof(la.eht)); 5593 5594 /* padding */ 5595 skb_put_zero(skb, MT7996_SKU_PATH_NUM - MT7996_SKU_RATE_NUM); 5596 5597 return mt76_mcu_skb_send_msg(&dev->mt76, skb, 5598 MCU_WM_UNI_CMD(TXPOWER), true); 5599 } 5600 5601 int mt7996_mcu_cp_support(struct mt7996_dev *dev, u8 mode) 5602 { 5603 __le32 cp_mode; 5604 5605 if (mode < mt76_connac_lmac_mapping(IEEE80211_AC_BE) || 5606 mode > mt76_connac_lmac_mapping(IEEE80211_AC_VO)) 5607 return -EINVAL; 5608 5609 if (!mt7996_has_wa(dev)) { 5610 struct { 5611 u8 _rsv[4]; 5612 5613 __le16 tag; 5614 __le16 len; 5615 u8 cp_mode; 5616 u8 rsv[3]; 5617 } __packed req = { 5618 .tag = cpu_to_le16(UNI_CMD_SDO_CP_MODE), 5619 .len = cpu_to_le16(sizeof(req) - 4), 5620 .cp_mode = mode, 5621 }; 5622 5623 return mt76_mcu_send_msg(&dev->mt76, MCU_WA_UNI_CMD(SDO), 5624 &req, sizeof(req), false); 5625 } 5626 5627 cp_mode = cpu_to_le32(mode); 5628 5629 return mt76_mcu_send_msg(&dev->mt76, MCU_WA_EXT_CMD(CP_SUPPORT), 5630 &cp_mode, sizeof(cp_mode), true); 5631 } 5632 5633 int mt7996_mcu_set_dup_wtbl(struct mt7996_dev *dev) 5634 { 5635 #define DUP_WTBL_NUM 80 5636 struct { 5637 u8 _rsv[4]; 5638 5639 __le16 tag; 5640 __le16 len; 5641 __le16 base; 5642 __le16 num; 5643 u8 _rsv2[4]; 5644 } __packed req = { 5645 .tag = cpu_to_le16(UNI_CHIP_CONFIG_DUP_WTBL), 5646 .len = cpu_to_le16(sizeof(req) - 4), 5647 .base = cpu_to_le16(MT7996_WTBL_STA - DUP_WTBL_NUM + 1), 5648 .num = cpu_to_le16(DUP_WTBL_NUM), 5649 }; 5650 5651 return mt76_mcu_send_msg(&dev->mt76, MCU_WM_UNI_CMD(CHIP_CONFIG), &req, 5652 sizeof(req), true); 5653 } 5654