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

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