Debian Codegraph @

drivers/net/wireless/realtek/rtw89/wow.c

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