drivers/net/wireless/mediatek/mt76/mt76_connac_mcu.c

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