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