1 // SPDX-License-Identifier: ISC 2 /* Copyright (C) 2020 MediaTek Inc. */ 3 4 #include "mt76_connac_mcu.h" 5 6 int mt76_connac_mcu_start_firmware(struct mt76_dev *dev, u32 addr, u32 option) 7 { 8 struct { 9 __le32 option; 10 __le32 addr; 11 } req = { 12 .option = cpu_to_le32(option), 13 .addr = cpu_to_le32(addr), 14 }; 15 16 return mt76_mcu_send_msg(dev, MCU_CMD_FW_START_REQ, &req, sizeof(req), 17 true); 18 } 19 EXPORT_SYMBOL_GPL(mt76_connac_mcu_start_firmware); 20 21 int mt76_connac_mcu_patch_sem_ctrl(struct mt76_dev *dev, bool get) 22 { 23 u32 op = get ? PATCH_SEM_GET : PATCH_SEM_RELEASE; 24 struct { 25 __le32 op; 26 } req = { 27 .op = cpu_to_le32(op), 28 }; 29 30 return mt76_mcu_send_msg(dev, MCU_CMD_PATCH_SEM_CONTROL, &req, 31 sizeof(req), true); 32 } 33 EXPORT_SYMBOL_GPL(mt76_connac_mcu_patch_sem_ctrl); 34 35 int mt76_connac_mcu_start_patch(struct mt76_dev *dev) 36 { 37 struct { 38 u8 check_crc; 39 u8 reserved[3]; 40 } req = { 41 .check_crc = 0, 42 }; 43 44 return mt76_mcu_send_msg(dev, MCU_CMD_PATCH_FINISH_REQ, &req, 45 sizeof(req), true); 46 } 47 EXPORT_SYMBOL_GPL(mt76_connac_mcu_start_patch); 48 49 #define MCU_PATCH_ADDRESS 0x200000 50 51 int mt76_connac_mcu_init_download(struct mt76_dev *dev, u32 addr, u32 len, 52 u32 mode) 53 { 54 struct { 55 __le32 addr; 56 __le32 len; 57 __le32 mode; 58 } req = { 59 .addr = cpu_to_le32(addr), 60 .len = cpu_to_le32(len), 61 .mode = cpu_to_le32(mode), 62 }; 63 int cmd; 64 65 if (is_mt7921(dev) && 66 (req.addr == cpu_to_le32(MCU_PATCH_ADDRESS) || addr == 0x900000)) 67 cmd = MCU_CMD_PATCH_START_REQ; 68 else 69 cmd = MCU_CMD_TARGET_ADDRESS_LEN_REQ; 70 71 return mt76_mcu_send_msg(dev, cmd, &req, sizeof(req), true); 72 } 73 EXPORT_SYMBOL_GPL(mt76_connac_mcu_init_download); 74 75 int mt76_connac_mcu_set_channel_domain(struct mt76_phy *phy) 76 { 77 struct mt76_dev *dev = phy->dev; 78 struct mt76_connac_mcu_channel_domain { 79 u8 alpha2[4]; /* regulatory_request.alpha2 */ 80 u8 bw_2g; /* BW_20_40M 0 81 * BW_20M 1 82 * BW_20_40_80M 2 83 * BW_20_40_80_160M 3 84 * BW_20_40_80_8080M 4 85 */ 86 u8 bw_5g; 87 __le16 pad; 88 u8 n_2ch; 89 u8 n_5ch; 90 __le16 pad2; 91 } __packed hdr = { 92 .bw_2g = 0, 93 .bw_5g = 3, 94 }; 95 struct mt76_connac_mcu_chan { 96 __le16 hw_value; 97 __le16 pad; 98 __le32 flags; 99 } __packed channel; 100 int len, i, n_max_channels, n_2ch = 0, n_5ch = 0; 101 struct ieee80211_channel *chan; 102 struct sk_buff *skb; 103 104 n_max_channels = phy->sband_2g.sband.n_channels + 105 phy->sband_5g.sband.n_channels; 106 len = sizeof(hdr) + n_max_channels * sizeof(channel); 107 108 skb = mt76_mcu_msg_alloc(dev, NULL, len); 109 if (!skb) 110 return -ENOMEM; 111 112 skb_reserve(skb, sizeof(hdr)); 113 114 for (i = 0; i < phy->sband_2g.sband.n_channels; i++) { 115 chan = &phy->sband_2g.sband.channels[i]; 116 if (chan->flags & IEEE80211_CHAN_DISABLED) 117 continue; 118 119 channel.hw_value = cpu_to_le16(chan->hw_value); 120 channel.flags = cpu_to_le32(chan->flags); 121 channel.pad = 0; 122 123 skb_put_data(skb, &channel, sizeof(channel)); 124 n_2ch++; 125 } 126 for (i = 0; i < phy->sband_5g.sband.n_channels; i++) { 127 chan = &phy->sband_5g.sband.channels[i]; 128 if (chan->flags & IEEE80211_CHAN_DISABLED) 129 continue; 130 131 channel.hw_value = cpu_to_le16(chan->hw_value); 132 channel.flags = cpu_to_le32(chan->flags); 133 channel.pad = 0; 134 135 skb_put_data(skb, &channel, sizeof(channel)); 136 n_5ch++; 137 } 138 139 BUILD_BUG_ON(sizeof(dev->alpha2) > sizeof(hdr.alpha2)); 140 memcpy(hdr.alpha2, dev->alpha2, sizeof(dev->alpha2)); 141 hdr.n_2ch = n_2ch; 142 hdr.n_5ch = n_5ch; 143 144 memcpy(__skb_push(skb, sizeof(hdr)), &hdr, sizeof(hdr)); 145 146 return mt76_mcu_skb_send_msg(dev, skb, MCU_CMD_SET_CHAN_DOMAIN, false); 147 } 148 EXPORT_SYMBOL_GPL(mt76_connac_mcu_set_channel_domain); 149 150 int mt76_connac_mcu_set_mac_enable(struct mt76_dev *dev, int band, bool enable, 151 bool hdr_trans) 152 { 153 struct { 154 u8 enable; 155 u8 band; 156 u8 rsv[2]; 157 } __packed req_mac = { 158 .enable = enable, 159 .band = band, 160 }; 161 162 return mt76_mcu_send_msg(dev, MCU_EXT_CMD_MAC_INIT_CTRL, &req_mac, 163 sizeof(req_mac), true); 164 } 165 EXPORT_SYMBOL_GPL(mt76_connac_mcu_set_mac_enable); 166 167 int mt76_connac_mcu_set_vif_ps(struct mt76_dev *dev, struct ieee80211_vif *vif) 168 { 169 struct mt76_vif *mvif = (struct mt76_vif *)vif->drv_priv; 170 struct { 171 u8 bss_idx; 172 u8 ps_state; /* 0: device awake 173 * 1: static power save 174 * 2: dynamic power saving 175 */ 176 } req = { 177 .bss_idx = mvif->idx, 178 .ps_state = vif->bss_conf.ps ? 2 : 0, 179 }; 180 181 if (vif->type != NL80211_IFTYPE_STATION) 182 return -EOPNOTSUPP; 183 184 return mt76_mcu_send_msg(dev, MCU_CMD_SET_PS_PROFILE, &req, 185 sizeof(req), false); 186 } 187 EXPORT_SYMBOL_GPL(mt76_connac_mcu_set_vif_ps); 188 189 int mt76_connac_mcu_set_rts_thresh(struct mt76_dev *dev, u32 val, u8 band) 190 { 191 struct { 192 u8 prot_idx; 193 u8 band; 194 u8 rsv[2]; 195 __le32 len_thresh; 196 __le32 pkt_thresh; 197 } __packed req = { 198 .prot_idx = 1, 199 .band = band, 200 .len_thresh = cpu_to_le32(val), 201 .pkt_thresh = cpu_to_le32(0x2), 202 }; 203 204 return mt76_mcu_send_msg(dev, MCU_EXT_CMD_PROTECT_CTRL, &req, 205 sizeof(req), true); 206 } 207 EXPORT_SYMBOL_GPL(mt76_connac_mcu_set_rts_thresh); 208 209 void mt76_connac_mcu_beacon_loss_iter(void *priv, u8 *mac, 210 struct ieee80211_vif *vif) 211 { 212 struct mt76_vif *mvif = (struct mt76_vif *)vif->drv_priv; 213 struct mt76_connac_beacon_loss_event *event = priv; 214 215 if (mvif->idx != event->bss_idx) 216 return; 217 218 if (!(vif->driver_flags & IEEE80211_VIF_BEACON_FILTER)) 219 return; 220 221 ieee80211_beacon_loss(vif); 222 } 223 EXPORT_SYMBOL_GPL(mt76_connac_mcu_beacon_loss_iter); 224 225 struct tlv * 226 mt76_connac_mcu_add_nested_tlv(struct sk_buff *skb, int tag, int len, 227 void *sta_ntlv, void *sta_wtbl) 228 { 229 struct sta_ntlv_hdr *ntlv_hdr = sta_ntlv; 230 struct tlv *sta_hdr = sta_wtbl; 231 struct tlv *ptlv, tlv = { 232 .tag = cpu_to_le16(tag), 233 .len = cpu_to_le16(len), 234 }; 235 u16 ntlv; 236 237 ptlv = skb_put(skb, len); 238 memcpy(ptlv, &tlv, sizeof(tlv)); 239 240 ntlv = le16_to_cpu(ntlv_hdr->tlv_num); 241 ntlv_hdr->tlv_num = cpu_to_le16(ntlv + 1); 242 243 if (sta_hdr) { 244 u16 size = le16_to_cpu(sta_hdr->len); 245 246 sta_hdr->len = cpu_to_le16(size + len); 247 } 248 249 return ptlv; 250 } 251 EXPORT_SYMBOL_GPL(mt76_connac_mcu_add_nested_tlv); 252 253 struct sk_buff * 254 mt76_connac_mcu_alloc_sta_req(struct mt76_dev *dev, struct mt76_vif *mvif, 255 struct mt76_wcid *wcid) 256 { 257 struct sta_req_hdr hdr = { 258 .bss_idx = mvif->idx, 259 .muar_idx = wcid ? mvif->omac_idx : 0, 260 .is_tlv_append = 1, 261 }; 262 struct sk_buff *skb; 263 264 mt76_connac_mcu_get_wlan_idx(dev, wcid, &hdr.wlan_idx_lo, 265 &hdr.wlan_idx_hi); 266 skb = mt76_mcu_msg_alloc(dev, NULL, MT76_CONNAC_STA_UPDATE_MAX_SIZE); 267 if (!skb) 268 return ERR_PTR(-ENOMEM); 269 270 skb_put_data(skb, &hdr, sizeof(hdr)); 271 272 return skb; 273 } 274 EXPORT_SYMBOL_GPL(mt76_connac_mcu_alloc_sta_req); 275 276 struct wtbl_req_hdr * 277 mt76_connac_mcu_alloc_wtbl_req(struct mt76_dev *dev, struct mt76_wcid *wcid, 278 int cmd, void *sta_wtbl, struct sk_buff **skb) 279 { 280 struct tlv *sta_hdr = sta_wtbl; 281 struct wtbl_req_hdr hdr = { 282 .operation = cmd, 283 }; 284 struct sk_buff *nskb = *skb; 285 286 mt76_connac_mcu_get_wlan_idx(dev, wcid, &hdr.wlan_idx_lo, 287 &hdr.wlan_idx_hi); 288 if (!nskb) { 289 nskb = mt76_mcu_msg_alloc(dev, NULL, 290 MT76_CONNAC_WTBL_UPDATE_MAX_SIZE); 291 if (!nskb) 292 return ERR_PTR(-ENOMEM); 293 294 *skb = nskb; 295 } 296 297 if (sta_hdr) 298 sta_hdr->len = cpu_to_le16(sizeof(hdr)); 299 300 return skb_put_data(nskb, &hdr, sizeof(hdr)); 301 } 302 EXPORT_SYMBOL_GPL(mt76_connac_mcu_alloc_wtbl_req); 303 304 void mt76_connac_mcu_sta_basic_tlv(struct sk_buff *skb, 305 struct ieee80211_vif *vif, 306 struct ieee80211_sta *sta, 307 bool enable) 308 { 309 struct sta_rec_basic *basic; 310 struct tlv *tlv; 311 int conn_type; 312 313 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_BASIC, sizeof(*basic)); 314 315 basic = (struct sta_rec_basic *)tlv; 316 basic->extra_info = cpu_to_le16(EXTRA_INFO_VER); 317 318 if (enable) { 319 basic->extra_info |= cpu_to_le16(EXTRA_INFO_NEW); 320 basic->conn_state = CONN_STATE_PORT_SECURE; 321 } else { 322 basic->conn_state = CONN_STATE_DISCONNECT; 323 } 324 325 if (!sta) { 326 basic->conn_type = cpu_to_le32(CONNECTION_INFRA_BC); 327 eth_broadcast_addr(basic->peer_addr); 328 return; 329 } 330 331 switch (vif->type) { 332 case NL80211_IFTYPE_MESH_POINT: 333 case NL80211_IFTYPE_AP: 334 if (vif->p2p) 335 conn_type = CONNECTION_P2P_GC; 336 else 337 conn_type = CONNECTION_INFRA_STA; 338 basic->conn_type = cpu_to_le32(conn_type); 339 basic->aid = cpu_to_le16(sta->aid); 340 break; 341 case NL80211_IFTYPE_STATION: 342 if (vif->p2p) 343 conn_type = CONNECTION_P2P_GO; 344 else 345 conn_type = CONNECTION_INFRA_AP; 346 basic->conn_type = cpu_to_le32(conn_type); 347 basic->aid = cpu_to_le16(vif->bss_conf.aid); 348 break; 349 case NL80211_IFTYPE_ADHOC: 350 basic->conn_type = cpu_to_le32(CONNECTION_IBSS_ADHOC); 351 basic->aid = cpu_to_le16(sta->aid); 352 break; 353 default: 354 WARN_ON(1); 355 break; 356 } 357 358 memcpy(basic->peer_addr, sta->addr, ETH_ALEN); 359 basic->qos = sta->wme; 360 } 361 EXPORT_SYMBOL_GPL(mt76_connac_mcu_sta_basic_tlv); 362 363 static void 364 mt76_connac_mcu_sta_uapsd(struct sk_buff *skb, struct ieee80211_vif *vif, 365 struct ieee80211_sta *sta) 366 { 367 struct sta_rec_uapsd *uapsd; 368 struct tlv *tlv; 369 370 if (vif->type != NL80211_IFTYPE_AP || !sta->wme) 371 return; 372 373 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_APPS, sizeof(*uapsd)); 374 uapsd = (struct sta_rec_uapsd *)tlv; 375 376 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VO) { 377 uapsd->dac_map |= BIT(3); 378 uapsd->tac_map |= BIT(3); 379 } 380 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VI) { 381 uapsd->dac_map |= BIT(2); 382 uapsd->tac_map |= BIT(2); 383 } 384 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BE) { 385 uapsd->dac_map |= BIT(1); 386 uapsd->tac_map |= BIT(1); 387 } 388 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BK) { 389 uapsd->dac_map |= BIT(0); 390 uapsd->tac_map |= BIT(0); 391 } 392 uapsd->max_sp = sta->max_sp; 393 } 394 395 void mt76_connac_mcu_wtbl_hdr_trans_tlv(struct sk_buff *skb, 396 struct mt76_wcid *wcid, 397 void *sta_wtbl, void *wtbl_tlv) 398 { 399 struct wtbl_hdr_trans *htr; 400 struct tlv *tlv; 401 402 tlv = mt76_connac_mcu_add_nested_tlv(skb, WTBL_HDR_TRANS, 403 sizeof(*htr), 404 wtbl_tlv, sta_wtbl); 405 htr = (struct wtbl_hdr_trans *)tlv; 406 htr->no_rx_trans = !test_bit(MT_WCID_FLAG_HDR_TRANS, &wcid->flags); 407 } 408 EXPORT_SYMBOL_GPL(mt76_connac_mcu_wtbl_hdr_trans_tlv); 409 410 void mt76_connac_mcu_wtbl_generic_tlv(struct mt76_dev *dev, 411 struct sk_buff *skb, 412 struct ieee80211_vif *vif, 413 struct ieee80211_sta *sta, 414 void *sta_wtbl, void *wtbl_tlv) 415 { 416 struct mt76_vif *mvif = (struct mt76_vif *)vif->drv_priv; 417 struct wtbl_generic *generic; 418 struct wtbl_rx *rx; 419 struct wtbl_spe *spe; 420 struct tlv *tlv; 421 422 tlv = mt76_connac_mcu_add_nested_tlv(skb, WTBL_GENERIC, 423 sizeof(*generic), 424 wtbl_tlv, sta_wtbl); 425 426 generic = (struct wtbl_generic *)tlv; 427 428 if (sta) { 429 if (vif->type == NL80211_IFTYPE_STATION) 430 generic->partial_aid = cpu_to_le16(vif->bss_conf.aid); 431 else 432 generic->partial_aid = cpu_to_le16(sta->aid); 433 memcpy(generic->peer_addr, sta->addr, ETH_ALEN); 434 generic->muar_idx = mvif->omac_idx; 435 generic->qos = sta->wme; 436 } else { 437 if (is_mt7921(dev) && 438 vif->type == NL80211_IFTYPE_STATION) 439 memcpy(generic->peer_addr, vif->bss_conf.bssid, 440 ETH_ALEN); 441 else 442 eth_broadcast_addr(generic->peer_addr); 443 444 generic->muar_idx = 0xe; 445 } 446 447 tlv = mt76_connac_mcu_add_nested_tlv(skb, WTBL_RX, sizeof(*rx), 448 wtbl_tlv, sta_wtbl); 449 450 rx = (struct wtbl_rx *)tlv; 451 rx->rca1 = sta ? vif->type != NL80211_IFTYPE_AP : 1; 452 rx->rca2 = 1; 453 rx->rv = 1; 454 455 if (is_mt7921(dev)) 456 return; 457 458 tlv = mt76_connac_mcu_add_nested_tlv(skb, WTBL_SPE, sizeof(*spe), 459 wtbl_tlv, sta_wtbl); 460 spe = (struct wtbl_spe *)tlv; 461 spe->spe_idx = 24; 462 } 463 EXPORT_SYMBOL_GPL(mt76_connac_mcu_wtbl_generic_tlv); 464 465 static void 466 mt76_connac_mcu_sta_amsdu_tlv(struct sk_buff *skb, struct ieee80211_sta *sta, 467 struct ieee80211_vif *vif) 468 { 469 struct mt76_wcid *wcid = (struct mt76_wcid *)sta->drv_priv; 470 struct sta_rec_amsdu *amsdu; 471 struct tlv *tlv; 472 473 if (vif->type != NL80211_IFTYPE_AP && 474 vif->type != NL80211_IFTYPE_STATION) 475 return; 476 477 if (!sta->max_amsdu_len) 478 return; 479 480 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_HW_AMSDU, sizeof(*amsdu)); 481 amsdu = (struct sta_rec_amsdu *)tlv; 482 amsdu->max_amsdu_num = 8; 483 amsdu->amsdu_en = true; 484 amsdu->max_mpdu_size = sta->max_amsdu_len >= 485 IEEE80211_MAX_MPDU_LEN_VHT_7991; 486 487 wcid->amsdu = true; 488 } 489 490 #define HE_PHY(p, c) u8_get_bits(c, IEEE80211_HE_PHY_##p) 491 #define HE_MAC(m, c) u8_get_bits(c, IEEE80211_HE_MAC_##m) 492 static void 493 mt76_connac_mcu_sta_he_tlv(struct sk_buff *skb, struct ieee80211_sta *sta) 494 { 495 struct ieee80211_sta_he_cap *he_cap = &sta->he_cap; 496 struct ieee80211_he_cap_elem *elem = &he_cap->he_cap_elem; 497 struct sta_rec_he *he; 498 struct tlv *tlv; 499 u32 cap = 0; 500 501 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_HE, sizeof(*he)); 502 503 he = (struct sta_rec_he *)tlv; 504 505 if (elem->mac_cap_info[0] & IEEE80211_HE_MAC_CAP0_HTC_HE) 506 cap |= STA_REC_HE_CAP_HTC; 507 508 if (elem->mac_cap_info[2] & IEEE80211_HE_MAC_CAP2_BSR) 509 cap |= STA_REC_HE_CAP_BSR; 510 511 if (elem->mac_cap_info[3] & IEEE80211_HE_MAC_CAP3_OMI_CONTROL) 512 cap |= STA_REC_HE_CAP_OM; 513 514 if (elem->mac_cap_info[4] & IEEE80211_HE_MAC_CAP4_AMSDU_IN_AMPDU) 515 cap |= STA_REC_HE_CAP_AMSDU_IN_AMPDU; 516 517 if (elem->mac_cap_info[4] & IEEE80211_HE_MAC_CAP4_BQR) 518 cap |= STA_REC_HE_CAP_BQR; 519 520 if (elem->phy_cap_info[0] & 521 (IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_RU_MAPPING_IN_2G | 522 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_RU_MAPPING_IN_5G)) 523 cap |= STA_REC_HE_CAP_BW20_RU242_SUPPORT; 524 525 if (elem->phy_cap_info[1] & 526 IEEE80211_HE_PHY_CAP1_LDPC_CODING_IN_PAYLOAD) 527 cap |= STA_REC_HE_CAP_LDPC; 528 529 if (elem->phy_cap_info[1] & 530 IEEE80211_HE_PHY_CAP1_HE_LTF_AND_GI_FOR_HE_PPDUS_0_8US) 531 cap |= STA_REC_HE_CAP_SU_PPDU_1LTF_8US_GI; 532 533 if (elem->phy_cap_info[2] & 534 IEEE80211_HE_PHY_CAP2_NDP_4x_LTF_AND_3_2US) 535 cap |= STA_REC_HE_CAP_NDP_4LTF_3DOT2MS_GI; 536 537 if (elem->phy_cap_info[2] & 538 IEEE80211_HE_PHY_CAP2_STBC_TX_UNDER_80MHZ) 539 cap |= STA_REC_HE_CAP_LE_EQ_80M_TX_STBC; 540 541 if (elem->phy_cap_info[2] & 542 IEEE80211_HE_PHY_CAP2_STBC_RX_UNDER_80MHZ) 543 cap |= STA_REC_HE_CAP_LE_EQ_80M_RX_STBC; 544 545 if (elem->phy_cap_info[6] & 546 IEEE80211_HE_PHY_CAP6_PARTIAL_BW_EXT_RANGE) 547 cap |= STA_REC_HE_CAP_PARTIAL_BW_EXT_RANGE; 548 549 if (elem->phy_cap_info[7] & 550 IEEE80211_HE_PHY_CAP7_HE_SU_MU_PPDU_4XLTF_AND_08_US_GI) 551 cap |= STA_REC_HE_CAP_SU_MU_PPDU_4LTF_8US_GI; 552 553 if (elem->phy_cap_info[7] & 554 IEEE80211_HE_PHY_CAP7_STBC_TX_ABOVE_80MHZ) 555 cap |= STA_REC_HE_CAP_GT_80M_TX_STBC; 556 557 if (elem->phy_cap_info[7] & 558 IEEE80211_HE_PHY_CAP7_STBC_RX_ABOVE_80MHZ) 559 cap |= STA_REC_HE_CAP_GT_80M_RX_STBC; 560 561 if (elem->phy_cap_info[8] & 562 IEEE80211_HE_PHY_CAP8_HE_ER_SU_PPDU_4XLTF_AND_08_US_GI) 563 cap |= STA_REC_HE_CAP_ER_SU_PPDU_4LTF_8US_GI; 564 565 if (elem->phy_cap_info[8] & 566 IEEE80211_HE_PHY_CAP8_HE_ER_SU_1XLTF_AND_08_US_GI) 567 cap |= STA_REC_HE_CAP_ER_SU_PPDU_1LTF_8US_GI; 568 569 if (elem->phy_cap_info[9] & 570 IEEE80211_HE_PHY_CAP9_NON_TRIGGERED_CQI_FEEDBACK) 571 cap |= STA_REC_HE_CAP_TRIG_CQI_FK; 572 573 if (elem->phy_cap_info[9] & 574 IEEE80211_HE_PHY_CAP9_TX_1024_QAM_LESS_THAN_242_TONE_RU) 575 cap |= STA_REC_HE_CAP_TX_1024QAM_UNDER_RU242; 576 577 if (elem->phy_cap_info[9] & 578 IEEE80211_HE_PHY_CAP9_RX_1024_QAM_LESS_THAN_242_TONE_RU) 579 cap |= STA_REC_HE_CAP_RX_1024QAM_UNDER_RU242; 580 581 he->he_cap = cpu_to_le32(cap); 582 583 switch (sta->bandwidth) { 584 case IEEE80211_STA_RX_BW_160: 585 if (elem->phy_cap_info[0] & 586 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_80PLUS80_MHZ_IN_5G) 587 he->max_nss_mcs[CMD_HE_MCS_BW8080] = 588 he_cap->he_mcs_nss_supp.rx_mcs_80p80; 589 590 he->max_nss_mcs[CMD_HE_MCS_BW160] = 591 he_cap->he_mcs_nss_supp.rx_mcs_160; 592 fallthrough; 593 default: 594 he->max_nss_mcs[CMD_HE_MCS_BW80] = 595 he_cap->he_mcs_nss_supp.rx_mcs_80; 596 break; 597 } 598 599 he->t_frame_dur = 600 HE_MAC(CAP1_TF_MAC_PAD_DUR_MASK, elem->mac_cap_info[1]); 601 he->max_ampdu_exp = 602 HE_MAC(CAP3_MAX_AMPDU_LEN_EXP_MASK, elem->mac_cap_info[3]); 603 604 he->bw_set = 605 HE_PHY(CAP0_CHANNEL_WIDTH_SET_MASK, elem->phy_cap_info[0]); 606 he->device_class = 607 HE_PHY(CAP1_DEVICE_CLASS_A, elem->phy_cap_info[1]); 608 he->punc_pream_rx = 609 HE_PHY(CAP1_PREAMBLE_PUNC_RX_MASK, elem->phy_cap_info[1]); 610 611 he->dcm_tx_mode = 612 HE_PHY(CAP3_DCM_MAX_CONST_TX_MASK, elem->phy_cap_info[3]); 613 he->dcm_tx_max_nss = 614 HE_PHY(CAP3_DCM_MAX_TX_NSS_2, elem->phy_cap_info[3]); 615 he->dcm_rx_mode = 616 HE_PHY(CAP3_DCM_MAX_CONST_RX_MASK, elem->phy_cap_info[3]); 617 he->dcm_rx_max_nss = 618 HE_PHY(CAP3_DCM_MAX_RX_NSS_2, elem->phy_cap_info[3]); 619 he->dcm_rx_max_nss = 620 HE_PHY(CAP8_DCM_MAX_RU_MASK, elem->phy_cap_info[8]); 621 622 he->pkt_ext = 2; 623 } 624 625 static u8 626 mt76_connac_get_phy_mode_v2(struct mt76_phy *mphy, struct ieee80211_vif *vif, 627 enum nl80211_band band, struct ieee80211_sta *sta) 628 { 629 struct ieee80211_sta_ht_cap *ht_cap; 630 struct ieee80211_sta_vht_cap *vht_cap; 631 const struct ieee80211_sta_he_cap *he_cap; 632 u8 mode = 0; 633 634 if (sta) { 635 ht_cap = &sta->ht_cap; 636 vht_cap = &sta->vht_cap; 637 he_cap = &sta->he_cap; 638 } else { 639 struct ieee80211_supported_band *sband; 640 641 sband = mphy->hw->wiphy->bands[band]; 642 ht_cap = &sband->ht_cap; 643 vht_cap = &sband->vht_cap; 644 he_cap = ieee80211_get_he_iftype_cap(sband, vif->type); 645 } 646 647 if (band == NL80211_BAND_2GHZ) { 648 mode |= PHY_TYPE_BIT_HR_DSSS | PHY_TYPE_BIT_ERP; 649 650 if (ht_cap->ht_supported) 651 mode |= PHY_TYPE_BIT_HT; 652 653 if (he_cap->has_he) 654 mode |= PHY_TYPE_BIT_HE; 655 } else if (band == NL80211_BAND_5GHZ) { 656 mode |= PHY_TYPE_BIT_OFDM; 657 658 if (ht_cap->ht_supported) 659 mode |= PHY_TYPE_BIT_HT; 660 661 if (vht_cap->vht_supported) 662 mode |= PHY_TYPE_BIT_VHT; 663 664 if (he_cap->has_he) 665 mode |= PHY_TYPE_BIT_HE; 666 } 667 668 return mode; 669 } 670 671 void mt76_connac_mcu_sta_tlv(struct mt76_phy *mphy, struct sk_buff *skb, 672 struct ieee80211_sta *sta, 673 struct ieee80211_vif *vif, 674 u8 rcpi) 675 { 676 struct cfg80211_chan_def *chandef = &mphy->chandef; 677 enum nl80211_band band = chandef->chan->band; 678 struct mt76_dev *dev = mphy->dev; 679 struct sta_rec_ra_info *ra_info; 680 struct sta_rec_state *state; 681 struct sta_rec_phy *phy; 682 struct tlv *tlv; 683 684 /* starec ht */ 685 if (sta->ht_cap.ht_supported) { 686 struct sta_rec_ht *ht; 687 688 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_HT, sizeof(*ht)); 689 ht = (struct sta_rec_ht *)tlv; 690 ht->ht_cap = cpu_to_le16(sta->ht_cap.cap); 691 } 692 693 /* starec vht */ 694 if (sta->vht_cap.vht_supported) { 695 struct sta_rec_vht *vht; 696 int len; 697 698 len = is_mt7921(dev) ? sizeof(*vht) : sizeof(*vht) - 4; 699 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_VHT, len); 700 vht = (struct sta_rec_vht *)tlv; 701 vht->vht_cap = cpu_to_le32(sta->vht_cap.cap); 702 vht->vht_rx_mcs_map = sta->vht_cap.vht_mcs.rx_mcs_map; 703 vht->vht_tx_mcs_map = sta->vht_cap.vht_mcs.tx_mcs_map; 704 } 705 706 /* starec uapsd */ 707 mt76_connac_mcu_sta_uapsd(skb, vif, sta); 708 709 if (!is_mt7921(dev)) 710 return; 711 712 if (sta->ht_cap.ht_supported) 713 mt76_connac_mcu_sta_amsdu_tlv(skb, sta, vif); 714 715 /* starec he */ 716 if (sta->he_cap.has_he) 717 mt76_connac_mcu_sta_he_tlv(skb, sta); 718 719 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_PHY, sizeof(*phy)); 720 phy = (struct sta_rec_phy *)tlv; 721 phy->phy_type = mt76_connac_get_phy_mode_v2(mphy, vif, band, sta); 722 phy->basic_rate = cpu_to_le16((u16)vif->bss_conf.basic_rates); 723 phy->rcpi = rcpi; 724 phy->ampdu = FIELD_PREP(IEEE80211_HT_AMPDU_PARM_FACTOR, 725 sta->ht_cap.ampdu_factor) | 726 FIELD_PREP(IEEE80211_HT_AMPDU_PARM_DENSITY, 727 sta->ht_cap.ampdu_density); 728 729 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_RA, sizeof(*ra_info)); 730 ra_info = (struct sta_rec_ra_info *)tlv; 731 ra_info->legacy = cpu_to_le16((u16)sta->supp_rates[band]); 732 733 if (sta->ht_cap.ht_supported) 734 memcpy(ra_info->rx_mcs_bitmask, sta->ht_cap.mcs.rx_mask, 735 HT_MCS_MASK_NUM); 736 737 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_STATE, sizeof(*state)); 738 state = (struct sta_rec_state *)tlv; 739 state->state = 2; 740 741 if (sta->vht_cap.vht_supported) { 742 state->vht_opmode = sta->bandwidth; 743 state->vht_opmode |= (sta->rx_nss - 1) << 744 IEEE80211_OPMODE_NOTIF_RX_NSS_SHIFT; 745 } 746 } 747 EXPORT_SYMBOL_GPL(mt76_connac_mcu_sta_tlv); 748 749 static void 750 mt76_connac_mcu_wtbl_smps_tlv(struct sk_buff *skb, struct ieee80211_sta *sta, 751 void *sta_wtbl, void *wtbl_tlv) 752 { 753 struct wtbl_smps *smps; 754 struct tlv *tlv; 755 756 tlv = mt76_connac_mcu_add_nested_tlv(skb, WTBL_SMPS, sizeof(*smps), 757 wtbl_tlv, sta_wtbl); 758 smps = (struct wtbl_smps *)tlv; 759 760 if (sta->smps_mode == IEEE80211_SMPS_DYNAMIC) 761 smps->smps = true; 762 } 763 764 void mt76_connac_mcu_wtbl_ht_tlv(struct mt76_dev *dev, struct sk_buff *skb, 765 struct ieee80211_sta *sta, void *sta_wtbl, 766 void *wtbl_tlv) 767 { 768 struct wtbl_ht *ht = NULL; 769 struct tlv *tlv; 770 u32 flags = 0; 771 772 if (sta->ht_cap.ht_supported) { 773 tlv = mt76_connac_mcu_add_nested_tlv(skb, WTBL_HT, sizeof(*ht), 774 wtbl_tlv, sta_wtbl); 775 ht = (struct wtbl_ht *)tlv; 776 ht->ldpc = !!(sta->ht_cap.cap & IEEE80211_HT_CAP_LDPC_CODING); 777 ht->af = sta->ht_cap.ampdu_factor; 778 ht->mm = sta->ht_cap.ampdu_density; 779 ht->ht = true; 780 } 781 782 if (sta->vht_cap.vht_supported) { 783 struct wtbl_vht *vht; 784 u8 af; 785 786 tlv = mt76_connac_mcu_add_nested_tlv(skb, WTBL_VHT, 787 sizeof(*vht), wtbl_tlv, 788 sta_wtbl); 789 vht = (struct wtbl_vht *)tlv; 790 vht->ldpc = !!(sta->vht_cap.cap & IEEE80211_VHT_CAP_RXLDPC); 791 vht->vht = true; 792 793 af = FIELD_GET(IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK, 794 sta->vht_cap.cap); 795 if (ht) 796 ht->af = max(ht->af, af); 797 } 798 799 mt76_connac_mcu_wtbl_smps_tlv(skb, sta, sta_wtbl, wtbl_tlv); 800 801 if (!is_mt7921(dev) && sta->ht_cap.ht_supported) { 802 /* sgi */ 803 u32 msk = MT_WTBL_W5_SHORT_GI_20 | MT_WTBL_W5_SHORT_GI_40 | 804 MT_WTBL_W5_SHORT_GI_80 | MT_WTBL_W5_SHORT_GI_160; 805 struct wtbl_raw *raw; 806 807 tlv = mt76_connac_mcu_add_nested_tlv(skb, WTBL_RAW_DATA, 808 sizeof(*raw), wtbl_tlv, 809 sta_wtbl); 810 811 if (sta->ht_cap.cap & IEEE80211_HT_CAP_SGI_20) 812 flags |= MT_WTBL_W5_SHORT_GI_20; 813 if (sta->ht_cap.cap & IEEE80211_HT_CAP_SGI_40) 814 flags |= MT_WTBL_W5_SHORT_GI_40; 815 816 if (sta->vht_cap.vht_supported) { 817 if (sta->vht_cap.cap & IEEE80211_VHT_CAP_SHORT_GI_80) 818 flags |= MT_WTBL_W5_SHORT_GI_80; 819 if (sta->vht_cap.cap & IEEE80211_VHT_CAP_SHORT_GI_160) 820 flags |= MT_WTBL_W5_SHORT_GI_160; 821 } 822 raw = (struct wtbl_raw *)tlv; 823 raw->val = cpu_to_le32(flags); 824 raw->msk = cpu_to_le32(~msk); 825 raw->wtbl_idx = 1; 826 raw->dw = 5; 827 } 828 } 829 EXPORT_SYMBOL_GPL(mt76_connac_mcu_wtbl_ht_tlv); 830 831 int mt76_connac_mcu_add_sta_cmd(struct mt76_phy *phy, 832 struct mt76_sta_cmd_info *info) 833 { 834 struct mt76_vif *mvif = (struct mt76_vif *)info->vif->drv_priv; 835 struct mt76_dev *dev = phy->dev; 836 struct wtbl_req_hdr *wtbl_hdr; 837 struct tlv *sta_wtbl; 838 struct sk_buff *skb; 839 840 skb = mt76_connac_mcu_alloc_sta_req(dev, mvif, info->wcid); 841 if (IS_ERR(skb)) 842 return PTR_ERR(skb); 843 844 mt76_connac_mcu_sta_basic_tlv(skb, info->vif, info->sta, info->enable); 845 if (info->enable && info->sta) 846 mt76_connac_mcu_sta_tlv(phy, skb, info->sta, info->vif, 847 info->rcpi); 848 849 sta_wtbl = mt76_connac_mcu_add_tlv(skb, STA_REC_WTBL, 850 sizeof(struct tlv)); 851 852 wtbl_hdr = mt76_connac_mcu_alloc_wtbl_req(dev, info->wcid, 853 WTBL_RESET_AND_SET, 854 sta_wtbl, &skb); 855 if (IS_ERR(wtbl_hdr)) 856 return PTR_ERR(wtbl_hdr); 857 858 if (info->enable) { 859 mt76_connac_mcu_wtbl_generic_tlv(dev, skb, info->vif, 860 info->sta, sta_wtbl, 861 wtbl_hdr); 862 if (info->sta) 863 mt76_connac_mcu_wtbl_ht_tlv(dev, skb, info->sta, 864 sta_wtbl, wtbl_hdr); 865 } 866 867 return mt76_mcu_skb_send_msg(dev, skb, info->cmd, true); 868 } 869 EXPORT_SYMBOL_GPL(mt76_connac_mcu_add_sta_cmd); 870 871 void mt76_connac_mcu_wtbl_ba_tlv(struct mt76_dev *dev, struct sk_buff *skb, 872 struct ieee80211_ampdu_params *params, 873 bool enable, bool tx, void *sta_wtbl, 874 void *wtbl_tlv) 875 { 876 struct wtbl_ba *ba; 877 struct tlv *tlv; 878 879 tlv = mt76_connac_mcu_add_nested_tlv(skb, WTBL_BA, sizeof(*ba), 880 wtbl_tlv, sta_wtbl); 881 882 ba = (struct wtbl_ba *)tlv; 883 ba->tid = params->tid; 884 885 if (tx) { 886 ba->ba_type = MT_BA_TYPE_ORIGINATOR; 887 ba->sn = enable ? cpu_to_le16(params->ssn) : 0; 888 ba->ba_winsize = enable ? cpu_to_le16(params->buf_size) : 0; 889 ba->ba_en = enable; 890 } else { 891 memcpy(ba->peer_addr, params->sta->addr, ETH_ALEN); 892 ba->ba_type = MT_BA_TYPE_RECIPIENT; 893 ba->rst_ba_tid = params->tid; 894 ba->rst_ba_sel = RST_BA_MAC_TID_MATCH; 895 ba->rst_ba_sb = 1; 896 } 897 898 if (is_mt7921(dev)) 899 return; 900 901 if (enable && tx) { 902 u8 ba_range[] = { 4, 8, 12, 24, 36, 48, 54, 64 }; 903 int i; 904 905 for (i = 7; i > 0; i--) { 906 if (params->buf_size >= ba_range[i]) 907 break; 908 } 909 ba->ba_winsize_idx = i; 910 } 911 } 912 EXPORT_SYMBOL_GPL(mt76_connac_mcu_wtbl_ba_tlv); 913 914 int mt76_connac_mcu_uni_add_dev(struct mt76_phy *phy, 915 struct ieee80211_vif *vif, 916 struct mt76_wcid *wcid, 917 bool enable) 918 { 919 struct mt76_vif *mvif = (struct mt76_vif *)vif->drv_priv; 920 struct mt76_dev *dev = phy->dev; 921 struct { 922 struct { 923 u8 omac_idx; 924 u8 band_idx; 925 __le16 pad; 926 } __packed hdr; 927 struct req_tlv { 928 __le16 tag; 929 __le16 len; 930 u8 active; 931 u8 pad; 932 u8 omac_addr[ETH_ALEN]; 933 } __packed tlv; 934 } dev_req = { 935 .hdr = { 936 .omac_idx = mvif->omac_idx, 937 .band_idx = mvif->band_idx, 938 }, 939 .tlv = { 940 .tag = cpu_to_le16(DEV_INFO_ACTIVE), 941 .len = cpu_to_le16(sizeof(struct req_tlv)), 942 .active = enable, 943 }, 944 }; 945 struct { 946 struct { 947 u8 bss_idx; 948 u8 pad[3]; 949 } __packed hdr; 950 struct mt76_connac_bss_basic_tlv basic; 951 } basic_req = { 952 .hdr = { 953 .bss_idx = mvif->idx, 954 }, 955 .basic = { 956 .tag = cpu_to_le16(UNI_BSS_INFO_BASIC), 957 .len = cpu_to_le16(sizeof(struct mt76_connac_bss_basic_tlv)), 958 .omac_idx = mvif->omac_idx, 959 .band_idx = mvif->band_idx, 960 .wmm_idx = mvif->wmm_idx, 961 .active = enable, 962 .bmc_tx_wlan_idx = cpu_to_le16(wcid->idx), 963 .sta_idx = cpu_to_le16(wcid->idx), 964 .conn_state = 1, 965 }, 966 }; 967 int err, idx, cmd, len; 968 void *data; 969 970 switch (vif->type) { 971 case NL80211_IFTYPE_MESH_POINT: 972 case NL80211_IFTYPE_MONITOR: 973 case NL80211_IFTYPE_AP: 974 basic_req.basic.conn_type = cpu_to_le32(CONNECTION_INFRA_AP); 975 break; 976 case NL80211_IFTYPE_STATION: 977 basic_req.basic.conn_type = cpu_to_le32(CONNECTION_INFRA_STA); 978 break; 979 case NL80211_IFTYPE_ADHOC: 980 basic_req.basic.conn_type = cpu_to_le32(CONNECTION_IBSS_ADHOC); 981 break; 982 default: 983 WARN_ON(1); 984 break; 985 } 986 987 idx = mvif->omac_idx > EXT_BSSID_START ? HW_BSSID_0 : mvif->omac_idx; 988 basic_req.basic.hw_bss_idx = idx; 989 990 memcpy(dev_req.tlv.omac_addr, vif->addr, ETH_ALEN); 991 992 cmd = enable ? MCU_UNI_CMD_DEV_INFO_UPDATE : MCU_UNI_CMD_BSS_INFO_UPDATE; 993 data = enable ? (void *)&dev_req : (void *)&basic_req; 994 len = enable ? sizeof(dev_req) : sizeof(basic_req); 995 996 err = mt76_mcu_send_msg(dev, cmd, data, len, true); 997 if (err < 0) 998 return err; 999 1000 cmd = enable ? MCU_UNI_CMD_BSS_INFO_UPDATE : MCU_UNI_CMD_DEV_INFO_UPDATE; 1001 data = enable ? (void *)&basic_req : (void *)&dev_req; 1002 len = enable ? sizeof(basic_req) : sizeof(dev_req); 1003 1004 return mt76_mcu_send_msg(dev, cmd, data, len, true); 1005 } 1006 EXPORT_SYMBOL_GPL(mt76_connac_mcu_uni_add_dev); 1007 1008 void mt76_connac_mcu_sta_ba_tlv(struct sk_buff *skb, 1009 struct ieee80211_ampdu_params *params, 1010 bool enable, bool tx) 1011 { 1012 struct sta_rec_ba *ba; 1013 struct tlv *tlv; 1014 1015 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_BA, sizeof(*ba)); 1016 1017 ba = (struct sta_rec_ba *)tlv; 1018 ba->ba_type = tx ? MT_BA_TYPE_ORIGINATOR : MT_BA_TYPE_RECIPIENT; 1019 ba->winsize = cpu_to_le16(params->buf_size); 1020 ba->ssn = cpu_to_le16(params->ssn); 1021 ba->ba_en = enable << params->tid; 1022 ba->amsdu = params->amsdu; 1023 ba->tid = params->tid; 1024 } 1025 EXPORT_SYMBOL_GPL(mt76_connac_mcu_sta_ba_tlv); 1026 1027 int mt76_connac_mcu_sta_ba(struct mt76_dev *dev, struct mt76_vif *mvif, 1028 struct ieee80211_ampdu_params *params, 1029 bool enable, bool tx) 1030 { 1031 struct mt76_wcid *wcid = (struct mt76_wcid *)params->sta->drv_priv; 1032 struct wtbl_req_hdr *wtbl_hdr; 1033 struct tlv *sta_wtbl; 1034 struct sk_buff *skb; 1035 int ret; 1036 1037 skb = mt76_connac_mcu_alloc_sta_req(dev, mvif, wcid); 1038 if (IS_ERR(skb)) 1039 return PTR_ERR(skb); 1040 1041 sta_wtbl = mt76_connac_mcu_add_tlv(skb, STA_REC_WTBL, 1042 sizeof(struct tlv)); 1043 1044 wtbl_hdr = mt76_connac_mcu_alloc_wtbl_req(dev, wcid, WTBL_SET, 1045 sta_wtbl, &skb); 1046 if (IS_ERR(wtbl_hdr)) 1047 return PTR_ERR(wtbl_hdr); 1048 1049 mt76_connac_mcu_wtbl_ba_tlv(dev, skb, params, enable, tx, sta_wtbl, 1050 wtbl_hdr); 1051 1052 ret = mt76_mcu_skb_send_msg(dev, skb, MCU_UNI_CMD_STA_REC_UPDATE, true); 1053 if (ret) 1054 return ret; 1055 1056 skb = mt76_connac_mcu_alloc_sta_req(dev, mvif, wcid); 1057 if (IS_ERR(skb)) 1058 return PTR_ERR(skb); 1059 1060 mt76_connac_mcu_sta_ba_tlv(skb, params, enable, tx); 1061 1062 return mt76_mcu_skb_send_msg(dev, skb, MCU_UNI_CMD_STA_REC_UPDATE, 1063 true); 1064 } 1065 EXPORT_SYMBOL_GPL(mt76_connac_mcu_sta_ba); 1066 1067 static u8 1068 mt76_connac_get_phy_mode(struct mt76_phy *phy, struct ieee80211_vif *vif, 1069 enum nl80211_band band, 1070 struct ieee80211_sta *sta) 1071 { 1072 struct mt76_dev *dev = phy->dev; 1073 const struct ieee80211_sta_he_cap *he_cap; 1074 struct ieee80211_sta_vht_cap *vht_cap; 1075 struct ieee80211_sta_ht_cap *ht_cap; 1076 u8 mode = 0; 1077 1078 if (!is_mt7921(dev)) 1079 return 0x38; 1080 1081 if (sta) { 1082 ht_cap = &sta->ht_cap; 1083 vht_cap = &sta->vht_cap; 1084 he_cap = &sta->he_cap; 1085 } else { 1086 struct ieee80211_supported_band *sband; 1087 1088 sband = phy->hw->wiphy->bands[band]; 1089 ht_cap = &sband->ht_cap; 1090 vht_cap = &sband->vht_cap; 1091 he_cap = ieee80211_get_he_iftype_cap(sband, vif->type); 1092 } 1093 1094 if (band == NL80211_BAND_2GHZ) { 1095 mode |= PHY_MODE_B | PHY_MODE_G; 1096 1097 if (ht_cap->ht_supported) 1098 mode |= PHY_MODE_GN; 1099 1100 if (he_cap->has_he) 1101 mode |= PHY_MODE_AX_24G; 1102 } else if (band == NL80211_BAND_5GHZ) { 1103 mode |= PHY_MODE_A; 1104 1105 if (ht_cap->ht_supported) 1106 mode |= PHY_MODE_AN; 1107 1108 if (vht_cap->vht_supported) 1109 mode |= PHY_MODE_AC; 1110 1111 if (he_cap->has_he) 1112 mode |= PHY_MODE_AX_5G; 1113 } 1114 1115 return mode; 1116 } 1117 1118 static const struct ieee80211_sta_he_cap * 1119 mt76_connac_get_he_phy_cap(struct mt76_phy *phy, struct ieee80211_vif *vif) 1120 { 1121 enum nl80211_band band = phy->chandef.chan->band; 1122 struct ieee80211_supported_band *sband; 1123 1124 sband = phy->hw->wiphy->bands[band]; 1125 1126 return ieee80211_get_he_iftype_cap(sband, vif->type); 1127 } 1128 1129 #define DEFAULT_HE_PE_DURATION 4 1130 #define DEFAULT_HE_DURATION_RTS_THRES 1023 1131 static void 1132 mt76_connac_mcu_uni_bss_he_tlv(struct mt76_phy *phy, struct ieee80211_vif *vif, 1133 struct tlv *tlv) 1134 { 1135 const struct ieee80211_sta_he_cap *cap; 1136 struct bss_info_uni_he *he; 1137 1138 cap = mt76_connac_get_he_phy_cap(phy, vif); 1139 1140 he = (struct bss_info_uni_he *)tlv; 1141 he->he_pe_duration = vif->bss_conf.htc_trig_based_pkt_ext; 1142 if (!he->he_pe_duration) 1143 he->he_pe_duration = DEFAULT_HE_PE_DURATION; 1144 1145 he->he_rts_thres = cpu_to_le16(vif->bss_conf.frame_time_rts_th); 1146 if (!he->he_rts_thres) 1147 he->he_rts_thres = cpu_to_le16(DEFAULT_HE_DURATION_RTS_THRES); 1148 1149 he->max_nss_mcs[CMD_HE_MCS_BW80] = cap->he_mcs_nss_supp.tx_mcs_80; 1150 he->max_nss_mcs[CMD_HE_MCS_BW160] = cap->he_mcs_nss_supp.tx_mcs_160; 1151 he->max_nss_mcs[CMD_HE_MCS_BW8080] = cap->he_mcs_nss_supp.tx_mcs_80p80; 1152 } 1153 1154 int mt76_connac_mcu_uni_add_bss(struct mt76_phy *phy, 1155 struct ieee80211_vif *vif, 1156 struct mt76_wcid *wcid, 1157 bool enable) 1158 { 1159 struct mt76_vif *mvif = (struct mt76_vif *)vif->drv_priv; 1160 struct cfg80211_chan_def *chandef = &phy->chandef; 1161 int freq1 = chandef->center_freq1, freq2 = chandef->center_freq2; 1162 enum nl80211_band band = chandef->chan->band; 1163 struct mt76_dev *mdev = phy->dev; 1164 struct { 1165 struct { 1166 u8 bss_idx; 1167 u8 pad[3]; 1168 } __packed hdr; 1169 struct mt76_connac_bss_basic_tlv basic; 1170 struct mt76_connac_bss_qos_tlv qos; 1171 } basic_req = { 1172 .hdr = { 1173 .bss_idx = mvif->idx, 1174 }, 1175 .basic = { 1176 .tag = cpu_to_le16(UNI_BSS_INFO_BASIC), 1177 .len = cpu_to_le16(sizeof(struct mt76_connac_bss_basic_tlv)), 1178 .bcn_interval = cpu_to_le16(vif->bss_conf.beacon_int), 1179 .dtim_period = vif->bss_conf.dtim_period, 1180 .omac_idx = mvif->omac_idx, 1181 .band_idx = mvif->band_idx, 1182 .wmm_idx = mvif->wmm_idx, 1183 .active = true, /* keep bss deactivated */ 1184 .phymode = mt76_connac_get_phy_mode(phy, vif, band, NULL), 1185 }, 1186 .qos = { 1187 .tag = cpu_to_le16(UNI_BSS_INFO_QBSS), 1188 .len = cpu_to_le16(sizeof(struct mt76_connac_bss_qos_tlv)), 1189 .qos = vif->bss_conf.qos, 1190 }, 1191 }; 1192 struct { 1193 struct { 1194 u8 bss_idx; 1195 u8 pad[3]; 1196 } __packed hdr; 1197 struct rlm_tlv { 1198 __le16 tag; 1199 __le16 len; 1200 u8 control_channel; 1201 u8 center_chan; 1202 u8 center_chan2; 1203 u8 bw; 1204 u8 tx_streams; 1205 u8 rx_streams; 1206 u8 short_st; 1207 u8 ht_op_info; 1208 u8 sco; 1209 u8 pad[3]; 1210 } __packed rlm; 1211 } __packed rlm_req = { 1212 .hdr = { 1213 .bss_idx = mvif->idx, 1214 }, 1215 .rlm = { 1216 .tag = cpu_to_le16(UNI_BSS_INFO_RLM), 1217 .len = cpu_to_le16(sizeof(struct rlm_tlv)), 1218 .control_channel = chandef->chan->hw_value, 1219 .center_chan = ieee80211_frequency_to_channel(freq1), 1220 .center_chan2 = ieee80211_frequency_to_channel(freq2), 1221 .tx_streams = hweight8(phy->antenna_mask), 1222 .ht_op_info = 4, /* set HT 40M allowed */ 1223 .rx_streams = phy->chainmask, 1224 .short_st = true, 1225 }, 1226 }; 1227 int err, conn_type; 1228 u8 idx; 1229 1230 idx = mvif->omac_idx > EXT_BSSID_START ? HW_BSSID_0 : mvif->omac_idx; 1231 basic_req.basic.hw_bss_idx = idx; 1232 1233 switch (vif->type) { 1234 case NL80211_IFTYPE_MESH_POINT: 1235 case NL80211_IFTYPE_AP: 1236 if (vif->p2p) 1237 conn_type = CONNECTION_P2P_GO; 1238 else 1239 conn_type = CONNECTION_INFRA_AP; 1240 basic_req.basic.conn_type = cpu_to_le32(conn_type); 1241 break; 1242 case NL80211_IFTYPE_STATION: 1243 if (vif->p2p) 1244 conn_type = CONNECTION_P2P_GC; 1245 else 1246 conn_type = CONNECTION_INFRA_STA; 1247 basic_req.basic.conn_type = cpu_to_le32(conn_type); 1248 break; 1249 case NL80211_IFTYPE_ADHOC: 1250 basic_req.basic.conn_type = cpu_to_le32(CONNECTION_IBSS_ADHOC); 1251 break; 1252 default: 1253 WARN_ON(1); 1254 break; 1255 } 1256 1257 memcpy(basic_req.basic.bssid, vif->bss_conf.bssid, ETH_ALEN); 1258 basic_req.basic.bmc_tx_wlan_idx = cpu_to_le16(wcid->idx); 1259 basic_req.basic.sta_idx = cpu_to_le16(wcid->idx); 1260 basic_req.basic.conn_state = !enable; 1261 1262 err = mt76_mcu_send_msg(mdev, MCU_UNI_CMD_BSS_INFO_UPDATE, &basic_req, 1263 sizeof(basic_req), true); 1264 if (err < 0) 1265 return err; 1266 1267 if (vif->bss_conf.he_support) { 1268 struct { 1269 struct { 1270 u8 bss_idx; 1271 u8 pad[3]; 1272 } __packed hdr; 1273 struct bss_info_uni_he he; 1274 } he_req = { 1275 .hdr = { 1276 .bss_idx = mvif->idx, 1277 }, 1278 .he = { 1279 .tag = cpu_to_le16(UNI_BSS_INFO_HE_BASIC), 1280 .len = cpu_to_le16(sizeof(struct bss_info_uni_he)), 1281 }, 1282 }; 1283 1284 mt76_connac_mcu_uni_bss_he_tlv(phy, vif, 1285 (struct tlv *)&he_req.he); 1286 err = mt76_mcu_send_msg(mdev, MCU_UNI_CMD_BSS_INFO_UPDATE, 1287 &he_req, sizeof(he_req), true); 1288 if (err < 0) 1289 return err; 1290 } 1291 1292 switch (chandef->width) { 1293 case NL80211_CHAN_WIDTH_40: 1294 rlm_req.rlm.bw = CMD_CBW_40MHZ; 1295 break; 1296 case NL80211_CHAN_WIDTH_80: 1297 rlm_req.rlm.bw = CMD_CBW_80MHZ; 1298 break; 1299 case NL80211_CHAN_WIDTH_80P80: 1300 rlm_req.rlm.bw = CMD_CBW_8080MHZ; 1301 break; 1302 case NL80211_CHAN_WIDTH_160: 1303 rlm_req.rlm.bw = CMD_CBW_160MHZ; 1304 break; 1305 case NL80211_CHAN_WIDTH_5: 1306 rlm_req.rlm.bw = CMD_CBW_5MHZ; 1307 break; 1308 case NL80211_CHAN_WIDTH_10: 1309 rlm_req.rlm.bw = CMD_CBW_10MHZ; 1310 break; 1311 case NL80211_CHAN_WIDTH_20_NOHT: 1312 case NL80211_CHAN_WIDTH_20: 1313 default: 1314 rlm_req.rlm.bw = CMD_CBW_20MHZ; 1315 rlm_req.rlm.ht_op_info = 0; 1316 break; 1317 } 1318 1319 if (rlm_req.rlm.control_channel < rlm_req.rlm.center_chan) 1320 rlm_req.rlm.sco = 1; /* SCA */ 1321 else if (rlm_req.rlm.control_channel > rlm_req.rlm.center_chan) 1322 rlm_req.rlm.sco = 3; /* SCB */ 1323 1324 return mt76_mcu_send_msg(mdev, MCU_UNI_CMD_BSS_INFO_UPDATE, &rlm_req, 1325 sizeof(rlm_req), true); 1326 } 1327 EXPORT_SYMBOL_GPL(mt76_connac_mcu_uni_add_bss); 1328 1329 #define MT76_CONNAC_SCAN_CHANNEL_TIME 60 1330 int mt76_connac_mcu_hw_scan(struct mt76_phy *phy, struct ieee80211_vif *vif, 1331 struct ieee80211_scan_request *scan_req) 1332 { 1333 struct mt76_vif *mvif = (struct mt76_vif *)vif->drv_priv; 1334 struct cfg80211_scan_request *sreq = &scan_req->req; 1335 int n_ssids = 0, err, i, duration; 1336 int ext_channels_num = max_t(int, sreq->n_channels - 32, 0); 1337 struct ieee80211_channel **scan_list = sreq->channels; 1338 struct mt76_dev *mdev = phy->dev; 1339 bool ext_phy = phy == mdev->phy2; 1340 struct mt76_connac_mcu_scan_channel *chan; 1341 struct mt76_connac_hw_scan_req *req; 1342 struct sk_buff *skb; 1343 1344 skb = mt76_mcu_msg_alloc(mdev, NULL, sizeof(*req)); 1345 if (!skb) 1346 return -ENOMEM; 1347 1348 set_bit(MT76_HW_SCANNING, &phy->state); 1349 mvif->scan_seq_num = (mvif->scan_seq_num + 1) & 0x7f; 1350 1351 req = (struct mt76_connac_hw_scan_req *)skb_put(skb, sizeof(*req)); 1352 1353 req->seq_num = mvif->scan_seq_num | ext_phy << 7; 1354 req->bss_idx = mvif->idx; 1355 req->scan_type = sreq->n_ssids ? 1 : 0; 1356 req->probe_req_num = sreq->n_ssids ? 2 : 0; 1357 req->version = 1; 1358 1359 for (i = 0; i < sreq->n_ssids; i++) { 1360 if (!sreq->ssids[i].ssid_len) 1361 continue; 1362 1363 req->ssids[i].ssid_len = cpu_to_le32(sreq->ssids[i].ssid_len); 1364 memcpy(req->ssids[i].ssid, sreq->ssids[i].ssid, 1365 sreq->ssids[i].ssid_len); 1366 n_ssids++; 1367 } 1368 req->ssid_type = n_ssids ? BIT(2) : BIT(0); 1369 req->ssid_type_ext = n_ssids ? BIT(0) : 0; 1370 req->ssids_num = n_ssids; 1371 1372 duration = is_mt7921(phy->dev) ? 0 : MT76_CONNAC_SCAN_CHANNEL_TIME; 1373 /* increase channel time for passive scan */ 1374 if (!sreq->n_ssids) 1375 duration *= 2; 1376 req->timeout_value = cpu_to_le16(sreq->n_channels * duration); 1377 req->channel_min_dwell_time = cpu_to_le16(duration); 1378 req->channel_dwell_time = cpu_to_le16(duration); 1379 1380 req->channels_num = min_t(u8, sreq->n_channels, 32); 1381 req->ext_channels_num = min_t(u8, ext_channels_num, 32); 1382 for (i = 0; i < req->channels_num + req->ext_channels_num; i++) { 1383 if (i >= 32) 1384 chan = &req->ext_channels[i - 32]; 1385 else 1386 chan = &req->channels[i]; 1387 1388 chan->band = scan_list[i]->band == NL80211_BAND_2GHZ ? 1 : 2; 1389 chan->channel_num = scan_list[i]->hw_value; 1390 } 1391 req->channel_type = sreq->n_channels ? 4 : 0; 1392 1393 if (sreq->ie_len > 0) { 1394 memcpy(req->ies, sreq->ie, sreq->ie_len); 1395 req->ies_len = cpu_to_le16(sreq->ie_len); 1396 } 1397 1398 if (is_mt7921(phy->dev)) 1399 req->scan_func |= SCAN_FUNC_SPLIT_SCAN; 1400 1401 memcpy(req->bssid, sreq->bssid, ETH_ALEN); 1402 if (sreq->flags & NL80211_SCAN_FLAG_RANDOM_ADDR) { 1403 get_random_mask_addr(req->random_mac, sreq->mac_addr, 1404 sreq->mac_addr_mask); 1405 req->scan_func |= SCAN_FUNC_RANDOM_MAC; 1406 } 1407 1408 err = mt76_mcu_skb_send_msg(mdev, skb, MCU_CMD_START_HW_SCAN, false); 1409 if (err < 0) 1410 clear_bit(MT76_HW_SCANNING, &phy->state); 1411 1412 return err; 1413 } 1414 EXPORT_SYMBOL_GPL(mt76_connac_mcu_hw_scan); 1415 1416 int mt76_connac_mcu_cancel_hw_scan(struct mt76_phy *phy, 1417 struct ieee80211_vif *vif) 1418 { 1419 struct mt76_vif *mvif = (struct mt76_vif *)vif->drv_priv; 1420 struct { 1421 u8 seq_num; 1422 u8 is_ext_channel; 1423 u8 rsv[2]; 1424 } __packed req = { 1425 .seq_num = mvif->scan_seq_num, 1426 }; 1427 1428 if (test_and_clear_bit(MT76_HW_SCANNING, &phy->state)) { 1429 struct cfg80211_scan_info info = { 1430 .aborted = true, 1431 }; 1432 1433 ieee80211_scan_completed(phy->hw, &info); 1434 } 1435 1436 return mt76_mcu_send_msg(phy->dev, MCU_CMD_CANCEL_HW_SCAN, &req, 1437 sizeof(req), false); 1438 } 1439 EXPORT_SYMBOL_GPL(mt76_connac_mcu_cancel_hw_scan); 1440 1441 int mt76_connac_mcu_sched_scan_req(struct mt76_phy *phy, 1442 struct ieee80211_vif *vif, 1443 struct cfg80211_sched_scan_request *sreq) 1444 { 1445 struct mt76_vif *mvif = (struct mt76_vif *)vif->drv_priv; 1446 struct ieee80211_channel **scan_list = sreq->channels; 1447 struct mt76_connac_mcu_scan_channel *chan; 1448 struct mt76_connac_sched_scan_req *req; 1449 struct mt76_dev *mdev = phy->dev; 1450 bool ext_phy = phy == mdev->phy2; 1451 struct cfg80211_match_set *match; 1452 struct cfg80211_ssid *ssid; 1453 struct sk_buff *skb; 1454 int i; 1455 1456 skb = mt76_mcu_msg_alloc(mdev, NULL, sizeof(*req) + sreq->ie_len); 1457 if (!skb) 1458 return -ENOMEM; 1459 1460 mvif->scan_seq_num = (mvif->scan_seq_num + 1) & 0x7f; 1461 1462 req = (struct mt76_connac_sched_scan_req *)skb_put(skb, sizeof(*req)); 1463 req->version = 1; 1464 req->seq_num = mvif->scan_seq_num | ext_phy << 7; 1465 1466 if (is_mt7663(phy->dev) && 1467 (sreq->flags & NL80211_SCAN_FLAG_RANDOM_ADDR)) { 1468 get_random_mask_addr(req->mt7663.random_mac, sreq->mac_addr, 1469 sreq->mac_addr_mask); 1470 req->scan_func = 1; 1471 } else if (is_mt7921(phy->dev)) { 1472 req->mt7921.bss_idx = mvif->idx; 1473 } 1474 1475 req->ssids_num = sreq->n_ssids; 1476 for (i = 0; i < req->ssids_num; i++) { 1477 ssid = &sreq->ssids[i]; 1478 memcpy(req->ssids[i].ssid, ssid->ssid, ssid->ssid_len); 1479 req->ssids[i].ssid_len = cpu_to_le32(ssid->ssid_len); 1480 } 1481 1482 req->match_num = sreq->n_match_sets; 1483 for (i = 0; i < req->match_num; i++) { 1484 match = &sreq->match_sets[i]; 1485 memcpy(req->match[i].ssid, match->ssid.ssid, 1486 match->ssid.ssid_len); 1487 req->match[i].rssi_th = cpu_to_le32(match->rssi_thold); 1488 req->match[i].ssid_len = match->ssid.ssid_len; 1489 } 1490 1491 req->channel_type = sreq->n_channels ? 4 : 0; 1492 req->channels_num = min_t(u8, sreq->n_channels, 64); 1493 for (i = 0; i < req->channels_num; i++) { 1494 chan = &req->channels[i]; 1495 chan->band = scan_list[i]->band == NL80211_BAND_2GHZ ? 1 : 2; 1496 chan->channel_num = scan_list[i]->hw_value; 1497 } 1498 1499 req->intervals_num = sreq->n_scan_plans; 1500 for (i = 0; i < req->intervals_num; i++) 1501 req->intervals[i] = cpu_to_le16(sreq->scan_plans[i].interval); 1502 1503 if (sreq->ie_len > 0) { 1504 req->ie_len = cpu_to_le16(sreq->ie_len); 1505 memcpy(skb_put(skb, sreq->ie_len), sreq->ie, sreq->ie_len); 1506 } 1507 1508 return mt76_mcu_skb_send_msg(mdev, skb, MCU_CMD_SCHED_SCAN_REQ, false); 1509 } 1510 EXPORT_SYMBOL_GPL(mt76_connac_mcu_sched_scan_req); 1511 1512 int mt76_connac_mcu_sched_scan_enable(struct mt76_phy *phy, 1513 struct ieee80211_vif *vif, 1514 bool enable) 1515 { 1516 struct { 1517 u8 active; /* 0: enabled 1: disabled */ 1518 u8 rsv[3]; 1519 } __packed req = { 1520 .active = !enable, 1521 }; 1522 1523 if (enable) 1524 set_bit(MT76_HW_SCHED_SCANNING, &phy->state); 1525 else 1526 clear_bit(MT76_HW_SCHED_SCANNING, &phy->state); 1527 1528 return mt76_mcu_send_msg(phy->dev, MCU_CMD_SCHED_SCAN_ENABLE, &req, 1529 sizeof(req), false); 1530 } 1531 EXPORT_SYMBOL_GPL(mt76_connac_mcu_sched_scan_enable); 1532 1533 int mt76_connac_mcu_chip_config(struct mt76_dev *dev) 1534 { 1535 struct mt76_connac_config req = { 1536 .resp_type = 0, 1537 }; 1538 1539 memcpy(req.data, "assert", 7); 1540 1541 return mt76_mcu_send_msg(dev, MCU_CMD_CHIP_CONFIG, &req, sizeof(req), 1542 false); 1543 } 1544 EXPORT_SYMBOL_GPL(mt76_connac_mcu_chip_config); 1545 1546 int mt76_connac_mcu_set_deep_sleep(struct mt76_dev *dev, bool enable) 1547 { 1548 struct mt76_connac_config req = { 1549 .resp_type = 0, 1550 }; 1551 1552 snprintf(req.data, sizeof(req.data), "KeepFullPwr %d", !enable); 1553 1554 return mt76_mcu_send_msg(dev, MCU_CMD_CHIP_CONFIG, &req, sizeof(req), 1555 false); 1556 } 1557 EXPORT_SYMBOL_GPL(mt76_connac_mcu_set_deep_sleep); 1558 1559 void mt76_connac_mcu_coredump_event(struct mt76_dev *dev, struct sk_buff *skb, 1560 struct mt76_connac_coredump *coredump) 1561 { 1562 spin_lock_bh(&dev->lock); 1563 __skb_queue_tail(&coredump->msg_list, skb); 1564 spin_unlock_bh(&dev->lock); 1565 1566 coredump->last_activity = jiffies; 1567 1568 queue_delayed_work(dev->wq, &coredump->work, 1569 MT76_CONNAC_COREDUMP_TIMEOUT); 1570 } 1571 EXPORT_SYMBOL_GPL(mt76_connac_mcu_coredump_event); 1572 1573 static void 1574 mt76_connac_mcu_build_sku(struct mt76_dev *dev, s8 *sku, 1575 struct mt76_power_limits *limits, 1576 enum nl80211_band band) 1577 { 1578 int max_power = is_mt7921(dev) ? 127 : 63; 1579 int i, offset = sizeof(limits->cck); 1580 1581 memset(sku, max_power, MT_SKU_POWER_LIMIT); 1582 1583 if (band == NL80211_BAND_2GHZ) { 1584 /* cck */ 1585 memcpy(sku, limits->cck, sizeof(limits->cck)); 1586 } 1587 1588 /* ofdm */ 1589 memcpy(&sku[offset], limits->ofdm, sizeof(limits->ofdm)); 1590 offset += sizeof(limits->ofdm); 1591 1592 /* ht */ 1593 for (i = 0; i < 2; i++) { 1594 memcpy(&sku[offset], limits->mcs[i], 8); 1595 offset += 8; 1596 } 1597 sku[offset++] = limits->mcs[0][0]; 1598 1599 /* vht */ 1600 for (i = 0; i < ARRAY_SIZE(limits->mcs); i++) { 1601 memcpy(&sku[offset], limits->mcs[i], 1602 ARRAY_SIZE(limits->mcs[i])); 1603 offset += 12; 1604 } 1605 1606 if (!is_mt7921(dev)) 1607 return; 1608 1609 /* he */ 1610 for (i = 0; i < ARRAY_SIZE(limits->ru); i++) { 1611 memcpy(&sku[offset], limits->ru[i], ARRAY_SIZE(limits->ru[i])); 1612 offset += ARRAY_SIZE(limits->ru[i]); 1613 } 1614 } 1615 1616 static int 1617 mt76_connac_mcu_rate_txpower_band(struct mt76_phy *phy, 1618 enum nl80211_band band) 1619 { 1620 struct mt76_dev *dev = phy->dev; 1621 int sku_len, batch_len = is_mt7921(dev) ? 8 : 16; 1622 static const u8 chan_list_2ghz[] = { 1623 1, 2, 3, 4, 5, 6, 7, 1624 8, 9, 10, 11, 12, 13, 14 1625 }; 1626 static const u8 chan_list_5ghz[] = { 1627 36, 38, 40, 42, 44, 46, 48, 1628 50, 52, 54, 56, 58, 60, 62, 1629 64, 100, 102, 104, 106, 108, 110, 1630 112, 114, 116, 118, 120, 122, 124, 1631 126, 128, 132, 134, 136, 138, 140, 1632 142, 144, 149, 151, 153, 155, 157, 1633 159, 161, 165 1634 }; 1635 struct mt76_connac_sku_tlv sku_tlbv; 1636 int i, n_chan, batch_size, idx = 0; 1637 struct mt76_power_limits limits; 1638 const u8 *ch_list; 1639 1640 sku_len = is_mt7921(dev) ? sizeof(sku_tlbv) : sizeof(sku_tlbv) - 92; 1641 1642 if (band == NL80211_BAND_2GHZ) { 1643 n_chan = ARRAY_SIZE(chan_list_2ghz); 1644 ch_list = chan_list_2ghz; 1645 } else { 1646 n_chan = ARRAY_SIZE(chan_list_5ghz); 1647 ch_list = chan_list_5ghz; 1648 } 1649 batch_size = DIV_ROUND_UP(n_chan, batch_len); 1650 1651 for (i = 0; i < batch_size; i++) { 1652 bool last_msg = i == batch_size - 1; 1653 int num_ch = last_msg ? n_chan % batch_len : batch_len; 1654 struct mt76_connac_tx_power_limit_tlv tx_power_tlv = { 1655 .band = band == NL80211_BAND_2GHZ ? 1 : 2, 1656 .n_chan = num_ch, 1657 .last_msg = last_msg, 1658 }; 1659 struct sk_buff *skb; 1660 int j, err, msg_len; 1661 1662 msg_len = sizeof(tx_power_tlv) + num_ch * sizeof(sku_tlbv); 1663 skb = mt76_mcu_msg_alloc(dev, NULL, msg_len); 1664 if (!skb) 1665 return -ENOMEM; 1666 1667 BUILD_BUG_ON(sizeof(dev->alpha2) > sizeof(tx_power_tlv.alpha2)); 1668 memcpy(tx_power_tlv.alpha2, dev->alpha2, sizeof(dev->alpha2)); 1669 1670 skb_put_data(skb, &tx_power_tlv, sizeof(tx_power_tlv)); 1671 for (j = 0; j < num_ch; j++, idx++) { 1672 struct ieee80211_channel chan = { 1673 .hw_value = ch_list[idx], 1674 .band = band, 1675 }; 1676 1677 mt76_get_rate_power_limits(phy, &chan, &limits, 127); 1678 1679 sku_tlbv.channel = ch_list[idx]; 1680 mt76_connac_mcu_build_sku(dev, sku_tlbv.pwr_limit, 1681 &limits, band); 1682 skb_put_data(skb, &sku_tlbv, sku_len); 1683 } 1684 1685 err = mt76_mcu_skb_send_msg(dev, skb, 1686 MCU_CMD_SET_RATE_TX_POWER, false); 1687 if (err < 0) 1688 return err; 1689 } 1690 1691 return 0; 1692 } 1693 1694 int mt76_connac_mcu_set_rate_txpower(struct mt76_phy *phy) 1695 { 1696 int err; 1697 1698 err = mt76_connac_mcu_rate_txpower_band(phy, NL80211_BAND_2GHZ); 1699 if (err < 0) 1700 return err; 1701 1702 return mt76_connac_mcu_rate_txpower_band(phy, NL80211_BAND_5GHZ); 1703 } 1704 EXPORT_SYMBOL_GPL(mt76_connac_mcu_set_rate_txpower); 1705 1706 int mt76_connac_mcu_update_arp_filter(struct mt76_dev *dev, 1707 struct mt76_vif *vif, 1708 struct ieee80211_bss_conf *info) 1709 { 1710 struct sk_buff *skb; 1711 int i, len = min_t(int, info->arp_addr_cnt, 1712 IEEE80211_BSS_ARP_ADDR_LIST_LEN); 1713 struct { 1714 struct { 1715 u8 bss_idx; 1716 u8 pad[3]; 1717 } __packed hdr; 1718 struct mt76_connac_arpns_tlv arp; 1719 } req_hdr = { 1720 .hdr = { 1721 .bss_idx = vif->idx, 1722 }, 1723 .arp = { 1724 .tag = cpu_to_le16(UNI_OFFLOAD_OFFLOAD_ARP), 1725 .len = cpu_to_le16(sizeof(struct mt76_connac_arpns_tlv)), 1726 .ips_num = len, 1727 .mode = 2, /* update */ 1728 .option = 1, 1729 }, 1730 }; 1731 1732 skb = mt76_mcu_msg_alloc(dev, NULL, 1733 sizeof(req_hdr) + len * sizeof(__be32)); 1734 if (!skb) 1735 return -ENOMEM; 1736 1737 skb_put_data(skb, &req_hdr, sizeof(req_hdr)); 1738 for (i = 0; i < len; i++) { 1739 u8 *addr = (u8 *)skb_put(skb, sizeof(__be32)); 1740 1741 memcpy(addr, &info->arp_addr_list[i], sizeof(__be32)); 1742 } 1743 1744 return mt76_mcu_skb_send_msg(dev, skb, MCU_UNI_CMD_OFFLOAD, true); 1745 } 1746 EXPORT_SYMBOL_GPL(mt76_connac_mcu_update_arp_filter); 1747 1748 #ifdef CONFIG_PM 1749 1750 const struct wiphy_wowlan_support mt76_connac_wowlan_support = { 1751 .flags = WIPHY_WOWLAN_MAGIC_PKT | WIPHY_WOWLAN_DISCONNECT | 1752 WIPHY_WOWLAN_SUPPORTS_GTK_REKEY | WIPHY_WOWLAN_NET_DETECT, 1753 .n_patterns = 1, 1754 .pattern_min_len = 1, 1755 .pattern_max_len = MT76_CONNAC_WOW_PATTEN_MAX_LEN, 1756 .max_nd_match_sets = 10, 1757 }; 1758 EXPORT_SYMBOL_GPL(mt76_connac_wowlan_support); 1759 1760 static void 1761 mt76_connac_mcu_key_iter(struct ieee80211_hw *hw, 1762 struct ieee80211_vif *vif, 1763 struct ieee80211_sta *sta, 1764 struct ieee80211_key_conf *key, 1765 void *data) 1766 { 1767 struct mt76_connac_gtk_rekey_tlv *gtk_tlv = data; 1768 u32 cipher; 1769 1770 if (key->cipher != WLAN_CIPHER_SUITE_AES_CMAC && 1771 key->cipher != WLAN_CIPHER_SUITE_CCMP && 1772 key->cipher != WLAN_CIPHER_SUITE_TKIP) 1773 return; 1774 1775 if (key->cipher == WLAN_CIPHER_SUITE_TKIP) { 1776 gtk_tlv->proto = cpu_to_le32(NL80211_WPA_VERSION_1); 1777 cipher = BIT(3); 1778 } else { 1779 gtk_tlv->proto = cpu_to_le32(NL80211_WPA_VERSION_2); 1780 cipher = BIT(4); 1781 } 1782 1783 /* we are assuming here to have a single pairwise key */ 1784 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE) { 1785 gtk_tlv->pairwise_cipher = cpu_to_le32(cipher); 1786 gtk_tlv->group_cipher = cpu_to_le32(cipher); 1787 gtk_tlv->keyid = key->keyidx; 1788 } 1789 } 1790 1791 int mt76_connac_mcu_update_gtk_rekey(struct ieee80211_hw *hw, 1792 struct ieee80211_vif *vif, 1793 struct cfg80211_gtk_rekey_data *key) 1794 { 1795 struct mt76_vif *mvif = (struct mt76_vif *)vif->drv_priv; 1796 struct mt76_connac_gtk_rekey_tlv *gtk_tlv; 1797 struct mt76_phy *phy = hw->priv; 1798 struct sk_buff *skb; 1799 struct { 1800 u8 bss_idx; 1801 u8 pad[3]; 1802 } __packed hdr = { 1803 .bss_idx = mvif->idx, 1804 }; 1805 1806 skb = mt76_mcu_msg_alloc(phy->dev, NULL, 1807 sizeof(hdr) + sizeof(*gtk_tlv)); 1808 if (!skb) 1809 return -ENOMEM; 1810 1811 skb_put_data(skb, &hdr, sizeof(hdr)); 1812 gtk_tlv = (struct mt76_connac_gtk_rekey_tlv *)skb_put(skb, 1813 sizeof(*gtk_tlv)); 1814 gtk_tlv->tag = cpu_to_le16(UNI_OFFLOAD_OFFLOAD_GTK_REKEY); 1815 gtk_tlv->len = cpu_to_le16(sizeof(*gtk_tlv)); 1816 gtk_tlv->rekey_mode = 2; 1817 gtk_tlv->option = 1; 1818 1819 rcu_read_lock(); 1820 ieee80211_iter_keys_rcu(hw, vif, mt76_connac_mcu_key_iter, gtk_tlv); 1821 rcu_read_unlock(); 1822 1823 memcpy(gtk_tlv->kek, key->kek, NL80211_KEK_LEN); 1824 memcpy(gtk_tlv->kck, key->kck, NL80211_KCK_LEN); 1825 memcpy(gtk_tlv->replay_ctr, key->replay_ctr, NL80211_REPLAY_CTR_LEN); 1826 1827 return mt76_mcu_skb_send_msg(phy->dev, skb, MCU_UNI_CMD_OFFLOAD, true); 1828 } 1829 EXPORT_SYMBOL_GPL(mt76_connac_mcu_update_gtk_rekey); 1830 1831 static int 1832 mt76_connac_mcu_set_arp_filter(struct mt76_dev *dev, struct ieee80211_vif *vif, 1833 bool suspend) 1834 { 1835 struct mt76_vif *mvif = (struct mt76_vif *)vif->drv_priv; 1836 struct { 1837 struct { 1838 u8 bss_idx; 1839 u8 pad[3]; 1840 } __packed hdr; 1841 struct mt76_connac_arpns_tlv arpns; 1842 } req = { 1843 .hdr = { 1844 .bss_idx = mvif->idx, 1845 }, 1846 .arpns = { 1847 .tag = cpu_to_le16(UNI_OFFLOAD_OFFLOAD_ARP), 1848 .len = cpu_to_le16(sizeof(struct mt76_connac_arpns_tlv)), 1849 .mode = suspend, 1850 }, 1851 }; 1852 1853 return mt76_mcu_send_msg(dev, MCU_UNI_CMD_OFFLOAD, &req, sizeof(req), 1854 true); 1855 } 1856 1857 static int 1858 mt76_connac_mcu_set_gtk_rekey(struct mt76_dev *dev, struct ieee80211_vif *vif, 1859 bool suspend) 1860 { 1861 struct mt76_vif *mvif = (struct mt76_vif *)vif->drv_priv; 1862 struct { 1863 struct { 1864 u8 bss_idx; 1865 u8 pad[3]; 1866 } __packed hdr; 1867 struct mt76_connac_gtk_rekey_tlv gtk_tlv; 1868 } __packed req = { 1869 .hdr = { 1870 .bss_idx = mvif->idx, 1871 }, 1872 .gtk_tlv = { 1873 .tag = cpu_to_le16(UNI_OFFLOAD_OFFLOAD_GTK_REKEY), 1874 .len = cpu_to_le16(sizeof(struct mt76_connac_gtk_rekey_tlv)), 1875 .rekey_mode = !suspend, 1876 }, 1877 }; 1878 1879 return mt76_mcu_send_msg(dev, MCU_UNI_CMD_OFFLOAD, &req, sizeof(req), 1880 true); 1881 } 1882 1883 static int 1884 mt76_connac_mcu_set_suspend_mode(struct mt76_dev *dev, 1885 struct ieee80211_vif *vif, 1886 bool enable, u8 mdtim, 1887 bool wow_suspend) 1888 { 1889 struct mt76_vif *mvif = (struct mt76_vif *)vif->drv_priv; 1890 struct { 1891 struct { 1892 u8 bss_idx; 1893 u8 pad[3]; 1894 } __packed hdr; 1895 struct mt76_connac_suspend_tlv suspend_tlv; 1896 } req = { 1897 .hdr = { 1898 .bss_idx = mvif->idx, 1899 }, 1900 .suspend_tlv = { 1901 .tag = cpu_to_le16(UNI_SUSPEND_MODE_SETTING), 1902 .len = cpu_to_le16(sizeof(struct mt76_connac_suspend_tlv)), 1903 .enable = enable, 1904 .mdtim = mdtim, 1905 .wow_suspend = wow_suspend, 1906 }, 1907 }; 1908 1909 return mt76_mcu_send_msg(dev, MCU_UNI_CMD_SUSPEND, &req, sizeof(req), 1910 true); 1911 } 1912 1913 static int 1914 mt76_connac_mcu_set_wow_pattern(struct mt76_dev *dev, 1915 struct ieee80211_vif *vif, 1916 u8 index, bool enable, 1917 struct cfg80211_pkt_pattern *pattern) 1918 { 1919 struct mt76_vif *mvif = (struct mt76_vif *)vif->drv_priv; 1920 struct mt76_connac_wow_pattern_tlv *ptlv; 1921 struct sk_buff *skb; 1922 struct req_hdr { 1923 u8 bss_idx; 1924 u8 pad[3]; 1925 } __packed hdr = { 1926 .bss_idx = mvif->idx, 1927 }; 1928 1929 skb = mt76_mcu_msg_alloc(dev, NULL, sizeof(hdr) + sizeof(*ptlv)); 1930 if (!skb) 1931 return -ENOMEM; 1932 1933 skb_put_data(skb, &hdr, sizeof(hdr)); 1934 ptlv = (struct mt76_connac_wow_pattern_tlv *)skb_put(skb, sizeof(*ptlv)); 1935 ptlv->tag = cpu_to_le16(UNI_SUSPEND_WOW_PATTERN); 1936 ptlv->len = cpu_to_le16(sizeof(*ptlv)); 1937 ptlv->data_len = pattern->pattern_len; 1938 ptlv->enable = enable; 1939 ptlv->index = index; 1940 1941 memcpy(ptlv->pattern, pattern->pattern, pattern->pattern_len); 1942 memcpy(ptlv->mask, pattern->mask, pattern->pattern_len / 8); 1943 1944 return mt76_mcu_skb_send_msg(dev, skb, MCU_UNI_CMD_SUSPEND, true); 1945 } 1946 1947 static int 1948 mt76_connac_mcu_set_wow_ctrl(struct mt76_phy *phy, struct ieee80211_vif *vif, 1949 bool suspend, struct cfg80211_wowlan *wowlan) 1950 { 1951 struct mt76_vif *mvif = (struct mt76_vif *)vif->drv_priv; 1952 struct mt76_dev *dev = phy->dev; 1953 struct { 1954 struct { 1955 u8 bss_idx; 1956 u8 pad[3]; 1957 } __packed hdr; 1958 struct mt76_connac_wow_ctrl_tlv wow_ctrl_tlv; 1959 struct mt76_connac_wow_gpio_param_tlv gpio_tlv; 1960 } req = { 1961 .hdr = { 1962 .bss_idx = mvif->idx, 1963 }, 1964 .wow_ctrl_tlv = { 1965 .tag = cpu_to_le16(UNI_SUSPEND_WOW_CTRL), 1966 .len = cpu_to_le16(sizeof(struct mt76_connac_wow_ctrl_tlv)), 1967 .cmd = suspend ? 1 : 2, 1968 }, 1969 .gpio_tlv = { 1970 .tag = cpu_to_le16(UNI_SUSPEND_WOW_GPIO_PARAM), 1971 .len = cpu_to_le16(sizeof(struct mt76_connac_wow_gpio_param_tlv)), 1972 .gpio_pin = 0xff, /* follow fw about GPIO pin */ 1973 }, 1974 }; 1975 1976 if (wowlan->magic_pkt) 1977 req.wow_ctrl_tlv.trigger |= BIT(0); 1978 if (wowlan->disconnect) 1979 req.wow_ctrl_tlv.trigger |= BIT(2); 1980 if (wowlan->nd_config) { 1981 mt76_connac_mcu_sched_scan_req(phy, vif, wowlan->nd_config); 1982 req.wow_ctrl_tlv.trigger |= BIT(5); 1983 mt76_connac_mcu_sched_scan_enable(phy, vif, suspend); 1984 } 1985 1986 if (mt76_is_mmio(dev)) 1987 req.wow_ctrl_tlv.wakeup_hif = WOW_PCIE; 1988 else if (mt76_is_usb(dev)) 1989 req.wow_ctrl_tlv.wakeup_hif = WOW_USB; 1990 else if (mt76_is_sdio(dev)) 1991 req.wow_ctrl_tlv.wakeup_hif = WOW_GPIO; 1992 1993 return mt76_mcu_send_msg(dev, MCU_UNI_CMD_SUSPEND, &req, sizeof(req), 1994 true); 1995 } 1996 1997 int mt76_connac_mcu_set_hif_suspend(struct mt76_dev *dev, bool suspend) 1998 { 1999 struct { 2000 struct { 2001 u8 hif_type; /* 0x0: HIF_SDIO 2002 * 0x1: HIF_USB 2003 * 0x2: HIF_PCIE 2004 */ 2005 u8 pad[3]; 2006 } __packed hdr; 2007 struct hif_suspend_tlv { 2008 __le16 tag; 2009 __le16 len; 2010 u8 suspend; 2011 } __packed hif_suspend; 2012 } req = { 2013 .hif_suspend = { 2014 .tag = cpu_to_le16(0), /* 0: UNI_HIF_CTRL_BASIC */ 2015 .len = cpu_to_le16(sizeof(struct hif_suspend_tlv)), 2016 .suspend = suspend, 2017 }, 2018 }; 2019 2020 if (mt76_is_mmio(dev)) 2021 req.hdr.hif_type = 2; 2022 else if (mt76_is_usb(dev)) 2023 req.hdr.hif_type = 1; 2024 else if (mt76_is_sdio(dev)) 2025 req.hdr.hif_type = 0; 2026 2027 return mt76_mcu_send_msg(dev, MCU_UNI_CMD_HIF_CTRL, &req, sizeof(req), 2028 true); 2029 } 2030 EXPORT_SYMBOL_GPL(mt76_connac_mcu_set_hif_suspend); 2031 2032 void mt76_connac_mcu_set_suspend_iter(void *priv, u8 *mac, 2033 struct ieee80211_vif *vif) 2034 { 2035 struct mt76_phy *phy = priv; 2036 bool suspend = test_bit(MT76_STATE_SUSPEND, &phy->state); 2037 struct ieee80211_hw *hw = phy->hw; 2038 struct cfg80211_wowlan *wowlan = hw->wiphy->wowlan_config; 2039 int i; 2040 2041 mt76_connac_mcu_set_gtk_rekey(phy->dev, vif, suspend); 2042 mt76_connac_mcu_set_arp_filter(phy->dev, vif, suspend); 2043 2044 mt76_connac_mcu_set_suspend_mode(phy->dev, vif, suspend, 1, true); 2045 2046 for (i = 0; i < wowlan->n_patterns; i++) 2047 mt76_connac_mcu_set_wow_pattern(phy->dev, vif, i, suspend, 2048 &wowlan->patterns[i]); 2049 mt76_connac_mcu_set_wow_ctrl(phy, vif, suspend, wowlan); 2050 } 2051 EXPORT_SYMBOL_GPL(mt76_connac_mcu_set_suspend_iter); 2052 2053 #endif /* CONFIG_PM */ 2054 2055 MODULE_AUTHOR("Lorenzo Bianconi <lorenzo@kernel.org>"); 2056 MODULE_LICENSE("Dual BSD/GPL"); 2057