FILE
mt76_connac_mcu.c
File preview with syntax highlighting.
linux-6.19.14/drivers/net/wireless/mediatek/mt76/mt76_connac_mcu.c
1// SPDX-License-Identifier: BSD-3-Clause-Clear 2/* Copyright (C) 2020 MediaTek Inc. */ 3 4#include <linux/firmware.h> 5#include "mt76_connac2_mac.h" 6#include "mt76_connac_mcu.h" 7 8int mt76_connac_mcu_start_firmware(struct mt76_dev *dev, u32 addr, u32 option) 9{ 10 struct { 11 __le32 option; 12 __le32 addr; 13 } req = { 14 .option = cpu_to_le32(option), 15 .addr = cpu_to_le32(addr), 16 }; 17 18 return mt76_mcu_send_msg(dev, MCU_CMD(FW_START_REQ), &req, 19 sizeof(req), true); 20} 21EXPORT_SYMBOL_GPL(mt76_connac_mcu_start_firmware); 22 23int mt76_connac_mcu_patch_sem_ctrl(struct mt76_dev *dev, bool get) 24{ 25 u32 op = get ? PATCH_SEM_GET : PATCH_SEM_RELEASE; 26 struct { 27 __le32 op; 28 } req = { 29 .op = cpu_to_le32(op), 30 }; 31 32 return mt76_mcu_send_msg(dev, MCU_CMD(PATCH_SEM_CONTROL), 33 &req, sizeof(req), true); 34} 35EXPORT_SYMBOL_GPL(mt76_connac_mcu_patch_sem_ctrl); 36 37int mt76_connac_mcu_start_patch(struct mt76_dev *dev) 38{ 39 struct { 40 u8 check_crc; 41 u8 reserved[3]; 42 } req = { 43 .check_crc = 0, 44 }; 45 46 return mt76_mcu_send_msg(dev, MCU_CMD(PATCH_FINISH_REQ), 47 &req, sizeof(req), true); 48} 49EXPORT_SYMBOL_GPL(mt76_connac_mcu_start_patch); 50 51#define MCU_PATCH_ADDRESS 0x200000 52 53int mt76_connac_mcu_init_download(struct mt76_dev *dev, u32 addr, u32 len, 54 u32 mode) 55{ 56 struct { 57 __le32 addr; 58 __le32 len; 59 __le32 mode; 60 } req = { 61 .addr = cpu_to_le32(addr), 62 .len = cpu_to_le32(len), 63 .mode = cpu_to_le32(mode), 64 }; 65 int cmd; 66 67 if ((!is_connac_v1(dev) && addr == MCU_PATCH_ADDRESS) || 68 (is_mt7921(dev) && addr == 0x900000) || 69 (is_mt7925(dev) && (addr == 0x900000 || addr == 0xe0002800)) || 70 (is_mt799x(dev) && addr == 0x900000)) 71 cmd = MCU_CMD(PATCH_START_REQ); 72 else 73 cmd = MCU_CMD(TARGET_ADDRESS_LEN_REQ); 74 75 return mt76_mcu_send_msg(dev, cmd, &req, sizeof(req), true); 76} 77EXPORT_SYMBOL_GPL(mt76_connac_mcu_init_download); 78 79int mt76_connac_mcu_set_channel_domain(struct mt76_phy *phy) 80{ 81 int len, i, n_max_channels, n_2ch = 0, n_5ch = 0, n_6ch = 0; 82 struct mt76_connac_mcu_channel_domain { 83 u8 alpha2[4]; /* regulatory_request.alpha2 */ 84 u8 bw_2g; /* BW_20_40M 0 85 * BW_20M 1 86 * BW_20_40_80M 2 87 * BW_20_40_80_160M 3 88 * BW_20_40_80_8080M 4 89 */ 90 u8 bw_5g; 91 u8 bw_6g; 92 u8 pad; 93 u8 n_2ch; 94 u8 n_5ch; 95 u8 n_6ch; 96 u8 pad2; 97 } __packed hdr = { 98 .bw_2g = 0, 99 .bw_5g = 3, /* BW_20_40_80_160M */ 100 .bw_6g = 3, 101 }; 102 struct mt76_connac_mcu_chan { 103 __le16 hw_value; 104 __le16 pad; 105 __le32 flags; 106 } __packed channel; 107 struct mt76_dev *dev = phy->dev; 108 struct ieee80211_channel *chan; 109 struct sk_buff *skb; 110 111 n_max_channels = phy->sband_2g.sband.n_channels + 112 phy->sband_5g.sband.n_channels + 113 phy->sband_6g.sband.n_channels; 114 len = sizeof(hdr) + n_max_channels * sizeof(channel); 115 116 skb = mt76_mcu_msg_alloc(dev, NULL, len); 117 if (!skb) 118 return -ENOMEM; 119 120 skb_reserve(skb, sizeof(hdr)); 121 122 for (i = 0; i < phy->sband_2g.sband.n_channels; i++) { 123 chan = &phy->sband_2g.sband.channels[i]; 124 if (chan->flags & IEEE80211_CHAN_DISABLED) 125 continue; 126 127 channel.hw_value = cpu_to_le16(chan->hw_value); 128 channel.flags = cpu_to_le32(chan->flags); 129 channel.pad = 0; 130 131 skb_put_data(skb, &channel, sizeof(channel)); 132 n_2ch++; 133 } 134 for (i = 0; i < phy->sband_5g.sband.n_channels; i++) { 135 chan = &phy->sband_5g.sband.channels[i]; 136 if (chan->flags & IEEE80211_CHAN_DISABLED) 137 continue; 138 139 channel.hw_value = cpu_to_le16(chan->hw_value); 140 channel.flags = cpu_to_le32(chan->flags); 141 channel.pad = 0; 142 143 skb_put_data(skb, &channel, sizeof(channel)); 144 n_5ch++; 145 } 146 for (i = 0; i < phy->sband_6g.sband.n_channels; i++) { 147 chan = &phy->sband_6g.sband.channels[i]; 148 if (chan->flags & IEEE80211_CHAN_DISABLED) 149 continue; 150 151 channel.hw_value = cpu_to_le16(chan->hw_value); 152 channel.flags = cpu_to_le32(chan->flags); 153 channel.pad = 0; 154 155 skb_put_data(skb, &channel, sizeof(channel)); 156 n_6ch++; 157 } 158 159 BUILD_BUG_ON(sizeof(dev->alpha2) > sizeof(hdr.alpha2)); 160 memcpy(hdr.alpha2, dev->alpha2, sizeof(dev->alpha2)); 161 hdr.n_2ch = n_2ch; 162 hdr.n_5ch = n_5ch; 163 hdr.n_6ch = n_6ch; 164 165 memcpy(__skb_push(skb, sizeof(hdr)), &hdr, sizeof(hdr)); 166 167 return mt76_mcu_skb_send_msg(dev, skb, MCU_CE_CMD(SET_CHAN_DOMAIN), 168 false); 169} 170EXPORT_SYMBOL_GPL(mt76_connac_mcu_set_channel_domain); 171 172int mt76_connac_mcu_set_mac_enable(struct mt76_dev *dev, int band, bool enable, 173 bool hdr_trans) 174{ 175 struct { 176 u8 enable; 177 u8 band; 178 u8 rsv[2]; 179 } __packed req_mac = { 180 .enable = enable, 181 .band = band, 182 }; 183 184 return mt76_mcu_send_msg(dev, MCU_EXT_CMD(MAC_INIT_CTRL), &req_mac, 185 sizeof(req_mac), true); 186} 187EXPORT_SYMBOL_GPL(mt76_connac_mcu_set_mac_enable); 188 189int mt76_connac_mcu_set_vif_ps(struct mt76_dev *dev, struct ieee80211_vif *vif) 190{ 191 struct mt76_vif_link *mvif = (struct mt76_vif_link *)vif->drv_priv; 192 struct { 193 u8 bss_idx; 194 u8 ps_state; /* 0: device awake 195 * 1: static power save 196 * 2: dynamic power saving 197 */ 198 } req = { 199 .bss_idx = mvif->idx, 200 .ps_state = vif->cfg.ps ? 2 : 0, 201 }; 202 203 if (vif->type != NL80211_IFTYPE_STATION) 204 return -EOPNOTSUPP; 205 206 return mt76_mcu_send_msg(dev, MCU_CE_CMD(SET_PS_PROFILE), 207 &req, sizeof(req), false); 208} 209EXPORT_SYMBOL_GPL(mt76_connac_mcu_set_vif_ps); 210 211int mt76_connac_mcu_set_rts_thresh(struct mt76_dev *dev, u32 val, u8 band) 212{ 213 struct { 214 u8 prot_idx; 215 u8 band; 216 u8 rsv[2]; 217 __le32 len_thresh; 218 __le32 pkt_thresh; 219 } __packed req = { 220 .prot_idx = 1, 221 .band = band, 222 .len_thresh = cpu_to_le32(val), 223 .pkt_thresh = cpu_to_le32(0x2), 224 }; 225 226 return mt76_mcu_send_msg(dev, MCU_EXT_CMD(PROTECT_CTRL), &req, 227 sizeof(req), true); 228} 229EXPORT_SYMBOL_GPL(mt76_connac_mcu_set_rts_thresh); 230 231void mt76_connac_mcu_beacon_loss_iter(void *priv, u8 *mac, 232 struct ieee80211_vif *vif) 233{ 234 struct mt76_vif_link *mvif = (struct mt76_vif_link *)vif->drv_priv; 235 struct mt76_connac_beacon_loss_event *event = priv; 236 237 if (mvif->idx != event->bss_idx) 238 return; 239 240 if (!(vif->driver_flags & IEEE80211_VIF_BEACON_FILTER)) 241 return; 242 243 ieee80211_beacon_loss(vif); 244} 245EXPORT_SYMBOL_GPL(mt76_connac_mcu_beacon_loss_iter); 246 247struct tlv * 248mt76_connac_mcu_add_nested_tlv(struct sk_buff *skb, int tag, int len, 249 void *sta_ntlv, void *sta_wtbl) 250{ 251 struct sta_ntlv_hdr *ntlv_hdr = sta_ntlv; 252 struct tlv *sta_hdr = sta_wtbl; 253 struct tlv *ptlv, tlv = { 254 .tag = cpu_to_le16(tag), 255 .len = cpu_to_le16(len), 256 }; 257 u16 ntlv; 258 259 ptlv = skb_put_zero(skb, len); 260 memcpy(ptlv, &tlv, sizeof(tlv)); 261 262 ntlv = le16_to_cpu(ntlv_hdr->tlv_num); 263 ntlv_hdr->tlv_num = cpu_to_le16(ntlv + 1); 264 265 if (sta_hdr) { 266 len += le16_to_cpu(sta_hdr->len); 267 sta_hdr->len = cpu_to_le16(len); 268 } 269 270 return ptlv; 271} 272EXPORT_SYMBOL_GPL(mt76_connac_mcu_add_nested_tlv); 273 274struct sk_buff * 275__mt76_connac_mcu_alloc_sta_req(struct mt76_dev *dev, struct mt76_vif_link *mvif, 276 struct mt76_wcid *wcid, int len) 277{ 278 struct sta_req_hdr hdr = { 279 .bss_idx = mvif->idx, 280 .muar_idx = wcid ? mvif->omac_idx : 0, 281 .is_tlv_append = 1, 282 }; 283 struct sk_buff *skb; 284 285 if (wcid && !wcid->sta && !wcid->sta_disabled) 286 hdr.muar_idx = 0xe; 287 288 mt76_connac_mcu_get_wlan_idx(dev, wcid, &hdr.wlan_idx_lo, 289 &hdr.wlan_idx_hi); 290 skb = __mt76_mcu_msg_alloc(dev, NULL, len, len, GFP_ATOMIC); 291 if (!skb) 292 return ERR_PTR(-ENOMEM); 293 294 skb_put_data(skb, &hdr, sizeof(hdr)); 295 296 return skb; 297} 298EXPORT_SYMBOL_GPL(__mt76_connac_mcu_alloc_sta_req); 299 300struct wtbl_req_hdr * 301mt76_connac_mcu_alloc_wtbl_req(struct mt76_dev *dev, struct mt76_wcid *wcid, 302 int cmd, void *sta_wtbl, struct sk_buff **skb) 303{ 304 struct tlv *sta_hdr = sta_wtbl; 305 struct wtbl_req_hdr hdr = { 306 .operation = cmd, 307 }; 308 struct sk_buff *nskb = *skb; 309 310 mt76_connac_mcu_get_wlan_idx(dev, wcid, &hdr.wlan_idx_lo, 311 &hdr.wlan_idx_hi); 312 if (!nskb) { 313 nskb = mt76_mcu_msg_alloc(dev, NULL, 314 MT76_CONNAC_WTBL_UPDATE_MAX_SIZE); 315 if (!nskb) 316 return ERR_PTR(-ENOMEM); 317 318 *skb = nskb; 319 } 320 321 if (sta_hdr) 322 le16_add_cpu(&sta_hdr->len, sizeof(hdr)); 323 324 return skb_put_data(nskb, &hdr, sizeof(hdr)); 325} 326EXPORT_SYMBOL_GPL(mt76_connac_mcu_alloc_wtbl_req); 327 328void mt76_connac_mcu_bss_omac_tlv(struct sk_buff *skb, 329 struct ieee80211_vif *vif) 330{ 331 struct mt76_vif_link *mvif = (struct mt76_vif_link *)vif->drv_priv; 332 u8 omac_idx = mvif->omac_idx; 333 struct bss_info_omac *omac; 334 struct tlv *tlv; 335 u32 type = 0; 336 337 switch (vif->type) { 338 case NL80211_IFTYPE_MONITOR: 339 case NL80211_IFTYPE_MESH_POINT: 340 case NL80211_IFTYPE_AP: 341 if (vif->p2p) 342 type = CONNECTION_P2P_GO; 343 else 344 type = CONNECTION_INFRA_AP; 345 break; 346 case NL80211_IFTYPE_STATION: 347 if (vif->p2p) 348 type = CONNECTION_P2P_GC; 349 else 350 type = CONNECTION_INFRA_STA; 351 break; 352 case NL80211_IFTYPE_ADHOC: 353 type = CONNECTION_IBSS_ADHOC; 354 break; 355 default: 356 WARN_ON(1); 357 break; 358 } 359 360 tlv = mt76_connac_mcu_add_tlv(skb, BSS_INFO_OMAC, sizeof(*omac)); 361 362 omac = (struct bss_info_omac *)tlv; 363 omac->conn_type = cpu_to_le32(type); 364 omac->omac_idx = mvif->omac_idx; 365 omac->band_idx = mvif->band_idx; 366 omac->hw_bss_idx = omac_idx > EXT_BSSID_START ? HW_BSSID_0 : omac_idx; 367} 368EXPORT_SYMBOL_GPL(mt76_connac_mcu_bss_omac_tlv); 369 370void mt76_connac_mcu_sta_basic_tlv(struct mt76_dev *dev, struct sk_buff *skb, 371 struct ieee80211_bss_conf *link_conf, 372 struct ieee80211_link_sta *link_sta, 373 int conn_state, bool newly) 374{ 375 struct ieee80211_vif *vif = link_conf->vif; 376 struct sta_rec_basic *basic; 377 struct tlv *tlv; 378 int conn_type; 379 380 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_BASIC, sizeof(*basic)); 381 382 basic = (struct sta_rec_basic *)tlv; 383 basic->extra_info = cpu_to_le16(EXTRA_INFO_VER); 384 385 if (newly && conn_state != CONN_STATE_DISCONNECT) 386 basic->extra_info |= cpu_to_le16(EXTRA_INFO_NEW); 387 basic->conn_state = conn_state; 388 389 if (!link_sta) { 390 basic->conn_type = cpu_to_le32(CONNECTION_INFRA_BC); 391 392 if (vif->type == NL80211_IFTYPE_STATION && 393 !is_zero_ether_addr(link_conf->bssid)) { 394 memcpy(basic->peer_addr, link_conf->bssid, ETH_ALEN); 395 basic->aid = cpu_to_le16(vif->cfg.aid); 396 } else { 397 eth_broadcast_addr(basic->peer_addr); 398 } 399 return; 400 } 401 402 switch (vif->type) { 403 case NL80211_IFTYPE_MESH_POINT: 404 case NL80211_IFTYPE_AP: 405 if (vif->p2p && !is_mt7921(dev)) 406 conn_type = CONNECTION_P2P_GC; 407 else 408 conn_type = CONNECTION_INFRA_STA; 409 basic->conn_type = cpu_to_le32(conn_type); 410 basic->aid = cpu_to_le16(link_sta->sta->aid); 411 break; 412 case NL80211_IFTYPE_STATION: 413 if (vif->p2p && !is_mt7921(dev)) 414 conn_type = CONNECTION_P2P_GO; 415 else 416 conn_type = CONNECTION_INFRA_AP; 417 basic->conn_type = cpu_to_le32(conn_type); 418 basic->aid = cpu_to_le16(vif->cfg.aid); 419 break; 420 case NL80211_IFTYPE_ADHOC: 421 basic->conn_type = cpu_to_le32(CONNECTION_IBSS_ADHOC); 422 basic->aid = cpu_to_le16(link_sta->sta->aid); 423 break; 424 default: 425 WARN_ON(1); 426 break; 427 } 428 429 memcpy(basic->peer_addr, link_sta->addr, ETH_ALEN); 430 basic->qos = link_sta->sta->wme; 431} 432EXPORT_SYMBOL_GPL(mt76_connac_mcu_sta_basic_tlv); 433 434void mt76_connac_mcu_sta_uapsd(struct sk_buff *skb, struct ieee80211_vif *vif, 435 struct ieee80211_sta *sta) 436{ 437 struct sta_rec_uapsd *uapsd; 438 struct tlv *tlv; 439 440 if (vif->type != NL80211_IFTYPE_AP || !sta->wme) 441 return; 442 443 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_APPS, sizeof(*uapsd)); 444 uapsd = (struct sta_rec_uapsd *)tlv; 445 446 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VO) { 447 uapsd->dac_map |= BIT(3); 448 uapsd->tac_map |= BIT(3); 449 } 450 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VI) { 451 uapsd->dac_map |= BIT(2); 452 uapsd->tac_map |= BIT(2); 453 } 454 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BE) { 455 uapsd->dac_map |= BIT(1); 456 uapsd->tac_map |= BIT(1); 457 } 458 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BK) { 459 uapsd->dac_map |= BIT(0); 460 uapsd->tac_map |= BIT(0); 461 } 462 uapsd->max_sp = sta->max_sp; 463} 464EXPORT_SYMBOL_GPL(mt76_connac_mcu_sta_uapsd); 465 466void mt76_connac_mcu_wtbl_hdr_trans_tlv(struct sk_buff *skb, 467 struct ieee80211_vif *vif, 468 struct mt76_wcid *wcid, 469 void *sta_wtbl, void *wtbl_tlv) 470{ 471 struct wtbl_hdr_trans *htr; 472 struct tlv *tlv; 473 474 tlv = mt76_connac_mcu_add_nested_tlv(skb, WTBL_HDR_TRANS, 475 sizeof(*htr), 476 wtbl_tlv, sta_wtbl); 477 htr = (struct wtbl_hdr_trans *)tlv; 478 htr->no_rx_trans = true; 479 480 if (vif->type == NL80211_IFTYPE_STATION) 481 htr->to_ds = true; 482 else 483 htr->from_ds = true; 484 485 if (!wcid) 486 return; 487 488 htr->no_rx_trans = !test_bit(MT_WCID_FLAG_HDR_TRANS, &wcid->flags); 489 if (test_bit(MT_WCID_FLAG_4ADDR, &wcid->flags)) { 490 htr->to_ds = true; 491 htr->from_ds = true; 492 } 493} 494EXPORT_SYMBOL_GPL(mt76_connac_mcu_wtbl_hdr_trans_tlv); 495 496int mt76_connac_mcu_sta_update_hdr_trans(struct mt76_dev *dev, 497 struct ieee80211_vif *vif, 498 struct mt76_wcid *wcid, int cmd) 499{ 500 struct mt76_vif_link *mvif = (struct mt76_vif_link *)vif->drv_priv; 501 struct wtbl_req_hdr *wtbl_hdr; 502 struct tlv *sta_wtbl; 503 struct sk_buff *skb; 504 505 skb = mt76_connac_mcu_alloc_sta_req(dev, mvif, wcid); 506 if (IS_ERR(skb)) 507 return PTR_ERR(skb); 508 509 sta_wtbl = mt76_connac_mcu_add_tlv(skb, STA_REC_WTBL, 510 sizeof(struct tlv)); 511 512 wtbl_hdr = mt76_connac_mcu_alloc_wtbl_req(dev, wcid, WTBL_SET, 513 sta_wtbl, &skb); 514 if (IS_ERR(wtbl_hdr)) 515 return PTR_ERR(wtbl_hdr); 516 517 mt76_connac_mcu_wtbl_hdr_trans_tlv(skb, vif, wcid, sta_wtbl, wtbl_hdr); 518 519 return mt76_mcu_skb_send_msg(dev, skb, cmd, true); 520} 521EXPORT_SYMBOL_GPL(mt76_connac_mcu_sta_update_hdr_trans); 522 523int mt76_connac_mcu_wtbl_update_hdr_trans(struct mt76_dev *dev, 524 struct ieee80211_vif *vif, 525 struct ieee80211_sta *sta) 526{ 527 struct mt76_wcid *wcid = (struct mt76_wcid *)sta->drv_priv; 528 struct wtbl_req_hdr *wtbl_hdr; 529 struct sk_buff *skb = NULL; 530 531 wtbl_hdr = mt76_connac_mcu_alloc_wtbl_req(dev, wcid, WTBL_SET, NULL, 532 &skb); 533 if (IS_ERR(wtbl_hdr)) 534 return PTR_ERR(wtbl_hdr); 535 536 mt76_connac_mcu_wtbl_hdr_trans_tlv(skb, vif, wcid, NULL, wtbl_hdr); 537 538 return mt76_mcu_skb_send_msg(dev, skb, MCU_EXT_CMD(WTBL_UPDATE), true); 539} 540EXPORT_SYMBOL_GPL(mt76_connac_mcu_wtbl_update_hdr_trans); 541 542void mt76_connac_mcu_wtbl_generic_tlv(struct mt76_dev *dev, 543 struct sk_buff *skb, 544 struct ieee80211_vif *vif, 545 struct ieee80211_sta *sta, 546 void *sta_wtbl, void *wtbl_tlv) 547{ 548 struct mt76_vif_link *mvif = (struct mt76_vif_link *)vif->drv_priv; 549 struct wtbl_generic *generic; 550 struct wtbl_rx *rx; 551 struct wtbl_spe *spe; 552 struct tlv *tlv; 553 554 tlv = mt76_connac_mcu_add_nested_tlv(skb, WTBL_GENERIC, 555 sizeof(*generic), 556 wtbl_tlv, sta_wtbl); 557 558 generic = (struct wtbl_generic *)tlv; 559 560 if (sta) { 561 if (vif->type == NL80211_IFTYPE_STATION) 562 generic->partial_aid = cpu_to_le16(vif->cfg.aid); 563 else 564 generic->partial_aid = cpu_to_le16(sta->aid); 565 memcpy(generic->peer_addr, sta->addr, ETH_ALEN); 566 generic->muar_idx = mvif->omac_idx; 567 generic->qos = sta->wme; 568 } else { 569 if (!is_connac_v1(dev) && vif->type == NL80211_IFTYPE_STATION) 570 memcpy(generic->peer_addr, vif->bss_conf.bssid, 571 ETH_ALEN); 572 else 573 eth_broadcast_addr(generic->peer_addr); 574 575 generic->muar_idx = 0xe; 576 } 577 578 tlv = mt76_connac_mcu_add_nested_tlv(skb, WTBL_RX, sizeof(*rx), 579 wtbl_tlv, sta_wtbl); 580 581 rx = (struct wtbl_rx *)tlv; 582 rx->rca1 = sta ? vif->type != NL80211_IFTYPE_AP : 1; 583 rx->rca2 = 1; 584 rx->rv = 1; 585 586 if (!is_connac_v1(dev)) 587 return; 588 589 tlv = mt76_connac_mcu_add_nested_tlv(skb, WTBL_SPE, sizeof(*spe), 590 wtbl_tlv, sta_wtbl); 591 spe = (struct wtbl_spe *)tlv; 592 spe->spe_idx = 24; 593} 594EXPORT_SYMBOL_GPL(mt76_connac_mcu_wtbl_generic_tlv); 595 596static void 597mt76_connac_mcu_sta_amsdu_tlv(struct sk_buff *skb, struct ieee80211_sta *sta, 598 struct ieee80211_vif *vif) 599{ 600 struct mt76_wcid *wcid = (struct mt76_wcid *)sta->drv_priv; 601 struct sta_rec_amsdu *amsdu; 602 struct tlv *tlv; 603 604 if (vif->type != NL80211_IFTYPE_AP && 605 vif->type != NL80211_IFTYPE_STATION) 606 return; 607 608 if (!sta->deflink.agg.max_amsdu_len) 609 return; 610 611 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_HW_AMSDU, sizeof(*amsdu)); 612 amsdu = (struct sta_rec_amsdu *)tlv; 613 amsdu->max_amsdu_num = 8; 614 amsdu->amsdu_en = true; 615 amsdu->max_mpdu_size = sta->deflink.agg.max_amsdu_len >= 616 IEEE80211_MAX_MPDU_LEN_VHT_7991; 617 618 wcid->amsdu = true; 619} 620 621#define HE_PHY(p, c) u8_get_bits(c, IEEE80211_HE_PHY_##p) 622#define HE_MAC(m, c) u8_get_bits(c, IEEE80211_HE_MAC_##m) 623static void 624mt76_connac_mcu_sta_he_tlv(struct sk_buff *skb, struct ieee80211_sta *sta) 625{ 626 struct ieee80211_sta_he_cap *he_cap = &sta->deflink.he_cap; 627 struct ieee80211_he_cap_elem *elem = &he_cap->he_cap_elem; 628 struct sta_rec_he *he; 629 struct tlv *tlv; 630 u32 cap = 0; 631 632 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_HE, sizeof(*he)); 633 634 he = (struct sta_rec_he *)tlv; 635 636 if (elem->mac_cap_info[0] & IEEE80211_HE_MAC_CAP0_HTC_HE) 637 cap |= STA_REC_HE_CAP_HTC; 638 639 if (elem->mac_cap_info[2] & IEEE80211_HE_MAC_CAP2_BSR) 640 cap |= STA_REC_HE_CAP_BSR; 641 642 if (elem->mac_cap_info[3] & IEEE80211_HE_MAC_CAP3_OMI_CONTROL) 643 cap |= STA_REC_HE_CAP_OM; 644 645 if (elem->mac_cap_info[4] & IEEE80211_HE_MAC_CAP4_AMSDU_IN_AMPDU) 646 cap |= STA_REC_HE_CAP_AMSDU_IN_AMPDU; 647 648 if (elem->mac_cap_info[4] & IEEE80211_HE_MAC_CAP4_BQR) 649 cap |= STA_REC_HE_CAP_BQR; 650 651 if (elem->phy_cap_info[0] & 652 (IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_RU_MAPPING_IN_2G | 653 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_RU_MAPPING_IN_5G)) 654 cap |= STA_REC_HE_CAP_BW20_RU242_SUPPORT; 655 656 if (elem->phy_cap_info[1] & 657 IEEE80211_HE_PHY_CAP1_LDPC_CODING_IN_PAYLOAD) 658 cap |= STA_REC_HE_CAP_LDPC; 659 660 if (elem->phy_cap_info[1] & 661 IEEE80211_HE_PHY_CAP1_HE_LTF_AND_GI_FOR_HE_PPDUS_0_8US) 662 cap |= STA_REC_HE_CAP_SU_PPDU_1LTF_8US_GI; 663 664 if (elem->phy_cap_info[2] & 665 IEEE80211_HE_PHY_CAP2_NDP_4x_LTF_AND_3_2US) 666 cap |= STA_REC_HE_CAP_NDP_4LTF_3DOT2MS_GI; 667 668 if (elem->phy_cap_info[2] & 669 IEEE80211_HE_PHY_CAP2_STBC_TX_UNDER_80MHZ) 670 cap |= STA_REC_HE_CAP_LE_EQ_80M_TX_STBC; 671 672 if (elem->phy_cap_info[2] & 673 IEEE80211_HE_PHY_CAP2_STBC_RX_UNDER_80MHZ) 674 cap |= STA_REC_HE_CAP_LE_EQ_80M_RX_STBC; 675 676 if (elem->phy_cap_info[6] & 677 IEEE80211_HE_PHY_CAP6_PARTIAL_BW_EXT_RANGE) 678 cap |= STA_REC_HE_CAP_PARTIAL_BW_EXT_RANGE; 679 680 if (elem->phy_cap_info[7] & 681 IEEE80211_HE_PHY_CAP7_HE_SU_MU_PPDU_4XLTF_AND_08_US_GI) 682 cap |= STA_REC_HE_CAP_SU_MU_PPDU_4LTF_8US_GI; 683 684 if (elem->phy_cap_info[7] & 685 IEEE80211_HE_PHY_CAP7_STBC_TX_ABOVE_80MHZ) 686 cap |= STA_REC_HE_CAP_GT_80M_TX_STBC; 687 688 if (elem->phy_cap_info[7] & 689 IEEE80211_HE_PHY_CAP7_STBC_RX_ABOVE_80MHZ) 690 cap |= STA_REC_HE_CAP_GT_80M_RX_STBC; 691 692 if (elem->phy_cap_info[8] & 693 IEEE80211_HE_PHY_CAP8_HE_ER_SU_PPDU_4XLTF_AND_08_US_GI) 694 cap |= STA_REC_HE_CAP_ER_SU_PPDU_4LTF_8US_GI; 695 696 if (elem->phy_cap_info[8] & 697 IEEE80211_HE_PHY_CAP8_HE_ER_SU_1XLTF_AND_08_US_GI) 698 cap |= STA_REC_HE_CAP_ER_SU_PPDU_1LTF_8US_GI; 699 700 if (elem->phy_cap_info[9] & 701 IEEE80211_HE_PHY_CAP9_NON_TRIGGERED_CQI_FEEDBACK) 702 cap |= STA_REC_HE_CAP_TRIG_CQI_FK; 703 704 if (elem->phy_cap_info[9] & 705 IEEE80211_HE_PHY_CAP9_TX_1024_QAM_LESS_THAN_242_TONE_RU) 706 cap |= STA_REC_HE_CAP_TX_1024QAM_UNDER_RU242; 707 708 if (elem->phy_cap_info[9] & 709 IEEE80211_HE_PHY_CAP9_RX_1024_QAM_LESS_THAN_242_TONE_RU) 710 cap |= STA_REC_HE_CAP_RX_1024QAM_UNDER_RU242; 711 712 he->he_cap = cpu_to_le32(cap); 713 714 switch (sta->deflink.bandwidth) { 715 case IEEE80211_STA_RX_BW_160: 716 if (elem->phy_cap_info[0] & 717 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_80PLUS80_MHZ_IN_5G) 718 he->max_nss_mcs[CMD_HE_MCS_BW8080] = 719 he_cap->he_mcs_nss_supp.rx_mcs_80p80; 720 721 he->max_nss_mcs[CMD_HE_MCS_BW160] = 722 he_cap->he_mcs_nss_supp.rx_mcs_160; 723 fallthrough; 724 default: 725 he->max_nss_mcs[CMD_HE_MCS_BW80] = 726 he_cap->he_mcs_nss_supp.rx_mcs_80; 727 break; 728 } 729 730 he->t_frame_dur = 731 HE_MAC(CAP1_TF_MAC_PAD_DUR_MASK, elem->mac_cap_info[1]); 732 he->max_ampdu_exp = 733 HE_MAC(CAP3_MAX_AMPDU_LEN_EXP_MASK, elem->mac_cap_info[3]); 734 735 he->bw_set = 736 HE_PHY(CAP0_CHANNEL_WIDTH_SET_MASK, elem->phy_cap_info[0]); 737 he->device_class = 738 HE_PHY(CAP1_DEVICE_CLASS_A, elem->phy_cap_info[1]); 739 he->punc_pream_rx = 740 HE_PHY(CAP1_PREAMBLE_PUNC_RX_MASK, elem->phy_cap_info[1]); 741 742 he->dcm_tx_mode = 743 HE_PHY(CAP3_DCM_MAX_CONST_TX_MASK, elem->phy_cap_info[3]); 744 he->dcm_tx_max_nss = 745 HE_PHY(CAP3_DCM_MAX_TX_NSS_2, elem->phy_cap_info[3]); 746 he->dcm_rx_mode = 747 HE_PHY(CAP3_DCM_MAX_CONST_RX_MASK, elem->phy_cap_info[3]); 748 he->dcm_rx_max_nss = 749 HE_PHY(CAP3_DCM_MAX_RX_NSS_2, elem->phy_cap_info[3]); 750 he->dcm_rx_max_nss = 751 HE_PHY(CAP8_DCM_MAX_RU_MASK, elem->phy_cap_info[8]); 752 753 he->pkt_ext = 2; 754} 755 756void 757mt76_connac_mcu_sta_he_tlv_v2(struct sk_buff *skb, struct ieee80211_sta *sta) 758{ 759 struct ieee80211_sta_he_cap *he_cap = &sta->deflink.he_cap; 760 struct ieee80211_he_cap_elem *elem = &he_cap->he_cap_elem; 761 struct sta_rec_he_v2 *he; 762 struct tlv *tlv; 763 764 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_HE_V2, sizeof(*he)); 765 766 he = (struct sta_rec_he_v2 *)tlv; 767 memcpy(he->he_phy_cap, elem->phy_cap_info, sizeof(he->he_phy_cap)); 768 memcpy(he->he_mac_cap, elem->mac_cap_info, sizeof(he->he_mac_cap)); 769 770 switch (sta->deflink.bandwidth) { 771 case IEEE80211_STA_RX_BW_160: 772 if (elem->phy_cap_info[0] & 773 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_80PLUS80_MHZ_IN_5G) 774 he->max_nss_mcs[CMD_HE_MCS_BW8080] = 775 he_cap->he_mcs_nss_supp.rx_mcs_80p80; 776 777 he->max_nss_mcs[CMD_HE_MCS_BW160] = 778 he_cap->he_mcs_nss_supp.rx_mcs_160; 779 fallthrough; 780 default: 781 he->max_nss_mcs[CMD_HE_MCS_BW80] = 782 he_cap->he_mcs_nss_supp.rx_mcs_80; 783 break; 784 } 785 786 he->pkt_ext = IEEE80211_HE_PHY_CAP9_NOMINAL_PKT_PADDING_16US; 787} 788EXPORT_SYMBOL_GPL(mt76_connac_mcu_sta_he_tlv_v2); 789 790u8 791mt76_connac_get_phy_mode_v2(struct mt76_phy *mphy, struct ieee80211_vif *vif, 792 enum nl80211_band band, 793 struct ieee80211_link_sta *link_sta) 794{ 795 struct ieee80211_sta_ht_cap *ht_cap; 796 struct ieee80211_sta_vht_cap *vht_cap; 797 const struct ieee80211_sta_he_cap *he_cap; 798 const struct ieee80211_sta_eht_cap *eht_cap; 799 u8 mode = 0; 800 801 if (link_sta) { 802 ht_cap = &link_sta->ht_cap; 803 vht_cap = &link_sta->vht_cap; 804 he_cap = &link_sta->he_cap; 805 eht_cap = &link_sta->eht_cap; 806 } else { 807 struct ieee80211_supported_band *sband; 808 809 sband = mphy->hw->wiphy->bands[band]; 810 ht_cap = &sband->ht_cap; 811 vht_cap = &sband->vht_cap; 812 he_cap = ieee80211_get_he_iftype_cap(sband, vif->type); 813 eht_cap = ieee80211_get_eht_iftype_cap(sband, vif->type); 814 } 815 816 if (band == NL80211_BAND_2GHZ) { 817 mode |= PHY_TYPE_BIT_HR_DSSS | PHY_TYPE_BIT_ERP; 818 819 if (ht_cap->ht_supported) 820 mode |= PHY_TYPE_BIT_HT; 821 822 if (he_cap && he_cap->has_he) 823 mode |= PHY_TYPE_BIT_HE; 824 825 if (eht_cap && eht_cap->has_eht) 826 mode |= PHY_TYPE_BIT_BE; 827 } else if (band == NL80211_BAND_5GHZ || band == NL80211_BAND_6GHZ) { 828 mode |= PHY_TYPE_BIT_OFDM; 829 830 if (ht_cap->ht_supported) 831 mode |= PHY_TYPE_BIT_HT; 832 833 if (vht_cap->vht_supported) 834 mode |= PHY_TYPE_BIT_VHT; 835 836 if (he_cap && he_cap->has_he) 837 mode |= PHY_TYPE_BIT_HE; 838 839 if (eht_cap && eht_cap->has_eht) 840 mode |= PHY_TYPE_BIT_BE; 841 } 842 843 return mode; 844} 845EXPORT_SYMBOL_GPL(mt76_connac_get_phy_mode_v2); 846 847void mt76_connac_mcu_sta_tlv(struct mt76_phy *mphy, struct sk_buff *skb, 848 struct ieee80211_sta *sta, 849 struct ieee80211_vif *vif, 850 u8 rcpi, u8 sta_state) 851{ 852 struct mt76_vif_link *mvif = (struct mt76_vif_link *)vif->drv_priv; 853 struct cfg80211_chan_def *chandef = mvif->ctx ? 854 &mvif->ctx->def : &mphy->chandef; 855 enum nl80211_band band = chandef->chan->band; 856 struct mt76_dev *dev = mphy->dev; 857 struct sta_rec_ra_info *ra_info; 858 struct sta_rec_state *state; 859 struct sta_rec_phy *phy; 860 struct tlv *tlv; 861 u16 supp_rates; 862 863 /* starec ht */ 864 if (sta->deflink.ht_cap.ht_supported) { 865 struct sta_rec_ht *ht; 866 867 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_HT, sizeof(*ht)); 868 ht = (struct sta_rec_ht *)tlv; 869 ht->ht_cap = cpu_to_le16(sta->deflink.ht_cap.cap); 870 } 871 872 /* starec vht */ 873 if (sta->deflink.vht_cap.vht_supported) { 874 struct sta_rec_vht *vht; 875 int len; 876 877 len = is_mt7921(dev) ? sizeof(*vht) : sizeof(*vht) - 4; 878 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_VHT, len); 879 vht = (struct sta_rec_vht *)tlv; 880 vht->vht_cap = cpu_to_le32(sta->deflink.vht_cap.cap); 881 vht->vht_rx_mcs_map = sta->deflink.vht_cap.vht_mcs.rx_mcs_map; 882 vht->vht_tx_mcs_map = sta->deflink.vht_cap.vht_mcs.tx_mcs_map; 883 } 884 885 /* starec uapsd */ 886 mt76_connac_mcu_sta_uapsd(skb, vif, sta); 887 888 if (!is_mt7921(dev)) 889 return; 890 891 if (sta->deflink.ht_cap.ht_supported || sta->deflink.he_cap.has_he) 892 mt76_connac_mcu_sta_amsdu_tlv(skb, sta, vif); 893 894 /* starec he */ 895 if (sta->deflink.he_cap.has_he) { 896 mt76_connac_mcu_sta_he_tlv(skb, sta); 897 mt76_connac_mcu_sta_he_tlv_v2(skb, sta); 898 if (band == NL80211_BAND_6GHZ && 899 sta_state == MT76_STA_INFO_STATE_ASSOC) { 900 struct sta_rec_he_6g_capa *he_6g_capa; 901 902 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_HE_6G, 903 sizeof(*he_6g_capa)); 904 he_6g_capa = (struct sta_rec_he_6g_capa *)tlv; 905 he_6g_capa->capa = sta->deflink.he_6ghz_capa.capa; 906 } 907 } 908 909 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_PHY, sizeof(*phy)); 910 phy = (struct sta_rec_phy *)tlv; 911 phy->phy_type = mt76_connac_get_phy_mode_v2(mphy, vif, band, 912 &sta->deflink); 913 phy->basic_rate = cpu_to_le16((u16)vif->bss_conf.basic_rates); 914 phy->rcpi = rcpi; 915 phy->ampdu = FIELD_PREP(IEEE80211_HT_AMPDU_PARM_FACTOR, 916 sta->deflink.ht_cap.ampdu_factor) | 917 FIELD_PREP(IEEE80211_HT_AMPDU_PARM_DENSITY, 918 sta->deflink.ht_cap.ampdu_density); 919 920 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_RA, sizeof(*ra_info)); 921 ra_info = (struct sta_rec_ra_info *)tlv; 922 923 supp_rates = sta->deflink.supp_rates[band]; 924 if (band == NL80211_BAND_2GHZ) 925 supp_rates = FIELD_PREP(RA_LEGACY_OFDM, supp_rates >> 4) | 926 FIELD_PREP(RA_LEGACY_CCK, supp_rates & 0xf); 927 else 928 supp_rates = FIELD_PREP(RA_LEGACY_OFDM, supp_rates); 929 930 ra_info->legacy = cpu_to_le16(supp_rates); 931 932 if (sta->deflink.ht_cap.ht_supported) 933 memcpy(ra_info->rx_mcs_bitmask, 934 sta->deflink.ht_cap.mcs.rx_mask, 935 HT_MCS_MASK_NUM); 936 937 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_STATE, sizeof(*state)); 938 state = (struct sta_rec_state *)tlv; 939 state->state = sta_state; 940 941 if (sta->deflink.vht_cap.vht_supported) { 942 state->vht_opmode = sta->deflink.bandwidth; 943 state->vht_opmode |= (sta->deflink.rx_nss - 1) << 944 IEEE80211_OPMODE_NOTIF_RX_NSS_SHIFT; 945 } 946} 947EXPORT_SYMBOL_GPL(mt76_connac_mcu_sta_tlv); 948 949void mt76_connac_mcu_wtbl_smps_tlv(struct sk_buff *skb, 950 struct ieee80211_sta *sta, 951 void *sta_wtbl, void *wtbl_tlv) 952{ 953 struct wtbl_smps *smps; 954 struct tlv *tlv; 955 956 tlv = mt76_connac_mcu_add_nested_tlv(skb, WTBL_SMPS, sizeof(*smps), 957 wtbl_tlv, sta_wtbl); 958 smps = (struct wtbl_smps *)tlv; 959 smps->smps = (sta->deflink.smps_mode == IEEE80211_SMPS_DYNAMIC); 960} 961EXPORT_SYMBOL_GPL(mt76_connac_mcu_wtbl_smps_tlv); 962 963void mt76_connac_mcu_wtbl_ht_tlv(struct mt76_dev *dev, struct sk_buff *skb, 964 struct ieee80211_sta *sta, void *sta_wtbl, 965 void *wtbl_tlv, bool ht_ldpc, bool vht_ldpc) 966{ 967 struct wtbl_ht *ht = NULL; 968 struct tlv *tlv; 969 u32 flags = 0; 970 971 if (sta->deflink.ht_cap.ht_supported || sta->deflink.he_6ghz_capa.capa) { 972 tlv = mt76_connac_mcu_add_nested_tlv(skb, WTBL_HT, sizeof(*ht), 973 wtbl_tlv, sta_wtbl); 974 ht = (struct wtbl_ht *)tlv; 975 ht->ldpc = ht_ldpc && 976 !!(sta->deflink.ht_cap.cap & IEEE80211_HT_CAP_LDPC_CODING); 977 978 if (sta->deflink.ht_cap.ht_supported) { 979 ht->af = sta->deflink.ht_cap.ampdu_factor; 980 ht->mm = sta->deflink.ht_cap.ampdu_density; 981 } else { 982 ht->af = le16_get_bits(sta->deflink.he_6ghz_capa.capa, 983 IEEE80211_HE_6GHZ_CAP_MAX_AMPDU_LEN_EXP); 984 ht->mm = le16_get_bits(sta->deflink.he_6ghz_capa.capa, 985 IEEE80211_HE_6GHZ_CAP_MIN_MPDU_START); 986 } 987 988 ht->ht = true; 989 } 990 991 if (sta->deflink.vht_cap.vht_supported || sta->deflink.he_6ghz_capa.capa) { 992 struct wtbl_vht *vht; 993 u8 af; 994 995 tlv = mt76_connac_mcu_add_nested_tlv(skb, WTBL_VHT, 996 sizeof(*vht), wtbl_tlv, 997 sta_wtbl); 998 vht = (struct wtbl_vht *)tlv; 999 vht->ldpc = vht_ldpc && 1000 !!(sta->deflink.vht_cap.cap & IEEE80211_VHT_CAP_RXLDPC); 1001 vht->vht = true; 1002 1003 af = FIELD_GET(IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK, 1004 sta->deflink.vht_cap.cap); 1005 if (ht) 1006 ht->af = max(ht->af, af); 1007 } 1008 1009 mt76_connac_mcu_wtbl_smps_tlv(skb, sta, sta_wtbl, wtbl_tlv); 1010 1011 if (is_connac_v1(dev) && sta->deflink.ht_cap.ht_supported) { 1012 /* sgi */ 1013 u32 msk = MT_WTBL_W5_SHORT_GI_20 | MT_WTBL_W5_SHORT_GI_40 | 1014 MT_WTBL_W5_SHORT_GI_80 | MT_WTBL_W5_SHORT_GI_160; 1015 struct wtbl_raw *raw; 1016 1017 tlv = mt76_connac_mcu_add_nested_tlv(skb, WTBL_RAW_DATA, 1018 sizeof(*raw), wtbl_tlv, 1019 sta_wtbl); 1020 1021 if (sta->deflink.ht_cap.cap & IEEE80211_HT_CAP_SGI_20) 1022 flags |= MT_WTBL_W5_SHORT_GI_20; 1023 if (sta->deflink.ht_cap.cap & IEEE80211_HT_CAP_SGI_40) 1024 flags |= MT_WTBL_W5_SHORT_GI_40; 1025 1026 if (sta->deflink.vht_cap.vht_supported) { 1027 if (sta->deflink.vht_cap.cap & IEEE80211_VHT_CAP_SHORT_GI_80) 1028 flags |= MT_WTBL_W5_SHORT_GI_80; 1029 if (sta->deflink.vht_cap.cap & IEEE80211_VHT_CAP_SHORT_GI_160) 1030 flags |= MT_WTBL_W5_SHORT_GI_160; 1031 } 1032 raw = (struct wtbl_raw *)tlv; 1033 raw->val = cpu_to_le32(flags); 1034 raw->msk = cpu_to_le32(~msk); 1035 raw->wtbl_idx = 1; 1036 raw->dw = 5; 1037 } 1038} 1039EXPORT_SYMBOL_GPL(mt76_connac_mcu_wtbl_ht_tlv); 1040 1041int mt76_connac_mcu_sta_cmd(struct mt76_phy *phy, 1042 struct mt76_sta_cmd_info *info) 1043{ 1044 struct mt76_vif_link *mvif = (struct mt76_vif_link *)info->vif->drv_priv; 1045 struct ieee80211_link_sta *link_sta; 1046 struct mt76_dev *dev = phy->dev; 1047 struct wtbl_req_hdr *wtbl_hdr; 1048 struct tlv *sta_wtbl; 1049 struct sk_buff *skb; 1050 int conn_state; 1051 1052 if (!info->link_conf) 1053 info->link_conf = &info->vif->bss_conf; 1054 1055 skb = mt76_connac_mcu_alloc_sta_req(dev, mvif, info->wcid); 1056 if (IS_ERR(skb)) 1057 return PTR_ERR(skb); 1058 1059 conn_state = info->enable ? CONN_STATE_PORT_SECURE : 1060 CONN_STATE_DISCONNECT; 1061 link_sta = info->sta ? &info->sta->deflink : NULL; 1062 if (info->sta || !info->offload_fw) 1063 mt76_connac_mcu_sta_basic_tlv(dev, skb, info->link_conf, 1064 link_sta, conn_state, 1065 info->newly); 1066 if (info->sta && info->enable) 1067 mt76_connac_mcu_sta_tlv(phy, skb, info->sta, 1068 info->vif, info->rcpi, 1069 info->state); 1070 1071 sta_wtbl = mt76_connac_mcu_add_tlv(skb, STA_REC_WTBL, 1072 sizeof(struct tlv)); 1073 1074 wtbl_hdr = mt76_connac_mcu_alloc_wtbl_req(dev, info->wcid, 1075 WTBL_RESET_AND_SET, 1076 sta_wtbl, &skb); 1077 if (IS_ERR(wtbl_hdr)) 1078 return PTR_ERR(wtbl_hdr); 1079 1080 if (info->enable) { 1081 mt76_connac_mcu_wtbl_generic_tlv(dev, skb, info->vif, 1082 info->sta, sta_wtbl, 1083 wtbl_hdr); 1084 mt76_connac_mcu_wtbl_hdr_trans_tlv(skb, info->vif, info->wcid, 1085 sta_wtbl, wtbl_hdr); 1086 if (info->sta) 1087 mt76_connac_mcu_wtbl_ht_tlv(dev, skb, info->sta, 1088 sta_wtbl, wtbl_hdr, 1089 true, true); 1090 } 1091 1092 return mt76_mcu_skb_send_msg(dev, skb, info->cmd, true); 1093} 1094EXPORT_SYMBOL_GPL(mt76_connac_mcu_sta_cmd); 1095 1096void mt76_connac_mcu_wtbl_ba_tlv(struct mt76_dev *dev, struct sk_buff *skb, 1097 struct ieee80211_ampdu_params *params, 1098 bool enable, bool tx, void *sta_wtbl, 1099 void *wtbl_tlv) 1100{ 1101 struct wtbl_ba *ba; 1102 struct tlv *tlv; 1103 1104 tlv = mt76_connac_mcu_add_nested_tlv(skb, WTBL_BA, sizeof(*ba), 1105 wtbl_tlv, sta_wtbl); 1106 1107 ba = (struct wtbl_ba *)tlv; 1108 ba->tid = params->tid; 1109 1110 if (tx) { 1111 ba->ba_type = MT_BA_TYPE_ORIGINATOR; 1112 ba->sn = enable ? cpu_to_le16(params->ssn) : 0; 1113 ba->ba_winsize = enable ? cpu_to_le16(params->buf_size) : 0; 1114 ba->ba_en = enable; 1115 } else { 1116 memcpy(ba->peer_addr, params->sta->addr, ETH_ALEN); 1117 ba->ba_type = MT_BA_TYPE_RECIPIENT; 1118 ba->rst_ba_tid = params->tid; 1119 ba->rst_ba_sel = RST_BA_MAC_TID_MATCH; 1120 ba->rst_ba_sb = 1; 1121 } 1122 1123 if (!is_connac_v1(dev)) { 1124 ba->ba_winsize = enable ? cpu_to_le16(params->buf_size) : 0; 1125 return; 1126 } 1127 1128 if (enable && tx) { 1129 static const u8 ba_range[] = { 4, 8, 12, 24, 36, 48, 54, 64 }; 1130 int i; 1131 1132 for (i = 7; i > 0; i--) { 1133 if (params->buf_size >= ba_range[i]) 1134 break; 1135 } 1136 ba->ba_winsize_idx = i; 1137 } 1138} 1139EXPORT_SYMBOL_GPL(mt76_connac_mcu_wtbl_ba_tlv); 1140 1141int mt76_connac_mcu_uni_add_dev(struct mt76_phy *phy, 1142 struct ieee80211_bss_conf *bss_conf, 1143 struct mt76_vif_link *mvif, 1144 struct mt76_wcid *wcid, 1145 bool enable) 1146{ 1147 struct mt76_dev *dev = phy->dev; 1148 struct { 1149 struct { 1150 u8 omac_idx; 1151 u8 band_idx; 1152 __le16 pad; 1153 } __packed hdr; 1154 struct req_tlv { 1155 __le16 tag; 1156 __le16 len; 1157 u8 active; 1158 u8 link_idx; /* not link_id */ 1159 u8 omac_addr[ETH_ALEN]; 1160 } __packed tlv; 1161 } dev_req = { 1162 .hdr = { 1163 .omac_idx = mvif->omac_idx, 1164 .band_idx = mvif->band_idx, 1165 }, 1166 .tlv = { 1167 .tag = cpu_to_le16(DEV_INFO_ACTIVE), 1168 .len = cpu_to_le16(sizeof(struct req_tlv)), 1169 .active = enable, 1170 .link_idx = mvif->link_idx, 1171 }, 1172 }; 1173 struct { 1174 struct { 1175 u8 bss_idx; 1176 u8 pad[3]; 1177 } __packed hdr; 1178 struct mt76_connac_bss_basic_tlv basic; 1179 } basic_req = { 1180 .hdr = { 1181 .bss_idx = mvif->idx, 1182 }, 1183 .basic = { 1184 .tag = cpu_to_le16(UNI_BSS_INFO_BASIC), 1185 .len = cpu_to_le16(sizeof(struct mt76_connac_bss_basic_tlv)), 1186 .omac_idx = mvif->omac_idx, 1187 .band_idx = mvif->band_idx, 1188 .wmm_idx = mvif->wmm_idx, 1189 .active = enable, 1190 .bmc_tx_wlan_idx = cpu_to_le16(wcid->idx), 1191 .sta_idx = cpu_to_le16(wcid->idx), 1192 .conn_state = 1, 1193 .link_idx = mvif->link_idx, 1194 }, 1195 }; 1196 int err, idx, cmd, len; 1197 void *data; 1198 1199 switch (bss_conf->vif->type) { 1200 case NL80211_IFTYPE_MESH_POINT: 1201 case NL80211_IFTYPE_MONITOR: 1202 case NL80211_IFTYPE_AP: 1203 basic_req.basic.conn_type = cpu_to_le32(CONNECTION_INFRA_AP); 1204 break; 1205 case NL80211_IFTYPE_STATION: 1206 basic_req.basic.conn_type = cpu_to_le32(CONNECTION_INFRA_STA); 1207 break; 1208 case NL80211_IFTYPE_P2P_DEVICE: 1209 basic_req.basic.conn_type = cpu_to_le32(CONNECTION_P2P_GO); 1210 break; 1211 case NL80211_IFTYPE_ADHOC: 1212 basic_req.basic.conn_type = cpu_to_le32(CONNECTION_IBSS_ADHOC); 1213 break; 1214 default: 1215 WARN_ON(1); 1216 break; 1217 } 1218 1219 idx = mvif->omac_idx > EXT_BSSID_START ? HW_BSSID_0 : mvif->omac_idx; 1220 basic_req.basic.hw_bss_idx = idx; 1221 1222 memcpy(dev_req.tlv.omac_addr, bss_conf->addr, ETH_ALEN); 1223 1224 cmd = enable ? MCU_UNI_CMD(DEV_INFO_UPDATE) : MCU_UNI_CMD(BSS_INFO_UPDATE); 1225 data = enable ? (void *)&dev_req : (void *)&basic_req; 1226 len = enable ? sizeof(dev_req) : sizeof(basic_req); 1227 1228 err = mt76_mcu_send_msg(dev, cmd, data, len, true); 1229 if (err < 0) 1230 return err; 1231 1232 cmd = enable ? MCU_UNI_CMD(BSS_INFO_UPDATE) : MCU_UNI_CMD(DEV_INFO_UPDATE); 1233 data = enable ? (void *)&basic_req : (void *)&dev_req; 1234 len = enable ? sizeof(basic_req) : sizeof(dev_req); 1235 1236 return mt76_mcu_send_msg(dev, cmd, data, len, true); 1237} 1238EXPORT_SYMBOL_GPL(mt76_connac_mcu_uni_add_dev); 1239 1240void mt76_connac_mcu_sta_ba_tlv(struct sk_buff *skb, 1241 struct ieee80211_ampdu_params *params, 1242 bool enable, bool tx) 1243{ 1244 struct sta_rec_ba *ba; 1245 struct tlv *tlv; 1246 1247 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_BA, sizeof(*ba)); 1248 1249 ba = (struct sta_rec_ba *)tlv; 1250 ba->ba_type = tx ? MT_BA_TYPE_ORIGINATOR : MT_BA_TYPE_RECIPIENT; 1251 ba->winsize = cpu_to_le16(params->buf_size); 1252 ba->ssn = cpu_to_le16(params->ssn); 1253 ba->ba_en = enable << params->tid; 1254 ba->amsdu = params->amsdu; 1255 ba->tid = params->tid; 1256} 1257EXPORT_SYMBOL_GPL(mt76_connac_mcu_sta_ba_tlv); 1258 1259int mt76_connac_mcu_sta_wed_update(struct mt76_dev *dev, struct sk_buff *skb) 1260{ 1261 if (!mt76_is_mmio(dev)) 1262 return 0; 1263 1264 if (!mtk_wed_device_active(&dev->mmio.wed)) 1265 return 0; 1266 1267 return mtk_wed_device_update_msg(&dev->mmio.wed, WED_WO_STA_REC, 1268 skb->data, skb->len); 1269} 1270EXPORT_SYMBOL_GPL(mt76_connac_mcu_sta_wed_update); 1271 1272int mt76_connac_mcu_sta_ba(struct mt76_dev *dev, struct mt76_vif_link *mvif, 1273 struct ieee80211_ampdu_params *params, 1274 int cmd, bool enable, bool tx) 1275{ 1276 struct mt76_wcid *wcid = (struct mt76_wcid *)params->sta->drv_priv; 1277 struct wtbl_req_hdr *wtbl_hdr; 1278 struct tlv *sta_wtbl; 1279 struct sk_buff *skb; 1280 int ret; 1281 1282 skb = mt76_connac_mcu_alloc_sta_req(dev, mvif, wcid); 1283 if (IS_ERR(skb)) 1284 return PTR_ERR(skb); 1285 1286 sta_wtbl = mt76_connac_mcu_add_tlv(skb, STA_REC_WTBL, 1287 sizeof(struct tlv)); 1288 1289 wtbl_hdr = mt76_connac_mcu_alloc_wtbl_req(dev, wcid, WTBL_SET, 1290 sta_wtbl, &skb); 1291 if (IS_ERR(wtbl_hdr)) 1292 return PTR_ERR(wtbl_hdr); 1293 1294 mt76_connac_mcu_wtbl_ba_tlv(dev, skb, params, enable, tx, sta_wtbl, 1295 wtbl_hdr); 1296 1297 ret = mt76_connac_mcu_sta_wed_update(dev, skb); 1298 if (ret) 1299 return ret; 1300 1301 ret = mt76_mcu_skb_send_msg(dev, skb, cmd, true); 1302 if (ret) 1303 return ret; 1304 1305 skb = mt76_connac_mcu_alloc_sta_req(dev, mvif, wcid); 1306 if (IS_ERR(skb)) 1307 return PTR_ERR(skb); 1308 1309 mt76_connac_mcu_sta_ba_tlv(skb, params, enable, tx); 1310 1311 ret = mt76_connac_mcu_sta_wed_update(dev, skb); 1312 if (ret) 1313 return ret; 1314 1315 return mt76_mcu_skb_send_msg(dev, skb, cmd, true); 1316} 1317EXPORT_SYMBOL_GPL(mt76_connac_mcu_sta_ba); 1318 1319u8 mt76_connac_get_phy_mode(struct mt76_phy *phy, struct ieee80211_vif *vif, 1320 enum nl80211_band band, 1321 struct ieee80211_link_sta *link_sta) 1322{ 1323 struct mt76_dev *dev = phy->dev; 1324 const struct ieee80211_sta_he_cap *he_cap; 1325 struct ieee80211_sta_vht_cap *vht_cap; 1326 struct ieee80211_sta_ht_cap *ht_cap; 1327 u8 mode = 0; 1328 1329 if (is_connac_v1(dev)) 1330 return 0x38; 1331 1332 if (link_sta) { 1333 ht_cap = &link_sta->ht_cap; 1334 vht_cap = &link_sta->vht_cap; 1335 he_cap = &link_sta->he_cap; 1336 } else { 1337 struct ieee80211_supported_band *sband; 1338 1339 sband = phy->hw->wiphy->bands[band]; 1340 ht_cap = &sband->ht_cap; 1341 vht_cap = &sband->vht_cap; 1342 he_cap = ieee80211_get_he_iftype_cap(sband, vif->type); 1343 } 1344 1345 if (band == NL80211_BAND_2GHZ) { 1346 mode |= PHY_MODE_B | PHY_MODE_G; 1347 1348 if (ht_cap->ht_supported) 1349 mode |= PHY_MODE_GN; 1350 1351 if (he_cap && he_cap->has_he) 1352 mode |= PHY_MODE_AX_24G; 1353 } else if (band == NL80211_BAND_5GHZ) { 1354 mode |= PHY_MODE_A; 1355 1356 if (ht_cap->ht_supported) 1357 mode |= PHY_MODE_AN; 1358 1359 if (vht_cap->vht_supported) 1360 mode |= PHY_MODE_AC; 1361 1362 if (he_cap && he_cap->has_he) 1363 mode |= PHY_MODE_AX_5G; 1364 } else if (band == NL80211_BAND_6GHZ) { 1365 mode |= PHY_MODE_A | PHY_MODE_AN | 1366 PHY_MODE_AC | PHY_MODE_AX_5G; 1367 } 1368 1369 return mode; 1370} 1371EXPORT_SYMBOL_GPL(mt76_connac_get_phy_mode); 1372 1373u8 mt76_connac_get_phy_mode_ext(struct mt76_phy *phy, struct ieee80211_bss_conf *conf, 1374 enum nl80211_band band) 1375{ 1376 const struct ieee80211_sta_eht_cap *eht_cap; 1377 struct ieee80211_supported_band *sband; 1378 u8 mode = 0; 1379 1380 if (band == NL80211_BAND_6GHZ) 1381 mode |= PHY_MODE_AX_6G; 1382 1383 sband = phy->hw->wiphy->bands[band]; 1384 eht_cap = ieee80211_get_eht_iftype_cap(sband, conf->vif->type); 1385 1386 if (!eht_cap || !eht_cap->has_eht || !conf->eht_support) 1387 return mode; 1388 1389 switch (band) { 1390 case NL80211_BAND_6GHZ: 1391 mode |= PHY_MODE_BE_6G; 1392 break; 1393 case NL80211_BAND_5GHZ: 1394 mode |= PHY_MODE_BE_5G; 1395 break; 1396 case NL80211_BAND_2GHZ: 1397 mode |= PHY_MODE_BE_24G; 1398 break; 1399 default: 1400 break; 1401 } 1402 1403 return mode; 1404} 1405EXPORT_SYMBOL_GPL(mt76_connac_get_phy_mode_ext); 1406 1407const struct ieee80211_sta_he_cap * 1408mt76_connac_get_he_phy_cap(struct mt76_phy *phy, struct ieee80211_vif *vif) 1409{ 1410 struct mt76_vif_link *mvif = (struct mt76_vif_link *)vif->drv_priv; 1411 struct cfg80211_chan_def *chandef = mvif->ctx ? 1412 &mvif->ctx->def : &phy->chandef; 1413 enum nl80211_band band = chandef->chan->band; 1414 struct ieee80211_supported_band *sband; 1415 1416 sband = phy->hw->wiphy->bands[band]; 1417 1418 return ieee80211_get_he_iftype_cap(sband, vif->type); 1419} 1420EXPORT_SYMBOL_GPL(mt76_connac_get_he_phy_cap); 1421 1422const struct ieee80211_sta_eht_cap * 1423mt76_connac_get_eht_phy_cap(struct mt76_phy *phy, struct ieee80211_vif *vif) 1424{ 1425 enum nl80211_band band = phy->chandef.chan->band; 1426 struct ieee80211_supported_band *sband; 1427 1428 sband = phy->hw->wiphy->bands[band]; 1429 1430 return ieee80211_get_eht_iftype_cap(sband, vif->type); 1431} 1432EXPORT_SYMBOL_GPL(mt76_connac_get_eht_phy_cap); 1433 1434#define DEFAULT_HE_PE_DURATION 4 1435#define DEFAULT_HE_DURATION_RTS_THRES 1023 1436static void 1437mt76_connac_mcu_uni_bss_he_tlv(struct mt76_phy *phy, struct ieee80211_vif *vif, 1438 struct tlv *tlv) 1439{ 1440 const struct ieee80211_sta_he_cap *cap; 1441 struct bss_info_uni_he *he; 1442 1443 cap = mt76_connac_get_he_phy_cap(phy, vif); 1444 1445 he = (struct bss_info_uni_he *)tlv; 1446 he->he_pe_duration = vif->bss_conf.htc_trig_based_pkt_ext; 1447 if (!he->he_pe_duration) 1448 he->he_pe_duration = DEFAULT_HE_PE_DURATION; 1449 1450 he->he_rts_thres = cpu_to_le16(vif->bss_conf.frame_time_rts_th); 1451 if (!he->he_rts_thres) 1452 he->he_rts_thres = cpu_to_le16(DEFAULT_HE_DURATION_RTS_THRES); 1453 1454 he->max_nss_mcs[CMD_HE_MCS_BW80] = cap->he_mcs_nss_supp.tx_mcs_80; 1455 he->max_nss_mcs[CMD_HE_MCS_BW160] = cap->he_mcs_nss_supp.tx_mcs_160; 1456 he->max_nss_mcs[CMD_HE_MCS_BW8080] = cap->he_mcs_nss_supp.tx_mcs_80p80; 1457} 1458 1459int mt76_connac_mcu_uni_set_chctx(struct mt76_phy *phy, struct mt76_vif_link *mvif, 1460 struct ieee80211_chanctx_conf *ctx) 1461{ 1462 struct cfg80211_chan_def *chandef = ctx ? &ctx->def : &phy->chandef; 1463 int freq1 = chandef->center_freq1, freq2 = chandef->center_freq2; 1464 enum nl80211_band band = chandef->chan->band; 1465 struct mt76_dev *mdev = phy->dev; 1466 struct { 1467 struct { 1468 u8 bss_idx; 1469 u8 pad[3]; 1470 } __packed hdr; 1471 struct rlm_tlv { 1472 __le16 tag; 1473 __le16 len; 1474 u8 control_channel; 1475 u8 center_chan; 1476 u8 center_chan2; 1477 u8 bw; 1478 u8 tx_streams; 1479 u8 rx_streams; 1480 u8 short_st; 1481 u8 ht_op_info; 1482 u8 sco; 1483 u8 band; 1484 u8 pad[2]; 1485 } __packed rlm; 1486 } __packed rlm_req = { 1487 .hdr = { 1488 .bss_idx = mvif->idx, 1489 }, 1490 .rlm = { 1491 .tag = cpu_to_le16(UNI_BSS_INFO_RLM), 1492 .len = cpu_to_le16(sizeof(struct rlm_tlv)), 1493 .control_channel = chandef->chan->hw_value, 1494 .center_chan = ieee80211_frequency_to_channel(freq1), 1495 .center_chan2 = ieee80211_frequency_to_channel(freq2), 1496 .tx_streams = hweight8(phy->antenna_mask), 1497 .ht_op_info = 4, /* set HT 40M allowed */ 1498 .rx_streams = phy->chainmask, 1499 .short_st = true, 1500 .band = band, 1501 }, 1502 }; 1503 1504 switch (chandef->width) { 1505 case NL80211_CHAN_WIDTH_40: 1506 rlm_req.rlm.bw = CMD_CBW_40MHZ; 1507 break; 1508 case NL80211_CHAN_WIDTH_80: 1509 rlm_req.rlm.bw = CMD_CBW_80MHZ; 1510 break; 1511 case NL80211_CHAN_WIDTH_80P80: 1512 rlm_req.rlm.bw = CMD_CBW_8080MHZ; 1513 break; 1514 case NL80211_CHAN_WIDTH_160: 1515 rlm_req.rlm.bw = CMD_CBW_160MHZ; 1516 break; 1517 case NL80211_CHAN_WIDTH_5: 1518 rlm_req.rlm.bw = CMD_CBW_5MHZ; 1519 break; 1520 case NL80211_CHAN_WIDTH_10: 1521 rlm_req.rlm.bw = CMD_CBW_10MHZ; 1522 break; 1523 case NL80211_CHAN_WIDTH_20_NOHT: 1524 case NL80211_CHAN_WIDTH_20: 1525 default: 1526 rlm_req.rlm.bw = CMD_CBW_20MHZ; 1527 rlm_req.rlm.ht_op_info = 0; 1528 break; 1529 } 1530 1531 if (rlm_req.rlm.control_channel < rlm_req.rlm.center_chan) 1532 rlm_req.rlm.sco = 1; /* SCA */ 1533 else if (rlm_req.rlm.control_channel > rlm_req.rlm.center_chan) 1534 rlm_req.rlm.sco = 3; /* SCB */ 1535 1536 return mt76_mcu_send_msg(mdev, MCU_UNI_CMD(BSS_INFO_UPDATE), &rlm_req, 1537 sizeof(rlm_req), true); 1538} 1539EXPORT_SYMBOL_GPL(mt76_connac_mcu_uni_set_chctx); 1540 1541int mt76_connac_mcu_uni_add_bss(struct mt76_phy *phy, 1542 struct ieee80211_vif *vif, 1543 struct mt76_wcid *wcid, 1544 bool enable, 1545 struct ieee80211_chanctx_conf *ctx) 1546{ 1547 struct mt76_vif_link *mvif = (struct mt76_vif_link *)vif->drv_priv; 1548 struct cfg80211_chan_def *chandef = ctx ? &ctx->def : &phy->chandef; 1549 enum nl80211_band band = chandef->chan->band; 1550 struct mt76_dev *mdev = phy->dev; 1551 struct { 1552 struct { 1553 u8 bss_idx; 1554 u8 pad[3]; 1555 } __packed hdr; 1556 struct mt76_connac_bss_basic_tlv basic; 1557 struct mt76_connac_bss_qos_tlv qos; 1558 } basic_req = { 1559 .hdr = { 1560 .bss_idx = mvif->idx, 1561 }, 1562 .basic = { 1563 .tag = cpu_to_le16(UNI_BSS_INFO_BASIC), 1564 .len = cpu_to_le16(sizeof(struct mt76_connac_bss_basic_tlv)), 1565 .bcn_interval = cpu_to_le16(vif->bss_conf.beacon_int), 1566 .dtim_period = vif->bss_conf.dtim_period, 1567 .omac_idx = mvif->omac_idx, 1568 .band_idx = mvif->band_idx, 1569 .wmm_idx = mvif->wmm_idx, 1570 .active = true, /* keep bss deactivated */ 1571 .phymode = mt76_connac_get_phy_mode(phy, vif, band, NULL), 1572 }, 1573 .qos = { 1574 .tag = cpu_to_le16(UNI_BSS_INFO_QBSS), 1575 .len = cpu_to_le16(sizeof(struct mt76_connac_bss_qos_tlv)), 1576 .qos = vif->bss_conf.qos, 1577 }, 1578 }; 1579 int err, conn_type; 1580 u8 idx, basic_phy; 1581 1582 idx = mvif->omac_idx > EXT_BSSID_START ? HW_BSSID_0 : mvif->omac_idx; 1583 basic_req.basic.hw_bss_idx = idx; 1584 if (band == NL80211_BAND_6GHZ) 1585 basic_req.basic.phymode_ext = PHY_MODE_AX_6G; 1586 1587 basic_phy = mt76_connac_get_phy_mode_v2(phy, vif, band, NULL); 1588 basic_req.basic.nonht_basic_phy = cpu_to_le16(basic_phy); 1589 1590 switch (vif->type) { 1591 case NL80211_IFTYPE_MESH_POINT: 1592 case NL80211_IFTYPE_AP: 1593 if (vif->p2p) 1594 conn_type = CONNECTION_P2P_GO; 1595 else 1596 conn_type = CONNECTION_INFRA_AP; 1597 basic_req.basic.conn_type = cpu_to_le32(conn_type); 1598 /* Fully active/deactivate BSS network in AP mode only */ 1599 basic_req.basic.active = enable; 1600 break; 1601 case NL80211_IFTYPE_STATION: 1602 if (vif->p2p) 1603 conn_type = CONNECTION_P2P_GC; 1604 else 1605 conn_type = CONNECTION_INFRA_STA; 1606 basic_req.basic.conn_type = cpu_to_le32(conn_type); 1607 break; 1608 case NL80211_IFTYPE_ADHOC: 1609 basic_req.basic.conn_type = cpu_to_le32(CONNECTION_IBSS_ADHOC); 1610 break; 1611 default: 1612 WARN_ON(1); 1613 break; 1614 } 1615 1616 memcpy(basic_req.basic.bssid, vif->bss_conf.bssid, ETH_ALEN); 1617 basic_req.basic.bmc_tx_wlan_idx = cpu_to_le16(wcid->idx); 1618 basic_req.basic.sta_idx = cpu_to_le16(wcid->idx); 1619 basic_req.basic.conn_state = !enable; 1620 1621 err = mt76_mcu_send_msg(mdev, MCU_UNI_CMD(BSS_INFO_UPDATE), &basic_req, 1622 sizeof(basic_req), true); 1623 if (err < 0) 1624 return err; 1625 1626 if (vif->bss_conf.he_support) { 1627 struct { 1628 struct { 1629 u8 bss_idx; 1630 u8 pad[3]; 1631 } __packed hdr; 1632 struct bss_info_uni_he he; 1633 struct bss_info_uni_bss_color bss_color; 1634 } he_req = { 1635 .hdr = { 1636 .bss_idx = mvif->idx, 1637 }, 1638 .he = { 1639 .tag = cpu_to_le16(UNI_BSS_INFO_HE_BASIC), 1640 .len = cpu_to_le16(sizeof(struct bss_info_uni_he)), 1641 }, 1642 .bss_color = { 1643 .tag = cpu_to_le16(UNI_BSS_INFO_BSS_COLOR), 1644 .len = cpu_to_le16(sizeof(struct bss_info_uni_bss_color)), 1645 .enable = 0, 1646 .bss_color = 0, 1647 }, 1648 }; 1649 1650 if (enable) { 1651 he_req.bss_color.enable = 1652 vif->bss_conf.he_bss_color.enabled; 1653 he_req.bss_color.bss_color = 1654 vif->bss_conf.he_bss_color.color; 1655 } 1656 1657 mt76_connac_mcu_uni_bss_he_tlv(phy, vif, 1658 (struct tlv *)&he_req.he); 1659 err = mt76_mcu_send_msg(mdev, MCU_UNI_CMD(BSS_INFO_UPDATE), 1660 &he_req, sizeof(he_req), true); 1661 if (err < 0) 1662 return err; 1663 } 1664 1665 if (enable && vif->bss_conf.bssid_indicator) { 1666 struct { 1667 struct { 1668 u8 bss_idx; 1669 u8 pad[3]; 1670 } __packed hdr; 1671 struct bss_info_uni_mbssid mbssid; 1672 } mbssid_req = { 1673 .hdr = { 1674 .bss_idx = mvif->idx, 1675 }, 1676 .mbssid = { 1677 .tag = cpu_to_le16(UNI_BSS_INFO_11V_MBSSID), 1678 .len = cpu_to_le16(sizeof(struct bss_info_uni_mbssid)), 1679 .max_indicator = vif->bss_conf.bssid_indicator, 1680 .mbss_idx = vif->bss_conf.bssid_index, 1681 }, 1682 }; 1683 1684 err = mt76_mcu_send_msg(mdev, MCU_UNI_CMD(BSS_INFO_UPDATE), 1685 &mbssid_req, sizeof(mbssid_req), true); 1686 if (err < 0) 1687 return err; 1688 } 1689 1690 return mt76_connac_mcu_uni_set_chctx(phy, mvif, ctx); 1691} 1692EXPORT_SYMBOL_GPL(mt76_connac_mcu_uni_add_bss); 1693 1694void mt76_connac_mcu_build_rnr_scan_param(struct mt76_dev *mdev, 1695 struct cfg80211_scan_request *sreq) 1696{ 1697 struct ieee80211_channel **scan_list = sreq->channels; 1698 int i, bssid_index = 0; 1699 1700 /* clear 6G active Scan BSSID table */ 1701 memset(&mdev->rnr, 0, sizeof(mdev->rnr)); 1702 1703 for (i = 0; i < sreq->n_6ghz_params; i++) { 1704 u8 ch_idx = sreq->scan_6ghz_params[i].channel_idx; 1705 int k = 0; 1706 1707 /* Remove the duplicated BSSID */ 1708 for (k = 0; k < bssid_index; k++) { 1709 if (!memcmp(&mdev->rnr.bssid[k], 1710 sreq->scan_6ghz_params[i].bssid, 1711 ETH_ALEN)) 1712 break; 1713 } 1714 1715 if (k == bssid_index && 1716 bssid_index < MT76_RNR_SCAN_MAX_BSSIDS) { 1717 memcpy(&mdev->rnr.bssid[bssid_index++], 1718 sreq->scan_6ghz_params[i].bssid, ETH_ALEN); 1719 mdev->rnr.channel[k] = scan_list[ch_idx]->hw_value; 1720 } 1721 } 1722 1723 mdev->rnr.bssid_num = bssid_index; 1724 1725 if (sreq->flags & NL80211_SCAN_FLAG_RANDOM_ADDR) { 1726 memcpy(mdev->rnr.random_mac, sreq->mac_addr, ETH_ALEN); 1727 mdev->rnr.sreq_flag = sreq->flags; 1728 } 1729} 1730EXPORT_SYMBOL_GPL(mt76_connac_mcu_build_rnr_scan_param); 1731 1732#define MT76_CONNAC_SCAN_CHANNEL_TIME 60 1733int mt76_connac_mcu_hw_scan(struct mt76_phy *phy, struct ieee80211_vif *vif, 1734 struct ieee80211_scan_request *scan_req) 1735{ 1736 struct mt76_vif_link *mvif = (struct mt76_vif_link *)vif->drv_priv; 1737 struct cfg80211_scan_request *sreq = &scan_req->req; 1738 int n_ssids = 0, err, i, duration; 1739 int ext_channels_num = max_t(int, sreq->n_channels - 32, 0); 1740 struct ieee80211_channel **scan_list = sreq->channels; 1741 struct mt76_dev *mdev = phy->dev; 1742 struct mt76_connac_mcu_scan_channel *chan; 1743 struct mt76_connac_hw_scan_req *req; 1744 struct sk_buff *skb; 1745 1746 if (test_bit(MT76_HW_SCANNING, &phy->state)) 1747 return -EBUSY; 1748 1749 skb = mt76_mcu_msg_alloc(mdev, NULL, sizeof(*req)); 1750 if (!skb) 1751 return -ENOMEM; 1752 1753 set_bit(MT76_HW_SCANNING, &phy->state); 1754 mvif->scan_seq_num = (mvif->scan_seq_num + 1) & 0x7f; 1755 1756 req = (struct mt76_connac_hw_scan_req *)skb_put_zero(skb, sizeof(*req)); 1757 1758 req->seq_num = mvif->scan_seq_num | mvif->band_idx << 7; 1759 req->bss_idx = mvif->idx; 1760 req->scan_type = sreq->n_ssids ? 1 : 0; 1761 req->probe_req_num = sreq->n_ssids ? 2 : 0; 1762 req->version = 1; 1763 1764 for (i = 0; i < sreq->n_ssids; i++) { 1765 if (!sreq->ssids[i].ssid_len) 1766 continue; 1767 1768 req->ssids[n_ssids].ssid_len = cpu_to_le32(sreq->ssids[i].ssid_len); 1769 memcpy(req->ssids[n_ssids].ssid, sreq->ssids[i].ssid, 1770 sreq->ssids[i].ssid_len); 1771 n_ssids++; 1772 } 1773 req->ssid_type = n_ssids ? BIT(2) : BIT(0); 1774 req->ssid_type_ext = n_ssids ? BIT(0) : 0; 1775 req->ssids_num = n_ssids; 1776 1777 duration = is_mt7921(phy->dev) ? 0 : MT76_CONNAC_SCAN_CHANNEL_TIME; 1778 /* increase channel time for passive scan */ 1779 if (!sreq->n_ssids) 1780 duration *= 2; 1781 req->timeout_value = cpu_to_le16(sreq->n_channels * duration); 1782 req->channel_min_dwell_time = cpu_to_le16(duration); 1783 req->channel_dwell_time = cpu_to_le16(duration); 1784 1785 if (sreq->n_channels == 0 || sreq->n_channels > 64) { 1786 req->channel_type = 0; 1787 req->channels_num = 0; 1788 req->ext_channels_num = 0; 1789 } else { 1790 req->channel_type = 4; 1791 req->channels_num = min_t(u8, sreq->n_channels, 32); 1792 req->ext_channels_num = min_t(u8, ext_channels_num, 32); 1793 } 1794 1795 for (i = 0; i < req->channels_num + req->ext_channels_num; i++) { 1796 if (i >= 32) 1797 chan = &req->ext_channels[i - 32]; 1798 else 1799 chan = &req->channels[i]; 1800 1801 switch (scan_list[i]->band) { 1802 case NL80211_BAND_2GHZ: 1803 chan->band = 1; 1804 break; 1805 case NL80211_BAND_6GHZ: 1806 chan->band = 3; 1807 break; 1808 default: 1809 chan->band = 2; 1810 break; 1811 } 1812 chan->channel_num = scan_list[i]->hw_value; 1813 } 1814 1815 if (sreq->ie_len > 0) { 1816 memcpy(req->ies, sreq->ie, sreq->ie_len); 1817 req->ies_len = cpu_to_le16(sreq->ie_len); 1818 } 1819 1820 if (is_mt7921(phy->dev)) 1821 req->scan_func |= SCAN_FUNC_SPLIT_SCAN; 1822 1823 memcpy(req->bssid, sreq->bssid, ETH_ALEN); 1824 if (sreq->flags & NL80211_SCAN_FLAG_RANDOM_ADDR) { 1825 get_random_mask_addr(req->random_mac, sreq->mac_addr, 1826 sreq->mac_addr_mask); 1827 req->scan_func |= SCAN_FUNC_RANDOM_MAC; 1828 } 1829 1830 err = mt76_mcu_skb_send_msg(mdev, skb, MCU_CE_CMD(START_HW_SCAN), 1831 false); 1832 if (err < 0) 1833 clear_bit(MT76_HW_SCANNING, &phy->state); 1834 1835 return err; 1836} 1837EXPORT_SYMBOL_GPL(mt76_connac_mcu_hw_scan); 1838 1839int mt76_connac_mcu_cancel_hw_scan(struct mt76_phy *phy, 1840 struct ieee80211_vif *vif) 1841{ 1842 struct mt76_vif_link *mvif = (struct mt76_vif_link *)vif->drv_priv; 1843 struct { 1844 u8 seq_num; 1845 u8 is_ext_channel; 1846 u8 rsv[2]; 1847 } __packed req = { 1848 .seq_num = mvif->scan_seq_num, 1849 }; 1850 1851 if (test_and_clear_bit(MT76_HW_SCANNING, &phy->state)) { 1852 struct cfg80211_scan_info info = { 1853 .aborted = true, 1854 }; 1855 1856 ieee80211_scan_completed(phy->hw, &info); 1857 } 1858 1859 return mt76_mcu_send_msg(phy->dev, MCU_CE_CMD(CANCEL_HW_SCAN), 1860 &req, sizeof(req), false); 1861} 1862EXPORT_SYMBOL_GPL(mt76_connac_mcu_cancel_hw_scan); 1863 1864int mt76_connac_mcu_sched_scan_req(struct mt76_phy *phy, 1865 struct ieee80211_vif *vif, 1866 struct cfg80211_sched_scan_request *sreq) 1867{ 1868 struct mt76_vif_link *mvif = (struct mt76_vif_link *)vif->drv_priv; 1869 struct ieee80211_channel **scan_list = sreq->channels; 1870 struct mt76_connac_mcu_scan_channel *chan; 1871 struct mt76_connac_sched_scan_req *req; 1872 struct mt76_dev *mdev = phy->dev; 1873 struct cfg80211_match_set *match; 1874 struct cfg80211_ssid *ssid; 1875 struct sk_buff *skb; 1876 int i; 1877 1878 skb = mt76_mcu_msg_alloc(mdev, NULL, sizeof(*req) + sreq->ie_len); 1879 if (!skb) 1880 return -ENOMEM; 1881 1882 mvif->scan_seq_num = (mvif->scan_seq_num + 1) & 0x7f; 1883 1884 req = (struct mt76_connac_sched_scan_req *)skb_put_zero(skb, sizeof(*req)); 1885 req->version = 1; 1886 req->seq_num = mvif->scan_seq_num | mvif->band_idx << 7; 1887 1888 if (sreq->flags & NL80211_SCAN_FLAG_RANDOM_ADDR) { 1889 u8 *addr = is_mt7663(phy->dev) ? req->mt7663.random_mac 1890 : req->mt7921.random_mac; 1891 1892 req->scan_func = 1; 1893 get_random_mask_addr(addr, sreq->mac_addr, 1894 sreq->mac_addr_mask); 1895 } 1896 if (is_mt7921(phy->dev)) { 1897 req->mt7921.bss_idx = mvif->idx; 1898 req->mt7921.delay = cpu_to_le32(sreq->delay); 1899 } 1900 1901 req->ssids_num = sreq->n_ssids; 1902 for (i = 0; i < req->ssids_num; i++) { 1903 ssid = &sreq->ssids[i]; 1904 memcpy(req->ssids[i].ssid, ssid->ssid, ssid->ssid_len); 1905 req->ssids[i].ssid_len = cpu_to_le32(ssid->ssid_len); 1906 } 1907 1908 req->match_num = sreq->n_match_sets; 1909 for (i = 0; i < req->match_num; i++) { 1910 match = &sreq->match_sets[i]; 1911 memcpy(req->match[i].ssid, match->ssid.ssid, 1912 match->ssid.ssid_len); 1913 req->match[i].rssi_th = cpu_to_le32(match->rssi_thold); 1914 req->match[i].ssid_len = match->ssid.ssid_len; 1915 } 1916 1917 req->channel_type = sreq->n_channels ? 4 : 0; 1918 req->channels_num = min_t(u8, sreq->n_channels, 64); 1919 for (i = 0; i < req->channels_num; i++) { 1920 chan = &req->channels[i]; 1921 1922 switch (scan_list[i]->band) { 1923 case NL80211_BAND_2GHZ: 1924 chan->band = 1; 1925 break; 1926 case NL80211_BAND_6GHZ: 1927 chan->band = 3; 1928 break; 1929 default: 1930 chan->band = 2; 1931 break; 1932 } 1933 chan->channel_num = scan_list[i]->hw_value; 1934 } 1935 1936 req->intervals_num = sreq->n_scan_plans; 1937 for (i = 0; i < req->intervals_num; i++) 1938 req->intervals[i] = cpu_to_le16(sreq->scan_plans[i].interval); 1939 1940 if (sreq->ie_len > 0) { 1941 req->ie_len = cpu_to_le16(sreq->ie_len); 1942 memcpy(skb_put(skb, sreq->ie_len), sreq->ie, sreq->ie_len); 1943 } 1944 1945 return mt76_mcu_skb_send_msg(mdev, skb, MCU_CE_CMD(SCHED_SCAN_REQ), 1946 false); 1947} 1948EXPORT_SYMBOL_GPL(mt76_connac_mcu_sched_scan_req); 1949 1950int mt76_connac_mcu_sched_scan_enable(struct mt76_phy *phy, 1951 struct ieee80211_vif *vif, 1952 bool enable) 1953{ 1954 struct { 1955 u8 active; /* 0: enabled 1: disabled */ 1956 u8 rsv[3]; 1957 } __packed req = { 1958 .active = !enable, 1959 }; 1960 1961 if (enable) 1962 set_bit(MT76_HW_SCHED_SCANNING, &phy->state); 1963 else 1964 clear_bit(MT76_HW_SCHED_SCANNING, &phy->state); 1965 1966 return mt76_mcu_send_msg(phy->dev, MCU_CE_CMD(SCHED_SCAN_ENABLE), 1967 &req, sizeof(req), false); 1968} 1969EXPORT_SYMBOL_GPL(mt76_connac_mcu_sched_scan_enable); 1970 1971int mt76_connac_mcu_chip_config(struct mt76_dev *dev) 1972{ 1973 struct mt76_connac_config req = { 1974 .resp_type = 0, 1975 }; 1976 1977 strscpy(req.data, "assert"); 1978 1979 return mt76_mcu_send_msg(dev, MCU_CE_CMD(CHIP_CONFIG), 1980 &req, sizeof(req), false); 1981} 1982EXPORT_SYMBOL_GPL(mt76_connac_mcu_chip_config); 1983 1984int mt76_connac_mcu_set_deep_sleep(struct mt76_dev *dev, bool enable) 1985{ 1986 struct mt76_connac_config req = { 1987 .resp_type = 0, 1988 }; 1989 1990 snprintf(req.data, sizeof(req.data), "KeepFullPwr %d", !enable); 1991 1992 return mt76_mcu_send_msg(dev, MCU_CE_CMD(CHIP_CONFIG), 1993 &req, sizeof(req), false); 1994} 1995EXPORT_SYMBOL_GPL(mt76_connac_mcu_set_deep_sleep); 1996 1997int mt76_connac_sta_state_dp(struct mt76_dev *dev, 1998 enum ieee80211_sta_state old_state, 1999 enum ieee80211_sta_state new_state) 2000{ 2001 if ((old_state == IEEE80211_STA_ASSOC && 2002 new_state == IEEE80211_STA_AUTHORIZED) || 2003 (old_state == IEEE80211_STA_NONE && 2004 new_state == IEEE80211_STA_NOTEXIST)) 2005 mt76_connac_mcu_set_deep_sleep(dev, true); 2006 2007 if ((old_state == IEEE80211_STA_NOTEXIST && 2008 new_state == IEEE80211_STA_NONE) || 2009 (old_state == IEEE80211_STA_AUTHORIZED && 2010 new_state == IEEE80211_STA_ASSOC)) 2011 mt76_connac_mcu_set_deep_sleep(dev, false); 2012 2013 return 0; 2014} 2015EXPORT_SYMBOL_GPL(mt76_connac_sta_state_dp); 2016 2017void mt76_connac_mcu_coredump_event(struct mt76_dev *dev, struct sk_buff *skb, 2018 struct mt76_connac_coredump *coredump) 2019{ 2020 spin_lock_bh(&dev->lock); 2021 __skb_queue_tail(&coredump->msg_list, skb); 2022 spin_unlock_bh(&dev->lock); 2023 2024 coredump->last_activity = jiffies; 2025 2026 queue_delayed_work(dev->wq, &coredump->work, 2027 MT76_CONNAC_COREDUMP_TIMEOUT); 2028} 2029EXPORT_SYMBOL_GPL(mt76_connac_mcu_coredump_event); 2030 2031static void 2032mt76_connac_mcu_build_sku(struct mt76_dev *dev, s8 *sku, 2033 struct mt76_power_limits *limits, 2034 enum nl80211_band band) 2035{ 2036 int max_power = is_mt7921(dev) ? 127 : 63; 2037 int i, offset = sizeof(limits->cck); 2038 2039 memset(sku, max_power, MT_SKU_POWER_LIMIT); 2040 2041 if (band == NL80211_BAND_2GHZ) { 2042 /* cck */ 2043 memcpy(sku, limits->cck, sizeof(limits->cck)); 2044 } 2045 2046 /* ofdm */ 2047 memcpy(&sku[offset], limits->ofdm, sizeof(limits->ofdm)); 2048 offset += sizeof(limits->ofdm); 2049 2050 /* ht */ 2051 for (i = 0; i < 2; i++) { 2052 memcpy(&sku[offset], limits->mcs[i], 8); 2053 offset += 8; 2054 } 2055 sku[offset++] = limits->mcs[0][0]; 2056 2057 /* vht */ 2058 for (i = 0; i < ARRAY_SIZE(limits->mcs); i++) { 2059 memcpy(&sku[offset], limits->mcs[i], 2060 ARRAY_SIZE(limits->mcs[i])); 2061 offset += 12; 2062 } 2063 2064 if (!is_mt7921(dev)) 2065 return; 2066 2067 /* he */ 2068 for (i = 0; i < ARRAY_SIZE(limits->ru); i++) { 2069 memcpy(&sku[offset], limits->ru[i], ARRAY_SIZE(limits->ru[i])); 2070 offset += ARRAY_SIZE(limits->ru[i]); 2071 } 2072} 2073 2074s8 mt76_connac_get_ch_power(struct mt76_phy *phy, 2075 struct ieee80211_channel *chan, 2076 s8 target_power) 2077{ 2078 struct mt76_dev *dev = phy->dev; 2079 struct ieee80211_supported_band *sband; 2080 int i; 2081 2082 switch (chan->band) { 2083 case NL80211_BAND_2GHZ: 2084 sband = &phy->sband_2g.sband; 2085 break; 2086 case NL80211_BAND_5GHZ: 2087 sband = &phy->sband_5g.sband; 2088 break; 2089 case NL80211_BAND_6GHZ: 2090 sband = &phy->sband_6g.sband; 2091 break; 2092 default: 2093 return target_power; 2094 } 2095 2096 for (i = 0; i < sband->n_channels; i++) { 2097 struct ieee80211_channel *ch = &sband->channels[i]; 2098 2099 if (ch->hw_value == chan->hw_value) { 2100 if (!(ch->flags & IEEE80211_CHAN_DISABLED)) { 2101 int power = 2 * ch->max_reg_power; 2102 2103 if (is_mt7663(dev) && (power > 63 || power < -64)) 2104 power = 63; 2105 target_power = min_t(s8, power, target_power); 2106 } 2107 break; 2108 } 2109 } 2110 2111 return target_power; 2112} 2113EXPORT_SYMBOL_GPL(mt76_connac_get_ch_power); 2114 2115static int 2116mt76_connac_mcu_rate_txpower_band(struct mt76_phy *phy, 2117 enum nl80211_band band) 2118{ 2119 struct mt76_dev *dev = phy->dev; 2120 int sku_len, batch_len = is_mt7921(dev) ? 8 : 16; 2121 static const u8 chan_list_2ghz[] = { 2122 1, 2, 3, 4, 5, 6, 7, 2123 8, 9, 10, 11, 12, 13, 14 2124 }; 2125 static const u8 chan_list_5ghz[] = { 2126 36, 38, 40, 42, 44, 46, 48, 2127 50, 52, 54, 56, 58, 60, 62, 2128 64, 100, 102, 104, 106, 108, 110, 2129 112, 114, 116, 118, 120, 122, 124, 2130 126, 128, 132, 134, 136, 138, 140, 2131 142, 144, 149, 151, 153, 155, 157, 2132 159, 161, 165, 169, 173, 177 2133 }; 2134 static const u8 chan_list_6ghz[] = { 2135 1, 3, 5, 7, 9, 11, 13, 2136 15, 17, 19, 21, 23, 25, 27, 2137 29, 33, 35, 37, 39, 41, 43, 2138 45, 47, 49, 51, 53, 55, 57, 2139 59, 61, 65, 67, 69, 71, 73, 2140 75, 77, 79, 81, 83, 85, 87, 2141 89, 91, 93, 97, 99, 101, 103, 2142 105, 107, 109, 111, 113, 115, 117, 2143 119, 121, 123, 125, 129, 131, 133, 2144 135, 137, 139, 141, 143, 145, 147, 2145 149, 151, 153, 155, 157, 161, 163, 2146 165, 167, 169, 171, 173, 175, 177, 2147 179, 181, 183, 185, 187, 189, 193, 2148 195, 197, 199, 201, 203, 205, 207, 2149 209, 211, 213, 215, 217, 219, 221, 2150 225, 227, 229, 233 2151 }; 2152 int i, n_chan, batch_size, idx = 0, tx_power, last_ch, err = 0; 2153 struct mt76_connac_sku_tlv sku_tlbv; 2154 struct mt76_power_limits *limits; 2155 const u8 *ch_list; 2156 2157 limits = devm_kmalloc(dev->dev, sizeof(*limits), GFP_KERNEL); 2158 if (!limits) 2159 return -ENOMEM; 2160 2161 sku_len = is_mt7921(dev) ? sizeof(sku_tlbv) : sizeof(sku_tlbv) - 92; 2162 tx_power = 2 * phy->hw->conf.power_level; 2163 if (!tx_power) 2164 tx_power = 127; 2165 2166 if (band == NL80211_BAND_2GHZ) { 2167 n_chan = ARRAY_SIZE(chan_list_2ghz); 2168 ch_list = chan_list_2ghz; 2169 } else if (band == NL80211_BAND_6GHZ) { 2170 n_chan = ARRAY_SIZE(chan_list_6ghz); 2171 ch_list = chan_list_6ghz; 2172 } else { 2173 n_chan = ARRAY_SIZE(chan_list_5ghz); 2174 ch_list = chan_list_5ghz; 2175 } 2176 batch_size = DIV_ROUND_UP(n_chan, batch_len); 2177 2178 if (phy->cap.has_6ghz) 2179 last_ch = chan_list_6ghz[ARRAY_SIZE(chan_list_6ghz) - 1]; 2180 else if (phy->cap.has_5ghz) 2181 last_ch = chan_list_5ghz[ARRAY_SIZE(chan_list_5ghz) - 1]; 2182 else 2183 last_ch = chan_list_2ghz[ARRAY_SIZE(chan_list_2ghz) - 1]; 2184 2185 for (i = 0; i < batch_size; i++) { 2186 struct mt76_connac_tx_power_limit_tlv tx_power_tlv = {}; 2187 int j, msg_len, num_ch; 2188 struct sk_buff *skb; 2189 2190 num_ch = i == batch_size - 1 ? n_chan - i * batch_len : batch_len; 2191 msg_len = sizeof(tx_power_tlv) + num_ch * sizeof(sku_tlbv); 2192 skb = mt76_mcu_msg_alloc(dev, NULL, msg_len); 2193 if (!skb) { 2194 err = -ENOMEM; 2195 goto out; 2196 } 2197 2198 skb_reserve(skb, sizeof(tx_power_tlv)); 2199 2200 BUILD_BUG_ON(sizeof(dev->alpha2) > sizeof(tx_power_tlv.alpha2)); 2201 memcpy(tx_power_tlv.alpha2, dev->alpha2, sizeof(dev->alpha2)); 2202 tx_power_tlv.n_chan = num_ch; 2203 2204 switch (band) { 2205 case NL80211_BAND_2GHZ: 2206 tx_power_tlv.band = 1; 2207 break; 2208 case NL80211_BAND_6GHZ: 2209 tx_power_tlv.band = 3; 2210 break; 2211 default: 2212 tx_power_tlv.band = 2; 2213 break; 2214 } 2215 2216 for (j = 0; j < num_ch; j++, idx++) { 2217 struct ieee80211_channel chan = { 2218 .hw_value = ch_list[idx], 2219 .band = band, 2220 }; 2221 s8 reg_power, sar_power; 2222 2223 reg_power = mt76_connac_get_ch_power(phy, &chan, 2224 tx_power); 2225 sar_power = mt76_get_sar_power(phy, &chan, reg_power); 2226 2227 mt76_get_rate_power_limits(phy, &chan, limits, 2228 sar_power); 2229 2230 tx_power_tlv.last_msg = ch_list[idx] == last_ch; 2231 sku_tlbv.channel = ch_list[idx]; 2232 2233 mt76_connac_mcu_build_sku(dev, sku_tlbv.pwr_limit, 2234 limits, band); 2235 skb_put_data(skb, &sku_tlbv, sku_len); 2236 } 2237 __skb_push(skb, sizeof(tx_power_tlv)); 2238 memcpy(skb->data, &tx_power_tlv, sizeof(tx_power_tlv)); 2239 2240 err = mt76_mcu_skb_send_msg(dev, skb, 2241 MCU_CE_CMD(SET_RATE_TX_POWER), 2242 false); 2243 if (err < 0) 2244 goto out; 2245 } 2246 2247out: 2248 devm_kfree(dev->dev, limits); 2249 return err; 2250} 2251 2252int mt76_connac_mcu_set_rate_txpower(struct mt76_phy *phy) 2253{ 2254 int err; 2255 2256 if (phy->cap.has_2ghz) { 2257 err = mt76_connac_mcu_rate_txpower_band(phy, 2258 NL80211_BAND_2GHZ); 2259 if (err < 0) 2260 return err; 2261 } 2262 if (phy->cap.has_5ghz) { 2263 err = mt76_connac_mcu_rate_txpower_band(phy, 2264 NL80211_BAND_5GHZ); 2265 if (err < 0) 2266 return err; 2267 } 2268 if (phy->cap.has_6ghz) { 2269 err = mt76_connac_mcu_rate_txpower_band(phy, 2270 NL80211_BAND_6GHZ); 2271 if (err < 0) 2272 return err; 2273 } 2274 2275 return 0; 2276} 2277EXPORT_SYMBOL_GPL(mt76_connac_mcu_set_rate_txpower); 2278 2279int mt76_connac_mcu_update_arp_filter(struct mt76_dev *dev, 2280 struct mt76_vif_link *vif, 2281 struct ieee80211_bss_conf *info) 2282{ 2283 struct ieee80211_vif *mvif = container_of(info, struct ieee80211_vif, 2284 bss_conf); 2285 struct sk_buff *skb; 2286 int i, len = min_t(int, mvif->cfg.arp_addr_cnt, 2287 IEEE80211_BSS_ARP_ADDR_LIST_LEN); 2288 struct { 2289 struct { 2290 u8 bss_idx; 2291 u8 pad[3]; 2292 } __packed hdr; 2293 struct mt76_connac_arpns_tlv arp; 2294 } req_hdr = { 2295 .hdr = { 2296 .bss_idx = vif->idx, 2297 }, 2298 .arp = { 2299 .tag = cpu_to_le16(UNI_OFFLOAD_OFFLOAD_ARP), 2300 .len = cpu_to_le16(sizeof(struct mt76_connac_arpns_tlv)), 2301 .ips_num = len, 2302 .mode = 2, /* update */ 2303 .option = 1, 2304 }, 2305 }; 2306 2307 skb = mt76_mcu_msg_alloc(dev, NULL, 2308 sizeof(req_hdr) + len * sizeof(__be32)); 2309 if (!skb) 2310 return -ENOMEM; 2311 2312 skb_put_data(skb, &req_hdr, sizeof(req_hdr)); 2313 for (i = 0; i < len; i++) 2314 skb_put_data(skb, &mvif->cfg.arp_addr_list[i], sizeof(__be32)); 2315 2316 return mt76_mcu_skb_send_msg(dev, skb, MCU_UNI_CMD(OFFLOAD), true); 2317} 2318EXPORT_SYMBOL_GPL(mt76_connac_mcu_update_arp_filter); 2319 2320int mt76_connac_mcu_set_p2p_oppps(struct ieee80211_hw *hw, 2321 struct ieee80211_vif *vif) 2322{ 2323 struct mt76_vif_link *mvif = (struct mt76_vif_link *)vif->drv_priv; 2324 int ct_window = vif->bss_conf.p2p_noa_attr.oppps_ctwindow; 2325 struct mt76_phy *phy = hw->priv; 2326 struct { 2327 __le32 ct_win; 2328 u8 bss_idx; 2329 u8 rsv[3]; 2330 } __packed req = { 2331 .ct_win = cpu_to_le32(ct_window), 2332 .bss_idx = mvif->idx, 2333 }; 2334 2335 return mt76_mcu_send_msg(phy->dev, MCU_CE_CMD(SET_P2P_OPPPS), 2336 &req, sizeof(req), false); 2337} 2338EXPORT_SYMBOL_GPL(mt76_connac_mcu_set_p2p_oppps); 2339 2340#ifdef CONFIG_PM 2341 2342const struct wiphy_wowlan_support mt76_connac_wowlan_support = { 2343 .flags = WIPHY_WOWLAN_MAGIC_PKT | WIPHY_WOWLAN_DISCONNECT | 2344 WIPHY_WOWLAN_SUPPORTS_GTK_REKEY | WIPHY_WOWLAN_NET_DETECT, 2345 .n_patterns = 1, 2346 .pattern_min_len = 1, 2347 .pattern_max_len = MT76_CONNAC_WOW_PATTEN_MAX_LEN, 2348 .max_nd_match_sets = 10, 2349}; 2350EXPORT_SYMBOL_GPL(mt76_connac_wowlan_support); 2351 2352static void 2353mt76_connac_mcu_key_iter(struct ieee80211_hw *hw, 2354 struct ieee80211_vif *vif, 2355 struct ieee80211_sta *sta, 2356 struct ieee80211_key_conf *key, 2357 void *data) 2358{ 2359 struct mt76_connac_gtk_rekey_tlv *gtk_tlv = data; 2360 u32 cipher; 2361 2362 if (key->cipher != WLAN_CIPHER_SUITE_AES_CMAC && 2363 key->cipher != WLAN_CIPHER_SUITE_CCMP && 2364 key->cipher != WLAN_CIPHER_SUITE_TKIP) 2365 return; 2366 2367 if (key->cipher == WLAN_CIPHER_SUITE_TKIP) 2368 cipher = BIT(3); 2369 else 2370 cipher = BIT(4); 2371 2372 /* we are assuming here to have a single pairwise key */ 2373 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE) { 2374 if (key->cipher == WLAN_CIPHER_SUITE_TKIP) 2375 gtk_tlv->proto = cpu_to_le32(NL80211_WPA_VERSION_1); 2376 else 2377 gtk_tlv->proto = cpu_to_le32(NL80211_WPA_VERSION_2); 2378 2379 gtk_tlv->pairwise_cipher = cpu_to_le32(cipher); 2380 gtk_tlv->keyid = key->keyidx; 2381 } else { 2382 gtk_tlv->group_cipher = cpu_to_le32(cipher); 2383 } 2384} 2385 2386int mt76_connac_mcu_update_gtk_rekey(struct ieee80211_hw *hw, 2387 struct ieee80211_vif *vif, 2388 struct cfg80211_gtk_rekey_data *key) 2389{ 2390 struct mt76_vif_link *mvif = (struct mt76_vif_link *)vif->drv_priv; 2391 struct mt76_connac_gtk_rekey_tlv *gtk_tlv; 2392 struct mt76_phy *phy = hw->priv; 2393 struct sk_buff *skb; 2394 struct { 2395 u8 bss_idx; 2396 u8 pad[3]; 2397 } __packed hdr = { 2398 .bss_idx = mvif->idx, 2399 }; 2400 2401 skb = mt76_mcu_msg_alloc(phy->dev, NULL, 2402 sizeof(hdr) + sizeof(*gtk_tlv)); 2403 if (!skb) 2404 return -ENOMEM; 2405 2406 skb_put_data(skb, &hdr, sizeof(hdr)); 2407 gtk_tlv = (struct mt76_connac_gtk_rekey_tlv *)skb_put_zero(skb, 2408 sizeof(*gtk_tlv)); 2409 gtk_tlv->tag = cpu_to_le16(UNI_OFFLOAD_OFFLOAD_GTK_REKEY); 2410 gtk_tlv->len = cpu_to_le16(sizeof(*gtk_tlv)); 2411 gtk_tlv->rekey_mode = 2; 2412 gtk_tlv->option = 1; 2413 2414 rcu_read_lock(); 2415 ieee80211_iter_keys_rcu(hw, vif, mt76_connac_mcu_key_iter, gtk_tlv); 2416 rcu_read_unlock(); 2417 2418 memcpy(gtk_tlv->kek, key->kek, NL80211_KEK_LEN); 2419 memcpy(gtk_tlv->kck, key->kck, NL80211_KCK_LEN); 2420 memcpy(gtk_tlv->replay_ctr, key->replay_ctr, NL80211_REPLAY_CTR_LEN); 2421 2422 return mt76_mcu_skb_send_msg(phy->dev, skb, 2423 MCU_UNI_CMD(OFFLOAD), true); 2424} 2425EXPORT_SYMBOL_GPL(mt76_connac_mcu_update_gtk_rekey); 2426 2427static int 2428mt76_connac_mcu_set_arp_filter(struct mt76_dev *dev, struct ieee80211_vif *vif, 2429 bool suspend) 2430{ 2431 struct mt76_vif_link *mvif = (struct mt76_vif_link *)vif->drv_priv; 2432 struct { 2433 struct { 2434 u8 bss_idx; 2435 u8 pad[3]; 2436 } __packed hdr; 2437 struct mt76_connac_arpns_tlv arpns; 2438 } req = { 2439 .hdr = { 2440 .bss_idx = mvif->idx, 2441 }, 2442 .arpns = { 2443 .tag = cpu_to_le16(UNI_OFFLOAD_OFFLOAD_ARP), 2444 .len = cpu_to_le16(sizeof(struct mt76_connac_arpns_tlv)), 2445 .mode = suspend, 2446 }, 2447 }; 2448 2449 return mt76_mcu_send_msg(dev, MCU_UNI_CMD(OFFLOAD), &req, 2450 sizeof(req), true); 2451} 2452 2453int 2454mt76_connac_mcu_set_gtk_rekey(struct mt76_dev *dev, struct ieee80211_vif *vif, 2455 bool suspend) 2456{ 2457 struct mt76_vif_link *mvif = (struct mt76_vif_link *)vif->drv_priv; 2458 struct { 2459 struct { 2460 u8 bss_idx; 2461 u8 pad[3]; 2462 } __packed hdr; 2463 struct mt76_connac_gtk_rekey_tlv gtk_tlv; 2464 } __packed req = { 2465 .hdr = { 2466 .bss_idx = mvif->idx, 2467 }, 2468 .gtk_tlv = { 2469 .tag = cpu_to_le16(UNI_OFFLOAD_OFFLOAD_GTK_REKEY), 2470 .len = cpu_to_le16(sizeof(struct mt76_connac_gtk_rekey_tlv)), 2471 .rekey_mode = !suspend, 2472 }, 2473 }; 2474 2475 return mt76_mcu_send_msg(dev, MCU_UNI_CMD(OFFLOAD), &req, 2476 sizeof(req), true); 2477} 2478EXPORT_SYMBOL_GPL(mt76_connac_mcu_set_gtk_rekey); 2479 2480int 2481mt76_connac_mcu_set_suspend_mode(struct mt76_dev *dev, 2482 struct ieee80211_vif *vif, 2483 bool enable, u8 mdtim, 2484 bool wow_suspend) 2485{ 2486 struct mt76_vif_link *mvif = (struct mt76_vif_link *)vif->drv_priv; 2487 struct { 2488 struct { 2489 u8 bss_idx; 2490 u8 pad[3]; 2491 } __packed hdr; 2492 struct mt76_connac_suspend_tlv suspend_tlv; 2493 } req = { 2494 .hdr = { 2495 .bss_idx = mvif->idx, 2496 }, 2497 .suspend_tlv = { 2498 .tag = cpu_to_le16(UNI_SUSPEND_MODE_SETTING), 2499 .len = cpu_to_le16(sizeof(struct mt76_connac_suspend_tlv)), 2500 .enable = enable, 2501 .mdtim = mdtim, 2502 .wow_suspend = wow_suspend, 2503 }, 2504 }; 2505 2506 return mt76_mcu_send_msg(dev, MCU_UNI_CMD(SUSPEND), &req, 2507 sizeof(req), true); 2508} 2509EXPORT_SYMBOL_GPL(mt76_connac_mcu_set_suspend_mode); 2510 2511static int 2512mt76_connac_mcu_set_wow_pattern(struct mt76_dev *dev, 2513 struct ieee80211_vif *vif, 2514 u8 index, bool enable, 2515 struct cfg80211_pkt_pattern *pattern) 2516{ 2517 struct mt76_vif_link *mvif = (struct mt76_vif_link *)vif->drv_priv; 2518 struct mt76_connac_wow_pattern_tlv *ptlv; 2519 struct sk_buff *skb; 2520 struct req_hdr { 2521 u8 bss_idx; 2522 u8 pad[3]; 2523 } __packed hdr = { 2524 .bss_idx = mvif->idx, 2525 }; 2526 2527 skb = mt76_mcu_msg_alloc(dev, NULL, sizeof(hdr) + sizeof(*ptlv)); 2528 if (!skb) 2529 return -ENOMEM; 2530 2531 skb_put_data(skb, &hdr, sizeof(hdr)); 2532 ptlv = (struct mt76_connac_wow_pattern_tlv *)skb_put_zero(skb, sizeof(*ptlv)); 2533 ptlv->tag = cpu_to_le16(UNI_SUSPEND_WOW_PATTERN); 2534 ptlv->len = cpu_to_le16(sizeof(*ptlv)); 2535 ptlv->data_len = pattern->pattern_len; 2536 ptlv->enable = enable; 2537 ptlv->index = index; 2538 2539 memcpy(ptlv->pattern, pattern->pattern, pattern->pattern_len); 2540 memcpy(ptlv->mask, pattern->mask, DIV_ROUND_UP(pattern->pattern_len, 8)); 2541 2542 return mt76_mcu_skb_send_msg(dev, skb, MCU_UNI_CMD(SUSPEND), true); 2543} 2544 2545int 2546mt76_connac_mcu_set_wow_ctrl(struct mt76_phy *phy, struct ieee80211_vif *vif, 2547 bool suspend, struct cfg80211_wowlan *wowlan) 2548{ 2549 struct mt76_vif_link *mvif = (struct mt76_vif_link *)vif->drv_priv; 2550 struct mt76_dev *dev = phy->dev; 2551 struct { 2552 struct { 2553 u8 bss_idx; 2554 u8 pad[3]; 2555 } __packed hdr; 2556 struct mt76_connac_wow_ctrl_tlv wow_ctrl_tlv; 2557 struct mt76_connac_wow_gpio_param_tlv gpio_tlv; 2558 } req = { 2559 .hdr = { 2560 .bss_idx = mvif->idx, 2561 }, 2562 .wow_ctrl_tlv = { 2563 .tag = cpu_to_le16(UNI_SUSPEND_WOW_CTRL), 2564 .len = cpu_to_le16(sizeof(struct mt76_connac_wow_ctrl_tlv)), 2565 .cmd = suspend ? 1 : 2, 2566 }, 2567 .gpio_tlv = { 2568 .tag = cpu_to_le16(UNI_SUSPEND_WOW_GPIO_PARAM), 2569 .len = cpu_to_le16(sizeof(struct mt76_connac_wow_gpio_param_tlv)), 2570 .gpio_pin = 0xff, /* follow fw about GPIO pin */ 2571 }, 2572 }; 2573 2574 if (wowlan->magic_pkt) 2575 req.wow_ctrl_tlv.trigger |= UNI_WOW_DETECT_TYPE_MAGIC; 2576 if (wowlan->disconnect) 2577 req.wow_ctrl_tlv.trigger |= (UNI_WOW_DETECT_TYPE_DISCONNECT | 2578 UNI_WOW_DETECT_TYPE_BCN_LOST); 2579 if (wowlan->nd_config) { 2580 mt76_connac_mcu_sched_scan_req(phy, vif, wowlan->nd_config); 2581 req.wow_ctrl_tlv.trigger |= UNI_WOW_DETECT_TYPE_SCH_SCAN_HIT; 2582 mt76_connac_mcu_sched_scan_enable(phy, vif, suspend); 2583 } 2584 if (wowlan->n_patterns) 2585 req.wow_ctrl_tlv.trigger |= UNI_WOW_DETECT_TYPE_BITMAP; 2586 2587 if (mt76_is_mmio(dev)) 2588 req.wow_ctrl_tlv.wakeup_hif = WOW_PCIE; 2589 else if (mt76_is_usb(dev)) 2590 req.wow_ctrl_tlv.wakeup_hif = WOW_USB; 2591 else if (mt76_is_sdio(dev)) 2592 req.wow_ctrl_tlv.wakeup_hif = WOW_GPIO; 2593 2594 return mt76_mcu_send_msg(dev, MCU_UNI_CMD(SUSPEND), &req, 2595 sizeof(req), true); 2596} 2597EXPORT_SYMBOL_GPL(mt76_connac_mcu_set_wow_ctrl); 2598 2599int mt76_connac_mcu_set_hif_suspend(struct mt76_dev *dev, bool suspend, bool wait_resp) 2600{ 2601 struct { 2602 struct { 2603 u8 hif_type; /* 0x0: HIF_SDIO 2604 * 0x1: HIF_USB 2605 * 0x2: HIF_PCIE 2606 */ 2607 u8 pad[3]; 2608 } __packed hdr; 2609 struct hif_suspend_tlv { 2610 __le16 tag; 2611 __le16 len; 2612 u8 suspend; 2613 u8 pad[7]; 2614 } __packed hif_suspend; 2615 } req = { 2616 .hif_suspend = { 2617 .tag = cpu_to_le16(0), /* 0: UNI_HIF_CTRL_BASIC */ 2618 .len = cpu_to_le16(sizeof(struct hif_suspend_tlv)), 2619 .suspend = suspend, 2620 }, 2621 }; 2622 2623 if (mt76_is_mmio(dev)) 2624 req.hdr.hif_type = 2; 2625 else if (mt76_is_usb(dev)) 2626 req.hdr.hif_type = 1; 2627 else if (mt76_is_sdio(dev)) 2628 req.hdr.hif_type = 0; 2629 2630 return mt76_mcu_send_msg(dev, MCU_UNI_CMD(HIF_CTRL), &req, 2631 sizeof(req), wait_resp); 2632} 2633EXPORT_SYMBOL_GPL(mt76_connac_mcu_set_hif_suspend); 2634 2635void mt76_connac_mcu_set_suspend_iter(void *priv, u8 *mac, 2636 struct ieee80211_vif *vif) 2637{ 2638 struct mt76_phy *phy = priv; 2639 bool suspend = !test_bit(MT76_STATE_RUNNING, &phy->state); 2640 struct ieee80211_hw *hw = phy->hw; 2641 struct cfg80211_wowlan *wowlan = hw->wiphy->wowlan_config; 2642 int i; 2643 2644 mt76_connac_mcu_set_gtk_rekey(phy->dev, vif, suspend); 2645 mt76_connac_mcu_set_arp_filter(phy->dev, vif, suspend); 2646 2647 mt76_connac_mcu_set_suspend_mode(phy->dev, vif, suspend, 1, true); 2648 2649 for (i = 0; i < wowlan->n_patterns; i++) 2650 mt76_connac_mcu_set_wow_pattern(phy->dev, vif, i, suspend, 2651 &wowlan->patterns[i]); 2652 mt76_connac_mcu_set_wow_ctrl(phy, vif, suspend, wowlan); 2653} 2654EXPORT_SYMBOL_GPL(mt76_connac_mcu_set_suspend_iter); 2655#endif /* CONFIG_PM */ 2656 2657u32 mt76_connac_mcu_reg_rr(struct mt76_dev *dev, u32 offset) 2658{ 2659 struct { 2660 __le32 addr; 2661 __le32 val; 2662 } __packed req = { 2663 .addr = cpu_to_le32(offset), 2664 }; 2665 2666 return mt76_mcu_send_msg(dev, MCU_CE_QUERY(REG_READ), &req, 2667 sizeof(req), true); 2668} 2669EXPORT_SYMBOL_GPL(mt76_connac_mcu_reg_rr); 2670 2671void mt76_connac_mcu_reg_wr(struct mt76_dev *dev, u32 offset, u32 val) 2672{ 2673 struct { 2674 __le32 addr; 2675 __le32 val; 2676 } __packed req = { 2677 .addr = cpu_to_le32(offset), 2678 .val = cpu_to_le32(val), 2679 }; 2680 2681 mt76_mcu_send_msg(dev, MCU_CE_CMD(REG_WRITE), &req, 2682 sizeof(req), false); 2683} 2684EXPORT_SYMBOL_GPL(mt76_connac_mcu_reg_wr); 2685 2686static int 2687mt76_connac_mcu_sta_key_tlv(struct mt76_connac_sta_key_conf *sta_key_conf, 2688 struct sk_buff *skb, 2689 struct ieee80211_key_conf *key, 2690 enum set_key_cmd cmd) 2691{ 2692 struct sta_rec_sec *sec; 2693 u32 len = sizeof(*sec); 2694 struct tlv *tlv; 2695 2696 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_KEY_V2, sizeof(*sec)); 2697 sec = (struct sta_rec_sec *)tlv; 2698 sec->add = cmd; 2699 2700 if (cmd == SET_KEY) { 2701 struct sec_key *sec_key; 2702 u8 cipher; 2703 2704 cipher = mt76_connac_mcu_get_cipher(key->cipher); 2705 if (cipher == MCU_CIPHER_NONE) 2706 return -EOPNOTSUPP; 2707 2708 sec_key = &sec->key[0]; 2709 sec_key->cipher_len = sizeof(*sec_key); 2710 2711 if (cipher == MCU_CIPHER_BIP_CMAC_128) { 2712 sec_key->cipher_id = MCU_CIPHER_AES_CCMP; 2713 sec_key->key_id = sta_key_conf->keyidx; 2714 sec_key->key_len = 16; 2715 memcpy(sec_key->key, sta_key_conf->key, 16); 2716 2717 sec_key = &sec->key[1]; 2718 sec_key->cipher_id = MCU_CIPHER_BIP_CMAC_128; 2719 sec_key->cipher_len = sizeof(*sec_key); 2720 sec_key->key_len = 16; 2721 memcpy(sec_key->key, key->key, 16); 2722 sec->n_cipher = 2; 2723 } else { 2724 sec_key->cipher_id = cipher; 2725 sec_key->key_id = key->keyidx; 2726 sec_key->key_len = key->keylen; 2727 memcpy(sec_key->key, key->key, key->keylen); 2728 2729 if (cipher == MCU_CIPHER_TKIP) { 2730 /* Rx/Tx MIC keys are swapped */ 2731 memcpy(sec_key->key + 16, key->key + 24, 8); 2732 memcpy(sec_key->key + 24, key->key + 16, 8); 2733 } 2734 2735 /* store key_conf for BIP batch update */ 2736 if (cipher == MCU_CIPHER_AES_CCMP) { 2737 memcpy(sta_key_conf->key, key->key, key->keylen); 2738 sta_key_conf->keyidx = key->keyidx; 2739 } 2740 2741 len -= sizeof(*sec_key); 2742 sec->n_cipher = 1; 2743 } 2744 } else { 2745 len -= sizeof(sec->key); 2746 sec->n_cipher = 0; 2747 } 2748 sec->len = cpu_to_le16(len); 2749 2750 return 0; 2751} 2752 2753int mt76_connac_mcu_add_key(struct mt76_dev *dev, struct ieee80211_vif *vif, 2754 struct mt76_connac_sta_key_conf *sta_key_conf, 2755 struct ieee80211_key_conf *key, int mcu_cmd, 2756 struct mt76_wcid *wcid, enum set_key_cmd cmd) 2757{ 2758 struct mt76_vif_link *mvif = (struct mt76_vif_link *)vif->drv_priv; 2759 struct sk_buff *skb; 2760 int ret; 2761 2762 skb = mt76_connac_mcu_alloc_sta_req(dev, mvif, wcid); 2763 if (IS_ERR(skb)) 2764 return PTR_ERR(skb); 2765 2766 ret = mt76_connac_mcu_sta_key_tlv(sta_key_conf, skb, key, cmd); 2767 if (ret) 2768 return ret; 2769 2770 ret = mt76_connac_mcu_sta_wed_update(dev, skb); 2771 if (ret) 2772 return ret; 2773 2774 return mt76_mcu_skb_send_msg(dev, skb, mcu_cmd, true); 2775} 2776EXPORT_SYMBOL_GPL(mt76_connac_mcu_add_key); 2777 2778/* SIFS 20us + 512 byte beacon transmitted by 1Mbps (3906us) */ 2779#define BCN_TX_ESTIMATE_TIME (4096 + 20) 2780void mt76_connac_mcu_bss_ext_tlv(struct sk_buff *skb, struct mt76_vif_link *mvif) 2781{ 2782 struct bss_info_ext_bss *ext; 2783 int ext_bss_idx, tsf_offset; 2784 struct tlv *tlv; 2785 2786 ext_bss_idx = mvif->omac_idx - EXT_BSSID_START; 2787 if (ext_bss_idx < 0) 2788 return; 2789 2790 tlv = mt76_connac_mcu_add_tlv(skb, BSS_INFO_EXT_BSS, sizeof(*ext)); 2791 2792 ext = (struct bss_info_ext_bss *)tlv; 2793 tsf_offset = ext_bss_idx * BCN_TX_ESTIMATE_TIME; 2794 ext->mbss_tsf_offset = cpu_to_le32(tsf_offset); 2795} 2796EXPORT_SYMBOL_GPL(mt76_connac_mcu_bss_ext_tlv); 2797 2798int mt76_connac_mcu_bss_basic_tlv(struct sk_buff *skb, 2799 struct ieee80211_vif *vif, 2800 struct ieee80211_sta *sta, 2801 struct mt76_phy *phy, u16 wlan_idx, 2802 bool enable) 2803{ 2804 struct mt76_vif_link *mvif = (struct mt76_vif_link *)vif->drv_priv; 2805 u32 type = vif->p2p ? NETWORK_P2P : NETWORK_INFRA; 2806 struct bss_info_basic *bss; 2807 struct tlv *tlv; 2808 2809 tlv = mt76_connac_mcu_add_tlv(skb, BSS_INFO_BASIC, sizeof(*bss)); 2810 bss = (struct bss_info_basic *)tlv; 2811 2812 switch (vif->type) { 2813 case NL80211_IFTYPE_MESH_POINT: 2814 case NL80211_IFTYPE_MONITOR: 2815 break; 2816 case NL80211_IFTYPE_AP: 2817 if (ieee80211_hw_check(phy->hw, SUPPORTS_MULTI_BSSID)) { 2818 u8 bssid_id = vif->bss_conf.bssid_indicator; 2819 struct wiphy *wiphy = phy->hw->wiphy; 2820 2821 if (bssid_id > ilog2(wiphy->mbssid_max_interfaces)) 2822 return -EINVAL; 2823 2824 bss->non_tx_bssid = vif->bss_conf.bssid_index; 2825 bss->max_bssid = bssid_id; 2826 } 2827 break; 2828 case NL80211_IFTYPE_STATION: 2829 if (enable) { 2830 rcu_read_lock(); 2831 if (!sta) 2832 sta = ieee80211_find_sta(vif, 2833 vif->bss_conf.bssid); 2834 /* TODO: enable BSS_INFO_UAPSD & BSS_INFO_PM */ 2835 if (sta) { 2836 struct mt76_wcid *wcid; 2837 2838 wcid = (struct mt76_wcid *)sta->drv_priv; 2839 wlan_idx = wcid->idx; 2840 } 2841 rcu_read_unlock(); 2842 } 2843 break; 2844 case NL80211_IFTYPE_ADHOC: 2845 type = NETWORK_IBSS; 2846 break; 2847 default: 2848 WARN_ON(1); 2849 break; 2850 } 2851 2852 bss->network_type = cpu_to_le32(type); 2853 bss->bmc_wcid_lo = to_wcid_lo(wlan_idx); 2854 bss->bmc_wcid_hi = to_wcid_hi(wlan_idx); 2855 bss->wmm_idx = mvif->wmm_idx; 2856 bss->active = enable; 2857 bss->cipher = mvif->cipher; 2858 2859 if (vif->type != NL80211_IFTYPE_MONITOR) { 2860 struct cfg80211_chan_def *chandef = &phy->chandef; 2861 2862 memcpy(bss->bssid, vif->bss_conf.bssid, ETH_ALEN); 2863 bss->bcn_interval = cpu_to_le16(vif->bss_conf.beacon_int); 2864 bss->dtim_period = vif->bss_conf.dtim_period; 2865 bss->phy_mode = mt76_connac_get_phy_mode(phy, vif, 2866 chandef->chan->band, NULL); 2867 } else { 2868 memcpy(bss->bssid, phy->macaddr, ETH_ALEN); 2869 } 2870 2871 return 0; 2872} 2873EXPORT_SYMBOL_GPL(mt76_connac_mcu_bss_basic_tlv); 2874 2875#define ENTER_PM_STATE 1 2876#define EXIT_PM_STATE 2 2877int mt76_connac_mcu_set_pm(struct mt76_dev *dev, int band, int enter) 2878{ 2879 struct { 2880 u8 pm_number; 2881 u8 pm_state; 2882 u8 bssid[ETH_ALEN]; 2883 u8 dtim_period; 2884 u8 wlan_idx_lo; 2885 __le16 bcn_interval; 2886 __le32 aid; 2887 __le32 rx_filter; 2888 u8 band_idx; 2889 u8 wlan_idx_hi; 2890 u8 rsv[2]; 2891 __le32 feature; 2892 u8 omac_idx; 2893 u8 wmm_idx; 2894 u8 bcn_loss_cnt; 2895 u8 bcn_sp_duration; 2896 } __packed req = { 2897 .pm_number = 5, 2898 .pm_state = enter ? ENTER_PM_STATE : EXIT_PM_STATE, 2899 .band_idx = band, 2900 }; 2901 2902 return mt76_mcu_send_msg(dev, MCU_EXT_CMD(PM_STATE_CTRL), &req, 2903 sizeof(req), true); 2904} 2905EXPORT_SYMBOL_GPL(mt76_connac_mcu_set_pm); 2906 2907int mt76_connac_mcu_restart(struct mt76_dev *dev) 2908{ 2909 struct { 2910 u8 power_mode; 2911 u8 rsv[3]; 2912 } req = { 2913 .power_mode = 1, 2914 }; 2915 2916 return mt76_mcu_send_msg(dev, MCU_CMD(NIC_POWER_CTRL), &req, 2917 sizeof(req), false); 2918} 2919EXPORT_SYMBOL_GPL(mt76_connac_mcu_restart); 2920 2921int mt76_connac_mcu_del_wtbl_all(struct mt76_dev *dev) 2922{ 2923 struct wtbl_req_hdr req = { 2924 .operation = WTBL_RESET_ALL, 2925 }; 2926 2927 return mt76_mcu_send_msg(dev, MCU_EXT_CMD(WTBL_UPDATE), 2928 &req, sizeof(req), true); 2929} 2930EXPORT_SYMBOL_GPL(mt76_connac_mcu_del_wtbl_all); 2931 2932int mt76_connac_mcu_rdd_cmd(struct mt76_dev *dev, int cmd, u8 index, 2933 u8 rx_sel, u8 val) 2934{ 2935 struct { 2936 u8 ctrl; 2937 u8 rdd_idx; 2938 u8 rdd_rx_sel; 2939 u8 val; 2940 u8 rsv[4]; 2941 } __packed req = { 2942 .ctrl = cmd, 2943 .rdd_idx = index, 2944 .rdd_rx_sel = rx_sel, 2945 .val = val, 2946 }; 2947 2948 return mt76_mcu_send_msg(dev, MCU_EXT_CMD(SET_RDD_CTRL), &req, 2949 sizeof(req), true); 2950} 2951EXPORT_SYMBOL_GPL(mt76_connac_mcu_rdd_cmd); 2952 2953static int 2954mt76_connac_mcu_send_ram_firmware(struct mt76_dev *dev, 2955 const struct mt76_connac2_fw_trailer *hdr, 2956 const u8 *data, bool is_wa) 2957{ 2958 int i, offset = 0, max_len = mt76_is_sdio(dev) ? 2048 : 4096; 2959 u32 override = 0, option = 0; 2960 2961 for (i = 0; i < hdr->n_region; i++) { 2962 const struct mt76_connac2_fw_region *region; 2963 u32 len, addr, mode; 2964 int err; 2965 2966 region = (const void *)((const u8 *)hdr - 2967 (hdr->n_region - i) * sizeof(*region)); 2968 mode = mt76_connac_mcu_gen_dl_mode(dev, region->feature_set, 2969 is_wa); 2970 len = le32_to_cpu(region->len); 2971 addr = le32_to_cpu(region->addr); 2972 2973 if (region->feature_set & FW_FEATURE_NON_DL) 2974 goto next; 2975 2976 if (region->feature_set & FW_FEATURE_OVERRIDE_ADDR) 2977 override = addr; 2978 2979 err = mt76_connac_mcu_init_download(dev, addr, len, mode); 2980 if (err) { 2981 dev_err(dev->dev, "Download request failed\n"); 2982 return err; 2983 } 2984 2985 err = __mt76_mcu_send_firmware(dev, MCU_CMD(FW_SCATTER), 2986 data + offset, len, max_len); 2987 if (err) { 2988 dev_err(dev->dev, "Failed to send firmware.\n"); 2989 return err; 2990 } 2991 2992next: 2993 offset += len; 2994 } 2995 2996 if (override) 2997 option |= FW_START_OVERRIDE; 2998 if (is_wa) 2999 option |= FW_START_WORKING_PDA_CR4; 3000 3001 return mt76_connac_mcu_start_firmware(dev, override, option); 3002} 3003 3004int mt76_connac2_load_ram(struct mt76_dev *dev, const char *fw_wm, 3005 const char *fw_wa) 3006{ 3007 const struct mt76_connac2_fw_trailer *hdr; 3008 const struct firmware *fw; 3009 int ret; 3010 3011 ret = request_firmware(&fw, fw_wm, dev->dev); 3012 if (ret) 3013 return ret; 3014 3015 if (!fw || !fw->data || fw->size < sizeof(*hdr)) { 3016 dev_err(dev->dev, "Invalid firmware\n"); 3017 ret = -EINVAL; 3018 goto out; 3019 } 3020 3021 hdr = (const void *)(fw->data + fw->size - sizeof(*hdr)); 3022 dev_info(dev->dev, "WM Firmware Version: %.10s, Build Time: %.15s", 3023 hdr->fw_ver, hdr->build_date); 3024 3025 ret = mt76_connac_mcu_send_ram_firmware(dev, hdr, fw->data, false); 3026 if (ret) { 3027 dev_err(dev->dev, "Failed to start WM firmware\n"); 3028 goto out; 3029 } 3030 3031 snprintf(dev->hw->wiphy->fw_version, 3032 sizeof(dev->hw->wiphy->fw_version), 3033 "%.10s-%.15s", hdr->fw_ver, hdr->build_date); 3034 3035 release_firmware(fw); 3036 3037 if (!fw_wa) 3038 return 0; 3039 3040 ret = request_firmware(&fw, fw_wa, dev->dev); 3041 if (ret) 3042 return ret; 3043 3044 if (!fw || !fw->data || fw->size < sizeof(*hdr)) { 3045 dev_err(dev->dev, "Invalid firmware\n"); 3046 ret = -EINVAL; 3047 goto out; 3048 } 3049 3050 hdr = (const void *)(fw->data + fw->size - sizeof(*hdr)); 3051 dev_info(dev->dev, "WA Firmware Version: %.10s, Build Time: %.15s", 3052 hdr->fw_ver, hdr->build_date); 3053 3054 ret = mt76_connac_mcu_send_ram_firmware(dev, hdr, fw->data, true); 3055 if (ret) { 3056 dev_err(dev->dev, "Failed to start WA firmware\n"); 3057 goto out; 3058 } 3059 3060 snprintf(dev->hw->wiphy->fw_version, 3061 sizeof(dev->hw->wiphy->fw_version), 3062 "%.10s-%.15s", hdr->fw_ver, hdr->build_date); 3063 3064out: 3065 release_firmware(fw); 3066 3067 return ret; 3068} 3069EXPORT_SYMBOL_GPL(mt76_connac2_load_ram); 3070 3071static u32 mt76_connac2_get_data_mode(struct mt76_dev *dev, u32 info) 3072{ 3073 u32 mode = DL_MODE_NEED_RSP; 3074 3075 if ((!is_mt7921(dev) && !is_mt7925(dev)) || info == PATCH_SEC_NOT_SUPPORT) 3076 return mode; 3077 3078 switch (FIELD_GET(PATCH_SEC_ENC_TYPE_MASK, info)) { 3079 case PATCH_SEC_ENC_TYPE_PLAIN: 3080 break; 3081 case PATCH_SEC_ENC_TYPE_AES: 3082 mode |= DL_MODE_ENCRYPT; 3083 mode |= FIELD_PREP(DL_MODE_KEY_IDX, 3084 (info & PATCH_SEC_ENC_AES_KEY_MASK)) & DL_MODE_KEY_IDX; 3085 mode |= DL_MODE_RESET_SEC_IV; 3086 break; 3087 case PATCH_SEC_ENC_TYPE_SCRAMBLE: 3088 mode |= DL_MODE_ENCRYPT; 3089 mode |= DL_CONFIG_ENCRY_MODE_SEL; 3090 mode |= DL_MODE_RESET_SEC_IV; 3091 break; 3092 default: 3093 dev_err(dev->dev, "Encryption type not support!\n"); 3094 } 3095 3096 return mode; 3097} 3098 3099int mt76_connac2_load_patch(struct mt76_dev *dev, const char *fw_name) 3100{ 3101 int i, ret, sem, max_len = mt76_is_sdio(dev) ? 2048 : 4096; 3102 const struct mt76_connac2_patch_hdr *hdr; 3103 const struct firmware *fw = NULL; 3104 3105 sem = mt76_connac_mcu_patch_sem_ctrl(dev, true); 3106 switch (sem) { 3107 case PATCH_IS_DL: 3108 return 0; 3109 case PATCH_NOT_DL_SEM_SUCCESS: 3110 break; 3111 default: 3112 dev_err(dev->dev, "Failed to get patch semaphore\n"); 3113 return -EAGAIN; 3114 } 3115 3116 ret = request_firmware(&fw, fw_name, dev->dev); 3117 if (ret) 3118 goto out; 3119 3120 if (!fw || !fw->data || fw->size < sizeof(*hdr)) { 3121 dev_err(dev->dev, "Invalid firmware\n"); 3122 ret = -EINVAL; 3123 goto out; 3124 } 3125 3126 hdr = (const void *)fw->data; 3127 dev_info(dev->dev, "HW/SW Version: 0x%x, Build Time: %.16s", 3128 be32_to_cpu(hdr->hw_sw_ver), hdr->build_date); 3129 3130 for (i = 0; i < be32_to_cpu(hdr->desc.n_region); i++) { 3131 struct mt76_connac2_patch_sec *sec; 3132 u32 len, addr, mode; 3133 const u8 *dl; 3134 u32 sec_info; 3135 3136 sec = (void *)(fw->data + sizeof(*hdr) + i * sizeof(*sec)); 3137 if ((be32_to_cpu(sec->type) & PATCH_SEC_TYPE_MASK) != 3138 PATCH_SEC_TYPE_INFO) { 3139 ret = -EINVAL; 3140 goto out; 3141 } 3142 3143 addr = be32_to_cpu(sec->info.addr); 3144 len = be32_to_cpu(sec->info.len); 3145 dl = fw->data + be32_to_cpu(sec->offs); 3146 sec_info = be32_to_cpu(sec->info.sec_key_idx); 3147 mode = mt76_connac2_get_data_mode(dev, sec_info); 3148 3149 ret = mt76_connac_mcu_init_download(dev, addr, len, mode); 3150 if (ret) { 3151 dev_err(dev->dev, "Download request failed\n"); 3152 goto out; 3153 } 3154 3155 ret = __mt76_mcu_send_firmware(dev, MCU_CMD(FW_SCATTER), 3156 dl, len, max_len); 3157 if (ret) { 3158 dev_err(dev->dev, "Failed to send patch\n"); 3159 goto out; 3160 } 3161 } 3162 3163 ret = mt76_connac_mcu_start_patch(dev); 3164 if (ret) 3165 dev_err(dev->dev, "Failed to start patch\n"); 3166 3167out: 3168 sem = mt76_connac_mcu_patch_sem_ctrl(dev, false); 3169 switch (sem) { 3170 case PATCH_REL_SEM_SUCCESS: 3171 break; 3172 default: 3173 ret = -EAGAIN; 3174 dev_err(dev->dev, "Failed to release patch semaphore\n"); 3175 break; 3176 } 3177 3178 release_firmware(fw); 3179 3180 return ret; 3181} 3182EXPORT_SYMBOL_GPL(mt76_connac2_load_patch); 3183 3184int mt76_connac2_mcu_fill_message(struct mt76_dev *dev, struct sk_buff *skb, 3185 int cmd, int *wait_seq) 3186{ 3187 int txd_len, mcu_cmd = FIELD_GET(__MCU_CMD_FIELD_ID, cmd); 3188 struct mt76_connac2_mcu_uni_txd *uni_txd; 3189 struct mt76_connac2_mcu_txd *mcu_txd; 3190 __le32 *txd; 3191 u32 val; 3192 u8 seq; 3193 3194 /* TODO: make dynamic based on msg type */ 3195 dev->mcu.timeout = 20 * HZ; 3196 3197 seq = ++dev->mcu.msg_seq & 0xf; 3198 if (!seq) 3199 seq = ++dev->mcu.msg_seq & 0xf; 3200 3201 if (cmd == MCU_CMD(FW_SCATTER)) 3202 goto exit; 3203 3204 txd_len = cmd & __MCU_CMD_FIELD_UNI ? sizeof(*uni_txd) : sizeof(*mcu_txd); 3205 txd = (__le32 *)skb_push(skb, txd_len); 3206 3207 val = FIELD_PREP(MT_TXD0_TX_BYTES, skb->len) | 3208 FIELD_PREP(MT_TXD0_PKT_FMT, MT_TX_TYPE_CMD) | 3209 FIELD_PREP(MT_TXD0_Q_IDX, MT_TX_MCU_PORT_RX_Q0); 3210 txd[0] = cpu_to_le32(val); 3211 3212 val = MT_TXD1_LONG_FORMAT | 3213 FIELD_PREP(MT_TXD1_HDR_FORMAT, MT_HDR_FORMAT_CMD); 3214 txd[1] = cpu_to_le32(val); 3215 3216 if (cmd & __MCU_CMD_FIELD_UNI) { 3217 uni_txd = (struct mt76_connac2_mcu_uni_txd *)txd; 3218 uni_txd->len = cpu_to_le16(skb->len - sizeof(uni_txd->txd)); 3219 uni_txd->option = MCU_CMD_UNI_EXT_ACK; 3220 uni_txd->cid = cpu_to_le16(mcu_cmd); 3221 uni_txd->s2d_index = MCU_S2D_H2N; 3222 uni_txd->pkt_type = MCU_PKT_ID; 3223 uni_txd->seq = seq; 3224 3225 goto exit; 3226 } 3227 3228 mcu_txd = (struct mt76_connac2_mcu_txd *)txd; 3229 mcu_txd->len = cpu_to_le16(skb->len - sizeof(mcu_txd->txd)); 3230 mcu_txd->pq_id = cpu_to_le16(MCU_PQ_ID(MT_TX_PORT_IDX_MCU, 3231 MT_TX_MCU_PORT_RX_Q0)); 3232 mcu_txd->pkt_type = MCU_PKT_ID; 3233 mcu_txd->seq = seq; 3234 mcu_txd->cid = mcu_cmd; 3235 mcu_txd->ext_cid = FIELD_GET(__MCU_CMD_FIELD_EXT_ID, cmd); 3236 3237 if (mcu_txd->ext_cid || (cmd & __MCU_CMD_FIELD_CE)) { 3238 if (cmd & __MCU_CMD_FIELD_QUERY) 3239 mcu_txd->set_query = MCU_Q_QUERY; 3240 else 3241 mcu_txd->set_query = MCU_Q_SET; 3242 mcu_txd->ext_cid_ack = !!mcu_txd->ext_cid; 3243 } else { 3244 mcu_txd->set_query = MCU_Q_NA; 3245 } 3246 3247 if (cmd & __MCU_CMD_FIELD_WA) 3248 mcu_txd->s2d_index = MCU_S2D_H2C; 3249 else 3250 mcu_txd->s2d_index = MCU_S2D_H2N; 3251 3252exit: 3253 if (wait_seq) 3254 *wait_seq = seq; 3255 3256 return 0; 3257} 3258EXPORT_SYMBOL_GPL(mt76_connac2_mcu_fill_message); 3259 3260MODULE_AUTHOR("Lorenzo Bianconi <lorenzo@kernel.org>"); 3261MODULE_DESCRIPTION("MediaTek MT76x connac layer helpers"); 3262MODULE_LICENSE("Dual BSD/GPL");
~/
Read-only file preview.