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