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