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