wow.c

   1// SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause
   2/* Copyright(c) 2019-2022  Realtek Corporation
   3 */
   4#include "cam.h"
   5#include "core.h"
   6#include "debug.h"
   7#include "fw.h"
   8#include "mac.h"
   9#include "phy.h"
  10#include "ps.h"
  11#include "reg.h"
  12#include "util.h"
  13#include "wow.h"
  14
  15void __rtw89_wow_parse_akm(struct rtw89_dev *rtwdev, struct sk_buff *skb)
  16{
  17	struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *)skb->data;
  18	struct rtw89_wow_param *rtw_wow = &rtwdev->wow;
  19	const u8 *rsn, *ies = mgmt->u.assoc_req.variable;
  20	struct rtw89_rsn_ie *rsn_ie;
  21
  22	rsn = cfg80211_find_ie(WLAN_EID_RSN, ies, skb->len);
  23	if (!rsn)
  24		return;
  25
  26	rsn_ie = (struct rtw89_rsn_ie *)rsn;
  27	rtw_wow->akm = rsn_ie->akm_cipher_suite.type;
  28}
  29
  30#define RTW89_CIPHER_INFO_DEF(cipher) \
  31	{WLAN_CIPHER_SUITE_ ## cipher, .fw_alg = RTW89_WOW_FW_ALG_ ## cipher, \
  32	 .len = WLAN_KEY_LEN_ ## cipher}
  33
  34static const struct rtw89_cipher_info rtw89_cipher_info_defs[] = {
  35	RTW89_CIPHER_INFO_DEF(WEP40),
  36	RTW89_CIPHER_INFO_DEF(WEP104),
  37	RTW89_CIPHER_INFO_DEF(TKIP),
  38	RTW89_CIPHER_INFO_DEF(CCMP),
  39	RTW89_CIPHER_INFO_DEF(GCMP),
  40	RTW89_CIPHER_INFO_DEF(CCMP_256),
  41	RTW89_CIPHER_INFO_DEF(GCMP_256),
  42	RTW89_CIPHER_INFO_DEF(AES_CMAC),
  43};
  44
  45#undef RTW89_CIPHER_INFO_DEF
  46
  47static const
  48struct rtw89_cipher_info *rtw89_cipher_alg_recognize(u32 cipher)
  49{
  50	const struct rtw89_cipher_info *cipher_info_defs;
  51	int i;
  52
  53	for (i = 0; i < ARRAY_SIZE(rtw89_cipher_info_defs); i++) {
  54		cipher_info_defs = &rtw89_cipher_info_defs[i];
  55		if (cipher_info_defs->cipher == cipher)
  56			return cipher_info_defs;
  57	}
  58
  59	return NULL;
  60}
  61
  62static int _pn_to_iv(struct rtw89_dev *rtwdev, struct ieee80211_key_conf *key,
  63		     u8 *iv, u64 pn, u8 key_idx)
  64{
  65	switch (key->cipher) {
  66	case WLAN_CIPHER_SUITE_TKIP:
  67		iv[0] = u64_get_bits(pn, RTW89_KEY_PN_1);
  68		iv[1] = (u64_get_bits(pn, RTW89_KEY_PN_1) | 0x20) & 0x7f;
  69		iv[2] = u64_get_bits(pn, RTW89_KEY_PN_0);
  70		break;
  71	case WLAN_CIPHER_SUITE_CCMP:
  72	case WLAN_CIPHER_SUITE_GCMP:
  73	case WLAN_CIPHER_SUITE_CCMP_256:
  74	case WLAN_CIPHER_SUITE_GCMP_256:
  75		iv[0] = u64_get_bits(pn, RTW89_KEY_PN_0);
  76		iv[1] = u64_get_bits(pn, RTW89_KEY_PN_1);
  77		iv[2] = 0;
  78		break;
  79	default:
  80		return -EINVAL;
  81	}
  82
  83	iv[3] = BIT(5) | ((key_idx & 0x3) << 6);
  84	iv[4] = u64_get_bits(pn, RTW89_KEY_PN_2);
  85	iv[5] = u64_get_bits(pn, RTW89_KEY_PN_3);
  86	iv[6] = u64_get_bits(pn, RTW89_KEY_PN_4);
  87	iv[7] = u64_get_bits(pn, RTW89_KEY_PN_5);
  88
  89	return 0;
  90}
  91
  92static int rtw89_rx_pn_to_iv(struct rtw89_dev *rtwdev,
  93			     struct ieee80211_key_conf *key,
  94			     u8 *iv)
  95{
  96	struct ieee80211_key_seq seq;
  97	int err;
  98	u64 pn;
  99
 100	ieee80211_get_key_rx_seq(key, 0, &seq);
 101
 102	switch (key->cipher) {
 103	case WLAN_CIPHER_SUITE_TKIP:
 104		pn = u64_encode_bits(seq.tkip.iv32, RTW89_KEY_TKIP_PN_IV32) |
 105		     u64_encode_bits(seq.tkip.iv16, RTW89_KEY_TKIP_PN_IV16);
 106		break;
 107	case WLAN_CIPHER_SUITE_CCMP:
 108	case WLAN_CIPHER_SUITE_GCMP:
 109	case WLAN_CIPHER_SUITE_CCMP_256:
 110	case WLAN_CIPHER_SUITE_GCMP_256:
 111		/* seq.ccmp.pn[] is BE order array */
 112		pn = u64_encode_bits(seq.ccmp.pn[0], RTW89_KEY_PN_5) |
 113		     u64_encode_bits(seq.ccmp.pn[1], RTW89_KEY_PN_4) |
 114		     u64_encode_bits(seq.ccmp.pn[2], RTW89_KEY_PN_3) |
 115		     u64_encode_bits(seq.ccmp.pn[3], RTW89_KEY_PN_2) |
 116		     u64_encode_bits(seq.ccmp.pn[4], RTW89_KEY_PN_1) |
 117		     u64_encode_bits(seq.ccmp.pn[5], RTW89_KEY_PN_0);
 118		break;
 119	default:
 120		return -EINVAL;
 121	}
 122
 123	err = _pn_to_iv(rtwdev, key, iv, pn, key->keyidx);
 124	if (err)
 125		return err;
 126
 127	rtw89_debug(rtwdev, RTW89_DBG_WOW, "%s key %d pn-%llx to iv-%*ph\n",
 128		    __func__, key->keyidx, pn, 8, iv);
 129
 130	return 0;
 131}
 132
 133static int rtw89_tx_pn_to_iv(struct rtw89_dev *rtwdev,
 134			     struct ieee80211_key_conf *key,
 135			     u8 *iv)
 136{
 137	int err;
 138	u64 pn;
 139
 140	pn = atomic64_inc_return(&key->tx_pn);
 141	err = _pn_to_iv(rtwdev, key, iv, pn, key->keyidx);
 142	if (err)
 143		return err;
 144
 145	rtw89_debug(rtwdev, RTW89_DBG_WOW, "%s key %d pn-%llx to iv-%*ph\n",
 146		    __func__, key->keyidx, pn, 8, iv);
 147
 148	return 0;
 149}
 150
 151static int _iv_to_pn(struct rtw89_dev *rtwdev, u8 *iv, u64 *pn, u8 *key_id,
 152		     struct ieee80211_key_conf *key)
 153{
 154	switch (key->cipher) {
 155	case WLAN_CIPHER_SUITE_TKIP:
 156		*pn = u64_encode_bits(iv[2], RTW89_KEY_PN_0) |
 157		      u64_encode_bits(iv[0], RTW89_KEY_PN_1);
 158		break;
 159	case WLAN_CIPHER_SUITE_CCMP:
 160	case WLAN_CIPHER_SUITE_GCMP:
 161	case WLAN_CIPHER_SUITE_CCMP_256:
 162	case WLAN_CIPHER_SUITE_GCMP_256:
 163		*pn = u64_encode_bits(iv[0], RTW89_KEY_PN_0) |
 164		      u64_encode_bits(iv[1], RTW89_KEY_PN_1);
 165		break;
 166	default:
 167		return -EINVAL;
 168	}
 169
 170	*pn |= u64_encode_bits(iv[4], RTW89_KEY_PN_2) |
 171	       u64_encode_bits(iv[5], RTW89_KEY_PN_3) |
 172	       u64_encode_bits(iv[6], RTW89_KEY_PN_4) |
 173	       u64_encode_bits(iv[7], RTW89_KEY_PN_5);
 174
 175	if (key_id)
 176		*key_id = *(iv + 3) >> 6;
 177
 178	return 0;
 179}
 180
 181static int rtw89_rx_iv_to_pn(struct rtw89_dev *rtwdev,
 182			     struct ieee80211_key_conf *key,
 183			     u8 *iv)
 184{
 185	struct ieee80211_key_seq seq;
 186	int err;
 187	u64 pn;
 188
 189	err = _iv_to_pn(rtwdev, iv, &pn, NULL, key);
 190	if (err)
 191		return err;
 192
 193	switch (key->cipher) {
 194	case WLAN_CIPHER_SUITE_TKIP:
 195		seq.tkip.iv32 = u64_get_bits(pn, RTW89_KEY_TKIP_PN_IV32);
 196		seq.tkip.iv16 = u64_get_bits(pn, RTW89_KEY_TKIP_PN_IV16);
 197		break;
 198	case WLAN_CIPHER_SUITE_CCMP:
 199	case WLAN_CIPHER_SUITE_GCMP:
 200	case WLAN_CIPHER_SUITE_CCMP_256:
 201	case WLAN_CIPHER_SUITE_GCMP_256:
 202		/* seq.ccmp.pn[] is BE order array */
 203		seq.ccmp.pn[0] = u64_get_bits(pn, RTW89_KEY_PN_5);
 204		seq.ccmp.pn[1] = u64_get_bits(pn, RTW89_KEY_PN_4);
 205		seq.ccmp.pn[2] = u64_get_bits(pn, RTW89_KEY_PN_3);
 206		seq.ccmp.pn[3] = u64_get_bits(pn, RTW89_KEY_PN_2);
 207		seq.ccmp.pn[4] = u64_get_bits(pn, RTW89_KEY_PN_1);
 208		seq.ccmp.pn[5] = u64_get_bits(pn, RTW89_KEY_PN_0);
 209		break;
 210	default:
 211		return -EINVAL;
 212	}
 213
 214	ieee80211_set_key_rx_seq(key, 0, &seq);
 215	rtw89_debug(rtwdev, RTW89_DBG_WOW, "%s key %d iv-%*ph to pn-%*ph\n",
 216		    __func__, key->keyidx, 8, iv, 6, seq.ccmp.pn);
 217
 218	return 0;
 219}
 220
 221static int rtw89_tx_iv_to_pn(struct rtw89_dev *rtwdev,
 222			     struct ieee80211_key_conf *key,
 223			     u8 *iv)
 224{
 225	int err;
 226	u64 pn;
 227
 228	err = _iv_to_pn(rtwdev, iv, &pn, NULL, key);
 229	if (err)
 230		return err;
 231
 232	atomic64_set(&key->tx_pn, pn);
 233	rtw89_debug(rtwdev, RTW89_DBG_WOW, "%s key %d iv-%*ph to pn-%llx\n",
 234		    __func__, key->keyidx, 8, iv, pn);
 235
 236	return 0;
 237}
 238
 239static int rtw89_rx_pn_get_pmf(struct rtw89_dev *rtwdev,
 240			       struct ieee80211_key_conf *key,
 241			       struct rtw89_wow_gtk_info *gtk_info)
 242{
 243	struct ieee80211_key_seq seq;
 244	u64 pn;
 245
 246	if (key->keyidx == 4)
 247		memcpy(gtk_info->igtk[0], key->key, key->keylen);
 248	else if (key->keyidx == 5)
 249		memcpy(gtk_info->igtk[1], key->key, key->keylen);
 250	else
 251		return -EINVAL;
 252
 253	ieee80211_get_key_rx_seq(key, 0, &seq);
 254
 255	/* seq.ccmp.pn[] is BE order array */
 256	pn = u64_encode_bits(seq.ccmp.pn[0], RTW89_KEY_PN_5) |
 257	     u64_encode_bits(seq.ccmp.pn[1], RTW89_KEY_PN_4) |
 258	     u64_encode_bits(seq.ccmp.pn[2], RTW89_KEY_PN_3) |
 259	     u64_encode_bits(seq.ccmp.pn[3], RTW89_KEY_PN_2) |
 260	     u64_encode_bits(seq.ccmp.pn[4], RTW89_KEY_PN_1) |
 261	     u64_encode_bits(seq.ccmp.pn[5], RTW89_KEY_PN_0);
 262	gtk_info->ipn = cpu_to_le64(pn);
 263	gtk_info->igtk_keyid = cpu_to_le32(key->keyidx);
 264	rtw89_debug(rtwdev, RTW89_DBG_WOW, "%s key %d pn-%llx\n",
 265		    __func__, key->keyidx, pn);
 266
 267	return 0;
 268}
 269
 270static int rtw89_rx_pn_set_pmf(struct rtw89_dev *rtwdev,
 271			       struct ieee80211_key_conf *key,
 272			       u64 pn)
 273{
 274	struct rtw89_wow_param *rtw_wow = &rtwdev->wow;
 275	struct rtw89_wow_aoac_report *aoac_rpt = &rtw_wow->aoac_rpt;
 276	struct ieee80211_key_seq seq;
 277
 278	if (key->keyidx != aoac_rpt->igtk_key_id)
 279		return 0;
 280
 281	/* seq.ccmp.pn[] is BE order array */
 282	seq.ccmp.pn[0] = u64_get_bits(pn, RTW89_KEY_PN_5);
 283	seq.ccmp.pn[1] = u64_get_bits(pn, RTW89_KEY_PN_4);
 284	seq.ccmp.pn[2] = u64_get_bits(pn, RTW89_KEY_PN_3);
 285	seq.ccmp.pn[3] = u64_get_bits(pn, RTW89_KEY_PN_2);
 286	seq.ccmp.pn[4] = u64_get_bits(pn, RTW89_KEY_PN_1);
 287	seq.ccmp.pn[5] = u64_get_bits(pn, RTW89_KEY_PN_0);
 288
 289	ieee80211_set_key_rx_seq(key, 0, &seq);
 290	rtw89_debug(rtwdev, RTW89_DBG_WOW, "%s key %d pn-%*ph\n",
 291		    __func__, key->keyidx, 6, seq.ccmp.pn);
 292
 293	return 0;
 294}
 295
 296static void rtw89_wow_get_key_info_iter(struct ieee80211_hw *hw,
 297					struct ieee80211_vif *vif,
 298					struct ieee80211_sta *sta,
 299					struct ieee80211_key_conf *key,
 300					void *data)
 301{
 302	struct rtw89_dev *rtwdev = hw->priv;
 303	struct rtw89_wow_param *rtw_wow = &rtwdev->wow;
 304	struct rtw89_wow_key_info *key_info = &rtw_wow->key_info;
 305	struct rtw89_wow_gtk_info *gtk_info = &rtw_wow->gtk_info;
 306	const struct rtw89_cipher_info *cipher_info;
 307	bool *err = data;
 308	int ret;
 309
 310	cipher_info = rtw89_cipher_alg_recognize(key->cipher);
 311
 312	switch (key->cipher) {
 313	case WLAN_CIPHER_SUITE_TKIP:
 314		if (sta)
 315			memcpy(gtk_info->txmickey,
 316			       key->key + NL80211_TKIP_DATA_OFFSET_TX_MIC_KEY,
 317			       sizeof(gtk_info->txmickey));
 318		fallthrough;
 319	case WLAN_CIPHER_SUITE_CCMP:
 320	case WLAN_CIPHER_SUITE_GCMP:
 321	case WLAN_CIPHER_SUITE_CCMP_256:
 322	case WLAN_CIPHER_SUITE_GCMP_256:
 323		if (sta) {
 324			ret = rtw89_tx_pn_to_iv(rtwdev, key,
 325						key_info->ptk_tx_iv);
 326			if (ret)
 327				goto err;
 328			ret = rtw89_rx_pn_to_iv(rtwdev, key,
 329						key_info->ptk_rx_iv);
 330			if (ret)
 331				goto err;
 332
 333			rtw_wow->ptk_alg = cipher_info->fw_alg;
 334			rtw_wow->ptk_keyidx = key->keyidx;
 335		} else {
 336			ret = rtw89_rx_pn_to_iv(rtwdev, key,
 337						key_info->gtk_rx_iv[key->keyidx]);
 338			if (ret)
 339				goto err;
 340
 341			rtw_wow->gtk_alg = cipher_info->fw_alg;
 342			key_info->gtk_keyidx = key->keyidx;
 343		}
 344		break;
 345	case WLAN_CIPHER_SUITE_AES_CMAC:
 346		ret = rtw89_rx_pn_get_pmf(rtwdev, key, gtk_info);
 347		if (ret)
 348			goto err;
 349		break;
 350	case WLAN_CIPHER_SUITE_WEP40:
 351	case WLAN_CIPHER_SUITE_WEP104:
 352		/* WEP only set group key in mac80211, but fw need to set
 353		 * both of pairwise key and group key.
 354		 */
 355		rtw_wow->ptk_alg = cipher_info->fw_alg;
 356		rtw_wow->ptk_keyidx = key->keyidx;
 357		rtw_wow->gtk_alg = cipher_info->fw_alg;
 358		key_info->gtk_keyidx = key->keyidx;
 359		break;
 360	default:
 361		rtw89_debug(rtwdev, RTW89_DBG_WOW, "unsupport cipher %x\n",
 362			    key->cipher);
 363		goto err;
 364	}
 365
 366	return;
 367err:
 368	*err = true;
 369}
 370
 371static void rtw89_wow_set_key_info_iter(struct ieee80211_hw *hw,
 372					struct ieee80211_vif *vif,
 373					struct ieee80211_sta *sta,
 374					struct ieee80211_key_conf *key,
 375					void *data)
 376{
 377	struct rtw89_dev *rtwdev = hw->priv;
 378	struct rtw89_wow_param *rtw_wow = &rtwdev->wow;
 379	struct rtw89_wow_aoac_report *aoac_rpt = &rtw_wow->aoac_rpt;
 380	struct rtw89_set_key_info_iter_data *iter_data = data;
 381	bool update_tx_key_info = iter_data->rx_ready;
 382	u8 tmp[RTW89_MIC_KEY_LEN];
 383	int ret;
 384
 385	switch (key->cipher) {
 386	case WLAN_CIPHER_SUITE_TKIP:
 387		/*
 388		 * TX MIC KEY and RX MIC KEY is oppsite in FW,
 389		 * need to swap it before sending to mac80211.
 390		 */
 391		if (!sta && update_tx_key_info && aoac_rpt->rekey_ok &&
 392		    !iter_data->tkip_gtk_swapped) {
 393			memcpy(tmp, &aoac_rpt->gtk[NL80211_TKIP_DATA_OFFSET_TX_MIC_KEY],
 394			       RTW89_MIC_KEY_LEN);
 395			memcpy(&aoac_rpt->gtk[NL80211_TKIP_DATA_OFFSET_TX_MIC_KEY],
 396			       &aoac_rpt->gtk[NL80211_TKIP_DATA_OFFSET_RX_MIC_KEY],
 397			       RTW89_MIC_KEY_LEN);
 398			memcpy(&aoac_rpt->gtk[NL80211_TKIP_DATA_OFFSET_RX_MIC_KEY],
 399			       tmp, RTW89_MIC_KEY_LEN);
 400			iter_data->tkip_gtk_swapped = true;
 401		}
 402		fallthrough;
 403	case WLAN_CIPHER_SUITE_CCMP:
 404	case WLAN_CIPHER_SUITE_GCMP:
 405	case WLAN_CIPHER_SUITE_CCMP_256:
 406	case WLAN_CIPHER_SUITE_GCMP_256:
 407		if (sta && !update_tx_key_info) {
 408			ret = rtw89_rx_iv_to_pn(rtwdev, key,
 409						aoac_rpt->ptk_rx_iv);
 410			if (ret)
 411				goto err;
 412		}
 413
 414		if (sta && update_tx_key_info) {
 415			ret = rtw89_tx_iv_to_pn(rtwdev, key,
 416						aoac_rpt->ptk_tx_iv);
 417			if (ret)
 418				goto err;
 419		}
 420
 421		if (!sta && !update_tx_key_info) {
 422			ret = rtw89_rx_iv_to_pn(rtwdev, key,
 423						aoac_rpt->gtk_rx_iv[key->keyidx]);
 424			if (ret)
 425				goto err;
 426		}
 427
 428		if (!sta && update_tx_key_info && aoac_rpt->rekey_ok)
 429			iter_data->gtk_cipher = key->cipher;
 430		break;
 431	case WLAN_CIPHER_SUITE_AES_CMAC:
 432		if (update_tx_key_info) {
 433			if (aoac_rpt->rekey_ok)
 434				iter_data->igtk_cipher = key->cipher;
 435		} else {
 436			ret = rtw89_rx_pn_set_pmf(rtwdev, key,
 437						  aoac_rpt->igtk_ipn);
 438			if (ret)
 439				goto err;
 440		}
 441		break;
 442	case WLAN_CIPHER_SUITE_WEP40:
 443	case WLAN_CIPHER_SUITE_WEP104:
 444		break;
 445	default:
 446		rtw89_debug(rtwdev, RTW89_DBG_WOW, "unsupport cipher %x\n",
 447			    key->cipher);
 448		goto err;
 449	}
 450
 451	return;
 452
 453err:
 454	iter_data->error = true;
 455}
 456
 457static void rtw89_wow_key_clear(struct rtw89_dev *rtwdev)
 458{
 459	struct rtw89_wow_param *rtw_wow = &rtwdev->wow;
 460
 461	memset(&rtw_wow->aoac_rpt, 0, sizeof(rtw_wow->aoac_rpt));
 462	memset(&rtw_wow->gtk_info, 0, sizeof(rtw_wow->gtk_info));
 463	memset(&rtw_wow->key_info, 0, sizeof(rtw_wow->key_info));
 464	rtw_wow->ptk_alg = 0;
 465	rtw_wow->gtk_alg = 0;
 466}
 467
 468static void rtw89_wow_construct_key_info(struct rtw89_dev *rtwdev)
 469{
 470	struct rtw89_wow_param *rtw_wow = &rtwdev->wow;
 471	struct rtw89_wow_key_info *key_info = &rtw_wow->key_info;
 472	struct rtw89_vif_link *rtwvif_link = rtwdev->wow.rtwvif_link;
 473	struct ieee80211_vif *wow_vif = rtwvif_link_to_vif(rtwvif_link);
 474	bool err = false;
 475
 476	rcu_read_lock();
 477	ieee80211_iter_keys_rcu(rtwdev->hw, wow_vif,
 478				rtw89_wow_get_key_info_iter, &err);
 479	rcu_read_unlock();
 480
 481	if (err) {
 482		rtw89_wow_key_clear(rtwdev);
 483		return;
 484	}
 485
 486	key_info->valid_check = RTW89_WOW_VALID_CHECK;
 487	key_info->symbol_check_en = RTW89_WOW_SYMBOL_CHK_PTK |
 488				    RTW89_WOW_SYMBOL_CHK_GTK;
 489}
 490
 491static void rtw89_wow_debug_aoac_rpt(struct rtw89_dev *rtwdev)
 492{
 493	struct rtw89_wow_param *rtw_wow = &rtwdev->wow;
 494	struct rtw89_wow_aoac_report *aoac_rpt = &rtw_wow->aoac_rpt;
 495
 496	if (!rtw89_debug_is_enabled(rtwdev, RTW89_DBG_WOW))
 497		return;
 498
 499	rtw89_debug(rtwdev, RTW89_DBG_WOW, "[aoac_rpt] rpt_ver = %d\n",
 500		    aoac_rpt->rpt_ver);
 501	rtw89_debug(rtwdev, RTW89_DBG_WOW, "[aoac_rpt] sec_type = %d\n",
 502		    aoac_rpt->sec_type);
 503	rtw89_debug(rtwdev, RTW89_DBG_WOW, "[aoac_rpt] key_idx = %d\n",
 504		    aoac_rpt->key_idx);
 505	rtw89_debug(rtwdev, RTW89_DBG_WOW, "[aoac_rpt] pattern_idx = %d\n",
 506		    aoac_rpt->pattern_idx);
 507	rtw89_debug(rtwdev, RTW89_DBG_WOW, "[aoac_rpt] rekey_ok = %d\n",
 508		    aoac_rpt->rekey_ok);
 509	rtw89_debug(rtwdev, RTW89_DBG_WOW, "[aoac_rpt] ptk_tx_iv = %*ph\n",
 510		    8, aoac_rpt->ptk_tx_iv);
 511	rtw89_debug(rtwdev, RTW89_DBG_WOW,
 512		    "[aoac_rpt] eapol_key_replay_count = %*ph\n",
 513		    8, aoac_rpt->eapol_key_replay_count);
 514	rtw89_debug(rtwdev, RTW89_DBG_WOW, "[aoac_rpt] ptk_rx_iv = %*ph\n",
 515		    8, aoac_rpt->ptk_rx_iv);
 516	rtw89_debug(rtwdev, RTW89_DBG_WOW, "[aoac_rpt] gtk_rx_iv[0] = %*ph\n",
 517		    8, aoac_rpt->gtk_rx_iv[0]);
 518	rtw89_debug(rtwdev, RTW89_DBG_WOW, "[aoac_rpt] gtk_rx_iv[1] = %*ph\n",
 519		    8, aoac_rpt->gtk_rx_iv[1]);
 520	rtw89_debug(rtwdev, RTW89_DBG_WOW, "[aoac_rpt] gtk_rx_iv[2] = %*ph\n",
 521		    8, aoac_rpt->gtk_rx_iv[2]);
 522	rtw89_debug(rtwdev, RTW89_DBG_WOW, "[aoac_rpt] gtk_rx_iv[3] = %*ph\n",
 523		    8, aoac_rpt->gtk_rx_iv[3]);
 524	rtw89_debug(rtwdev, RTW89_DBG_WOW, "[aoac_rpt] igtk_key_id = %llu\n",
 525		    aoac_rpt->igtk_key_id);
 526	rtw89_debug(rtwdev, RTW89_DBG_WOW, "[aoac_rpt] igtk_ipn = %llu\n",
 527		    aoac_rpt->igtk_ipn);
 528	rtw89_debug(rtwdev, RTW89_DBG_WOW, "[aoac_rpt] igtk = %*ph\n",
 529		    32, aoac_rpt->igtk);
 530}
 531
 532static int rtw89_wow_get_aoac_rpt_reg(struct rtw89_dev *rtwdev)
 533{
 534	struct rtw89_wow_param *rtw_wow = &rtwdev->wow;
 535	struct rtw89_wow_aoac_report *aoac_rpt = &rtw_wow->aoac_rpt;
 536	struct rtw89_mac_c2h_info c2h_info = {};
 537	struct rtw89_mac_h2c_info h2c_info = {};
 538	u8 igtk_ipn[8];
 539	u8 key_idx;
 540	int ret;
 541
 542	h2c_info.id = RTW89_FWCMD_H2CREG_FUNC_AOAC_RPT_1;
 543	h2c_info.content_len = 2;
 544	ret = rtw89_fw_msg_reg(rtwdev, &h2c_info, &c2h_info);
 545	if (ret)
 546		return ret;
 547
 548	aoac_rpt->key_idx =
 549		u32_get_bits(c2h_info.u.c2hreg[0], RTW89_C2HREG_AOAC_RPT_1_W0_KEY_IDX);
 550	key_idx = aoac_rpt->key_idx;
 551	aoac_rpt->gtk_rx_iv[key_idx][0] =
 552		u32_get_bits(c2h_info.u.c2hreg[1], RTW89_C2HREG_AOAC_RPT_1_W1_IV_0);
 553	aoac_rpt->gtk_rx_iv[key_idx][1] =
 554		u32_get_bits(c2h_info.u.c2hreg[1], RTW89_C2HREG_AOAC_RPT_1_W1_IV_1);
 555	aoac_rpt->gtk_rx_iv[key_idx][2] =
 556		u32_get_bits(c2h_info.u.c2hreg[1], RTW89_C2HREG_AOAC_RPT_1_W1_IV_2);
 557	aoac_rpt->gtk_rx_iv[key_idx][3] =
 558		u32_get_bits(c2h_info.u.c2hreg[1], RTW89_C2HREG_AOAC_RPT_1_W1_IV_3);
 559	aoac_rpt->gtk_rx_iv[key_idx][4] =
 560		u32_get_bits(c2h_info.u.c2hreg[2], RTW89_C2HREG_AOAC_RPT_1_W2_IV_4);
 561	aoac_rpt->gtk_rx_iv[key_idx][5] =
 562		u32_get_bits(c2h_info.u.c2hreg[2], RTW89_C2HREG_AOAC_RPT_1_W2_IV_5);
 563	aoac_rpt->gtk_rx_iv[key_idx][6] =
 564		u32_get_bits(c2h_info.u.c2hreg[2], RTW89_C2HREG_AOAC_RPT_1_W2_IV_6);
 565	aoac_rpt->gtk_rx_iv[key_idx][7] =
 566		u32_get_bits(c2h_info.u.c2hreg[2], RTW89_C2HREG_AOAC_RPT_1_W2_IV_7);
 567	aoac_rpt->ptk_rx_iv[0] =
 568		u32_get_bits(c2h_info.u.c2hreg[3], RTW89_C2HREG_AOAC_RPT_1_W3_PTK_IV_0);
 569	aoac_rpt->ptk_rx_iv[1] =
 570		u32_get_bits(c2h_info.u.c2hreg[3], RTW89_C2HREG_AOAC_RPT_1_W3_PTK_IV_1);
 571	aoac_rpt->ptk_rx_iv[2] =
 572		u32_get_bits(c2h_info.u.c2hreg[3], RTW89_C2HREG_AOAC_RPT_1_W3_PTK_IV_2);
 573	aoac_rpt->ptk_rx_iv[3] =
 574		u32_get_bits(c2h_info.u.c2hreg[3], RTW89_C2HREG_AOAC_RPT_1_W3_PTK_IV_3);
 575
 576	h2c_info.id = RTW89_FWCMD_H2CREG_FUNC_AOAC_RPT_2;
 577	h2c_info.content_len = 2;
 578	ret = rtw89_fw_msg_reg(rtwdev, &h2c_info, &c2h_info);
 579	if (ret)
 580		return ret;
 581
 582	aoac_rpt->ptk_rx_iv[4] =
 583		u32_get_bits(c2h_info.u.c2hreg[0], RTW89_C2HREG_AOAC_RPT_2_W0_PTK_IV_4);
 584	aoac_rpt->ptk_rx_iv[5] =
 585		u32_get_bits(c2h_info.u.c2hreg[0], RTW89_C2HREG_AOAC_RPT_2_W0_PTK_IV_5);
 586	aoac_rpt->ptk_rx_iv[6] =
 587		u32_get_bits(c2h_info.u.c2hreg[1], RTW89_C2HREG_AOAC_RPT_2_W1_PTK_IV_6);
 588	aoac_rpt->ptk_rx_iv[7] =
 589		u32_get_bits(c2h_info.u.c2hreg[1], RTW89_C2HREG_AOAC_RPT_2_W1_PTK_IV_7);
 590	igtk_ipn[0] =
 591		u32_get_bits(c2h_info.u.c2hreg[1], RTW89_C2HREG_AOAC_RPT_2_W1_IGTK_IPN_IV_0);
 592	igtk_ipn[1] =
 593		u32_get_bits(c2h_info.u.c2hreg[1], RTW89_C2HREG_AOAC_RPT_2_W1_IGTK_IPN_IV_1);
 594	igtk_ipn[2] =
 595		u32_get_bits(c2h_info.u.c2hreg[2], RTW89_C2HREG_AOAC_RPT_2_W2_IGTK_IPN_IV_2);
 596	igtk_ipn[3] =
 597		u32_get_bits(c2h_info.u.c2hreg[2], RTW89_C2HREG_AOAC_RPT_2_W2_IGTK_IPN_IV_3);
 598	igtk_ipn[4] =
 599		u32_get_bits(c2h_info.u.c2hreg[2], RTW89_C2HREG_AOAC_RPT_2_W2_IGTK_IPN_IV_4);
 600	igtk_ipn[5] =
 601		u32_get_bits(c2h_info.u.c2hreg[2], RTW89_C2HREG_AOAC_RPT_2_W2_IGTK_IPN_IV_5);
 602	igtk_ipn[6] =
 603		u32_get_bits(c2h_info.u.c2hreg[3], RTW89_C2HREG_AOAC_RPT_2_W3_IGTK_IPN_IV_6);
 604	igtk_ipn[7] =
 605		u32_get_bits(c2h_info.u.c2hreg[3], RTW89_C2HREG_AOAC_RPT_2_W3_IGTK_IPN_IV_7);
 606	aoac_rpt->igtk_ipn = u64_encode_bits(igtk_ipn[0], RTW89_IGTK_IPN_0) |
 607			     u64_encode_bits(igtk_ipn[1], RTW89_IGTK_IPN_1) |
 608			     u64_encode_bits(igtk_ipn[2], RTW89_IGTK_IPN_2) |
 609			     u64_encode_bits(igtk_ipn[3], RTW89_IGTK_IPN_3) |
 610			     u64_encode_bits(igtk_ipn[4], RTW89_IGTK_IPN_4) |
 611			     u64_encode_bits(igtk_ipn[5], RTW89_IGTK_IPN_5) |
 612			     u64_encode_bits(igtk_ipn[6], RTW89_IGTK_IPN_6) |
 613			     u64_encode_bits(igtk_ipn[7], RTW89_IGTK_IPN_7);
 614
 615	return 0;
 616}
 617
 618static int rtw89_wow_get_aoac_rpt(struct rtw89_dev *rtwdev, bool rx_ready)
 619{
 620	struct rtw89_wow_param *rtw_wow = &rtwdev->wow;
 621	int ret;
 622
 623	if (!rtw_wow->ptk_alg)
 624		return -EPERM;
 625
 626	if (!rx_ready) {
 627		ret = rtw89_wow_get_aoac_rpt_reg(rtwdev);
 628		if (ret) {
 629			rtw89_err(rtwdev, "wow: failed to get aoac rpt by reg\n");
 630			return ret;
 631		}
 632	} else {
 633		ret = rtw89_fw_h2c_wow_request_aoac(rtwdev);
 634		if (ret) {
 635			rtw89_err(rtwdev, "wow: failed to get aoac rpt by pkt\n");
 636			return ret;
 637		}
 638	}
 639
 640	rtw89_wow_debug_aoac_rpt(rtwdev);
 641
 642	return 0;
 643}
 644
 645static struct ieee80211_key_conf *rtw89_wow_gtk_rekey(struct rtw89_dev *rtwdev,
 646						      u32 cipher, u8 keyidx, u8 *gtk)
 647{
 648	struct rtw89_vif_link *rtwvif_link = rtwdev->wow.rtwvif_link;
 649	struct ieee80211_vif *wow_vif = rtwvif_link_to_vif(rtwvif_link);
 650	const struct rtw89_cipher_info *cipher_info;
 651	struct ieee80211_key_conf *rekey_conf;
 652	struct ieee80211_key_conf *key;
 653	u8 sz;
 654
 655	lockdep_assert_wiphy(rtwdev->hw->wiphy);
 656
 657	cipher_info = rtw89_cipher_alg_recognize(cipher);
 658	sz = struct_size(rekey_conf, key, cipher_info->len);
 659	rekey_conf = kmalloc(sz, GFP_KERNEL);
 660	if (!rekey_conf)
 661		return NULL;
 662
 663	rekey_conf->cipher = cipher;
 664	rekey_conf->keyidx = keyidx;
 665	rekey_conf->keylen = cipher_info->len;
 666	memcpy(rekey_conf->key, gtk,
 667	       flex_array_size(rekey_conf, key, cipher_info->len));
 668
 669	if (ieee80211_vif_is_mld(wow_vif))
 670		key = ieee80211_gtk_rekey_add(wow_vif, keyidx, gtk,
 671					      cipher_info->len,
 672					      rtwvif_link->link_id);
 673	else
 674		key = ieee80211_gtk_rekey_add(wow_vif, keyidx, gtk,
 675					      cipher_info->len, -1);
 676
 677	kfree(rekey_conf);
 678	if (IS_ERR(key)) {
 679		rtw89_err(rtwdev, "ieee80211_gtk_rekey_add failed\n");
 680		return NULL;
 681	}
 682
 683	return key;
 684}
 685
 686static void rtw89_wow_update_key_info(struct rtw89_dev *rtwdev, bool rx_ready)
 687{
 688	struct rtw89_vif_link *rtwvif_link = rtwdev->wow.rtwvif_link;
 689	struct ieee80211_vif *wow_vif = rtwvif_link_to_vif(rtwvif_link);
 690	struct rtw89_wow_param *rtw_wow = &rtwdev->wow;
 691	struct rtw89_wow_aoac_report *aoac_rpt = &rtw_wow->aoac_rpt;
 692	struct rtw89_set_key_info_iter_data data = {.error = false,
 693						    .rx_ready = rx_ready,
 694						    .tkip_gtk_swapped = false};
 695	struct ieee80211_bss_conf *bss_conf;
 696	struct ieee80211_key_conf *key;
 697
 698	rcu_read_lock();
 699	ieee80211_iter_keys_rcu(rtwdev->hw, wow_vif,
 700				rtw89_wow_set_key_info_iter, &data);
 701	rcu_read_unlock();
 702
 703	if (data.error) {
 704		rtw89_debug(rtwdev, RTW89_DBG_WOW, "%s error\n", __func__);
 705		return;
 706	}
 707
 708	if (!data.gtk_cipher)
 709		return;
 710
 711	key = rtw89_wow_gtk_rekey(rtwdev, data.gtk_cipher, aoac_rpt->key_idx,
 712				  aoac_rpt->gtk);
 713	if (!key)
 714		return;
 715
 716	rtw89_rx_iv_to_pn(rtwdev, key,
 717			  aoac_rpt->gtk_rx_iv[key->keyidx]);
 718
 719	if (!data.igtk_cipher)
 720		return;
 721
 722	key = rtw89_wow_gtk_rekey(rtwdev, data.igtk_cipher, aoac_rpt->igtk_key_id,
 723				  aoac_rpt->igtk);
 724	if (!key)
 725		return;
 726
 727	rtw89_rx_pn_set_pmf(rtwdev, key, aoac_rpt->igtk_ipn);
 728
 729	rcu_read_lock();
 730
 731	bss_conf = rtw89_vif_rcu_dereference_link(rtwvif_link, true);
 732	ieee80211_gtk_rekey_notify(wow_vif, bss_conf->bssid,
 733				   aoac_rpt->eapol_key_replay_count,
 734				   GFP_ATOMIC);
 735
 736	rcu_read_unlock();
 737}
 738
 739static void rtw89_wow_leave_deep_ps(struct rtw89_dev *rtwdev)
 740{
 741	__rtw89_leave_ps_mode(rtwdev);
 742}
 743
 744static void rtw89_wow_enter_deep_ps(struct rtw89_dev *rtwdev)
 745{
 746	__rtw89_enter_ps_mode(rtwdev);
 747}
 748
 749static void rtw89_wow_enter_ps(struct rtw89_dev *rtwdev)
 750{
 751	struct rtw89_vif_link *rtwvif_link = rtwdev->wow.rtwvif_link;
 752
 753	if (rtw89_wow_mgd_linked(rtwdev))
 754		rtw89_enter_lps(rtwdev, rtwvif_link->rtwvif, false);
 755	else if (rtw89_wow_no_link(rtwdev))
 756		rtw89_fw_h2c_fwips(rtwdev, rtwvif_link, true);
 757}
 758
 759static void rtw89_wow_leave_ps(struct rtw89_dev *rtwdev, bool enable_wow)
 760{
 761	struct rtw89_vif_link *rtwvif_link = rtwdev->wow.rtwvif_link;
 762
 763	if (rtw89_wow_mgd_linked(rtwdev)) {
 764		rtw89_leave_lps(rtwdev);
 765	} else if (rtw89_wow_no_link(rtwdev)) {
 766		if (enable_wow)
 767			rtw89_leave_ips(rtwdev);
 768		else
 769			rtw89_fw_h2c_fwips(rtwdev, rtwvif_link, false);
 770	}
 771}
 772
 773static int rtw89_wow_config_mac(struct rtw89_dev *rtwdev, bool enable_wow)
 774{
 775	const struct rtw89_mac_gen_def *mac = rtwdev->chip->mac_def;
 776
 777	return mac->wow_config_mac(rtwdev, enable_wow);
 778}
 779
 780static void rtw89_wow_set_rx_filter(struct rtw89_dev *rtwdev, bool enable)
 781{
 782	const struct rtw89_mac_gen_def *mac = rtwdev->chip->mac_def;
 783	enum rtw89_mac_fwd_target fwd_target = enable ?
 784					       RTW89_FWD_DONT_CARE :
 785					       RTW89_FWD_TO_HOST;
 786
 787	mac->typ_fltr_opt(rtwdev, RTW89_MGNT, fwd_target, RTW89_MAC_0);
 788	mac->typ_fltr_opt(rtwdev, RTW89_CTRL, fwd_target, RTW89_MAC_0);
 789	mac->typ_fltr_opt(rtwdev, RTW89_DATA, fwd_target, RTW89_MAC_0);
 790}
 791
 792static void rtw89_wow_show_wakeup_reason(struct rtw89_dev *rtwdev)
 793{
 794	struct rtw89_vif_link *rtwvif_link = rtwdev->wow.rtwvif_link;
 795	struct ieee80211_vif *wow_vif = rtwvif_link_to_vif(rtwvif_link);
 796	struct rtw89_wow_param *rtw_wow = &rtwdev->wow;
 797	struct rtw89_wow_aoac_report *aoac_rpt = &rtw_wow->aoac_rpt;
 798	struct cfg80211_wowlan_nd_info nd_info;
 799	struct cfg80211_wowlan_wakeup wakeup = {
 800		.pattern_idx = -1,
 801	};
 802	u32 wow_reason_reg;
 803	u8 reason;
 804
 805	if (RTW89_CHK_FW_FEATURE(WOW_REASON_V1, &rtwdev->fw))
 806		wow_reason_reg = rtwdev->chip->wow_reason_reg[RTW89_WOW_REASON_V1];
 807	else
 808		wow_reason_reg = rtwdev->chip->wow_reason_reg[RTW89_WOW_REASON_V0];
 809
 810	reason = rtw89_read8(rtwdev, wow_reason_reg);
 811	switch (reason) {
 812	case RTW89_WOW_RSN_RX_DISASSOC:
 813		wakeup.disconnect = true;
 814		rtw89_debug(rtwdev, RTW89_DBG_WOW, "WOW: Rx disassoc\n");
 815		break;
 816	case RTW89_WOW_RSN_RX_DEAUTH:
 817		wakeup.disconnect = true;
 818		rtw89_debug(rtwdev, RTW89_DBG_WOW, "WOW: Rx deauth\n");
 819		break;
 820	case RTW89_WOW_RSN_DISCONNECT:
 821		wakeup.disconnect = true;
 822		rtw89_debug(rtwdev, RTW89_DBG_WOW, "WOW: AP is off\n");
 823		break;
 824	case RTW89_WOW_RSN_RX_MAGIC_PKT:
 825		wakeup.magic_pkt = true;
 826		rtw89_debug(rtwdev, RTW89_DBG_WOW, "WOW: Rx magic packet\n");
 827		break;
 828	case RTW89_WOW_RSN_RX_GTK_REKEY:
 829		wakeup.gtk_rekey_failure = true;
 830		rtw89_debug(rtwdev, RTW89_DBG_WOW, "WOW: Rx gtk rekey\n");
 831		break;
 832	case RTW89_WOW_RSN_RX_PATTERN_MATCH:
 833		wakeup.pattern_idx = aoac_rpt->pattern_idx;
 834		rtw89_debug(rtwdev, RTW89_DBG_WOW, "WOW: Rx pattern match packet\n");
 835		break;
 836	case RTW89_WOW_RSN_RX_NLO:
 837		/* Current firmware and driver don't report ssid index.
 838		 * Use 0 for n_matches based on its comment.
 839		 */
 840		nd_info.n_matches = 0;
 841		wakeup.net_detect = &nd_info;
 842		rtw89_debug(rtwdev, RTW89_DBG_WOW, "Rx NLO\n");
 843		break;
 844	default:
 845		rtw89_warn(rtwdev, "Unknown wakeup reason %x\n", reason);
 846		ieee80211_report_wowlan_wakeup(wow_vif, NULL, GFP_KERNEL);
 847		return;
 848	}
 849
 850	ieee80211_report_wowlan_wakeup(wow_vif, &wakeup, GFP_KERNEL);
 851}
 852
 853static void rtw89_wow_vif_iter(struct rtw89_dev *rtwdev,
 854			       struct rtw89_vif_link *rtwvif_link)
 855{
 856	struct rtw89_wow_param *rtw_wow = &rtwdev->wow;
 857	struct ieee80211_vif *vif = rtwvif_link_to_vif(rtwvif_link);
 858
 859	/* Current WoWLAN function support setting of only vif in
 860	 * infra mode or no link mode. When one suitable vif is found,
 861	 * stop the iteration.
 862	 */
 863	if (rtw_wow->rtwvif_link || vif->type != NL80211_IFTYPE_STATION)
 864		return;
 865
 866	switch (rtwvif_link->net_type) {
 867	case RTW89_NET_TYPE_INFRA:
 868		if (rtw_wow_has_mgd_features(rtwdev))
 869			rtw_wow->rtwvif_link = rtwvif_link;
 870		break;
 871	case RTW89_NET_TYPE_NO_LINK:
 872		if (rtw_wow->pno_inited)
 873			rtw_wow->rtwvif_link = rtwvif_link;
 874		break;
 875	default:
 876		break;
 877	}
 878}
 879
 880static u16 __rtw89_cal_crc16(u8 data, u16 crc)
 881{
 882	u8 shift_in, data_bit;
 883	u8 crc_bit4, crc_bit11, crc_bit15;
 884	u16 crc_result;
 885	int index;
 886
 887	for (index = 0; index < 8; index++) {
 888		crc_bit15 = crc & BIT(15) ? 1 : 0;
 889		data_bit = data & BIT(index) ? 1 : 0;
 890		shift_in = crc_bit15 ^ data_bit;
 891
 892		crc_result = crc << 1;
 893
 894		if (shift_in == 0)
 895			crc_result &= ~BIT(0);
 896		else
 897			crc_result |= BIT(0);
 898
 899		crc_bit11 = (crc & BIT(11) ? 1 : 0) ^ shift_in;
 900
 901		if (crc_bit11 == 0)
 902			crc_result &= ~BIT(12);
 903		else
 904			crc_result |= BIT(12);
 905
 906		crc_bit4 = (crc & BIT(4) ? 1 : 0) ^ shift_in;
 907
 908		if (crc_bit4 == 0)
 909			crc_result &= ~BIT(5);
 910		else
 911			crc_result |= BIT(5);
 912
 913		crc = crc_result;
 914	}
 915	return crc;
 916}
 917
 918static u16 rtw89_calc_crc(u8 *pdata, int length)
 919{
 920	u16 crc = 0xffff;
 921	int i;
 922
 923	for (i = 0; i < length; i++)
 924		crc = __rtw89_cal_crc16(pdata[i], crc);
 925
 926	/* get 1' complement */
 927	return ~crc;
 928}
 929
 930static int rtw89_wow_pattern_get_type(struct rtw89_vif_link *rtwvif_link,
 931				      struct rtw89_wow_cam_info *rtw_pattern,
 932				      const u8 *pattern, u8 da_mask)
 933{
 934	u8 da[ETH_ALEN];
 935
 936	ether_addr_copy_mask(da, pattern, da_mask);
 937
 938	/* Each pattern is divided into different kinds by DA address
 939	 *  a. DA is broadcast address: set bc = 0;
 940	 *  b. DA is multicast address: set mc = 0
 941	 *  c. DA is unicast address same as dev's mac address: set uc = 0
 942	 *  d. DA is unmasked. Also called wildcard type: set uc = bc = mc = 0
 943	 *  e. Others is invalid type.
 944	 */
 945
 946	if (is_broadcast_ether_addr(da))
 947		rtw_pattern->bc = true;
 948	else if (is_multicast_ether_addr(da))
 949		rtw_pattern->mc = true;
 950	else if (ether_addr_equal(da, rtwvif_link->mac_addr) &&
 951		 da_mask == GENMASK(5, 0))
 952		rtw_pattern->uc = true;
 953	else if (!da_mask) /*da_mask == 0 mean wildcard*/
 954		return 0;
 955	else
 956		return -EPERM;
 957
 958	return 0;
 959}
 960
 961static int rtw89_wow_pattern_generate(struct rtw89_dev *rtwdev,
 962				      struct rtw89_vif_link *rtwvif_link,
 963				      const struct cfg80211_pkt_pattern *pkt_pattern,
 964				      struct rtw89_wow_cam_info *rtw_pattern)
 965{
 966	u8 mask_hw[RTW89_MAX_PATTERN_MASK_SIZE * 4] = {0};
 967	u8 content[RTW89_MAX_PATTERN_SIZE] = {0};
 968	const u8 *mask;
 969	const u8 *pattern;
 970	u8 mask_len;
 971	u16 count;
 972	u32 len;
 973	int i, ret;
 974
 975	pattern = pkt_pattern->pattern;
 976	len = pkt_pattern->pattern_len;
 977	mask = pkt_pattern->mask;
 978	mask_len = DIV_ROUND_UP(len, 8);
 979	memset(rtw_pattern, 0, sizeof(*rtw_pattern));
 980
 981	ret = rtw89_wow_pattern_get_type(rtwvif_link, rtw_pattern, pattern,
 982					 mask[0] & GENMASK(5, 0));
 983	if (ret)
 984		return ret;
 985
 986	/* translate mask from os to mask for hw
 987	 * pattern from OS uses 'ethenet frame', like this:
 988	 * |    6   |    6   |   2  |     20    |  Variable  |  4  |
 989	 * |--------+--------+------+-----------+------------+-----|
 990	 * |    802.3 Mac Header    | IP Header | TCP Packet | FCS |
 991	 * |   DA   |   SA   | Type |
 992	 *
 993	 * BUT, packet catched by our HW is in '802.11 frame', begin from LLC
 994	 * |     24 or 30      |    6   |   2  |     20    |  Variable  |  4  |
 995	 * |-------------------+--------+------+-----------+------------+-----|
 996	 * | 802.11 MAC Header |       LLC     | IP Header | TCP Packet | FCS |
 997	 *		       | Others | Tpye |
 998	 *
 999	 * Therefore, we need translate mask_from_OS to mask_to_hw.
1000	 * We should left-shift mask by 6 bits, then set the new bit[0~5] = 0,
1001	 * because new mask[0~5] means 'SA', but our HW packet begins from LLC,
1002	 * bit[0~5] corresponds to first 6 Bytes in LLC, they just don't match.
1003	 */
1004
1005	/* Shift 6 bits */
1006	for (i = 0; i < mask_len - 1; i++) {
1007		mask_hw[i] = u8_get_bits(mask[i], GENMASK(7, 6)) |
1008			     u8_get_bits(mask[i + 1], GENMASK(5, 0)) << 2;
1009	}
1010	mask_hw[i] = u8_get_bits(mask[i], GENMASK(7, 6));
1011
1012	/* Set bit 0-5 to zero */
1013	mask_hw[0] &= ~GENMASK(5, 0);
1014
1015	memcpy(rtw_pattern->mask, mask_hw, sizeof(rtw_pattern->mask));
1016
1017	/* To get the wake up pattern from the mask.
1018	 * We do not count first 12 bits which means
1019	 * DA[6] and SA[6] in the pattern to match HW design.
1020	 */
1021	count = 0;
1022	for (i = 12; i < len; i++) {
1023		if ((mask[i / 8] >> (i % 8)) & 0x01) {
1024			content[count] = pattern[i];
1025			count++;
1026		}
1027	}
1028
1029	rtw_pattern->crc = rtw89_calc_crc(content, count);
1030
1031	return 0;
1032}
1033
1034static int rtw89_wow_parse_patterns(struct rtw89_dev *rtwdev,
1035				    struct rtw89_vif_link *rtwvif_link,
1036				    struct cfg80211_wowlan *wowlan)
1037{
1038	struct rtw89_wow_param *rtw_wow = &rtwdev->wow;
1039	struct rtw89_wow_cam_info *rtw_pattern = rtw_wow->patterns;
1040	int i;
1041	int ret;
1042
1043	if (!wowlan->n_patterns || !wowlan->patterns)
1044		return 0;
1045
1046	for (i = 0; i < wowlan->n_patterns; i++) {
1047		rtw_pattern = &rtw_wow->patterns[i];
1048		ret = rtw89_wow_pattern_generate(rtwdev, rtwvif_link,
1049						 &wowlan->patterns[i],
1050						 rtw_pattern);
1051		if (ret) {
1052			rtw89_err(rtwdev, "failed to generate pattern(%d)\n", i);
1053			rtw_wow->pattern_cnt = 0;
1054			return ret;
1055		}
1056
1057		rtw_pattern->r_w = true;
1058		rtw_pattern->idx = i;
1059		rtw_pattern->negative_pattern_match = false;
1060		rtw_pattern->skip_mac_hdr = true;
1061		rtw_pattern->valid = true;
1062	}
1063	rtw_wow->pattern_cnt = wowlan->n_patterns;
1064
1065	return 0;
1066}
1067
1068static void rtw89_wow_pattern_clear_cam(struct rtw89_dev *rtwdev)
1069{
1070	struct rtw89_wow_param *rtw_wow = &rtwdev->wow;
1071	struct rtw89_wow_cam_info *rtw_pattern = rtw_wow->patterns;
1072	int i = 0;
1073
1074	for (i = 0; i < rtw_wow->pattern_cnt; i++) {
1075		rtw_pattern = &rtw_wow->patterns[i];
1076		rtw_pattern->valid = false;
1077		rtw89_fw_wow_cam_update(rtwdev, rtw_pattern);
1078	}
1079}
1080
1081static void rtw89_wow_pattern_write(struct rtw89_dev *rtwdev)
1082{
1083	struct rtw89_wow_param *rtw_wow = &rtwdev->wow;
1084	struct rtw89_wow_cam_info *rtw_pattern = rtw_wow->patterns;
1085	int i;
1086
1087	for (i = 0; i < rtw_wow->pattern_cnt; i++)
1088		rtw89_fw_wow_cam_update(rtwdev, rtw_pattern + i);
1089}
1090
1091static void rtw89_wow_pattern_clear(struct rtw89_dev *rtwdev)
1092{
1093	struct rtw89_wow_param *rtw_wow = &rtwdev->wow;
1094
1095	rtw89_wow_pattern_clear_cam(rtwdev);
1096
1097	rtw_wow->pattern_cnt = 0;
1098	memset(rtw_wow->patterns, 0, sizeof(rtw_wow->patterns));
1099}
1100
1101static void rtw89_wow_clear_wakeups(struct rtw89_dev *rtwdev)
1102{
1103	struct rtw89_wow_param *rtw_wow = &rtwdev->wow;
1104
1105	rtw_wow->rtwvif_link = NULL;
1106	rtw89_core_release_all_bits_map(rtw_wow->flags, RTW89_WOW_FLAG_NUM);
1107	rtw_wow->pattern_cnt = 0;
1108	rtw_wow->pno_inited = false;
1109}
1110
1111static void rtw89_wow_init_pno(struct rtw89_dev *rtwdev,
1112			       struct cfg80211_sched_scan_request *nd_config)
1113{
1114	struct rtw89_wow_param *rtw_wow = &rtwdev->wow;
1115
1116	if (!nd_config->n_match_sets || !nd_config->n_channels)
1117		return;
1118
1119	rtw_wow->nd_config = nd_config;
1120	rtw_wow->pno_inited = true;
1121
1122	INIT_LIST_HEAD(&rtw_wow->pno_pkt_list);
1123
1124	rtw89_debug(rtwdev, RTW89_DBG_WOW, "WOW: net-detect is enabled\n");
1125}
1126
1127static int rtw89_wow_set_wakeups(struct rtw89_dev *rtwdev,
1128				 struct cfg80211_wowlan *wowlan)
1129{
1130	struct rtw89_wow_param *rtw_wow = &rtwdev->wow;
1131	struct rtw89_vif_link *rtwvif_link;
1132	struct rtw89_vif *rtwvif;
1133
1134	if (wowlan->disconnect)
1135		set_bit(RTW89_WOW_FLAG_EN_DISCONNECT, rtw_wow->flags);
1136	if (wowlan->magic_pkt)
1137		set_bit(RTW89_WOW_FLAG_EN_MAGIC_PKT, rtw_wow->flags);
1138	if (wowlan->n_patterns && wowlan->patterns)
1139		set_bit(RTW89_WOW_FLAG_EN_PATTERN, rtw_wow->flags);
1140
1141	if (wowlan->nd_config)
1142		rtw89_wow_init_pno(rtwdev, wowlan->nd_config);
1143
1144	rtw89_for_each_rtwvif(rtwdev, rtwvif) {
1145		rtwvif_link = rtw89_get_designated_link(rtwvif);
1146		if (!rtwvif_link)
1147			continue;
1148
1149		rtw89_wow_vif_iter(rtwdev, rtwvif_link);
1150	}
1151
1152	rtwvif_link = rtw_wow->rtwvif_link;
1153	if (!rtwvif_link)
1154		return -EPERM;
1155
1156	return rtw89_wow_parse_patterns(rtwdev, rtwvif_link, wowlan);
1157}
1158
1159static int rtw89_wow_cfg_wake_pno(struct rtw89_dev *rtwdev, bool wow)
1160{
1161	struct rtw89_vif_link *rtwvif_link = rtwdev->wow.rtwvif_link;
1162	int ret;
1163
1164	ret = rtw89_fw_h2c_cfg_pno(rtwdev, rtwvif_link, true);
1165	if (ret) {
1166		rtw89_err(rtwdev, "failed to config pno\n");
1167		return ret;
1168	}
1169
1170	ret = rtw89_fw_h2c_wow_wakeup_ctrl(rtwdev, rtwvif_link, wow);
1171	if (ret) {
1172		rtw89_err(rtwdev, "failed to fw wow wakeup ctrl\n");
1173		return ret;
1174	}
1175
1176	ret = rtw89_fw_h2c_wow_global(rtwdev, rtwvif_link, wow);
1177	if (ret) {
1178		rtw89_err(rtwdev, "failed to fw wow global\n");
1179		return ret;
1180	}
1181
1182	return 0;
1183}
1184
1185static int rtw89_wow_cfg_wake(struct rtw89_dev *rtwdev, bool wow)
1186{
1187	struct rtw89_wow_param *rtw_wow = &rtwdev->wow;
1188	struct rtw89_vif_link *rtwvif_link = rtw_wow->rtwvif_link;
1189	struct ieee80211_vif *wow_vif = rtwvif_link_to_vif(rtwvif_link);
1190	struct ieee80211_sta *wow_sta;
1191	struct rtw89_sta_link *rtwsta_link = NULL;
1192	struct rtw89_sta *rtwsta;
1193	int ret;
1194
1195	wow_sta = ieee80211_find_sta(wow_vif, wow_vif->cfg.ap_addr);
1196	if (wow_sta) {
1197		rtwsta = sta_to_rtwsta(wow_sta);
1198		rtwsta_link = rtwsta->links[rtwvif_link->link_id];
1199		if (!rtwsta_link)
1200			return -ENOLINK;
1201	}
1202
1203	if (wow) {
1204		if (rtw_wow->pattern_cnt)
1205			rtwvif_link->wowlan_pattern = true;
1206		if (test_bit(RTW89_WOW_FLAG_EN_MAGIC_PKT, rtw_wow->flags))
1207			rtwvif_link->wowlan_magic = true;
1208	} else {
1209		rtwvif_link->wowlan_pattern = false;
1210		rtwvif_link->wowlan_magic = false;
1211	}
1212
1213	ret = rtw89_fw_h2c_wow_wakeup_ctrl(rtwdev, rtwvif_link, wow);
1214	if (ret) {
1215		rtw89_err(rtwdev, "failed to fw wow wakeup ctrl\n");
1216		return ret;
1217	}
1218
1219	if (wow) {
1220		ret = rtw89_chip_h2c_dctl_sec_cam(rtwdev, rtwvif_link, rtwsta_link);
1221		if (ret) {
1222			rtw89_err(rtwdev, "failed to update dctl cam sec entry: %d\n",
1223				  ret);
1224			return ret;
1225		}
1226	}
1227
1228	ret = rtw89_fw_h2c_cam(rtwdev, rtwvif_link, rtwsta_link, NULL,
1229			       RTW89_ROLE_INFO_CHANGE);
1230	if (ret) {
1231		rtw89_warn(rtwdev, "failed to send h2c cam\n");
1232		return ret;
1233	}
1234
1235	ret = rtw89_fw_h2c_wow_global(rtwdev, rtwvif_link, wow);
1236	if (ret) {
1237		rtw89_err(rtwdev, "failed to fw wow global\n");
1238		return ret;
1239	}
1240
1241	return 0;
1242}
1243
1244static int rtw89_wow_check_fw_status(struct rtw89_dev *rtwdev, bool wow_enable)
1245{
1246	const struct rtw89_mac_gen_def *mac = rtwdev->chip->mac_def;
1247	u8 polling;
1248	int ret;
1249
1250	ret = read_poll_timeout_atomic(rtw89_read8_mask, polling,
1251				       wow_enable == !!polling,
1252				       50, 50000, false, rtwdev,
1253				       mac->wow_ctrl.addr, mac->wow_ctrl.mask);
1254	if (ret)
1255		rtw89_err(rtwdev, "failed to check wow status %s\n",
1256			  str_enabled_disabled(wow_enable));
1257	return ret;
1258}
1259
1260static int rtw89_wow_swap_fw(struct rtw89_dev *rtwdev, bool wow)
1261{
1262	enum rtw89_fw_type fw_type = wow ? RTW89_FW_WOWLAN : RTW89_FW_NORMAL;
1263	enum rtw89_chip_gen chip_gen = rtwdev->chip->chip_gen;
1264	struct rtw89_wow_param *rtw_wow = &rtwdev->wow;
1265	struct rtw89_vif_link *rtwvif_link = rtw_wow->rtwvif_link;
1266	struct ieee80211_vif *wow_vif = rtwvif_link_to_vif(rtwvif_link);
1267	enum rtw89_core_chip_id chip_id = rtwdev->chip->chip_id;
1268	const struct rtw89_chip_info *chip = rtwdev->chip;
1269	bool include_bb = !!chip->bbmcu_nr;
1270	bool disable_intr_for_dlfw = false;
1271	struct ieee80211_sta *wow_sta;
1272	struct rtw89_sta_link *rtwsta_link = NULL;
1273	struct rtw89_sta *rtwsta;
1274	bool is_conn = true;
1275	int ret;
1276
1277	if (chip_id == RTL8852C || chip_id == RTL8922A)
1278		disable_intr_for_dlfw = true;
1279
1280	wow_sta = ieee80211_find_sta(wow_vif, wow_vif->cfg.ap_addr);
1281	if (wow_sta) {
1282		rtwsta = sta_to_rtwsta(wow_sta);
1283		rtwsta_link = rtwsta->links[rtwvif_link->link_id];
1284		if (!rtwsta_link)
1285			return -ENOLINK;
1286	} else {
1287		is_conn = false;
1288	}
1289
1290	if (disable_intr_for_dlfw)
1291		rtw89_hci_disable_intr(rtwdev);
1292
1293	ret = rtw89_fw_download(rtwdev, fw_type, include_bb);
1294	if (ret) {
1295		rtw89_warn(rtwdev, "download fw failed\n");
1296		return ret;
1297	}
1298
1299	if (disable_intr_for_dlfw)
1300		rtw89_hci_enable_intr(rtwdev);
1301
1302	rtw89_phy_init_rf_reg(rtwdev, true);
1303
1304	ret = rtw89_fw_h2c_role_maintain(rtwdev, rtwvif_link, rtwsta_link,
1305					 RTW89_ROLE_FW_RESTORE);
1306	if (ret) {
1307		rtw89_warn(rtwdev, "failed to send h2c role maintain\n");
1308		return ret;
1309	}
1310
1311	ret = rtw89_chip_h2c_assoc_cmac_tbl(rtwdev, rtwvif_link, rtwsta_link);
1312	if (ret) {
1313		rtw89_warn(rtwdev, "failed to send h2c assoc cmac tbl\n");
1314		return ret;
1315	}
1316
1317	if (!is_conn)
1318		rtw89_cam_reset_keys(rtwdev);
1319
1320	ret = rtw89_fw_h2c_join_info(rtwdev, rtwvif_link, rtwsta_link, !is_conn);
1321	if (ret) {
1322		rtw89_warn(rtwdev, "failed to send h2c join info\n");
1323		return ret;
1324	}
1325
1326	ret = rtw89_fw_h2c_cam(rtwdev, rtwvif_link, rtwsta_link, NULL,
1327			       RTW89_ROLE_FW_RESTORE);
1328	if (ret) {
1329		rtw89_warn(rtwdev, "failed to send h2c cam\n");
1330		return ret;
1331	}
1332
1333	if (is_conn) {
1334		ret = rtw89_fw_h2c_general_pkt(rtwdev, rtwvif_link, rtwsta_link->mac_id);
1335		if (ret) {
1336			rtw89_warn(rtwdev, "failed to send h2c general packet\n");
1337			return ret;
1338		}
1339		rtw89_phy_ra_assoc(rtwdev, rtwsta_link);
1340		rtw89_phy_set_bss_color(rtwdev, rtwvif_link);
1341		rtw89_chip_cfg_txpwr_ul_tb_offset(rtwdev, rtwvif_link);
1342	}
1343
1344	if (chip_gen == RTW89_CHIP_BE)
1345		rtw89_phy_rfk_pre_ntfy_and_wait(rtwdev, RTW89_PHY_0, 5);
1346
1347	rtw89_mac_hw_mgnt_sec(rtwdev, wow);
1348
1349	return 0;
1350}
1351
1352static int rtw89_wow_enable_trx_pre(struct rtw89_dev *rtwdev)
1353{
1354	int ret;
1355
1356	rtw89_hci_ctrl_txdma_ch(rtwdev, false);
1357	rtw89_hci_ctrl_txdma_fw_ch(rtwdev, true);
1358
1359	rtw89_mac_ptk_drop_by_band_and_wait(rtwdev, RTW89_MAC_0);
1360
1361	ret = rtw89_hci_poll_txdma_ch_idle(rtwdev);
1362	if (ret) {
1363		rtw89_err(rtwdev, "txdma ch busy\n");
1364		return ret;
1365	}
1366	rtw89_wow_set_rx_filter(rtwdev, true);
1367
1368	ret = rtw89_mac_cfg_ppdu_status(rtwdev, RTW89_MAC_0, false);
1369	if (ret) {
1370		rtw89_err(rtwdev, "cfg ppdu status\n");
1371		return ret;
1372	}
1373
1374	return 0;
1375}
1376
1377static int rtw89_wow_enable_trx_post(struct rtw89_dev *rtwdev)
1378{
1379	int ret;
1380
1381	rtw89_hci_disable_intr(rtwdev);
1382	rtw89_hci_ctrl_trxhci(rtwdev, false);
1383
1384	ret = rtw89_hci_poll_txdma_ch_idle(rtwdev);
1385	if (ret) {
1386		rtw89_err(rtwdev, "failed to poll txdma ch idle pcie\n");
1387		return ret;
1388	}
1389
1390	ret = rtw89_wow_config_mac(rtwdev, true);
1391	if (ret) {
1392		rtw89_err(rtwdev, "failed to config mac\n");
1393		return ret;
1394	}
1395
1396	rtw89_wow_set_rx_filter(rtwdev, false);
1397	rtw89_hci_reset(rtwdev);
1398
1399	return 0;
1400}
1401
1402static int rtw89_wow_disable_trx_pre(struct rtw89_dev *rtwdev)
1403{
1404	int ret;
1405
1406	rtw89_hci_clr_idx_all(rtwdev);
1407
1408	ret = rtw89_hci_rst_bdram(rtwdev);
1409	if (ret) {
1410		rtw89_warn(rtwdev, "reset bdram busy\n");
1411		return ret;
1412	}
1413
1414	rtw89_hci_ctrl_trxhci(rtwdev, true);
1415	rtw89_hci_ctrl_txdma_ch(rtwdev, true);
1416
1417	ret = rtw89_wow_config_mac(rtwdev, false);
1418	if (ret) {
1419		rtw89_err(rtwdev, "failed to config mac\n");
1420		return ret;
1421	}
1422
1423	/* Before enabling interrupt, we need to get AOAC report by reg due to RX
1424	 * not enabled yet. Also, we need to sync RX related IV from firmware to
1425	 * mac80211 before receiving RX packets from driver.
1426	 * After enabling interrupt, we can get AOAC report from h2c and c2h, and
1427	 * can get TX IV and complete rekey info. We need to update TX related IV
1428	 * and new GTK info if rekey happened.
1429	 */
1430	ret = rtw89_wow_get_aoac_rpt(rtwdev, false);
1431	if (!ret)
1432		rtw89_wow_update_key_info(rtwdev, false);
1433
1434	rtw89_hci_enable_intr(rtwdev);
1435	ret = rtw89_wow_get_aoac_rpt(rtwdev, true);
1436	if (!ret)
1437		rtw89_wow_update_key_info(rtwdev, true);
1438
1439	return 0;
1440}
1441
1442static int rtw89_wow_disable_trx_post(struct rtw89_dev *rtwdev)
1443{
1444	struct rtw89_vif_link *rtwvif_link = rtwdev->wow.rtwvif_link;
1445	int ret;
1446
1447	ret = rtw89_mac_cfg_ppdu_status(rtwdev, RTW89_MAC_0, true);
1448	if (ret)
1449		rtw89_err(rtwdev, "cfg ppdu status\n");
1450
1451	rtw89_fw_h2c_set_bcn_fltr_cfg(rtwdev, rtwvif_link, true);
1452
1453	return ret;
1454}
1455
1456static void rtw89_fw_release_pno_pkt_list(struct rtw89_dev *rtwdev,
1457					  struct rtw89_vif_link *rtwvif_link)
1458{
1459	struct rtw89_wow_param *rtw_wow = &rtwdev->wow;
1460	struct list_head *pkt_list = &rtw_wow->pno_pkt_list;
1461	struct rtw89_pktofld_info *info, *tmp;
1462
1463	list_for_each_entry_safe(info, tmp, pkt_list, list) {
1464		rtw89_fw_h2c_del_pkt_offload(rtwdev, info->id);
1465		list_del(&info->list);
1466		kfree(info);
1467	}
1468}
1469
1470static int rtw89_pno_scan_update_probe_req(struct rtw89_dev *rtwdev,
1471					   struct rtw89_vif_link *rtwvif_link)
1472{
1473	static const u8 basic_rate_ie[] = {WLAN_EID_SUPP_RATES, 0x08,
1474		 0x0c, 0x12, 0x18, 0x24, 0x30, 0x48, 0x60, 0x6c};
1475	struct rtw89_wow_param *rtw_wow = &rtwdev->wow;
1476	struct cfg80211_sched_scan_request *nd_config = rtw_wow->nd_config;
1477	u8 num = nd_config->n_match_sets, i;
1478	struct rtw89_pktofld_info *info;
1479	struct sk_buff *skb;
1480	int ret;
1481
1482	for (i = 0; i < num; i++) {
1483		skb = ieee80211_probereq_get(rtwdev->hw, rtwvif_link->mac_addr,
1484					     nd_config->match_sets[i].ssid.ssid,
1485					     nd_config->match_sets[i].ssid.ssid_len,
1486					     nd_config->ie_len + sizeof(basic_rate_ie));
1487		if (!skb)
1488			return -ENOMEM;
1489
1490		skb_put_data(skb, basic_rate_ie, sizeof(basic_rate_ie));
1491		skb_put_data(skb, nd_config->ie, nd_config->ie_len);
1492
1493		info = kzalloc(sizeof(*info), GFP_KERNEL);
1494		if (!info) {
1495			kfree_skb(skb);
1496			rtw89_fw_release_pno_pkt_list(rtwdev, rtwvif_link);
1497			return -ENOMEM;
1498		}
1499
1500		ret = rtw89_fw_h2c_add_pkt_offload(rtwdev, &info->id, skb);
1501		if (ret) {
1502			kfree_skb(skb);
1503			kfree(info);
1504			rtw89_fw_release_pno_pkt_list(rtwdev, rtwvif_link);
1505			return ret;
1506		}
1507
1508		list_add_tail(&info->list, &rtw_wow->pno_pkt_list);
1509		kfree_skb(skb);
1510	}
1511
1512	return 0;
1513}
1514
1515static int rtw89_pno_scan_offload(struct rtw89_dev *rtwdev, bool enable)
1516{
1517	const struct rtw89_mac_gen_def *mac = rtwdev->chip->mac_def;
1518	struct rtw89_wow_param *rtw_wow = &rtwdev->wow;
1519	struct rtw89_vif_link *rtwvif_link = rtwdev->wow.rtwvif_link;
1520	int interval = rtw_wow->nd_config->scan_plans[0].interval;
1521	struct rtw89_scan_option opt = {};
1522	int ret;
1523
1524	if (enable) {
1525		ret = rtw89_pno_scan_update_probe_req(rtwdev, rtwvif_link);
1526		if (ret) {
1527			rtw89_err(rtwdev, "Update probe request failed\n");
1528			return ret;
1529		}
1530
1531		ret = mac->add_chan_list_pno(rtwdev, rtwvif_link);
1532		if (ret) {
1533			rtw89_err(rtwdev, "Update channel list failed\n");
1534			return ret;
1535		}
1536	}
1537
1538	opt.enable = enable;
1539	opt.repeat = RTW89_SCAN_NORMAL;
1540	opt.norm_pd = max(interval, 1) * 10; /* in unit of 100ms */
1541	opt.delay = max(rtw_wow->nd_config->delay, 1) * 1000;
1542
1543	if (rtwdev->chip->chip_gen == RTW89_CHIP_BE) {
1544		opt.operation = enable ? RTW89_SCAN_OP_START : RTW89_SCAN_OP_STOP;
1545		opt.scan_mode = RTW89_SCAN_MODE_SA;
1546		opt.band = RTW89_PHY_0;
1547		opt.num_macc_role = 0;
1548		opt.mlo_mode = rtwdev->mlo_dbcc_mode;
1549		opt.num_opch = 0;
1550		opt.opch_end = RTW89_CHAN_INVALID;
1551	}
1552
1553	rtw89_mac_scan_offload(rtwdev, &opt, rtwvif_link, true);
1554
1555	return 0;
1556}
1557
1558static int rtw89_wow_fw_start(struct rtw89_dev *rtwdev)
1559{
1560	struct rtw89_wow_param *rtw_wow = &rtwdev->wow;
1561	struct rtw89_vif_link *rtwvif_link = rtw_wow->rtwvif_link;
1562	int ret;
1563
1564	if (rtw89_wow_no_link(rtwdev)) {
1565		ret = rtw89_pno_scan_offload(rtwdev, false);
1566		if (ret) {
1567			rtw89_err(rtwdev, "wow: failed to disable pno scan offload\n");
1568			return ret;
1569		}
1570
1571		ret = rtw89_pno_scan_offload(rtwdev, true);
1572		if (ret) {
1573			rtw89_err(rtwdev, "wow: failed to enable pno scan offload\n");
1574			return ret;
1575		}
1576	} else {
1577		rtw89_wow_pattern_write(rtwdev);
1578		rtw89_wow_construct_key_info(rtwdev);
1579
1580		ret = rtw89_fw_h2c_keep_alive(rtwdev, rtwvif_link, true);
1581		if (ret) {
1582			rtw89_err(rtwdev, "wow: failed to enable keep alive\n");
1583			return ret;
1584		}
1585
1586		ret = rtw89_fw_h2c_disconnect_detect(rtwdev, rtwvif_link, true);
1587		if (ret) {
1588			rtw89_err(rtwdev, "wow: failed to enable disconnect detect\n");
1589			return ret;
1590		}
1591
1592		ret = rtw89_fw_h2c_wow_gtk_ofld(rtwdev, rtwvif_link, true);
1593		if (ret) {
1594			rtw89_err(rtwdev, "wow: failed to enable GTK offload\n");
1595			return ret;
1596		}
1597
1598		ret = rtw89_fw_h2c_arp_offload(rtwdev, rtwvif_link, true);
1599		if (ret)
1600			rtw89_warn(rtwdev, "wow: failed to enable arp offload\n");
1601	}
1602
1603	if (rtw89_wow_no_link(rtwdev)) {
1604		ret = rtw89_wow_cfg_wake_pno(rtwdev, true);
1605		if (ret) {
1606			rtw89_err(rtwdev, "wow: failed to config wake PNO\n");
1607			return ret;
1608		}
1609	} else {
1610		ret = rtw89_wow_cfg_wake(rtwdev, true);
1611		if (ret) {
1612			rtw89_err(rtwdev, "wow: failed to config wake\n");
1613			return ret;
1614		}
1615	}
1616
1617	ret = rtw89_wow_check_fw_status(rtwdev, true);
1618	if (ret) {
1619		rtw89_err(rtwdev, "wow: failed to check enable fw ready\n");
1620		return ret;
1621	}
1622
1623	return 0;
1624}
1625
1626static int rtw89_wow_fw_stop(struct rtw89_dev *rtwdev)
1627{
1628	struct rtw89_wow_param *rtw_wow = &rtwdev->wow;
1629	struct rtw89_vif_link *rtwvif_link = rtw_wow->rtwvif_link;
1630	int ret;
1631
1632	if (rtw89_wow_no_link(rtwdev)) {
1633		ret = rtw89_pno_scan_offload(rtwdev, false);
1634		if (ret) {
1635			rtw89_err(rtwdev, "wow: failed to disable pno scan offload\n");
1636			return ret;
1637		}
1638
1639		ret = rtw89_fw_h2c_cfg_pno(rtwdev, rtwvif_link, false);
1640		if (ret) {
1641			rtw89_err(rtwdev, "wow: failed to disable pno\n");
1642			return ret;
1643		}
1644
1645		rtw89_fw_release_pno_pkt_list(rtwdev, rtwvif_link);
1646	} else {
1647		rtw89_wow_pattern_clear(rtwdev);
1648
1649		ret = rtw89_fw_h2c_keep_alive(rtwdev, rtwvif_link, false);
1650		if (ret) {
1651			rtw89_err(rtwdev, "wow: failed to disable keep alive\n");
1652			return ret;
1653		}
1654
1655		ret = rtw89_fw_h2c_disconnect_detect(rtwdev, rtwvif_link, false);
1656		if (ret) {
1657			rtw89_err(rtwdev, "wow: failed to disable disconnect detect\n");
1658			return ret;
1659		}
1660
1661		ret = rtw89_fw_h2c_wow_gtk_ofld(rtwdev, rtwvif_link, false);
1662		if (ret) {
1663			rtw89_err(rtwdev, "wow: failed to disable GTK offload\n");
1664			return ret;
1665		}
1666
1667		ret = rtw89_fw_h2c_arp_offload(rtwdev, rtwvif_link, false);
1668		if (ret)
1669			rtw89_warn(rtwdev, "wow: failed to disable arp offload\n");
1670
1671		rtw89_wow_key_clear(rtwdev);
1672		rtw89_fw_release_general_pkt_list(rtwdev, true);
1673	}
1674
1675
1676	ret = rtw89_wow_cfg_wake(rtwdev, false);
1677	if (ret) {
1678		rtw89_err(rtwdev, "wow: failed to disable config wake\n");
1679		return ret;
1680	}
1681
1682	ret = rtw89_wow_check_fw_status(rtwdev, false);
1683	if (ret) {
1684		rtw89_err(rtwdev, "wow: failed to check disable fw ready\n");
1685		return ret;
1686	}
1687
1688	return 0;
1689}
1690
1691static int rtw89_wow_enable(struct rtw89_dev *rtwdev)
1692{
1693	int ret;
1694
1695	set_bit(RTW89_FLAG_WOWLAN, rtwdev->flags);
1696
1697	ret = rtw89_wow_enable_trx_pre(rtwdev);
1698	if (ret) {
1699		rtw89_err(rtwdev, "wow: failed to enable trx_pre\n");
1700		goto out;
1701	}
1702
1703	rtw89_fw_release_general_pkt_list(rtwdev, true);
1704
1705	ret = rtw89_wow_swap_fw(rtwdev, true);
1706	if (ret) {
1707		rtw89_err(rtwdev, "wow: failed to swap to wow fw\n");
1708		goto out;
1709	}
1710
1711	ret = rtw89_wow_fw_start(rtwdev);
1712	if (ret) {
1713		rtw89_err(rtwdev, "wow: failed to let wow fw start\n");
1714		goto out;
1715	}
1716
1717	rtw89_wow_enter_ps(rtwdev);
1718
1719	ret = rtw89_wow_enable_trx_post(rtwdev);
1720	if (ret) {
1721		rtw89_err(rtwdev, "wow: failed to enable trx_post\n");
1722		goto out;
1723	}
1724
1725	return 0;
1726
1727out:
1728	clear_bit(RTW89_FLAG_WOWLAN, rtwdev->flags);
1729	return ret;
1730}
1731
1732static int rtw89_wow_disable(struct rtw89_dev *rtwdev)
1733{
1734	int ret;
1735
1736	ret = rtw89_wow_disable_trx_pre(rtwdev);
1737	if (ret) {
1738		rtw89_err(rtwdev, "wow: failed to disable trx_pre\n");
1739		goto out;
1740	}
1741
1742	rtw89_wow_leave_ps(rtwdev, false);
1743
1744	ret = rtw89_wow_fw_stop(rtwdev);
1745	if (ret) {
1746		rtw89_err(rtwdev, "wow: failed to swap to normal fw\n");
1747		goto out;
1748	}
1749
1750	ret = rtw89_wow_swap_fw(rtwdev, false);
1751	if (ret) {
1752		rtw89_err(rtwdev, "wow: failed to disable trx_post\n");
1753		goto out;
1754	}
1755
1756	ret = rtw89_wow_disable_trx_post(rtwdev);
1757	if (ret) {
1758		rtw89_err(rtwdev, "wow: failed to disable trx_pre\n");
1759		goto out;
1760	}
1761
1762out:
1763	clear_bit(RTW89_FLAG_WOWLAN, rtwdev->flags);
1764	return ret;
1765}
1766
1767static void rtw89_wow_restore_ps(struct rtw89_dev *rtwdev)
1768{
1769	if (rtw89_wow_no_link(rtwdev))
1770		rtw89_enter_ips(rtwdev);
1771}
1772
1773int rtw89_wow_resume(struct rtw89_dev *rtwdev)
1774{
1775	int ret;
1776
1777	if (!test_bit(RTW89_FLAG_WOWLAN, rtwdev->flags)) {
1778		rtw89_err(rtwdev, "wow is not enabled\n");
1779		ret = -EPERM;
1780		goto out;
1781	}
1782
1783	if (!rtw89_mac_get_power_state(rtwdev)) {
1784		rtw89_err(rtwdev, "chip is no power when resume\n");
1785		ret = -EPERM;
1786		goto out;
1787	}
1788
1789	rtw89_wow_leave_deep_ps(rtwdev);
1790
1791	rtw89_wow_show_wakeup_reason(rtwdev);
1792
1793	ret = rtw89_wow_disable(rtwdev);
1794	if (ret)
1795		rtw89_err(rtwdev, "failed to disable wow\n");
1796
1797	rtw89_wow_restore_ps(rtwdev);
1798out:
1799	rtw89_wow_clear_wakeups(rtwdev);
1800	return ret;
1801}
1802
1803int rtw89_wow_suspend(struct rtw89_dev *rtwdev, struct cfg80211_wowlan *wowlan)
1804{
1805	int ret;
1806
1807	ret = rtw89_wow_set_wakeups(rtwdev, wowlan);
1808	if (ret) {
1809		rtw89_err(rtwdev, "failed to set wakeup event\n");
1810		return ret;
1811	}
1812
1813	rtw89_wow_leave_ps(rtwdev, true);
1814
1815	ret = rtw89_wow_enable(rtwdev);
1816	if (ret) {
1817		rtw89_err(rtwdev, "failed to enable wow\n");
1818		return ret;
1819	}
1820
1821	rtw89_wow_enter_deep_ps(rtwdev);
1822
1823	return 0;
1824}