| 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 |
|
| 11 |
static struct sk_buff * |
| 12 |
rtw89_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 |
|
| 52 |
static 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 |
|
| 102 |
static 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 |
|
| 121 |
again: |
| 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 |
|
| 138 |
static 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 |
|
| 215 |
static 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 |
|
| 248 |
static 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 |
|
| 292 |
int 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 |
|
| 308 |
static 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 |
|
| 345 |
static 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 |
|
| 399 |
static 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_obj(*sec_cam); |
| 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 |
|
| 455 |
err_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 |
|
| 465 |
int 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 |
|
| 537 |
int 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 |
|
| 568 |
static 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 |
|
| 579 |
void 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 |
|
| 588 |
void 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 |
|
| 597 |
void 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 |
|
| 606 |
void 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 |
|
| 613 |
static 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 |
|
| 631 |
static 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 |
|
| 646 |
int 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 |
|
| 686 |
static 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 |
|
| 704 |
int 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 |
|
| 734 |
void 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 |
|
| 741 |
int 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 |
|
| 763 |
int 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 |
|
| 803 |
static 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 |
|
| 814 |
void 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 |
|
| 930 |
void 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 |
|
| 1011 |
void 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 |
} |
| 1143 |
|
| 1144 |
void rtw89_cam_fill_dctl_sec_cam_info_v3(struct rtw89_dev *rtwdev, |
| 1145 |
struct rtw89_vif_link *rtwvif_link, |
| 1146 |
struct rtw89_sta_link *rtwsta_link, |
| 1147 |
struct rtw89_h2c_dctlinfo_ud_v3 *h2c) |
| 1148 |
{ |
| 1149 |
struct ieee80211_sta *sta = rtwsta_link_to_sta_safe(rtwsta_link); |
| 1150 |
struct ieee80211_vif *vif = rtwvif_to_vif(rtwvif_link->rtwvif); |
| 1151 |
struct rtw89_vif *rtwvif = rtwvif_link->rtwvif; |
| 1152 |
struct rtw89_addr_cam_entry *addr_cam = |
| 1153 |
rtw89_get_addr_cam_of(rtwvif_link, rtwsta_link); |
| 1154 |
bool is_mld = sta ? sta->mlo : ieee80211_vif_is_mld(vif); |
| 1155 |
struct rtw89_wow_param *rtw_wow = &rtwdev->wow; |
| 1156 |
u8 *ptk_tx_iv = rtw_wow->key_info.ptk_tx_iv; |
| 1157 |
u8 *mld_sma, *mld_tma, *mld_bssid; |
| 1158 |
|
| 1159 |
h2c->c0 = le32_encode_bits(rtwsta_link ? rtwsta_link->mac_id : |
| 1160 |
rtwvif_link->mac_id, |
| 1161 |
DCTLINFO_V3_C0_MACID) | |
| 1162 |
le32_encode_bits(1, DCTLINFO_V3_C0_OP); |
| 1163 |
|
| 1164 |
h2c->w2 = le32_encode_bits(is_mld, DCTLINFO_V3_W2_IS_MLD); |
| 1165 |
h2c->m2 = cpu_to_le32(DCTLINFO_V3_W2_IS_MLD); |
| 1166 |
|
| 1167 |
h2c->w4 = le32_encode_bits(addr_cam->sec_ent_keyid[0], |
| 1168 |
DCTLINFO_V3_W4_SEC_ENT0_KEYID) | |
| 1169 |
le32_encode_bits(addr_cam->sec_ent_keyid[1], |
| 1170 |
DCTLINFO_V3_W4_SEC_ENT1_KEYID) | |
| 1171 |
le32_encode_bits(addr_cam->sec_ent_keyid[2], |
| 1172 |
DCTLINFO_V3_W4_SEC_ENT2_KEYID) | |
| 1173 |
le32_encode_bits(addr_cam->sec_ent_keyid[3], |
| 1174 |
DCTLINFO_V3_W4_SEC_ENT3_KEYID) | |
| 1175 |
le32_encode_bits(addr_cam->sec_ent_keyid[4], |
| 1176 |
DCTLINFO_V3_W4_SEC_ENT4_KEYID) | |
| 1177 |
le32_encode_bits(addr_cam->sec_ent_keyid[5], |
| 1178 |
DCTLINFO_V3_W4_SEC_ENT5_KEYID) | |
| 1179 |
le32_encode_bits(addr_cam->sec_ent_keyid[6], |
| 1180 |
DCTLINFO_V3_W4_SEC_ENT6_KEYID); |
| 1181 |
h2c->m4 = cpu_to_le32(DCTLINFO_V3_W4_SEC_ENT0_KEYID | |
| 1182 |
DCTLINFO_V3_W4_SEC_ENT1_KEYID | |
| 1183 |
DCTLINFO_V3_W4_SEC_ENT2_KEYID | |
| 1184 |
DCTLINFO_V3_W4_SEC_ENT3_KEYID | |
| 1185 |
DCTLINFO_V3_W4_SEC_ENT4_KEYID | |
| 1186 |
DCTLINFO_V3_W4_SEC_ENT5_KEYID | |
| 1187 |
DCTLINFO_V3_W4_SEC_ENT6_KEYID); |
| 1188 |
|
| 1189 |
h2c->w5 = le32_encode_bits(addr_cam->sec_cam_map[0], |
| 1190 |
DCTLINFO_V3_W5_SEC_ENT_VALID_V1); |
| 1191 |
h2c->m5 = cpu_to_le32(DCTLINFO_V3_W5_SEC_ENT_VALID_V1); |
| 1192 |
|
| 1193 |
h2c->w6 = le32_encode_bits(addr_cam->sec_ent[0], |
| 1194 |
DCTLINFO_V3_W6_SEC_ENT0_V2) | |
| 1195 |
le32_encode_bits(addr_cam->sec_ent[1], |
| 1196 |
DCTLINFO_V3_W6_SEC_ENT1_V2) | |
| 1197 |
le32_encode_bits(addr_cam->sec_ent[2], |
| 1198 |
DCTLINFO_V3_W6_SEC_ENT2_V2); |
| 1199 |
h2c->m6 = cpu_to_le32(DCTLINFO_V3_W6_SEC_ENT0_V2 | |
| 1200 |
DCTLINFO_V3_W6_SEC_ENT1_V2 | |
| 1201 |
DCTLINFO_V3_W6_SEC_ENT2_V2); |
| 1202 |
|
| 1203 |
h2c->w7 = le32_encode_bits(addr_cam->sec_ent[3], |
| 1204 |
DCTLINFO_V3_W7_SEC_ENT3_V2) | |
| 1205 |
le32_encode_bits(addr_cam->sec_ent[4], |
| 1206 |
DCTLINFO_V3_W7_SEC_ENT4_V2) | |
| 1207 |
le32_encode_bits(addr_cam->sec_ent[5], |
| 1208 |
DCTLINFO_V3_W7_SEC_ENT5_V2); |
| 1209 |
h2c->m7 = cpu_to_le32(DCTLINFO_V3_W7_SEC_ENT3_V2 | |
| 1210 |
DCTLINFO_V3_W7_SEC_ENT4_V2 | |
| 1211 |
DCTLINFO_V3_W7_SEC_ENT5_V2); |
| 1212 |
|
| 1213 |
h2c->w8 = le32_encode_bits(addr_cam->sec_ent[6], |
| 1214 |
DCTLINFO_V3_W8_SEC_ENT6_V2); |
| 1215 |
h2c->m8 = cpu_to_le32(DCTLINFO_V3_W8_SEC_ENT6_V2); |
| 1216 |
|
| 1217 |
if (rtw_wow->ptk_alg) { |
| 1218 |
h2c->w0 = le32_encode_bits(ptk_tx_iv[0] | ptk_tx_iv[1] << 8, |
| 1219 |
DCTLINFO_V3_W0_AES_IV_L); |
| 1220 |
h2c->m0 = cpu_to_le32(DCTLINFO_V3_W0_AES_IV_L); |
| 1221 |
|
| 1222 |
h2c->w1 = le32_encode_bits(ptk_tx_iv[4] | |
| 1223 |
ptk_tx_iv[5] << 8 | |
| 1224 |
ptk_tx_iv[6] << 16 | |
| 1225 |
ptk_tx_iv[7] << 24, |
| 1226 |
DCTLINFO_V3_W1_AES_IV_H); |
| 1227 |
h2c->m1 = cpu_to_le32(DCTLINFO_V3_W1_AES_IV_H); |
| 1228 |
|
| 1229 |
h2c->w4 |= le32_encode_bits(rtw_wow->ptk_keyidx, |
| 1230 |
DCTLINFO_V3_W4_SEC_KEY_ID); |
| 1231 |
h2c->m4 |= cpu_to_le32(DCTLINFO_V3_W4_SEC_KEY_ID); |
| 1232 |
} |
| 1233 |
|
| 1234 |
if (!is_mld) |
| 1235 |
return; |
| 1236 |
|
| 1237 |
if (rtwvif_link->net_type == RTW89_NET_TYPE_INFRA) { |
| 1238 |
mld_sma = rtwvif->mac_addr; |
| 1239 |
mld_tma = vif->cfg.ap_addr; |
| 1240 |
mld_bssid = vif->cfg.ap_addr; |
| 1241 |
} else if (rtwvif_link->net_type == RTW89_NET_TYPE_AP_MODE && sta) { |
| 1242 |
mld_sma = rtwvif->mac_addr; |
| 1243 |
mld_tma = sta->addr; |
| 1244 |
mld_bssid = rtwvif->mac_addr; |
| 1245 |
} else { |
| 1246 |
return; |
| 1247 |
} |
| 1248 |
|
| 1249 |
h2c->w9 = le32_encode_bits(mld_sma[0], DCTLINFO_V3_W9_MLD_SMA_0_V2) | |
| 1250 |
le32_encode_bits(mld_sma[1], DCTLINFO_V3_W9_MLD_SMA_1_V2) | |
| 1251 |
le32_encode_bits(mld_sma[2], DCTLINFO_V3_W9_MLD_SMA_2_V2) | |
| 1252 |
le32_encode_bits(mld_sma[3], DCTLINFO_V3_W9_MLD_SMA_3_V2); |
| 1253 |
h2c->m9 = cpu_to_le32(DCTLINFO_V3_W9_ALL); |
| 1254 |
|
| 1255 |
h2c->w10 = le32_encode_bits(mld_sma[4], DCTLINFO_V3_W10_MLD_SMA_4_V2) | |
| 1256 |
le32_encode_bits(mld_sma[5], DCTLINFO_V3_W10_MLD_SMA_5_V2) | |
| 1257 |
le32_encode_bits(mld_tma[0], DCTLINFO_V3_W10_MLD_TMA_0_V2) | |
| 1258 |
le32_encode_bits(mld_tma[1], DCTLINFO_V3_W10_MLD_TMA_1_V2); |
| 1259 |
h2c->m10 = cpu_to_le32(DCTLINFO_V3_W10_ALL); |
| 1260 |
|
| 1261 |
h2c->w11 = le32_encode_bits(mld_tma[2], DCTLINFO_V3_W11_MLD_TMA_2_V2) | |
| 1262 |
le32_encode_bits(mld_tma[3], DCTLINFO_V3_W11_MLD_TMA_3_V2) | |
| 1263 |
le32_encode_bits(mld_tma[4], DCTLINFO_V3_W11_MLD_TMA_4_V2) | |
| 1264 |
le32_encode_bits(mld_tma[5], DCTLINFO_V3_W11_MLD_TMA_5_V2); |
| 1265 |
h2c->m11 = cpu_to_le32(DCTLINFO_V3_W11_ALL); |
| 1266 |
|
| 1267 |
h2c->w12 = le32_encode_bits(mld_bssid[0], DCTLINFO_V3_W12_MLD_TA_BSSID_0_V2) | |
| 1268 |
le32_encode_bits(mld_bssid[1], DCTLINFO_V3_W12_MLD_TA_BSSID_1_V2) | |
| 1269 |
le32_encode_bits(mld_bssid[2], DCTLINFO_V3_W12_MLD_TA_BSSID_2_V2) | |
| 1270 |
le32_encode_bits(mld_bssid[3], DCTLINFO_V3_W12_MLD_TA_BSSID_3_V2); |
| 1271 |
h2c->m12 = cpu_to_le32(DCTLINFO_V3_W12_ALL); |
| 1272 |
|
| 1273 |
h2c->w13 = le32_encode_bits(mld_bssid[4], DCTLINFO_V3_W13_MLD_TA_BSSID_4_V2) | |
| 1274 |
le32_encode_bits(mld_bssid[5], DCTLINFO_V3_W13_MLD_TA_BSSID_5_V2); |
| 1275 |
h2c->m13 = cpu_to_le32(DCTLINFO_V3_W13_ALL); |
| 1276 |
} |