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