1 // SPDX-License-Identifier: BSD-3-Clause-Clear 2 /* Copyright (C) 2020 MediaTek Inc. */ 3 4 #if defined(__FreeBSD__) 5 #define LINUXKPI_PARAM_PREFIX mt7921_ 6 #endif 7 8 #include <linux/fs.h> 9 #include <linux/firmware.h> 10 #include "mt7921.h" 11 #include "mcu.h" 12 #include "../mt76_connac2_mac.h" 13 #include "../mt792x_trace.h" 14 15 #define MT_STA_BFER BIT(0) 16 #define MT_STA_BFEE BIT(1) 17 18 static bool mt7921_disable_clc; 19 module_param_named(disable_clc, mt7921_disable_clc, bool, 0644); 20 MODULE_PARM_DESC(disable_clc, "disable CLC support"); 21 22 int mt7921_mcu_parse_response(struct mt76_dev *mdev, int cmd, 23 struct sk_buff *skb, int seq) 24 { 25 int mcu_cmd = FIELD_GET(__MCU_CMD_FIELD_ID, cmd); 26 struct mt76_connac2_mcu_rxd *rxd; 27 int ret = 0; 28 29 if (!skb) { 30 dev_err(mdev->dev, "Message %08x (seq %d) timeout\n", 31 cmd, seq); 32 mt792x_reset(mdev); 33 34 return -ETIMEDOUT; 35 } 36 37 rxd = (struct mt76_connac2_mcu_rxd *)skb->data; 38 if (seq != rxd->seq) 39 return -EAGAIN; 40 41 if (cmd == MCU_CMD(PATCH_SEM_CONTROL) || 42 cmd == MCU_CMD(PATCH_FINISH_REQ)) { 43 skb_pull(skb, sizeof(*rxd) - 4); 44 ret = *skb->data; 45 } else if (cmd == MCU_EXT_CMD(THERMAL_CTRL)) { 46 skb_pull(skb, sizeof(*rxd) + 4); 47 ret = le32_to_cpu(*(__le32 *)skb->data); 48 } else if (cmd == MCU_UNI_CMD(DEV_INFO_UPDATE) || 49 cmd == MCU_UNI_CMD(BSS_INFO_UPDATE) || 50 cmd == MCU_UNI_CMD(STA_REC_UPDATE) || 51 cmd == MCU_UNI_CMD(HIF_CTRL) || 52 cmd == MCU_UNI_CMD(OFFLOAD) || 53 cmd == MCU_UNI_CMD(SUSPEND)) { 54 struct mt76_connac_mcu_uni_event *event; 55 56 skb_pull(skb, sizeof(*rxd)); 57 event = (struct mt76_connac_mcu_uni_event *)skb->data; 58 ret = le32_to_cpu(event->status); 59 /* skip invalid event */ 60 if (mcu_cmd != event->cid) 61 ret = -EAGAIN; 62 } else if (cmd == MCU_CE_QUERY(REG_READ)) { 63 struct mt76_connac_mcu_reg_event *event; 64 65 skb_pull(skb, sizeof(*rxd)); 66 event = (struct mt76_connac_mcu_reg_event *)skb->data; 67 ret = (int)le32_to_cpu(event->val); 68 } else if (cmd == MCU_EXT_CMD(WF_RF_PIN_CTRL)) { 69 struct mt7921_wf_rf_pin_ctrl_event *event; 70 71 skb_pull(skb, sizeof(*rxd)); 72 event = (struct mt7921_wf_rf_pin_ctrl_event *)skb->data; 73 ret = (int)event->result; 74 } else { 75 skb_pull(skb, sizeof(struct mt76_connac2_mcu_rxd)); 76 } 77 78 return ret; 79 } 80 EXPORT_SYMBOL_GPL(mt7921_mcu_parse_response); 81 82 static int mt7921_mcu_read_eeprom(struct mt792x_dev *dev, u32 offset, u8 *val) 83 { 84 struct mt7921_mcu_eeprom_info *res, req = { 85 .addr = cpu_to_le32(round_down(offset, 86 MT7921_EEPROM_BLOCK_SIZE)), 87 }; 88 struct sk_buff *skb; 89 int ret; 90 91 ret = mt76_mcu_send_and_get_msg(&dev->mt76, MCU_EXT_QUERY(EFUSE_ACCESS), 92 &req, sizeof(req), true, &skb); 93 if (ret) 94 return ret; 95 96 res = (struct mt7921_mcu_eeprom_info *)skb->data; 97 *val = res->data[offset % MT7921_EEPROM_BLOCK_SIZE]; 98 dev_kfree_skb(skb); 99 100 return 0; 101 } 102 103 #ifdef CONFIG_PM 104 105 static int 106 mt7921_mcu_set_ipv6_ns_filter(struct mt76_dev *dev, 107 struct ieee80211_vif *vif, bool suspend) 108 { 109 struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv; 110 struct { 111 struct { 112 u8 bss_idx; 113 u8 pad[3]; 114 } __packed hdr; 115 struct mt76_connac_arpns_tlv arpns; 116 } req = { 117 .hdr = { 118 .bss_idx = mvif->bss_conf.mt76.idx, 119 }, 120 .arpns = { 121 .tag = cpu_to_le16(UNI_OFFLOAD_OFFLOAD_ND), 122 .len = cpu_to_le16(sizeof(struct mt76_connac_arpns_tlv)), 123 .mode = suspend, 124 }, 125 }; 126 127 return mt76_mcu_send_msg(dev, MCU_UNI_CMD_OFFLOAD, &req, sizeof(req), 128 true); 129 } 130 131 void mt7921_mcu_set_suspend_iter(void *priv, u8 *mac, struct ieee80211_vif *vif) 132 { 133 if (IS_ENABLED(CONFIG_IPV6)) { 134 struct mt76_phy *phy = priv; 135 136 mt7921_mcu_set_ipv6_ns_filter(phy->dev, vif, 137 !test_bit(MT76_STATE_RUNNING, 138 &phy->state)); 139 } 140 141 mt76_connac_mcu_set_suspend_iter(priv, mac, vif); 142 } 143 144 #endif /* CONFIG_PM */ 145 146 static void 147 mt7921_mcu_uni_roc_event(struct mt792x_dev *dev, struct sk_buff *skb) 148 { 149 struct mt7921_roc_grant_tlv *grant; 150 struct mt76_connac2_mcu_rxd *rxd; 151 int duration; 152 153 rxd = (struct mt76_connac2_mcu_rxd *)skb->data; 154 grant = (struct mt7921_roc_grant_tlv *)(rxd->tlv + 4); 155 156 /* should never happen */ 157 WARN_ON_ONCE((le16_to_cpu(grant->tag) != UNI_EVENT_ROC_GRANT)); 158 159 if (grant->reqtype == MT7921_ROC_REQ_ROC) 160 ieee80211_ready_on_channel(dev->mt76.phy.hw); 161 162 dev->phy.roc_grant = true; 163 wake_up(&dev->phy.roc_wait); 164 duration = le32_to_cpu(grant->max_interval); 165 mod_timer(&dev->phy.roc_timer, 166 jiffies + msecs_to_jiffies(duration)); 167 } 168 169 static void 170 mt7921_mcu_scan_event(struct mt792x_dev *dev, struct sk_buff *skb) 171 { 172 struct mt76_phy *mphy = &dev->mt76.phy; 173 struct mt792x_phy *phy = mphy->priv; 174 175 spin_lock_bh(&dev->mt76.lock); 176 __skb_queue_tail(&phy->scan_event_list, skb); 177 spin_unlock_bh(&dev->mt76.lock); 178 179 ieee80211_queue_delayed_work(mphy->hw, &phy->scan_work, 180 MT792x_HW_SCAN_TIMEOUT); 181 } 182 183 static void 184 mt7921_mcu_connection_loss_iter(void *priv, u8 *mac, 185 struct ieee80211_vif *vif) 186 { 187 struct mt76_vif_link *mvif = (struct mt76_vif_link *)vif->drv_priv; 188 struct mt76_connac_beacon_loss_event *event = priv; 189 190 if (mvif->idx != event->bss_idx) 191 return; 192 193 if (!(vif->driver_flags & IEEE80211_VIF_BEACON_FILTER) || 194 vif->type != NL80211_IFTYPE_STATION) 195 return; 196 197 ieee80211_connection_loss(vif); 198 } 199 200 static void 201 mt7921_mcu_connection_loss_event(struct mt792x_dev *dev, struct sk_buff *skb) 202 { 203 struct mt76_connac_beacon_loss_event *event; 204 struct mt76_phy *mphy = &dev->mt76.phy; 205 206 skb_pull(skb, sizeof(struct mt76_connac2_mcu_rxd)); 207 event = (struct mt76_connac_beacon_loss_event *)skb->data; 208 209 ieee80211_iterate_active_interfaces_atomic(mphy->hw, 210 IEEE80211_IFACE_ITER_RESUME_ALL, 211 mt7921_mcu_connection_loss_iter, event); 212 } 213 214 static void 215 mt7921_mcu_debug_msg_event(struct mt792x_dev *dev, struct sk_buff *skb) 216 { 217 struct mt7921_debug_msg { 218 __le16 id; 219 u8 type; 220 u8 flag; 221 __le32 value; 222 __le16 len; 223 u8 content[512]; 224 } __packed * msg; 225 226 skb_pull(skb, sizeof(struct mt76_connac2_mcu_rxd)); 227 msg = (struct mt7921_debug_msg *)skb->data; 228 229 if (msg->type == 3) { /* fw log */ 230 u16 len = min_t(u16, le16_to_cpu(msg->len), 512); 231 int i; 232 233 for (i = 0 ; i < len; i++) { 234 if (!msg->content[i]) 235 msg->content[i] = ' '; 236 } 237 wiphy_info(mt76_hw(dev)->wiphy, "%.*s", len, msg->content); 238 } 239 } 240 241 static void 242 mt7921_mcu_low_power_event(struct mt792x_dev *dev, struct sk_buff *skb) 243 { 244 struct mt7921_mcu_lp_event { 245 u8 state; 246 u8 reserved[3]; 247 } __packed * event; 248 249 skb_pull(skb, sizeof(struct mt76_connac2_mcu_rxd)); 250 event = (struct mt7921_mcu_lp_event *)skb->data; 251 252 trace_lp_event(dev, event->state); 253 } 254 255 static void 256 mt7921_mcu_tx_done_event(struct mt792x_dev *dev, struct sk_buff *skb) 257 { 258 struct mt7921_mcu_tx_done_event *event; 259 260 skb_pull(skb, sizeof(struct mt76_connac2_mcu_rxd)); 261 event = (struct mt7921_mcu_tx_done_event *)skb->data; 262 263 mt7921_mac_add_txs(dev, event->txs); 264 } 265 266 static void 267 mt7921_mcu_rssi_monitor_iter(void *priv, u8 *mac, 268 struct ieee80211_vif *vif) 269 { 270 struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv; 271 struct mt76_connac_rssi_notify_event *event = priv; 272 enum nl80211_cqm_rssi_threshold_event nl_event; 273 s32 rssi = le32_to_cpu(event->rssi[mvif->bss_conf.mt76.idx]); 274 275 if (!rssi) 276 return; 277 278 if (!(vif->driver_flags & IEEE80211_VIF_SUPPORTS_CQM_RSSI)) 279 return; 280 281 if (rssi > vif->bss_conf.cqm_rssi_thold) 282 nl_event = NL80211_CQM_RSSI_THRESHOLD_EVENT_HIGH; 283 else 284 nl_event = NL80211_CQM_RSSI_THRESHOLD_EVENT_LOW; 285 286 ieee80211_cqm_rssi_notify(vif, nl_event, rssi, GFP_KERNEL); 287 } 288 289 static void 290 mt7921_mcu_rssi_monitor_event(struct mt792x_dev *dev, struct sk_buff *skb) 291 { 292 struct mt76_connac_rssi_notify_event *event; 293 294 skb_pull(skb, sizeof(struct mt76_connac2_mcu_rxd)); 295 event = (struct mt76_connac_rssi_notify_event *)skb->data; 296 297 ieee80211_iterate_active_interfaces_atomic(mt76_hw(dev), 298 IEEE80211_IFACE_ITER_RESUME_ALL, 299 mt7921_mcu_rssi_monitor_iter, event); 300 } 301 302 static void 303 mt7921_mcu_rx_unsolicited_event(struct mt792x_dev *dev, struct sk_buff *skb) 304 { 305 struct mt76_connac2_mcu_rxd *rxd; 306 307 rxd = (struct mt76_connac2_mcu_rxd *)skb->data; 308 switch (rxd->eid) { 309 case MCU_EVENT_BSS_BEACON_LOSS: 310 mt7921_mcu_connection_loss_event(dev, skb); 311 break; 312 case MCU_EVENT_SCHED_SCAN_DONE: 313 case MCU_EVENT_SCAN_DONE: 314 mt7921_mcu_scan_event(dev, skb); 315 return; 316 case MCU_EVENT_DBG_MSG: 317 mt7921_mcu_debug_msg_event(dev, skb); 318 break; 319 case MCU_EVENT_COREDUMP: 320 dev->fw_assert = true; 321 mt76_connac_mcu_coredump_event(&dev->mt76, skb, 322 &dev->coredump); 323 return; 324 case MCU_EVENT_LP_INFO: 325 mt7921_mcu_low_power_event(dev, skb); 326 break; 327 case MCU_EVENT_TX_DONE: 328 mt7921_mcu_tx_done_event(dev, skb); 329 break; 330 case MCU_EVENT_RSSI_NOTIFY: 331 mt7921_mcu_rssi_monitor_event(dev, skb); 332 break; 333 default: 334 break; 335 } 336 dev_kfree_skb(skb); 337 } 338 339 static void 340 mt7921_mcu_uni_rx_unsolicited_event(struct mt792x_dev *dev, 341 struct sk_buff *skb) 342 { 343 struct mt76_connac2_mcu_rxd *rxd; 344 345 rxd = (struct mt76_connac2_mcu_rxd *)skb->data; 346 347 switch (rxd->eid) { 348 case MCU_UNI_EVENT_ROC: 349 mt7921_mcu_uni_roc_event(dev, skb); 350 break; 351 default: 352 break; 353 } 354 dev_kfree_skb(skb); 355 } 356 357 void mt7921_mcu_rx_event(struct mt792x_dev *dev, struct sk_buff *skb) 358 { 359 struct mt76_connac2_mcu_rxd *rxd; 360 361 if (skb_linearize(skb)) 362 return; 363 364 rxd = (struct mt76_connac2_mcu_rxd *)skb->data; 365 366 if (rxd->option & MCU_UNI_CMD_UNSOLICITED_EVENT) { 367 mt7921_mcu_uni_rx_unsolicited_event(dev, skb); 368 return; 369 } 370 371 if (rxd->eid == 0x6) { 372 mt76_mcu_rx_event(&dev->mt76, skb); 373 return; 374 } 375 376 if (rxd->ext_eid == MCU_EXT_EVENT_RATE_REPORT || 377 rxd->eid == MCU_EVENT_BSS_BEACON_LOSS || 378 rxd->eid == MCU_EVENT_SCHED_SCAN_DONE || 379 rxd->eid == MCU_EVENT_RSSI_NOTIFY || 380 rxd->eid == MCU_EVENT_SCAN_DONE || 381 rxd->eid == MCU_EVENT_TX_DONE || 382 rxd->eid == MCU_EVENT_DBG_MSG || 383 rxd->eid == MCU_EVENT_COREDUMP || 384 rxd->eid == MCU_EVENT_LP_INFO || 385 !rxd->seq) 386 mt7921_mcu_rx_unsolicited_event(dev, skb); 387 else 388 mt76_mcu_rx_event(&dev->mt76, skb); 389 } 390 391 /** starec & wtbl **/ 392 int mt7921_mcu_uni_tx_ba(struct mt792x_dev *dev, 393 struct ieee80211_ampdu_params *params, 394 bool enable) 395 { 396 struct mt792x_sta *msta = (struct mt792x_sta *)params->sta->drv_priv; 397 398 if (enable && !params->amsdu) 399 msta->deflink.wcid.amsdu = false; 400 401 return mt76_connac_mcu_sta_ba(&dev->mt76, &msta->vif->bss_conf.mt76, params, 402 MCU_UNI_CMD(STA_REC_UPDATE), 403 enable, true); 404 } 405 406 int mt7921_mcu_uni_rx_ba(struct mt792x_dev *dev, 407 struct ieee80211_ampdu_params *params, 408 bool enable) 409 { 410 struct mt792x_sta *msta = (struct mt792x_sta *)params->sta->drv_priv; 411 412 return mt76_connac_mcu_sta_ba(&dev->mt76, &msta->vif->bss_conf.mt76, params, 413 MCU_UNI_CMD(STA_REC_UPDATE), 414 enable, false); 415 } 416 417 static int mt7921_load_clc(struct mt792x_dev *dev, const char *fw_name) 418 { 419 const struct mt76_connac2_fw_trailer *hdr; 420 const struct mt76_connac2_fw_region *region; 421 const struct mt7921_clc *clc; 422 struct mt76_dev *mdev = &dev->mt76; 423 struct mt792x_phy *phy = &dev->phy; 424 const struct firmware *fw; 425 int ret, i, len, offset = 0; 426 #if defined(__linux__) 427 u8 *clc_base = NULL, hw_encap = 0; 428 #elif defined(__FreeBSD__) 429 const u8 *clc_base = NULL; 430 u8 hw_encap = 0; 431 #endif 432 433 dev->phy.clc_chan_conf = 0xff; 434 if (mt7921_disable_clc || 435 mt76_is_usb(&dev->mt76)) 436 return 0; 437 438 if (mt76_is_mmio(&dev->mt76)) { 439 ret = mt7921_mcu_read_eeprom(dev, MT_EE_HW_TYPE, &hw_encap); 440 if (ret) 441 return ret; 442 hw_encap = u8_get_bits(hw_encap, MT_EE_HW_TYPE_ENCAP); 443 } 444 445 ret = request_firmware(&fw, fw_name, mdev->dev); 446 if (ret) 447 return ret; 448 449 if (!fw || !fw->data || fw->size < sizeof(*hdr)) { 450 dev_err(mdev->dev, "Invalid firmware\n"); 451 ret = -EINVAL; 452 goto out; 453 } 454 455 hdr = (const void *)(fw->data + fw->size - sizeof(*hdr)); 456 for (i = 0; i < hdr->n_region; i++) { 457 region = (const void *)((const u8 *)hdr - 458 (hdr->n_region - i) * sizeof(*region)); 459 len = le32_to_cpu(region->len); 460 461 /* check if we have valid buffer size */ 462 if (offset + len > fw->size) { 463 dev_err(mdev->dev, "Invalid firmware region\n"); 464 ret = -EINVAL; 465 goto out; 466 } 467 468 if ((region->feature_set & FW_FEATURE_NON_DL) && 469 region->type == FW_TYPE_CLC) { 470 #if defined(__linux__) 471 clc_base = (u8 *)(fw->data + offset); 472 #elif defined(__FreeBSD__) 473 clc_base = (const u8 *)(fw->data + offset); 474 #endif 475 break; 476 } 477 offset += len; 478 } 479 480 if (!clc_base) 481 goto out; 482 483 for (offset = 0; offset < len; offset += le32_to_cpu(clc->len)) { 484 clc = (const struct mt7921_clc *)(clc_base + offset); 485 486 /* do not init buf again if chip reset triggered */ 487 if (phy->clc[clc->idx]) 488 continue; 489 490 /* header content sanity */ 491 if (clc->idx == MT7921_CLC_POWER && 492 u8_get_bits(clc->type, MT_EE_HW_TYPE_ENCAP) != hw_encap) 493 continue; 494 495 phy->clc[clc->idx] = devm_kmemdup(mdev->dev, clc, 496 le32_to_cpu(clc->len), 497 GFP_KERNEL); 498 499 if (!phy->clc[clc->idx]) { 500 ret = -ENOMEM; 501 goto out; 502 } 503 } 504 ret = mt7921_mcu_set_clc(dev, "00", ENVIRON_INDOOR); 505 out: 506 release_firmware(fw); 507 508 return ret; 509 } 510 511 static void mt7921_mcu_parse_tx_resource(struct mt76_dev *dev, 512 struct sk_buff *skb) 513 { 514 struct mt76_sdio *sdio = &dev->sdio; 515 struct mt7921_tx_resource { 516 __le32 version; 517 __le32 pse_data_quota; 518 __le32 pse_mcu_quota; 519 __le32 ple_data_quota; 520 __le32 ple_mcu_quota; 521 __le16 pse_page_size; 522 __le16 ple_page_size; 523 u8 pp_padding; 524 u8 pad[3]; 525 } __packed * tx_res; 526 527 tx_res = (struct mt7921_tx_resource *)skb->data; 528 sdio->sched.pse_data_quota = le32_to_cpu(tx_res->pse_data_quota); 529 sdio->pse_mcu_quota_max = le32_to_cpu(tx_res->pse_mcu_quota); 530 /* The mcu quota usage of this function itself must be taken into consideration */ 531 sdio->sched.pse_mcu_quota = 532 sdio->sched.pse_mcu_quota ? sdio->pse_mcu_quota_max : sdio->pse_mcu_quota_max - 1; 533 sdio->sched.ple_data_quota = le32_to_cpu(tx_res->ple_data_quota); 534 sdio->sched.pse_page_size = le16_to_cpu(tx_res->pse_page_size); 535 sdio->sched.deficit = tx_res->pp_padding; 536 } 537 538 static void mt7921_mcu_parse_phy_cap(struct mt76_dev *dev, 539 struct sk_buff *skb) 540 { 541 struct mt7921_phy_cap { 542 u8 ht; 543 u8 vht; 544 u8 _5g; 545 u8 max_bw; 546 u8 nss; 547 u8 dbdc; 548 u8 tx_ldpc; 549 u8 rx_ldpc; 550 u8 tx_stbc; 551 u8 rx_stbc; 552 u8 hw_path; 553 u8 he; 554 } __packed * cap; 555 556 enum { 557 WF0_24G, 558 WF0_5G 559 }; 560 561 cap = (struct mt7921_phy_cap *)skb->data; 562 563 dev->phy.antenna_mask = BIT(cap->nss) - 1; 564 dev->phy.chainmask = dev->phy.antenna_mask; 565 dev->phy.cap.has_2ghz = cap->hw_path & BIT(WF0_24G); 566 dev->phy.cap.has_5ghz = cap->hw_path & BIT(WF0_5G); 567 } 568 569 static int mt7921_mcu_get_nic_capability(struct mt792x_phy *mphy) 570 { 571 struct mt76_connac_cap_hdr { 572 __le16 n_element; 573 u8 rsv[2]; 574 } __packed * hdr; 575 struct sk_buff *skb; 576 struct mt76_phy *phy = mphy->mt76; 577 int ret, i; 578 579 ret = mt76_mcu_send_and_get_msg(phy->dev, MCU_CE_CMD(GET_NIC_CAPAB), 580 NULL, 0, true, &skb); 581 if (ret) 582 return ret; 583 584 hdr = (struct mt76_connac_cap_hdr *)skb->data; 585 if (skb->len < sizeof(*hdr)) { 586 ret = -EINVAL; 587 goto out; 588 } 589 590 skb_pull(skb, sizeof(*hdr)); 591 592 for (i = 0; i < le16_to_cpu(hdr->n_element); i++) { 593 struct tlv_hdr { 594 __le32 type; 595 __le32 len; 596 } __packed * tlv = (struct tlv_hdr *)skb->data; 597 int len; 598 599 if (skb->len < sizeof(*tlv)) 600 break; 601 602 skb_pull(skb, sizeof(*tlv)); 603 604 len = le32_to_cpu(tlv->len); 605 if (skb->len < len) 606 break; 607 608 switch (le32_to_cpu(tlv->type)) { 609 case MT_NIC_CAP_6G: 610 phy->cap.has_6ghz = skb->data[0]; 611 break; 612 case MT_NIC_CAP_MAC_ADDR: 613 memcpy(phy->macaddr, (void *)skb->data, ETH_ALEN); 614 break; 615 case MT_NIC_CAP_PHY: 616 mt7921_mcu_parse_phy_cap(phy->dev, skb); 617 break; 618 case MT_NIC_CAP_TX_RESOURCE: 619 if (mt76_is_sdio(phy->dev)) 620 mt7921_mcu_parse_tx_resource(phy->dev, 621 skb); 622 break; 623 case MT_NIC_CAP_CHIP_CAP: 624 memcpy(&mphy->chip_cap, (void *)skb->data, sizeof(u64)); 625 break; 626 default: 627 break; 628 } 629 skb_pull(skb, len); 630 } 631 out: 632 dev_kfree_skb(skb); 633 634 return ret; 635 } 636 637 int mt7921_mcu_fw_log_2_host(struct mt792x_dev *dev, u8 ctrl) 638 { 639 struct { 640 u8 ctrl_val; 641 u8 pad[3]; 642 } data = { 643 .ctrl_val = ctrl 644 }; 645 646 return mt76_mcu_send_msg(&dev->mt76, MCU_CE_CMD(FWLOG_2_HOST), 647 &data, sizeof(data), false); 648 } 649 650 int mt7921_run_firmware(struct mt792x_dev *dev) 651 { 652 int err; 653 654 err = mt792x_load_firmware(dev); 655 if (err) 656 return err; 657 658 err = mt7921_mcu_get_nic_capability(&dev->phy); 659 if (err) 660 return err; 661 662 err = mt7921_load_clc(dev, mt792x_ram_name(dev)); 663 if (err) 664 return err; 665 set_bit(MT76_STATE_MCU_RUNNING, &dev->mphy.state); 666 667 return mt7921_mcu_fw_log_2_host(dev, 1); 668 } 669 EXPORT_SYMBOL_GPL(mt7921_run_firmware); 670 671 int mt7921_mcu_radio_led_ctrl(struct mt792x_dev *dev, u8 value) 672 { 673 struct { 674 u8 ctrlid; 675 u8 rsv[3]; 676 } __packed req = { 677 .ctrlid = value, 678 }; 679 680 return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD(ID_RADIO_ON_OFF_CTRL), 681 &req, sizeof(req), false); 682 } 683 EXPORT_SYMBOL_GPL(mt7921_mcu_radio_led_ctrl); 684 685 int mt7921_mcu_set_tx(struct mt792x_dev *dev, struct ieee80211_vif *vif) 686 { 687 struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv; 688 struct edca { 689 __le16 cw_min; 690 __le16 cw_max; 691 __le16 txop; 692 __le16 aifs; 693 u8 guardtime; 694 u8 acm; 695 } __packed; 696 struct mt7921_mcu_tx { 697 struct edca edca[IEEE80211_NUM_ACS]; 698 u8 bss_idx; 699 u8 qos; 700 u8 wmm_idx; 701 u8 pad; 702 } __packed req = { 703 .bss_idx = mvif->bss_conf.mt76.idx, 704 .qos = vif->bss_conf.qos, 705 .wmm_idx = mvif->bss_conf.mt76.wmm_idx, 706 }; 707 struct mu_edca { 708 u8 cw_min; 709 u8 cw_max; 710 u8 aifsn; 711 u8 acm; 712 u8 timer; 713 u8 padding[3]; 714 }; 715 struct mt7921_mcu_mu_tx { 716 u8 ver; 717 u8 pad0; 718 __le16 len; 719 u8 bss_idx; 720 u8 qos; 721 u8 wmm_idx; 722 u8 pad1; 723 struct mu_edca edca[IEEE80211_NUM_ACS]; 724 u8 pad3[32]; 725 } __packed req_mu = { 726 .bss_idx = mvif->bss_conf.mt76.idx, 727 .qos = vif->bss_conf.qos, 728 .wmm_idx = mvif->bss_conf.mt76.wmm_idx, 729 }; 730 static const int to_aci[] = { 1, 0, 2, 3 }; 731 int ac, ret; 732 733 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) { 734 struct ieee80211_tx_queue_params *q = &mvif->bss_conf.queue_params[ac]; 735 struct edca *e = &req.edca[to_aci[ac]]; 736 737 e->aifs = cpu_to_le16(q->aifs); 738 e->txop = cpu_to_le16(q->txop); 739 740 if (q->cw_min) 741 e->cw_min = cpu_to_le16(q->cw_min); 742 else 743 e->cw_min = cpu_to_le16(5); 744 745 if (q->cw_max) 746 e->cw_max = cpu_to_le16(q->cw_max); 747 else 748 e->cw_max = cpu_to_le16(10); 749 } 750 751 ret = mt76_mcu_send_msg(&dev->mt76, MCU_CE_CMD(SET_EDCA_PARMS), &req, 752 sizeof(req), false); 753 if (ret) 754 return ret; 755 756 if (!vif->bss_conf.he_support) 757 return 0; 758 759 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) { 760 struct ieee80211_he_mu_edca_param_ac_rec *q; 761 struct mu_edca *e; 762 763 if (!mvif->bss_conf.queue_params[ac].mu_edca) 764 break; 765 766 q = &mvif->bss_conf.queue_params[ac].mu_edca_param_rec; 767 e = &(req_mu.edca[to_aci[ac]]); 768 769 e->cw_min = q->ecw_min_max & 0xf; 770 e->cw_max = (q->ecw_min_max & 0xf0) >> 4; 771 e->aifsn = q->aifsn; 772 e->timer = q->mu_edca_timer; 773 } 774 775 return mt76_mcu_send_msg(&dev->mt76, MCU_CE_CMD(SET_MU_EDCA_PARMS), 776 &req_mu, sizeof(req_mu), false); 777 } 778 779 int mt7921_mcu_set_roc(struct mt792x_phy *phy, struct mt792x_vif *vif, 780 struct ieee80211_channel *chan, int duration, 781 enum mt7921_roc_req type, u8 token_id) 782 { 783 int center_ch = ieee80211_frequency_to_channel(chan->center_freq); 784 struct mt792x_dev *dev = phy->dev; 785 struct { 786 struct { 787 u8 rsv[4]; 788 } __packed hdr; 789 struct roc_acquire_tlv { 790 __le16 tag; 791 __le16 len; 792 u8 bss_idx; 793 u8 tokenid; 794 u8 control_channel; 795 u8 sco; 796 u8 band; 797 u8 bw; 798 u8 center_chan; 799 u8 center_chan2; 800 u8 bw_from_ap; 801 u8 center_chan_from_ap; 802 u8 center_chan2_from_ap; 803 u8 reqtype; 804 __le32 maxinterval; 805 u8 dbdcband; 806 u8 rsv[3]; 807 } __packed roc; 808 } __packed req = { 809 .roc = { 810 .tag = cpu_to_le16(UNI_ROC_ACQUIRE), 811 .len = cpu_to_le16(sizeof(struct roc_acquire_tlv)), 812 .tokenid = token_id, 813 .reqtype = type, 814 .maxinterval = cpu_to_le32(duration), 815 .bss_idx = vif->bss_conf.mt76.idx, 816 .control_channel = chan->hw_value, 817 .bw = CMD_CBW_20MHZ, 818 .bw_from_ap = CMD_CBW_20MHZ, 819 .center_chan = center_ch, 820 .center_chan_from_ap = center_ch, 821 .dbdcband = 0xff, /* auto */ 822 }, 823 }; 824 825 if (chan->hw_value < center_ch) 826 req.roc.sco = 1; /* SCA */ 827 else if (chan->hw_value > center_ch) 828 req.roc.sco = 3; /* SCB */ 829 830 switch (chan->band) { 831 case NL80211_BAND_6GHZ: 832 req.roc.band = 3; 833 break; 834 case NL80211_BAND_5GHZ: 835 req.roc.band = 2; 836 break; 837 default: 838 req.roc.band = 1; 839 break; 840 } 841 842 return mt76_mcu_send_msg(&dev->mt76, MCU_UNI_CMD(ROC), 843 &req, sizeof(req), false); 844 } 845 846 int mt7921_mcu_abort_roc(struct mt792x_phy *phy, struct mt792x_vif *vif, 847 u8 token_id) 848 { 849 struct mt792x_dev *dev = phy->dev; 850 struct { 851 struct { 852 u8 rsv[4]; 853 } __packed hdr; 854 struct roc_abort_tlv { 855 __le16 tag; 856 __le16 len; 857 u8 bss_idx; 858 u8 tokenid; 859 u8 dbdcband; 860 u8 rsv[5]; 861 } __packed abort; 862 } __packed req = { 863 .abort = { 864 .tag = cpu_to_le16(UNI_ROC_ABORT), 865 .len = cpu_to_le16(sizeof(struct roc_abort_tlv)), 866 .tokenid = token_id, 867 .bss_idx = vif->bss_conf.mt76.idx, 868 .dbdcband = 0xff, /* auto*/ 869 }, 870 }; 871 872 return mt76_mcu_send_msg(&dev->mt76, MCU_UNI_CMD(ROC), 873 &req, sizeof(req), false); 874 } 875 876 int mt7921_mcu_set_chan_info(struct mt792x_phy *phy, int cmd) 877 { 878 struct mt792x_dev *dev = phy->dev; 879 struct cfg80211_chan_def *chandef = &phy->mt76->chandef; 880 int freq1 = chandef->center_freq1; 881 struct { 882 u8 control_ch; 883 u8 center_ch; 884 u8 bw; 885 u8 tx_streams_num; 886 u8 rx_streams; /* mask or num */ 887 u8 switch_reason; 888 u8 band_idx; 889 u8 center_ch2; /* for 80+80 only */ 890 __le16 cac_case; 891 u8 channel_band; 892 u8 rsv0; 893 __le32 outband_freq; 894 u8 txpower_drop; 895 u8 ap_bw; 896 u8 ap_center_ch; 897 u8 rsv1[57]; 898 } __packed req = { 899 .control_ch = chandef->chan->hw_value, 900 .center_ch = ieee80211_frequency_to_channel(freq1), 901 .bw = mt76_connac_chan_bw(chandef), 902 .tx_streams_num = hweight8(phy->mt76->antenna_mask), 903 .rx_streams = phy->mt76->antenna_mask, 904 .band_idx = phy != &dev->phy, 905 }; 906 907 if (chandef->chan->band == NL80211_BAND_6GHZ) 908 req.channel_band = 2; 909 else 910 req.channel_band = chandef->chan->band; 911 912 if (cmd == MCU_EXT_CMD(SET_RX_PATH) || 913 dev->mt76.hw->conf.flags & IEEE80211_CONF_MONITOR) 914 req.switch_reason = CH_SWITCH_NORMAL; 915 else if (phy->mt76->offchannel) 916 req.switch_reason = CH_SWITCH_SCAN_BYPASS_DPD; 917 else if (!cfg80211_reg_can_beacon(dev->mt76.hw->wiphy, chandef, 918 NL80211_IFTYPE_AP)) 919 req.switch_reason = CH_SWITCH_DFS; 920 else 921 req.switch_reason = CH_SWITCH_NORMAL; 922 923 if (cmd == MCU_EXT_CMD(CHANNEL_SWITCH)) 924 req.rx_streams = hweight8(req.rx_streams); 925 926 if (chandef->width == NL80211_CHAN_WIDTH_80P80) { 927 int freq2 = chandef->center_freq2; 928 929 req.center_ch2 = ieee80211_frequency_to_channel(freq2); 930 } 931 932 return mt76_mcu_send_msg(&dev->mt76, cmd, &req, sizeof(req), true); 933 } 934 935 int mt7921_mcu_set_eeprom(struct mt792x_dev *dev) 936 { 937 struct req_hdr { 938 u8 buffer_mode; 939 u8 format; 940 __le16 len; 941 } __packed req = { 942 .buffer_mode = EE_MODE_EFUSE, 943 .format = EE_FORMAT_WHOLE, 944 }; 945 946 return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD(EFUSE_BUFFER_MODE), 947 &req, sizeof(req), true); 948 } 949 EXPORT_SYMBOL_GPL(mt7921_mcu_set_eeprom); 950 951 int mt7921_mcu_uni_bss_ps(struct mt792x_dev *dev, struct ieee80211_vif *vif) 952 { 953 struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv; 954 struct { 955 struct { 956 u8 bss_idx; 957 u8 pad[3]; 958 } __packed hdr; 959 struct ps_tlv { 960 __le16 tag; 961 __le16 len; 962 u8 ps_state; /* 0: device awake 963 * 1: static power save 964 * 2: dynamic power saving 965 * 3: enter TWT power saving 966 * 4: leave TWT power saving 967 */ 968 u8 pad[3]; 969 } __packed ps; 970 } __packed ps_req = { 971 .hdr = { 972 .bss_idx = mvif->bss_conf.mt76.idx, 973 }, 974 .ps = { 975 .tag = cpu_to_le16(UNI_BSS_INFO_PS), 976 .len = cpu_to_le16(sizeof(struct ps_tlv)), 977 .ps_state = vif->cfg.ps ? 2 : 0, 978 }, 979 }; 980 981 if (vif->type != NL80211_IFTYPE_STATION) 982 return -EOPNOTSUPP; 983 984 return mt76_mcu_send_msg(&dev->mt76, MCU_UNI_CMD(BSS_INFO_UPDATE), 985 &ps_req, sizeof(ps_req), true); 986 } 987 988 static int 989 mt7921_mcu_uni_bss_bcnft(struct mt792x_dev *dev, struct ieee80211_vif *vif, 990 bool enable) 991 { 992 struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv; 993 struct { 994 struct { 995 u8 bss_idx; 996 u8 pad[3]; 997 } __packed hdr; 998 struct bcnft_tlv { 999 __le16 tag; 1000 __le16 len; 1001 __le16 bcn_interval; 1002 u8 dtim_period; 1003 u8 pad; 1004 } __packed bcnft; 1005 } __packed bcnft_req = { 1006 .hdr = { 1007 .bss_idx = mvif->bss_conf.mt76.idx, 1008 }, 1009 .bcnft = { 1010 .tag = cpu_to_le16(UNI_BSS_INFO_BCNFT), 1011 .len = cpu_to_le16(sizeof(struct bcnft_tlv)), 1012 .bcn_interval = cpu_to_le16(vif->bss_conf.beacon_int), 1013 .dtim_period = vif->bss_conf.dtim_period, 1014 }, 1015 }; 1016 1017 if (vif->type != NL80211_IFTYPE_STATION) 1018 return 0; 1019 1020 return mt76_mcu_send_msg(&dev->mt76, MCU_UNI_CMD(BSS_INFO_UPDATE), 1021 &bcnft_req, sizeof(bcnft_req), true); 1022 } 1023 1024 int 1025 mt7921_mcu_set_bss_pm(struct mt792x_dev *dev, struct ieee80211_vif *vif, 1026 bool enable) 1027 { 1028 struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv; 1029 struct { 1030 u8 bss_idx; 1031 u8 dtim_period; 1032 __le16 aid; 1033 __le16 bcn_interval; 1034 __le16 atim_window; 1035 u8 uapsd; 1036 u8 bmc_delivered_ac; 1037 u8 bmc_triggered_ac; 1038 u8 pad; 1039 } req = { 1040 .bss_idx = mvif->bss_conf.mt76.idx, 1041 .aid = cpu_to_le16(vif->cfg.aid), 1042 .dtim_period = vif->bss_conf.dtim_period, 1043 .bcn_interval = cpu_to_le16(vif->bss_conf.beacon_int), 1044 }; 1045 struct { 1046 u8 bss_idx; 1047 u8 pad[3]; 1048 } req_hdr = { 1049 .bss_idx = mvif->bss_conf.mt76.idx, 1050 }; 1051 int err; 1052 1053 err = mt76_mcu_send_msg(&dev->mt76, MCU_CE_CMD(SET_BSS_ABORT), 1054 &req_hdr, sizeof(req_hdr), false); 1055 if (err < 0 || !enable) 1056 return err; 1057 1058 return mt76_mcu_send_msg(&dev->mt76, MCU_CE_CMD(SET_BSS_CONNECTED), 1059 &req, sizeof(req), false); 1060 } 1061 1062 int mt7921_mcu_sta_update(struct mt792x_dev *dev, struct ieee80211_sta *sta, 1063 struct ieee80211_vif *vif, bool enable, 1064 enum mt76_sta_info_state state) 1065 { 1066 struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv; 1067 int rssi = -ewma_rssi_read(&mvif->bss_conf.rssi); 1068 struct mt76_sta_cmd_info info = { 1069 .sta = sta, 1070 .vif = vif, 1071 .enable = enable, 1072 .cmd = MCU_UNI_CMD(STA_REC_UPDATE), 1073 .state = state, 1074 .offload_fw = true, 1075 .rcpi = to_rcpi(rssi), 1076 }; 1077 struct mt792x_sta *msta; 1078 1079 msta = sta ? (struct mt792x_sta *)sta->drv_priv : NULL; 1080 info.wcid = msta ? &msta->deflink.wcid : &mvif->sta.deflink.wcid; 1081 info.newly = msta ? state != MT76_STA_INFO_STATE_ASSOC : true; 1082 1083 return mt76_connac_mcu_sta_cmd(&dev->mphy, &info); 1084 } 1085 1086 int mt7921_mcu_set_beacon_filter(struct mt792x_dev *dev, 1087 struct ieee80211_vif *vif, 1088 bool enable) 1089 { 1090 #define MT7921_FIF_BIT_CLR BIT(1) 1091 #define MT7921_FIF_BIT_SET BIT(0) 1092 int err; 1093 1094 if (enable) { 1095 err = mt7921_mcu_uni_bss_bcnft(dev, vif, true); 1096 if (err) 1097 return err; 1098 1099 err = mt7921_mcu_set_rxfilter(dev, 0, 1100 MT7921_FIF_BIT_SET, 1101 MT_WF_RFCR_DROP_OTHER_BEACON); 1102 if (err) 1103 return err; 1104 1105 return 0; 1106 } 1107 1108 err = mt7921_mcu_set_bss_pm(dev, vif, false); 1109 if (err) 1110 return err; 1111 1112 err = mt7921_mcu_set_rxfilter(dev, 0, 1113 MT7921_FIF_BIT_CLR, 1114 MT_WF_RFCR_DROP_OTHER_BEACON); 1115 if (err) 1116 return err; 1117 1118 return 0; 1119 } 1120 1121 int mt7921_get_txpwr_info(struct mt792x_dev *dev, struct mt7921_txpwr *txpwr) 1122 { 1123 struct mt7921_txpwr_event *event; 1124 struct mt7921_txpwr_req req = { 1125 .dbdc_idx = 0, 1126 }; 1127 struct sk_buff *skb; 1128 int ret; 1129 1130 ret = mt76_mcu_send_and_get_msg(&dev->mt76, MCU_CE_CMD(GET_TXPWR), 1131 &req, sizeof(req), true, &skb); 1132 if (ret) 1133 return ret; 1134 1135 event = (struct mt7921_txpwr_event *)skb->data; 1136 WARN_ON(skb->len != le16_to_cpu(event->len)); 1137 memcpy(txpwr, &event->txpwr, sizeof(event->txpwr)); 1138 1139 dev_kfree_skb(skb); 1140 1141 return 0; 1142 } 1143 1144 int mt7921_mcu_set_sniffer(struct mt792x_dev *dev, struct ieee80211_vif *vif, 1145 bool enable) 1146 { 1147 struct mt76_vif_link *mvif = (struct mt76_vif_link *)vif->drv_priv; 1148 struct { 1149 struct { 1150 u8 band_idx; 1151 u8 pad[3]; 1152 } __packed hdr; 1153 struct sniffer_enable_tlv { 1154 __le16 tag; 1155 __le16 len; 1156 u8 enable; 1157 u8 pad[3]; 1158 } __packed enable; 1159 } req = { 1160 .hdr = { 1161 .band_idx = mvif->band_idx, 1162 }, 1163 .enable = { 1164 .tag = cpu_to_le16(0), 1165 .len = cpu_to_le16(sizeof(struct sniffer_enable_tlv)), 1166 .enable = enable, 1167 }, 1168 }; 1169 1170 return mt76_mcu_send_msg(&dev->mt76, MCU_UNI_CMD(SNIFFER), &req, sizeof(req), 1171 true); 1172 } 1173 1174 int mt7921_mcu_config_sniffer(struct mt792x_vif *vif, 1175 struct ieee80211_chanctx_conf *ctx) 1176 { 1177 struct cfg80211_chan_def *chandef = &ctx->def; 1178 int freq1 = chandef->center_freq1, freq2 = chandef->center_freq2; 1179 static const u8 ch_band[] = { 1180 [NL80211_BAND_2GHZ] = 1, 1181 [NL80211_BAND_5GHZ] = 2, 1182 [NL80211_BAND_6GHZ] = 3, 1183 }; 1184 static const u8 ch_width[] = { 1185 [NL80211_CHAN_WIDTH_20_NOHT] = 0, 1186 [NL80211_CHAN_WIDTH_20] = 0, 1187 [NL80211_CHAN_WIDTH_40] = 0, 1188 [NL80211_CHAN_WIDTH_80] = 1, 1189 [NL80211_CHAN_WIDTH_160] = 2, 1190 [NL80211_CHAN_WIDTH_80P80] = 3, 1191 [NL80211_CHAN_WIDTH_5] = 4, 1192 [NL80211_CHAN_WIDTH_10] = 5, 1193 [NL80211_CHAN_WIDTH_320] = 6, 1194 }; 1195 struct { 1196 struct { 1197 u8 band_idx; 1198 u8 pad[3]; 1199 } __packed hdr; 1200 struct config_tlv { 1201 __le16 tag; 1202 __le16 len; 1203 u16 aid; 1204 u8 ch_band; 1205 u8 bw; 1206 u8 control_ch; 1207 u8 sco; 1208 u8 center_ch; 1209 u8 center_ch2; 1210 u8 drop_err; 1211 u8 pad[3]; 1212 } __packed tlv; 1213 } __packed req = { 1214 .hdr = { 1215 .band_idx = vif->bss_conf.mt76.band_idx, 1216 }, 1217 .tlv = { 1218 .tag = cpu_to_le16(1), 1219 .len = cpu_to_le16(sizeof(req.tlv)), 1220 .control_ch = chandef->chan->hw_value, 1221 .center_ch = ieee80211_frequency_to_channel(freq1), 1222 .drop_err = 1, 1223 }, 1224 }; 1225 if (chandef->chan->band < ARRAY_SIZE(ch_band)) 1226 req.tlv.ch_band = ch_band[chandef->chan->band]; 1227 if (chandef->width < ARRAY_SIZE(ch_width)) 1228 req.tlv.bw = ch_width[chandef->width]; 1229 1230 if (freq2) 1231 req.tlv.center_ch2 = ieee80211_frequency_to_channel(freq2); 1232 1233 if (req.tlv.control_ch < req.tlv.center_ch) 1234 req.tlv.sco = 1; /* SCA */ 1235 else if (req.tlv.control_ch > req.tlv.center_ch) 1236 req.tlv.sco = 3; /* SCB */ 1237 1238 return mt76_mcu_send_msg(vif->phy->mt76->dev, MCU_UNI_CMD(SNIFFER), 1239 &req, sizeof(req), true); 1240 } 1241 1242 int 1243 mt7921_mcu_uni_add_beacon_offload(struct mt792x_dev *dev, 1244 struct ieee80211_hw *hw, 1245 struct ieee80211_vif *vif, 1246 bool enable) 1247 { 1248 struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv; 1249 struct mt76_wcid *wcid = &dev->mt76.global_wcid; 1250 struct ieee80211_mutable_offsets offs; 1251 struct { 1252 struct req_hdr { 1253 u8 bss_idx; 1254 u8 pad[3]; 1255 } __packed hdr; 1256 struct bcn_content_tlv { 1257 __le16 tag; 1258 __le16 len; 1259 __le16 tim_ie_pos; 1260 __le16 csa_ie_pos; 1261 __le16 bcc_ie_pos; 1262 /* 0: disable beacon offload 1263 * 1: enable beacon offload 1264 * 2: update probe respond offload 1265 */ 1266 u8 enable; 1267 /* 0: legacy format (TXD + payload) 1268 * 1: only cap field IE 1269 */ 1270 u8 type; 1271 __le16 pkt_len; 1272 u8 pkt[512]; 1273 } __packed beacon_tlv; 1274 } req = { 1275 .hdr = { 1276 .bss_idx = mvif->bss_conf.mt76.idx, 1277 }, 1278 .beacon_tlv = { 1279 .tag = cpu_to_le16(UNI_BSS_INFO_BCN_CONTENT), 1280 .len = cpu_to_le16(sizeof(struct bcn_content_tlv)), 1281 .enable = enable, 1282 }, 1283 }; 1284 struct sk_buff *skb; 1285 1286 /* support enable/update process only 1287 * disable flow would be handled in bss stop handler automatically 1288 */ 1289 if (!enable) 1290 return -EOPNOTSUPP; 1291 1292 skb = ieee80211_beacon_get_template(mt76_hw(dev), vif, &offs, 0); 1293 if (!skb) 1294 return -EINVAL; 1295 1296 if (skb->len > 512 - MT_TXD_SIZE) { 1297 dev_err(dev->mt76.dev, "beacon size limit exceed\n"); 1298 dev_kfree_skb(skb); 1299 return -EINVAL; 1300 } 1301 1302 mt76_connac2_mac_write_txwi(&dev->mt76, (__le32 *)(req.beacon_tlv.pkt), 1303 skb, wcid, NULL, 0, 0, BSS_CHANGED_BEACON); 1304 memcpy(req.beacon_tlv.pkt + MT_TXD_SIZE, skb->data, skb->len); 1305 req.beacon_tlv.pkt_len = cpu_to_le16(MT_TXD_SIZE + skb->len); 1306 req.beacon_tlv.tim_ie_pos = cpu_to_le16(MT_TXD_SIZE + offs.tim_offset); 1307 1308 if (offs.cntdwn_counter_offs[0]) { 1309 u16 csa_offs; 1310 1311 csa_offs = MT_TXD_SIZE + offs.cntdwn_counter_offs[0] - 4; 1312 req.beacon_tlv.csa_ie_pos = cpu_to_le16(csa_offs); 1313 } 1314 dev_kfree_skb(skb); 1315 1316 return mt76_mcu_send_msg(&dev->mt76, MCU_UNI_CMD(BSS_INFO_UPDATE), 1317 &req, sizeof(req), true); 1318 } 1319 1320 static 1321 int __mt7921_mcu_set_clc(struct mt792x_dev *dev, u8 *alpha2, 1322 enum environment_cap env_cap, 1323 struct mt7921_clc *clc, 1324 u8 idx) 1325 { 1326 #define CLC_CAP_EVT_EN BIT(0) 1327 #define CLC_CAP_DTS_EN BIT(1) 1328 struct sk_buff *skb, *ret_skb = NULL; 1329 struct { 1330 u8 ver; 1331 u8 pad0; 1332 __le16 len; 1333 u8 idx; 1334 u8 env; 1335 u8 acpi_conf; 1336 u8 cap; 1337 u8 alpha2[2]; 1338 u8 type[2]; 1339 u8 env_6g; 1340 u8 mtcl_conf; 1341 u8 rsvd[62]; 1342 } __packed req = { 1343 .ver = 1, 1344 .idx = idx, 1345 .env = env_cap, 1346 .env_6g = dev->phy.power_type, 1347 .acpi_conf = mt792x_acpi_get_flags(&dev->phy), 1348 .mtcl_conf = mt792x_acpi_get_mtcl_conf(&dev->phy, alpha2), 1349 }; 1350 int ret, valid_cnt = 0; 1351 u32 buf_len = 0; 1352 u8 *pos; 1353 1354 if (!clc) 1355 return 0; 1356 1357 if (dev->phy.chip_cap & MT792x_CHIP_CAP_CLC_EVT_EN) 1358 req.cap |= CLC_CAP_EVT_EN; 1359 if (mt76_find_power_limits_node(&dev->mt76)) 1360 req.cap |= CLC_CAP_DTS_EN; 1361 1362 buf_len = le32_to_cpu(clc->len) - sizeof(*clc); 1363 pos = clc->data; 1364 while (buf_len > 16) { 1365 struct mt7921_clc_rule *rule = (struct mt7921_clc_rule *)pos; 1366 u16 len = le16_to_cpu(rule->len); 1367 u16 offset = len + sizeof(*rule); 1368 1369 pos += offset; 1370 buf_len -= offset; 1371 if (rule->alpha2[0] != alpha2[0] || 1372 rule->alpha2[1] != alpha2[1]) 1373 continue; 1374 1375 memcpy(req.alpha2, rule->alpha2, 2); 1376 memcpy(req.type, rule->type, 2); 1377 1378 req.len = cpu_to_le16(sizeof(req) + len); 1379 skb = __mt76_mcu_msg_alloc(&dev->mt76, &req, 1380 le16_to_cpu(req.len), 1381 sizeof(req), GFP_KERNEL); 1382 if (!skb) 1383 return -ENOMEM; 1384 skb_put_data(skb, rule->data, len); 1385 1386 ret = mt76_mcu_skb_send_and_get_msg(&dev->mt76, skb, 1387 MCU_CE_CMD(SET_CLC), 1388 !!(req.cap & CLC_CAP_EVT_EN), 1389 &ret_skb); 1390 if (ret < 0) 1391 return ret; 1392 1393 if (ret_skb) { 1394 struct mt7921_clc_info_tlv *info; 1395 1396 info = (struct mt7921_clc_info_tlv *)(ret_skb->data + 4); 1397 dev->phy.clc_chan_conf = info->chan_conf; 1398 dev_kfree_skb(ret_skb); 1399 } 1400 1401 valid_cnt++; 1402 } 1403 1404 if (!valid_cnt) 1405 return -ENOENT; 1406 1407 return 0; 1408 } 1409 1410 int mt7921_mcu_set_clc(struct mt792x_dev *dev, u8 *alpha2, 1411 enum environment_cap env_cap) 1412 { 1413 struct mt792x_phy *phy = (struct mt792x_phy *)&dev->phy; 1414 int i, ret; 1415 1416 /* submit all clc config */ 1417 for (i = 0; i < ARRAY_SIZE(phy->clc); i++) { 1418 ret = __mt7921_mcu_set_clc(dev, alpha2, env_cap, 1419 phy->clc[i], i); 1420 1421 /* If no country found, set "00" as default */ 1422 if (ret == -ENOENT) 1423 ret = __mt7921_mcu_set_clc(dev, "00", 1424 ENVIRON_INDOOR, 1425 phy->clc[i], i); 1426 if (ret < 0) 1427 return ret; 1428 } 1429 return 0; 1430 } 1431 1432 int mt7921_mcu_get_temperature(struct mt792x_phy *phy) 1433 { 1434 struct mt792x_dev *dev = phy->dev; 1435 struct { 1436 u8 ctrl_id; 1437 u8 action; 1438 u8 band_idx; 1439 u8 rsv[5]; 1440 } req = { 1441 .ctrl_id = THERMAL_SENSOR_TEMP_QUERY, 1442 .band_idx = phy->mt76->band_idx, 1443 }; 1444 1445 return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD(THERMAL_CTRL), &req, 1446 sizeof(req), true); 1447 } 1448 1449 int mt7921_mcu_wf_rf_pin_ctrl(struct mt792x_phy *phy, u8 action) 1450 { 1451 struct mt792x_dev *dev = phy->dev; 1452 struct { 1453 u8 action; 1454 u8 value; 1455 } req = { 1456 .action = action, 1457 .value = 0, 1458 }; 1459 1460 return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD(WF_RF_PIN_CTRL), &req, 1461 sizeof(req), action ? true : false); 1462 } 1463 1464 int mt7921_mcu_set_rxfilter(struct mt792x_dev *dev, u32 fif, 1465 u8 bit_op, u32 bit_map) 1466 { 1467 struct { 1468 u8 rsv[4]; 1469 u8 mode; 1470 u8 rsv2[3]; 1471 __le32 fif; 1472 __le32 bit_map; /* bit_* for bitmap update */ 1473 u8 bit_op; 1474 u8 pad[51]; 1475 } __packed data = { 1476 .mode = fif ? 1 : 2, 1477 .fif = cpu_to_le32(fif), 1478 .bit_map = cpu_to_le32(bit_map), 1479 .bit_op = bit_op, 1480 }; 1481 1482 return mt76_mcu_send_msg(&dev->mt76, MCU_CE_CMD(SET_RX_FILTER), 1483 &data, sizeof(data), false); 1484 } 1485 1486 int mt7921_mcu_set_rssimonitor(struct mt792x_dev *dev, struct ieee80211_vif *vif) 1487 { 1488 struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv; 1489 struct { 1490 u8 enable; 1491 s8 cqm_rssi_high; 1492 s8 cqm_rssi_low; 1493 u8 bss_idx; 1494 u16 duration; 1495 u8 rsv2[2]; 1496 } __packed data = { 1497 .enable = vif->cfg.assoc, 1498 .cqm_rssi_high = vif->bss_conf.cqm_rssi_thold + vif->bss_conf.cqm_rssi_hyst, 1499 .cqm_rssi_low = vif->bss_conf.cqm_rssi_thold - vif->bss_conf.cqm_rssi_hyst, 1500 .bss_idx = mvif->bss_conf.mt76.idx, 1501 }; 1502 1503 return mt76_mcu_send_msg(&dev->mt76, MCU_CE_CMD(RSSI_MONITOR), 1504 &data, sizeof(data), false); 1505 } 1506