cam.c

   1// SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause
   2/* Copyright(c) 2019-2020  Realtek Corporation
   3 */
   4
   5#include "cam.h"
   6#include "debug.h"
   7#include "fw.h"
   8#include "mac.h"
   9#include "ps.h"
  10
  11static struct sk_buff *
  12rtw89_cam_get_sec_key_cmd(struct rtw89_dev *rtwdev,
  13			  struct rtw89_sec_cam_entry *sec_cam,
  14			  bool ext_key)
  15{
  16	struct sk_buff *skb;
  17	u32 cmd_len = H2C_SEC_CAM_LEN;
  18	u32 key32[4];
  19	u8 *cmd;
  20	int i, j;
  21
  22	skb = rtw89_fw_h2c_alloc_skb_with_hdr(rtwdev, cmd_len);
  23	if (!skb)
  24		return NULL;
  25
  26	skb_put_zero(skb, cmd_len);
  27
  28	for (i = 0; i < 4; i++) {
  29		j = i * 4;
  30		j += ext_key ? 16 : 0;
  31		key32[i] = FIELD_PREP(GENMASK(7, 0), sec_cam->key[j + 0]) |
  32			   FIELD_PREP(GENMASK(15, 8), sec_cam->key[j + 1]) |
  33			   FIELD_PREP(GENMASK(23, 16), sec_cam->key[j + 2]) |
  34			   FIELD_PREP(GENMASK(31, 24), sec_cam->key[j + 3]);
  35	}
  36
  37	cmd = skb->data;
  38	RTW89_SET_FWCMD_SEC_IDX(cmd, sec_cam->sec_cam_idx + (ext_key ? 1 : 0));
  39	RTW89_SET_FWCMD_SEC_OFFSET(cmd, sec_cam->offset);
  40	RTW89_SET_FWCMD_SEC_LEN(cmd, sec_cam->len);
  41	RTW89_SET_FWCMD_SEC_TYPE(cmd, sec_cam->type);
  42	RTW89_SET_FWCMD_SEC_EXT_KEY(cmd, ext_key);
  43	RTW89_SET_FWCMD_SEC_SPP_MODE(cmd, sec_cam->spp_mode);
  44	RTW89_SET_FWCMD_SEC_KEY0(cmd, key32[0]);
  45	RTW89_SET_FWCMD_SEC_KEY1(cmd, key32[1]);
  46	RTW89_SET_FWCMD_SEC_KEY2(cmd, key32[2]);
  47	RTW89_SET_FWCMD_SEC_KEY3(cmd, key32[3]);
  48
  49	return skb;
  50}
  51
  52static int rtw89_cam_send_sec_key_cmd(struct rtw89_dev *rtwdev,
  53				      struct rtw89_sec_cam_entry *sec_cam)
  54{
  55	struct sk_buff *skb, *ext_skb;
  56	int ret;
  57
  58	skb = rtw89_cam_get_sec_key_cmd(rtwdev, sec_cam, false);
  59	if (!skb) {
  60		rtw89_err(rtwdev, "failed to get sec key command\n");
  61		return -ENOMEM;
  62	}
  63
  64	rtw89_h2c_pkt_set_hdr(rtwdev, skb,
  65			      FWCMD_TYPE_H2C,
  66			      H2C_CAT_MAC,
  67			      H2C_CL_MAC_SEC_CAM,
  68			      H2C_FUNC_MAC_SEC_UPD, 1, 0,
  69			      H2C_SEC_CAM_LEN);
  70	ret = rtw89_h2c_tx(rtwdev, skb, false);
  71	if (ret) {
  72		rtw89_err(rtwdev, "failed to send sec key h2c: %d\n", ret);
  73		dev_kfree_skb(skb);
  74		return ret;
  75	}
  76
  77	if (!sec_cam->ext_key)
  78		return 0;
  79
  80	ext_skb = rtw89_cam_get_sec_key_cmd(rtwdev, sec_cam, true);
  81	if (!ext_skb) {
  82		rtw89_err(rtwdev, "failed to get ext sec key command\n");
  83		return -ENOMEM;
  84	}
  85
  86	rtw89_h2c_pkt_set_hdr(rtwdev, ext_skb,
  87			      FWCMD_TYPE_H2C,
  88			      H2C_CAT_MAC,
  89			      H2C_CL_MAC_SEC_CAM,
  90			      H2C_FUNC_MAC_SEC_UPD,
  91			      1, 0, H2C_SEC_CAM_LEN);
  92	ret = rtw89_h2c_tx(rtwdev, ext_skb, false);
  93	if (ret) {
  94		rtw89_err(rtwdev, "failed to send ext sec key h2c: %d\n", ret);
  95		dev_kfree_skb(ext_skb);
  96		return ret;
  97	}
  98
  99	return 0;
 100}
 101
 102static int rtw89_cam_get_avail_sec_cam(struct rtw89_dev *rtwdev,
 103				       u8 *sec_cam_idx, bool ext_key)
 104{
 105	const struct rtw89_chip_info *chip = rtwdev->chip;
 106	struct rtw89_cam_info *cam_info = &rtwdev->cam_info;
 107	u8 sec_cam_num = chip->scam_num;
 108	u8 idx = 0;
 109
 110	if (!ext_key) {
 111		idx = find_first_zero_bit(cam_info->sec_cam_map, sec_cam_num);
 112		if (idx >= sec_cam_num)
 113			return -EBUSY;
 114
 115		set_bit(idx, cam_info->sec_cam_map);
 116		*sec_cam_idx = idx;
 117
 118		return 0;
 119	}
 120
 121again:
 122	idx = find_next_zero_bit(cam_info->sec_cam_map, sec_cam_num, idx);
 123	if (idx >= sec_cam_num - 1)
 124		return -EBUSY;
 125	/* ext keys need two cam entries for 256-bit key */
 126	if (test_bit(idx + 1, cam_info->sec_cam_map)) {
 127		idx++;
 128		goto again;
 129	}
 130
 131	set_bit(idx, cam_info->sec_cam_map);
 132	set_bit(idx + 1, cam_info->sec_cam_map);
 133	*sec_cam_idx = idx;
 134
 135	return 0;
 136}
 137
 138static int rtw89_cam_get_addr_cam_key_idx(struct rtw89_addr_cam_entry *addr_cam,
 139					  const struct rtw89_sec_cam_entry *sec_cam,
 140					  const struct ieee80211_key_conf *key,
 141					  u8 *key_idx)
 142{
 143	u8 idx;
 144
 145	/* RTW89_ADDR_CAM_SEC_NONE	: not enabled
 146	 * RTW89_ADDR_CAM_SEC_ALL_UNI	: 0 - 6 unicast
 147	 * RTW89_ADDR_CAM_SEC_NORMAL	: 0 - 1 unicast, 2 - 4 group, 5 - 6 BIP
 148	 * RTW89_ADDR_CAM_SEC_4GROUP	: 0 - 1 unicast, 2 - 5 group, 6 BIP
 149	 */
 150	switch (addr_cam->sec_ent_mode) {
 151	case RTW89_ADDR_CAM_SEC_NONE:
 152		return -EINVAL;
 153	case RTW89_ADDR_CAM_SEC_ALL_UNI:
 154		idx = find_first_zero_bit(addr_cam->sec_cam_map,
 155					  RTW89_SEC_CAM_IN_ADDR_CAM);
 156		if (idx >= RTW89_SEC_CAM_IN_ADDR_CAM)
 157			return -EBUSY;
 158		*key_idx = idx;
 159		break;
 160	case RTW89_ADDR_CAM_SEC_NORMAL:
 161		if (sec_cam->type == RTW89_SEC_KEY_TYPE_BIP_CCMP128) {
 162			idx = find_next_zero_bit(addr_cam->sec_cam_map,
 163						 RTW89_SEC_CAM_IN_ADDR_CAM, 5);
 164			if (idx > 6)
 165				return -EBUSY;
 166			*key_idx = idx;
 167			break;
 168		}
 169
 170		if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE) {
 171			idx = find_next_zero_bit(addr_cam->sec_cam_map,
 172						 RTW89_SEC_CAM_IN_ADDR_CAM, 0);
 173			if (idx > 1)
 174				return -EBUSY;
 175			*key_idx = idx;
 176			break;
 177		}
 178
 179		/* Group keys */
 180		idx = find_next_zero_bit(addr_cam->sec_cam_map,
 181					 RTW89_SEC_CAM_IN_ADDR_CAM, 2);
 182		if (idx > 4)
 183			return -EBUSY;
 184		*key_idx = idx;
 185		break;
 186	case RTW89_ADDR_CAM_SEC_4GROUP:
 187		if (sec_cam->type == RTW89_SEC_KEY_TYPE_BIP_CCMP128) {
 188			if (test_bit(6, addr_cam->sec_cam_map))
 189				return -EINVAL;
 190			*key_idx = 6;
 191			break;
 192		}
 193
 194		if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE) {
 195			idx = find_next_zero_bit(addr_cam->sec_cam_map,
 196						 RTW89_SEC_CAM_IN_ADDR_CAM, 0);
 197			if (idx > 1)
 198				return -EBUSY;
 199			*key_idx = idx;
 200			break;
 201		}
 202
 203		/* Group keys */
 204		idx = find_next_zero_bit(addr_cam->sec_cam_map,
 205					 RTW89_SEC_CAM_IN_ADDR_CAM, 2);
 206		if (idx > 5)
 207			return -EBUSY;
 208		*key_idx = idx;
 209		break;
 210	}
 211
 212	return 0;
 213}
 214
 215static int __rtw89_cam_detach_sec_cam(struct rtw89_dev *rtwdev,
 216				      struct rtw89_vif_link *rtwvif_link,
 217				      struct rtw89_sta_link *rtwsta_link,
 218				      const struct rtw89_sec_cam_entry *sec_cam,
 219				      bool inform_fw)
 220{
 221	struct rtw89_addr_cam_entry *addr_cam;
 222	unsigned int i;
 223	int ret = 0;
 224
 225	addr_cam = rtw89_get_addr_cam_of(rtwvif_link, rtwsta_link);
 226
 227	for_each_set_bit(i, addr_cam->sec_cam_map, RTW89_SEC_CAM_IN_ADDR_CAM) {
 228		if (addr_cam->sec_ent[i] != sec_cam->sec_cam_idx)
 229			continue;
 230
 231		clear_bit(i, addr_cam->sec_cam_map);
 232	}
 233
 234	if (inform_fw) {
 235		ret = rtw89_chip_h2c_dctl_sec_cam(rtwdev, rtwvif_link, rtwsta_link);
 236		if (ret)
 237			rtw89_err(rtwdev,
 238				  "failed to update dctl cam del key: %d\n", ret);
 239		ret = rtw89_fw_h2c_cam(rtwdev, rtwvif_link, rtwsta_link, NULL,
 240				       RTW89_ROLE_INFO_CHANGE);
 241		if (ret)
 242			rtw89_err(rtwdev, "failed to update cam del key: %d\n", ret);
 243	}
 244
 245	return ret;
 246}
 247
 248static int __rtw89_cam_attach_sec_cam(struct rtw89_dev *rtwdev,
 249				      struct rtw89_vif_link *rtwvif_link,
 250				      struct rtw89_sta_link *rtwsta_link,
 251				      const struct ieee80211_key_conf *key,
 252				      const struct rtw89_sec_cam_entry *sec_cam)
 253{
 254	struct rtw89_addr_cam_entry *addr_cam;
 255	u8 key_idx = 0;
 256	int ret;
 257
 258	addr_cam = rtw89_get_addr_cam_of(rtwvif_link, rtwsta_link);
 259
 260	if (key->cipher == WLAN_CIPHER_SUITE_WEP40 ||
 261	    key->cipher == WLAN_CIPHER_SUITE_WEP104)
 262		addr_cam->sec_ent_mode = RTW89_ADDR_CAM_SEC_ALL_UNI;
 263
 264	ret = rtw89_cam_get_addr_cam_key_idx(addr_cam, sec_cam, key, &key_idx);
 265	if (ret) {
 266		rtw89_err(rtwdev, "failed to get addr cam key idx %d, %d\n",
 267			  addr_cam->sec_ent_mode, sec_cam->type);
 268		return ret;
 269	}
 270
 271	addr_cam->sec_ent_keyid[key_idx] = key->keyidx;
 272	addr_cam->sec_ent[key_idx] = sec_cam->sec_cam_idx;
 273	set_bit(key_idx, addr_cam->sec_cam_map);
 274	ret = rtw89_chip_h2c_dctl_sec_cam(rtwdev, rtwvif_link, rtwsta_link);
 275	if (ret) {
 276		rtw89_err(rtwdev, "failed to update dctl cam sec entry: %d\n",
 277			  ret);
 278		return ret;
 279	}
 280	ret = rtw89_fw_h2c_cam(rtwdev, rtwvif_link, rtwsta_link, NULL,
 281			       RTW89_ROLE_INFO_CHANGE);
 282	if (ret) {
 283		rtw89_err(rtwdev, "failed to update addr cam sec entry: %d\n",
 284			  ret);
 285		clear_bit(key_idx, addr_cam->sec_cam_map);
 286		return ret;
 287	}
 288
 289	return 0;
 290}
 291
 292int rtw89_cam_attach_link_sec_cam(struct rtw89_dev *rtwdev,
 293				  struct rtw89_vif_link *rtwvif_link,
 294				  struct rtw89_sta_link *rtwsta_link,
 295				  u8 sec_cam_idx)
 296{
 297	struct rtw89_cam_info *cam_info = &rtwdev->cam_info;
 298	const struct rtw89_sec_cam_entry *sec_cam;
 299
 300	sec_cam = cam_info->sec_entries[sec_cam_idx];
 301	if (!sec_cam)
 302		return -ENOENT;
 303
 304	return __rtw89_cam_attach_sec_cam(rtwdev, rtwvif_link, rtwsta_link,
 305					  sec_cam->key_conf, sec_cam);
 306}
 307
 308static int rtw89_cam_detach_sec_cam(struct rtw89_dev *rtwdev,
 309				    struct ieee80211_vif *vif,
 310				    struct ieee80211_sta *sta,
 311				    const struct rtw89_sec_cam_entry *sec_cam,
 312				    bool inform_fw)
 313{
 314	struct rtw89_sta *rtwsta = sta_to_rtwsta_safe(sta);
 315	struct rtw89_sta_link *rtwsta_link;
 316	struct rtw89_vif_link *rtwvif_link;
 317	struct rtw89_vif *rtwvif;
 318	unsigned int link_id;
 319	int ret;
 320
 321	if (!vif) {
 322		rtw89_err(rtwdev, "No iface for deleting sec cam\n");
 323		return -EINVAL;
 324	}
 325
 326	rtwvif = vif_to_rtwvif(vif);
 327
 328	if (rtwsta)
 329		clear_bit(sec_cam->sec_cam_idx, rtwsta->pairwise_sec_cam_map);
 330
 331	rtw89_vif_for_each_link(rtwvif, rtwvif_link, link_id) {
 332		rtwsta_link = rtwsta ? rtwsta->links[link_id] : NULL;
 333		if (rtwsta && !rtwsta_link)
 334			continue;
 335
 336		ret = __rtw89_cam_detach_sec_cam(rtwdev, rtwvif_link, rtwsta_link,
 337						 sec_cam, inform_fw);
 338		if (ret)
 339			return ret;
 340	}
 341
 342	return 0;
 343}
 344
 345static int rtw89_cam_attach_sec_cam(struct rtw89_dev *rtwdev,
 346				    struct ieee80211_vif *vif,
 347				    struct ieee80211_sta *sta,
 348				    struct ieee80211_key_conf *key,
 349				    struct rtw89_sec_cam_entry *sec_cam)
 350{
 351	struct rtw89_sta *rtwsta = sta_to_rtwsta_safe(sta);
 352	struct rtw89_sta_link *rtwsta_link;
 353	struct rtw89_vif_link *rtwvif_link;
 354	struct rtw89_vif *rtwvif;
 355	unsigned int link_id;
 356	int key_link_id;
 357	int ret;
 358
 359	if (!vif) {
 360		rtw89_err(rtwdev, "No iface for adding sec cam\n");
 361		return -EINVAL;
 362	}
 363
 364	rtwvif = vif_to_rtwvif(vif);
 365
 366	key_link_id = ieee80211_vif_is_mld(vif) ? key->link_id : 0;
 367	if (key_link_id >= 0) {
 368		rtwvif_link = rtwvif->links[key_link_id];
 369		rtwsta_link = rtwsta ? rtwsta->links[key_link_id] : NULL;
 370
 371		if (!rtwvif_link || (rtwsta && !rtwsta_link)) {
 372			rtw89_err(rtwdev, "No drv link for adding sec cam\n");
 373			return -ENOLINK;
 374		}
 375
 376		return __rtw89_cam_attach_sec_cam(rtwdev, rtwvif_link,
 377						  rtwsta_link, key, sec_cam);
 378	}
 379
 380	/* key_link_id < 0: MLD pairwise key */
 381	if (!rtwsta) {
 382		rtw89_err(rtwdev, "No sta for adding MLD pairwise sec cam\n");
 383		return -EINVAL;
 384	}
 385
 386	rtw89_sta_for_each_link(rtwsta, rtwsta_link, link_id) {
 387		rtwvif_link = rtwsta_link->rtwvif_link;
 388		ret = __rtw89_cam_attach_sec_cam(rtwdev, rtwvif_link,
 389						 rtwsta_link, key, sec_cam);
 390		if (ret)
 391			return ret;
 392	}
 393
 394	set_bit(sec_cam->sec_cam_idx, rtwsta->pairwise_sec_cam_map);
 395
 396	return 0;
 397}
 398
 399static int rtw89_cam_sec_key_install(struct rtw89_dev *rtwdev,
 400				     struct ieee80211_vif *vif,
 401				     struct ieee80211_sta *sta,
 402				     struct ieee80211_key_conf *key,
 403				     u8 hw_key_type, bool ext_key)
 404{
 405	struct rtw89_sec_cam_entry *sec_cam = NULL;
 406	struct rtw89_cam_info *cam_info = &rtwdev->cam_info;
 407	u8 sec_cam_idx;
 408	int ret;
 409
 410	/* maximum key length 256-bit */
 411	if (key->keylen > 32) {
 412		rtw89_err(rtwdev, "invalid sec key length %d\n", key->keylen);
 413		return -EINVAL;
 414	}
 415
 416	ret = rtw89_cam_get_avail_sec_cam(rtwdev, &sec_cam_idx, ext_key);
 417	if (ret) {
 418		rtw89_warn(rtwdev, "no available sec cam: %d ext: %d\n",
 419			   ret, ext_key);
 420		return ret;
 421	}
 422
 423	sec_cam = kzalloc(sizeof(*sec_cam), GFP_KERNEL);
 424	if (!sec_cam) {
 425		ret = -ENOMEM;
 426		goto err_release_cam;
 427	}
 428
 429	key->hw_key_idx = sec_cam_idx;
 430	cam_info->sec_entries[sec_cam_idx] = sec_cam;
 431
 432	sec_cam->sec_cam_idx = sec_cam_idx;
 433	sec_cam->type = hw_key_type;
 434	sec_cam->len = RTW89_SEC_CAM_LEN;
 435	sec_cam->ext_key = ext_key;
 436	memcpy(sec_cam->key, key->key, key->keylen);
 437
 438	sec_cam->key_conf = key;
 439
 440	ret = rtw89_cam_send_sec_key_cmd(rtwdev, sec_cam);
 441	if (ret) {
 442		rtw89_err(rtwdev, "failed to send sec key cmd: %d\n", ret);
 443		goto err_release_cam;
 444	}
 445
 446	/* associate with addr cam */
 447	ret = rtw89_cam_attach_sec_cam(rtwdev, vif, sta, key, sec_cam);
 448	if (ret) {
 449		rtw89_err(rtwdev, "failed to attach sec cam: %d\n", ret);
 450		goto err_release_cam;
 451	}
 452
 453	return 0;
 454
 455err_release_cam:
 456	cam_info->sec_entries[sec_cam_idx] = NULL;
 457	kfree(sec_cam);
 458	clear_bit(sec_cam_idx, cam_info->sec_cam_map);
 459	if (ext_key)
 460		clear_bit(sec_cam_idx + 1, cam_info->sec_cam_map);
 461
 462	return ret;
 463}
 464
 465int rtw89_cam_sec_key_add(struct rtw89_dev *rtwdev,
 466			  struct ieee80211_vif *vif,
 467			  struct ieee80211_sta *sta,
 468			  struct ieee80211_key_conf *key)
 469{
 470	const struct rtw89_chip_info *chip = rtwdev->chip;
 471	u8 hw_key_type;
 472	bool ext_key = false;
 473	int ret;
 474
 475	if (ieee80211_vif_is_mld(vif) && !chip->hw_mlo_bmc_crypto &&
 476	    !(key->flags & IEEE80211_KEY_FLAG_PAIRWISE))
 477		return -EOPNOTSUPP;
 478
 479	switch (key->cipher) {
 480	case WLAN_CIPHER_SUITE_WEP40:
 481		rtw89_leave_ips_by_hwflags(rtwdev);
 482		hw_key_type = RTW89_SEC_KEY_TYPE_WEP40;
 483		break;
 484	case WLAN_CIPHER_SUITE_WEP104:
 485		rtw89_leave_ips_by_hwflags(rtwdev);
 486		hw_key_type = RTW89_SEC_KEY_TYPE_WEP104;
 487		break;
 488	case WLAN_CIPHER_SUITE_TKIP:
 489		if (!chip->hw_tkip_crypto)
 490			return -EOPNOTSUPP;
 491		hw_key_type = RTW89_SEC_KEY_TYPE_TKIP;
 492		key->flags |= IEEE80211_KEY_FLAG_GENERATE_MMIC;
 493		break;
 494	case WLAN_CIPHER_SUITE_CCMP:
 495		hw_key_type = RTW89_SEC_KEY_TYPE_CCMP128;
 496		if (!chip->hw_mgmt_tx_encrypt)
 497			key->flags |= IEEE80211_KEY_FLAG_SW_MGMT_TX;
 498		break;
 499	case WLAN_CIPHER_SUITE_CCMP_256:
 500		hw_key_type = RTW89_SEC_KEY_TYPE_CCMP256;
 501		if (!chip->hw_mgmt_tx_encrypt)
 502			key->flags |= IEEE80211_KEY_FLAG_SW_MGMT_TX;
 503		ext_key = true;
 504		break;
 505	case WLAN_CIPHER_SUITE_GCMP:
 506		hw_key_type = RTW89_SEC_KEY_TYPE_GCMP128;
 507		if (!chip->hw_mgmt_tx_encrypt)
 508			key->flags |= IEEE80211_KEY_FLAG_SW_MGMT_TX;
 509		break;
 510	case WLAN_CIPHER_SUITE_GCMP_256:
 511		hw_key_type = RTW89_SEC_KEY_TYPE_GCMP256;
 512		if (!chip->hw_mgmt_tx_encrypt)
 513			key->flags |= IEEE80211_KEY_FLAG_SW_MGMT_TX;
 514		ext_key = true;
 515		break;
 516	case WLAN_CIPHER_SUITE_AES_CMAC:
 517		hw_key_type = RTW89_SEC_KEY_TYPE_BIP_CCMP128;
 518		break;
 519	default:
 520		return -EOPNOTSUPP;
 521	}
 522
 523	if (!chip->hw_sec_hdr)
 524		key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
 525
 526	ret = rtw89_cam_sec_key_install(rtwdev, vif, sta, key, hw_key_type,
 527					ext_key);
 528	if (ret) {
 529		rtw89_err(rtwdev, "failed to install key type %d ext %d: %d\n",
 530			  hw_key_type, ext_key, ret);
 531		return ret;
 532	}
 533
 534	return 0;
 535}
 536
 537int rtw89_cam_sec_key_del(struct rtw89_dev *rtwdev,
 538			  struct ieee80211_vif *vif,
 539			  struct ieee80211_sta *sta,
 540			  struct ieee80211_key_conf *key,
 541			  bool inform_fw)
 542{
 543	struct rtw89_cam_info *cam_info = &rtwdev->cam_info;
 544	const struct rtw89_sec_cam_entry *sec_cam;
 545	u8 sec_cam_idx;
 546	int ret;
 547
 548	sec_cam_idx = key->hw_key_idx;
 549	sec_cam = cam_info->sec_entries[sec_cam_idx];
 550	if (!sec_cam)
 551		return -EINVAL;
 552
 553	ret = rtw89_cam_detach_sec_cam(rtwdev, vif, sta, sec_cam, inform_fw);
 554
 555	/* clear valid bit in addr cam will disable sec cam,
 556	 * so we don't need to send H2C command again
 557	 */
 558	cam_info->sec_entries[sec_cam_idx] = NULL;
 559	clear_bit(sec_cam_idx, cam_info->sec_cam_map);
 560	if (sec_cam->ext_key)
 561		clear_bit(sec_cam_idx + 1, cam_info->sec_cam_map);
 562
 563	kfree(sec_cam);
 564
 565	return ret;
 566}
 567
 568static void rtw89_cam_reset_key_iter(struct ieee80211_hw *hw,
 569				     struct ieee80211_vif *vif,
 570				     struct ieee80211_sta *sta,
 571				     struct ieee80211_key_conf *key,
 572				     void *data)
 573{
 574	struct rtw89_dev *rtwdev = (struct rtw89_dev *)data;
 575
 576	rtw89_cam_sec_key_del(rtwdev, vif, sta, key, false);
 577}
 578
 579void rtw89_cam_deinit_addr_cam(struct rtw89_dev *rtwdev,
 580			       struct rtw89_addr_cam_entry *addr_cam)
 581{
 582	struct rtw89_cam_info *cam_info = &rtwdev->cam_info;
 583
 584	addr_cam->valid = false;
 585	clear_bit(addr_cam->addr_cam_idx, cam_info->addr_cam_map);
 586}
 587
 588void rtw89_cam_deinit_bssid_cam(struct rtw89_dev *rtwdev,
 589				struct rtw89_bssid_cam_entry *bssid_cam)
 590{
 591	struct rtw89_cam_info *cam_info = &rtwdev->cam_info;
 592
 593	bssid_cam->valid = false;
 594	clear_bit(bssid_cam->bssid_cam_idx, cam_info->bssid_cam_map);
 595}
 596
 597void rtw89_cam_deinit(struct rtw89_dev *rtwdev, struct rtw89_vif_link *rtwvif_link)
 598{
 599	struct rtw89_addr_cam_entry *addr_cam = &rtwvif_link->addr_cam;
 600	struct rtw89_bssid_cam_entry *bssid_cam = &rtwvif_link->bssid_cam;
 601
 602	rtw89_cam_deinit_addr_cam(rtwdev, addr_cam);
 603	rtw89_cam_deinit_bssid_cam(rtwdev, bssid_cam);
 604}
 605
 606void rtw89_cam_reset_keys(struct rtw89_dev *rtwdev)
 607{
 608	rcu_read_lock();
 609	ieee80211_iter_keys_rcu(rtwdev->hw, NULL, rtw89_cam_reset_key_iter, rtwdev);
 610	rcu_read_unlock();
 611}
 612
 613static int rtw89_cam_get_avail_addr_cam(struct rtw89_dev *rtwdev,
 614					u8 *addr_cam_idx)
 615{
 616	const struct rtw89_chip_info *chip = rtwdev->chip;
 617	struct rtw89_cam_info *cam_info = &rtwdev->cam_info;
 618	u8 addr_cam_num = chip->acam_num;
 619	u8 idx;
 620
 621	idx = find_first_zero_bit(cam_info->addr_cam_map, addr_cam_num);
 622	if (idx >= addr_cam_num)
 623		return -EBUSY;
 624
 625	set_bit(idx, cam_info->addr_cam_map);
 626	*addr_cam_idx = idx;
 627
 628	return 0;
 629}
 630
 631static u8 rtw89_get_addr_cam_entry_size(struct rtw89_dev *rtwdev)
 632{
 633	const struct rtw89_chip_info *chip = rtwdev->chip;
 634
 635	switch (chip->chip_id) {
 636	case RTL8852A:
 637	case RTL8852B:
 638	case RTL8851B:
 639	case RTL8852BT:
 640		return ADDR_CAM_ENT_SIZE;
 641	default:
 642		return ADDR_CAM_ENT_SHORT_SIZE;
 643	}
 644}
 645
 646int rtw89_cam_init_addr_cam(struct rtw89_dev *rtwdev,
 647			    struct rtw89_addr_cam_entry *addr_cam,
 648			    const struct rtw89_bssid_cam_entry *bssid_cam)
 649{
 650	u8 addr_cam_idx;
 651	int i;
 652	int ret;
 653
 654	if (unlikely(addr_cam->valid)) {
 655		rtw89_debug(rtwdev, RTW89_DBG_FW,
 656			    "addr cam is already valid; skip init\n");
 657		return 0;
 658	}
 659
 660	ret = rtw89_cam_get_avail_addr_cam(rtwdev, &addr_cam_idx);
 661	if (ret) {
 662		rtw89_err(rtwdev, "failed to get available addr cam\n");
 663		return ret;
 664	}
 665
 666	addr_cam->addr_cam_idx = addr_cam_idx;
 667	addr_cam->len = rtw89_get_addr_cam_entry_size(rtwdev);
 668	addr_cam->offset = 0;
 669	addr_cam->valid = true;
 670	addr_cam->addr_mask = 0;
 671	addr_cam->mask_sel = RTW89_NO_MSK;
 672	addr_cam->sec_ent_mode = RTW89_ADDR_CAM_SEC_NORMAL;
 673	bitmap_zero(addr_cam->sec_cam_map, RTW89_SEC_CAM_IN_ADDR_CAM);
 674
 675	for (i = 0; i < RTW89_SEC_CAM_IN_ADDR_CAM; i++) {
 676		addr_cam->sec_ent_keyid[i] = 0;
 677		addr_cam->sec_ent[i] = 0;
 678	}
 679
 680	/* associate addr cam with bssid cam */
 681	addr_cam->bssid_cam_idx = bssid_cam->bssid_cam_idx;
 682
 683	return 0;
 684}
 685
 686static int rtw89_cam_get_avail_bssid_cam(struct rtw89_dev *rtwdev,
 687					 u8 *bssid_cam_idx)
 688{
 689	const struct rtw89_chip_info *chip = rtwdev->chip;
 690	struct rtw89_cam_info *cam_info = &rtwdev->cam_info;
 691	u8 bssid_cam_num = chip->bcam_num;
 692	u8 idx;
 693
 694	idx = find_first_zero_bit(cam_info->bssid_cam_map, bssid_cam_num);
 695	if (idx >= bssid_cam_num)
 696		return -EBUSY;
 697
 698	set_bit(idx, cam_info->bssid_cam_map);
 699	*bssid_cam_idx = idx;
 700
 701	return 0;
 702}
 703
 704int rtw89_cam_init_bssid_cam(struct rtw89_dev *rtwdev,
 705			     struct rtw89_vif_link *rtwvif_link,
 706			     struct rtw89_bssid_cam_entry *bssid_cam,
 707			     const u8 *bssid)
 708{
 709	u8 bssid_cam_idx;
 710	int ret;
 711
 712	if (unlikely(bssid_cam->valid)) {
 713		rtw89_debug(rtwdev, RTW89_DBG_FW,
 714			    "bssid cam is already valid; skip init\n");
 715		return 0;
 716	}
 717
 718	ret = rtw89_cam_get_avail_bssid_cam(rtwdev, &bssid_cam_idx);
 719	if (ret) {
 720		rtw89_err(rtwdev, "failed to get available bssid cam\n");
 721		return ret;
 722	}
 723
 724	bssid_cam->bssid_cam_idx = bssid_cam_idx;
 725	bssid_cam->phy_idx = rtwvif_link->phy_idx;
 726	bssid_cam->len = BSSID_CAM_ENT_SIZE;
 727	bssid_cam->offset = 0;
 728	bssid_cam->valid = true;
 729	ether_addr_copy(bssid_cam->bssid, bssid);
 730
 731	return 0;
 732}
 733
 734void rtw89_cam_bssid_changed(struct rtw89_dev *rtwdev, struct rtw89_vif_link *rtwvif_link)
 735{
 736	struct rtw89_bssid_cam_entry *bssid_cam = &rtwvif_link->bssid_cam;
 737
 738	ether_addr_copy(bssid_cam->bssid, rtwvif_link->bssid);
 739}
 740
 741int rtw89_cam_init(struct rtw89_dev *rtwdev, struct rtw89_vif_link *rtwvif_link)
 742{
 743	struct rtw89_addr_cam_entry *addr_cam = &rtwvif_link->addr_cam;
 744	struct rtw89_bssid_cam_entry *bssid_cam = &rtwvif_link->bssid_cam;
 745	int ret;
 746
 747	ret = rtw89_cam_init_bssid_cam(rtwdev, rtwvif_link, bssid_cam,
 748				       rtwvif_link->bssid);
 749	if (ret) {
 750		rtw89_err(rtwdev, "failed to init bssid cam\n");
 751		return ret;
 752	}
 753
 754	ret = rtw89_cam_init_addr_cam(rtwdev, addr_cam, bssid_cam);
 755	if (ret) {
 756		rtw89_err(rtwdev, "failed to init addr cam\n");
 757		return ret;
 758	}
 759
 760	return 0;
 761}
 762
 763int rtw89_cam_fill_bssid_cam_info(struct rtw89_dev *rtwdev,
 764				  struct rtw89_vif_link *rtwvif_link,
 765				  struct rtw89_sta_link *rtwsta_link,
 766				  struct rtw89_h2c_addr_cam_v0 *h2c)
 767{
 768	struct rtw89_bssid_cam_entry *bssid_cam = rtw89_get_bssid_cam_of(rtwvif_link,
 769									 rtwsta_link);
 770	struct ieee80211_bss_conf *bss_conf;
 771	u8 bss_color;
 772	u8 bss_mask;
 773
 774	rcu_read_lock();
 775
 776	bss_conf = rtw89_vif_rcu_dereference_link(rtwvif_link, false);
 777	bss_color = bss_conf->he_bss_color.color;
 778
 779	if (bss_conf->nontransmitted)
 780		bss_mask = RTW89_BSSID_MATCH_5_BYTES;
 781	else
 782		bss_mask = RTW89_BSSID_MATCH_ALL;
 783
 784	rcu_read_unlock();
 785
 786	h2c->w12 = le32_encode_bits(bssid_cam->bssid_cam_idx, ADDR_CAM_W12_BSSID_IDX) |
 787		   le32_encode_bits(bssid_cam->offset, ADDR_CAM_W12_BSSID_OFFSET) |
 788		   le32_encode_bits(bssid_cam->len, ADDR_CAM_W12_BSSID_LEN);
 789	h2c->w13 = le32_encode_bits(bssid_cam->valid, ADDR_CAM_W13_BSSID_VALID) |
 790		   le32_encode_bits(bss_mask, ADDR_CAM_W13_BSSID_MASK) |
 791		   le32_encode_bits(bssid_cam->phy_idx, ADDR_CAM_W13_BSSID_BB_SEL) |
 792		   le32_encode_bits(bss_color, ADDR_CAM_W13_BSSID_BSS_COLOR) |
 793		   le32_encode_bits(bssid_cam->bssid[0], ADDR_CAM_W13_BSSID_BSSID0) |
 794		   le32_encode_bits(bssid_cam->bssid[1], ADDR_CAM_W13_BSSID_BSSID1);
 795	h2c->w14 = le32_encode_bits(bssid_cam->bssid[2], ADDR_CAM_W14_BSSID_BSSID2) |
 796		   le32_encode_bits(bssid_cam->bssid[3], ADDR_CAM_W14_BSSID_BSSID3) |
 797		   le32_encode_bits(bssid_cam->bssid[4], ADDR_CAM_W14_BSSID_BSSID4) |
 798		   le32_encode_bits(bssid_cam->bssid[5], ADDR_CAM_W14_BSSID_BSSID5);
 799
 800	return 0;
 801}
 802
 803static u8 rtw89_cam_addr_hash(u8 start, const u8 *addr)
 804{
 805	u8 hash = 0;
 806	u8 i;
 807
 808	for (i = start; i < ETH_ALEN; i++)
 809		hash ^= addr[i];
 810
 811	return hash;
 812}
 813
 814void rtw89_cam_fill_addr_cam_info(struct rtw89_dev *rtwdev,
 815				  struct rtw89_vif_link *rtwvif_link,
 816				  struct rtw89_sta_link *rtwsta_link,
 817				  const u8 *scan_mac_addr,
 818				  struct rtw89_h2c_addr_cam_v0 *h2c)
 819{
 820	struct ieee80211_vif *vif = rtwvif_link_to_vif(rtwvif_link);
 821	struct rtw89_addr_cam_entry *addr_cam =
 822		rtw89_get_addr_cam_of(rtwvif_link, rtwsta_link);
 823	struct ieee80211_sta *sta = rtwsta_link_to_sta_safe(rtwsta_link);
 824	const struct rtw89_chip_info *chip = rtwdev->chip;
 825	struct ieee80211_link_sta *link_sta;
 826	const u8 *sma = scan_mac_addr ? scan_mac_addr : rtwvif_link->mac_addr;
 827	u8 sma_hash, tma_hash, addr_msk_start;
 828	u8 ver = chip->addrcam_ver;
 829	u8 sma_start = 0;
 830	u8 tma_start = 0;
 831	const u8 *tma;
 832	u8 mac_id;
 833
 834	rcu_read_lock();
 835
 836	if (sta) {
 837		link_sta = rtw89_sta_rcu_dereference_link(rtwsta_link, true);
 838		tma = link_sta->addr;
 839	} else {
 840		tma = rtwvif_link->bssid;
 841	}
 842
 843	if (addr_cam->addr_mask != 0) {
 844		addr_msk_start = __ffs(addr_cam->addr_mask);
 845		if (addr_cam->mask_sel == RTW89_SMA)
 846			sma_start = addr_msk_start;
 847		else if (addr_cam->mask_sel == RTW89_TMA)
 848			tma_start = addr_msk_start;
 849	}
 850	sma_hash = rtw89_cam_addr_hash(sma_start, sma);
 851	tma_hash = rtw89_cam_addr_hash(tma_start, tma);
 852
 853	mac_id = rtwsta_link ? rtwsta_link->mac_id : rtwvif_link->mac_id;
 854
 855	if (ver == 0)
 856		h2c->w1 = le32_encode_bits(addr_cam->addr_cam_idx, ADDR_CAM_W1_IDX) |
 857			  le32_encode_bits(addr_cam->offset, ADDR_CAM_W1_OFFSET) |
 858			  le32_encode_bits(addr_cam->len, ADDR_CAM_W1_LEN);
 859	else
 860		h2c->w1 = le32_encode_bits(addr_cam->addr_cam_idx, ADDR_CAM_W1_V1_IDX) |
 861			  le32_encode_bits(addr_cam->offset, ADDR_CAM_W1_V1_OFFSET) |
 862			  le32_encode_bits(addr_cam->len, ADDR_CAM_W1_V1_LEN);
 863
 864	h2c->w2 = le32_encode_bits(addr_cam->valid, ADDR_CAM_W2_VALID) |
 865		  le32_encode_bits(rtwvif_link->net_type, ADDR_CAM_W2_NET_TYPE) |
 866		  le32_encode_bits(rtwvif_link->bcn_hit_cond, ADDR_CAM_W2_BCN_HIT_COND) |
 867		  le32_encode_bits(rtwvif_link->hit_rule, ADDR_CAM_W2_HIT_RULE) |
 868		  le32_encode_bits(rtwvif_link->phy_idx, ADDR_CAM_W2_BB_SEL) |
 869		  le32_encode_bits(addr_cam->addr_mask, ADDR_CAM_W2_ADDR_MASK) |
 870		  le32_encode_bits(addr_cam->mask_sel, ADDR_CAM_W2_MASK_SEL) |
 871		  le32_encode_bits(sma_hash, ADDR_CAM_W2_SMA_HASH) |
 872		  le32_encode_bits(tma_hash, ADDR_CAM_W2_TMA_HASH);
 873	h2c->w3 = le32_encode_bits(addr_cam->bssid_cam_idx, ADDR_CAM_W3_BSSID_CAM_IDX);
 874	h2c->w4 = le32_encode_bits(sma[0], ADDR_CAM_W4_SMA0) |
 875		  le32_encode_bits(sma[1], ADDR_CAM_W4_SMA1) |
 876		  le32_encode_bits(sma[2], ADDR_CAM_W4_SMA2) |
 877		  le32_encode_bits(sma[3], ADDR_CAM_W4_SMA3);
 878	h2c->w5 = le32_encode_bits(sma[4], ADDR_CAM_W5_SMA4) |
 879		  le32_encode_bits(sma[5], ADDR_CAM_W5_SMA5) |
 880		  le32_encode_bits(tma[0], ADDR_CAM_W5_TMA0) |
 881		  le32_encode_bits(tma[1], ADDR_CAM_W5_TMA1);
 882	h2c->w6 = le32_encode_bits(tma[2], ADDR_CAM_W6_TMA2) |
 883		  le32_encode_bits(tma[3], ADDR_CAM_W6_TMA3) |
 884		  le32_encode_bits(tma[4], ADDR_CAM_W6_TMA4) |
 885		  le32_encode_bits(tma[5], ADDR_CAM_W6_TMA5);
 886	if (ver == 0)
 887		h2c->w8 = le32_encode_bits(rtwvif_link->port, ADDR_CAM_W8_PORT_INT) |
 888			  le32_encode_bits(rtwvif_link->port, ADDR_CAM_W8_TSF_SYNC) |
 889			  le32_encode_bits(rtwvif_link->trigger, ADDR_CAM_W8_TF_TRS) |
 890			  le32_encode_bits(rtwvif_link->lsig_txop, ADDR_CAM_W8_LSIG_TXOP) |
 891			  le32_encode_bits(rtwvif_link->tgt_ind, ADDR_CAM_W8_TGT_IND) |
 892			  le32_encode_bits(rtwvif_link->frm_tgt_ind, ADDR_CAM_W8_FRM_TGT_IND) |
 893			  le32_encode_bits(mac_id, ADDR_CAM_W8_MACID);
 894	else
 895		h2c->w8 = le32_encode_bits(rtwvif_link->port, ADDR_CAM_W8_V1_PORT_INT) |
 896			  le32_encode_bits(rtwvif_link->port, ADDR_CAM_W8_V1_TSF_SYNC) |
 897			  le32_encode_bits(rtwvif_link->trigger, ADDR_CAM_W8_V1_TF_TRS) |
 898			  le32_encode_bits(rtwvif_link->lsig_txop, ADDR_CAM_W8_V1_LSIG_TXOP) |
 899			  le32_encode_bits(mac_id, ADDR_CAM_W8_V1_MACID);
 900
 901	if (rtwvif_link->net_type == RTW89_NET_TYPE_INFRA)
 902		h2c->w9 = le32_encode_bits(vif->cfg.aid & 0xfff, ADDR_CAM_W9_AID12);
 903	else if (rtwvif_link->net_type == RTW89_NET_TYPE_AP_MODE)
 904		h2c->w9 = le32_encode_bits(sta ? sta->aid & 0xfff : 0, ADDR_CAM_W9_AID12);
 905
 906	h2c->w9 |= le32_encode_bits(rtwvif_link->wowlan_pattern, ADDR_CAM_W9_WOL_PATTERN) |
 907		   le32_encode_bits(rtwvif_link->wowlan_uc, ADDR_CAM_W9_WOL_UC) |
 908		   le32_encode_bits(rtwvif_link->wowlan_magic, ADDR_CAM_W9_WOL_MAGIC) |
 909		   le32_encode_bits(addr_cam->wapi, ADDR_CAM_W9_WAPI) |
 910		   le32_encode_bits(addr_cam->sec_ent_mode, ADDR_CAM_W9_SEC_ENT_MODE) |
 911		   le32_encode_bits(addr_cam->sec_ent_keyid[0], ADDR_CAM_W9_SEC_ENT0_KEYID) |
 912		   le32_encode_bits(addr_cam->sec_ent_keyid[1], ADDR_CAM_W9_SEC_ENT1_KEYID) |
 913		   le32_encode_bits(addr_cam->sec_ent_keyid[2], ADDR_CAM_W9_SEC_ENT2_KEYID) |
 914		   le32_encode_bits(addr_cam->sec_ent_keyid[3], ADDR_CAM_W9_SEC_ENT3_KEYID) |
 915		   le32_encode_bits(addr_cam->sec_ent_keyid[4], ADDR_CAM_W9_SEC_ENT4_KEYID) |
 916		   le32_encode_bits(addr_cam->sec_ent_keyid[5], ADDR_CAM_W9_SEC_ENT5_KEYID) |
 917		   le32_encode_bits(addr_cam->sec_ent_keyid[6], ADDR_CAM_W9_SEC_ENT6_KEYID);
 918	h2c->w10 = le32_encode_bits(addr_cam->sec_cam_map[0] & 0xff, ADDR_CAM_W10_SEC_ENT_VALID) |
 919		   le32_encode_bits(addr_cam->sec_ent[0], ADDR_CAM_W10_SEC_ENT0) |
 920		   le32_encode_bits(addr_cam->sec_ent[1], ADDR_CAM_W10_SEC_ENT1) |
 921		   le32_encode_bits(addr_cam->sec_ent[2], ADDR_CAM_W10_SEC_ENT2);
 922	h2c->w11 = le32_encode_bits(addr_cam->sec_ent[3], ADDR_CAM_W11_SEC_ENT3) |
 923		   le32_encode_bits(addr_cam->sec_ent[4], ADDR_CAM_W11_SEC_ENT4) |
 924		   le32_encode_bits(addr_cam->sec_ent[5], ADDR_CAM_W11_SEC_ENT5) |
 925		   le32_encode_bits(addr_cam->sec_ent[6], ADDR_CAM_W11_SEC_ENT6);
 926
 927	rcu_read_unlock();
 928}
 929
 930void rtw89_cam_fill_dctl_sec_cam_info_v1(struct rtw89_dev *rtwdev,
 931					 struct rtw89_vif_link *rtwvif_link,
 932					 struct rtw89_sta_link *rtwsta_link,
 933					 struct rtw89_h2c_dctlinfo_ud_v1 *h2c)
 934{
 935	struct rtw89_addr_cam_entry *addr_cam =
 936		rtw89_get_addr_cam_of(rtwvif_link, rtwsta_link);
 937	struct rtw89_wow_param *rtw_wow = &rtwdev->wow;
 938	u8 *ptk_tx_iv = rtw_wow->key_info.ptk_tx_iv;
 939
 940	h2c->c0 = le32_encode_bits(rtwsta_link ? rtwsta_link->mac_id :
 941						 rtwvif_link->mac_id,
 942				   DCTLINFO_V1_C0_MACID) |
 943		  le32_encode_bits(1, DCTLINFO_V1_C0_OP);
 944
 945	h2c->w4 = le32_encode_bits(addr_cam->sec_ent_keyid[0],
 946				   DCTLINFO_V1_W4_SEC_ENT0_KEYID) |
 947		  le32_encode_bits(addr_cam->sec_ent_keyid[1],
 948				   DCTLINFO_V1_W4_SEC_ENT1_KEYID) |
 949		  le32_encode_bits(addr_cam->sec_ent_keyid[2],
 950				   DCTLINFO_V1_W4_SEC_ENT2_KEYID) |
 951		  le32_encode_bits(addr_cam->sec_ent_keyid[3],
 952				   DCTLINFO_V1_W4_SEC_ENT3_KEYID) |
 953		  le32_encode_bits(addr_cam->sec_ent_keyid[4],
 954				   DCTLINFO_V1_W4_SEC_ENT4_KEYID) |
 955		  le32_encode_bits(addr_cam->sec_ent_keyid[5],
 956				   DCTLINFO_V1_W4_SEC_ENT5_KEYID) |
 957		  le32_encode_bits(addr_cam->sec_ent_keyid[6],
 958				   DCTLINFO_V1_W4_SEC_ENT6_KEYID);
 959	h2c->m4 = cpu_to_le32(DCTLINFO_V1_W4_SEC_ENT0_KEYID |
 960			      DCTLINFO_V1_W4_SEC_ENT1_KEYID |
 961			      DCTLINFO_V1_W4_SEC_ENT2_KEYID |
 962			      DCTLINFO_V1_W4_SEC_ENT3_KEYID |
 963			      DCTLINFO_V1_W4_SEC_ENT4_KEYID |
 964			      DCTLINFO_V1_W4_SEC_ENT5_KEYID |
 965			      DCTLINFO_V1_W4_SEC_ENT6_KEYID);
 966
 967	h2c->w5 = le32_encode_bits(addr_cam->sec_cam_map[0] & 0xff,
 968				   DCTLINFO_V1_W5_SEC_ENT_VALID) |
 969		  le32_encode_bits(addr_cam->sec_ent[0],
 970				   DCTLINFO_V1_W5_SEC_ENT0) |
 971		  le32_encode_bits(addr_cam->sec_ent[1],
 972				   DCTLINFO_V1_W5_SEC_ENT1) |
 973		  le32_encode_bits(addr_cam->sec_ent[2],
 974				   DCTLINFO_V1_W5_SEC_ENT2);
 975	h2c->m5 = cpu_to_le32(DCTLINFO_V1_W5_SEC_ENT_VALID |
 976			      DCTLINFO_V1_W5_SEC_ENT0      |
 977			      DCTLINFO_V1_W5_SEC_ENT1      |
 978			      DCTLINFO_V1_W5_SEC_ENT2);
 979
 980	h2c->w6 = le32_encode_bits(addr_cam->sec_ent[3],
 981				   DCTLINFO_V1_W6_SEC_ENT3) |
 982		  le32_encode_bits(addr_cam->sec_ent[4],
 983				   DCTLINFO_V1_W6_SEC_ENT4) |
 984		  le32_encode_bits(addr_cam->sec_ent[5],
 985				   DCTLINFO_V1_W6_SEC_ENT5) |
 986		  le32_encode_bits(addr_cam->sec_ent[6],
 987				   DCTLINFO_V1_W6_SEC_ENT6);
 988	h2c->m6 = cpu_to_le32(DCTLINFO_V1_W6_SEC_ENT3 |
 989			      DCTLINFO_V1_W6_SEC_ENT4 |
 990			      DCTLINFO_V1_W6_SEC_ENT5 |
 991			      DCTLINFO_V1_W6_SEC_ENT6);
 992
 993	if (rtw_wow->ptk_alg) {
 994		h2c->w0 = le32_encode_bits(ptk_tx_iv[0] | ptk_tx_iv[1] << 8,
 995					   DCTLINFO_V1_W0_AES_IV_L);
 996		h2c->m0 = cpu_to_le32(DCTLINFO_V1_W0_AES_IV_L);
 997
 998		h2c->w1 = le32_encode_bits(ptk_tx_iv[4]       |
 999					   ptk_tx_iv[5] << 8  |
1000					   ptk_tx_iv[6] << 16 |
1001					   ptk_tx_iv[7] << 24,
1002					   DCTLINFO_V1_W1_AES_IV_H);
1003		h2c->m1 = cpu_to_le32(DCTLINFO_V1_W1_AES_IV_H);
1004
1005		h2c->w4 |= le32_encode_bits(rtw_wow->ptk_keyidx,
1006					    DCTLINFO_V1_W4_SEC_KEY_ID);
1007		h2c->m4 |= cpu_to_le32(DCTLINFO_V1_W4_SEC_KEY_ID);
1008	}
1009}
1010
1011void rtw89_cam_fill_dctl_sec_cam_info_v2(struct rtw89_dev *rtwdev,
1012					 struct rtw89_vif_link *rtwvif_link,
1013					 struct rtw89_sta_link *rtwsta_link,
1014					 struct rtw89_h2c_dctlinfo_ud_v2 *h2c)
1015{
1016	struct ieee80211_sta *sta = rtwsta_link_to_sta_safe(rtwsta_link);
1017	struct ieee80211_vif *vif = rtwvif_to_vif(rtwvif_link->rtwvif);
1018	struct rtw89_vif *rtwvif = rtwvif_link->rtwvif;
1019	struct rtw89_addr_cam_entry *addr_cam =
1020		rtw89_get_addr_cam_of(rtwvif_link, rtwsta_link);
1021	bool is_mld = sta ? sta->mlo : ieee80211_vif_is_mld(vif);
1022	struct rtw89_wow_param *rtw_wow = &rtwdev->wow;
1023	u8 *ptk_tx_iv = rtw_wow->key_info.ptk_tx_iv;
1024	u8 *mld_sma, *mld_tma, *mld_bssid;
1025
1026	h2c->c0 = le32_encode_bits(rtwsta_link ? rtwsta_link->mac_id :
1027						 rtwvif_link->mac_id,
1028				   DCTLINFO_V2_C0_MACID) |
1029		  le32_encode_bits(1, DCTLINFO_V2_C0_OP);
1030
1031	h2c->w2 = le32_encode_bits(is_mld, DCTLINFO_V2_W2_IS_MLD);
1032	h2c->m2 = cpu_to_le32(DCTLINFO_V2_W2_IS_MLD);
1033
1034	h2c->w4 = le32_encode_bits(addr_cam->sec_ent_keyid[0],
1035				   DCTLINFO_V2_W4_SEC_ENT0_KEYID) |
1036		  le32_encode_bits(addr_cam->sec_ent_keyid[1],
1037				   DCTLINFO_V2_W4_SEC_ENT1_KEYID) |
1038		  le32_encode_bits(addr_cam->sec_ent_keyid[2],
1039				   DCTLINFO_V2_W4_SEC_ENT2_KEYID) |
1040		  le32_encode_bits(addr_cam->sec_ent_keyid[3],
1041				   DCTLINFO_V2_W4_SEC_ENT3_KEYID) |
1042		  le32_encode_bits(addr_cam->sec_ent_keyid[4],
1043				   DCTLINFO_V2_W4_SEC_ENT4_KEYID) |
1044		  le32_encode_bits(addr_cam->sec_ent_keyid[5],
1045				   DCTLINFO_V2_W4_SEC_ENT5_KEYID) |
1046		  le32_encode_bits(addr_cam->sec_ent_keyid[6],
1047				   DCTLINFO_V2_W4_SEC_ENT6_KEYID);
1048	h2c->m4 = cpu_to_le32(DCTLINFO_V2_W4_SEC_ENT0_KEYID |
1049			      DCTLINFO_V2_W4_SEC_ENT1_KEYID |
1050			      DCTLINFO_V2_W4_SEC_ENT2_KEYID |
1051			      DCTLINFO_V2_W4_SEC_ENT3_KEYID |
1052			      DCTLINFO_V2_W4_SEC_ENT4_KEYID |
1053			      DCTLINFO_V2_W4_SEC_ENT5_KEYID |
1054			      DCTLINFO_V2_W4_SEC_ENT6_KEYID);
1055
1056	h2c->w5 = le32_encode_bits(addr_cam->sec_cam_map[0],
1057				   DCTLINFO_V2_W5_SEC_ENT_VALID_V1) |
1058		  le32_encode_bits(addr_cam->sec_ent[0],
1059				   DCTLINFO_V2_W5_SEC_ENT0_V1);
1060	h2c->m5 = cpu_to_le32(DCTLINFO_V2_W5_SEC_ENT_VALID_V1 |
1061			      DCTLINFO_V2_W5_SEC_ENT0_V1);
1062
1063	h2c->w6 = le32_encode_bits(addr_cam->sec_ent[1],
1064				   DCTLINFO_V2_W6_SEC_ENT1_V1) |
1065		  le32_encode_bits(addr_cam->sec_ent[2],
1066				   DCTLINFO_V2_W6_SEC_ENT2_V1) |
1067		  le32_encode_bits(addr_cam->sec_ent[3],
1068				   DCTLINFO_V2_W6_SEC_ENT3_V1) |
1069		  le32_encode_bits(addr_cam->sec_ent[4],
1070				   DCTLINFO_V2_W6_SEC_ENT4_V1);
1071	h2c->m6 = cpu_to_le32(DCTLINFO_V2_W6_SEC_ENT1_V1 |
1072			      DCTLINFO_V2_W6_SEC_ENT2_V1 |
1073			      DCTLINFO_V2_W6_SEC_ENT3_V1 |
1074			      DCTLINFO_V2_W6_SEC_ENT4_V1);
1075
1076	h2c->w7 = le32_encode_bits(addr_cam->sec_ent[5],
1077				   DCTLINFO_V2_W7_SEC_ENT5_V1) |
1078		  le32_encode_bits(addr_cam->sec_ent[6],
1079				   DCTLINFO_V2_W7_SEC_ENT6_V1);
1080	h2c->m7 = cpu_to_le32(DCTLINFO_V2_W7_SEC_ENT5_V1 |
1081			      DCTLINFO_V2_W7_SEC_ENT6_V1);
1082
1083	if (rtw_wow->ptk_alg) {
1084		h2c->w0 = le32_encode_bits(ptk_tx_iv[0] | ptk_tx_iv[1] << 8,
1085					   DCTLINFO_V2_W0_AES_IV_L);
1086		h2c->m0 = cpu_to_le32(DCTLINFO_V2_W0_AES_IV_L);
1087
1088		h2c->w1 = le32_encode_bits(ptk_tx_iv[4] |
1089					   ptk_tx_iv[5] << 8 |
1090					   ptk_tx_iv[6] << 16 |
1091					   ptk_tx_iv[7] << 24,
1092					   DCTLINFO_V2_W1_AES_IV_H);
1093		h2c->m1 = cpu_to_le32(DCTLINFO_V2_W1_AES_IV_H);
1094
1095		h2c->w4 |= le32_encode_bits(rtw_wow->ptk_keyidx,
1096					    DCTLINFO_V2_W4_SEC_KEY_ID);
1097		h2c->m4 |= cpu_to_le32(DCTLINFO_V2_W4_SEC_KEY_ID);
1098	}
1099
1100	if (!is_mld)
1101		return;
1102
1103	if (rtwvif_link->net_type == RTW89_NET_TYPE_INFRA) {
1104		mld_sma = rtwvif->mac_addr;
1105		mld_tma = vif->cfg.ap_addr;
1106		mld_bssid = vif->cfg.ap_addr;
1107	} else if (rtwvif_link->net_type == RTW89_NET_TYPE_AP_MODE && sta) {
1108		mld_sma = rtwvif->mac_addr;
1109		mld_tma = sta->addr;
1110		mld_bssid = rtwvif->mac_addr;
1111	} else {
1112		return;
1113	}
1114
1115	h2c->w8 = le32_encode_bits(mld_sma[0], DCTLINFO_V2_W8_MLD_SMA_0) |
1116		  le32_encode_bits(mld_sma[1], DCTLINFO_V2_W8_MLD_SMA_1) |
1117		  le32_encode_bits(mld_sma[2], DCTLINFO_V2_W8_MLD_SMA_2) |
1118		  le32_encode_bits(mld_sma[3], DCTLINFO_V2_W8_MLD_SMA_3);
1119	h2c->m8 = cpu_to_le32(DCTLINFO_V2_W8_ALL);
1120
1121	h2c->w9 = le32_encode_bits(mld_sma[4], DCTLINFO_V2_W9_MLD_SMA_4) |
1122		  le32_encode_bits(mld_sma[5], DCTLINFO_V2_W9_MLD_SMA_5) |
1123		  le32_encode_bits(mld_tma[0], DCTLINFO_V2_W9_MLD_TMA_0) |
1124		  le32_encode_bits(mld_tma[1], DCTLINFO_V2_W9_MLD_TMA_1);
1125	h2c->m9 = cpu_to_le32(DCTLINFO_V2_W9_ALL);
1126
1127	h2c->w10 = le32_encode_bits(mld_tma[2], DCTLINFO_V2_W10_MLD_TMA_2) |
1128		   le32_encode_bits(mld_tma[3], DCTLINFO_V2_W10_MLD_TMA_3) |
1129		   le32_encode_bits(mld_tma[4], DCTLINFO_V2_W10_MLD_TMA_4) |
1130		   le32_encode_bits(mld_tma[5], DCTLINFO_V2_W10_MLD_TMA_5);
1131	h2c->m10 = cpu_to_le32(DCTLINFO_V2_W10_ALL);
1132
1133	h2c->w11 = le32_encode_bits(mld_bssid[0], DCTLINFO_V2_W11_MLD_BSSID_0) |
1134		   le32_encode_bits(mld_bssid[1], DCTLINFO_V2_W11_MLD_BSSID_1) |
1135		   le32_encode_bits(mld_bssid[2], DCTLINFO_V2_W11_MLD_BSSID_2) |
1136		   le32_encode_bits(mld_bssid[3], DCTLINFO_V2_W11_MLD_BSSID_3);
1137	h2c->m11 = cpu_to_le32(DCTLINFO_V2_W11_ALL);
1138
1139	h2c->w12 = le32_encode_bits(mld_bssid[4], DCTLINFO_V2_W12_MLD_BSSID_4) |
1140		   le32_encode_bits(mld_bssid[5], DCTLINFO_V2_W12_MLD_BSSID_5);
1141	h2c->m12 = cpu_to_le32(DCTLINFO_V2_W12_ALL);
1142}