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