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