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
10static struct sk_buff *
11rtw89_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(rtwdev, len: cmd_len);
22 if (!skb)
23 return NULL;
24
25 skb_put_zero(skb, len: 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, val: sec_cam->sec_cam_idx + (ext_key ? 1 : 0));
38 RTW89_SET_FWCMD_SEC_OFFSET(cmd, val: sec_cam->offset);
39 RTW89_SET_FWCMD_SEC_LEN(cmd, val: sec_cam->len);
40 RTW89_SET_FWCMD_SEC_TYPE(cmd, val: sec_cam->type);
41 RTW89_SET_FWCMD_SEC_EXT_KEY(cmd, val: ext_key);
42 RTW89_SET_FWCMD_SEC_SPP_MODE(cmd, val: sec_cam->spp_mode);
43 RTW89_SET_FWCMD_SEC_KEY0(cmd, val: key32[0]);
44 RTW89_SET_FWCMD_SEC_KEY1(cmd, val: key32[1]);
45 RTW89_SET_FWCMD_SEC_KEY2(cmd, val: key32[2]);
46 RTW89_SET_FWCMD_SEC_KEY3(cmd, val: key32[3]);
47
48 return skb;
49}
50
51static 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, ext_key: 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, rack: 1, dack: 0,
68 H2C_SEC_CAM_LEN);
69 ret = rtw89_h2c_tx(rtwdev, skb, fwdl: 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, ext_key: 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, skb: ext_skb,
86 FWCMD_TYPE_H2C,
87 H2C_CAT_MAC,
88 H2C_CL_MAC_SEC_CAM,
89 H2C_FUNC_MAC_SEC_UPD,
90 rack: 1, dack: 0, H2C_SEC_CAM_LEN);
91 ret = rtw89_h2c_tx(rtwdev, skb: ext_skb, fwdl: 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
101static 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(addr: cam_info->sec_cam_map, size: sec_cam_num);
111 if (idx >= sec_cam_num)
112 return -EBUSY;
113
114 set_bit(nr: idx, addr: cam_info->sec_cam_map);
115 *sec_cam_idx = idx;
116
117 return 0;
118 }
119
120again:
121 idx = find_next_zero_bit(addr: cam_info->sec_cam_map, size: sec_cam_num, offset: 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(nr: idx, addr: cam_info->sec_cam_map);
131 set_bit(nr: idx + 1, addr: cam_info->sec_cam_map);
132 *sec_cam_idx = idx;
133
134 return 0;
135}
136
137static 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: 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: addr_cam->sec_cam_map,
164 RTW89_SEC_CAM_IN_ADDR_CAM, offset: 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: addr_cam->sec_cam_map,
173 RTW89_SEC_CAM_IN_ADDR_CAM, offset: 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: addr_cam->sec_cam_map,
182 RTW89_SEC_CAM_IN_ADDR_CAM, offset: 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: addr_cam->sec_cam_map,
197 RTW89_SEC_CAM_IN_ADDR_CAM, offset: 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: addr_cam->sec_cam_map,
206 RTW89_SEC_CAM_IN_ADDR_CAM, offset: 2);
207 if (idx > 5)
208 return -EBUSY;
209 *key_idx = idx;
210 break;
211 }
212
213 return 0;
214}
215
216static 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: &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(nr: key_idx, addr: addr_cam->sec_cam_map);
247 ret = rtw89_chip_h2c_dctl_sec_cam(rtwdev, rtwvif, rtwsta);
248 if (ret) {
249 rtw89_err(rtwdev, "failed to update dctl cam sec entry: %d\n",
250 ret);
251 return ret;
252 }
253 ret = rtw89_fw_h2c_cam(rtwdev, vif: rtwvif, rtwsta, NULL);
254 if (ret) {
255 rtw89_err(rtwdev, "failed to update addr cam sec entry: %d\n",
256 ret);
257 clear_bit(nr: key_idx, addr: addr_cam->sec_cam_map);
258 addr_cam->sec_entries[key_idx] = NULL;
259 return ret;
260 }
261
262 return 0;
263}
264
265static int rtw89_cam_sec_key_install(struct rtw89_dev *rtwdev,
266 struct ieee80211_vif *vif,
267 struct ieee80211_sta *sta,
268 struct ieee80211_key_conf *key,
269 u8 hw_key_type, bool ext_key)
270{
271 struct rtw89_sec_cam_entry *sec_cam = NULL;
272 struct rtw89_cam_info *cam_info = &rtwdev->cam_info;
273 u8 sec_cam_idx;
274 int ret;
275
276 /* maximum key length 256-bit */
277 if (key->keylen > 32) {
278 rtw89_err(rtwdev, "invalid sec key length %d\n", key->keylen);
279 return -EINVAL;
280 }
281
282 ret = rtw89_cam_get_avail_sec_cam(rtwdev, sec_cam_idx: &sec_cam_idx, ext_key);
283 if (ret) {
284 rtw89_warn(rtwdev, "no available sec cam: %d ext: %d\n",
285 ret, ext_key);
286 return ret;
287 }
288
289 sec_cam = kzalloc(size: sizeof(*sec_cam), GFP_KERNEL);
290 if (!sec_cam) {
291 ret = -ENOMEM;
292 goto err_release_cam;
293 }
294
295 sec_cam->sec_cam_idx = sec_cam_idx;
296 sec_cam->type = hw_key_type;
297 sec_cam->len = RTW89_SEC_CAM_LEN;
298 sec_cam->ext_key = ext_key;
299 memcpy(sec_cam->key, key->key, key->keylen);
300 ret = rtw89_cam_send_sec_key_cmd(rtwdev, sec_cam);
301 if (ret) {
302 rtw89_err(rtwdev, "failed to send sec key cmd: %d\n", ret);
303 goto err_release_cam;
304 }
305
306 /* associate with addr cam */
307 ret = rtw89_cam_attach_sec_cam(rtwdev, vif, sta, key, sec_cam);
308 if (ret) {
309 rtw89_err(rtwdev, "failed to attach sec cam: %d\n", ret);
310 goto err_release_cam;
311 }
312
313 return 0;
314
315err_release_cam:
316 kfree(objp: sec_cam);
317 clear_bit(nr: sec_cam_idx, addr: cam_info->sec_cam_map);
318 if (ext_key)
319 clear_bit(nr: sec_cam_idx + 1, addr: cam_info->sec_cam_map);
320
321 return ret;
322}
323
324int rtw89_cam_sec_key_add(struct rtw89_dev *rtwdev,
325 struct ieee80211_vif *vif,
326 struct ieee80211_sta *sta,
327 struct ieee80211_key_conf *key)
328{
329 const struct rtw89_chip_info *chip = rtwdev->chip;
330 u8 hw_key_type;
331 bool ext_key = false;
332 int ret;
333
334 switch (key->cipher) {
335 case WLAN_CIPHER_SUITE_WEP40:
336 hw_key_type = RTW89_SEC_KEY_TYPE_WEP40;
337 break;
338 case WLAN_CIPHER_SUITE_WEP104:
339 hw_key_type = RTW89_SEC_KEY_TYPE_WEP104;
340 break;
341 case WLAN_CIPHER_SUITE_CCMP:
342 hw_key_type = RTW89_SEC_KEY_TYPE_CCMP128;
343 key->flags |= IEEE80211_KEY_FLAG_SW_MGMT_TX;
344 break;
345 case WLAN_CIPHER_SUITE_CCMP_256:
346 hw_key_type = RTW89_SEC_KEY_TYPE_CCMP256;
347 key->flags |= IEEE80211_KEY_FLAG_SW_MGMT_TX;
348 ext_key = true;
349 break;
350 case WLAN_CIPHER_SUITE_GCMP:
351 hw_key_type = RTW89_SEC_KEY_TYPE_GCMP128;
352 key->flags |= IEEE80211_KEY_FLAG_SW_MGMT_TX;
353 break;
354 case WLAN_CIPHER_SUITE_GCMP_256:
355 hw_key_type = RTW89_SEC_KEY_TYPE_GCMP256;
356 key->flags |= IEEE80211_KEY_FLAG_SW_MGMT_TX;
357 ext_key = true;
358 break;
359 default:
360 return -EOPNOTSUPP;
361 }
362
363 if (!chip->hw_sec_hdr)
364 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
365
366 ret = rtw89_cam_sec_key_install(rtwdev, vif, sta, key, hw_key_type,
367 ext_key);
368 if (ret) {
369 rtw89_err(rtwdev, "failed to install key type %d ext %d: %d\n",
370 hw_key_type, ext_key, ret);
371 return ret;
372 }
373
374 return 0;
375}
376
377int rtw89_cam_sec_key_del(struct rtw89_dev *rtwdev,
378 struct ieee80211_vif *vif,
379 struct ieee80211_sta *sta,
380 struct ieee80211_key_conf *key,
381 bool inform_fw)
382{
383 struct rtw89_sta *rtwsta = sta_to_rtwsta_safe(sta);
384 struct rtw89_cam_info *cam_info = &rtwdev->cam_info;
385 struct rtw89_vif *rtwvif;
386 struct rtw89_addr_cam_entry *addr_cam;
387 struct rtw89_sec_cam_entry *sec_cam;
388 u8 key_idx = key->hw_key_idx;
389 u8 sec_cam_idx;
390 int ret = 0;
391
392 if (!vif) {
393 rtw89_err(rtwdev, "No iface for deleting sec cam\n");
394 return -EINVAL;
395 }
396
397 rtwvif = (struct rtw89_vif *)vif->drv_priv;
398 addr_cam = rtw89_get_addr_cam_of(rtwvif, rtwsta);
399 sec_cam = addr_cam->sec_entries[key_idx];
400 if (!sec_cam)
401 return -EINVAL;
402
403 /* detach sec cam from addr cam */
404 clear_bit(nr: key_idx, addr: addr_cam->sec_cam_map);
405 addr_cam->sec_entries[key_idx] = NULL;
406 if (inform_fw) {
407 ret = rtw89_chip_h2c_dctl_sec_cam(rtwdev, rtwvif, rtwsta);
408 if (ret)
409 rtw89_err(rtwdev, "failed to update dctl cam del key: %d\n", ret);
410 ret = rtw89_fw_h2c_cam(rtwdev, vif: rtwvif, rtwsta, NULL);
411 if (ret)
412 rtw89_err(rtwdev, "failed to update cam del key: %d\n", ret);
413 }
414
415 /* clear valid bit in addr cam will disable sec cam,
416 * so we don't need to send H2C command again
417 */
418 sec_cam_idx = sec_cam->sec_cam_idx;
419 clear_bit(nr: sec_cam_idx, addr: cam_info->sec_cam_map);
420 if (sec_cam->ext_key)
421 clear_bit(nr: sec_cam_idx + 1, addr: cam_info->sec_cam_map);
422
423 kfree(objp: sec_cam);
424
425 return ret;
426}
427
428static void rtw89_cam_reset_key_iter(struct ieee80211_hw *hw,
429 struct ieee80211_vif *vif,
430 struct ieee80211_sta *sta,
431 struct ieee80211_key_conf *key,
432 void *data)
433{
434 struct rtw89_dev *rtwdev = (struct rtw89_dev *)data;
435
436 rtw89_cam_sec_key_del(rtwdev, vif, sta, key, inform_fw: false);
437}
438
439void rtw89_cam_deinit_addr_cam(struct rtw89_dev *rtwdev,
440 struct rtw89_addr_cam_entry *addr_cam)
441{
442 struct rtw89_cam_info *cam_info = &rtwdev->cam_info;
443
444 addr_cam->valid = false;
445 clear_bit(nr: addr_cam->addr_cam_idx, addr: cam_info->addr_cam_map);
446}
447
448void rtw89_cam_deinit_bssid_cam(struct rtw89_dev *rtwdev,
449 struct rtw89_bssid_cam_entry *bssid_cam)
450{
451 struct rtw89_cam_info *cam_info = &rtwdev->cam_info;
452
453 bssid_cam->valid = false;
454 clear_bit(nr: bssid_cam->bssid_cam_idx, addr: cam_info->bssid_cam_map);
455}
456
457void rtw89_cam_deinit(struct rtw89_dev *rtwdev, struct rtw89_vif *rtwvif)
458{
459 struct rtw89_addr_cam_entry *addr_cam = &rtwvif->addr_cam;
460 struct rtw89_bssid_cam_entry *bssid_cam = &rtwvif->bssid_cam;
461
462 rtw89_cam_deinit_addr_cam(rtwdev, addr_cam);
463 rtw89_cam_deinit_bssid_cam(rtwdev, bssid_cam);
464}
465
466void rtw89_cam_reset_keys(struct rtw89_dev *rtwdev)
467{
468 rcu_read_lock();
469 ieee80211_iter_keys_rcu(hw: rtwdev->hw, NULL, iter: rtw89_cam_reset_key_iter, iter_data: rtwdev);
470 rcu_read_unlock();
471}
472
473static int rtw89_cam_get_avail_addr_cam(struct rtw89_dev *rtwdev,
474 u8 *addr_cam_idx)
475{
476 const struct rtw89_chip_info *chip = rtwdev->chip;
477 struct rtw89_cam_info *cam_info = &rtwdev->cam_info;
478 u8 addr_cam_num = chip->acam_num;
479 u8 idx;
480
481 idx = find_first_zero_bit(addr: cam_info->addr_cam_map, size: addr_cam_num);
482 if (idx >= addr_cam_num)
483 return -EBUSY;
484
485 set_bit(nr: idx, addr: cam_info->addr_cam_map);
486 *addr_cam_idx = idx;
487
488 return 0;
489}
490
491static u8 rtw89_get_addr_cam_entry_size(struct rtw89_dev *rtwdev)
492{
493 const struct rtw89_chip_info *chip = rtwdev->chip;
494
495 switch (chip->chip_id) {
496 case RTL8852A:
497 case RTL8852B:
498 case RTL8851B:
499 return ADDR_CAM_ENT_SIZE;
500 default:
501 return ADDR_CAM_ENT_SHORT_SIZE;
502 }
503}
504
505int rtw89_cam_init_addr_cam(struct rtw89_dev *rtwdev,
506 struct rtw89_addr_cam_entry *addr_cam,
507 const struct rtw89_bssid_cam_entry *bssid_cam)
508{
509 u8 addr_cam_idx;
510 int i;
511 int ret;
512
513 if (unlikely(addr_cam->valid)) {
514 rtw89_debug(rtwdev, mask: RTW89_DBG_FW,
515 fmt: "addr cam is already valid; skip init\n");
516 return 0;
517 }
518
519 ret = rtw89_cam_get_avail_addr_cam(rtwdev, addr_cam_idx: &addr_cam_idx);
520 if (ret) {
521 rtw89_err(rtwdev, "failed to get available addr cam\n");
522 return ret;
523 }
524
525 addr_cam->addr_cam_idx = addr_cam_idx;
526 addr_cam->len = rtw89_get_addr_cam_entry_size(rtwdev);
527 addr_cam->offset = 0;
528 addr_cam->valid = true;
529 addr_cam->addr_mask = 0;
530 addr_cam->mask_sel = RTW89_NO_MSK;
531 addr_cam->sec_ent_mode = RTW89_ADDR_CAM_SEC_NORMAL;
532 bitmap_zero(dst: addr_cam->sec_cam_map, RTW89_SEC_CAM_IN_ADDR_CAM);
533
534 for (i = 0; i < RTW89_SEC_CAM_IN_ADDR_CAM; i++) {
535 addr_cam->sec_ent_keyid[i] = 0;
536 addr_cam->sec_ent[i] = 0;
537 }
538
539 /* associate addr cam with bssid cam */
540 addr_cam->bssid_cam_idx = bssid_cam->bssid_cam_idx;
541
542 return 0;
543}
544
545static int rtw89_cam_get_avail_bssid_cam(struct rtw89_dev *rtwdev,
546 u8 *bssid_cam_idx)
547{
548 const struct rtw89_chip_info *chip = rtwdev->chip;
549 struct rtw89_cam_info *cam_info = &rtwdev->cam_info;
550 u8 bssid_cam_num = chip->bcam_num;
551 u8 idx;
552
553 idx = find_first_zero_bit(addr: cam_info->bssid_cam_map, size: bssid_cam_num);
554 if (idx >= bssid_cam_num)
555 return -EBUSY;
556
557 set_bit(nr: idx, addr: cam_info->bssid_cam_map);
558 *bssid_cam_idx = idx;
559
560 return 0;
561}
562
563int rtw89_cam_init_bssid_cam(struct rtw89_dev *rtwdev,
564 struct rtw89_vif *rtwvif,
565 struct rtw89_bssid_cam_entry *bssid_cam,
566 const u8 *bssid)
567{
568 u8 bssid_cam_idx;
569 int ret;
570
571 if (unlikely(bssid_cam->valid)) {
572 rtw89_debug(rtwdev, mask: RTW89_DBG_FW,
573 fmt: "bssid cam is already valid; skip init\n");
574 return 0;
575 }
576
577 ret = rtw89_cam_get_avail_bssid_cam(rtwdev, bssid_cam_idx: &bssid_cam_idx);
578 if (ret) {
579 rtw89_err(rtwdev, "failed to get available bssid cam\n");
580 return ret;
581 }
582
583 bssid_cam->bssid_cam_idx = bssid_cam_idx;
584 bssid_cam->phy_idx = rtwvif->phy_idx;
585 bssid_cam->len = BSSID_CAM_ENT_SIZE;
586 bssid_cam->offset = 0;
587 bssid_cam->valid = true;
588 ether_addr_copy(dst: bssid_cam->bssid, src: bssid);
589
590 return 0;
591}
592
593void rtw89_cam_bssid_changed(struct rtw89_dev *rtwdev, struct rtw89_vif *rtwvif)
594{
595 struct rtw89_bssid_cam_entry *bssid_cam = &rtwvif->bssid_cam;
596
597 ether_addr_copy(dst: bssid_cam->bssid, src: rtwvif->bssid);
598}
599
600int rtw89_cam_init(struct rtw89_dev *rtwdev, struct rtw89_vif *rtwvif)
601{
602 struct rtw89_addr_cam_entry *addr_cam = &rtwvif->addr_cam;
603 struct rtw89_bssid_cam_entry *bssid_cam = &rtwvif->bssid_cam;
604 int ret;
605
606 ret = rtw89_cam_init_bssid_cam(rtwdev, rtwvif, bssid_cam, bssid: rtwvif->bssid);
607 if (ret) {
608 rtw89_err(rtwdev, "failed to init bssid cam\n");
609 return ret;
610 }
611
612 ret = rtw89_cam_init_addr_cam(rtwdev, addr_cam, bssid_cam);
613 if (ret) {
614 rtw89_err(rtwdev, "failed to init addr cam\n");
615 return ret;
616 }
617
618 return 0;
619}
620
621int rtw89_cam_fill_bssid_cam_info(struct rtw89_dev *rtwdev,
622 struct rtw89_vif *rtwvif,
623 struct rtw89_sta *rtwsta, u8 *cmd)
624{
625 struct ieee80211_vif *vif = rtwvif_to_vif(rtwvif);
626 struct rtw89_bssid_cam_entry *bssid_cam = rtw89_get_bssid_cam_of(rtwvif, rtwsta);
627 u8 bss_color = vif->bss_conf.he_bss_color.color;
628 u8 bss_mask;
629
630 if (vif->bss_conf.nontransmitted)
631 bss_mask = RTW89_BSSID_MATCH_5_BYTES;
632 else
633 bss_mask = RTW89_BSSID_MATCH_ALL;
634
635 FWCMD_SET_ADDR_BSSID_IDX(cmd, value: bssid_cam->bssid_cam_idx);
636 FWCMD_SET_ADDR_BSSID_OFFSET(cmd, value: bssid_cam->offset);
637 FWCMD_SET_ADDR_BSSID_LEN(cmd, value: bssid_cam->len);
638 FWCMD_SET_ADDR_BSSID_VALID(cmd, value: bssid_cam->valid);
639 FWCMD_SET_ADDR_BSSID_MASK(cmd, value: bss_mask);
640 FWCMD_SET_ADDR_BSSID_BB_SEL(cmd, value: bssid_cam->phy_idx);
641 FWCMD_SET_ADDR_BSSID_BSS_COLOR(cmd, value: bss_color);
642
643 FWCMD_SET_ADDR_BSSID_BSSID0(cmd, value: bssid_cam->bssid[0]);
644 FWCMD_SET_ADDR_BSSID_BSSID1(cmd, value: bssid_cam->bssid[1]);
645 FWCMD_SET_ADDR_BSSID_BSSID2(cmd, value: bssid_cam->bssid[2]);
646 FWCMD_SET_ADDR_BSSID_BSSID3(cmd, value: bssid_cam->bssid[3]);
647 FWCMD_SET_ADDR_BSSID_BSSID4(cmd, value: bssid_cam->bssid[4]);
648 FWCMD_SET_ADDR_BSSID_BSSID5(cmd, value: bssid_cam->bssid[5]);
649
650 return 0;
651}
652
653static u8 rtw89_cam_addr_hash(u8 start, const u8 *addr)
654{
655 u8 hash = 0;
656 u8 i;
657
658 for (i = start; i < ETH_ALEN; i++)
659 hash ^= addr[i];
660
661 return hash;
662}
663
664void rtw89_cam_fill_addr_cam_info(struct rtw89_dev *rtwdev,
665 struct rtw89_vif *rtwvif,
666 struct rtw89_sta *rtwsta,
667 const u8 *scan_mac_addr,
668 u8 *cmd)
669{
670 struct ieee80211_vif *vif = rtwvif_to_vif(rtwvif);
671 struct rtw89_addr_cam_entry *addr_cam = rtw89_get_addr_cam_of(rtwvif, rtwsta);
672 struct ieee80211_sta *sta = rtwsta_to_sta_safe(rtwsta);
673 const u8 *sma = scan_mac_addr ? scan_mac_addr : rtwvif->mac_addr;
674 u8 sma_hash, tma_hash, addr_msk_start;
675 u8 sma_start = 0;
676 u8 tma_start = 0;
677 u8 *tma = sta ? sta->addr : rtwvif->bssid;
678
679 if (addr_cam->addr_mask != 0) {
680 addr_msk_start = __ffs(addr_cam->addr_mask);
681 if (addr_cam->mask_sel == RTW89_SMA)
682 sma_start = addr_msk_start;
683 else if (addr_cam->mask_sel == RTW89_TMA)
684 tma_start = addr_msk_start;
685 }
686 sma_hash = rtw89_cam_addr_hash(start: sma_start, addr: sma);
687 tma_hash = rtw89_cam_addr_hash(start: tma_start, addr: tma);
688
689 FWCMD_SET_ADDR_IDX(cmd, value: addr_cam->addr_cam_idx);
690 FWCMD_SET_ADDR_OFFSET(cmd, value: addr_cam->offset);
691 FWCMD_SET_ADDR_LEN(cmd, value: addr_cam->len);
692
693 FWCMD_SET_ADDR_VALID(cmd, value: addr_cam->valid);
694 FWCMD_SET_ADDR_NET_TYPE(cmd, value: rtwvif->net_type);
695 FWCMD_SET_ADDR_BCN_HIT_COND(cmd, value: rtwvif->bcn_hit_cond);
696 FWCMD_SET_ADDR_HIT_RULE(cmd, value: rtwvif->hit_rule);
697 FWCMD_SET_ADDR_BB_SEL(cmd, value: rtwvif->phy_idx);
698 FWCMD_SET_ADDR_ADDR_MASK(cmd, value: addr_cam->addr_mask);
699 FWCMD_SET_ADDR_MASK_SEL(cmd, value: addr_cam->mask_sel);
700 FWCMD_SET_ADDR_SMA_HASH(cmd, value: sma_hash);
701 FWCMD_SET_ADDR_TMA_HASH(cmd, value: tma_hash);
702
703 FWCMD_SET_ADDR_BSSID_CAM_IDX(cmd, value: addr_cam->bssid_cam_idx);
704
705 FWCMD_SET_ADDR_SMA0(cmd, value: sma[0]);
706 FWCMD_SET_ADDR_SMA1(cmd, value: sma[1]);
707 FWCMD_SET_ADDR_SMA2(cmd, value: sma[2]);
708 FWCMD_SET_ADDR_SMA3(cmd, value: sma[3]);
709 FWCMD_SET_ADDR_SMA4(cmd, value: sma[4]);
710 FWCMD_SET_ADDR_SMA5(cmd, value: sma[5]);
711
712 FWCMD_SET_ADDR_TMA0(cmd, value: tma[0]);
713 FWCMD_SET_ADDR_TMA1(cmd, value: tma[1]);
714 FWCMD_SET_ADDR_TMA2(cmd, value: tma[2]);
715 FWCMD_SET_ADDR_TMA3(cmd, value: tma[3]);
716 FWCMD_SET_ADDR_TMA4(cmd, value: tma[4]);
717 FWCMD_SET_ADDR_TMA5(cmd, value: tma[5]);
718
719 FWCMD_SET_ADDR_PORT_INT(cmd, value: rtwvif->port);
720 FWCMD_SET_ADDR_TSF_SYNC(cmd, value: rtwvif->port);
721 FWCMD_SET_ADDR_TF_TRS(cmd, value: rtwvif->trigger);
722 FWCMD_SET_ADDR_LSIG_TXOP(cmd, value: rtwvif->lsig_txop);
723 FWCMD_SET_ADDR_TGT_IND(cmd, value: rtwvif->tgt_ind);
724 FWCMD_SET_ADDR_FRM_TGT_IND(cmd, value: rtwvif->frm_tgt_ind);
725 FWCMD_SET_ADDR_MACID(cmd, value: rtwsta ? rtwsta->mac_id : rtwvif->mac_id);
726 if (rtwvif->net_type == RTW89_NET_TYPE_INFRA)
727 FWCMD_SET_ADDR_AID12(cmd, value: vif->cfg.aid & 0xfff);
728 else if (rtwvif->net_type == RTW89_NET_TYPE_AP_MODE)
729 FWCMD_SET_ADDR_AID12(cmd, value: sta ? sta->aid & 0xfff : 0);
730 FWCMD_SET_ADDR_WOL_PATTERN(cmd, value: rtwvif->wowlan_pattern);
731 FWCMD_SET_ADDR_WOL_UC(cmd, value: rtwvif->wowlan_uc);
732 FWCMD_SET_ADDR_WOL_MAGIC(cmd, value: rtwvif->wowlan_magic);
733 FWCMD_SET_ADDR_WAPI(cmd, value: addr_cam->wapi);
734 FWCMD_SET_ADDR_SEC_ENT_MODE(cmd, value: addr_cam->sec_ent_mode);
735 FWCMD_SET_ADDR_SEC_ENT0_KEYID(cmd, value: addr_cam->sec_ent_keyid[0]);
736 FWCMD_SET_ADDR_SEC_ENT1_KEYID(cmd, value: addr_cam->sec_ent_keyid[1]);
737 FWCMD_SET_ADDR_SEC_ENT2_KEYID(cmd, value: addr_cam->sec_ent_keyid[2]);
738 FWCMD_SET_ADDR_SEC_ENT3_KEYID(cmd, value: addr_cam->sec_ent_keyid[3]);
739 FWCMD_SET_ADDR_SEC_ENT4_KEYID(cmd, value: addr_cam->sec_ent_keyid[4]);
740 FWCMD_SET_ADDR_SEC_ENT5_KEYID(cmd, value: addr_cam->sec_ent_keyid[5]);
741 FWCMD_SET_ADDR_SEC_ENT6_KEYID(cmd, value: addr_cam->sec_ent_keyid[6]);
742
743 FWCMD_SET_ADDR_SEC_ENT_VALID(cmd, value: addr_cam->sec_cam_map[0] & 0xff);
744 FWCMD_SET_ADDR_SEC_ENT0(cmd, value: addr_cam->sec_ent[0]);
745 FWCMD_SET_ADDR_SEC_ENT1(cmd, value: addr_cam->sec_ent[1]);
746 FWCMD_SET_ADDR_SEC_ENT2(cmd, value: addr_cam->sec_ent[2]);
747 FWCMD_SET_ADDR_SEC_ENT3(cmd, value: addr_cam->sec_ent[3]);
748 FWCMD_SET_ADDR_SEC_ENT4(cmd, value: addr_cam->sec_ent[4]);
749 FWCMD_SET_ADDR_SEC_ENT5(cmd, value: addr_cam->sec_ent[5]);
750 FWCMD_SET_ADDR_SEC_ENT6(cmd, value: addr_cam->sec_ent[6]);
751}
752
753void rtw89_cam_fill_dctl_sec_cam_info_v1(struct rtw89_dev *rtwdev,
754 struct rtw89_vif *rtwvif,
755 struct rtw89_sta *rtwsta,
756 u8 *cmd)
757{
758 struct rtw89_addr_cam_entry *addr_cam = rtw89_get_addr_cam_of(rtwvif, rtwsta);
759
760 SET_DCTL_MACID_V1(table: cmd, val: rtwsta ? rtwsta->mac_id : rtwvif->mac_id);
761 SET_DCTL_OPERATION_V1(table: cmd, val: 1);
762
763 SET_DCTL_SEC_ENT0_KEYID_V1(table: cmd, val: addr_cam->sec_ent_keyid[0]);
764 SET_DCTL_SEC_ENT1_KEYID_V1(table: cmd, val: addr_cam->sec_ent_keyid[1]);
765 SET_DCTL_SEC_ENT2_KEYID_V1(table: cmd, val: addr_cam->sec_ent_keyid[2]);
766 SET_DCTL_SEC_ENT3_KEYID_V1(table: cmd, val: addr_cam->sec_ent_keyid[3]);
767 SET_DCTL_SEC_ENT4_KEYID_V1(table: cmd, val: addr_cam->sec_ent_keyid[4]);
768 SET_DCTL_SEC_ENT5_KEYID_V1(table: cmd, val: addr_cam->sec_ent_keyid[5]);
769 SET_DCTL_SEC_ENT6_KEYID_V1(table: cmd, val: addr_cam->sec_ent_keyid[6]);
770
771 SET_DCTL_SEC_ENT_VALID_V1(table: cmd, val: addr_cam->sec_cam_map[0] & 0xff);
772 SET_DCTL_SEC_ENT0_V1(table: cmd, val: addr_cam->sec_ent[0]);
773 SET_DCTL_SEC_ENT1_V1(table: cmd, val: addr_cam->sec_ent[1]);
774 SET_DCTL_SEC_ENT2_V1(table: cmd, val: addr_cam->sec_ent[2]);
775 SET_DCTL_SEC_ENT3_V1(table: cmd, val: addr_cam->sec_ent[3]);
776 SET_DCTL_SEC_ENT4_V1(table: cmd, val: addr_cam->sec_ent[4]);
777 SET_DCTL_SEC_ENT5_V1(table: cmd, val: addr_cam->sec_ent[5]);
778 SET_DCTL_SEC_ENT6_V1(table: cmd, val: addr_cam->sec_ent[6]);
779}
780
781void rtw89_cam_fill_dctl_sec_cam_info_v2(struct rtw89_dev *rtwdev,
782 struct rtw89_vif *rtwvif,
783 struct rtw89_sta *rtwsta,
784 struct rtw89_h2c_dctlinfo_ud_v2 *h2c)
785{
786 struct rtw89_addr_cam_entry *addr_cam = rtw89_get_addr_cam_of(rtwvif, rtwsta);
787
788 h2c->c0 = le32_encode_bits(v: rtwsta ? rtwsta->mac_id : rtwvif->mac_id,
789 DCTLINFO_V2_C0_MACID) |
790 le32_encode_bits(v: 1, DCTLINFO_V2_C0_OP);
791
792 h2c->w4 = le32_encode_bits(v: addr_cam->sec_ent_keyid[0],
793 DCTLINFO_V2_W4_SEC_ENT0_KEYID) |
794 le32_encode_bits(v: addr_cam->sec_ent_keyid[1],
795 DCTLINFO_V2_W4_SEC_ENT1_KEYID) |
796 le32_encode_bits(v: addr_cam->sec_ent_keyid[2],
797 DCTLINFO_V2_W4_SEC_ENT2_KEYID) |
798 le32_encode_bits(v: addr_cam->sec_ent_keyid[3],
799 DCTLINFO_V2_W4_SEC_ENT3_KEYID) |
800 le32_encode_bits(v: addr_cam->sec_ent_keyid[4],
801 DCTLINFO_V2_W4_SEC_ENT4_KEYID) |
802 le32_encode_bits(v: addr_cam->sec_ent_keyid[5],
803 DCTLINFO_V2_W4_SEC_ENT5_KEYID) |
804 le32_encode_bits(v: addr_cam->sec_ent_keyid[6],
805 DCTLINFO_V2_W4_SEC_ENT6_KEYID);
806 h2c->m4 = cpu_to_le32(DCTLINFO_V2_W4_SEC_ENT0_KEYID |
807 DCTLINFO_V2_W4_SEC_ENT1_KEYID |
808 DCTLINFO_V2_W4_SEC_ENT2_KEYID |
809 DCTLINFO_V2_W4_SEC_ENT3_KEYID |
810 DCTLINFO_V2_W4_SEC_ENT4_KEYID |
811 DCTLINFO_V2_W4_SEC_ENT5_KEYID |
812 DCTLINFO_V2_W4_SEC_ENT6_KEYID);
813
814 h2c->w5 = le32_encode_bits(v: addr_cam->sec_cam_map[0],
815 DCTLINFO_V2_W5_SEC_ENT_VALID_V1) |
816 le32_encode_bits(v: addr_cam->sec_ent[0],
817 DCTLINFO_V2_W5_SEC_ENT0_V1);
818 h2c->m5 = cpu_to_le32(DCTLINFO_V2_W5_SEC_ENT_VALID_V1 |
819 DCTLINFO_V2_W5_SEC_ENT0_V1);
820
821 h2c->w6 = le32_encode_bits(v: addr_cam->sec_ent[1],
822 DCTLINFO_V2_W6_SEC_ENT1_V1) |
823 le32_encode_bits(v: addr_cam->sec_ent[2],
824 DCTLINFO_V2_W6_SEC_ENT2_V1) |
825 le32_encode_bits(v: addr_cam->sec_ent[3],
826 DCTLINFO_V2_W6_SEC_ENT3_V1) |
827 le32_encode_bits(v: addr_cam->sec_ent[4],
828 DCTLINFO_V2_W6_SEC_ENT4_V1);
829 h2c->m6 = cpu_to_le32(DCTLINFO_V2_W6_SEC_ENT1_V1 |
830 DCTLINFO_V2_W6_SEC_ENT2_V1 |
831 DCTLINFO_V2_W6_SEC_ENT3_V1 |
832 DCTLINFO_V2_W6_SEC_ENT4_V1);
833
834 h2c->w7 = le32_encode_bits(v: addr_cam->sec_ent[5],
835 DCTLINFO_V2_W7_SEC_ENT5_V1) |
836 le32_encode_bits(v: addr_cam->sec_ent[6],
837 DCTLINFO_V2_W7_SEC_ENT6_V1);
838 h2c->m7 = cpu_to_le32(DCTLINFO_V2_W7_SEC_ENT5_V1 |
839 DCTLINFO_V2_W7_SEC_ENT6_V1);
840}
841

source code of linux/drivers/net/wireless/realtek/rtw89/cam.c