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