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