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 
10 static struct sk_buff *
11 rtw89_cam_get_sec_key_cmd(struct rtw89_dev *rtwdev,
12 			  struct rtw89_sec_cam_entry *sec_cam,
13 			  bool ext_key)
14 {
15 	struct sk_buff *skb;
16 	u32 cmd_len = H2C_SEC_CAM_LEN;
17 	u32 key32[4];
18 	u8 *cmd;
19 	int i, j;
20 
21 	skb = rtw89_fw_h2c_alloc_skb_with_hdr(cmd_len);
22 	if (!skb)
23 		return NULL;
24 
25 	skb_put_zero(skb, cmd_len);
26 
27 	for (i = 0; i < 4; i++) {
28 		j = i * 4;
29 		j += ext_key ? 16 : 0;
30 		key32[i] = FIELD_PREP(GENMASK(7, 0), sec_cam->key[j + 0]) |
31 			   FIELD_PREP(GENMASK(15, 8), sec_cam->key[j + 1]) |
32 			   FIELD_PREP(GENMASK(23, 16), sec_cam->key[j + 2]) |
33 			   FIELD_PREP(GENMASK(31, 24), sec_cam->key[j + 3]);
34 	}
35 
36 	cmd = skb->data;
37 	RTW89_SET_FWCMD_SEC_IDX(cmd, sec_cam->sec_cam_idx + (ext_key ? 1 : 0));
38 	RTW89_SET_FWCMD_SEC_OFFSET(cmd, sec_cam->offset);
39 	RTW89_SET_FWCMD_SEC_LEN(cmd, sec_cam->len);
40 	RTW89_SET_FWCMD_SEC_TYPE(cmd, sec_cam->type);
41 	RTW89_SET_FWCMD_SEC_EXT_KEY(cmd, ext_key);
42 	RTW89_SET_FWCMD_SEC_SPP_MODE(cmd, sec_cam->spp_mode);
43 	RTW89_SET_FWCMD_SEC_KEY0(cmd, key32[0]);
44 	RTW89_SET_FWCMD_SEC_KEY1(cmd, key32[1]);
45 	RTW89_SET_FWCMD_SEC_KEY2(cmd, key32[2]);
46 	RTW89_SET_FWCMD_SEC_KEY3(cmd, key32[3]);
47 
48 	return skb;
49 }
50 
51 static int rtw89_cam_send_sec_key_cmd(struct rtw89_dev *rtwdev,
52 				      struct rtw89_sec_cam_entry *sec_cam)
53 {
54 	struct sk_buff *skb, *ext_skb;
55 	int ret;
56 
57 	skb = rtw89_cam_get_sec_key_cmd(rtwdev, sec_cam, false);
58 	if (!skb) {
59 		rtw89_err(rtwdev, "failed to get sec key command\n");
60 		return -ENOMEM;
61 	}
62 
63 	rtw89_h2c_pkt_set_hdr(rtwdev, skb,
64 			      FWCMD_TYPE_H2C,
65 			      H2C_CAT_MAC,
66 			      H2C_CL_MAC_SEC_CAM,
67 			      H2C_FUNC_MAC_SEC_UPD, 1, 0,
68 			      H2C_SEC_CAM_LEN);
69 	ret = rtw89_h2c_tx(rtwdev, skb, false);
70 	if (ret) {
71 		rtw89_err(rtwdev, "failed to send sec key h2c: %d\n", ret);
72 		dev_kfree_skb(skb);
73 		return ret;
74 	}
75 
76 	if (!sec_cam->ext_key)
77 		return 0;
78 
79 	ext_skb = rtw89_cam_get_sec_key_cmd(rtwdev, sec_cam, true);
80 	if (!ext_skb) {
81 		rtw89_err(rtwdev, "failed to get ext sec key command\n");
82 		return -ENOMEM;
83 	}
84 
85 	rtw89_h2c_pkt_set_hdr(rtwdev, ext_skb,
86 			      FWCMD_TYPE_H2C,
87 			      H2C_CAT_MAC,
88 			      H2C_CL_MAC_SEC_CAM,
89 			      H2C_FUNC_MAC_SEC_UPD,
90 			      1, 0, H2C_SEC_CAM_LEN);
91 	ret = rtw89_h2c_tx(rtwdev, ext_skb, false);
92 	if (ret) {
93 		rtw89_err(rtwdev, "failed to send ext sec key h2c: %d\n", ret);
94 		dev_kfree_skb(ext_skb);
95 		return ret;
96 	}
97 
98 	return 0;
99 }
100 
101 static int rtw89_cam_get_avail_sec_cam(struct rtw89_dev *rtwdev,
102 				       u8 *sec_cam_idx, bool ext_key)
103 {
104 	const struct rtw89_chip_info *chip = rtwdev->chip;
105 	struct rtw89_cam_info *cam_info = &rtwdev->cam_info;
106 	u8 sec_cam_num = chip->scam_num;
107 	u8 idx = 0;
108 
109 	if (!ext_key) {
110 		idx = find_first_zero_bit(cam_info->sec_cam_map, sec_cam_num);
111 		if (idx >= sec_cam_num)
112 			return -EBUSY;
113 
114 		set_bit(idx, cam_info->sec_cam_map);
115 		*sec_cam_idx = idx;
116 
117 		return 0;
118 	}
119 
120 again:
121 	idx = find_next_zero_bit(cam_info->sec_cam_map, sec_cam_num, idx);
122 	if (idx >= sec_cam_num - 1)
123 		return -EBUSY;
124 	/* ext keys need two cam entries for 256-bit key */
125 	if (test_bit(idx + 1, cam_info->sec_cam_map)) {
126 		idx++;
127 		goto again;
128 	}
129 
130 	set_bit(idx, cam_info->sec_cam_map);
131 	set_bit(idx + 1, cam_info->sec_cam_map);
132 	*sec_cam_idx = idx;
133 
134 	return 0;
135 }
136 
137 static int rtw89_cam_get_addr_cam_key_idx(struct rtw89_addr_cam_entry *addr_cam,
138 					  struct rtw89_sec_cam_entry *sec_cam,
139 					  struct ieee80211_key_conf *key,
140 					  u8 *key_idx)
141 {
142 	u8 idx;
143 
144 	/* RTW89_ADDR_CAM_SEC_NONE	: not enabled
145 	 * RTW89_ADDR_CAM_SEC_ALL_UNI	: 0 - 6 unicast
146 	 * RTW89_ADDR_CAM_SEC_NORMAL	: 0 - 1 unicast, 2 - 4 group, 5 - 6 BIP
147 	 * RTW89_ADDR_CAM_SEC_4GROUP	: 0 - 1 unicast, 2 - 5 group, 6 BIP
148 	 */
149 	switch (addr_cam->sec_ent_mode) {
150 	case RTW89_ADDR_CAM_SEC_NONE:
151 		return -EINVAL;
152 	case RTW89_ADDR_CAM_SEC_ALL_UNI:
153 		if (!(key->flags & IEEE80211_KEY_FLAG_PAIRWISE))
154 			return -EINVAL;
155 		idx = find_first_zero_bit(addr_cam->sec_cam_map,
156 					  RTW89_SEC_CAM_IN_ADDR_CAM);
157 		if (idx >= RTW89_SEC_CAM_IN_ADDR_CAM)
158 			return -EBUSY;
159 		*key_idx = idx;
160 		break;
161 	case RTW89_ADDR_CAM_SEC_NORMAL:
162 		if (sec_cam->type == RTW89_SEC_KEY_TYPE_BIP_CCMP128) {
163 			idx = find_next_zero_bit(addr_cam->sec_cam_map,
164 						 RTW89_SEC_CAM_IN_ADDR_CAM, 5);
165 			if (idx > 6)
166 				return -EBUSY;
167 			*key_idx = idx;
168 			break;
169 		}
170 
171 		if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE) {
172 			idx = find_next_zero_bit(addr_cam->sec_cam_map,
173 						 RTW89_SEC_CAM_IN_ADDR_CAM, 0);
174 			if (idx > 1)
175 				return -EBUSY;
176 			*key_idx = idx;
177 			break;
178 		}
179 
180 		/* Group keys */
181 		idx = find_next_zero_bit(addr_cam->sec_cam_map,
182 					 RTW89_SEC_CAM_IN_ADDR_CAM, 2);
183 		if (idx > 4)
184 			return -EBUSY;
185 		*key_idx = idx;
186 		break;
187 	case RTW89_ADDR_CAM_SEC_4GROUP:
188 		if (sec_cam->type == RTW89_SEC_KEY_TYPE_BIP_CCMP128) {
189 			if (test_bit(6, addr_cam->sec_cam_map))
190 				return -EINVAL;
191 			*key_idx = 6;
192 			break;
193 		}
194 
195 		if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE) {
196 			idx = find_next_zero_bit(addr_cam->sec_cam_map,
197 						 RTW89_SEC_CAM_IN_ADDR_CAM, 0);
198 			if (idx > 1)
199 				return -EBUSY;
200 			*key_idx = idx;
201 			break;
202 		}
203 
204 		/* Group keys */
205 		idx = find_next_zero_bit(addr_cam->sec_cam_map,
206 					 RTW89_SEC_CAM_IN_ADDR_CAM, 2);
207 		if (idx > 5)
208 			return -EBUSY;
209 		*key_idx = idx;
210 		break;
211 	}
212 
213 	return 0;
214 }
215 
216 static int rtw89_cam_attach_sec_cam(struct rtw89_dev *rtwdev,
217 				    struct ieee80211_vif *vif,
218 				    struct ieee80211_sta *sta,
219 				    struct ieee80211_key_conf *key,
220 				    struct rtw89_sec_cam_entry *sec_cam)
221 {
222 	struct rtw89_sta *rtwsta = sta_to_rtwsta_safe(sta);
223 	struct rtw89_vif *rtwvif;
224 	struct rtw89_addr_cam_entry *addr_cam;
225 	u8 key_idx = 0;
226 	int ret;
227 
228 	if (!vif) {
229 		rtw89_err(rtwdev, "No iface for adding sec cam\n");
230 		return -EINVAL;
231 	}
232 
233 	rtwvif = (struct rtw89_vif *)vif->drv_priv;
234 	addr_cam = rtw89_get_addr_cam_of(rtwvif, rtwsta);
235 	ret = rtw89_cam_get_addr_cam_key_idx(addr_cam, sec_cam, key, &key_idx);
236 	if (ret) {
237 		rtw89_err(rtwdev, "failed to get addr cam key idx %d, %d\n",
238 			  addr_cam->sec_ent_mode, sec_cam->type);
239 		return ret;
240 	}
241 
242 	key->hw_key_idx = key_idx;
243 	addr_cam->sec_ent_keyid[key_idx] = key->keyidx;
244 	addr_cam->sec_ent[key_idx] = sec_cam->sec_cam_idx;
245 	addr_cam->sec_entries[key_idx] = sec_cam;
246 	set_bit(key_idx, addr_cam->sec_cam_map);
247 	ret = rtw89_fw_h2c_cam(rtwdev, rtwvif, rtwsta, NULL);
248 	if (ret) {
249 		rtw89_err(rtwdev, "failed to update addr cam sec entry: %d\n",
250 			  ret);
251 		clear_bit(key_idx, addr_cam->sec_cam_map);
252 		addr_cam->sec_entries[key_idx] = NULL;
253 		return ret;
254 	}
255 
256 	return 0;
257 }
258 
259 static int rtw89_cam_sec_key_install(struct rtw89_dev *rtwdev,
260 				     struct ieee80211_vif *vif,
261 				     struct ieee80211_sta *sta,
262 				     struct ieee80211_key_conf *key,
263 				     u8 hw_key_type, bool ext_key)
264 {
265 	struct rtw89_sec_cam_entry *sec_cam = NULL;
266 	struct rtw89_cam_info *cam_info = &rtwdev->cam_info;
267 	u8 sec_cam_idx;
268 	int ret;
269 
270 	/* maximum key length 256-bit */
271 	if (key->keylen > 32) {
272 		rtw89_err(rtwdev, "invalid sec key length %d\n", key->keylen);
273 		return -EINVAL;
274 	}
275 
276 	ret = rtw89_cam_get_avail_sec_cam(rtwdev, &sec_cam_idx, ext_key);
277 	if (ret) {
278 		rtw89_warn(rtwdev, "no available sec cam: %d ext: %d\n",
279 			   ret, ext_key);
280 		return ret;
281 	}
282 
283 	sec_cam = kzalloc(sizeof(*sec_cam), GFP_KERNEL);
284 	if (!sec_cam) {
285 		ret = -ENOMEM;
286 		goto err_release_cam;
287 	}
288 
289 	sec_cam->sec_cam_idx = sec_cam_idx;
290 	sec_cam->type = hw_key_type;
291 	sec_cam->len = RTW89_SEC_CAM_LEN;
292 	sec_cam->ext_key = ext_key;
293 	memcpy(sec_cam->key, key->key, key->keylen);
294 	ret = rtw89_cam_send_sec_key_cmd(rtwdev, sec_cam);
295 	if (ret) {
296 		rtw89_err(rtwdev, "failed to send sec key cmd: %d\n", ret);
297 		goto err_release_cam;
298 	}
299 
300 	/* associate with addr cam */
301 	ret = rtw89_cam_attach_sec_cam(rtwdev, vif, sta, key, sec_cam);
302 	if (ret) {
303 		rtw89_err(rtwdev, "failed to attach sec cam: %d\n", ret);
304 		goto err_release_cam;
305 	}
306 
307 	return 0;
308 
309 err_release_cam:
310 	kfree(sec_cam);
311 	clear_bit(sec_cam_idx, cam_info->sec_cam_map);
312 	if (ext_key)
313 		clear_bit(sec_cam_idx + 1, cam_info->sec_cam_map);
314 
315 	return ret;
316 }
317 
318 int rtw89_cam_sec_key_add(struct rtw89_dev *rtwdev,
319 			  struct ieee80211_vif *vif,
320 			  struct ieee80211_sta *sta,
321 			  struct ieee80211_key_conf *key)
322 {
323 	u8 hw_key_type;
324 	bool ext_key = false;
325 	int ret;
326 
327 	switch (key->cipher) {
328 	case WLAN_CIPHER_SUITE_WEP40:
329 		hw_key_type = RTW89_SEC_KEY_TYPE_WEP40;
330 		break;
331 	case WLAN_CIPHER_SUITE_WEP104:
332 		hw_key_type = RTW89_SEC_KEY_TYPE_WEP104;
333 		break;
334 	case WLAN_CIPHER_SUITE_CCMP:
335 		hw_key_type = RTW89_SEC_KEY_TYPE_CCMP128;
336 		key->flags |= IEEE80211_KEY_FLAG_SW_MGMT_TX;
337 		break;
338 	case WLAN_CIPHER_SUITE_CCMP_256:
339 		hw_key_type = RTW89_SEC_KEY_TYPE_CCMP256;
340 		key->flags |= IEEE80211_KEY_FLAG_SW_MGMT_TX;
341 		ext_key = true;
342 		break;
343 	case WLAN_CIPHER_SUITE_GCMP:
344 		hw_key_type = RTW89_SEC_KEY_TYPE_GCMP128;
345 		key->flags |= IEEE80211_KEY_FLAG_SW_MGMT_TX;
346 		break;
347 	case WLAN_CIPHER_SUITE_GCMP_256:
348 		hw_key_type = RTW89_SEC_KEY_TYPE_GCMP256;
349 		key->flags |= IEEE80211_KEY_FLAG_SW_MGMT_TX;
350 		ext_key = true;
351 		break;
352 	default:
353 		return -EOPNOTSUPP;
354 	}
355 
356 	key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
357 
358 	ret = rtw89_cam_sec_key_install(rtwdev, vif, sta, key, hw_key_type,
359 					ext_key);
360 	if (ret) {
361 		rtw89_err(rtwdev, "failed to install key type %d ext %d: %d\n",
362 			  hw_key_type, ext_key, ret);
363 		return ret;
364 	}
365 
366 	return 0;
367 }
368 
369 int rtw89_cam_sec_key_del(struct rtw89_dev *rtwdev,
370 			  struct ieee80211_vif *vif,
371 			  struct ieee80211_sta *sta,
372 			  struct ieee80211_key_conf *key,
373 			  bool inform_fw)
374 {
375 	struct rtw89_sta *rtwsta = sta_to_rtwsta_safe(sta);
376 	struct rtw89_cam_info *cam_info = &rtwdev->cam_info;
377 	struct rtw89_vif *rtwvif;
378 	struct rtw89_addr_cam_entry *addr_cam;
379 	struct rtw89_sec_cam_entry *sec_cam;
380 	u8 key_idx = key->hw_key_idx;
381 	u8 sec_cam_idx;
382 	int ret = 0;
383 
384 	if (!vif) {
385 		rtw89_err(rtwdev, "No iface for deleting sec cam\n");
386 		return -EINVAL;
387 	}
388 
389 	rtwvif = (struct rtw89_vif *)vif->drv_priv;
390 	addr_cam = rtw89_get_addr_cam_of(rtwvif, rtwsta);
391 	sec_cam = addr_cam->sec_entries[key_idx];
392 	if (!sec_cam)
393 		return -EINVAL;
394 
395 	/* detach sec cam from addr cam */
396 	clear_bit(key_idx, addr_cam->sec_cam_map);
397 	addr_cam->sec_entries[key_idx] = NULL;
398 	if (inform_fw) {
399 		ret = rtw89_fw_h2c_cam(rtwdev, rtwvif, rtwsta, NULL);
400 		if (ret)
401 			rtw89_err(rtwdev, "failed to update cam del key: %d\n", ret);
402 	}
403 
404 	/* clear valid bit in addr cam will disable sec cam,
405 	 * so we don't need to send H2C command again
406 	 */
407 	sec_cam_idx = sec_cam->sec_cam_idx;
408 	clear_bit(sec_cam_idx, cam_info->sec_cam_map);
409 	if (sec_cam->ext_key)
410 		clear_bit(sec_cam_idx + 1, cam_info->sec_cam_map);
411 
412 	kfree(sec_cam);
413 
414 	return ret;
415 }
416 
417 static void rtw89_cam_reset_key_iter(struct ieee80211_hw *hw,
418 				     struct ieee80211_vif *vif,
419 				     struct ieee80211_sta *sta,
420 				     struct ieee80211_key_conf *key,
421 				     void *data)
422 {
423 	struct rtw89_dev *rtwdev = (struct rtw89_dev *)data;
424 	struct rtw89_vif *rtwvif = (struct rtw89_vif *)vif->drv_priv;
425 
426 	rtw89_cam_sec_key_del(rtwdev, vif, sta, key, false);
427 	rtw89_cam_deinit(rtwdev, rtwvif);
428 }
429 
430 void rtw89_cam_deinit_addr_cam(struct rtw89_dev *rtwdev,
431 			       struct rtw89_addr_cam_entry *addr_cam)
432 {
433 	struct rtw89_cam_info *cam_info = &rtwdev->cam_info;
434 
435 	addr_cam->valid = false;
436 	clear_bit(addr_cam->addr_cam_idx, cam_info->addr_cam_map);
437 }
438 
439 void rtw89_cam_deinit(struct rtw89_dev *rtwdev, struct rtw89_vif *rtwvif)
440 {
441 	struct rtw89_cam_info *cam_info = &rtwdev->cam_info;
442 	struct rtw89_addr_cam_entry *addr_cam = &rtwvif->addr_cam;
443 	struct rtw89_bssid_cam_entry *bssid_cam = &rtwvif->bssid_cam;
444 
445 	rtw89_cam_deinit_addr_cam(rtwdev, addr_cam);
446 	bssid_cam->valid = false;
447 	clear_bit(bssid_cam->bssid_cam_idx, cam_info->bssid_cam_map);
448 }
449 
450 void rtw89_cam_reset_keys(struct rtw89_dev *rtwdev)
451 {
452 	rcu_read_lock();
453 	ieee80211_iter_keys_rcu(rtwdev->hw, NULL, rtw89_cam_reset_key_iter, rtwdev);
454 	rcu_read_unlock();
455 }
456 
457 static int rtw89_cam_get_avail_addr_cam(struct rtw89_dev *rtwdev,
458 					u8 *addr_cam_idx)
459 {
460 	const struct rtw89_chip_info *chip = rtwdev->chip;
461 	struct rtw89_cam_info *cam_info = &rtwdev->cam_info;
462 	u8 addr_cam_num = chip->acam_num;
463 	u8 idx;
464 
465 	idx = find_first_zero_bit(cam_info->addr_cam_map, addr_cam_num);
466 	if (idx >= addr_cam_num)
467 		return -EBUSY;
468 
469 	set_bit(idx, cam_info->addr_cam_map);
470 	*addr_cam_idx = idx;
471 
472 	return 0;
473 }
474 
475 int rtw89_cam_init_addr_cam(struct rtw89_dev *rtwdev,
476 			    struct rtw89_addr_cam_entry *addr_cam,
477 			    const struct rtw89_bssid_cam_entry *bssid_cam)
478 {
479 	u8 addr_cam_idx;
480 	int i;
481 	int ret;
482 
483 	ret = rtw89_cam_get_avail_addr_cam(rtwdev, &addr_cam_idx);
484 	if (ret) {
485 		rtw89_err(rtwdev, "failed to get available addr cam\n");
486 		return ret;
487 	}
488 
489 	addr_cam->addr_cam_idx = addr_cam_idx;
490 	addr_cam->len = ADDR_CAM_ENT_SIZE;
491 	addr_cam->offset = 0;
492 	addr_cam->valid = true;
493 	addr_cam->addr_mask = 0;
494 	addr_cam->mask_sel = RTW89_NO_MSK;
495 	addr_cam->sec_ent_mode = RTW89_ADDR_CAM_SEC_NORMAL;
496 	bitmap_zero(addr_cam->sec_cam_map, RTW89_SEC_CAM_IN_ADDR_CAM);
497 
498 	for (i = 0; i < RTW89_SEC_CAM_IN_ADDR_CAM; i++) {
499 		addr_cam->sec_ent_keyid[i] = 0;
500 		addr_cam->sec_ent[i] = 0;
501 	}
502 
503 	/* associate addr cam with bssid cam */
504 	addr_cam->bssid_cam_idx = bssid_cam->bssid_cam_idx;
505 
506 	return 0;
507 }
508 
509 static int rtw89_cam_get_avail_bssid_cam(struct rtw89_dev *rtwdev,
510 					 u8 *bssid_cam_idx)
511 {
512 	const struct rtw89_chip_info *chip = rtwdev->chip;
513 	struct rtw89_cam_info *cam_info = &rtwdev->cam_info;
514 	u8 bssid_cam_num = chip->bcam_num;
515 	u8 idx;
516 
517 	idx = find_first_zero_bit(cam_info->bssid_cam_map, bssid_cam_num);
518 	if (idx >= bssid_cam_num)
519 		return -EBUSY;
520 
521 	set_bit(idx, cam_info->bssid_cam_map);
522 	*bssid_cam_idx = idx;
523 
524 	return 0;
525 }
526 
527 static int rtw89_cam_init_bssid_cam(struct rtw89_dev *rtwdev,
528 				    struct rtw89_vif *rtwvif)
529 {
530 	struct rtw89_bssid_cam_entry *bssid_cam = &rtwvif->bssid_cam;
531 	u8 bssid_cam_idx;
532 	int ret;
533 
534 	ret = rtw89_cam_get_avail_bssid_cam(rtwdev, &bssid_cam_idx);
535 	if (ret) {
536 		rtw89_err(rtwdev, "failed to get available bssid cam\n");
537 		return ret;
538 	}
539 
540 	bssid_cam->bssid_cam_idx = bssid_cam_idx;
541 	bssid_cam->phy_idx = rtwvif->phy_idx;
542 	bssid_cam->len = BSSID_CAM_ENT_SIZE;
543 	bssid_cam->offset = 0;
544 	bssid_cam->valid = true;
545 	ether_addr_copy(bssid_cam->bssid, rtwvif->bssid);
546 
547 	return 0;
548 }
549 
550 void rtw89_cam_bssid_changed(struct rtw89_dev *rtwdev, struct rtw89_vif *rtwvif)
551 {
552 	struct rtw89_bssid_cam_entry *bssid_cam = &rtwvif->bssid_cam;
553 
554 	ether_addr_copy(bssid_cam->bssid, rtwvif->bssid);
555 }
556 
557 int rtw89_cam_init(struct rtw89_dev *rtwdev, struct rtw89_vif *rtwvif)
558 {
559 	struct rtw89_addr_cam_entry *addr_cam = &rtwvif->addr_cam;
560 	struct rtw89_bssid_cam_entry *bssid_cam = &rtwvif->bssid_cam;
561 	int ret;
562 
563 	ret = rtw89_cam_init_bssid_cam(rtwdev, rtwvif);
564 	if (ret) {
565 		rtw89_err(rtwdev, "failed to init bssid cam\n");
566 		return ret;
567 	}
568 
569 	ret = rtw89_cam_init_addr_cam(rtwdev, addr_cam, bssid_cam);
570 	if (ret) {
571 		rtw89_err(rtwdev, "failed to init addr cam\n");
572 		return ret;
573 	}
574 
575 	return 0;
576 }
577 
578 int rtw89_cam_fill_bssid_cam_info(struct rtw89_dev *rtwdev,
579 				  struct rtw89_vif *rtwvif, u8 *cmd)
580 {
581 	struct ieee80211_vif *vif = rtwvif_to_vif(rtwvif);
582 	struct rtw89_bssid_cam_entry *bssid_cam = &rtwvif->bssid_cam;
583 	u8 bss_color = vif->bss_conf.he_bss_color.color;
584 
585 	FWCMD_SET_ADDR_BSSID_IDX(cmd, bssid_cam->bssid_cam_idx);
586 	FWCMD_SET_ADDR_BSSID_OFFSET(cmd, bssid_cam->offset);
587 	FWCMD_SET_ADDR_BSSID_LEN(cmd, bssid_cam->len);
588 	FWCMD_SET_ADDR_BSSID_VALID(cmd, bssid_cam->valid);
589 	FWCMD_SET_ADDR_BSSID_BB_SEL(cmd, bssid_cam->phy_idx);
590 	FWCMD_SET_ADDR_BSSID_BSS_COLOR(cmd, bss_color);
591 
592 	FWCMD_SET_ADDR_BSSID_BSSID0(cmd, bssid_cam->bssid[0]);
593 	FWCMD_SET_ADDR_BSSID_BSSID1(cmd, bssid_cam->bssid[1]);
594 	FWCMD_SET_ADDR_BSSID_BSSID2(cmd, bssid_cam->bssid[2]);
595 	FWCMD_SET_ADDR_BSSID_BSSID3(cmd, bssid_cam->bssid[3]);
596 	FWCMD_SET_ADDR_BSSID_BSSID4(cmd, bssid_cam->bssid[4]);
597 	FWCMD_SET_ADDR_BSSID_BSSID5(cmd, bssid_cam->bssid[5]);
598 
599 	return 0;
600 }
601 
602 static u8 rtw89_cam_addr_hash(u8 start, const u8 *addr)
603 {
604 	u8 hash = 0;
605 	u8 i;
606 
607 	for (i = start; i < ETH_ALEN; i++)
608 		hash ^= addr[i];
609 
610 	return hash;
611 }
612 
613 void rtw89_cam_fill_addr_cam_info(struct rtw89_dev *rtwdev,
614 				  struct rtw89_vif *rtwvif,
615 				  struct rtw89_sta *rtwsta,
616 				  const u8 *scan_mac_addr,
617 				  u8 *cmd)
618 {
619 	struct ieee80211_vif *vif = rtwvif_to_vif(rtwvif);
620 	struct rtw89_addr_cam_entry *addr_cam = rtw89_get_addr_cam_of(rtwvif, rtwsta);
621 	struct ieee80211_sta *sta = rtwsta_to_sta_safe(rtwsta);
622 	const u8 *sma = scan_mac_addr ? scan_mac_addr : rtwvif->mac_addr;
623 	u8 sma_hash, tma_hash, addr_msk_start;
624 	u8 sma_start = 0;
625 	u8 tma_start = 0;
626 	u8 *tma = sta ? sta->addr : rtwvif->bssid;
627 
628 	if (addr_cam->addr_mask != 0) {
629 		addr_msk_start = __ffs(addr_cam->addr_mask);
630 		if (addr_cam->mask_sel == RTW89_SMA)
631 			sma_start = addr_msk_start;
632 		else if (addr_cam->mask_sel == RTW89_TMA)
633 			tma_start = addr_msk_start;
634 	}
635 	sma_hash = rtw89_cam_addr_hash(sma_start, sma);
636 	tma_hash = rtw89_cam_addr_hash(tma_start, tma);
637 
638 	FWCMD_SET_ADDR_IDX(cmd, addr_cam->addr_cam_idx);
639 	FWCMD_SET_ADDR_OFFSET(cmd, addr_cam->offset);
640 	FWCMD_SET_ADDR_LEN(cmd, addr_cam->len);
641 
642 	FWCMD_SET_ADDR_VALID(cmd, addr_cam->valid);
643 	FWCMD_SET_ADDR_NET_TYPE(cmd, rtwvif->net_type);
644 	FWCMD_SET_ADDR_BCN_HIT_COND(cmd, rtwvif->bcn_hit_cond);
645 	FWCMD_SET_ADDR_HIT_RULE(cmd, rtwvif->hit_rule);
646 	FWCMD_SET_ADDR_BB_SEL(cmd, rtwvif->phy_idx);
647 	FWCMD_SET_ADDR_ADDR_MASK(cmd, addr_cam->addr_mask);
648 	FWCMD_SET_ADDR_MASK_SEL(cmd, addr_cam->mask_sel);
649 	FWCMD_SET_ADDR_SMA_HASH(cmd, sma_hash);
650 	FWCMD_SET_ADDR_TMA_HASH(cmd, tma_hash);
651 
652 	FWCMD_SET_ADDR_BSSID_CAM_IDX(cmd, addr_cam->bssid_cam_idx);
653 
654 	FWCMD_SET_ADDR_SMA0(cmd, sma[0]);
655 	FWCMD_SET_ADDR_SMA1(cmd, sma[1]);
656 	FWCMD_SET_ADDR_SMA2(cmd, sma[2]);
657 	FWCMD_SET_ADDR_SMA3(cmd, sma[3]);
658 	FWCMD_SET_ADDR_SMA4(cmd, sma[4]);
659 	FWCMD_SET_ADDR_SMA5(cmd, sma[5]);
660 
661 	FWCMD_SET_ADDR_TMA0(cmd, tma[0]);
662 	FWCMD_SET_ADDR_TMA1(cmd, tma[1]);
663 	FWCMD_SET_ADDR_TMA2(cmd, tma[2]);
664 	FWCMD_SET_ADDR_TMA3(cmd, tma[3]);
665 	FWCMD_SET_ADDR_TMA4(cmd, tma[4]);
666 	FWCMD_SET_ADDR_TMA5(cmd, tma[5]);
667 
668 	FWCMD_SET_ADDR_PORT_INT(cmd, rtwvif->port);
669 	FWCMD_SET_ADDR_TSF_SYNC(cmd, rtwvif->port);
670 	FWCMD_SET_ADDR_TF_TRS(cmd, rtwvif->trigger);
671 	FWCMD_SET_ADDR_LSIG_TXOP(cmd, rtwvif->lsig_txop);
672 	FWCMD_SET_ADDR_TGT_IND(cmd, rtwvif->tgt_ind);
673 	FWCMD_SET_ADDR_FRM_TGT_IND(cmd, rtwvif->frm_tgt_ind);
674 	FWCMD_SET_ADDR_MACID(cmd, rtwsta ? rtwsta->mac_id : rtwvif->mac_id);
675 	if (rtwvif->net_type == RTW89_NET_TYPE_INFRA)
676 		FWCMD_SET_ADDR_AID12(cmd, vif->bss_conf.aid & 0xfff);
677 	else if (rtwvif->net_type == RTW89_NET_TYPE_AP_MODE)
678 		FWCMD_SET_ADDR_AID12(cmd, sta ? sta->aid & 0xfff : 0);
679 	FWCMD_SET_ADDR_WOL_PATTERN(cmd, rtwvif->wowlan_pattern);
680 	FWCMD_SET_ADDR_WOL_UC(cmd, rtwvif->wowlan_uc);
681 	FWCMD_SET_ADDR_WOL_MAGIC(cmd, rtwvif->wowlan_magic);
682 	FWCMD_SET_ADDR_WAPI(cmd, addr_cam->wapi);
683 	FWCMD_SET_ADDR_SEC_ENT_MODE(cmd, addr_cam->sec_ent_mode);
684 	FWCMD_SET_ADDR_SEC_ENT0_KEYID(cmd, addr_cam->sec_ent_keyid[0]);
685 	FWCMD_SET_ADDR_SEC_ENT1_KEYID(cmd, addr_cam->sec_ent_keyid[1]);
686 	FWCMD_SET_ADDR_SEC_ENT2_KEYID(cmd, addr_cam->sec_ent_keyid[2]);
687 	FWCMD_SET_ADDR_SEC_ENT3_KEYID(cmd, addr_cam->sec_ent_keyid[3]);
688 	FWCMD_SET_ADDR_SEC_ENT4_KEYID(cmd, addr_cam->sec_ent_keyid[4]);
689 	FWCMD_SET_ADDR_SEC_ENT5_KEYID(cmd, addr_cam->sec_ent_keyid[5]);
690 	FWCMD_SET_ADDR_SEC_ENT6_KEYID(cmd, addr_cam->sec_ent_keyid[6]);
691 
692 	FWCMD_SET_ADDR_SEC_ENT_VALID(cmd, addr_cam->sec_cam_map[0] & 0xff);
693 	FWCMD_SET_ADDR_SEC_ENT0(cmd, addr_cam->sec_ent[0]);
694 	FWCMD_SET_ADDR_SEC_ENT1(cmd, addr_cam->sec_ent[1]);
695 	FWCMD_SET_ADDR_SEC_ENT2(cmd, addr_cam->sec_ent[2]);
696 	FWCMD_SET_ADDR_SEC_ENT3(cmd, addr_cam->sec_ent[3]);
697 	FWCMD_SET_ADDR_SEC_ENT4(cmd, addr_cam->sec_ent[4]);
698 	FWCMD_SET_ADDR_SEC_ENT5(cmd, addr_cam->sec_ent[5]);
699 	FWCMD_SET_ADDR_SEC_ENT6(cmd, addr_cam->sec_ent[6]);
700 }
701