1 /******************************************************************************
2 *
3 * This file is provided under a dual BSD/GPLv2 license. When using or
4 * redistributing this file, you may do so under either license.
5 *
6 * GPL LICENSE SUMMARY
7 *
8 * Copyright(c) 2012 - 2014 Intel Corporation. All rights reserved.
9 * Copyright(c) 2013 - 2014 Intel Mobile Communications GmbH
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of version 2 of the GNU General Public License as
13 * published by the Free Software Foundation.
14 *
15 * This program is distributed in the hope that it will be useful, but
16 * WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
23 * USA
24 *
25 * The full GNU General Public License is included in this distribution
26 * in the file called COPYING.
27 *
28 * Contact Information:
29 * Intel Linux Wireless <ilw@linux.intel.com>
30 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
31 *
32 * BSD LICENSE
33 *
34 * Copyright(c) 2012 - 2014 Intel Corporation. All rights reserved.
35 * Copyright(c) 2013 - 2014 Intel Mobile Communications GmbH
36 * All rights reserved.
37 *
38 * Redistribution and use in source and binary forms, with or without
39 * modification, are permitted provided that the following conditions
40 * are met:
41 *
42 * * Redistributions of source code must retain the above copyright
43 * notice, this list of conditions and the following disclaimer.
44 * * Redistributions in binary form must reproduce the above copyright
45 * notice, this list of conditions and the following disclaimer in
46 * the documentation and/or other materials provided with the
47 * distribution.
48 * * Neither the name Intel Corporation nor the names of its
49 * contributors may be used to endorse or promote products derived
50 * from this software without specific prior written permission.
51 *
52 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
53 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
54 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
55 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
56 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
57 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
58 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
59 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
60 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
61 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
62 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
63 *
64 *****************************************************************************/
65
66 #include <linux/etherdevice.h>
67 #include <linux/ip.h>
68 #include <linux/fs.h>
69 #include <net/cfg80211.h>
70 #include <net/ipv6.h>
71 #include <net/tcp.h>
72 #include <net/addrconf.h>
73 #include "iwl-modparams.h"
74 #include "fw-api.h"
75 #include "mvm.h"
76
iwl_mvm_set_rekey_data(struct ieee80211_hw * hw,struct ieee80211_vif * vif,struct cfg80211_gtk_rekey_data * data)77 void iwl_mvm_set_rekey_data(struct ieee80211_hw *hw,
78 struct ieee80211_vif *vif,
79 struct cfg80211_gtk_rekey_data *data)
80 {
81 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
82 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
83
84 if (iwlwifi_mod_params.sw_crypto)
85 return;
86
87 mutex_lock(&mvm->mutex);
88
89 memcpy(mvmvif->rekey_data.kek, data->kek, NL80211_KEK_LEN);
90 memcpy(mvmvif->rekey_data.kck, data->kck, NL80211_KCK_LEN);
91 mvmvif->rekey_data.replay_ctr =
92 cpu_to_le64(be64_to_cpup((__be64 *)&data->replay_ctr));
93 mvmvif->rekey_data.valid = true;
94
95 mutex_unlock(&mvm->mutex);
96 }
97
98 #if IS_ENABLED(CONFIG_IPV6)
iwl_mvm_ipv6_addr_change(struct ieee80211_hw * hw,struct ieee80211_vif * vif,struct inet6_dev * idev)99 void iwl_mvm_ipv6_addr_change(struct ieee80211_hw *hw,
100 struct ieee80211_vif *vif,
101 struct inet6_dev *idev)
102 {
103 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
104 struct inet6_ifaddr *ifa;
105 int idx = 0;
106
107 read_lock_bh(&idev->lock);
108 list_for_each_entry(ifa, &idev->addr_list, if_list) {
109 mvmvif->target_ipv6_addrs[idx] = ifa->addr;
110 idx++;
111 if (idx >= IWL_PROTO_OFFLOAD_NUM_IPV6_ADDRS_MAX)
112 break;
113 }
114 read_unlock_bh(&idev->lock);
115
116 mvmvif->num_target_ipv6_addrs = idx;
117 }
118 #endif
119
iwl_mvm_set_default_unicast_key(struct ieee80211_hw * hw,struct ieee80211_vif * vif,int idx)120 void iwl_mvm_set_default_unicast_key(struct ieee80211_hw *hw,
121 struct ieee80211_vif *vif, int idx)
122 {
123 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
124
125 mvmvif->tx_key_idx = idx;
126 }
127
iwl_mvm_convert_p1k(u16 * p1k,__le16 * out)128 static void iwl_mvm_convert_p1k(u16 *p1k, __le16 *out)
129 {
130 int i;
131
132 for (i = 0; i < IWL_P1K_SIZE; i++)
133 out[i] = cpu_to_le16(p1k[i]);
134 }
135
136 struct wowlan_key_data {
137 struct iwl_wowlan_rsc_tsc_params_cmd *rsc_tsc;
138 struct iwl_wowlan_tkip_params_cmd *tkip;
139 bool error, use_rsc_tsc, use_tkip;
140 int wep_key_idx;
141 };
142
iwl_mvm_wowlan_program_keys(struct ieee80211_hw * hw,struct ieee80211_vif * vif,struct ieee80211_sta * sta,struct ieee80211_key_conf * key,void * _data)143 static void iwl_mvm_wowlan_program_keys(struct ieee80211_hw *hw,
144 struct ieee80211_vif *vif,
145 struct ieee80211_sta *sta,
146 struct ieee80211_key_conf *key,
147 void *_data)
148 {
149 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
150 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
151 struct wowlan_key_data *data = _data;
152 struct aes_sc *aes_sc, *aes_tx_sc = NULL;
153 struct tkip_sc *tkip_sc, *tkip_tx_sc = NULL;
154 struct iwl_p1k_cache *rx_p1ks;
155 u8 *rx_mic_key;
156 struct ieee80211_key_seq seq;
157 u32 cur_rx_iv32 = 0;
158 u16 p1k[IWL_P1K_SIZE];
159 int ret, i;
160
161 mutex_lock(&mvm->mutex);
162
163 switch (key->cipher) {
164 case WLAN_CIPHER_SUITE_WEP40:
165 case WLAN_CIPHER_SUITE_WEP104: { /* hack it for now */
166 struct {
167 struct iwl_mvm_wep_key_cmd wep_key_cmd;
168 struct iwl_mvm_wep_key wep_key;
169 } __packed wkc = {
170 .wep_key_cmd.mac_id_n_color =
171 cpu_to_le32(FW_CMD_ID_AND_COLOR(mvmvif->id,
172 mvmvif->color)),
173 .wep_key_cmd.num_keys = 1,
174 /* firmware sets STA_KEY_FLG_WEP_13BYTES */
175 .wep_key_cmd.decryption_type = STA_KEY_FLG_WEP,
176 .wep_key.key_index = key->keyidx,
177 .wep_key.key_size = key->keylen,
178 };
179
180 /*
181 * This will fail -- the key functions don't set support
182 * pairwise WEP keys. However, that's better than silently
183 * failing WoWLAN. Or maybe not?
184 */
185 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
186 break;
187
188 memcpy(&wkc.wep_key.key[3], key->key, key->keylen);
189 if (key->keyidx == mvmvif->tx_key_idx) {
190 /* TX key must be at offset 0 */
191 wkc.wep_key.key_offset = 0;
192 } else {
193 /* others start at 1 */
194 data->wep_key_idx++;
195 wkc.wep_key.key_offset = data->wep_key_idx;
196 }
197
198 ret = iwl_mvm_send_cmd_pdu(mvm, WEP_KEY, 0, sizeof(wkc), &wkc);
199 data->error = ret != 0;
200
201 mvm->ptk_ivlen = key->iv_len;
202 mvm->ptk_icvlen = key->icv_len;
203 mvm->gtk_ivlen = key->iv_len;
204 mvm->gtk_icvlen = key->icv_len;
205
206 /* don't upload key again */
207 goto out_unlock;
208 }
209 default:
210 data->error = true;
211 goto out_unlock;
212 case WLAN_CIPHER_SUITE_AES_CMAC:
213 /*
214 * Ignore CMAC keys -- the WoWLAN firmware doesn't support them
215 * but we also shouldn't abort suspend due to that. It does have
216 * support for the IGTK key renewal, but doesn't really use the
217 * IGTK for anything. This means we could spuriously wake up or
218 * be deauthenticated, but that was considered acceptable.
219 */
220 goto out_unlock;
221 case WLAN_CIPHER_SUITE_TKIP:
222 if (sta) {
223 tkip_sc = data->rsc_tsc->all_tsc_rsc.tkip.unicast_rsc;
224 tkip_tx_sc = &data->rsc_tsc->all_tsc_rsc.tkip.tsc;
225
226 rx_p1ks = data->tkip->rx_uni;
227
228 ieee80211_get_key_tx_seq(key, &seq);
229 tkip_tx_sc->iv16 = cpu_to_le16(seq.tkip.iv16);
230 tkip_tx_sc->iv32 = cpu_to_le32(seq.tkip.iv32);
231
232 ieee80211_get_tkip_p1k_iv(key, seq.tkip.iv32, p1k);
233 iwl_mvm_convert_p1k(p1k, data->tkip->tx.p1k);
234
235 memcpy(data->tkip->mic_keys.tx,
236 &key->key[NL80211_TKIP_DATA_OFFSET_TX_MIC_KEY],
237 IWL_MIC_KEY_SIZE);
238
239 rx_mic_key = data->tkip->mic_keys.rx_unicast;
240 } else {
241 tkip_sc =
242 data->rsc_tsc->all_tsc_rsc.tkip.multicast_rsc;
243 rx_p1ks = data->tkip->rx_multi;
244 rx_mic_key = data->tkip->mic_keys.rx_mcast;
245 }
246
247 /*
248 * For non-QoS this relies on the fact that both the uCode and
249 * mac80211 use TID 0 (as they need to to avoid replay attacks)
250 * for checking the IV in the frames.
251 */
252 for (i = 0; i < IWL_NUM_RSC; i++) {
253 ieee80211_get_key_rx_seq(key, i, &seq);
254 tkip_sc[i].iv16 = cpu_to_le16(seq.tkip.iv16);
255 tkip_sc[i].iv32 = cpu_to_le32(seq.tkip.iv32);
256 /* wrapping isn't allowed, AP must rekey */
257 if (seq.tkip.iv32 > cur_rx_iv32)
258 cur_rx_iv32 = seq.tkip.iv32;
259 }
260
261 ieee80211_get_tkip_rx_p1k(key, vif->bss_conf.bssid,
262 cur_rx_iv32, p1k);
263 iwl_mvm_convert_p1k(p1k, rx_p1ks[0].p1k);
264 ieee80211_get_tkip_rx_p1k(key, vif->bss_conf.bssid,
265 cur_rx_iv32 + 1, p1k);
266 iwl_mvm_convert_p1k(p1k, rx_p1ks[1].p1k);
267
268 memcpy(rx_mic_key,
269 &key->key[NL80211_TKIP_DATA_OFFSET_RX_MIC_KEY],
270 IWL_MIC_KEY_SIZE);
271
272 data->use_tkip = true;
273 data->use_rsc_tsc = true;
274 break;
275 case WLAN_CIPHER_SUITE_CCMP:
276 if (sta) {
277 u8 *pn = seq.ccmp.pn;
278
279 aes_sc = data->rsc_tsc->all_tsc_rsc.aes.unicast_rsc;
280 aes_tx_sc = &data->rsc_tsc->all_tsc_rsc.aes.tsc;
281
282 ieee80211_get_key_tx_seq(key, &seq);
283 aes_tx_sc->pn = cpu_to_le64((u64)pn[5] |
284 ((u64)pn[4] << 8) |
285 ((u64)pn[3] << 16) |
286 ((u64)pn[2] << 24) |
287 ((u64)pn[1] << 32) |
288 ((u64)pn[0] << 40));
289 } else {
290 aes_sc = data->rsc_tsc->all_tsc_rsc.aes.multicast_rsc;
291 }
292
293 /*
294 * For non-QoS this relies on the fact that both the uCode and
295 * mac80211 use TID 0 for checking the IV in the frames.
296 */
297 for (i = 0; i < IWL_NUM_RSC; i++) {
298 u8 *pn = seq.ccmp.pn;
299
300 ieee80211_get_key_rx_seq(key, i, &seq);
301 aes_sc[i].pn = cpu_to_le64((u64)pn[5] |
302 ((u64)pn[4] << 8) |
303 ((u64)pn[3] << 16) |
304 ((u64)pn[2] << 24) |
305 ((u64)pn[1] << 32) |
306 ((u64)pn[0] << 40));
307 }
308 data->use_rsc_tsc = true;
309 break;
310 }
311
312 /*
313 * The D3 firmware hardcodes the key offset 0 as the key it uses
314 * to transmit packets to the AP, i.e. the PTK.
315 */
316 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE) {
317 key->hw_key_idx = 0;
318 mvm->ptk_ivlen = key->iv_len;
319 mvm->ptk_icvlen = key->icv_len;
320 } else {
321 /*
322 * firmware only supports TSC/RSC for a single key,
323 * so if there are multiple keep overwriting them
324 * with new ones -- this relies on mac80211 doing
325 * list_add_tail().
326 */
327 key->hw_key_idx = 1;
328 mvm->gtk_ivlen = key->iv_len;
329 mvm->gtk_icvlen = key->icv_len;
330 }
331
332 ret = iwl_mvm_set_sta_key(mvm, vif, sta, key, true);
333 data->error = ret != 0;
334 out_unlock:
335 mutex_unlock(&mvm->mutex);
336 }
337
iwl_mvm_send_patterns(struct iwl_mvm * mvm,struct cfg80211_wowlan * wowlan)338 static int iwl_mvm_send_patterns(struct iwl_mvm *mvm,
339 struct cfg80211_wowlan *wowlan)
340 {
341 struct iwl_wowlan_patterns_cmd *pattern_cmd;
342 struct iwl_host_cmd cmd = {
343 .id = WOWLAN_PATTERNS,
344 .dataflags[0] = IWL_HCMD_DFL_NOCOPY,
345 };
346 int i, err;
347
348 if (!wowlan->n_patterns)
349 return 0;
350
351 cmd.len[0] = sizeof(*pattern_cmd) +
352 wowlan->n_patterns * sizeof(struct iwl_wowlan_pattern);
353
354 pattern_cmd = kmalloc(cmd.len[0], GFP_KERNEL);
355 if (!pattern_cmd)
356 return -ENOMEM;
357
358 pattern_cmd->n_patterns = cpu_to_le32(wowlan->n_patterns);
359
360 for (i = 0; i < wowlan->n_patterns; i++) {
361 int mask_len = DIV_ROUND_UP(wowlan->patterns[i].pattern_len, 8);
362
363 memcpy(&pattern_cmd->patterns[i].mask,
364 wowlan->patterns[i].mask, mask_len);
365 memcpy(&pattern_cmd->patterns[i].pattern,
366 wowlan->patterns[i].pattern,
367 wowlan->patterns[i].pattern_len);
368 pattern_cmd->patterns[i].mask_size = mask_len;
369 pattern_cmd->patterns[i].pattern_size =
370 wowlan->patterns[i].pattern_len;
371 }
372
373 cmd.data[0] = pattern_cmd;
374 err = iwl_mvm_send_cmd(mvm, &cmd);
375 kfree(pattern_cmd);
376 return err;
377 }
378
379 enum iwl_mvm_tcp_packet_type {
380 MVM_TCP_TX_SYN,
381 MVM_TCP_RX_SYNACK,
382 MVM_TCP_TX_DATA,
383 MVM_TCP_RX_ACK,
384 MVM_TCP_RX_WAKE,
385 MVM_TCP_TX_FIN,
386 };
387
pseudo_hdr_check(int len,__be32 saddr,__be32 daddr)388 static __le16 pseudo_hdr_check(int len, __be32 saddr, __be32 daddr)
389 {
390 __sum16 check = tcp_v4_check(len, saddr, daddr, 0);
391 return cpu_to_le16(be16_to_cpu((__force __be16)check));
392 }
393
iwl_mvm_build_tcp_packet(struct ieee80211_vif * vif,struct cfg80211_wowlan_tcp * tcp,void * _pkt,u8 * mask,__le16 * pseudo_hdr_csum,enum iwl_mvm_tcp_packet_type ptype)394 static void iwl_mvm_build_tcp_packet(struct ieee80211_vif *vif,
395 struct cfg80211_wowlan_tcp *tcp,
396 void *_pkt, u8 *mask,
397 __le16 *pseudo_hdr_csum,
398 enum iwl_mvm_tcp_packet_type ptype)
399 {
400 struct {
401 struct ethhdr eth;
402 struct iphdr ip;
403 struct tcphdr tcp;
404 u8 data[];
405 } __packed *pkt = _pkt;
406 u16 ip_tot_len = sizeof(struct iphdr) + sizeof(struct tcphdr);
407 int i;
408
409 pkt->eth.h_proto = cpu_to_be16(ETH_P_IP),
410 pkt->ip.version = 4;
411 pkt->ip.ihl = 5;
412 pkt->ip.protocol = IPPROTO_TCP;
413
414 switch (ptype) {
415 case MVM_TCP_TX_SYN:
416 case MVM_TCP_TX_DATA:
417 case MVM_TCP_TX_FIN:
418 memcpy(pkt->eth.h_dest, tcp->dst_mac, ETH_ALEN);
419 memcpy(pkt->eth.h_source, vif->addr, ETH_ALEN);
420 pkt->ip.ttl = 128;
421 pkt->ip.saddr = tcp->src;
422 pkt->ip.daddr = tcp->dst;
423 pkt->tcp.source = cpu_to_be16(tcp->src_port);
424 pkt->tcp.dest = cpu_to_be16(tcp->dst_port);
425 /* overwritten for TX SYN later */
426 pkt->tcp.doff = sizeof(struct tcphdr) / 4;
427 pkt->tcp.window = cpu_to_be16(65000);
428 break;
429 case MVM_TCP_RX_SYNACK:
430 case MVM_TCP_RX_ACK:
431 case MVM_TCP_RX_WAKE:
432 memcpy(pkt->eth.h_dest, vif->addr, ETH_ALEN);
433 memcpy(pkt->eth.h_source, tcp->dst_mac, ETH_ALEN);
434 pkt->ip.saddr = tcp->dst;
435 pkt->ip.daddr = tcp->src;
436 pkt->tcp.source = cpu_to_be16(tcp->dst_port);
437 pkt->tcp.dest = cpu_to_be16(tcp->src_port);
438 break;
439 default:
440 WARN_ON(1);
441 return;
442 }
443
444 switch (ptype) {
445 case MVM_TCP_TX_SYN:
446 /* firmware assumes 8 option bytes - 8 NOPs for now */
447 memset(pkt->data, 0x01, 8);
448 ip_tot_len += 8;
449 pkt->tcp.doff = (sizeof(struct tcphdr) + 8) / 4;
450 pkt->tcp.syn = 1;
451 break;
452 case MVM_TCP_TX_DATA:
453 ip_tot_len += tcp->payload_len;
454 memcpy(pkt->data, tcp->payload, tcp->payload_len);
455 pkt->tcp.psh = 1;
456 pkt->tcp.ack = 1;
457 break;
458 case MVM_TCP_TX_FIN:
459 pkt->tcp.fin = 1;
460 pkt->tcp.ack = 1;
461 break;
462 case MVM_TCP_RX_SYNACK:
463 pkt->tcp.syn = 1;
464 pkt->tcp.ack = 1;
465 break;
466 case MVM_TCP_RX_ACK:
467 pkt->tcp.ack = 1;
468 break;
469 case MVM_TCP_RX_WAKE:
470 ip_tot_len += tcp->wake_len;
471 pkt->tcp.psh = 1;
472 pkt->tcp.ack = 1;
473 memcpy(pkt->data, tcp->wake_data, tcp->wake_len);
474 break;
475 }
476
477 switch (ptype) {
478 case MVM_TCP_TX_SYN:
479 case MVM_TCP_TX_DATA:
480 case MVM_TCP_TX_FIN:
481 pkt->ip.tot_len = cpu_to_be16(ip_tot_len);
482 pkt->ip.check = ip_fast_csum(&pkt->ip, pkt->ip.ihl);
483 break;
484 case MVM_TCP_RX_WAKE:
485 for (i = 0; i < DIV_ROUND_UP(tcp->wake_len, 8); i++) {
486 u8 tmp = tcp->wake_mask[i];
487 mask[i + 6] |= tmp << 6;
488 if (i + 1 < DIV_ROUND_UP(tcp->wake_len, 8))
489 mask[i + 7] = tmp >> 2;
490 }
491 /* fall through for ethernet/IP/TCP headers mask */
492 case MVM_TCP_RX_SYNACK:
493 case MVM_TCP_RX_ACK:
494 mask[0] = 0xff; /* match ethernet */
495 /*
496 * match ethernet, ip.version, ip.ihl
497 * the ip.ihl half byte is really masked out by firmware
498 */
499 mask[1] = 0x7f;
500 mask[2] = 0x80; /* match ip.protocol */
501 mask[3] = 0xfc; /* match ip.saddr, ip.daddr */
502 mask[4] = 0x3f; /* match ip.daddr, tcp.source, tcp.dest */
503 mask[5] = 0x80; /* match tcp flags */
504 /* leave rest (0 or set for MVM_TCP_RX_WAKE) */
505 break;
506 };
507
508 *pseudo_hdr_csum = pseudo_hdr_check(ip_tot_len - sizeof(struct iphdr),
509 pkt->ip.saddr, pkt->ip.daddr);
510 }
511
iwl_mvm_send_remote_wake_cfg(struct iwl_mvm * mvm,struct ieee80211_vif * vif,struct cfg80211_wowlan_tcp * tcp)512 static int iwl_mvm_send_remote_wake_cfg(struct iwl_mvm *mvm,
513 struct ieee80211_vif *vif,
514 struct cfg80211_wowlan_tcp *tcp)
515 {
516 struct iwl_wowlan_remote_wake_config *cfg;
517 struct iwl_host_cmd cmd = {
518 .id = REMOTE_WAKE_CONFIG_CMD,
519 .len = { sizeof(*cfg), },
520 .dataflags = { IWL_HCMD_DFL_NOCOPY, },
521 };
522 int ret;
523
524 if (!tcp)
525 return 0;
526
527 cfg = kzalloc(sizeof(*cfg), GFP_KERNEL);
528 if (!cfg)
529 return -ENOMEM;
530 cmd.data[0] = cfg;
531
532 cfg->max_syn_retries = 10;
533 cfg->max_data_retries = 10;
534 cfg->tcp_syn_ack_timeout = 1; /* seconds */
535 cfg->tcp_ack_timeout = 1; /* seconds */
536
537 /* SYN (TX) */
538 iwl_mvm_build_tcp_packet(
539 vif, tcp, cfg->syn_tx.data, NULL,
540 &cfg->syn_tx.info.tcp_pseudo_header_checksum,
541 MVM_TCP_TX_SYN);
542 cfg->syn_tx.info.tcp_payload_length = 0;
543
544 /* SYN/ACK (RX) */
545 iwl_mvm_build_tcp_packet(
546 vif, tcp, cfg->synack_rx.data, cfg->synack_rx.rx_mask,
547 &cfg->synack_rx.info.tcp_pseudo_header_checksum,
548 MVM_TCP_RX_SYNACK);
549 cfg->synack_rx.info.tcp_payload_length = 0;
550
551 /* KEEPALIVE/ACK (TX) */
552 iwl_mvm_build_tcp_packet(
553 vif, tcp, cfg->keepalive_tx.data, NULL,
554 &cfg->keepalive_tx.info.tcp_pseudo_header_checksum,
555 MVM_TCP_TX_DATA);
556 cfg->keepalive_tx.info.tcp_payload_length =
557 cpu_to_le16(tcp->payload_len);
558 cfg->sequence_number_offset = tcp->payload_seq.offset;
559 /* length must be 0..4, the field is little endian */
560 cfg->sequence_number_length = tcp->payload_seq.len;
561 cfg->initial_sequence_number = cpu_to_le32(tcp->payload_seq.start);
562 cfg->keepalive_interval = cpu_to_le16(tcp->data_interval);
563 if (tcp->payload_tok.len) {
564 cfg->token_offset = tcp->payload_tok.offset;
565 cfg->token_length = tcp->payload_tok.len;
566 cfg->num_tokens =
567 cpu_to_le16(tcp->tokens_size % tcp->payload_tok.len);
568 memcpy(cfg->tokens, tcp->payload_tok.token_stream,
569 tcp->tokens_size);
570 } else {
571 /* set tokens to max value to almost never run out */
572 cfg->num_tokens = cpu_to_le16(65535);
573 }
574
575 /* ACK (RX) */
576 iwl_mvm_build_tcp_packet(
577 vif, tcp, cfg->keepalive_ack_rx.data,
578 cfg->keepalive_ack_rx.rx_mask,
579 &cfg->keepalive_ack_rx.info.tcp_pseudo_header_checksum,
580 MVM_TCP_RX_ACK);
581 cfg->keepalive_ack_rx.info.tcp_payload_length = 0;
582
583 /* WAKEUP (RX) */
584 iwl_mvm_build_tcp_packet(
585 vif, tcp, cfg->wake_rx.data, cfg->wake_rx.rx_mask,
586 &cfg->wake_rx.info.tcp_pseudo_header_checksum,
587 MVM_TCP_RX_WAKE);
588 cfg->wake_rx.info.tcp_payload_length =
589 cpu_to_le16(tcp->wake_len);
590
591 /* FIN */
592 iwl_mvm_build_tcp_packet(
593 vif, tcp, cfg->fin_tx.data, NULL,
594 &cfg->fin_tx.info.tcp_pseudo_header_checksum,
595 MVM_TCP_TX_FIN);
596 cfg->fin_tx.info.tcp_payload_length = 0;
597
598 ret = iwl_mvm_send_cmd(mvm, &cmd);
599 kfree(cfg);
600
601 return ret;
602 }
603
iwl_mvm_d3_reprogram(struct iwl_mvm * mvm,struct ieee80211_vif * vif,struct ieee80211_sta * ap_sta)604 static int iwl_mvm_d3_reprogram(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
605 struct ieee80211_sta *ap_sta)
606 {
607 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
608 struct ieee80211_chanctx_conf *ctx;
609 u8 chains_static, chains_dynamic;
610 struct cfg80211_chan_def chandef;
611 int ret, i;
612 struct iwl_binding_cmd binding_cmd = {};
613 struct iwl_time_quota_cmd quota_cmd = {};
614 u32 status;
615
616 /* add back the PHY */
617 if (WARN_ON(!mvmvif->phy_ctxt))
618 return -EINVAL;
619
620 rcu_read_lock();
621 ctx = rcu_dereference(vif->chanctx_conf);
622 if (WARN_ON(!ctx)) {
623 rcu_read_unlock();
624 return -EINVAL;
625 }
626 chandef = ctx->def;
627 chains_static = ctx->rx_chains_static;
628 chains_dynamic = ctx->rx_chains_dynamic;
629 rcu_read_unlock();
630
631 ret = iwl_mvm_phy_ctxt_add(mvm, mvmvif->phy_ctxt, &chandef,
632 chains_static, chains_dynamic);
633 if (ret)
634 return ret;
635
636 /* add back the MAC */
637 mvmvif->uploaded = false;
638
639 if (WARN_ON(!vif->bss_conf.assoc))
640 return -EINVAL;
641
642 ret = iwl_mvm_mac_ctxt_add(mvm, vif);
643 if (ret)
644 return ret;
645
646 /* add back binding - XXX refactor? */
647 binding_cmd.id_and_color =
648 cpu_to_le32(FW_CMD_ID_AND_COLOR(mvmvif->phy_ctxt->id,
649 mvmvif->phy_ctxt->color));
650 binding_cmd.action = cpu_to_le32(FW_CTXT_ACTION_ADD);
651 binding_cmd.phy =
652 cpu_to_le32(FW_CMD_ID_AND_COLOR(mvmvif->phy_ctxt->id,
653 mvmvif->phy_ctxt->color));
654 binding_cmd.macs[0] = cpu_to_le32(FW_CMD_ID_AND_COLOR(mvmvif->id,
655 mvmvif->color));
656 for (i = 1; i < MAX_MACS_IN_BINDING; i++)
657 binding_cmd.macs[i] = cpu_to_le32(FW_CTXT_INVALID);
658
659 status = 0;
660 ret = iwl_mvm_send_cmd_pdu_status(mvm, BINDING_CONTEXT_CMD,
661 sizeof(binding_cmd), &binding_cmd,
662 &status);
663 if (ret) {
664 IWL_ERR(mvm, "Failed to add binding: %d\n", ret);
665 return ret;
666 }
667
668 if (status) {
669 IWL_ERR(mvm, "Binding command failed: %u\n", status);
670 return -EIO;
671 }
672
673 ret = iwl_mvm_sta_send_to_fw(mvm, ap_sta, false);
674 if (ret)
675 return ret;
676 rcu_assign_pointer(mvm->fw_id_to_mac_id[mvmvif->ap_sta_id], ap_sta);
677
678 ret = iwl_mvm_mac_ctxt_changed(mvm, vif, false, NULL);
679 if (ret)
680 return ret;
681
682 /* and some quota */
683 quota_cmd.quotas[0].id_and_color =
684 cpu_to_le32(FW_CMD_ID_AND_COLOR(mvmvif->phy_ctxt->id,
685 mvmvif->phy_ctxt->color));
686 quota_cmd.quotas[0].quota = cpu_to_le32(IWL_MVM_MAX_QUOTA);
687 quota_cmd.quotas[0].max_duration = cpu_to_le32(IWL_MVM_MAX_QUOTA);
688
689 for (i = 1; i < MAX_BINDINGS; i++)
690 quota_cmd.quotas[i].id_and_color = cpu_to_le32(FW_CTXT_INVALID);
691
692 ret = iwl_mvm_send_cmd_pdu(mvm, TIME_QUOTA_CMD, 0,
693 sizeof(quota_cmd), "a_cmd);
694 if (ret)
695 IWL_ERR(mvm, "Failed to send quota: %d\n", ret);
696
697 if (iwl_mvm_is_lar_supported(mvm) && iwl_mvm_init_fw_regd(mvm))
698 IWL_ERR(mvm, "Failed to initialize D3 LAR information\n");
699
700 return 0;
701 }
702
iwl_mvm_get_last_nonqos_seq(struct iwl_mvm * mvm,struct ieee80211_vif * vif)703 static int iwl_mvm_get_last_nonqos_seq(struct iwl_mvm *mvm,
704 struct ieee80211_vif *vif)
705 {
706 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
707 struct iwl_nonqos_seq_query_cmd query_cmd = {
708 .get_set_flag = cpu_to_le32(IWL_NONQOS_SEQ_GET),
709 .mac_id_n_color =
710 cpu_to_le32(FW_CMD_ID_AND_COLOR(mvmvif->id,
711 mvmvif->color)),
712 };
713 struct iwl_host_cmd cmd = {
714 .id = NON_QOS_TX_COUNTER_CMD,
715 .flags = CMD_WANT_SKB,
716 };
717 int err;
718 u32 size;
719
720 cmd.data[0] = &query_cmd;
721 cmd.len[0] = sizeof(query_cmd);
722
723 err = iwl_mvm_send_cmd(mvm, &cmd);
724 if (err)
725 return err;
726
727 size = iwl_rx_packet_payload_len(cmd.resp_pkt);
728 if (size < sizeof(__le16)) {
729 err = -EINVAL;
730 } else {
731 err = le16_to_cpup((__le16 *)cmd.resp_pkt->data);
732 /* firmware returns next, not last-used seqno */
733 err = (u16) (err - 0x10);
734 }
735
736 iwl_free_resp(&cmd);
737 return err;
738 }
739
iwl_mvm_set_last_nonqos_seq(struct iwl_mvm * mvm,struct ieee80211_vif * vif)740 void iwl_mvm_set_last_nonqos_seq(struct iwl_mvm *mvm, struct ieee80211_vif *vif)
741 {
742 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
743 struct iwl_nonqos_seq_query_cmd query_cmd = {
744 .get_set_flag = cpu_to_le32(IWL_NONQOS_SEQ_SET),
745 .mac_id_n_color =
746 cpu_to_le32(FW_CMD_ID_AND_COLOR(mvmvif->id,
747 mvmvif->color)),
748 .value = cpu_to_le16(mvmvif->seqno),
749 };
750
751 /* return if called during restart, not resume from D3 */
752 if (!mvmvif->seqno_valid)
753 return;
754
755 mvmvif->seqno_valid = false;
756
757 if (iwl_mvm_send_cmd_pdu(mvm, NON_QOS_TX_COUNTER_CMD, 0,
758 sizeof(query_cmd), &query_cmd))
759 IWL_ERR(mvm, "failed to set non-QoS seqno\n");
760 }
761
iwl_mvm_switch_to_d3(struct iwl_mvm * mvm)762 static int iwl_mvm_switch_to_d3(struct iwl_mvm *mvm)
763 {
764 iwl_mvm_cancel_scan(mvm);
765
766 iwl_trans_stop_device(mvm->trans);
767
768 /*
769 * Set the HW restart bit -- this is mostly true as we're
770 * going to load new firmware and reprogram that, though
771 * the reprogramming is going to be manual to avoid adding
772 * all the MACs that aren't support.
773 * We don't have to clear up everything though because the
774 * reprogramming is manual. When we resume, we'll actually
775 * go through a proper restart sequence again to switch
776 * back to the runtime firmware image.
777 */
778 set_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status);
779
780 /* We reprogram keys and shouldn't allocate new key indices */
781 memset(mvm->fw_key_table, 0, sizeof(mvm->fw_key_table));
782
783 mvm->ptk_ivlen = 0;
784 mvm->ptk_icvlen = 0;
785 mvm->ptk_ivlen = 0;
786 mvm->ptk_icvlen = 0;
787
788 return iwl_mvm_load_d3_fw(mvm);
789 }
790
791 static int
iwl_mvm_get_wowlan_config(struct iwl_mvm * mvm,struct cfg80211_wowlan * wowlan,struct iwl_wowlan_config_cmd * wowlan_config_cmd,struct ieee80211_vif * vif,struct iwl_mvm_vif * mvmvif,struct ieee80211_sta * ap_sta)792 iwl_mvm_get_wowlan_config(struct iwl_mvm *mvm,
793 struct cfg80211_wowlan *wowlan,
794 struct iwl_wowlan_config_cmd *wowlan_config_cmd,
795 struct ieee80211_vif *vif, struct iwl_mvm_vif *mvmvif,
796 struct ieee80211_sta *ap_sta)
797 {
798 int ret;
799 struct iwl_mvm_sta *mvm_ap_sta = iwl_mvm_sta_from_mac80211(ap_sta);
800
801 /* TODO: wowlan_config_cmd->wowlan_ba_teardown_tids */
802
803 wowlan_config_cmd->is_11n_connection =
804 ap_sta->ht_cap.ht_supported;
805
806 /* Query the last used seqno and set it */
807 ret = iwl_mvm_get_last_nonqos_seq(mvm, vif);
808 if (ret < 0)
809 return ret;
810
811 wowlan_config_cmd->non_qos_seq = cpu_to_le16(ret);
812
813 iwl_mvm_set_wowlan_qos_seq(mvm_ap_sta, wowlan_config_cmd);
814
815 if (wowlan->disconnect)
816 wowlan_config_cmd->wakeup_filter |=
817 cpu_to_le32(IWL_WOWLAN_WAKEUP_BEACON_MISS |
818 IWL_WOWLAN_WAKEUP_LINK_CHANGE);
819 if (wowlan->magic_pkt)
820 wowlan_config_cmd->wakeup_filter |=
821 cpu_to_le32(IWL_WOWLAN_WAKEUP_MAGIC_PACKET);
822 if (wowlan->gtk_rekey_failure)
823 wowlan_config_cmd->wakeup_filter |=
824 cpu_to_le32(IWL_WOWLAN_WAKEUP_GTK_REKEY_FAIL);
825 if (wowlan->eap_identity_req)
826 wowlan_config_cmd->wakeup_filter |=
827 cpu_to_le32(IWL_WOWLAN_WAKEUP_EAP_IDENT_REQ);
828 if (wowlan->four_way_handshake)
829 wowlan_config_cmd->wakeup_filter |=
830 cpu_to_le32(IWL_WOWLAN_WAKEUP_4WAY_HANDSHAKE);
831 if (wowlan->n_patterns)
832 wowlan_config_cmd->wakeup_filter |=
833 cpu_to_le32(IWL_WOWLAN_WAKEUP_PATTERN_MATCH);
834
835 if (wowlan->rfkill_release)
836 wowlan_config_cmd->wakeup_filter |=
837 cpu_to_le32(IWL_WOWLAN_WAKEUP_RF_KILL_DEASSERT);
838
839 if (wowlan->tcp) {
840 /*
841 * Set the "link change" (really "link lost") flag as well
842 * since that implies losing the TCP connection.
843 */
844 wowlan_config_cmd->wakeup_filter |=
845 cpu_to_le32(IWL_WOWLAN_WAKEUP_REMOTE_LINK_LOSS |
846 IWL_WOWLAN_WAKEUP_REMOTE_SIGNATURE_TABLE |
847 IWL_WOWLAN_WAKEUP_REMOTE_WAKEUP_PACKET |
848 IWL_WOWLAN_WAKEUP_LINK_CHANGE);
849 }
850
851 return 0;
852 }
853
854 static int
iwl_mvm_wowlan_config(struct iwl_mvm * mvm,struct cfg80211_wowlan * wowlan,struct iwl_wowlan_config_cmd * wowlan_config_cmd,struct ieee80211_vif * vif,struct iwl_mvm_vif * mvmvif,struct ieee80211_sta * ap_sta)855 iwl_mvm_wowlan_config(struct iwl_mvm *mvm,
856 struct cfg80211_wowlan *wowlan,
857 struct iwl_wowlan_config_cmd *wowlan_config_cmd,
858 struct ieee80211_vif *vif, struct iwl_mvm_vif *mvmvif,
859 struct ieee80211_sta *ap_sta)
860 {
861 struct iwl_wowlan_kek_kck_material_cmd kek_kck_cmd = {};
862 struct iwl_wowlan_tkip_params_cmd tkip_cmd = {};
863 struct wowlan_key_data key_data = {
864 .use_rsc_tsc = false,
865 .tkip = &tkip_cmd,
866 .use_tkip = false,
867 };
868 int ret;
869
870 ret = iwl_mvm_switch_to_d3(mvm);
871 if (ret)
872 return ret;
873
874 ret = iwl_mvm_d3_reprogram(mvm, vif, ap_sta);
875 if (ret)
876 return ret;
877
878 key_data.rsc_tsc = kzalloc(sizeof(*key_data.rsc_tsc), GFP_KERNEL);
879 if (!key_data.rsc_tsc)
880 return -ENOMEM;
881
882 if (!iwlwifi_mod_params.sw_crypto) {
883 /*
884 * This needs to be unlocked due to lock ordering
885 * constraints. Since we're in the suspend path
886 * that isn't really a problem though.
887 */
888 mutex_unlock(&mvm->mutex);
889 ieee80211_iter_keys(mvm->hw, vif,
890 iwl_mvm_wowlan_program_keys,
891 &key_data);
892 mutex_lock(&mvm->mutex);
893 if (key_data.error) {
894 ret = -EIO;
895 goto out;
896 }
897
898 if (key_data.use_rsc_tsc) {
899 struct iwl_host_cmd rsc_tsc_cmd = {
900 .id = WOWLAN_TSC_RSC_PARAM,
901 .data[0] = key_data.rsc_tsc,
902 .dataflags[0] = IWL_HCMD_DFL_NOCOPY,
903 .len[0] = sizeof(*key_data.rsc_tsc),
904 };
905
906 ret = iwl_mvm_send_cmd(mvm, &rsc_tsc_cmd);
907 if (ret)
908 goto out;
909 }
910
911 if (key_data.use_tkip) {
912 ret = iwl_mvm_send_cmd_pdu(mvm,
913 WOWLAN_TKIP_PARAM,
914 0, sizeof(tkip_cmd),
915 &tkip_cmd);
916 if (ret)
917 goto out;
918 }
919
920 if (mvmvif->rekey_data.valid) {
921 memset(&kek_kck_cmd, 0, sizeof(kek_kck_cmd));
922 memcpy(kek_kck_cmd.kck, mvmvif->rekey_data.kck,
923 NL80211_KCK_LEN);
924 kek_kck_cmd.kck_len = cpu_to_le16(NL80211_KCK_LEN);
925 memcpy(kek_kck_cmd.kek, mvmvif->rekey_data.kek,
926 NL80211_KEK_LEN);
927 kek_kck_cmd.kek_len = cpu_to_le16(NL80211_KEK_LEN);
928 kek_kck_cmd.replay_ctr = mvmvif->rekey_data.replay_ctr;
929
930 ret = iwl_mvm_send_cmd_pdu(mvm,
931 WOWLAN_KEK_KCK_MATERIAL, 0,
932 sizeof(kek_kck_cmd),
933 &kek_kck_cmd);
934 if (ret)
935 goto out;
936 }
937 }
938
939 ret = iwl_mvm_send_cmd_pdu(mvm, WOWLAN_CONFIGURATION, 0,
940 sizeof(*wowlan_config_cmd),
941 wowlan_config_cmd);
942 if (ret)
943 goto out;
944
945 ret = iwl_mvm_send_patterns(mvm, wowlan);
946 if (ret)
947 goto out;
948
949 ret = iwl_mvm_send_proto_offload(mvm, vif, false, 0);
950 if (ret)
951 goto out;
952
953 ret = iwl_mvm_send_remote_wake_cfg(mvm, vif, wowlan->tcp);
954
955 out:
956 kfree(key_data.rsc_tsc);
957 return ret;
958 }
959
960 static int
iwl_mvm_netdetect_config(struct iwl_mvm * mvm,struct cfg80211_wowlan * wowlan,struct cfg80211_sched_scan_request * nd_config,struct ieee80211_vif * vif)961 iwl_mvm_netdetect_config(struct iwl_mvm *mvm,
962 struct cfg80211_wowlan *wowlan,
963 struct cfg80211_sched_scan_request *nd_config,
964 struct ieee80211_vif *vif)
965 {
966 struct iwl_wowlan_config_cmd wowlan_config_cmd = {};
967 int ret;
968
969 ret = iwl_mvm_switch_to_d3(mvm);
970 if (ret)
971 return ret;
972
973 /* rfkill release can be either for wowlan or netdetect */
974 if (wowlan->rfkill_release)
975 wowlan_config_cmd.wakeup_filter |=
976 cpu_to_le32(IWL_WOWLAN_WAKEUP_RF_KILL_DEASSERT);
977
978 ret = iwl_mvm_send_cmd_pdu(mvm, WOWLAN_CONFIGURATION, 0,
979 sizeof(wowlan_config_cmd),
980 &wowlan_config_cmd);
981 if (ret)
982 return ret;
983
984 ret = iwl_mvm_scan_offload_start(mvm, vif, nd_config, &mvm->nd_ies);
985 if (ret)
986 return ret;
987
988 if (WARN_ON(mvm->nd_match_sets || mvm->nd_channels))
989 return -EBUSY;
990
991 /* save the sched scan matchsets... */
992 if (nd_config->n_match_sets) {
993 mvm->nd_match_sets = kmemdup(nd_config->match_sets,
994 sizeof(*nd_config->match_sets) *
995 nd_config->n_match_sets,
996 GFP_KERNEL);
997 if (mvm->nd_match_sets)
998 mvm->n_nd_match_sets = nd_config->n_match_sets;
999 }
1000
1001 /* ...and the sched scan channels for later reporting */
1002 mvm->nd_channels = kmemdup(nd_config->channels,
1003 sizeof(*nd_config->channels) *
1004 nd_config->n_channels,
1005 GFP_KERNEL);
1006 if (mvm->nd_channels)
1007 mvm->n_nd_channels = nd_config->n_channels;
1008
1009 return 0;
1010 }
1011
iwl_mvm_free_nd(struct iwl_mvm * mvm)1012 static void iwl_mvm_free_nd(struct iwl_mvm *mvm)
1013 {
1014 kfree(mvm->nd_match_sets);
1015 mvm->nd_match_sets = NULL;
1016 mvm->n_nd_match_sets = 0;
1017 kfree(mvm->nd_channels);
1018 mvm->nd_channels = NULL;
1019 mvm->n_nd_channels = 0;
1020 }
1021
__iwl_mvm_suspend(struct ieee80211_hw * hw,struct cfg80211_wowlan * wowlan,bool test)1022 static int __iwl_mvm_suspend(struct ieee80211_hw *hw,
1023 struct cfg80211_wowlan *wowlan,
1024 bool test)
1025 {
1026 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
1027 struct ieee80211_vif *vif = NULL;
1028 struct iwl_mvm_vif *mvmvif = NULL;
1029 struct ieee80211_sta *ap_sta = NULL;
1030 struct iwl_d3_manager_config d3_cfg_cmd_data = {
1031 /*
1032 * Program the minimum sleep time to 10 seconds, as many
1033 * platforms have issues processing a wakeup signal while
1034 * still being in the process of suspending.
1035 */
1036 .min_sleep_time = cpu_to_le32(10 * 1000 * 1000),
1037 };
1038 struct iwl_host_cmd d3_cfg_cmd = {
1039 .id = D3_CONFIG_CMD,
1040 .flags = CMD_WANT_SKB,
1041 .data[0] = &d3_cfg_cmd_data,
1042 .len[0] = sizeof(d3_cfg_cmd_data),
1043 };
1044 int ret;
1045 int len __maybe_unused;
1046
1047 if (!wowlan) {
1048 /*
1049 * mac80211 shouldn't get here, but for D3 test
1050 * it doesn't warrant a warning
1051 */
1052 WARN_ON(!test);
1053 return -EINVAL;
1054 }
1055
1056 mutex_lock(&mvm->mutex);
1057
1058 vif = iwl_mvm_get_bss_vif(mvm);
1059 if (IS_ERR_OR_NULL(vif)) {
1060 ret = 1;
1061 goto out_noreset;
1062 }
1063
1064 mvmvif = iwl_mvm_vif_from_mac80211(vif);
1065
1066 if (mvmvif->ap_sta_id == IWL_MVM_STATION_COUNT) {
1067 /* if we're not associated, this must be netdetect */
1068 if (!wowlan->nd_config && !mvm->nd_config) {
1069 ret = 1;
1070 goto out_noreset;
1071 }
1072
1073 ret = iwl_mvm_netdetect_config(
1074 mvm, wowlan, wowlan->nd_config ?: mvm->nd_config, vif);
1075 if (ret)
1076 goto out;
1077
1078 mvm->net_detect = true;
1079 } else {
1080 struct iwl_wowlan_config_cmd wowlan_config_cmd = {};
1081
1082 ap_sta = rcu_dereference_protected(
1083 mvm->fw_id_to_mac_id[mvmvif->ap_sta_id],
1084 lockdep_is_held(&mvm->mutex));
1085 if (IS_ERR_OR_NULL(ap_sta)) {
1086 ret = -EINVAL;
1087 goto out_noreset;
1088 }
1089
1090 ret = iwl_mvm_get_wowlan_config(mvm, wowlan, &wowlan_config_cmd,
1091 vif, mvmvif, ap_sta);
1092 if (ret)
1093 goto out_noreset;
1094 ret = iwl_mvm_wowlan_config(mvm, wowlan, &wowlan_config_cmd,
1095 vif, mvmvif, ap_sta);
1096 if (ret)
1097 goto out;
1098
1099 mvm->net_detect = false;
1100 }
1101
1102 ret = iwl_mvm_power_update_device(mvm);
1103 if (ret)
1104 goto out;
1105
1106 ret = iwl_mvm_power_update_mac(mvm);
1107 if (ret)
1108 goto out;
1109
1110 #ifdef CONFIG_IWLWIFI_DEBUGFS
1111 if (mvm->d3_wake_sysassert)
1112 d3_cfg_cmd_data.wakeup_flags |=
1113 cpu_to_le32(IWL_WAKEUP_D3_CONFIG_FW_ERROR);
1114 #endif
1115
1116 /* must be last -- this switches firmware state */
1117 ret = iwl_mvm_send_cmd(mvm, &d3_cfg_cmd);
1118 if (ret)
1119 goto out;
1120 #ifdef CONFIG_IWLWIFI_DEBUGFS
1121 len = iwl_rx_packet_payload_len(d3_cfg_cmd.resp_pkt);
1122 if (len >= sizeof(u32)) {
1123 mvm->d3_test_pme_ptr =
1124 le32_to_cpup((__le32 *)d3_cfg_cmd.resp_pkt->data);
1125 }
1126 #endif
1127 iwl_free_resp(&d3_cfg_cmd);
1128
1129 clear_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status);
1130
1131 iwl_trans_d3_suspend(mvm->trans, test);
1132 out:
1133 if (ret < 0) {
1134 iwl_mvm_ref(mvm, IWL_MVM_REF_UCODE_DOWN);
1135 ieee80211_restart_hw(mvm->hw);
1136 iwl_mvm_free_nd(mvm);
1137 }
1138 out_noreset:
1139 mutex_unlock(&mvm->mutex);
1140
1141 return ret;
1142 }
1143
iwl_mvm_enter_d0i3_sync(struct iwl_mvm * mvm)1144 static int iwl_mvm_enter_d0i3_sync(struct iwl_mvm *mvm)
1145 {
1146 struct iwl_notification_wait wait_d3;
1147 static const u8 d3_notif[] = { D3_CONFIG_CMD };
1148 int ret;
1149
1150 iwl_init_notification_wait(&mvm->notif_wait, &wait_d3,
1151 d3_notif, ARRAY_SIZE(d3_notif),
1152 NULL, NULL);
1153
1154 ret = iwl_mvm_enter_d0i3(mvm->hw->priv);
1155 if (ret)
1156 goto remove_notif;
1157
1158 ret = iwl_wait_notification(&mvm->notif_wait, &wait_d3, HZ);
1159 WARN_ON_ONCE(ret);
1160 return ret;
1161
1162 remove_notif:
1163 iwl_remove_notification(&mvm->notif_wait, &wait_d3);
1164 return ret;
1165 }
1166
iwl_mvm_suspend(struct ieee80211_hw * hw,struct cfg80211_wowlan * wowlan)1167 int iwl_mvm_suspend(struct ieee80211_hw *hw, struct cfg80211_wowlan *wowlan)
1168 {
1169 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
1170
1171 iwl_trans_suspend(mvm->trans);
1172 if (wowlan->any) {
1173 /* 'any' trigger means d0i3 usage */
1174 if (mvm->trans->d0i3_mode == IWL_D0I3_MODE_ON_SUSPEND) {
1175 int ret = iwl_mvm_enter_d0i3_sync(mvm);
1176
1177 if (ret)
1178 return ret;
1179 }
1180
1181 mutex_lock(&mvm->d0i3_suspend_mutex);
1182 __set_bit(D0I3_DEFER_WAKEUP, &mvm->d0i3_suspend_flags);
1183 mutex_unlock(&mvm->d0i3_suspend_mutex);
1184 return 0;
1185 }
1186
1187 return __iwl_mvm_suspend(hw, wowlan, false);
1188 }
1189
1190 /* converted data from the different status responses */
1191 struct iwl_wowlan_status_data {
1192 u16 pattern_number;
1193 u16 qos_seq_ctr[8];
1194 u32 wakeup_reasons;
1195 u32 wake_packet_length;
1196 u32 wake_packet_bufsize;
1197 const u8 *wake_packet;
1198 };
1199
iwl_mvm_report_wakeup_reasons(struct iwl_mvm * mvm,struct ieee80211_vif * vif,struct iwl_wowlan_status_data * status)1200 static void iwl_mvm_report_wakeup_reasons(struct iwl_mvm *mvm,
1201 struct ieee80211_vif *vif,
1202 struct iwl_wowlan_status_data *status)
1203 {
1204 struct sk_buff *pkt = NULL;
1205 struct cfg80211_wowlan_wakeup wakeup = {
1206 .pattern_idx = -1,
1207 };
1208 struct cfg80211_wowlan_wakeup *wakeup_report = &wakeup;
1209 u32 reasons = status->wakeup_reasons;
1210
1211 if (reasons == IWL_WOWLAN_WAKEUP_BY_NON_WIRELESS) {
1212 wakeup_report = NULL;
1213 goto report;
1214 }
1215
1216 if (reasons & IWL_WOWLAN_WAKEUP_BY_MAGIC_PACKET)
1217 wakeup.magic_pkt = true;
1218
1219 if (reasons & IWL_WOWLAN_WAKEUP_BY_PATTERN)
1220 wakeup.pattern_idx =
1221 status->pattern_number;
1222
1223 if (reasons & (IWL_WOWLAN_WAKEUP_BY_DISCONNECTION_ON_MISSED_BEACON |
1224 IWL_WOWLAN_WAKEUP_BY_DISCONNECTION_ON_DEAUTH))
1225 wakeup.disconnect = true;
1226
1227 if (reasons & IWL_WOWLAN_WAKEUP_BY_GTK_REKEY_FAILURE)
1228 wakeup.gtk_rekey_failure = true;
1229
1230 if (reasons & IWL_WOWLAN_WAKEUP_BY_RFKILL_DEASSERTED)
1231 wakeup.rfkill_release = true;
1232
1233 if (reasons & IWL_WOWLAN_WAKEUP_BY_EAPOL_REQUEST)
1234 wakeup.eap_identity_req = true;
1235
1236 if (reasons & IWL_WOWLAN_WAKEUP_BY_FOUR_WAY_HANDSHAKE)
1237 wakeup.four_way_handshake = true;
1238
1239 if (reasons & IWL_WOWLAN_WAKEUP_BY_REM_WAKE_LINK_LOSS)
1240 wakeup.tcp_connlost = true;
1241
1242 if (reasons & IWL_WOWLAN_WAKEUP_BY_REM_WAKE_SIGNATURE_TABLE)
1243 wakeup.tcp_nomoretokens = true;
1244
1245 if (reasons & IWL_WOWLAN_WAKEUP_BY_REM_WAKE_WAKEUP_PACKET)
1246 wakeup.tcp_match = true;
1247
1248 if (status->wake_packet_bufsize) {
1249 int pktsize = status->wake_packet_bufsize;
1250 int pktlen = status->wake_packet_length;
1251 const u8 *pktdata = status->wake_packet;
1252 struct ieee80211_hdr *hdr = (void *)pktdata;
1253 int truncated = pktlen - pktsize;
1254
1255 /* this would be a firmware bug */
1256 if (WARN_ON_ONCE(truncated < 0))
1257 truncated = 0;
1258
1259 if (ieee80211_is_data(hdr->frame_control)) {
1260 int hdrlen = ieee80211_hdrlen(hdr->frame_control);
1261 int ivlen = 0, icvlen = 4; /* also FCS */
1262
1263 pkt = alloc_skb(pktsize, GFP_KERNEL);
1264 if (!pkt)
1265 goto report;
1266
1267 memcpy(skb_put(pkt, hdrlen), pktdata, hdrlen);
1268 pktdata += hdrlen;
1269 pktsize -= hdrlen;
1270
1271 if (ieee80211_has_protected(hdr->frame_control)) {
1272 /*
1273 * This is unlocked and using gtk_i(c)vlen,
1274 * but since everything is under RTNL still
1275 * that's not really a problem - changing
1276 * it would be difficult.
1277 */
1278 if (is_multicast_ether_addr(hdr->addr1)) {
1279 ivlen = mvm->gtk_ivlen;
1280 icvlen += mvm->gtk_icvlen;
1281 } else {
1282 ivlen = mvm->ptk_ivlen;
1283 icvlen += mvm->ptk_icvlen;
1284 }
1285 }
1286
1287 /* if truncated, FCS/ICV is (partially) gone */
1288 if (truncated >= icvlen) {
1289 icvlen = 0;
1290 truncated -= icvlen;
1291 } else {
1292 icvlen -= truncated;
1293 truncated = 0;
1294 }
1295
1296 pktsize -= ivlen + icvlen;
1297 pktdata += ivlen;
1298
1299 memcpy(skb_put(pkt, pktsize), pktdata, pktsize);
1300
1301 if (ieee80211_data_to_8023(pkt, vif->addr, vif->type))
1302 goto report;
1303 wakeup.packet = pkt->data;
1304 wakeup.packet_present_len = pkt->len;
1305 wakeup.packet_len = pkt->len - truncated;
1306 wakeup.packet_80211 = false;
1307 } else {
1308 int fcslen = 4;
1309
1310 if (truncated >= 4) {
1311 truncated -= 4;
1312 fcslen = 0;
1313 } else {
1314 fcslen -= truncated;
1315 truncated = 0;
1316 }
1317 pktsize -= fcslen;
1318 wakeup.packet = status->wake_packet;
1319 wakeup.packet_present_len = pktsize;
1320 wakeup.packet_len = pktlen - truncated;
1321 wakeup.packet_80211 = true;
1322 }
1323 }
1324
1325 report:
1326 ieee80211_report_wowlan_wakeup(vif, wakeup_report, GFP_KERNEL);
1327 kfree_skb(pkt);
1328 }
1329
iwl_mvm_aes_sc_to_seq(struct aes_sc * sc,struct ieee80211_key_seq * seq)1330 static void iwl_mvm_aes_sc_to_seq(struct aes_sc *sc,
1331 struct ieee80211_key_seq *seq)
1332 {
1333 u64 pn;
1334
1335 pn = le64_to_cpu(sc->pn);
1336 seq->ccmp.pn[0] = pn >> 40;
1337 seq->ccmp.pn[1] = pn >> 32;
1338 seq->ccmp.pn[2] = pn >> 24;
1339 seq->ccmp.pn[3] = pn >> 16;
1340 seq->ccmp.pn[4] = pn >> 8;
1341 seq->ccmp.pn[5] = pn;
1342 }
1343
iwl_mvm_tkip_sc_to_seq(struct tkip_sc * sc,struct ieee80211_key_seq * seq)1344 static void iwl_mvm_tkip_sc_to_seq(struct tkip_sc *sc,
1345 struct ieee80211_key_seq *seq)
1346 {
1347 seq->tkip.iv32 = le32_to_cpu(sc->iv32);
1348 seq->tkip.iv16 = le16_to_cpu(sc->iv16);
1349 }
1350
iwl_mvm_set_aes_rx_seq(struct aes_sc * scs,struct ieee80211_key_conf * key)1351 static void iwl_mvm_set_aes_rx_seq(struct aes_sc *scs,
1352 struct ieee80211_key_conf *key)
1353 {
1354 int tid;
1355
1356 BUILD_BUG_ON(IWL_NUM_RSC != IEEE80211_NUM_TIDS);
1357
1358 for (tid = 0; tid < IWL_NUM_RSC; tid++) {
1359 struct ieee80211_key_seq seq = {};
1360
1361 iwl_mvm_aes_sc_to_seq(&scs[tid], &seq);
1362 ieee80211_set_key_rx_seq(key, tid, &seq);
1363 }
1364 }
1365
iwl_mvm_set_tkip_rx_seq(struct tkip_sc * scs,struct ieee80211_key_conf * key)1366 static void iwl_mvm_set_tkip_rx_seq(struct tkip_sc *scs,
1367 struct ieee80211_key_conf *key)
1368 {
1369 int tid;
1370
1371 BUILD_BUG_ON(IWL_NUM_RSC != IEEE80211_NUM_TIDS);
1372
1373 for (tid = 0; tid < IWL_NUM_RSC; tid++) {
1374 struct ieee80211_key_seq seq = {};
1375
1376 iwl_mvm_tkip_sc_to_seq(&scs[tid], &seq);
1377 ieee80211_set_key_rx_seq(key, tid, &seq);
1378 }
1379 }
1380
iwl_mvm_set_key_rx_seq(struct ieee80211_key_conf * key,struct iwl_wowlan_status * status)1381 static void iwl_mvm_set_key_rx_seq(struct ieee80211_key_conf *key,
1382 struct iwl_wowlan_status *status)
1383 {
1384 union iwl_all_tsc_rsc *rsc = &status->gtk.rsc.all_tsc_rsc;
1385
1386 switch (key->cipher) {
1387 case WLAN_CIPHER_SUITE_CCMP:
1388 iwl_mvm_set_aes_rx_seq(rsc->aes.multicast_rsc, key);
1389 break;
1390 case WLAN_CIPHER_SUITE_TKIP:
1391 iwl_mvm_set_tkip_rx_seq(rsc->tkip.multicast_rsc, key);
1392 break;
1393 default:
1394 WARN_ON(1);
1395 }
1396 }
1397
1398 struct iwl_mvm_d3_gtk_iter_data {
1399 struct iwl_wowlan_status *status;
1400 void *last_gtk;
1401 u32 cipher;
1402 bool find_phase, unhandled_cipher;
1403 int num_keys;
1404 };
1405
iwl_mvm_d3_update_gtks(struct ieee80211_hw * hw,struct ieee80211_vif * vif,struct ieee80211_sta * sta,struct ieee80211_key_conf * key,void * _data)1406 static void iwl_mvm_d3_update_gtks(struct ieee80211_hw *hw,
1407 struct ieee80211_vif *vif,
1408 struct ieee80211_sta *sta,
1409 struct ieee80211_key_conf *key,
1410 void *_data)
1411 {
1412 struct iwl_mvm_d3_gtk_iter_data *data = _data;
1413
1414 if (data->unhandled_cipher)
1415 return;
1416
1417 switch (key->cipher) {
1418 case WLAN_CIPHER_SUITE_WEP40:
1419 case WLAN_CIPHER_SUITE_WEP104:
1420 /* ignore WEP completely, nothing to do */
1421 return;
1422 case WLAN_CIPHER_SUITE_CCMP:
1423 case WLAN_CIPHER_SUITE_TKIP:
1424 /* we support these */
1425 break;
1426 default:
1427 /* everything else (even CMAC for MFP) - disconnect from AP */
1428 data->unhandled_cipher = true;
1429 return;
1430 }
1431
1432 data->num_keys++;
1433
1434 /*
1435 * pairwise key - update sequence counters only;
1436 * note that this assumes no TDLS sessions are active
1437 */
1438 if (sta) {
1439 struct ieee80211_key_seq seq = {};
1440 union iwl_all_tsc_rsc *sc = &data->status->gtk.rsc.all_tsc_rsc;
1441
1442 if (data->find_phase)
1443 return;
1444
1445 switch (key->cipher) {
1446 case WLAN_CIPHER_SUITE_CCMP:
1447 iwl_mvm_aes_sc_to_seq(&sc->aes.tsc, &seq);
1448 iwl_mvm_set_aes_rx_seq(sc->aes.unicast_rsc, key);
1449 break;
1450 case WLAN_CIPHER_SUITE_TKIP:
1451 iwl_mvm_tkip_sc_to_seq(&sc->tkip.tsc, &seq);
1452 iwl_mvm_set_tkip_rx_seq(sc->tkip.unicast_rsc, key);
1453 break;
1454 }
1455 ieee80211_set_key_tx_seq(key, &seq);
1456
1457 /* that's it for this key */
1458 return;
1459 }
1460
1461 if (data->find_phase) {
1462 data->last_gtk = key;
1463 data->cipher = key->cipher;
1464 return;
1465 }
1466
1467 if (data->status->num_of_gtk_rekeys)
1468 ieee80211_remove_key(key);
1469 else if (data->last_gtk == key)
1470 iwl_mvm_set_key_rx_seq(key, data->status);
1471 }
1472
iwl_mvm_setup_connection_keep(struct iwl_mvm * mvm,struct ieee80211_vif * vif,struct iwl_wowlan_status * status)1473 static bool iwl_mvm_setup_connection_keep(struct iwl_mvm *mvm,
1474 struct ieee80211_vif *vif,
1475 struct iwl_wowlan_status *status)
1476 {
1477 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
1478 struct iwl_mvm_d3_gtk_iter_data gtkdata = {
1479 .status = status,
1480 };
1481 u32 disconnection_reasons =
1482 IWL_WOWLAN_WAKEUP_BY_DISCONNECTION_ON_MISSED_BEACON |
1483 IWL_WOWLAN_WAKEUP_BY_DISCONNECTION_ON_DEAUTH;
1484
1485 if (!status || !vif->bss_conf.bssid)
1486 return false;
1487
1488 if (le32_to_cpu(status->wakeup_reasons) & disconnection_reasons)
1489 return false;
1490
1491 /* find last GTK that we used initially, if any */
1492 gtkdata.find_phase = true;
1493 ieee80211_iter_keys(mvm->hw, vif,
1494 iwl_mvm_d3_update_gtks, >kdata);
1495 /* not trying to keep connections with MFP/unhandled ciphers */
1496 if (gtkdata.unhandled_cipher)
1497 return false;
1498 if (!gtkdata.num_keys)
1499 goto out;
1500 if (!gtkdata.last_gtk)
1501 return false;
1502
1503 /*
1504 * invalidate all other GTKs that might still exist and update
1505 * the one that we used
1506 */
1507 gtkdata.find_phase = false;
1508 ieee80211_iter_keys(mvm->hw, vif,
1509 iwl_mvm_d3_update_gtks, >kdata);
1510
1511 if (status->num_of_gtk_rekeys) {
1512 struct ieee80211_key_conf *key;
1513 struct {
1514 struct ieee80211_key_conf conf;
1515 u8 key[32];
1516 } conf = {
1517 .conf.cipher = gtkdata.cipher,
1518 .conf.keyidx = status->gtk.key_index,
1519 };
1520
1521 switch (gtkdata.cipher) {
1522 case WLAN_CIPHER_SUITE_CCMP:
1523 conf.conf.keylen = WLAN_KEY_LEN_CCMP;
1524 memcpy(conf.conf.key, status->gtk.decrypt_key,
1525 WLAN_KEY_LEN_CCMP);
1526 break;
1527 case WLAN_CIPHER_SUITE_TKIP:
1528 conf.conf.keylen = WLAN_KEY_LEN_TKIP;
1529 memcpy(conf.conf.key, status->gtk.decrypt_key, 16);
1530 /* leave TX MIC key zeroed, we don't use it anyway */
1531 memcpy(conf.conf.key +
1532 NL80211_TKIP_DATA_OFFSET_RX_MIC_KEY,
1533 status->gtk.tkip_mic_key, 8);
1534 break;
1535 }
1536
1537 key = ieee80211_gtk_rekey_add(vif, &conf.conf);
1538 if (IS_ERR(key))
1539 return false;
1540 iwl_mvm_set_key_rx_seq(key, status);
1541 }
1542
1543 if (status->num_of_gtk_rekeys) {
1544 __be64 replay_ctr =
1545 cpu_to_be64(le64_to_cpu(status->replay_ctr));
1546 ieee80211_gtk_rekey_notify(vif, vif->bss_conf.bssid,
1547 (void *)&replay_ctr, GFP_KERNEL);
1548 }
1549
1550 out:
1551 mvmvif->seqno_valid = true;
1552 /* +0x10 because the set API expects next-to-use, not last-used */
1553 mvmvif->seqno = le16_to_cpu(status->non_qos_seq_ctr) + 0x10;
1554
1555 return true;
1556 }
1557
1558 static struct iwl_wowlan_status *
iwl_mvm_get_wakeup_status(struct iwl_mvm * mvm,struct ieee80211_vif * vif)1559 iwl_mvm_get_wakeup_status(struct iwl_mvm *mvm, struct ieee80211_vif *vif)
1560 {
1561 u32 base = mvm->error_event_table;
1562 struct error_table_start {
1563 /* cf. struct iwl_error_event_table */
1564 u32 valid;
1565 u32 error_id;
1566 } err_info;
1567 struct iwl_host_cmd cmd = {
1568 .id = WOWLAN_GET_STATUSES,
1569 .flags = CMD_WANT_SKB,
1570 };
1571 struct iwl_wowlan_status *status, *fw_status;
1572 int ret, len, status_size;
1573
1574 iwl_trans_read_mem_bytes(mvm->trans, base,
1575 &err_info, sizeof(err_info));
1576
1577 if (err_info.valid) {
1578 IWL_INFO(mvm, "error table is valid (%d) with error (%d)\n",
1579 err_info.valid, err_info.error_id);
1580 if (err_info.error_id == RF_KILL_INDICATOR_FOR_WOWLAN) {
1581 struct cfg80211_wowlan_wakeup wakeup = {
1582 .rfkill_release = true,
1583 };
1584 ieee80211_report_wowlan_wakeup(vif, &wakeup,
1585 GFP_KERNEL);
1586 }
1587 return ERR_PTR(-EIO);
1588 }
1589
1590 /* only for tracing for now */
1591 ret = iwl_mvm_send_cmd_pdu(mvm, OFFLOADS_QUERY_CMD, 0, 0, NULL);
1592 if (ret)
1593 IWL_ERR(mvm, "failed to query offload statistics (%d)\n", ret);
1594
1595 ret = iwl_mvm_send_cmd(mvm, &cmd);
1596 if (ret) {
1597 IWL_ERR(mvm, "failed to query status (%d)\n", ret);
1598 return ERR_PTR(ret);
1599 }
1600
1601 /* RF-kill already asserted again... */
1602 if (!cmd.resp_pkt) {
1603 fw_status = ERR_PTR(-ERFKILL);
1604 goto out_free_resp;
1605 }
1606
1607 status_size = sizeof(*fw_status);
1608
1609 len = iwl_rx_packet_payload_len(cmd.resp_pkt);
1610 if (len < status_size) {
1611 IWL_ERR(mvm, "Invalid WoWLAN status response!\n");
1612 fw_status = ERR_PTR(-EIO);
1613 goto out_free_resp;
1614 }
1615
1616 status = (void *)cmd.resp_pkt->data;
1617 if (len != (status_size +
1618 ALIGN(le32_to_cpu(status->wake_packet_bufsize), 4))) {
1619 IWL_ERR(mvm, "Invalid WoWLAN status response!\n");
1620 fw_status = ERR_PTR(-EIO);
1621 goto out_free_resp;
1622 }
1623
1624 fw_status = kmemdup(status, len, GFP_KERNEL);
1625
1626 out_free_resp:
1627 iwl_free_resp(&cmd);
1628 return fw_status;
1629 }
1630
1631 /* releases the MVM mutex */
iwl_mvm_query_wakeup_reasons(struct iwl_mvm * mvm,struct ieee80211_vif * vif)1632 static bool iwl_mvm_query_wakeup_reasons(struct iwl_mvm *mvm,
1633 struct ieee80211_vif *vif)
1634 {
1635 struct iwl_wowlan_status_data status;
1636 struct iwl_wowlan_status *fw_status;
1637 int i;
1638 bool keep;
1639 struct ieee80211_sta *ap_sta;
1640 struct iwl_mvm_sta *mvm_ap_sta;
1641
1642 fw_status = iwl_mvm_get_wakeup_status(mvm, vif);
1643 if (IS_ERR_OR_NULL(fw_status))
1644 goto out_unlock;
1645
1646 status.pattern_number = le16_to_cpu(fw_status->pattern_number);
1647 for (i = 0; i < 8; i++)
1648 status.qos_seq_ctr[i] =
1649 le16_to_cpu(fw_status->qos_seq_ctr[i]);
1650 status.wakeup_reasons = le32_to_cpu(fw_status->wakeup_reasons);
1651 status.wake_packet_length =
1652 le32_to_cpu(fw_status->wake_packet_length);
1653 status.wake_packet_bufsize =
1654 le32_to_cpu(fw_status->wake_packet_bufsize);
1655 status.wake_packet = fw_status->wake_packet;
1656
1657 /* still at hard-coded place 0 for D3 image */
1658 ap_sta = rcu_dereference_protected(
1659 mvm->fw_id_to_mac_id[0],
1660 lockdep_is_held(&mvm->mutex));
1661 if (IS_ERR_OR_NULL(ap_sta))
1662 goto out_free;
1663
1664 mvm_ap_sta = iwl_mvm_sta_from_mac80211(ap_sta);
1665 for (i = 0; i < IWL_MAX_TID_COUNT; i++) {
1666 u16 seq = status.qos_seq_ctr[i];
1667 /* firmware stores last-used value, we store next value */
1668 seq += 0x10;
1669 mvm_ap_sta->tid_data[i].seq_number = seq;
1670 }
1671
1672 /* now we have all the data we need, unlock to avoid mac80211 issues */
1673 mutex_unlock(&mvm->mutex);
1674
1675 iwl_mvm_report_wakeup_reasons(mvm, vif, &status);
1676
1677 keep = iwl_mvm_setup_connection_keep(mvm, vif, fw_status);
1678
1679 kfree(fw_status);
1680 return keep;
1681
1682 out_free:
1683 kfree(fw_status);
1684 out_unlock:
1685 mutex_unlock(&mvm->mutex);
1686 return false;
1687 }
1688
1689 struct iwl_mvm_nd_query_results {
1690 u32 matched_profiles;
1691 struct iwl_scan_offload_profile_match matches[IWL_SCAN_MAX_PROFILES];
1692 };
1693
1694 static int
iwl_mvm_netdetect_query_results(struct iwl_mvm * mvm,struct iwl_mvm_nd_query_results * results)1695 iwl_mvm_netdetect_query_results(struct iwl_mvm *mvm,
1696 struct iwl_mvm_nd_query_results *results)
1697 {
1698 struct iwl_scan_offload_profiles_query *query;
1699 struct iwl_host_cmd cmd = {
1700 .id = SCAN_OFFLOAD_PROFILES_QUERY_CMD,
1701 .flags = CMD_WANT_SKB,
1702 };
1703 int ret, len;
1704
1705 ret = iwl_mvm_send_cmd(mvm, &cmd);
1706 if (ret) {
1707 IWL_ERR(mvm, "failed to query matched profiles (%d)\n", ret);
1708 return ret;
1709 }
1710
1711 /* RF-kill already asserted again... */
1712 if (!cmd.resp_pkt) {
1713 ret = -ERFKILL;
1714 goto out_free_resp;
1715 }
1716
1717 len = iwl_rx_packet_payload_len(cmd.resp_pkt);
1718 if (len < sizeof(*query)) {
1719 IWL_ERR(mvm, "Invalid scan offload profiles query response!\n");
1720 ret = -EIO;
1721 goto out_free_resp;
1722 }
1723
1724 query = (void *)cmd.resp_pkt->data;
1725
1726 results->matched_profiles = le32_to_cpu(query->matched_profiles);
1727 memcpy(results->matches, query->matches, sizeof(results->matches));
1728
1729 #ifdef CONFIG_IWLWIFI_DEBUGFS
1730 mvm->last_netdetect_scans = le32_to_cpu(query->n_scans_done);
1731 #endif
1732
1733 out_free_resp:
1734 iwl_free_resp(&cmd);
1735 return ret;
1736 }
1737
iwl_mvm_query_netdetect_reasons(struct iwl_mvm * mvm,struct ieee80211_vif * vif)1738 static void iwl_mvm_query_netdetect_reasons(struct iwl_mvm *mvm,
1739 struct ieee80211_vif *vif)
1740 {
1741 struct cfg80211_wowlan_nd_info *net_detect = NULL;
1742 struct cfg80211_wowlan_wakeup wakeup = {
1743 .pattern_idx = -1,
1744 };
1745 struct cfg80211_wowlan_wakeup *wakeup_report = &wakeup;
1746 struct iwl_mvm_nd_query_results query;
1747 struct iwl_wowlan_status *fw_status;
1748 unsigned long matched_profiles;
1749 u32 reasons = 0;
1750 int i, j, n_matches, ret;
1751
1752 fw_status = iwl_mvm_get_wakeup_status(mvm, vif);
1753 if (!IS_ERR_OR_NULL(fw_status)) {
1754 reasons = le32_to_cpu(fw_status->wakeup_reasons);
1755 kfree(fw_status);
1756 }
1757
1758 if (reasons & IWL_WOWLAN_WAKEUP_BY_RFKILL_DEASSERTED)
1759 wakeup.rfkill_release = true;
1760
1761 if (reasons != IWL_WOWLAN_WAKEUP_BY_NON_WIRELESS)
1762 goto out;
1763
1764 ret = iwl_mvm_netdetect_query_results(mvm, &query);
1765 if (ret || !query.matched_profiles) {
1766 wakeup_report = NULL;
1767 goto out;
1768 }
1769
1770 matched_profiles = query.matched_profiles;
1771 if (mvm->n_nd_match_sets) {
1772 n_matches = hweight_long(matched_profiles);
1773 } else {
1774 IWL_ERR(mvm, "no net detect match information available\n");
1775 n_matches = 0;
1776 }
1777
1778 net_detect = kzalloc(sizeof(*net_detect) +
1779 (n_matches * sizeof(net_detect->matches[0])),
1780 GFP_KERNEL);
1781 if (!net_detect || !n_matches)
1782 goto out_report_nd;
1783
1784 for_each_set_bit(i, &matched_profiles, mvm->n_nd_match_sets) {
1785 struct iwl_scan_offload_profile_match *fw_match;
1786 struct cfg80211_wowlan_nd_match *match;
1787 int n_channels = 0;
1788
1789 fw_match = &query.matches[i];
1790
1791 for (j = 0; j < SCAN_OFFLOAD_MATCHING_CHANNELS_LEN; j++)
1792 n_channels += hweight8(fw_match->matching_channels[j]);
1793
1794 match = kzalloc(sizeof(*match) +
1795 (n_channels * sizeof(*match->channels)),
1796 GFP_KERNEL);
1797 if (!match)
1798 goto out_report_nd;
1799
1800 net_detect->matches[net_detect->n_matches++] = match;
1801
1802 match->ssid.ssid_len = mvm->nd_match_sets[i].ssid.ssid_len;
1803 memcpy(match->ssid.ssid, mvm->nd_match_sets[i].ssid.ssid,
1804 match->ssid.ssid_len);
1805
1806 if (mvm->n_nd_channels < n_channels)
1807 continue;
1808
1809 for (j = 0; j < SCAN_OFFLOAD_MATCHING_CHANNELS_LEN * 8; j++)
1810 if (fw_match->matching_channels[j / 8] & (BIT(j % 8)))
1811 match->channels[match->n_channels++] =
1812 mvm->nd_channels[j]->center_freq;
1813 }
1814
1815 out_report_nd:
1816 wakeup.net_detect = net_detect;
1817 out:
1818 iwl_mvm_free_nd(mvm);
1819
1820 mutex_unlock(&mvm->mutex);
1821 ieee80211_report_wowlan_wakeup(vif, wakeup_report, GFP_KERNEL);
1822
1823 if (net_detect) {
1824 for (i = 0; i < net_detect->n_matches; i++)
1825 kfree(net_detect->matches[i]);
1826 kfree(net_detect);
1827 }
1828 }
1829
iwl_mvm_read_d3_sram(struct iwl_mvm * mvm)1830 static void iwl_mvm_read_d3_sram(struct iwl_mvm *mvm)
1831 {
1832 #ifdef CONFIG_IWLWIFI_DEBUGFS
1833 const struct fw_img *img = &mvm->fw->img[IWL_UCODE_WOWLAN];
1834 u32 len = img->sec[IWL_UCODE_SECTION_DATA].len;
1835 u32 offs = img->sec[IWL_UCODE_SECTION_DATA].offset;
1836
1837 if (!mvm->store_d3_resume_sram)
1838 return;
1839
1840 if (!mvm->d3_resume_sram) {
1841 mvm->d3_resume_sram = kzalloc(len, GFP_KERNEL);
1842 if (!mvm->d3_resume_sram)
1843 return;
1844 }
1845
1846 iwl_trans_read_mem_bytes(mvm->trans, offs, mvm->d3_resume_sram, len);
1847 #endif
1848 }
1849
iwl_mvm_d3_disconnect_iter(void * data,u8 * mac,struct ieee80211_vif * vif)1850 static void iwl_mvm_d3_disconnect_iter(void *data, u8 *mac,
1851 struct ieee80211_vif *vif)
1852 {
1853 /* skip the one we keep connection on */
1854 if (data == vif)
1855 return;
1856
1857 if (vif->type == NL80211_IFTYPE_STATION)
1858 ieee80211_resume_disconnect(vif);
1859 }
1860
__iwl_mvm_resume(struct iwl_mvm * mvm,bool test)1861 static int __iwl_mvm_resume(struct iwl_mvm *mvm, bool test)
1862 {
1863 struct ieee80211_vif *vif = NULL;
1864 int ret;
1865 enum iwl_d3_status d3_status;
1866 bool keep = false;
1867
1868 mutex_lock(&mvm->mutex);
1869
1870 /* get the BSS vif pointer again */
1871 vif = iwl_mvm_get_bss_vif(mvm);
1872 if (IS_ERR_OR_NULL(vif))
1873 goto err;
1874
1875 ret = iwl_trans_d3_resume(mvm->trans, &d3_status, test);
1876 if (ret)
1877 goto err;
1878
1879 if (d3_status != IWL_D3_STATUS_ALIVE) {
1880 IWL_INFO(mvm, "Device was reset during suspend\n");
1881 goto err;
1882 }
1883
1884 /* query SRAM first in case we want event logging */
1885 iwl_mvm_read_d3_sram(mvm);
1886
1887 /*
1888 * Query the current location and source from the D3 firmware so we
1889 * can play it back when we re-intiailize the D0 firmware
1890 */
1891 iwl_mvm_update_changed_regdom(mvm);
1892
1893 if (mvm->net_detect) {
1894 iwl_mvm_query_netdetect_reasons(mvm, vif);
1895 /* has unlocked the mutex, so skip that */
1896 goto out;
1897 } else {
1898 keep = iwl_mvm_query_wakeup_reasons(mvm, vif);
1899 #ifdef CONFIG_IWLWIFI_DEBUGFS
1900 if (keep)
1901 mvm->keep_vif = vif;
1902 #endif
1903 /* has unlocked the mutex, so skip that */
1904 goto out_iterate;
1905 }
1906
1907 err:
1908 iwl_mvm_free_nd(mvm);
1909 mutex_unlock(&mvm->mutex);
1910
1911 out_iterate:
1912 if (!test)
1913 ieee80211_iterate_active_interfaces_rtnl(mvm->hw,
1914 IEEE80211_IFACE_ITER_NORMAL,
1915 iwl_mvm_d3_disconnect_iter, keep ? vif : NULL);
1916
1917 out:
1918 /* return 1 to reconfigure the device */
1919 set_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status);
1920 set_bit(IWL_MVM_STATUS_D3_RECONFIG, &mvm->status);
1921
1922 /* We always return 1, which causes mac80211 to do a reconfig
1923 * with IEEE80211_RECONFIG_TYPE_RESTART. This type of
1924 * reconfig calls iwl_mvm_restart_complete(), where we unref
1925 * the IWL_MVM_REF_UCODE_DOWN, so we need to take the
1926 * reference here.
1927 */
1928 iwl_mvm_ref(mvm, IWL_MVM_REF_UCODE_DOWN);
1929 return 1;
1930 }
1931
iwl_mvm_resume(struct ieee80211_hw * hw)1932 int iwl_mvm_resume(struct ieee80211_hw *hw)
1933 {
1934 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
1935
1936 iwl_trans_resume(mvm->trans);
1937
1938 if (mvm->hw->wiphy->wowlan_config->any) {
1939 /* 'any' trigger means d0i3 usage */
1940 if (mvm->trans->d0i3_mode == IWL_D0I3_MODE_ON_SUSPEND) {
1941 int ret = iwl_mvm_exit_d0i3(hw->priv);
1942
1943 if (ret)
1944 return ret;
1945 /*
1946 * d0i3 exit will be deferred until reconfig_complete.
1947 * make sure there we are out of d0i3.
1948 */
1949 }
1950 return 0;
1951 }
1952
1953 return __iwl_mvm_resume(mvm, false);
1954 }
1955
iwl_mvm_set_wakeup(struct ieee80211_hw * hw,bool enabled)1956 void iwl_mvm_set_wakeup(struct ieee80211_hw *hw, bool enabled)
1957 {
1958 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
1959
1960 device_set_wakeup_enable(mvm->trans->dev, enabled);
1961 }
1962
1963 #ifdef CONFIG_IWLWIFI_DEBUGFS
iwl_mvm_d3_test_open(struct inode * inode,struct file * file)1964 static int iwl_mvm_d3_test_open(struct inode *inode, struct file *file)
1965 {
1966 struct iwl_mvm *mvm = inode->i_private;
1967 int err;
1968
1969 if (mvm->d3_test_active)
1970 return -EBUSY;
1971
1972 file->private_data = inode->i_private;
1973
1974 ieee80211_stop_queues(mvm->hw);
1975 synchronize_net();
1976
1977 /* start pseudo D3 */
1978 rtnl_lock();
1979 err = __iwl_mvm_suspend(mvm->hw, mvm->hw->wiphy->wowlan_config, true);
1980 rtnl_unlock();
1981 if (err > 0)
1982 err = -EINVAL;
1983 if (err) {
1984 ieee80211_wake_queues(mvm->hw);
1985 return err;
1986 }
1987 mvm->d3_test_active = true;
1988 mvm->keep_vif = NULL;
1989 return 0;
1990 }
1991
iwl_mvm_d3_test_read(struct file * file,char __user * user_buf,size_t count,loff_t * ppos)1992 static ssize_t iwl_mvm_d3_test_read(struct file *file, char __user *user_buf,
1993 size_t count, loff_t *ppos)
1994 {
1995 struct iwl_mvm *mvm = file->private_data;
1996 u32 pme_asserted;
1997
1998 while (true) {
1999 /* read pme_ptr if available */
2000 if (mvm->d3_test_pme_ptr) {
2001 pme_asserted = iwl_trans_read_mem32(mvm->trans,
2002 mvm->d3_test_pme_ptr);
2003 if (pme_asserted)
2004 break;
2005 }
2006
2007 if (msleep_interruptible(100))
2008 break;
2009 }
2010
2011 return 0;
2012 }
2013
iwl_mvm_d3_test_disconn_work_iter(void * _data,u8 * mac,struct ieee80211_vif * vif)2014 static void iwl_mvm_d3_test_disconn_work_iter(void *_data, u8 *mac,
2015 struct ieee80211_vif *vif)
2016 {
2017 /* skip the one we keep connection on */
2018 if (_data == vif)
2019 return;
2020
2021 if (vif->type == NL80211_IFTYPE_STATION)
2022 ieee80211_connection_loss(vif);
2023 }
2024
iwl_mvm_d3_test_release(struct inode * inode,struct file * file)2025 static int iwl_mvm_d3_test_release(struct inode *inode, struct file *file)
2026 {
2027 struct iwl_mvm *mvm = inode->i_private;
2028 int remaining_time = 10;
2029
2030 mvm->d3_test_active = false;
2031 rtnl_lock();
2032 __iwl_mvm_resume(mvm, true);
2033 rtnl_unlock();
2034 iwl_abort_notification_waits(&mvm->notif_wait);
2035 ieee80211_restart_hw(mvm->hw);
2036
2037 /* wait for restart and disconnect all interfaces */
2038 while (test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status) &&
2039 remaining_time > 0) {
2040 remaining_time--;
2041 msleep(1000);
2042 }
2043
2044 if (remaining_time == 0)
2045 IWL_ERR(mvm, "Timed out waiting for HW restart to finish!\n");
2046
2047 ieee80211_iterate_active_interfaces_atomic(
2048 mvm->hw, IEEE80211_IFACE_ITER_NORMAL,
2049 iwl_mvm_d3_test_disconn_work_iter, mvm->keep_vif);
2050
2051 ieee80211_wake_queues(mvm->hw);
2052
2053 return 0;
2054 }
2055
2056 const struct file_operations iwl_dbgfs_d3_test_ops = {
2057 .llseek = no_llseek,
2058 .open = iwl_mvm_d3_test_open,
2059 .read = iwl_mvm_d3_test_read,
2060 .release = iwl_mvm_d3_test_release,
2061 };
2062 #endif
2063