1// SPDX-License-Identifier: ISC
   2/* Copyright (C) 2023 MediaTek Inc. */
   3
   4#include <linux/fs.h>
   5#include <linux/firmware.h>
   6#include "mt7925.h"
   7#include "mcu.h"
   8#include "mac.h"
   9
  10#define MT_STA_BFER			BIT(0)
  11#define MT_STA_BFEE			BIT(1)
  12
  13static bool mt7925_disable_clc;
  14module_param_named(disable_clc, mt7925_disable_clc, bool, 0644);
  15MODULE_PARM_DESC(disable_clc, "disable CLC support");
  16
  17int mt7925_mcu_parse_response(struct mt76_dev *mdev, int cmd,
  18			      struct sk_buff *skb, int seq)
  19{
  20	int mcu_cmd = FIELD_GET(__MCU_CMD_FIELD_ID, cmd);
  21	struct mt7925_mcu_rxd *rxd;
  22	int ret = 0;
  23
  24	if (!skb) {
  25		dev_err(mdev->dev, "Message %08x (seq %d) timeout\n", cmd, seq);
  26		mt792x_reset(mdev);
  27
  28		return -ETIMEDOUT;
  29	}
  30
  31	rxd = (struct mt7925_mcu_rxd *)skb->data;
  32	if (seq != rxd->seq)
  33		return -EAGAIN;
  34
  35	if (cmd == MCU_CMD(PATCH_SEM_CONTROL) ||
  36	    cmd == MCU_CMD(PATCH_FINISH_REQ)) {
  37		skb_pull(skb, sizeof(*rxd) - 4);
  38		ret = *skb->data;
  39	} else if (cmd == MCU_UNI_CMD(DEV_INFO_UPDATE) ||
  40		   cmd == MCU_UNI_CMD(BSS_INFO_UPDATE) ||
  41		   cmd == MCU_UNI_CMD(STA_REC_UPDATE) ||
  42		   cmd == MCU_UNI_CMD(HIF_CTRL) ||
  43		   cmd == MCU_UNI_CMD(OFFLOAD) ||
  44		   cmd == MCU_UNI_CMD(SUSPEND)) {
  45		struct mt7925_mcu_uni_event *event;
  46
  47		skb_pull(skb, sizeof(*rxd));
  48		event = (struct mt7925_mcu_uni_event *)skb->data;
  49		ret = le32_to_cpu(event->status);
  50		/* skip invalid event */
  51		if (mcu_cmd != event->cid)
  52			ret = -EAGAIN;
  53	} else {
  54		skb_pull(skb, sizeof(*rxd));
  55	}
  56
  57	return ret;
  58}
  59EXPORT_SYMBOL_GPL(mt7925_mcu_parse_response);
  60
  61int mt7925_mcu_regval(struct mt792x_dev *dev, u32 regidx, u32 *val, bool set)
  62{
  63#define MT_RF_REG_HDR           GENMASK(31, 24)
  64#define MT_RF_REG_ANT           GENMASK(23, 16)
  65#define RF_REG_PREFIX           0x99
  66	struct {
  67		u8 __rsv[4];
  68		union {
  69			struct uni_cmd_access_reg_basic {
  70				__le16 tag;
  71				__le16 len;
  72				__le32 idx;
  73				__le32 data;
  74			} __packed reg;
  75			struct uni_cmd_access_rf_reg_basic {
  76				__le16 tag;
  77				__le16 len;
  78				__le16 ant;
  79				u8 __rsv[2];
  80				__le32 idx;
  81				__le32 data;
  82			} __packed rf_reg;
  83		};
  84	} __packed * res, req;
  85	struct sk_buff *skb;
  86	int ret;
  87
  88	if (u32_get_bits(regidx, MT_RF_REG_HDR) == RF_REG_PREFIX) {
  89		req.rf_reg.tag = cpu_to_le16(UNI_CMD_ACCESS_RF_REG_BASIC);
  90		req.rf_reg.len = cpu_to_le16(sizeof(req.rf_reg));
  91		req.rf_reg.ant = cpu_to_le16(u32_get_bits(regidx, MT_RF_REG_ANT));
  92		req.rf_reg.idx = cpu_to_le32(regidx);
  93		req.rf_reg.data = set ? cpu_to_le32(*val) : 0;
  94	} else {
  95		req.reg.tag = cpu_to_le16(UNI_CMD_ACCESS_REG_BASIC);
  96		req.reg.len = cpu_to_le16(sizeof(req.reg));
  97		req.reg.idx = cpu_to_le32(regidx);
  98		req.reg.data = set ? cpu_to_le32(*val) : 0;
  99	}
 100
 101	if (set)
 102		return mt76_mcu_send_msg(&dev->mt76, MCU_WM_UNI_CMD(REG_ACCESS),
 103					 &req, sizeof(req), true);
 104
 105	ret = mt76_mcu_send_and_get_msg(&dev->mt76,
 106					MCU_WM_UNI_CMD_QUERY(REG_ACCESS),
 107					&req, sizeof(req), true, &skb);
 108	if (ret)
 109		return ret;
 110
 111	res = (void *)skb->data;
 112	if (u32_get_bits(regidx, MT_RF_REG_HDR) == RF_REG_PREFIX)
 113		*val = le32_to_cpu(res->rf_reg.data);
 114	else
 115		*val = le32_to_cpu(res->reg.data);
 116
 117	dev_kfree_skb(skb);
 118
 119	return 0;
 120}
 121EXPORT_SYMBOL_GPL(mt7925_mcu_regval);
 122
 123int mt7925_mcu_update_arp_filter(struct mt76_dev *dev,
 124				 struct mt76_vif *vif,
 125				 struct ieee80211_bss_conf *info)
 126{
 127	struct ieee80211_vif *mvif = container_of(info, struct ieee80211_vif,
 128						  bss_conf);
 129	struct sk_buff *skb;
 130	int i, len = min_t(int, mvif->cfg.arp_addr_cnt,
 131			   IEEE80211_BSS_ARP_ADDR_LIST_LEN);
 132	struct {
 133		struct {
 134			u8 bss_idx;
 135			u8 pad[3];
 136		} __packed hdr;
 137		struct mt7925_arpns_tlv arp;
 138	} req = {
 139		.hdr = {
 140			.bss_idx = vif->idx,
 141		},
 142		.arp = {
 143			.tag = cpu_to_le16(UNI_OFFLOAD_OFFLOAD_ARP),
 144			.len = cpu_to_le16(sizeof(req) - 4 + len * 2 * sizeof(__be32)),
 145			.ips_num = len,
 146			.enable = true,
 147		},
 148	};
 149
 150	skb = mt76_mcu_msg_alloc(dev, NULL, sizeof(req) + len * 2 * sizeof(__be32));
 151	if (!skb)
 152		return -ENOMEM;
 153
 154	skb_put_data(skb, &req, sizeof(req));
 155	for (i = 0; i < len; i++) {
 156		skb_put_data(skb, &mvif->cfg.arp_addr_list[i], sizeof(__be32));
 157		skb_put_zero(skb, sizeof(__be32));
 158	}
 159
 160	return mt76_mcu_skb_send_msg(dev, skb, MCU_UNI_CMD(OFFLOAD), true);
 161}
 162
 163#ifdef CONFIG_PM
 164static int
 165mt7925_connac_mcu_set_wow_ctrl(struct mt76_phy *phy, struct ieee80211_vif *vif,
 166			       bool suspend, struct cfg80211_wowlan *wowlan)
 167{
 168	struct mt76_vif *mvif = (struct mt76_vif *)vif->drv_priv;
 169	struct mt76_dev *dev = phy->dev;
 170	struct {
 171		struct {
 172			u8 bss_idx;
 173			u8 pad[3];
 174		} __packed hdr;
 175		struct mt76_connac_wow_ctrl_tlv wow_ctrl_tlv;
 176		struct mt76_connac_wow_gpio_param_tlv gpio_tlv;
 177	} req = {
 178		.hdr = {
 179			.bss_idx = mvif->idx,
 180		},
 181		.wow_ctrl_tlv = {
 182			.tag = cpu_to_le16(UNI_SUSPEND_WOW_CTRL),
 183			.len = cpu_to_le16(sizeof(struct mt76_connac_wow_ctrl_tlv)),
 184			.cmd = suspend ? 1 : 2,
 185		},
 186		.gpio_tlv = {
 187			.tag = cpu_to_le16(UNI_SUSPEND_WOW_GPIO_PARAM),
 188			.len = cpu_to_le16(sizeof(struct mt76_connac_wow_gpio_param_tlv)),
 189			.gpio_pin = 0xff, /* follow fw about GPIO pin */
 190		},
 191	};
 192
 193	if (wowlan->magic_pkt)
 194		req.wow_ctrl_tlv.trigger |= UNI_WOW_DETECT_TYPE_MAGIC;
 195	if (wowlan->disconnect)
 196		req.wow_ctrl_tlv.trigger |= (UNI_WOW_DETECT_TYPE_DISCONNECT |
 197					     UNI_WOW_DETECT_TYPE_BCN_LOST);
 198	if (wowlan->nd_config) {
 199		mt7925_mcu_sched_scan_req(phy, vif, wowlan->nd_config);
 200		req.wow_ctrl_tlv.trigger |= UNI_WOW_DETECT_TYPE_SCH_SCAN_HIT;
 201		mt7925_mcu_sched_scan_enable(phy, vif, suspend);
 202	}
 203	if (wowlan->n_patterns)
 204		req.wow_ctrl_tlv.trigger |= UNI_WOW_DETECT_TYPE_BITMAP;
 205
 206	if (mt76_is_mmio(dev))
 207		req.wow_ctrl_tlv.wakeup_hif = WOW_PCIE;
 208	else if (mt76_is_usb(dev))
 209		req.wow_ctrl_tlv.wakeup_hif = WOW_USB;
 210	else if (mt76_is_sdio(dev))
 211		req.wow_ctrl_tlv.wakeup_hif = WOW_GPIO;
 212
 213	return mt76_mcu_send_msg(dev, MCU_UNI_CMD(SUSPEND), &req,
 214				 sizeof(req), true);
 215}
 216
 217static int
 218mt7925_mcu_set_wow_pattern(struct mt76_dev *dev,
 219			   struct ieee80211_vif *vif,
 220			   u8 index, bool enable,
 221			   struct cfg80211_pkt_pattern *pattern)
 222{
 223	struct mt76_vif *mvif = (struct mt76_vif *)vif->drv_priv;
 224	struct mt7925_wow_pattern_tlv *tlv;
 225	struct sk_buff *skb;
 226	struct {
 227		u8 bss_idx;
 228		u8 pad[3];
 229	} __packed hdr = {
 230		.bss_idx = mvif->idx,
 231	};
 232
 233	skb = mt76_mcu_msg_alloc(dev, NULL, sizeof(hdr) + sizeof(*tlv));
 234	if (!skb)
 235		return -ENOMEM;
 236
 237	skb_put_data(skb, &hdr, sizeof(hdr));
 238	tlv = (struct mt7925_wow_pattern_tlv *)skb_put(skb, sizeof(*tlv));
 239	tlv->tag = cpu_to_le16(UNI_SUSPEND_WOW_PATTERN);
 240	tlv->len = cpu_to_le16(sizeof(*tlv));
 241	tlv->bss_idx = 0xF;
 242	tlv->data_len = pattern->pattern_len;
 243	tlv->enable = enable;
 244	tlv->index = index;
 245	tlv->offset = 0;
 246
 247	memcpy(tlv->pattern, pattern->pattern, pattern->pattern_len);
 248	memcpy(tlv->mask, pattern->mask, DIV_ROUND_UP(pattern->pattern_len, 8));
 249
 250	return mt76_mcu_skb_send_msg(dev, skb, MCU_UNI_CMD(SUSPEND), true);
 251}
 252
 253void mt7925_mcu_set_suspend_iter(void *priv, u8 *mac,
 254				 struct ieee80211_vif *vif)
 255{
 256	struct mt76_phy *phy = priv;
 257	bool suspend = !test_bit(MT76_STATE_RUNNING, &phy->state);
 258	struct ieee80211_hw *hw = phy->hw;
 259	struct cfg80211_wowlan *wowlan = hw->wiphy->wowlan_config;
 260	int i;
 261
 262	mt76_connac_mcu_set_gtk_rekey(phy->dev, vif, suspend);
 263
 264	mt76_connac_mcu_set_suspend_mode(phy->dev, vif, suspend, 1, true);
 265
 266	for (i = 0; i < wowlan->n_patterns; i++)
 267		mt7925_mcu_set_wow_pattern(phy->dev, vif, i, suspend,
 268					   &wowlan->patterns[i]);
 269	mt7925_connac_mcu_set_wow_ctrl(phy, vif, suspend, wowlan);
 270}
 271
 272#endif /* CONFIG_PM */
 273
 274static void
 275mt7925_mcu_connection_loss_iter(void *priv, u8 *mac,
 276				struct ieee80211_vif *vif)
 277{
 278	struct mt76_vif *mvif = (struct mt76_vif *)vif->drv_priv;
 279	struct mt7925_uni_beacon_loss_event *event = priv;
 280
 281	if (mvif->idx != event->hdr.bss_idx)
 282		return;
 283
 284	if (!(vif->driver_flags & IEEE80211_VIF_BEACON_FILTER) ||
 285	    vif->type != NL80211_IFTYPE_STATION)
 286		return;
 287
 288	ieee80211_connection_loss(vif);
 289}
 290
 291static void
 292mt7925_mcu_connection_loss_event(struct mt792x_dev *dev, struct sk_buff *skb)
 293{
 294	struct mt7925_uni_beacon_loss_event *event;
 295	struct mt76_phy *mphy = &dev->mt76.phy;
 296
 297	skb_pull(skb, sizeof(struct mt7925_mcu_rxd));
 298	event = (struct mt7925_uni_beacon_loss_event *)skb->data;
 299
 300	ieee80211_iterate_active_interfaces_atomic(mphy->hw,
 301					IEEE80211_IFACE_ITER_RESUME_ALL,
 302					mt7925_mcu_connection_loss_iter, event);
 303}
 304
 305static void
 306mt7925_mcu_roc_iter(void *priv, u8 *mac, struct ieee80211_vif *vif)
 307{
 308	struct mt76_vif *mvif = (struct mt76_vif *)vif->drv_priv;
 309	struct mt7925_roc_grant_tlv *grant = priv;
 310
 311	if (mvif->idx != grant->bss_idx)
 312		return;
 313
 314	mvif->band_idx = grant->dbdcband;
 315}
 316
 317static void
 318mt7925_mcu_uni_roc_event(struct mt792x_dev *dev, struct sk_buff *skb)
 319{
 320	struct ieee80211_hw *hw = dev->mt76.hw;
 321	struct mt7925_roc_grant_tlv *grant;
 322	struct mt7925_mcu_rxd *rxd;
 323	int duration;
 324
 325	rxd = (struct mt7925_mcu_rxd *)skb->data;
 326	grant = (struct mt7925_roc_grant_tlv *)(rxd->tlv + 4);
 327
 328	/* should never happen */
 329	WARN_ON_ONCE((le16_to_cpu(grant->tag) != UNI_EVENT_ROC_GRANT));
 330
 331	if (grant->reqtype == MT7925_ROC_REQ_ROC)
 332		ieee80211_ready_on_channel(hw);
 333	else if (grant->reqtype == MT7925_ROC_REQ_JOIN)
 334		ieee80211_iterate_active_interfaces_atomic(hw,
 335						IEEE80211_IFACE_ITER_RESUME_ALL,
 336						mt7925_mcu_roc_iter, grant);
 337	dev->phy.roc_grant = true;
 338	wake_up(&dev->phy.roc_wait);
 339	duration = le32_to_cpu(grant->max_interval);
 340	mod_timer(&dev->phy.roc_timer,
 341		  jiffies + msecs_to_jiffies(duration));
 342}
 343
 344static void
 345mt7925_mcu_scan_event(struct mt792x_dev *dev, struct sk_buff *skb)
 346{
 347	struct mt76_phy *mphy = &dev->mt76.phy;
 348	struct mt792x_phy *phy = mphy->priv;
 349
 350	spin_lock_bh(&dev->mt76.lock);
 351	__skb_queue_tail(&phy->scan_event_list, skb);
 352	spin_unlock_bh(&dev->mt76.lock);
 353
 354	ieee80211_queue_delayed_work(mphy->hw, &phy->scan_work,
 355				     MT792x_HW_SCAN_TIMEOUT);
 356}
 357
 358static void
 359mt7925_mcu_tx_done_event(struct mt792x_dev *dev, struct sk_buff *skb)
 360{
 361#define UNI_EVENT_TX_DONE_MSG 0
 362#define UNI_EVENT_TX_DONE_RAW 1
 363	struct mt7925_mcu_txs_event {
 364		u8 ver;
 365		u8 rsv[3];
 366		u8 data[0];
 367	} __packed * txs;
 368	struct tlv *tlv;
 369	u32 tlv_len;
 370
 371	skb_pull(skb, sizeof(struct mt7925_mcu_rxd) + 4);
 372	tlv = (struct tlv *)skb->data;
 373	tlv_len = skb->len;
 374
 375	while (tlv_len > 0 && le16_to_cpu(tlv->len) <= tlv_len) {
 376		switch (le16_to_cpu(tlv->tag)) {
 377		case UNI_EVENT_TX_DONE_RAW:
 378			txs = (struct mt7925_mcu_txs_event *)tlv->data;
 379			mt7925_mac_add_txs(dev, txs->data);
 380			break;
 381		default:
 382			break;
 383		}
 384		tlv_len -= le16_to_cpu(tlv->len);
 385		tlv = (struct tlv *)((char *)(tlv) + le16_to_cpu(tlv->len));
 386	}
 387}
 388
 389static void
 390mt7925_mcu_uni_debug_msg_event(struct mt792x_dev *dev, struct sk_buff *skb)
 391{
 392	struct mt7925_uni_debug_msg {
 393		__le16 tag;
 394		__le16 len;
 395		u8 fmt;
 396		u8 rsv[3];
 397		u8 id;
 398		u8 type:3;
 399		u8 nr_args:5;
 400		union {
 401			struct idxlog {
 402				__le16 rsv;
 403				__le32 ts;
 404				__le32 idx;
 405				u8 data[];
 406			} __packed idx;
 407			struct txtlog {
 408				u8 len;
 409				u8 rsv;
 410				__le32 ts;
 411				u8 data[];
 412			} __packed txt;
 413		};
 414	} __packed * hdr;
 415
 416	skb_pull(skb, sizeof(struct mt7925_mcu_rxd) + 4);
 417	hdr = (struct mt7925_uni_debug_msg *)skb->data;
 418
 419	if (hdr->id == 0x28) {
 420		skb_pull(skb, offsetof(struct mt7925_uni_debug_msg, id));
 421		wiphy_info(mt76_hw(dev)->wiphy, "%.*s", skb->len, skb->data);
 422		return;
 423	} else if (hdr->id != 0xa8) {
 424		return;
 425	}
 426
 427	if (hdr->type == 0) { /* idx log */
 428		int i, ret, len = PAGE_SIZE - 1, nr_val;
 429		struct page *page = dev_alloc_pages(get_order(len));
 430		__le32 *val;
 431		char *buf, *cur;
 432
 433		if (!page)
 434			return;
 435
 436		buf = page_address(page);
 437		cur = buf;
 438
 439		nr_val = (le16_to_cpu(hdr->len) - sizeof(*hdr)) / 4;
 440		val = (__le32 *)hdr->idx.data;
 441		for (i = 0; i < nr_val && len > 0; i++) {
 442			ret = snprintf(cur, len, "0x%x,", le32_to_cpu(val[i]));
 443			if (ret <= 0)
 444				break;
 445
 446			cur += ret;
 447			len -= ret;
 448		}
 449		if (cur > buf)
 450			wiphy_info(mt76_hw(dev)->wiphy, "idx: 0x%X,%d,%s",
 451				   le32_to_cpu(hdr->idx.idx), nr_val, buf);
 452		put_page(page);
 453	} else if (hdr->type == 2) { /* str log */
 454		wiphy_info(mt76_hw(dev)->wiphy, "%.*s", hdr->txt.len, hdr->txt.data);
 455	}
 456}
 457
 458static void
 459mt7925_mcu_uni_rx_unsolicited_event(struct mt792x_dev *dev,
 460				    struct sk_buff *skb)
 461{
 462	struct mt7925_mcu_rxd *rxd;
 463
 464	rxd = (struct mt7925_mcu_rxd *)skb->data;
 465
 466	switch (rxd->eid) {
 467	case MCU_UNI_EVENT_FW_LOG_2_HOST:
 468		mt7925_mcu_uni_debug_msg_event(dev, skb);
 469		break;
 470	case MCU_UNI_EVENT_ROC:
 471		mt7925_mcu_uni_roc_event(dev, skb);
 472		break;
 473	case MCU_UNI_EVENT_SCAN_DONE:
 474		mt7925_mcu_scan_event(dev, skb);
 475		return;
 476	case MCU_UNI_EVENT_TX_DONE:
 477		mt7925_mcu_tx_done_event(dev, skb);
 478		break;
 479	case MCU_UNI_EVENT_BSS_BEACON_LOSS:
 480		mt7925_mcu_connection_loss_event(dev, skb);
 481		break;
 482	case MCU_UNI_EVENT_COREDUMP:
 483		dev->fw_assert = true;
 484		mt76_connac_mcu_coredump_event(&dev->mt76, skb, &dev->coredump);
 485		return;
 486	default:
 487		break;
 488	}
 489	dev_kfree_skb(skb);
 490}
 491
 492void mt7925_mcu_rx_event(struct mt792x_dev *dev, struct sk_buff *skb)
 493{
 494	struct mt7925_mcu_rxd *rxd = (struct mt7925_mcu_rxd *)skb->data;
 495
 496	if (skb_linearize(skb))
 497		return;
 498
 499	if (rxd->option & MCU_UNI_CMD_UNSOLICITED_EVENT) {
 500		mt7925_mcu_uni_rx_unsolicited_event(dev, skb);
 501		return;
 502	}
 503
 504	mt76_mcu_rx_event(&dev->mt76, skb);
 505}
 506
 507static int
 508mt7925_mcu_sta_ba(struct mt76_dev *dev, struct mt76_vif *mvif,
 509		  struct ieee80211_ampdu_params *params,
 510		  bool enable, bool tx)
 511{
 512	struct mt76_wcid *wcid = (struct mt76_wcid *)params->sta->drv_priv;
 513	struct sta_rec_ba_uni *ba;
 514	struct sk_buff *skb;
 515	struct tlv *tlv;
 516	int len;
 517
 518	len = sizeof(struct sta_req_hdr) + sizeof(*ba);
 519	skb = __mt76_connac_mcu_alloc_sta_req(dev, mvif, wcid,
 520					      len);
 521	if (IS_ERR(skb))
 522		return PTR_ERR(skb);
 523
 524	tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_BA, sizeof(*ba));
 525
 526	ba = (struct sta_rec_ba_uni *)tlv;
 527	ba->ba_type = tx ? MT_BA_TYPE_ORIGINATOR : MT_BA_TYPE_RECIPIENT;
 528	ba->winsize = cpu_to_le16(params->buf_size);
 529	ba->ssn = cpu_to_le16(params->ssn);
 530	ba->ba_en = enable << params->tid;
 531	ba->amsdu = params->amsdu;
 532	ba->tid = params->tid;
 533
 534	return mt76_mcu_skb_send_msg(dev, skb,
 535				     MCU_UNI_CMD(STA_REC_UPDATE), true);
 536}
 537
 538/** starec & wtbl **/
 539int mt7925_mcu_uni_tx_ba(struct mt792x_dev *dev,
 540			 struct ieee80211_ampdu_params *params,
 541			 bool enable)
 542{
 543	struct mt792x_sta *msta = (struct mt792x_sta *)params->sta->drv_priv;
 544	struct mt792x_vif *mvif = msta->vif;
 545
 546	if (enable && !params->amsdu)
 547		msta->wcid.amsdu = false;
 548
 549	return mt7925_mcu_sta_ba(&dev->mt76, &mvif->mt76, params,
 550				 enable, true);
 551}
 552
 553int mt7925_mcu_uni_rx_ba(struct mt792x_dev *dev,
 554			 struct ieee80211_ampdu_params *params,
 555			 bool enable)
 556{
 557	struct mt792x_sta *msta = (struct mt792x_sta *)params->sta->drv_priv;
 558	struct mt792x_vif *mvif = msta->vif;
 559
 560	return mt7925_mcu_sta_ba(&dev->mt76, &mvif->mt76, params,
 561				 enable, false);
 562}
 563
 564static int mt7925_load_clc(struct mt792x_dev *dev, const char *fw_name)
 565{
 566	const struct mt76_connac2_fw_trailer *hdr;
 567	const struct mt76_connac2_fw_region *region;
 568	const struct mt7925_clc *clc;
 569	struct mt76_dev *mdev = &dev->mt76;
 570	struct mt792x_phy *phy = &dev->phy;
 571	const struct firmware *fw;
 572	int ret, i, len, offset = 0;
 573	u8 *clc_base = NULL;
 574
 575	if (mt7925_disable_clc ||
 576	    mt76_is_usb(&dev->mt76))
 577		return 0;
 578
 579	ret = request_firmware(&fw, fw_name, mdev->dev);
 580	if (ret)
 581		return ret;
 582
 583	if (!fw || !fw->data || fw->size < sizeof(*hdr)) {
 584		dev_err(mdev->dev, "Invalid firmware\n");
 585		ret = -EINVAL;
 586		goto out;
 587	}
 588
 589	hdr = (const void *)(fw->data + fw->size - sizeof(*hdr));
 590	for (i = 0; i < hdr->n_region; i++) {
 591		region = (const void *)((const u8 *)hdr -
 592					(hdr->n_region - i) * sizeof(*region));
 593		len = le32_to_cpu(region->len);
 594
 595		/* check if we have valid buffer size */
 596		if (offset + len > fw->size) {
 597			dev_err(mdev->dev, "Invalid firmware region\n");
 598			ret = -EINVAL;
 599			goto out;
 600		}
 601
 602		if ((region->feature_set & FW_FEATURE_NON_DL) &&
 603		    region->type == FW_TYPE_CLC) {
 604			clc_base = (u8 *)(fw->data + offset);
 605			break;
 606		}
 607		offset += len;
 608	}
 609
 610	if (!clc_base)
 611		goto out;
 612
 613	for (offset = 0; offset < len; offset += le32_to_cpu(clc->len)) {
 614		clc = (const struct mt7925_clc *)(clc_base + offset);
 615
 616		/* do not init buf again if chip reset triggered */
 617		if (phy->clc[clc->idx])
 618			continue;
 619
 620		phy->clc[clc->idx] = devm_kmemdup(mdev->dev, clc,
 621						  le32_to_cpu(clc->len),
 622						  GFP_KERNEL);
 623
 624		if (!phy->clc[clc->idx]) {
 625			ret = -ENOMEM;
 626			goto out;
 627		}
 628	}
 629
 630	ret = mt7925_mcu_set_clc(dev, "00", ENVIRON_INDOOR);
 631out:
 632	release_firmware(fw);
 633
 634	return ret;
 635}
 636
 637int mt7925_mcu_fw_log_2_host(struct mt792x_dev *dev, u8 ctrl)
 638{
 639	struct {
 640		u8 _rsv[4];
 641
 642		__le16 tag;
 643		__le16 len;
 644		u8 ctrl;
 645		u8 interval;
 646		u8 _rsv2[2];
 647	} __packed req = {
 648		.tag = cpu_to_le16(UNI_WSYS_CONFIG_FW_LOG_CTRL),
 649		.len = cpu_to_le16(sizeof(req) - 4),
 650		.ctrl = ctrl,
 651	};
 652	int ret;
 653
 654	ret = mt76_mcu_send_and_get_msg(&dev->mt76, MCU_UNI_CMD(WSYS_CONFIG),
 655					&req, sizeof(req), false, NULL);
 656	return ret;
 657}
 658
 659static void
 660mt7925_mcu_parse_phy_cap(struct mt792x_dev *dev, char *data)
 661{
 662	struct mt76_phy *mphy = &dev->mt76.phy;
 663	struct mt76_dev *mdev = mphy->dev;
 664	struct mt7925_mcu_phy_cap {
 665		u8 ht;
 666		u8 vht;
 667		u8 _5g;
 668		u8 max_bw;
 669		u8 nss;
 670		u8 dbdc;
 671		u8 tx_ldpc;
 672		u8 rx_ldpc;
 673		u8 tx_stbc;
 674		u8 rx_stbc;
 675		u8 hw_path;
 676		u8 he;
 677		u8 eht;
 678	} __packed * cap;
 679	enum {
 680		WF0_24G,
 681		WF0_5G
 682	};
 683
 684	cap = (struct mt7925_mcu_phy_cap *)data;
 685
 686	mdev->phy.antenna_mask = BIT(cap->nss) - 1;
 687	mdev->phy.chainmask = mdev->phy.antenna_mask;
 688	mdev->phy.cap.has_2ghz = cap->hw_path & BIT(WF0_24G);
 689	mdev->phy.cap.has_5ghz = cap->hw_path & BIT(WF0_5G);
 690	dev->has_eht = cap->eht;
 691}
 692
 693static int
 694mt7925_mcu_get_nic_capability(struct mt792x_dev *dev)
 695{
 696	struct mt76_phy *mphy = &dev->mt76.phy;
 697	struct {
 698		u8 _rsv[4];
 699
 700		__le16 tag;
 701		__le16 len;
 702	} __packed req = {
 703		.tag = cpu_to_le16(UNI_CHIP_CONFIG_NIC_CAPA),
 704		.len = cpu_to_le16(sizeof(req) - 4),
 705	};
 706	struct mt76_connac_cap_hdr {
 707		__le16 n_element;
 708		u8 rsv[2];
 709	} __packed * hdr;
 710	struct sk_buff *skb;
 711	int ret, i;
 712
 713	ret = mt76_mcu_send_and_get_msg(&dev->mt76, MCU_UNI_CMD(CHIP_CONFIG),
 714					&req, sizeof(req), true, &skb);
 715	if (ret)
 716		return ret;
 717
 718	hdr = (struct mt76_connac_cap_hdr *)skb->data;
 719	if (skb->len < sizeof(*hdr)) {
 720		ret = -EINVAL;
 721		goto out;
 722	}
 723
 724	skb_pull(skb, sizeof(*hdr));
 725
 726	for (i = 0; i < le16_to_cpu(hdr->n_element); i++) {
 727		struct tlv *tlv = (struct tlv *)skb->data;
 728		int len;
 729
 730		if (skb->len < sizeof(*tlv))
 731			break;
 732
 733		len = le16_to_cpu(tlv->len);
 734		if (skb->len < len)
 735			break;
 736
 737		switch (le16_to_cpu(tlv->tag)) {
 738		case MT_NIC_CAP_6G:
 739			mphy->cap.has_6ghz = !!tlv->data[0];
 740			break;
 741		case MT_NIC_CAP_MAC_ADDR:
 742			memcpy(mphy->macaddr, (void *)tlv->data, ETH_ALEN);
 743			break;
 744		case MT_NIC_CAP_PHY:
 745			mt7925_mcu_parse_phy_cap(dev, tlv->data);
 746			break;
 747		default:
 748			break;
 749		}
 750		skb_pull(skb, len);
 751	}
 752out:
 753	dev_kfree_skb(skb);
 754	return ret;
 755}
 756
 757int mt7925_mcu_chip_config(struct mt792x_dev *dev, const char *cmd)
 758{
 759	u16 len = strlen(cmd) + 1;
 760	struct {
 761		u8 _rsv[4];
 762		__le16 tag;
 763		__le16 len;
 764		struct mt76_connac_config config;
 765	} __packed req = {
 766		.tag = cpu_to_le16(UNI_CHIP_CONFIG_CHIP_CFG),
 767		.len = cpu_to_le16(sizeof(req) - 4),
 768		.config = {
 769			.resp_type = 0,
 770			.type = 0,
 771			.data_size = cpu_to_le16(len),
 772		},
 773	};
 774
 775	memcpy(req.config.data, cmd, len);
 776
 777	return mt76_mcu_send_msg(&dev->mt76, MCU_UNI_CMD(CHIP_CONFIG),
 778				 &req, sizeof(req), false);
 779}
 780
 781int mt7925_mcu_set_deep_sleep(struct mt792x_dev *dev, bool enable)
 782{
 783	char cmd[16];
 784
 785	snprintf(cmd, sizeof(cmd), "KeepFullPwr %d", !enable);
 786
 787	return mt7925_mcu_chip_config(dev, cmd);
 788}
 789EXPORT_SYMBOL_GPL(mt7925_mcu_set_deep_sleep);
 790
 791int mt7925_run_firmware(struct mt792x_dev *dev)
 792{
 793	int err;
 794
 795	err = mt792x_load_firmware(dev);
 796	if (err)
 797		return err;
 798
 799	err = mt7925_mcu_get_nic_capability(dev);
 800	if (err)
 801		return err;
 802
 803	set_bit(MT76_STATE_MCU_RUNNING, &dev->mphy.state);
 804	err = mt7925_load_clc(dev, mt792x_ram_name(dev));
 805	if (err)
 806		return err;
 807
 808	return mt7925_mcu_fw_log_2_host(dev, 1);
 809}
 810EXPORT_SYMBOL_GPL(mt7925_run_firmware);
 811
 812static void
 813mt7925_mcu_sta_hdr_trans_tlv(struct sk_buff *skb,
 814			     struct ieee80211_vif *vif,
 815			     struct ieee80211_sta *sta)
 816{
 817	struct sta_rec_hdr_trans *hdr_trans;
 818	struct mt76_wcid *wcid;
 819	struct tlv *tlv;
 820
 821	tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_HDR_TRANS, sizeof(*hdr_trans));
 822	hdr_trans = (struct sta_rec_hdr_trans *)tlv;
 823	hdr_trans->dis_rx_hdr_tran = true;
 824
 825	if (vif->type == NL80211_IFTYPE_STATION)
 826		hdr_trans->to_ds = true;
 827	else
 828		hdr_trans->from_ds = true;
 829
 830	wcid = (struct mt76_wcid *)sta->drv_priv;
 831	if (!wcid)
 832		return;
 833
 834	hdr_trans->dis_rx_hdr_tran = !test_bit(MT_WCID_FLAG_HDR_TRANS, &wcid->flags);
 835	if (test_bit(MT_WCID_FLAG_4ADDR, &wcid->flags)) {
 836		hdr_trans->to_ds = true;
 837		hdr_trans->from_ds = true;
 838	}
 839}
 840
 841int mt7925_mcu_wtbl_update_hdr_trans(struct mt792x_dev *dev,
 842				     struct ieee80211_vif *vif,
 843				     struct ieee80211_sta *sta)
 844{
 845	struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv;
 846	struct mt792x_sta *msta;
 847	struct sk_buff *skb;
 848
 849	msta = sta ? (struct mt792x_sta *)sta->drv_priv : &mvif->sta;
 850
 851	skb = __mt76_connac_mcu_alloc_sta_req(&dev->mt76, &mvif->mt76,
 852					      &msta->wcid,
 853					      MT7925_STA_UPDATE_MAX_SIZE);
 854	if (IS_ERR(skb))
 855		return PTR_ERR(skb);
 856
 857	/* starec hdr trans */
 858	mt7925_mcu_sta_hdr_trans_tlv(skb, vif, sta);
 859	return mt76_mcu_skb_send_msg(&dev->mt76, skb,
 860				     MCU_WMWA_UNI_CMD(STA_REC_UPDATE), true);
 861}
 862
 863int mt7925_mcu_set_tx(struct mt792x_dev *dev, struct ieee80211_vif *vif)
 864{
 865#define MCU_EDCA_AC_PARAM	0
 866#define WMM_AIFS_SET		BIT(0)
 867#define WMM_CW_MIN_SET		BIT(1)
 868#define WMM_CW_MAX_SET		BIT(2)
 869#define WMM_TXOP_SET		BIT(3)
 870#define WMM_PARAM_SET		(WMM_AIFS_SET | WMM_CW_MIN_SET | \
 871				 WMM_CW_MAX_SET | WMM_TXOP_SET)
 872	struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv;
 873	struct {
 874		u8 bss_idx;
 875		u8 __rsv[3];
 876	} __packed hdr = {
 877		.bss_idx = mvif->mt76.idx,
 878	};
 879	struct sk_buff *skb;
 880	int len = sizeof(hdr) + IEEE80211_NUM_ACS * sizeof(struct edca);
 881	int ac;
 882
 883	skb = mt76_mcu_msg_alloc(&dev->mt76, NULL, len);
 884	if (!skb)
 885		return -ENOMEM;
 886
 887	skb_put_data(skb, &hdr, sizeof(hdr));
 888
 889	for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) {
 890		struct ieee80211_tx_queue_params *q = &mvif->queue_params[ac];
 891		struct edca *e;
 892		struct tlv *tlv;
 893
 894		tlv = mt76_connac_mcu_add_tlv(skb, MCU_EDCA_AC_PARAM, sizeof(*e));
 895
 896		e = (struct edca *)tlv;
 897		e->set = WMM_PARAM_SET;
 898		e->queue = ac + mvif->mt76.wmm_idx * MT76_CONNAC_MAX_WMM_SETS;
 899		e->aifs = q->aifs;
 900		e->txop = cpu_to_le16(q->txop);
 901
 902		if (q->cw_min)
 903			e->cw_min = fls(q->cw_min);
 904		else
 905			e->cw_min = 5;
 906
 907		if (q->cw_max)
 908			e->cw_max = fls(q->cw_max);
 909		else
 910			e->cw_max = 10;
 911	}
 912
 913	return mt76_mcu_skb_send_msg(&dev->mt76, skb,
 914				     MCU_UNI_CMD(EDCA_UPDATE), true);
 915}
 916
 917static int
 918mt7925_mcu_sta_key_tlv(struct mt76_wcid *wcid,
 919		       struct mt76_connac_sta_key_conf *sta_key_conf,
 920		       struct sk_buff *skb,
 921		       struct ieee80211_key_conf *key,
 922		       enum set_key_cmd cmd)
 923{
 924	struct sta_rec_sec_uni *sec;
 925	struct tlv *tlv;
 926
 927	tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_KEY_V2, sizeof(*sec));
 928	sec = (struct sta_rec_sec_uni *)tlv;
 929	sec->add = cmd;
 930
 931	if (cmd == SET_KEY) {
 932		struct sec_key_uni *sec_key;
 933		u8 cipher;
 934
 935		cipher = mt76_connac_mcu_get_cipher(key->cipher);
 936		if (cipher == MCU_CIPHER_NONE)
 937			return -EOPNOTSUPP;
 938
 939		sec_key = &sec->key[0];
 940		sec_key->cipher_len = sizeof(*sec_key);
 941
 942		if (cipher == MCU_CIPHER_BIP_CMAC_128) {
 943			sec_key->wlan_idx = cpu_to_le16(wcid->idx);
 944			sec_key->cipher_id = MCU_CIPHER_AES_CCMP;
 945			sec_key->key_id = sta_key_conf->keyidx;
 946			sec_key->key_len = 16;
 947			memcpy(sec_key->key, sta_key_conf->key, 16);
 948
 949			sec_key = &sec->key[1];
 950			sec_key->wlan_idx = cpu_to_le16(wcid->idx);
 951			sec_key->cipher_id = MCU_CIPHER_BIP_CMAC_128;
 952			sec_key->cipher_len = sizeof(*sec_key);
 953			sec_key->key_len = 16;
 954			memcpy(sec_key->key, key->key, 16);
 955			sec->n_cipher = 2;
 956		} else {
 957			sec_key->wlan_idx = cpu_to_le16(wcid->idx);
 958			sec_key->cipher_id = cipher;
 959			sec_key->key_id = key->keyidx;
 960			sec_key->key_len = key->keylen;
 961			memcpy(sec_key->key, key->key, key->keylen);
 962
 963			if (cipher == MCU_CIPHER_TKIP) {
 964				/* Rx/Tx MIC keys are swapped */
 965				memcpy(sec_key->key + 16, key->key + 24, 8);
 966				memcpy(sec_key->key + 24, key->key + 16, 8);
 967			}
 968
 969			/* store key_conf for BIP batch update */
 970			if (cipher == MCU_CIPHER_AES_CCMP) {
 971				memcpy(sta_key_conf->key, key->key, key->keylen);
 972				sta_key_conf->keyidx = key->keyidx;
 973			}
 974
 975			sec->n_cipher = 1;
 976		}
 977	} else {
 978		sec->n_cipher = 0;
 979	}
 980
 981	return 0;
 982}
 983
 984int mt7925_mcu_add_key(struct mt76_dev *dev, struct ieee80211_vif *vif,
 985		       struct mt76_connac_sta_key_conf *sta_key_conf,
 986		       struct ieee80211_key_conf *key, int mcu_cmd,
 987		       struct mt76_wcid *wcid, enum set_key_cmd cmd)
 988{
 989	struct mt76_vif *mvif = (struct mt76_vif *)vif->drv_priv;
 990	struct sk_buff *skb;
 991	int ret;
 992
 993	skb = __mt76_connac_mcu_alloc_sta_req(dev, mvif, wcid,
 994					      MT7925_STA_UPDATE_MAX_SIZE);
 995	if (IS_ERR(skb))
 996		return PTR_ERR(skb);
 997
 998	ret = mt7925_mcu_sta_key_tlv(wcid, sta_key_conf, skb, key, cmd);
 999	if (ret)
1000		return ret;
1001
1002	return mt76_mcu_skb_send_msg(dev, skb, mcu_cmd, true);
1003}
1004
1005int mt7925_mcu_set_roc(struct mt792x_phy *phy, struct mt792x_vif *vif,
1006		       struct ieee80211_channel *chan, int duration,
1007		       enum mt7925_roc_req type, u8 token_id)
1008{
1009	int center_ch = ieee80211_frequency_to_channel(chan->center_freq);
1010	struct mt792x_dev *dev = phy->dev;
1011	struct {
1012		struct {
1013			u8 rsv[4];
1014		} __packed hdr;
1015		struct roc_acquire_tlv {
1016			__le16 tag;
1017			__le16 len;
1018			u8 bss_idx;
1019			u8 tokenid;
1020			u8 control_channel;
1021			u8 sco;
1022			u8 band;
1023			u8 bw;
1024			u8 center_chan;
1025			u8 center_chan2;
1026			u8 bw_from_ap;
1027			u8 center_chan_from_ap;
1028			u8 center_chan2_from_ap;
1029			u8 reqtype;
1030			__le32 maxinterval;
1031			u8 dbdcband;
1032			u8 rsv[3];
1033		} __packed roc;
1034	} __packed req = {
1035		.roc = {
1036			.tag = cpu_to_le16(UNI_ROC_ACQUIRE),
1037			.len = cpu_to_le16(sizeof(struct roc_acquire_tlv)),
1038			.tokenid = token_id,
1039			.reqtype = type,
1040			.maxinterval = cpu_to_le32(duration),
1041			.bss_idx = vif->mt76.idx,
1042			.control_channel = chan->hw_value,
1043			.bw = CMD_CBW_20MHZ,
1044			.bw_from_ap = CMD_CBW_20MHZ,
1045			.center_chan = center_ch,
1046			.center_chan_from_ap = center_ch,
1047			.dbdcband = 0xff, /* auto */
1048		},
1049	};
1050
1051	if (chan->hw_value < center_ch)
1052		req.roc.sco = 1; /* SCA */
1053	else if (chan->hw_value > center_ch)
1054		req.roc.sco = 3; /* SCB */
1055
1056	switch (chan->band) {
1057	case NL80211_BAND_6GHZ:
1058		req.roc.band = 3;
1059		break;
1060	case NL80211_BAND_5GHZ:
1061		req.roc.band = 2;
1062		break;
1063	default:
1064		req.roc.band = 1;
1065		break;
1066	}
1067
1068	return mt76_mcu_send_msg(&dev->mt76, MCU_UNI_CMD(ROC),
1069				 &req, sizeof(req), false);
1070}
1071
1072int mt7925_mcu_abort_roc(struct mt792x_phy *phy, struct mt792x_vif *vif,
1073			 u8 token_id)
1074{
1075	struct mt792x_dev *dev = phy->dev;
1076	struct {
1077		struct {
1078			u8 rsv[4];
1079		} __packed hdr;
1080		struct roc_abort_tlv {
1081			__le16 tag;
1082			__le16 len;
1083			u8 bss_idx;
1084			u8 tokenid;
1085			u8 dbdcband;
1086			u8 rsv[5];
1087		} __packed abort;
1088	} __packed req = {
1089		.abort = {
1090			.tag = cpu_to_le16(UNI_ROC_ABORT),
1091			.len = cpu_to_le16(sizeof(struct roc_abort_tlv)),
1092			.tokenid = token_id,
1093			.bss_idx = vif->mt76.idx,
1094			.dbdcband = 0xff, /* auto*/
1095		},
1096	};
1097
1098	return mt76_mcu_send_msg(&dev->mt76, MCU_UNI_CMD(ROC),
1099				 &req, sizeof(req), false);
1100}
1101
1102int mt7925_mcu_set_chan_info(struct mt792x_phy *phy, u16 tag)
1103{
1104	static const u8 ch_band[] = {
1105		[NL80211_BAND_2GHZ] = 0,
1106		[NL80211_BAND_5GHZ] = 1,
1107		[NL80211_BAND_6GHZ] = 2,
1108	};
1109	struct mt792x_dev *dev = phy->dev;
1110	struct cfg80211_chan_def *chandef = &phy->mt76->chandef;
1111	int freq1 = chandef->center_freq1;
1112	u8 band_idx = chandef->chan->band != NL80211_BAND_2GHZ;
1113	struct {
1114		/* fixed field */
1115		u8 __rsv[4];
1116
1117		__le16 tag;
1118		__le16 len;
1119		u8 control_ch;
1120		u8 center_ch;
1121		u8 bw;
1122		u8 tx_path_num;
1123		u8 rx_path;	/* mask or num */
1124		u8 switch_reason;
1125		u8 band_idx;
1126		u8 center_ch2;	/* for 80+80 only */
1127		__le16 cac_case;
1128		u8 channel_band;
1129		u8 rsv0;
1130		__le32 outband_freq;
1131		u8 txpower_drop;
1132		u8 ap_bw;
1133		u8 ap_center_ch;
1134		u8 rsv1[53];
1135	} __packed req = {
1136		.tag = cpu_to_le16(tag),
1137		.len = cpu_to_le16(sizeof(req) - 4),
1138		.control_ch = chandef->chan->hw_value,
1139		.center_ch = ieee80211_frequency_to_channel(freq1),
1140		.bw = mt76_connac_chan_bw(chandef),
1141		.tx_path_num = hweight8(phy->mt76->antenna_mask),
1142		.rx_path = phy->mt76->antenna_mask,
1143		.band_idx = band_idx,
1144		.channel_band = ch_band[chandef->chan->band],
1145	};
1146
1147	if (chandef->chan->band == NL80211_BAND_6GHZ)
1148		req.channel_band = 2;
1149	else
1150		req.channel_band = chandef->chan->band;
1151
1152	if (tag == UNI_CHANNEL_RX_PATH ||
1153	    dev->mt76.hw->conf.flags & IEEE80211_CONF_MONITOR)
1154		req.switch_reason = CH_SWITCH_NORMAL;
1155	else if (phy->mt76->hw->conf.flags & IEEE80211_CONF_OFFCHANNEL)
1156		req.switch_reason = CH_SWITCH_SCAN_BYPASS_DPD;
1157	else if (!cfg80211_reg_can_beacon(phy->mt76->hw->wiphy, chandef,
1158					  NL80211_IFTYPE_AP))
1159		req.switch_reason = CH_SWITCH_DFS;
1160	else
1161		req.switch_reason = CH_SWITCH_NORMAL;
1162
1163	if (tag == UNI_CHANNEL_SWITCH)
1164		req.rx_path = hweight8(req.rx_path);
1165
1166	if (chandef->width == NL80211_CHAN_WIDTH_80P80) {
1167		int freq2 = chandef->center_freq2;
1168
1169		req.center_ch2 = ieee80211_frequency_to_channel(freq2);
1170	}
1171
1172	return mt76_mcu_send_msg(&dev->mt76, MCU_UNI_CMD(CHANNEL_SWITCH),
1173				 &req, sizeof(req), true);
1174}
1175
1176int mt7925_mcu_set_eeprom(struct mt792x_dev *dev)
1177{
1178	struct {
1179		u8 _rsv[4];
1180
1181		__le16 tag;
1182		__le16 len;
1183		u8 buffer_mode;
1184		u8 format;
1185		__le16 buf_len;
1186	} __packed req = {
1187		.tag = cpu_to_le16(UNI_EFUSE_BUFFER_MODE),
1188		.len = cpu_to_le16(sizeof(req) - 4),
1189		.buffer_mode = EE_MODE_EFUSE,
1190		.format = EE_FORMAT_WHOLE
1191	};
1192
1193	return mt76_mcu_send_and_get_msg(&dev->mt76, MCU_UNI_CMD(EFUSE_CTRL),
1194					 &req, sizeof(req), false, NULL);
1195}
1196EXPORT_SYMBOL_GPL(mt7925_mcu_set_eeprom);
1197
1198int mt7925_mcu_uni_bss_ps(struct mt792x_dev *dev, struct ieee80211_vif *vif)
1199{
1200	struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv;
1201	struct {
1202		struct {
1203			u8 bss_idx;
1204			u8 pad[3];
1205		} __packed hdr;
1206		struct ps_tlv {
1207			__le16 tag;
1208			__le16 len;
1209			u8 ps_state; /* 0: device awake
1210				      * 1: static power save
1211				      * 2: dynamic power saving
1212				      * 3: enter TWT power saving
1213				      * 4: leave TWT power saving
1214				      */
1215			u8 pad[3];
1216		} __packed ps;
1217	} __packed ps_req = {
1218		.hdr = {
1219			.bss_idx = mvif->mt76.idx,
1220		},
1221		.ps = {
1222			.tag = cpu_to_le16(UNI_BSS_INFO_PS),
1223			.len = cpu_to_le16(sizeof(struct ps_tlv)),
1224			.ps_state = vif->cfg.ps ? 2 : 0,
1225		},
1226	};
1227
1228	if (vif->type != NL80211_IFTYPE_STATION)
1229		return -EOPNOTSUPP;
1230
1231	return mt76_mcu_send_msg(&dev->mt76, MCU_UNI_CMD(BSS_INFO_UPDATE),
1232				 &ps_req, sizeof(ps_req), true);
1233}
1234
1235static int
1236mt7925_mcu_uni_bss_bcnft(struct mt792x_dev *dev, struct ieee80211_vif *vif,
1237			 bool enable)
1238{
1239	struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv;
1240	struct {
1241		struct {
1242			u8 bss_idx;
1243			u8 pad[3];
1244		} __packed hdr;
1245		struct bcnft_tlv {
1246			__le16 tag;
1247			__le16 len;
1248			__le16 bcn_interval;
1249			u8 dtim_period;
1250			u8 bmc_delivered_ac;
1251			u8 bmc_triggered_ac;
1252			u8 pad[3];
1253		} __packed bcnft;
1254	} __packed bcnft_req = {
1255		.hdr = {
1256			.bss_idx = mvif->mt76.idx,
1257		},
1258		.bcnft = {
1259			.tag = cpu_to_le16(UNI_BSS_INFO_BCNFT),
1260			.len = cpu_to_le16(sizeof(struct bcnft_tlv)),
1261			.bcn_interval = cpu_to_le16(vif->bss_conf.beacon_int),
1262			.dtim_period = vif->bss_conf.dtim_period,
1263		},
1264	};
1265
1266	if (vif->type != NL80211_IFTYPE_STATION)
1267		return 0;
1268
1269	return mt76_mcu_send_msg(&dev->mt76, MCU_UNI_CMD(BSS_INFO_UPDATE),
1270				 &bcnft_req, sizeof(bcnft_req), true);
1271}
1272
1273int
1274mt7925_mcu_set_bss_pm(struct mt792x_dev *dev, struct ieee80211_vif *vif,
1275		      bool enable)
1276{
1277	struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv;
1278	struct {
1279		struct {
1280			u8 bss_idx;
1281			u8 pad[3];
1282		} __packed hdr;
1283		struct bcnft_tlv {
1284			__le16 tag;
1285			__le16 len;
1286			__le16 bcn_interval;
1287			u8 dtim_period;
1288			u8 bmc_delivered_ac;
1289			u8 bmc_triggered_ac;
1290			u8 pad[3];
1291		} __packed enable;
1292	} req = {
1293		.hdr = {
1294			.bss_idx = mvif->mt76.idx,
1295		},
1296		.enable = {
1297			.tag = cpu_to_le16(UNI_BSS_INFO_BCNFT),
1298			.len = cpu_to_le16(sizeof(struct bcnft_tlv)),
1299			.dtim_period = vif->bss_conf.dtim_period,
1300			.bcn_interval = cpu_to_le16(vif->bss_conf.beacon_int),
1301		},
1302	};
1303	struct {
1304		struct {
1305			u8 bss_idx;
1306			u8 pad[3];
1307		} __packed hdr;
1308		struct pm_disable {
1309			__le16 tag;
1310			__le16 len;
1311		} __packed disable;
1312	} req1 = {
1313		.hdr = {
1314			.bss_idx = mvif->mt76.idx,
1315		},
1316		.disable = {
1317			.tag = cpu_to_le16(UNI_BSS_INFO_PM_DISABLE),
1318			.len = cpu_to_le16(sizeof(struct pm_disable))
1319		},
1320	};
1321	int err;
1322
1323	err = mt76_mcu_send_msg(&dev->mt76, MCU_UNI_CMD(BSS_INFO_UPDATE),
1324				&req1, sizeof(req1), false);
1325	if (err < 0 || !enable)
1326		return err;
1327
1328	return mt76_mcu_send_msg(&dev->mt76, MCU_UNI_CMD(BSS_INFO_UPDATE),
1329				 &req, sizeof(req), false);
1330}
1331
1332static void
1333mt7925_mcu_sta_he_tlv(struct sk_buff *skb, struct ieee80211_sta *sta)
1334{
1335	if (!sta->deflink.he_cap.has_he)
1336		return;
1337
1338	mt76_connac_mcu_sta_he_tlv_v2(skb, sta);
1339}
1340
1341static void
1342mt7925_mcu_sta_he_6g_tlv(struct sk_buff *skb, struct ieee80211_sta *sta)
1343{
1344	struct sta_rec_he_6g_capa *he_6g;
1345	struct tlv *tlv;
1346
1347	if (!sta->deflink.he_6ghz_capa.capa)
1348		return;
1349
1350	tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_HE_6G, sizeof(*he_6g));
1351
1352	he_6g = (struct sta_rec_he_6g_capa *)tlv;
1353	he_6g->capa = sta->deflink.he_6ghz_capa.capa;
1354}
1355
1356static void
1357mt7925_mcu_sta_eht_tlv(struct sk_buff *skb, struct ieee80211_sta *sta)
1358{
1359	struct ieee80211_eht_mcs_nss_supp *mcs_map;
1360	struct ieee80211_eht_cap_elem_fixed *elem;
1361	struct sta_rec_eht *eht;
1362	struct tlv *tlv;
1363
1364	if (!sta->deflink.eht_cap.has_eht)
1365		return;
1366
1367	mcs_map = &sta->deflink.eht_cap.eht_mcs_nss_supp;
1368	elem = &sta->deflink.eht_cap.eht_cap_elem;
1369
1370	tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_EHT, sizeof(*eht));
1371
1372	eht = (struct sta_rec_eht *)tlv;
1373	eht->tid_bitmap = 0xff;
1374	eht->mac_cap = cpu_to_le16(*(u16 *)elem->mac_cap_info);
1375	eht->phy_cap = cpu_to_le64(*(u64 *)elem->phy_cap_info);
1376	eht->phy_cap_ext = cpu_to_le64(elem->phy_cap_info[8]);
1377
1378	if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_20)
1379		memcpy(eht->mcs_map_bw20, &mcs_map->only_20mhz, sizeof(eht->mcs_map_bw20));
1380	memcpy(eht->mcs_map_bw80, &mcs_map->bw._80, sizeof(eht->mcs_map_bw80));
1381	memcpy(eht->mcs_map_bw160, &mcs_map->bw._160, sizeof(eht->mcs_map_bw160));
1382}
1383
1384static void
1385mt7925_mcu_sta_ht_tlv(struct sk_buff *skb, struct ieee80211_sta *sta)
1386{
1387	struct sta_rec_ht *ht;
1388	struct tlv *tlv;
1389
1390	if (!sta->deflink.ht_cap.ht_supported)
1391		return;
1392
1393	tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_HT, sizeof(*ht));
1394
1395	ht = (struct sta_rec_ht *)tlv;
1396	ht->ht_cap = cpu_to_le16(sta->deflink.ht_cap.cap);
1397}
1398
1399static void
1400mt7925_mcu_sta_vht_tlv(struct sk_buff *skb, struct ieee80211_sta *sta)
1401{
1402	struct sta_rec_vht *vht;
1403	struct tlv *tlv;
1404
1405	/* For 6G band, this tlv is necessary to let hw work normally */
1406	if (!sta->deflink.he_6ghz_capa.capa && !sta->deflink.vht_cap.vht_supported)
1407		return;
1408
1409	tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_VHT, sizeof(*vht));
1410
1411	vht = (struct sta_rec_vht *)tlv;
1412	vht->vht_cap = cpu_to_le32(sta->deflink.vht_cap.cap);
1413	vht->vht_rx_mcs_map = sta->deflink.vht_cap.vht_mcs.rx_mcs_map;
1414	vht->vht_tx_mcs_map = sta->deflink.vht_cap.vht_mcs.tx_mcs_map;
1415}
1416
1417static void
1418mt7925_mcu_sta_amsdu_tlv(struct sk_buff *skb,
1419			 struct ieee80211_vif *vif, struct ieee80211_sta *sta)
1420{
1421	struct mt792x_sta *msta = (struct mt792x_sta *)sta->drv_priv;
1422	struct sta_rec_amsdu *amsdu;
1423	struct tlv *tlv;
1424
1425	if (vif->type != NL80211_IFTYPE_STATION &&
1426	    vif->type != NL80211_IFTYPE_AP)
1427		return;
1428
1429	if (!sta->deflink.agg.max_amsdu_len)
1430		return;
1431
1432	tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_HW_AMSDU, sizeof(*amsdu));
1433	amsdu = (struct sta_rec_amsdu *)tlv;
1434	amsdu->max_amsdu_num = 8;
1435	amsdu->amsdu_en = true;
1436	msta->wcid.amsdu = true;
1437
1438	switch (sta->deflink.agg.max_amsdu_len) {
1439	case IEEE80211_MAX_MPDU_LEN_VHT_11454:
1440		amsdu->max_mpdu_size =
1441			IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_11454;
1442		return;
1443	case IEEE80211_MAX_MPDU_LEN_HT_7935:
1444	case IEEE80211_MAX_MPDU_LEN_VHT_7991:
1445		amsdu->max_mpdu_size = IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_7991;
1446		return;
1447	default:
1448		amsdu->max_mpdu_size = IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_3895;
1449		return;
1450	}
1451}
1452
1453static void
1454mt7925_mcu_sta_phy_tlv(struct sk_buff *skb,
1455		       struct ieee80211_vif *vif, struct ieee80211_sta *sta)
1456{
1457	struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv;
1458	struct cfg80211_chan_def *chandef = &mvif->mt76.ctx->def;
1459	struct sta_rec_phy *phy;
1460	struct tlv *tlv;
1461	u8 af = 0, mm = 0;
1462
1463	if (!sta->deflink.ht_cap.ht_supported && !sta->deflink.he_6ghz_capa.capa)
1464		return;
1465
1466	tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_PHY, sizeof(*phy));
1467	phy = (struct sta_rec_phy *)tlv;
1468	phy->phy_type = mt76_connac_get_phy_mode_v2(mvif->phy->mt76, vif, chandef->chan->band, sta);
1469	if (sta->deflink.ht_cap.ht_supported) {
1470		af = sta->deflink.ht_cap.ampdu_factor;
1471		mm = sta->deflink.ht_cap.ampdu_density;
1472	}
1473
1474	if (sta->deflink.vht_cap.vht_supported) {
1475		u8 vht_af = FIELD_GET(IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK,
1476				      sta->deflink.vht_cap.cap);
1477
1478		af = max_t(u8, af, vht_af);
1479	}
1480
1481	if (sta->deflink.he_6ghz_capa.capa) {
1482		af = le16_get_bits(sta->deflink.he_6ghz_capa.capa,
1483				   IEEE80211_HE_6GHZ_CAP_MAX_AMPDU_LEN_EXP);
1484		mm = le16_get_bits(sta->deflink.he_6ghz_capa.capa,
1485				   IEEE80211_HE_6GHZ_CAP_MIN_MPDU_START);
1486	}
1487
1488	phy->ampdu = FIELD_PREP(IEEE80211_HT_AMPDU_PARM_FACTOR, af) |
1489		     FIELD_PREP(IEEE80211_HT_AMPDU_PARM_DENSITY, mm);
1490	phy->max_ampdu_len = af;
1491}
1492
1493static void
1494mt7925_mcu_sta_state_v2_tlv(struct mt76_phy *mphy, struct sk_buff *skb,
1495			    struct ieee80211_sta *sta,
1496			    struct ieee80211_vif *vif,
1497			    u8 rcpi, u8 sta_state)
1498{
1499	struct sta_rec_state_v2 {
1500		__le16 tag;
1501		__le16 len;
1502		u8 state;
1503		u8 rsv[3];
1504		__le32 flags;
1505		u8 vht_opmode;
1506		u8 action;
1507		u8 rsv2[2];
1508	} __packed * state;
1509	struct tlv *tlv;
1510
1511	tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_STATE, sizeof(*state));
1512	state = (struct sta_rec_state_v2 *)tlv;
1513	state->state = sta_state;
1514
1515	if (sta->deflink.vht_cap.vht_supported) {
1516		state->vht_opmode = sta->deflink.bandwidth;
1517		state->vht_opmode |= sta->deflink.rx_nss <<
1518			IEEE80211_OPMODE_NOTIF_RX_NSS_SHIFT;
1519	}
1520}
1521
1522static void
1523mt7925_mcu_sta_rate_ctrl_tlv(struct sk_buff *skb,
1524			     struct ieee80211_vif *vif, struct ieee80211_sta *sta)
1525{
1526	struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv;
1527	struct cfg80211_chan_def *chandef = &mvif->mt76.ctx->def;
1528	enum nl80211_band band = chandef->chan->band;
1529	struct sta_rec_ra_info *ra_info;
1530	struct tlv *tlv;
1531	u16 supp_rates;
1532
1533	tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_RA, sizeof(*ra_info));
1534	ra_info = (struct sta_rec_ra_info *)tlv;
1535
1536	supp_rates = sta->deflink.supp_rates[band];
1537	if (band == NL80211_BAND_2GHZ)
1538		supp_rates = FIELD_PREP(RA_LEGACY_OFDM, supp_rates >> 4) |
1539			     FIELD_PREP(RA_LEGACY_CCK, supp_rates & 0xf);
1540	else
1541		supp_rates = FIELD_PREP(RA_LEGACY_OFDM, supp_rates);
1542
1543	ra_info->legacy = cpu_to_le16(supp_rates);
1544
1545	if (sta->deflink.ht_cap.ht_supported)
1546		memcpy(ra_info->rx_mcs_bitmask,
1547		       sta->deflink.ht_cap.mcs.rx_mask,
1548		       HT_MCS_MASK_NUM);
1549}
1550
1551static void
1552mt7925_mcu_sta_mld_tlv(struct sk_buff *skb,
1553		       struct ieee80211_vif *vif, struct ieee80211_sta *sta)
1554{
1555	struct mt76_wcid *wcid = (struct mt76_wcid *)sta->drv_priv;
1556	struct sta_rec_mld *mld;
1557	struct tlv *tlv;
1558
1559	tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_MLD, sizeof(*mld));
1560	mld = (struct sta_rec_mld *)tlv;
1561	memcpy(mld->mac_addr, vif->addr, ETH_ALEN);
1562	mld->primary_id = cpu_to_le16(wcid->idx);
1563	mld->wlan_id = cpu_to_le16(wcid->idx);
1564
1565	/* TODO: 0 means deflink only, add secondary link(1) later */
1566	mld->link_num = !!(hweight8(vif->active_links) > 1);
1567	WARN_ON_ONCE(mld->link_num);
1568}
1569
1570static int
1571mt7925_mcu_sta_cmd(struct mt76_phy *phy,
1572		   struct mt76_sta_cmd_info *info)
1573{
1574	struct mt76_vif *mvif = (struct mt76_vif *)info->vif->drv_priv;
1575	struct mt76_dev *dev = phy->dev;
1576	struct wtbl_req_hdr *wtbl_hdr;
1577	struct tlv *sta_wtbl;
1578	struct sk_buff *skb;
1579
1580	skb = __mt76_connac_mcu_alloc_sta_req(dev, mvif, info->wcid,
1581					      MT7925_STA_UPDATE_MAX_SIZE);
1582	if (IS_ERR(skb))
1583		return PTR_ERR(skb);
1584
1585	if (info->sta || !info->offload_fw)
1586		mt76_connac_mcu_sta_basic_tlv(dev, skb, info->vif, info->sta,
1587					      info->enable, info->newly);
1588	if (info->sta && info->enable) {
1589		mt7925_mcu_sta_phy_tlv(skb, info->vif, info->sta);
1590		mt7925_mcu_sta_ht_tlv(skb, info->sta);
1591		mt7925_mcu_sta_vht_tlv(skb, info->sta);
1592		mt76_connac_mcu_sta_uapsd(skb, info->vif, info->sta);
1593		mt7925_mcu_sta_amsdu_tlv(skb, info->vif, info->sta);
1594		mt7925_mcu_sta_he_tlv(skb, info->sta);
1595		mt7925_mcu_sta_he_6g_tlv(skb, info->sta);
1596		mt7925_mcu_sta_eht_tlv(skb, info->sta);
1597		mt7925_mcu_sta_rate_ctrl_tlv(skb, info->vif, info->sta);
1598		mt7925_mcu_sta_state_v2_tlv(phy, skb, info->sta,
1599					    info->vif, info->rcpi,
1600					    info->state);
1601		mt7925_mcu_sta_hdr_trans_tlv(skb, info->vif, info->sta);
1602		mt7925_mcu_sta_mld_tlv(skb, info->vif, info->sta);
1603	}
1604
1605	sta_wtbl = mt76_connac_mcu_add_tlv(skb, STA_REC_WTBL,
1606					   sizeof(struct tlv));
1607
1608	wtbl_hdr = mt76_connac_mcu_alloc_wtbl_req(dev, info->wcid,
1609						  WTBL_RESET_AND_SET,
1610						  sta_wtbl, &skb);
1611	if (IS_ERR(wtbl_hdr))
1612		return PTR_ERR(wtbl_hdr);
1613
1614	if (info->enable) {
1615		mt76_connac_mcu_wtbl_generic_tlv(dev, skb, info->vif,
1616						 info->sta, sta_wtbl,
1617						 wtbl_hdr);
1618		mt76_connac_mcu_wtbl_hdr_trans_tlv(skb, info->vif, info->wcid,
1619						   sta_wtbl, wtbl_hdr);
1620		if (info->sta)
1621			mt76_connac_mcu_wtbl_ht_tlv(dev, skb, info->sta,
1622						    sta_wtbl, wtbl_hdr,
1623						    true, true);
1624	}
1625
1626	return mt76_mcu_skb_send_msg(dev, skb, info->cmd, true);
1627}
1628
1629int mt7925_mcu_sta_update(struct mt792x_dev *dev, struct ieee80211_sta *sta,
1630			  struct ieee80211_vif *vif, bool enable,
1631			  enum mt76_sta_info_state state)
1632{
1633	struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv;
1634	int rssi = -ewma_rssi_read(&mvif->rssi);
1635	struct mt76_sta_cmd_info info = {
1636		.sta = sta,
1637		.vif = vif,
1638		.enable = enable,
1639		.cmd = MCU_UNI_CMD(STA_REC_UPDATE),
1640		.state = state,
1641		.offload_fw = true,
1642		.rcpi = to_rcpi(rssi),
1643	};
1644	struct mt792x_sta *msta;
1645
1646	msta = sta ? (struct mt792x_sta *)sta->drv_priv : NULL;
1647	info.wcid = msta ? &msta->wcid : &mvif->sta.wcid;
1648	info.newly = msta ? state != MT76_STA_INFO_STATE_ASSOC : true;
1649
1650	return mt7925_mcu_sta_cmd(&dev->mphy, &info);
1651}
1652
1653int mt7925_mcu_set_beacon_filter(struct mt792x_dev *dev,
1654				 struct ieee80211_vif *vif,
1655				 bool enable)
1656{
1657#define MT7925_FIF_BIT_CLR		BIT(1)
1658#define MT7925_FIF_BIT_SET		BIT(0)
1659	int err = 0;
1660
1661	if (enable) {
1662		err = mt7925_mcu_uni_bss_bcnft(dev, vif, true);
1663		if (err)
1664			return err;
1665
1666		return mt7925_mcu_set_rxfilter(dev, 0,
1667					       MT7925_FIF_BIT_SET,
1668					       MT_WF_RFCR_DROP_OTHER_BEACON);
1669	}
1670
1671	err = mt7925_mcu_set_bss_pm(dev, vif, false);
1672	if (err)
1673		return err;
1674
1675	return mt7925_mcu_set_rxfilter(dev, 0,
1676				       MT7925_FIF_BIT_CLR,
1677				       MT_WF_RFCR_DROP_OTHER_BEACON);
1678}
1679
1680int mt7925_get_txpwr_info(struct mt792x_dev *dev, u8 band_idx, struct mt7925_txpwr *txpwr)
1681{
1682#define TX_POWER_SHOW_INFO 0x7
1683#define TXPOWER_ALL_RATE_POWER_INFO 0x2
1684	struct mt7925_txpwr_event *event;
1685	struct mt7925_txpwr_req req = {
1686		.tag = cpu_to_le16(TX_POWER_SHOW_INFO),
1687		.len = cpu_to_le16(sizeof(req) - 4),
1688		.catg = TXPOWER_ALL_RATE_POWER_INFO,
1689		.band_idx = band_idx,
1690	};
1691	struct sk_buff *skb;
1692	int ret;
1693
1694	ret = mt76_mcu_send_and_get_msg(&dev->mt76, MCU_UNI_CMD(TXPOWER),
1695					&req, sizeof(req), true, &skb);
1696	if (ret)
1697		return ret;
1698
1699	event = (struct mt7925_txpwr_event *)skb->data;
1700	memcpy(txpwr, &event->txpwr, sizeof(event->txpwr));
1701
1702	dev_kfree_skb(skb);
1703
1704	return 0;
1705}
1706
1707int mt7925_mcu_set_sniffer(struct mt792x_dev *dev, struct ieee80211_vif *vif,
1708			   bool enable)
1709{
1710	struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv;
1711
1712	struct {
1713		struct {
1714			u8 band_idx;
1715			u8 pad[3];
1716		} __packed hdr;
1717		struct sniffer_enable_tlv {
1718			__le16 tag;
1719			__le16 len;
1720			u8 enable;
1721			u8 pad[3];
1722		} __packed enable;
1723	} __packed req = {
1724		.hdr = {
1725			.band_idx = mvif->mt76.band_idx,
1726		},
1727		.enable = {
1728			.tag = cpu_to_le16(UNI_SNIFFER_ENABLE),
1729			.len = cpu_to_le16(sizeof(struct sniffer_enable_tlv)),
1730			.enable = enable,
1731		},
1732	};
1733
1734	mt76_mcu_send_msg(&dev->mt76, MCU_UNI_CMD(SNIFFER), &req, sizeof(req), true);
1735
1736	return mt76_mcu_send_msg(&dev->mt76, MCU_UNI_CMD(SNIFFER), &req, sizeof(req),
1737				 true);
1738}
1739
1740int mt7925_mcu_config_sniffer(struct mt792x_vif *vif,
1741			      struct ieee80211_chanctx_conf *ctx)
1742{
1743	struct mt76_phy *mphy = vif->phy->mt76;
1744	struct cfg80211_chan_def *chandef = ctx ? &ctx->def : &mphy->chandef;
1745	int freq1 = chandef->center_freq1, freq2 = chandef->center_freq2;
1746
1747	const u8 ch_band[] = {
1748		[NL80211_BAND_2GHZ] = 1,
1749		[NL80211_BAND_5GHZ] = 2,
1750		[NL80211_BAND_6GHZ] = 3,
1751	};
1752	const u8 ch_width[] = {
1753		[NL80211_CHAN_WIDTH_20_NOHT] = 0,
1754		[NL80211_CHAN_WIDTH_20] = 0,
1755		[NL80211_CHAN_WIDTH_40] = 0,
1756		[NL80211_CHAN_WIDTH_80] = 1,
1757		[NL80211_CHAN_WIDTH_160] = 2,
1758		[NL80211_CHAN_WIDTH_80P80] = 3,
1759		[NL80211_CHAN_WIDTH_5] = 4,
1760		[NL80211_CHAN_WIDTH_10] = 5,
1761		[NL80211_CHAN_WIDTH_320] = 6,
1762	};
1763
1764	struct {
1765		struct {
1766			u8 band_idx;
1767			u8 pad[3];
1768		} __packed hdr;
1769		struct config_tlv {
1770			__le16 tag;
1771			__le16 len;
1772			u16 aid;
1773			u8 ch_band;
1774			u8 bw;
1775			u8 control_ch;
1776			u8 sco;
1777			u8 center_ch;
1778			u8 center_ch2;
1779			u8 drop_err;
1780			u8 pad[3];
1781		} __packed tlv;
1782	} __packed req = {
1783		.hdr = {
1784			.band_idx = vif->mt76.band_idx,
1785		},
1786		.tlv = {
1787			.tag = cpu_to_le16(UNI_SNIFFER_CONFIG),
1788			.len = cpu_to_le16(sizeof(req.tlv)),
1789			.control_ch = chandef->chan->hw_value,
1790			.center_ch = ieee80211_frequency_to_channel(freq1),
1791			.drop_err = 1,
1792		},
1793	};
1794
1795	if (chandef->chan->band < ARRAY_SIZE(ch_band))
1796		req.tlv.ch_band = ch_band[chandef->chan->band];
1797	if (chandef->width < ARRAY_SIZE(ch_width))
1798		req.tlv.bw = ch_width[chandef->width];
1799
1800	if (freq2)
1801		req.tlv.center_ch2 = ieee80211_frequency_to_channel(freq2);
1802
1803	if (req.tlv.control_ch < req.tlv.center_ch)
1804		req.tlv.sco = 1; /* SCA */
1805	else if (req.tlv.control_ch > req.tlv.center_ch)
1806		req.tlv.sco = 3; /* SCB */
1807
1808	return mt76_mcu_send_msg(mphy->dev, MCU_UNI_CMD(SNIFFER),
1809				 &req, sizeof(req), true);
1810}
1811
1812int
1813mt7925_mcu_uni_add_beacon_offload(struct mt792x_dev *dev,
1814				  struct ieee80211_hw *hw,
1815				  struct ieee80211_vif *vif,
1816				  bool enable)
1817{
1818	struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv;
1819	struct ieee80211_mutable_offsets offs;
1820	struct {
1821		struct req_hdr {
1822			u8 bss_idx;
1823			u8 pad[3];
1824		} __packed hdr;
1825		struct bcn_content_tlv {
1826			__le16 tag;
1827			__le16 len;
1828			__le16 tim_ie_pos;
1829			__le16 csa_ie_pos;
1830			__le16 bcc_ie_pos;
1831			/* 0: disable beacon offload
1832			 * 1: enable beacon offload
1833			 * 2: update probe respond offload
1834			 */
1835			u8 enable;
1836			/* 0: legacy format (TXD + payload)
1837			 * 1: only cap field IE
1838			 */
1839			u8 type;
1840			__le16 pkt_len;
1841			u8 pkt[512];
1842		} __packed beacon_tlv;
1843	} req = {
1844		.hdr = {
1845			.bss_idx = mvif->mt76.idx,
1846		},
1847		.beacon_tlv = {
1848			.tag = cpu_to_le16(UNI_BSS_INFO_BCN_CONTENT),
1849			.len = cpu_to_le16(sizeof(struct bcn_content_tlv)),
1850			.enable = enable,
1851			.type = 1,
1852		},
1853	};
1854	struct sk_buff *skb;
1855	u8 cap_offs;
1856
1857	/* support enable/update process only
1858	 * disable flow would be handled in bss stop handler automatically
1859	 */
1860	if (!enable)
1861		return -EOPNOTSUPP;
1862
1863	skb = ieee80211_beacon_get_template(mt76_hw(dev), vif, &offs, 0);
1864	if (!skb)
1865		return -EINVAL;
1866
1867	cap_offs = offsetof(struct ieee80211_mgmt, u.beacon.capab_info);
1868	if (!skb_pull(skb, cap_offs)) {
1869		dev_err(dev->mt76.dev, "beacon format err\n");
1870		dev_kfree_skb(skb);
1871		return -EINVAL;
1872	}
1873
1874	if (skb->len > 512) {
1875		dev_err(dev->mt76.dev, "beacon size limit exceed\n");
1876		dev_kfree_skb(skb);
1877		return -EINVAL;
1878	}
1879
1880	memcpy(req.beacon_tlv.pkt, skb->data, skb->len);
1881	req.beacon_tlv.pkt_len = cpu_to_le16(skb->len);
1882	offs.tim_offset -= cap_offs;
1883	req.beacon_tlv.tim_ie_pos = cpu_to_le16(offs.tim_offset);
1884
1885	if (offs.cntdwn_counter_offs[0]) {
1886		u16 csa_offs;
1887
1888		csa_offs = offs.cntdwn_counter_offs[0] - cap_offs - 4;
1889		req.beacon_tlv.csa_ie_pos = cpu_to_le16(csa_offs);
1890	}
1891	dev_kfree_skb(skb);
1892
1893	return mt76_mcu_send_msg(&dev->mt76, MCU_UNI_CMD(BSS_INFO_UPDATE),
1894				 &req, sizeof(req), true);
1895}
1896
1897int mt7925_mcu_set_chctx(struct mt76_phy *phy, struct mt76_vif *mvif,
1898			 struct ieee80211_chanctx_conf *ctx)
1899{
1900	struct cfg80211_chan_def *chandef = ctx ? &ctx->def : &phy->chandef;
1901	int freq1 = chandef->center_freq1, freq2 = chandef->center_freq2;
1902	enum nl80211_band band = chandef->chan->band;
1903	struct mt76_dev *mdev = phy->dev;
1904	struct {
1905		struct {
1906			u8 bss_idx;
1907			u8 pad[3];
1908		} __packed hdr;
1909		struct rlm_tlv {
1910			__le16 tag;
1911			__le16 len;
1912			u8 control_channel;
1913			u8 center_chan;
1914			u8 center_chan2;
1915			u8 bw;
1916			u8 tx_streams;
1917			u8 rx_streams;
1918			u8 ht_op_info;
1919			u8 sco;
1920			u8 band;
1921			u8 pad[3];
1922		} __packed rlm;
1923	} __packed rlm_req = {
1924		.hdr = {
1925			.bss_idx = mvif->idx,
1926		},
1927		.rlm = {
1928			.tag = cpu_to_le16(UNI_BSS_INFO_RLM),
1929			.len = cpu_to_le16(sizeof(struct rlm_tlv)),
1930			.control_channel = chandef->chan->hw_value,
1931			.center_chan = ieee80211_frequency_to_channel(freq1),
1932			.center_chan2 = ieee80211_frequency_to_channel(freq2),
1933			.tx_streams = hweight8(phy->antenna_mask),
1934			.ht_op_info = 4, /* set HT 40M allowed */
1935			.rx_streams = hweight8(phy->antenna_mask),
1936			.band = band,
1937		},
1938	};
1939
1940	switch (chandef->width) {
1941	case NL80211_CHAN_WIDTH_40:
1942		rlm_req.rlm.bw = CMD_CBW_40MHZ;
1943		break;
1944	case NL80211_CHAN_WIDTH_80:
1945		rlm_req.rlm.bw = CMD_CBW_80MHZ;
1946		break;
1947	case NL80211_CHAN_WIDTH_80P80:
1948		rlm_req.rlm.bw = CMD_CBW_8080MHZ;
1949		break;
1950	case NL80211_CHAN_WIDTH_160:
1951		rlm_req.rlm.bw = CMD_CBW_160MHZ;
1952		break;
1953	case NL80211_CHAN_WIDTH_5:
1954		rlm_req.rlm.bw = CMD_CBW_5MHZ;
1955		break;
1956	case NL80211_CHAN_WIDTH_10:
1957		rlm_req.rlm.bw = CMD_CBW_10MHZ;
1958		break;
1959	case NL80211_CHAN_WIDTH_20_NOHT:
1960	case NL80211_CHAN_WIDTH_20:
1961	default:
1962		rlm_req.rlm.bw = CMD_CBW_20MHZ;
1963		rlm_req.rlm.ht_op_info = 0;
1964		break;
1965	}
1966
1967	if (rlm_req.rlm.control_channel < rlm_req.rlm.center_chan)
1968		rlm_req.rlm.sco = 1; /* SCA */
1969	else if (rlm_req.rlm.control_channel > rlm_req.rlm.center_chan)
1970		rlm_req.rlm.sco = 3; /* SCB */
1971
1972	return mt76_mcu_send_msg(mdev, MCU_UNI_CMD(BSS_INFO_UPDATE), &rlm_req,
1973				 sizeof(rlm_req), true);
1974}
1975
1976static struct sk_buff *
1977__mt7925_mcu_alloc_bss_req(struct mt76_dev *dev, struct mt76_vif *mvif, int len)
1978{
1979	struct bss_req_hdr hdr = {
1980		.bss_idx = mvif->idx,
1981	};
1982	struct sk_buff *skb;
1983
1984	skb = mt76_mcu_msg_alloc(dev, NULL, len);
1985	if (!skb)
1986		return ERR_PTR(-ENOMEM);
1987
1988	skb_put_data(skb, &hdr, sizeof(hdr));
1989
1990	return skb;
1991}
1992
1993static u8
1994mt7925_get_phy_mode_ext(struct mt76_phy *phy, struct ieee80211_vif *vif,
1995			enum nl80211_band band, struct ieee80211_sta *sta)
1996{
1997	struct ieee80211_he_6ghz_capa *he_6ghz_capa;
1998	const struct ieee80211_sta_eht_cap *eht_cap;
1999	__le16 capa = 0;
2000	u8 mode = 0;
2001
2002	if (sta) {
2003		he_6ghz_capa = &sta->deflink.he_6ghz_capa;
2004		eht_cap = &sta->deflink.eht_cap;
2005	} else {
2006		struct ieee80211_supported_band *sband;
2007
2008		sband = phy->hw->wiphy->bands[band];
2009		capa = ieee80211_get_he_6ghz_capa(sband, vif->type);
2010		he_6ghz_capa = (struct ieee80211_he_6ghz_capa *)&capa;
2011
2012		eht_cap = ieee80211_get_eht_iftype_cap(sband, vif->type);
2013	}
2014
2015	switch (band) {
2016	case NL80211_BAND_2GHZ:
2017		if (eht_cap && eht_cap->has_eht)
2018			mode |= PHY_MODE_BE_24G;
2019		break;
2020	case NL80211_BAND_5GHZ:
2021		if (eht_cap && eht_cap->has_eht)
2022			mode |= PHY_MODE_BE_5G;
2023		break;
2024	case NL80211_BAND_6GHZ:
2025		if (he_6ghz_capa && he_6ghz_capa->capa)
2026			mode |= PHY_MODE_AX_6G;
2027
2028		if (eht_cap && eht_cap->has_eht)
2029			mode |= PHY_MODE_BE_6G;
2030		break;
2031	default:
2032		break;
2033	}
2034
2035	return mode;
2036}
2037
2038static void
2039mt7925_mcu_bss_basic_tlv(struct sk_buff *skb,
2040			 struct ieee80211_vif *vif,
2041			 struct ieee80211_sta *sta,
2042			 struct ieee80211_chanctx_conf *ctx,
2043			 struct mt76_phy *phy, u16 wlan_idx,
2044			 bool enable)
2045{
2046	struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv;
2047	struct mt792x_sta *msta = sta ? (struct mt792x_sta *)sta->drv_priv :
2048				  &mvif->sta;
2049	struct cfg80211_chan_def *chandef = ctx ? &ctx->def : &phy->chandef;
2050	enum nl80211_band band = chandef->chan->band;
2051	struct mt76_connac_bss_basic_tlv *basic_req;
2052	u8 idx, basic_phy;
2053	struct tlv *tlv;
2054	int conn_type;
2055
2056	tlv = mt76_connac_mcu_add_tlv(skb, UNI_BSS_INFO_BASIC, sizeof(*basic_req));
2057	basic_req = (struct mt76_connac_bss_basic_tlv *)tlv;
2058
2059	idx = mvif->mt76.omac_idx > EXT_BSSID_START ? HW_BSSID_0 :
2060						      mvif->mt76.omac_idx;
2061	basic_req->hw_bss_idx = idx;
2062
2063	basic_req->phymode_ext = mt7925_get_phy_mode_ext(phy, vif, band, sta);
2064
2065	basic_phy = mt76_connac_get_phy_mode_v2(phy, vif, band, sta);
2066	basic_req->nonht_basic_phy = cpu_to_le16(basic_phy);
2067
2068	memcpy(basic_req->bssid, vif->bss_conf.bssid, ETH_ALEN);
2069	basic_req->phymode = mt76_connac_get_phy_mode(phy, vif, band, sta);
2070	basic_req->bcn_interval = cpu_to_le16(vif->bss_conf.beacon_int);
2071	basic_req->dtim_period = vif->bss_conf.dtim_period;
2072	basic_req->bmc_tx_wlan_idx = cpu_to_le16(wlan_idx);
2073	basic_req->sta_idx = cpu_to_le16(msta->wcid.idx);
2074	basic_req->omac_idx = mvif->mt76.omac_idx;
2075	basic_req->band_idx = mvif->mt76.band_idx;
2076	basic_req->wmm_idx = mvif->mt76.wmm_idx;
2077	basic_req->conn_state = !enable;
2078
2079	switch (vif->type) {
2080	case NL80211_IFTYPE_MESH_POINT:
2081	case NL80211_IFTYPE_AP:
2082		if (vif->p2p)
2083			conn_type = CONNECTION_P2P_GO;
2084		else
2085			conn_type = CONNECTION_INFRA_AP;
2086		basic_req->conn_type = cpu_to_le32(conn_type);
2087		basic_req->active = enable;
2088		break;
2089	case NL80211_IFTYPE_STATION:
2090		if (vif->p2p)
2091			conn_type = CONNECTION_P2P_GC;
2092		else
2093			conn_type = CONNECTION_INFRA_STA;
2094		basic_req->conn_type = cpu_to_le32(conn_type);
2095		basic_req->active = true;
2096		break;
2097	case NL80211_IFTYPE_ADHOC:
2098		basic_req->conn_type = cpu_to_le32(CONNECTION_IBSS_ADHOC);
2099		basic_req->active = true;
2100		break;
2101	default:
2102		WARN_ON(1);
2103		break;
2104	}
2105}
2106
2107static void
2108mt7925_mcu_bss_sec_tlv(struct sk_buff *skb, struct ieee80211_vif *vif)
2109{
2110	struct mt76_vif *mvif = (struct mt76_vif *)vif->drv_priv;
2111	struct bss_sec_tlv {
2112		__le16 tag;
2113		__le16 len;
2114		u8 mode;
2115		u8 status;
2116		u8 cipher;
2117		u8 __rsv;
2118	} __packed * sec;
2119	struct tlv *tlv;
2120
2121	tlv = mt76_connac_mcu_add_tlv(skb, UNI_BSS_INFO_SEC, sizeof(*sec));
2122	sec = (struct bss_sec_tlv *)tlv;
2123
2124	switch (mvif->cipher) {
2125	case MCU_CIPHER_GCMP_256:
2126	case MCU_CIPHER_GCMP:
2127		sec->mode = MODE_WPA3_SAE;
2128		sec->status = 8;
2129		break;
2130	case MCU_CIPHER_AES_CCMP:
2131		sec->mode = MODE_WPA2_PSK;
2132		sec->status = 6;
2133		break;
2134	case MCU_CIPHER_TKIP:
2135		sec->mode = MODE_WPA2_PSK;
2136		sec->status = 4;
2137		break;
2138	case MCU_CIPHER_WEP104:
2139	case MCU_CIPHER_WEP40:
2140		sec->mode = MODE_SHARED;
2141		sec->status = 0;
2142		break;
2143	default:
2144		sec->mode = MODE_OPEN;
2145		sec->status = 1;
2146		break;
2147	}
2148
2149	sec->cipher = mvif->cipher;
2150}
2151
2152static void
2153mt7925_mcu_bss_bmc_tlv(struct sk_buff *skb, struct mt792x_phy *phy,
2154		       struct ieee80211_chanctx_conf *ctx,
2155			   struct ieee80211_vif *vif,
2156			   struct ieee80211_sta *sta)
2157{
2158	struct cfg80211_chan_def *chandef = ctx ? &ctx->def : &phy->mt76->chandef;
2159	struct mt76_vif *mvif = (struct mt76_vif *)vif->drv_priv;
2160	enum nl80211_band band = chandef->chan->band;
2161	struct bss_rate_tlv *bmc;
2162	struct tlv *tlv;
2163	u8 idx = mvif->mcast_rates_idx ?
2164		 mvif->mcast_rates_idx : mvif->basic_rates_idx;
2165
2166	tlv = mt76_connac_mcu_add_tlv(skb, UNI_BSS_INFO_RATE, sizeof(*bmc));
2167
2168	bmc = (struct bss_rate_tlv *)tlv;
2169
2170	bmc->short_preamble = (band == NL80211_BAND_2GHZ);
2171	bmc->bc_fixed_rate = idx;
2172	bmc->mc_fixed_rate = idx;
2173}
2174
2175static void
2176mt7925_mcu_bss_mld_tlv(struct sk_buff *skb,
2177		       struct ieee80211_vif *vif,
2178		       struct ieee80211_sta *sta)
2179{
2180	struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv;
2181	bool is_mld = ieee80211_vif_is_mld(vif);
2182	struct bss_mld_tlv *mld;
2183	struct tlv *tlv;
2184
2185	tlv = mt76_connac_mcu_add_tlv(skb, UNI_BSS_INFO_MLD, sizeof(*mld));
2186	mld = (struct bss_mld_tlv *)tlv;
2187
2188	mld->link_id = sta ? (is_mld ? vif->bss_conf.link_id : 0) : 0xff;
2189	mld->group_mld_id = is_mld ? mvif->mt76.idx : 0xff;
2190	mld->own_mld_id = mvif->mt76.idx + 32;
2191	mld->remap_idx = 0xff;
2192
2193	if (sta)
2194		memcpy(mld->mac_addr, sta->addr, ETH_ALEN);
2195}
2196
2197static void
2198mt7925_mcu_bss_qos_tlv(struct sk_buff *skb, struct ieee80211_vif *vif)
2199{
2200	struct mt76_connac_bss_qos_tlv *qos;
2201	struct tlv *tlv;
2202
2203	tlv = mt76_connac_mcu_add_tlv(skb, UNI_BSS_INFO_QBSS, sizeof(*qos));
2204	qos = (struct mt76_connac_bss_qos_tlv *)tlv;
2205	qos->qos = vif->bss_conf.qos;
2206}
2207
2208static void
2209mt7925_mcu_bss_he_tlv(struct sk_buff *skb, struct ieee80211_vif *vif,
2210		      struct mt792x_phy *phy)
2211{
2212#define DEFAULT_HE_PE_DURATION		4
2213#define DEFAULT_HE_DURATION_RTS_THRES	1023
2214	const struct ieee80211_sta_he_cap *cap;
2215	struct bss_info_uni_he *he;
2216	struct tlv *tlv;
2217
2218	cap = mt76_connac_get_he_phy_cap(phy->mt76, vif);
2219
2220	tlv = mt76_connac_mcu_add_tlv(skb, UNI_BSS_INFO_HE_BASIC, sizeof(*he));
2221
2222	he = (struct bss_info_uni_he *)tlv;
2223	he->he_pe_duration = vif->bss_conf.htc_trig_based_pkt_ext;
2224	if (!he->he_pe_duration)
2225		he->he_pe_duration = DEFAULT_HE_PE_DURATION;
2226
2227	he->he_rts_thres = cpu_to_le16(vif->bss_conf.frame_time_rts_th);
2228	if (!he->he_rts_thres)
2229		he->he_rts_thres = cpu_to_le16(DEFAULT_HE_DURATION_RTS_THRES);
2230
2231	he->max_nss_mcs[CMD_HE_MCS_BW80] = cap->he_mcs_nss_supp.tx_mcs_80;
2232	he->max_nss_mcs[CMD_HE_MCS_BW160] = cap->he_mcs_nss_supp.tx_mcs_160;
2233	he->max_nss_mcs[CMD_HE_MCS_BW8080] = cap->he_mcs_nss_supp.tx_mcs_80p80;
2234}
2235
2236static void
2237mt7925_mcu_bss_color_tlv(struct sk_buff *skb, struct ieee80211_vif *vif,
2238			 bool enable)
2239{
2240	struct bss_info_uni_bss_color *color;
2241	struct tlv *tlv;
2242
2243	tlv = mt76_connac_mcu_add_tlv(skb, UNI_BSS_INFO_BSS_COLOR, sizeof(*color));
2244	color = (struct bss_info_uni_bss_color *)tlv;
2245
2246	color->enable = enable ?
2247		vif->bss_conf.he_bss_color.enabled : 0;
2248	color->bss_color = enable ?
2249		vif->bss_conf.he_bss_color.color : 0;
2250}
2251
2252int mt7925_mcu_add_bss_info(struct mt792x_phy *phy,
2253			    struct ieee80211_chanctx_conf *ctx,
2254			    struct ieee80211_vif *vif,
2255			    struct ieee80211_sta *sta,
2256			    int enable)
2257{
2258	struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv;
2259	struct mt792x_dev *dev = phy->dev;
2260	struct sk_buff *skb;
2261	int err;
2262
2263	skb = __mt7925_mcu_alloc_bss_req(&dev->mt76, &mvif->mt76,
2264					 MT7925_BSS_UPDATE_MAX_SIZE);
2265	if (IS_ERR(skb))
2266		return PTR_ERR(skb);
2267
2268	/* bss_basic must be first */
2269	mt7925_mcu_bss_basic_tlv(skb, vif, sta, ctx, phy->mt76,
2270				 mvif->sta.wcid.idx, enable);
2271	mt7925_mcu_bss_sec_tlv(skb, vif);
2272
2273	mt7925_mcu_bss_bmc_tlv(skb, phy, ctx, vif, sta);
2274	mt7925_mcu_bss_qos_tlv(skb, vif);
2275	mt7925_mcu_bss_mld_tlv(skb, vif, sta);
2276
2277	if (vif->bss_conf.he_support) {
2278		mt7925_mcu_bss_he_tlv(skb, vif, phy);
2279		mt7925_mcu_bss_color_tlv(skb, vif, enable);
2280	}
2281
2282	err = mt76_mcu_skb_send_msg(&dev->mt76, skb,
2283				    MCU_UNI_CMD(BSS_INFO_UPDATE), true);
2284	if (err < 0)
2285		return err;
2286
2287	return mt7925_mcu_set_chctx(phy->mt76, &mvif->mt76, ctx);
2288}
2289
2290int mt7925_mcu_set_dbdc(struct mt76_phy *phy)
2291{
2292	struct mt76_dev *mdev = phy->dev;
2293
2294	struct mbmc_conf_tlv *conf;
2295	struct mbmc_set_req *hdr;
2296	struct sk_buff *skb;
2297	struct tlv *tlv;
2298	int max_len, err;
2299
2300	max_len = sizeof(*hdr) + sizeof(*conf);
2301	skb = mt76_mcu_msg_alloc(mdev, NULL, max_len);
2302	if (!skb)
2303		return -ENOMEM;
2304
2305	hdr = (struct mbmc_set_req *)skb_put(skb, sizeof(*hdr));
2306
2307	tlv = mt76_connac_mcu_add_tlv(skb, UNI_MBMC_SETTING, sizeof(*conf));
2308	conf = (struct mbmc_conf_tlv *)tlv;
2309
2310	conf->mbmc_en = 1;
2311	conf->band = 0; /* unused */
2312
2313	err = mt76_mcu_skb_send_msg(mdev, skb, MCU_UNI_CMD(SET_DBDC_PARMS),
2314				    false);
2315
2316	return err;
2317}
2318
2319#define MT76_CONNAC_SCAN_CHANNEL_TIME		60
2320
2321int mt7925_mcu_hw_scan(struct mt76_phy *phy, struct ieee80211_vif *vif,
2322		       struct ieee80211_scan_request *scan_req)
2323{
2324	struct mt76_vif *mvif = (struct mt76_vif *)vif->drv_priv;
2325	struct cfg80211_scan_request *sreq = &scan_req->req;
2326	int n_ssids = 0, err, i, duration;
2327	struct ieee80211_channel **scan_list = sreq->channels;
2328	struct mt76_dev *mdev = phy->dev;
2329	struct mt76_connac_mcu_scan_channel *chan;
2330	struct sk_buff *skb;
2331
2332	struct scan_hdr_tlv *hdr;
2333	struct scan_req_tlv *req;
2334	struct scan_ssid_tlv *ssid;
2335	struct scan_bssid_tlv *bssid;
2336	struct scan_chan_info_tlv *chan_info;
2337	struct scan_ie_tlv *ie;
2338	struct scan_misc_tlv *misc;
2339	struct tlv *tlv;
2340	int max_len;
2341
2342	max_len = sizeof(*hdr) + sizeof(*req) + sizeof(*ssid) +
2343				sizeof(*bssid) + sizeof(*chan_info) +
2344				sizeof(*misc) + sizeof(*ie);
2345
2346	skb = mt76_mcu_msg_alloc(mdev, NULL, max_len);
2347	if (!skb)
2348		return -ENOMEM;
2349
2350	set_bit(MT76_HW_SCANNING, &phy->state);
2351	mvif->scan_seq_num = (mvif->scan_seq_num + 1) & 0x7f;
2352
2353	hdr = (struct scan_hdr_tlv *)skb_put(skb, sizeof(*hdr));
2354	hdr->seq_num = mvif->scan_seq_num | mvif->band_idx << 7;
2355	hdr->bss_idx = mvif->idx;
2356
2357	tlv = mt76_connac_mcu_add_tlv(skb, UNI_SCAN_REQ, sizeof(*req));
2358	req = (struct scan_req_tlv *)tlv;
2359	req->scan_type = sreq->n_ssids ? 1 : 0;
2360	req->probe_req_num = sreq->n_ssids ? 2 : 0;
2361
2362	duration = MT76_CONNAC_SCAN_CHANNEL_TIME;
2363	/* increase channel time for passive scan */
2364	if (!sreq->n_ssids)
2365		duration *= 2;
2366	req->timeout_value = cpu_to_le16(sreq->n_channels * duration);
2367	req->channel_min_dwell_time = cpu_to_le16(duration);
2368	req->channel_dwell_time = cpu_to_le16(duration);
2369
2370	tlv = mt76_connac_mcu_add_tlv(skb, UNI_SCAN_SSID, sizeof(*ssid));
2371	ssid = (struct scan_ssid_tlv *)tlv;
2372	for (i = 0; i < sreq->n_ssids; i++) {
2373		if (!sreq->ssids[i].ssid_len)
2374			continue;
2375
2376		ssid->ssids[i].ssid_len = cpu_to_le32(sreq->ssids[i].ssid_len);
2377		memcpy(ssid->ssids[i].ssid, sreq->ssids[i].ssid,
2378		       sreq->ssids[i].ssid_len);
2379		n_ssids++;
2380	}
2381	ssid->ssid_type = n_ssids ? BIT(2) : BIT(0);
2382	ssid->ssids_num = n_ssids;
2383
2384	tlv = mt76_connac_mcu_add_tlv(skb, UNI_SCAN_BSSID, sizeof(*bssid));
2385	bssid = (struct scan_bssid_tlv *)tlv;
2386
2387	memcpy(bssid->bssid, sreq->bssid, ETH_ALEN);
2388
2389	tlv = mt76_connac_mcu_add_tlv(skb, UNI_SCAN_CHANNEL, sizeof(*chan_info));
2390	chan_info = (struct scan_chan_info_tlv *)tlv;
2391	chan_info->channels_num = min_t(u8, sreq->n_channels,
2392					ARRAY_SIZE(chan_info->channels));
2393	for (i = 0; i < chan_info->channels_num; i++) {
2394		chan = &chan_info->channels[i];
2395
2396		switch (scan_list[i]->band) {
2397		case NL80211_BAND_2GHZ:
2398			chan->band = 1;
2399			break;
2400		case NL80211_BAND_6GHZ:
2401			chan->band = 3;
2402			break;
2403		default:
2404			chan->band = 2;
2405			break;
2406		}
2407		chan->channel_num = scan_list[i]->hw_value;
2408	}
2409	chan_info->channel_type = sreq->n_channels ? 4 : 0;
2410
2411	tlv = mt76_connac_mcu_add_tlv(skb, UNI_SCAN_IE, sizeof(*ie));
2412	ie = (struct scan_ie_tlv *)tlv;
2413	if (sreq->ie_len > 0) {
2414		memcpy(ie->ies, sreq->ie, sreq->ie_len);
2415		ie->ies_len = cpu_to_le16(sreq->ie_len);
2416	}
2417
2418	req->scan_func |= SCAN_FUNC_SPLIT_SCAN;
2419
2420	tlv = mt76_connac_mcu_add_tlv(skb, UNI_SCAN_MISC, sizeof(*misc));
2421	misc = (struct scan_misc_tlv *)tlv;
2422	if (sreq->flags & NL80211_SCAN_FLAG_RANDOM_ADDR) {
2423		get_random_mask_addr(misc->random_mac, sreq->mac_addr,
2424				     sreq->mac_addr_mask);
2425		req->scan_func |= SCAN_FUNC_RANDOM_MAC;
2426	}
2427
2428	err = mt76_mcu_skb_send_msg(mdev, skb, MCU_UNI_CMD(SCAN_REQ),
2429				    false);
2430	if (err < 0)
2431		clear_bit(MT76_HW_SCANNING, &phy->state);
2432
2433	return err;
2434}
2435EXPORT_SYMBOL_GPL(mt7925_mcu_hw_scan);
2436
2437int mt7925_mcu_sched_scan_req(struct mt76_phy *phy,
2438			      struct ieee80211_vif *vif,
2439			      struct cfg80211_sched_scan_request *sreq)
2440{
2441	struct mt76_vif *mvif = (struct mt76_vif *)vif->drv_priv;
2442	struct ieee80211_channel **scan_list = sreq->channels;
2443	struct mt76_connac_mcu_scan_channel *chan;
2444	struct mt76_dev *mdev = phy->dev;
2445	struct cfg80211_match_set *cfg_match;
2446	struct cfg80211_ssid *cfg_ssid;
2447
2448	struct scan_hdr_tlv *hdr;
2449	struct scan_sched_req *req;
2450	struct scan_ssid_tlv *ssid;
2451	struct scan_chan_info_tlv *chan_info;
2452	struct scan_ie_tlv *ie;
2453	struct scan_sched_ssid_match_sets *match;
2454	struct sk_buff *skb;
2455	struct tlv *tlv;
2456	int i, max_len;
2457
2458	max_len = sizeof(*hdr) + sizeof(*req) + sizeof(*ssid) +
2459		  sizeof(*chan_info) + sizeof(*ie) +
2460		  sizeof(*match);
2461
2462	skb = mt76_mcu_msg_alloc(mdev, NULL, max_len);
2463	if (!skb)
2464		return -ENOMEM;
2465
2466	mvif->scan_seq_num = (mvif->scan_seq_num + 1) & 0x7f;
2467
2468	hdr = (struct scan_hdr_tlv *)skb_put(skb, sizeof(*hdr));
2469	hdr->seq_num = mvif->scan_seq_num | mvif->band_idx << 7;
2470	hdr->bss_idx = mvif->idx;
2471
2472	tlv = mt76_connac_mcu_add_tlv(skb, UNI_SCAN_SCHED_REQ, sizeof(*req));
2473	req = (struct scan_sched_req *)tlv;
2474	req->version = 1;
2475
2476	if (sreq->flags & NL80211_SCAN_FLAG_RANDOM_ADDR)
2477		req->scan_func |= SCAN_FUNC_RANDOM_MAC;
2478
2479	req->intervals_num = sreq->n_scan_plans;
2480	for (i = 0; i < req->intervals_num; i++)
2481		req->intervals[i] = cpu_to_le16(sreq->scan_plans[i].interval);
2482
2483	tlv = mt76_connac_mcu_add_tlv(skb, UNI_SCAN_SSID, sizeof(*ssid));
2484	ssid = (struct scan_ssid_tlv *)tlv;
2485
2486	ssid->ssids_num = sreq->n_ssids;
2487	ssid->ssid_type = BIT(2);
2488	for (i = 0; i < ssid->ssids_num; i++) {
2489		cfg_ssid = &sreq->ssids[i];
2490		memcpy(ssid->ssids[i].ssid, cfg_ssid->ssid, cfg_ssid->ssid_len);
2491		ssid->ssids[i].ssid_len = cpu_to_le32(cfg_ssid->ssid_len);
2492	}
2493
2494	tlv = mt76_connac_mcu_add_tlv(skb, UNI_SCAN_SSID_MATCH_SETS, sizeof(*match));
2495	match = (struct scan_sched_ssid_match_sets *)tlv;
2496	match->match_num = sreq->n_match_sets;
2497	for (i = 0; i < match->match_num; i++) {
2498		cfg_match = &sreq->match_sets[i];
2499		memcpy(match->match[i].ssid, cfg_match->ssid.ssid,
2500		       cfg_match->ssid.ssid_len);
2501		match->match[i].rssi_th = cpu_to_le32(cfg_match->rssi_thold);
2502		match->match[i].ssid_len = cfg_match->ssid.ssid_len;
2503	}
2504
2505	tlv = mt76_connac_mcu_add_tlv(skb, UNI_SCAN_CHANNEL, sizeof(*chan_info));
2506	chan_info = (struct scan_chan_info_tlv *)tlv;
2507	chan_info->channels_num = min_t(u8, sreq->n_channels,
2508					ARRAY_SIZE(chan_info->channels));
2509	for (i = 0; i < chan_info->channels_num; i++) {
2510		chan = &chan_info->channels[i];
2511
2512		switch (scan_list[i]->band) {
2513		case NL80211_BAND_2GHZ:
2514			chan->band = 1;
2515			break;
2516		case NL80211_BAND_6GHZ:
2517			chan->band = 3;
2518			break;
2519		default:
2520			chan->band = 2;
2521			break;
2522		}
2523		chan->channel_num = scan_list[i]->hw_value;
2524	}
2525	chan_info->channel_type = sreq->n_channels ? 4 : 0;
2526
2527	tlv = mt76_connac_mcu_add_tlv(skb, UNI_SCAN_IE, sizeof(*ie));
2528	ie = (struct scan_ie_tlv *)tlv;
2529	if (sreq->ie_len > 0) {
2530		memcpy(ie->ies, sreq->ie, sreq->ie_len);
2531		ie->ies_len = cpu_to_le16(sreq->ie_len);
2532	}
2533
2534	return mt76_mcu_skb_send_msg(mdev, skb, MCU_UNI_CMD(SCAN_REQ),
2535				     false);
2536}
2537EXPORT_SYMBOL_GPL(mt7925_mcu_sched_scan_req);
2538
2539int
2540mt7925_mcu_sched_scan_enable(struct mt76_phy *phy,
2541			     struct ieee80211_vif *vif,
2542			     bool enable)
2543{
2544	struct mt76_dev *mdev = phy->dev;
2545	struct scan_sched_enable *req;
2546	struct scan_hdr_tlv *hdr;
2547	struct sk_buff *skb;
2548	struct tlv *tlv;
2549	int max_len;
2550
2551	max_len = sizeof(*hdr) + sizeof(*req);
2552
2553	skb = mt76_mcu_msg_alloc(mdev, NULL, max_len);
2554	if (!skb)
2555		return -ENOMEM;
2556
2557	hdr = (struct scan_hdr_tlv *)skb_put(skb, sizeof(*hdr));
2558	hdr->seq_num = 0;
2559	hdr->bss_idx = 0;
2560
2561	tlv = mt76_connac_mcu_add_tlv(skb, UNI_SCAN_SCHED_ENABLE, sizeof(*req));
2562	req = (struct scan_sched_enable *)tlv;
2563	req->active = !enable;
2564
2565	if (enable)
2566		set_bit(MT76_HW_SCHED_SCANNING, &phy->state);
2567	else
2568		clear_bit(MT76_HW_SCHED_SCANNING, &phy->state);
2569
2570	return mt76_mcu_skb_send_msg(mdev, skb, MCU_UNI_CMD(SCAN_REQ),
2571				     false);
2572}
2573
2574int mt7925_mcu_cancel_hw_scan(struct mt76_phy *phy,
2575			      struct ieee80211_vif *vif)
2576{
2577	struct mt76_vif *mvif = (struct mt76_vif *)vif->drv_priv;
2578	struct {
2579		struct scan_hdr {
2580			u8 seq_num;
2581			u8 bss_idx;
2582			u8 pad[2];
2583		} __packed hdr;
2584		struct scan_cancel_tlv {
2585			__le16 tag;
2586			__le16 len;
2587			u8 is_ext_channel;
2588			u8 rsv[3];
2589		} __packed cancel;
2590	} req = {
2591		.hdr = {
2592			.seq_num = mvif->scan_seq_num,
2593			.bss_idx = mvif->idx,
2594		},
2595		.cancel = {
2596			.tag = cpu_to_le16(UNI_SCAN_CANCEL),
2597			.len = cpu_to_le16(sizeof(struct scan_cancel_tlv)),
2598		},
2599	};
2600
2601	if (test_and_clear_bit(MT76_HW_SCANNING, &phy->state)) {
2602		struct cfg80211_scan_info info = {
2603			.aborted = true,
2604		};
2605
2606		ieee80211_scan_completed(phy->hw, &info);
2607	}
2608
2609	return mt76_mcu_send_msg(phy->dev, MCU_UNI_CMD(SCAN_REQ),
2610				 &req, sizeof(req), false);
2611}
2612EXPORT_SYMBOL_GPL(mt7925_mcu_cancel_hw_scan);
2613
2614int mt7925_mcu_set_channel_domain(struct mt76_phy *phy)
2615{
2616	int len, i, n_max_channels, n_2ch = 0, n_5ch = 0, n_6ch = 0;
2617	struct {
2618		struct {
2619			u8 alpha2[4]; /* regulatory_request.alpha2 */
2620			u8 bw_2g; /* BW_20_40M		0
2621				   * BW_20M		1
2622				   * BW_20_40_80M	2
2623				   * BW_20_40_80_160M	3
2624				   * BW_20_40_80_8080M	4
2625				   */
2626			u8 bw_5g;
2627			u8 bw_6g;
2628			u8 pad;
2629		} __packed hdr;
2630		struct n_chan {
2631			__le16 tag;
2632			__le16 len;
2633			u8 n_2ch;
2634			u8 n_5ch;
2635			u8 n_6ch;
2636			u8 pad;
2637		} __packed n_ch;
2638	} req = {
2639		.hdr = {
2640			.bw_2g = 0,
2641			.bw_5g = 3, /* BW_20_40_80_160M */
2642			.bw_6g = 3,
2643		},
2644		.n_ch = {
2645			.tag = cpu_to_le16(2),
2646		},
2647	};
2648	struct mt76_connac_mcu_chan {
2649		__le16 hw_value;
2650		__le16 pad;
2651		__le32 flags;
2652	} __packed channel;
2653	struct mt76_dev *dev = phy->dev;
2654	struct ieee80211_channel *chan;
2655	struct sk_buff *skb;
2656
2657	n_max_channels = phy->sband_2g.sband.n_channels +
2658			 phy->sband_5g.sband.n_channels +
2659			 phy->sband_6g.sband.n_channels;
2660	len = sizeof(req) + n_max_channels * sizeof(channel);
2661
2662	skb = mt76_mcu_msg_alloc(dev, NULL, len);
2663	if (!skb)
2664		return -ENOMEM;
2665
2666	skb_reserve(skb, sizeof(req));
2667
2668	for (i = 0; i < phy->sband_2g.sband.n_channels; i++) {
2669		chan = &phy->sband_2g.sband.channels[i];
2670		if (chan->flags & IEEE80211_CHAN_DISABLED)
2671			continue;
2672
2673		channel.hw_value = cpu_to_le16(chan->hw_value);
2674		channel.flags = cpu_to_le32(chan->flags);
2675		channel.pad = 0;
2676
2677		skb_put_data(skb, &channel, sizeof(channel));
2678		n_2ch++;
2679	}
2680	for (i = 0; i < phy->sband_5g.sband.n_channels; i++) {
2681		chan = &phy->sband_5g.sband.channels[i];
2682		if (chan->flags & IEEE80211_CHAN_DISABLED)
2683			continue;
2684
2685		channel.hw_value = cpu_to_le16(chan->hw_value);
2686		channel.flags = cpu_to_le32(chan->flags);
2687		channel.pad = 0;
2688
2689		skb_put_data(skb, &channel, sizeof(channel));
2690		n_5ch++;
2691	}
2692	for (i = 0; i < phy->sband_6g.sband.n_channels; i++) {
2693		chan = &phy->sband_6g.sband.channels[i];
2694		if (chan->flags & IEEE80211_CHAN_DISABLED)
2695			continue;
2696
2697		channel.hw_value = cpu_to_le16(chan->hw_value);
2698		channel.flags = cpu_to_le32(chan->flags);
2699		channel.pad = 0;
2700
2701		skb_put_data(skb, &channel, sizeof(channel));
2702		n_6ch++;
2703	}
2704
2705	BUILD_BUG_ON(sizeof(dev->alpha2) > sizeof(req.hdr.alpha2));
2706	memcpy(req.hdr.alpha2, dev->alpha2, sizeof(dev->alpha2));
2707	req.n_ch.n_2ch = n_2ch;
2708	req.n_ch.n_5ch = n_5ch;
2709	req.n_ch.n_6ch = n_6ch;
2710	len = sizeof(struct n_chan) + (n_2ch + n_5ch + n_6ch) * sizeof(channel);
2711	req.n_ch.len = cpu_to_le16(len);
2712	memcpy(__skb_push(skb, sizeof(req)), &req, sizeof(req));
2713
2714	return mt76_mcu_skb_send_msg(dev, skb, MCU_UNI_CMD(SET_DOMAIN_INFO),
2715				     false);
2716}
2717EXPORT_SYMBOL_GPL(mt7925_mcu_set_channel_domain);
2718
2719static int
2720__mt7925_mcu_set_clc(struct mt792x_dev *dev, u8 *alpha2,
2721		     enum environment_cap env_cap,
2722		     struct mt7925_clc *clc, u8 idx)
2723{
2724	struct mt7925_clc_segment *seg;
2725	struct sk_buff *skb;
2726	struct {
2727		u8 rsv[4];
2728		__le16 tag;
2729		__le16 len;
2730
2731		u8 ver;
2732		u8 pad0;
2733		__le16 size;
2734		u8 idx;
2735		u8 env;
2736		u8 acpi_conf;
2737		u8 pad1;
2738		u8 alpha2[2];
2739		u8 type[2];
2740		u8 rsvd[64];
2741	} __packed req = {
2742		.tag = cpu_to_le16(0x3),
2743		.len = cpu_to_le16(sizeof(req) - 4),
2744
2745		.idx = idx,
2746		.env = env_cap,
2747		.acpi_conf = mt792x_acpi_get_flags(&dev->phy),
2748	};
2749	int ret, valid_cnt = 0;
2750	u8 i, *pos;
2751
2752	if (!clc)
2753		return 0;
2754
2755	pos = clc->data + sizeof(*seg) * clc->nr_seg;
2756	for (i = 0; i < clc->nr_country; i++) {
2757		struct mt7925_clc_rule *rule = (struct mt7925_clc_rule *)pos;
2758
2759		pos += sizeof(*rule);
2760		if (rule->alpha2[0] != alpha2[0] ||
2761		    rule->alpha2[1] != alpha2[1])
2762			continue;
2763
2764		seg = (struct mt7925_clc_segment *)clc->data
2765			  + rule->seg_idx - 1;
2766
2767		memcpy(req.alpha2, rule->alpha2, 2);
2768		memcpy(req.type, rule->type, 2);
2769
2770		req.size = cpu_to_le16(seg->len);
2771		skb = __mt76_mcu_msg_alloc(&dev->mt76, &req,
2772					   le16_to_cpu(req.size) + sizeof(req),
2773					   sizeof(req), GFP_KERNEL);
2774		if (!skb)
2775			return -ENOMEM;
2776		skb_put_data(skb, clc->data + seg->offset, seg->len);
2777
2778		ret = mt76_mcu_skb_send_msg(&dev->mt76, skb,
2779					    MCU_UNI_CMD(SET_POWER_LIMIT),
2780					    true);
2781		if (ret < 0)
2782			return ret;
2783		valid_cnt++;
2784	}
2785
2786	if (!valid_cnt)
2787		return -ENOENT;
2788
2789	return 0;
2790}
2791
2792int mt7925_mcu_set_clc(struct mt792x_dev *dev, u8 *alpha2,
2793		       enum environment_cap env_cap)
2794{
2795	struct mt792x_phy *phy = (struct mt792x_phy *)&dev->phy;
2796	int i, ret;
2797
2798	/* submit all clc config */
2799	for (i = 0; i < ARRAY_SIZE(phy->clc); i++) {
2800		ret = __mt7925_mcu_set_clc(dev, alpha2, env_cap,
2801					   phy->clc[i], i);
2802
2803		/* If no country found, set "00" as default */
2804		if (ret == -ENOENT)
2805			ret = __mt7925_mcu_set_clc(dev, "00",
2806						   ENVIRON_INDOOR,
2807						   phy->clc[i], i);
2808		if (ret < 0)
2809			return ret;
2810	}
2811	return 0;
2812}
2813
2814int mt7925_mcu_fill_message(struct mt76_dev *mdev, struct sk_buff *skb,
2815			    int cmd, int *wait_seq)
2816{
2817	int txd_len, mcu_cmd = FIELD_GET(__MCU_CMD_FIELD_ID, cmd);
2818	struct mt76_connac2_mcu_uni_txd *uni_txd;
2819	struct mt76_connac2_mcu_txd *mcu_txd;
2820	__le32 *txd;
2821	u32 val;
2822	u8 seq;
2823
2824	/* TODO: make dynamic based on msg type */
2825	mdev->mcu.timeout = 20 * HZ;
2826
2827	seq = ++mdev->mcu.msg_seq & 0xf;
2828	if (!seq)
2829		seq = ++mdev->mcu.msg_seq & 0xf;
2830
2831	if (cmd == MCU_CMD(FW_SCATTER))
2832		goto exit;
2833
2834	txd_len = cmd & __MCU_CMD_FIELD_UNI ? sizeof(*uni_txd) : sizeof(*mcu_txd);
2835	txd = (__le32 *)skb_push(skb, txd_len);
2836
2837	val = FIELD_PREP(MT_TXD0_TX_BYTES, skb->len) |
2838	      FIELD_PREP(MT_TXD0_PKT_FMT, MT_TX_TYPE_CMD) |
2839	      FIELD_PREP(MT_TXD0_Q_IDX, MT_TX_MCU_PORT_RX_Q0);
2840	txd[0] = cpu_to_le32(val);
2841
2842	val = FIELD_PREP(MT_TXD1_HDR_FORMAT, MT_HDR_FORMAT_CMD);
2843	txd[1] = cpu_to_le32(val);
2844
2845	if (cmd & __MCU_CMD_FIELD_UNI) {
2846		uni_txd = (struct mt76_connac2_mcu_uni_txd *)txd;
2847		uni_txd->len = cpu_to_le16(skb->len - sizeof(uni_txd->txd));
2848		uni_txd->option = MCU_CMD_UNI_EXT_ACK;
2849		uni_txd->cid = cpu_to_le16(mcu_cmd);
2850		uni_txd->s2d_index = MCU_S2D_H2N;
2851		uni_txd->pkt_type = MCU_PKT_ID;
2852		uni_txd->seq = seq;
2853
2854		goto exit;
2855	}
2856
2857	mcu_txd = (struct mt76_connac2_mcu_txd *)txd;
2858	mcu_txd->len = cpu_to_le16(skb->len - sizeof(mcu_txd->txd));
2859	mcu_txd->pq_id = cpu_to_le16(MCU_PQ_ID(MT_TX_PORT_IDX_MCU,
2860					       MT_TX_MCU_PORT_RX_Q0));
2861	mcu_txd->pkt_type = MCU_PKT_ID;
2862	mcu_txd->seq = seq;
2863	mcu_txd->cid = mcu_cmd;
2864	mcu_txd->ext_cid = FIELD_GET(__MCU_CMD_FIELD_EXT_ID, cmd);
2865
2866	if (mcu_txd->ext_cid || (cmd & __MCU_CMD_FIELD_CE)) {
2867		if (cmd & __MCU_CMD_FIELD_QUERY)
2868			mcu_txd->set_query = MCU_Q_QUERY;
2869		else
2870			mcu_txd->set_query = MCU_Q_SET;
2871		mcu_txd->ext_cid_ack = !!mcu_txd->ext_cid;
2872	} else {
2873		mcu_txd->set_query = MCU_Q_NA;
2874	}
2875
2876	if (cmd & __MCU_CMD_FIELD_WA)
2877		mcu_txd->s2d_index = MCU_S2D_H2C;
2878	else
2879		mcu_txd->s2d_index = MCU_S2D_H2N;
2880
2881exit:
2882	if (wait_seq)
2883		*wait_seq = seq;
2884
2885	return 0;
2886}
2887EXPORT_SYMBOL_GPL(mt7925_mcu_fill_message);
2888
2889int mt7925_mcu_set_rts_thresh(struct mt792x_phy *phy, u32 val)
2890{
2891	struct {
2892		u8 band_idx;
2893		u8 _rsv[3];
2894
2895		__le16 tag;
2896		__le16 len;
2897		__le32 len_thresh;
2898		__le32 pkt_thresh;
2899	} __packed req = {
2900		.band_idx = phy->mt76->band_idx,
2901		.tag = cpu_to_le16(UNI_BAND_CONFIG_RTS_THRESHOLD),
2902		.len = cpu_to_le16(sizeof(req) - 4),
2903		.len_thresh = cpu_to_le32(val),
2904		.pkt_thresh = cpu_to_le32(0x2),
2905	};
2906
2907	return mt76_mcu_send_msg(&phy->dev->mt76, MCU_UNI_CMD(BAND_CONFIG),
2908				 &req, sizeof(req), true);
2909}
2910
2911int mt7925_mcu_set_radio_en(struct mt792x_phy *phy, bool enable)
2912{
2913	struct {
2914		u8 band_idx;
2915		u8 _rsv[3];
2916
2917		__le16 tag;
2918		__le16 len;
2919		u8 enable;
2920		u8 _rsv2[3];
2921	} __packed req = {
2922		.band_idx = phy->mt76->band_idx,
2923		.tag = cpu_to_le16(UNI_BAND_CONFIG_RADIO_ENABLE),
2924		.len = cpu_to_le16(sizeof(req) - 4),
2925		.enable = enable,
2926	};
2927
2928	return mt76_mcu_send_msg(&phy->dev->mt76, MCU_UNI_CMD(BAND_CONFIG),
2929				 &req, sizeof(req), true);
2930}
2931
2932static void
2933mt7925_mcu_build_sku(struct mt76_dev *dev, s8 *sku,
2934		     struct mt76_power_limits *limits,
2935		     enum nl80211_band band)
2936{
2937	int i, offset = sizeof(limits->cck);
2938
2939	memset(sku, 127, MT_CONNAC3_SKU_POWER_LIMIT);
2940
2941	if (band == NL80211_BAND_2GHZ) {
2942		/* cck */
2943		memcpy(sku, limits->cck, sizeof(limits->cck));
2944	}
2945
2946	/* ofdm */
2947	memcpy(&sku[offset], limits->ofdm, sizeof(limits->ofdm));
2948	offset += (sizeof(limits->ofdm) * 5);
2949
2950	/* ht */
2951	for (i = 0; i < 2; i++) {
2952		memcpy(&sku[offset], limits->mcs[i], 8);
2953		offset += 8;
2954	}
2955	sku[offset++] = limits->mcs[0][0];
2956
2957	/* vht */
2958	for (i = 0; i < ARRAY_SIZE(limits->mcs); i++) {
2959		memcpy(&sku[offset], limits->mcs[i],
2960		       ARRAY_SIZE(limits->mcs[i]));
2961		offset += 12;
2962	}
2963
2964	/* he */
2965	for (i = 0; i < ARRAY_SIZE(limits->ru); i++) {
2966		memcpy(&sku[offset], limits->ru[i], ARRAY_SIZE(limits->ru[i]));
2967		offset += ARRAY_SIZE(limits->ru[i]);
2968	}
2969
2970	/* eht */
2971	for (i = 0; i < ARRAY_SIZE(limits->eht); i++) {
2972		memcpy(&sku[offset], limits->eht[i], ARRAY_SIZE(limits->eht[i]));
2973		offset += ARRAY_SIZE(limits->eht[i]);
2974	}
2975}
2976
2977static int
2978mt7925_mcu_rate_txpower_band(struct mt76_phy *phy,
2979			     enum nl80211_band band)
2980{
2981	int tx_power, n_chan, last_ch, err = 0, idx = 0;
2982	int i, sku_len, batch_size, batch_len = 3;
2983	struct mt76_dev *dev = phy->dev;
2984	static const u8 chan_list_2ghz[] = {
2985		1, 2,  3,  4,  5,  6,  7,
2986		8, 9, 10, 11, 12, 13, 14
2987	};
2988	static const u8 chan_list_5ghz[] = {
2989		 36,  38,  40,  42,  44,  46,  48,
2990		 50,  52,  54,  56,  58,  60,  62,
2991		 64, 100, 102, 104, 106, 108, 110,
2992		112, 114, 116, 118, 120, 122, 124,
2993		126, 128, 132, 134, 136, 138, 140,
2994		142, 144, 149, 151, 153, 155, 157,
2995		159, 161, 165, 167
2996	};
2997	static const u8 chan_list_6ghz[] = {
2998		  1,   3,   5,   7,   9,  11,  13,
2999		 15,  17,  19,  21,  23,  25,  27,
3000		 29,  33,  35,  37,  39,  41,  43,
3001		 45,  47,  49,  51,  53,  55,  57,
3002		 59,  61,  65,  67,  69,  71,  73,
3003		 75,  77,  79,  81,  83,  85,  87,
3004		 89,  91,  93,  97,  99, 101, 103,
3005		105, 107, 109, 111, 113, 115, 117,
3006		119, 121, 123, 125, 129, 131, 133,
3007		135, 137, 139, 141, 143, 145, 147,
3008		149, 151, 153, 155, 157, 161, 163,
3009		165, 167, 169, 171, 173, 175, 177,
3010		179, 181, 183, 185, 187, 189, 193,
3011		195, 197, 199, 201, 203, 205, 207,
3012		209, 211, 213, 215, 217, 219, 221,
3013		225, 227, 229, 233
3014	};
3015	struct mt76_power_limits *limits;
3016	struct mt7925_sku_tlv *sku_tlbv;
3017	const u8 *ch_list;
3018
3019	sku_len = sizeof(*sku_tlbv);
3020	tx_power = 2 * phy->hw->conf.power_level;
3021	if (!tx_power)
3022		tx_power = 127;
3023
3024	if (band == NL80211_BAND_2GHZ) {
3025		n_chan = ARRAY_SIZE(chan_list_2ghz);
3026		ch_list = chan_list_2ghz;
3027		last_ch = chan_list_2ghz[ARRAY_SIZE(chan_list_2ghz) - 1];
3028	} else if (band == NL80211_BAND_6GHZ) {
3029		n_chan = ARRAY_SIZE(chan_list_6ghz);
3030		ch_list = chan_list_6ghz;
3031		last_ch = chan_list_6ghz[ARRAY_SIZE(chan_list_6ghz) - 1];
3032	} else {
3033		n_chan = ARRAY_SIZE(chan_list_5ghz);
3034		ch_list = chan_list_5ghz;
3035		last_ch = chan_list_5ghz[ARRAY_SIZE(chan_list_5ghz) - 1];
3036	}
3037	batch_size = DIV_ROUND_UP(n_chan, batch_len);
3038
3039	limits = devm_kmalloc(dev->dev, sizeof(*limits), GFP_KERNEL);
3040	if (!limits)
3041		return -ENOMEM;
3042
3043	sku_tlbv = devm_kmalloc(dev->dev, sku_len, GFP_KERNEL);
3044	if (!sku_tlbv) {
3045		devm_kfree(dev->dev, limits);
3046		return -ENOMEM;
3047	}
3048
3049	for (i = 0; i < batch_size; i++) {
3050		struct mt7925_tx_power_limit_tlv *tx_power_tlv;
3051		int j, msg_len, num_ch;
3052		struct sk_buff *skb;
3053
3054		num_ch = i == batch_size - 1 ? n_chan % batch_len : batch_len;
3055		msg_len = sizeof(*tx_power_tlv) + num_ch * sku_len;
3056		skb = mt76_mcu_msg_alloc(dev, NULL, msg_len);
3057		if (!skb) {
3058			err = -ENOMEM;
3059			goto out;
3060		}
3061
3062		tx_power_tlv = (struct mt7925_tx_power_limit_tlv *)
3063			       skb_put(skb, sizeof(*tx_power_tlv));
3064
3065		BUILD_BUG_ON(sizeof(dev->alpha2) > sizeof(tx_power_tlv->alpha2));
3066		memcpy(tx_power_tlv->alpha2, dev->alpha2, sizeof(dev->alpha2));
3067		tx_power_tlv->n_chan = num_ch;
3068		tx_power_tlv->tag = cpu_to_le16(0x1);
3069		tx_power_tlv->len = cpu_to_le16(sizeof(*tx_power_tlv));
3070
3071		switch (band) {
3072		case NL80211_BAND_2GHZ:
3073			tx_power_tlv->band = 1;
3074			break;
3075		case NL80211_BAND_6GHZ:
3076			tx_power_tlv->band = 3;
3077			break;
3078		default:
3079			tx_power_tlv->band = 2;
3080			break;
3081		}
3082
3083		for (j = 0; j < num_ch; j++, idx++) {
3084			struct ieee80211_channel chan = {
3085				.hw_value = ch_list[idx],
3086				.band = band,
3087			};
3088			s8 reg_power, sar_power;
3089
3090			reg_power = mt76_connac_get_ch_power(phy, &chan,
3091							     tx_power);
3092			sar_power = mt76_get_sar_power(phy, &chan, reg_power);
3093
3094			mt76_get_rate_power_limits(phy, &chan, limits,
3095						   sar_power);
3096
3097			tx_power_tlv->last_msg = ch_list[idx] == last_ch;
3098			sku_tlbv->channel = ch_list[idx];
3099
3100			mt7925_mcu_build_sku(dev, sku_tlbv->pwr_limit,
3101					     limits, band);
3102			skb_put_data(skb, sku_tlbv, sku_len);
3103		}
3104		err = mt76_mcu_skb_send_msg(dev, skb,
3105					    MCU_UNI_CMD(SET_POWER_LIMIT),
3106					    true);
3107		if (err < 0)
3108			goto out;
3109	}
3110
3111out:
3112	devm_kfree(dev->dev, sku_tlbv);
3113	devm_kfree(dev->dev, limits);
3114	return err;
3115}
3116
3117int mt7925_mcu_set_rate_txpower(struct mt76_phy *phy)
3118{
3119	int err;
3120
3121	if (phy->cap.has_2ghz) {
3122		err = mt7925_mcu_rate_txpower_band(phy,
3123						   NL80211_BAND_2GHZ);
3124		if (err < 0)
3125			return err;
3126	}
3127
3128	if (phy->cap.has_5ghz) {
3129		err = mt7925_mcu_rate_txpower_band(phy,
3130						   NL80211_BAND_5GHZ);
3131		if (err < 0)
3132			return err;
3133	}
3134
3135	if (phy->cap.has_6ghz) {
3136		err = mt7925_mcu_rate_txpower_band(phy,
3137						   NL80211_BAND_6GHZ);
3138		if (err < 0)
3139			return err;
3140	}
3141
3142	return 0;
3143}
3144
3145int mt7925_mcu_set_rxfilter(struct mt792x_dev *dev, u32 fif,
3146			    u8 bit_op, u32 bit_map)
3147{
3148	struct mt792x_phy *phy = &dev->phy;
3149	struct {
3150		u8 band_idx;
3151		u8 rsv1[3];
3152
3153		__le16 tag;
3154		__le16 len;
3155		u8 mode;
3156		u8 rsv2[3];
3157		__le32 fif;
3158		__le32 bit_map; /* bit_* for bitmap update */
3159		u8 bit_op;
3160		u8 pad[51];
3161	} __packed req = {
3162		.band_idx = phy->mt76->band_idx,
3163		.tag = cpu_to_le16(UNI_BAND_CONFIG_SET_MAC80211_RX_FILTER),
3164		.len = cpu_to_le16(sizeof(req) - 4),
3165
3166		.mode = fif ? 0 : 1,
3167		.fif = cpu_to_le32(fif),
3168		.bit_map = cpu_to_le32(bit_map),
3169		.bit_op = bit_op,
3170	};
3171
3172	return mt76_mcu_send_msg(&phy->dev->mt76, MCU_UNI_CMD(BAND_CONFIG),
3173				 &req, sizeof(req), true);
3174}