1 // SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause 2 /* 3 * Copyright (C) 2024-2025 Intel Corporation 4 */ 5 #include "mld.h" 6 7 #include "d3.h" 8 #include "power.h" 9 #include "hcmd.h" 10 #include "iface.h" 11 #include "mcc.h" 12 #include "sta.h" 13 #include "mlo.h" 14 #include "key.h" 15 16 #include "fw/api/d3.h" 17 #include "fw/api/offload.h" 18 #include "fw/api/sta.h" 19 #include "fw/dbg.h" 20 21 #include <net/ipv6.h> 22 #include <net/addrconf.h> 23 #include <linux/bitops.h> 24 25 /** 26 * enum iwl_mld_d3_notif - d3 notifications 27 * @IWL_D3_NOTIF_WOWLAN_INFO: WOWLAN_INFO_NOTIF is expected/was received 28 * @IWL_D3_NOTIF_WOWLAN_WAKE_PKT: WOWLAN_WAKE_PKT_NOTIF is expected/was received 29 * @IWL_D3_NOTIF_PROT_OFFLOAD: PROT_OFFLOAD_NOTIF is expected/was received 30 * @IWL_D3_ND_MATCH_INFO: OFFLOAD_MATCH_INFO_NOTIF is expected/was received 31 * @IWL_D3_NOTIF_D3_END_NOTIF: D3_END_NOTIF is expected/was received 32 */ 33 enum iwl_mld_d3_notif { 34 IWL_D3_NOTIF_WOWLAN_INFO = BIT(0), 35 IWL_D3_NOTIF_WOWLAN_WAKE_PKT = BIT(1), 36 IWL_D3_NOTIF_PROT_OFFLOAD = BIT(2), 37 IWL_D3_ND_MATCH_INFO = BIT(3), 38 IWL_D3_NOTIF_D3_END_NOTIF = BIT(4) 39 }; 40 41 struct iwl_mld_resume_key_iter_data { 42 struct iwl_mld *mld; 43 struct iwl_mld_wowlan_status *wowlan_status; 44 u32 num_keys; 45 bool unhandled_cipher; 46 }; 47 48 struct iwl_mld_suspend_key_iter_data { 49 struct iwl_wowlan_rsc_tsc_params_cmd *rsc; 50 bool have_rsc; 51 int gtks; 52 int found_gtk_idx[4]; 53 __le32 gtk_cipher; 54 __le32 igtk_cipher; 55 __le32 bigtk_cipher; 56 }; 57 58 struct iwl_mld_mcast_key_data { 59 u8 key[WOWLAN_KEY_MAX_SIZE]; 60 u8 len; 61 u8 flags; 62 u8 id; 63 union { 64 struct { 65 struct ieee80211_key_seq aes_seq[IWL_MAX_TID_COUNT]; 66 struct ieee80211_key_seq tkip_seq[IWL_MAX_TID_COUNT]; 67 } gtk; 68 struct { 69 struct ieee80211_key_seq cmac_gmac_seq; 70 } igtk_bigtk; 71 }; 72 73 }; 74 75 struct iwl_mld_wowlan_mlo_key { 76 u8 key[WOWLAN_KEY_MAX_SIZE]; 77 u8 idx, type, link_id; 78 u8 pn[6]; 79 }; 80 81 /** 82 * struct iwl_mld_wowlan_status - contains wowlan status data from 83 * all wowlan notifications 84 * @wakeup_reasons: wakeup reasons, see &enum iwl_wowlan_wakeup_reason 85 * @replay_ctr: GTK rekey replay counter 86 * @pattern_number: number of the matched patterns on packets 87 * @last_qos_seq: QoS sequence counter of offloaded tid 88 * @num_of_gtk_rekeys: number of GTK rekeys during D3 89 * @tid_offloaded_tx: tid used by the firmware to transmit data packets 90 * while in wowlan 91 * @wake_packet: wakeup packet received 92 * @wake_packet_length: wake packet length 93 * @wake_packet_bufsize: wake packet bufsize 94 * @gtk: data of the last two used gtk's by the FW upon resume 95 * @igtk: data of the last used igtk by the FW upon resume 96 * @bigtk: data of the last two used gtk's by the FW upon resume 97 * @ptk: last seq numbers per tid passed by the FW, 98 * holds both in tkip and aes formats 99 * @num_mlo_keys: number of &struct iwl_mld_wowlan_mlo_key structs 100 * @mlo_keys: array of MLO keys 101 */ 102 struct iwl_mld_wowlan_status { 103 u32 wakeup_reasons; 104 u64 replay_ctr; 105 u16 pattern_number; 106 u16 last_qos_seq; 107 u32 num_of_gtk_rekeys; 108 u8 tid_offloaded_tx; 109 u8 *wake_packet; 110 u32 wake_packet_length; 111 u32 wake_packet_bufsize; 112 struct iwl_mld_mcast_key_data gtk[WOWLAN_GTK_KEYS_NUM]; 113 struct iwl_mld_mcast_key_data igtk; 114 struct iwl_mld_mcast_key_data bigtk[WOWLAN_BIGTK_KEYS_NUM]; 115 struct { 116 struct ieee80211_key_seq aes_seq[IWL_MAX_TID_COUNT]; 117 struct ieee80211_key_seq tkip_seq[IWL_MAX_TID_COUNT]; 118 119 } ptk; 120 121 int num_mlo_keys; 122 struct iwl_mld_wowlan_mlo_key mlo_keys[WOWLAN_MAX_MLO_KEYS]; 123 }; 124 125 #define NETDETECT_QUERY_BUF_LEN \ 126 (sizeof(struct iwl_scan_offload_profile_match) * \ 127 IWL_SCAN_MAX_PROFILES_V2) 128 129 /** 130 * struct iwl_mld_netdetect_res - contains netdetect results from 131 * match_info_notif 132 * @matched_profiles: bitmap of matched profiles, referencing the 133 * matches passed in the scan offload request 134 * @matches: array of match information, one for each match 135 */ 136 struct iwl_mld_netdetect_res { 137 u32 matched_profiles; 138 u8 matches[NETDETECT_QUERY_BUF_LEN]; 139 }; 140 141 /** 142 * struct iwl_mld_resume_data - d3 resume flow data 143 * @notifs_expected: bitmap of expected notifications from fw, 144 * see &enum iwl_mld_d3_notif 145 * @notifs_received: bitmap of received notifications from fw, 146 * see &enum iwl_mld_d3_notif 147 * @d3_end_flags: bitmap of flags from d3_end_notif 148 * @notif_handling_err: error handling one of the resume notifications 149 * @wowlan_status: wowlan status data from all wowlan notifications 150 * @netdetect_res: contains netdetect results from match_info_notif 151 */ 152 struct iwl_mld_resume_data { 153 u32 notifs_expected; 154 u32 notifs_received; 155 u32 d3_end_flags; 156 bool notif_handling_err; 157 struct iwl_mld_wowlan_status *wowlan_status; 158 struct iwl_mld_netdetect_res *netdetect_res; 159 }; 160 161 #define IWL_WOWLAN_WAKEUP_REASON_HAS_WAKEUP_PKT \ 162 (IWL_WOWLAN_WAKEUP_BY_MAGIC_PACKET | \ 163 IWL_WOWLAN_WAKEUP_BY_PATTERN | \ 164 IWL_WAKEUP_BY_PATTERN_IPV4_TCP_SYN |\ 165 IWL_WAKEUP_BY_PATTERN_IPV4_TCP_SYN_WILDCARD |\ 166 IWL_WAKEUP_BY_PATTERN_IPV6_TCP_SYN |\ 167 IWL_WAKEUP_BY_PATTERN_IPV6_TCP_SYN_WILDCARD) 168 169 #define IWL_WOWLAN_OFFLOAD_TID 0 170 171 void iwl_mld_set_rekey_data(struct ieee80211_hw *hw, 172 struct ieee80211_vif *vif, 173 struct cfg80211_gtk_rekey_data *data) 174 { 175 struct iwl_mld *mld = IWL_MAC80211_GET_MLD(hw); 176 struct iwl_mld_vif *mld_vif = iwl_mld_vif_from_mac80211(vif); 177 struct iwl_mld_wowlan_data *wowlan_data = &mld_vif->wowlan_data; 178 179 lockdep_assert_wiphy(mld->wiphy); 180 181 wowlan_data->rekey_data.kek_len = data->kek_len; 182 wowlan_data->rekey_data.kck_len = data->kck_len; 183 memcpy(wowlan_data->rekey_data.kek, data->kek, data->kek_len); 184 memcpy(wowlan_data->rekey_data.kck, data->kck, data->kck_len); 185 wowlan_data->rekey_data.akm = data->akm & 0xFF; 186 wowlan_data->rekey_data.replay_ctr = 187 cpu_to_le64(be64_to_cpup((const __be64 *)data->replay_ctr)); 188 wowlan_data->rekey_data.valid = true; 189 } 190 191 #if IS_ENABLED(CONFIG_IPV6) 192 void iwl_mld_ipv6_addr_change(struct ieee80211_hw *hw, 193 struct ieee80211_vif *vif, 194 struct inet6_dev *idev) 195 { 196 struct iwl_mld_vif *mld_vif = iwl_mld_vif_from_mac80211(vif); 197 struct iwl_mld_wowlan_data *wowlan_data = &mld_vif->wowlan_data; 198 struct inet6_ifaddr *ifa; 199 int idx = 0; 200 201 memset(wowlan_data->tentative_addrs, 0, 202 sizeof(wowlan_data->tentative_addrs)); 203 204 read_lock_bh(&idev->lock); 205 list_for_each_entry(ifa, &idev->addr_list, if_list) { 206 wowlan_data->target_ipv6_addrs[idx] = ifa->addr; 207 if (ifa->flags & IFA_F_TENTATIVE) 208 __set_bit(idx, wowlan_data->tentative_addrs); 209 idx++; 210 if (idx >= IWL_PROTO_OFFLOAD_NUM_IPV6_ADDRS_MAX) 211 break; 212 } 213 read_unlock_bh(&idev->lock); 214 215 wowlan_data->num_target_ipv6_addrs = idx; 216 } 217 #endif 218 219 static int 220 iwl_mld_netdetect_config(struct iwl_mld *mld, 221 struct ieee80211_vif *vif, 222 const struct cfg80211_wowlan *wowlan) 223 { 224 int ret; 225 struct cfg80211_sched_scan_request *netdetect_cfg = 226 wowlan->nd_config; 227 struct ieee80211_scan_ies ies = {}; 228 229 ret = iwl_mld_scan_stop(mld, IWL_MLD_SCAN_SCHED, true); 230 if (ret) 231 return ret; 232 233 ret = iwl_mld_sched_scan_start(mld, vif, netdetect_cfg, &ies, 234 IWL_MLD_SCAN_NETDETECT); 235 return ret; 236 } 237 238 static void 239 iwl_mld_le64_to_tkip_seq(__le64 le_pn, struct ieee80211_key_seq *seq) 240 { 241 u64 pn = le64_to_cpu(le_pn); 242 243 seq->tkip.iv16 = (u16)pn; 244 seq->tkip.iv32 = (u32)(pn >> 16); 245 } 246 247 static void 248 iwl_mld_le64_to_aes_seq(__le64 le_pn, struct ieee80211_key_seq *seq) 249 { 250 u64 pn = le64_to_cpu(le_pn); 251 252 seq->ccmp.pn[0] = pn >> 40; 253 seq->ccmp.pn[1] = pn >> 32; 254 seq->ccmp.pn[2] = pn >> 24; 255 seq->ccmp.pn[3] = pn >> 16; 256 seq->ccmp.pn[4] = pn >> 8; 257 seq->ccmp.pn[5] = pn; 258 } 259 260 static void 261 iwl_mld_convert_gtk_resume_seq(struct iwl_mld_mcast_key_data *gtk_data, 262 const struct iwl_wowlan_all_rsc_tsc_v5 *sc, 263 int rsc_idx) 264 { 265 struct ieee80211_key_seq *aes_seq = gtk_data->gtk.aes_seq; 266 struct ieee80211_key_seq *tkip_seq = gtk_data->gtk.tkip_seq; 267 268 if (rsc_idx >= ARRAY_SIZE(sc->mcast_rsc)) 269 return; 270 271 /* We store both the TKIP and AES representations coming from the 272 * FW because we decode the data from there before we iterate 273 * the keys and know which type is used. 274 */ 275 for (int tid = 0; tid < IWL_MAX_TID_COUNT; tid++) { 276 iwl_mld_le64_to_tkip_seq(sc->mcast_rsc[rsc_idx][tid], 277 &tkip_seq[tid]); 278 iwl_mld_le64_to_aes_seq(sc->mcast_rsc[rsc_idx][tid], 279 &aes_seq[tid]); 280 } 281 } 282 283 static void 284 iwl_mld_convert_gtk_resume_data(struct iwl_mld *mld, 285 struct iwl_mld_wowlan_status *wowlan_status, 286 const struct iwl_wowlan_gtk_status_v3 *gtk_data, 287 const struct iwl_wowlan_all_rsc_tsc_v5 *sc) 288 { 289 int status_idx = 0; 290 291 BUILD_BUG_ON(sizeof(wowlan_status->gtk[0].key) < 292 sizeof(gtk_data[0].key)); 293 BUILD_BUG_ON(ARRAY_SIZE(wowlan_status->gtk) < WOWLAN_GTK_KEYS_NUM); 294 295 for (int notif_idx = 0; notif_idx < ARRAY_SIZE(wowlan_status->gtk); 296 notif_idx++) { 297 int rsc_idx; 298 299 if (!(gtk_data[notif_idx].key_len)) 300 continue; 301 302 wowlan_status->gtk[status_idx].len = 303 gtk_data[notif_idx].key_len; 304 wowlan_status->gtk[status_idx].flags = 305 gtk_data[notif_idx].key_flags; 306 wowlan_status->gtk[status_idx].id = 307 wowlan_status->gtk[status_idx].flags & 308 IWL_WOWLAN_GTK_IDX_MASK; 309 memcpy(wowlan_status->gtk[status_idx].key, 310 gtk_data[notif_idx].key, 311 sizeof(gtk_data[notif_idx].key)); 312 313 /* The rsc for both gtk keys are stored in gtk[0]->sc->mcast_rsc 314 * The gtk ids can be any two numbers between 0 and 3, 315 * the id_map maps between the key id and the index in sc->mcast 316 */ 317 rsc_idx = 318 sc->mcast_key_id_map[wowlan_status->gtk[status_idx].id]; 319 iwl_mld_convert_gtk_resume_seq(&wowlan_status->gtk[status_idx], 320 sc, rsc_idx); 321 322 /* if it's as long as the TKIP encryption key, copy MIC key */ 323 if (wowlan_status->gtk[status_idx].len == 324 NL80211_TKIP_DATA_OFFSET_TX_MIC_KEY) 325 memcpy(wowlan_status->gtk[status_idx].key + 326 NL80211_TKIP_DATA_OFFSET_RX_MIC_KEY, 327 gtk_data[notif_idx].tkip_mic_key, 328 sizeof(gtk_data[notif_idx].tkip_mic_key)); 329 status_idx++; 330 } 331 } 332 333 static void 334 iwl_mld_convert_ptk_resume_seq(struct iwl_mld *mld, 335 struct iwl_mld_wowlan_status *wowlan_status, 336 const struct iwl_wowlan_all_rsc_tsc_v5 *sc) 337 { 338 struct ieee80211_key_seq *aes_seq = wowlan_status->ptk.aes_seq; 339 struct ieee80211_key_seq *tkip_seq = wowlan_status->ptk.tkip_seq; 340 341 BUILD_BUG_ON(ARRAY_SIZE(sc->ucast_rsc) != IWL_MAX_TID_COUNT); 342 343 for (int tid = 0; tid < IWL_MAX_TID_COUNT; tid++) { 344 iwl_mld_le64_to_aes_seq(sc->ucast_rsc[tid], &aes_seq[tid]); 345 iwl_mld_le64_to_tkip_seq(sc->ucast_rsc[tid], &tkip_seq[tid]); 346 } 347 } 348 349 static void 350 iwl_mld_convert_mcast_ipn(struct iwl_mld_mcast_key_data *key_status, 351 const struct iwl_wowlan_igtk_status *key) 352 { 353 struct ieee80211_key_seq *seq = 354 &key_status->igtk_bigtk.cmac_gmac_seq; 355 u8 ipn_len = ARRAY_SIZE(key->ipn); 356 357 BUILD_BUG_ON(ipn_len != ARRAY_SIZE(seq->aes_gmac.pn)); 358 BUILD_BUG_ON(ipn_len != ARRAY_SIZE(seq->aes_cmac.pn)); 359 BUILD_BUG_ON(offsetof(struct ieee80211_key_seq, aes_gmac) != 360 offsetof(struct ieee80211_key_seq, aes_cmac)); 361 362 /* mac80211 expects big endian for memcmp() to work, convert. 363 * We don't have the key cipher yet so copy to both to cmac and gmac 364 */ 365 for (int i = 0; i < ipn_len; i++) { 366 seq->aes_gmac.pn[i] = key->ipn[ipn_len - i - 1]; 367 seq->aes_cmac.pn[i] = key->ipn[ipn_len - i - 1]; 368 } 369 } 370 371 static void 372 iwl_mld_convert_igtk_resume_data(struct iwl_mld_wowlan_status *wowlan_status, 373 const struct iwl_wowlan_igtk_status *igtk) 374 { 375 BUILD_BUG_ON(sizeof(wowlan_status->igtk.key) < sizeof(igtk->key)); 376 377 if (!igtk->key_len) 378 return; 379 380 wowlan_status->igtk.len = igtk->key_len; 381 wowlan_status->igtk.flags = igtk->key_flags; 382 wowlan_status->igtk.id = 383 u32_get_bits(igtk->key_flags, 384 IWL_WOWLAN_IGTK_BIGTK_IDX_MASK) + 385 WOWLAN_IGTK_MIN_INDEX; 386 387 memcpy(wowlan_status->igtk.key, igtk->key, sizeof(igtk->key)); 388 iwl_mld_convert_mcast_ipn(&wowlan_status->igtk, igtk); 389 } 390 391 static void 392 iwl_mld_convert_bigtk_resume_data(struct iwl_mld_wowlan_status *wowlan_status, 393 const struct iwl_wowlan_igtk_status *bigtk) 394 { 395 int status_idx = 0; 396 397 BUILD_BUG_ON(ARRAY_SIZE(wowlan_status->bigtk) < WOWLAN_BIGTK_KEYS_NUM); 398 399 for (int notif_idx = 0; notif_idx < WOWLAN_BIGTK_KEYS_NUM; 400 notif_idx++) { 401 if (!bigtk[notif_idx].key_len) 402 continue; 403 404 wowlan_status->bigtk[status_idx].len = bigtk[notif_idx].key_len; 405 wowlan_status->bigtk[status_idx].flags = 406 bigtk[notif_idx].key_flags; 407 wowlan_status->bigtk[status_idx].id = 408 u32_get_bits(bigtk[notif_idx].key_flags, 409 IWL_WOWLAN_IGTK_BIGTK_IDX_MASK) 410 + WOWLAN_BIGTK_MIN_INDEX; 411 412 BUILD_BUG_ON(sizeof(wowlan_status->bigtk[status_idx].key) < 413 sizeof(bigtk[notif_idx].key)); 414 memcpy(wowlan_status->bigtk[status_idx].key, 415 bigtk[notif_idx].key, sizeof(bigtk[notif_idx].key)); 416 iwl_mld_convert_mcast_ipn(&wowlan_status->bigtk[status_idx], 417 &bigtk[notif_idx]); 418 status_idx++; 419 } 420 } 421 422 static void 423 iwl_mld_convert_mlo_keys(struct iwl_mld *mld, 424 const struct iwl_wowlan_info_notif *notif, 425 struct iwl_mld_wowlan_status *wowlan_status) 426 { 427 if (!notif->num_mlo_link_keys) 428 return; 429 430 wowlan_status->num_mlo_keys = notif->num_mlo_link_keys; 431 432 if (IWL_FW_CHECK(mld, wowlan_status->num_mlo_keys > WOWLAN_MAX_MLO_KEYS, 433 "Too many MLO keys: %d, max %d\n", 434 wowlan_status->num_mlo_keys, WOWLAN_MAX_MLO_KEYS)) 435 wowlan_status->num_mlo_keys = WOWLAN_MAX_MLO_KEYS; 436 437 for (int i = 0; i < wowlan_status->num_mlo_keys; i++) { 438 const struct iwl_wowlan_mlo_gtk *fw_mlo_key = ¬if->mlo_gtks[i]; 439 struct iwl_mld_wowlan_mlo_key *driver_mlo_key = 440 &wowlan_status->mlo_keys[i]; 441 u16 flags = le16_to_cpu(fw_mlo_key->flags); 442 443 driver_mlo_key->link_id = 444 u16_get_bits(flags, WOWLAN_MLO_GTK_FLAG_LINK_ID_MSK); 445 driver_mlo_key->type = 446 u16_get_bits(flags, WOWLAN_MLO_GTK_FLAG_KEY_TYPE_MSK); 447 driver_mlo_key->idx = 448 u16_get_bits(flags, WOWLAN_MLO_GTK_FLAG_KEY_ID_MSK); 449 450 BUILD_BUG_ON(sizeof(driver_mlo_key->key) != sizeof(fw_mlo_key->key)); 451 BUILD_BUG_ON(sizeof(driver_mlo_key->pn) != sizeof(fw_mlo_key->pn)); 452 453 memcpy(driver_mlo_key->key, fw_mlo_key->key, sizeof(fw_mlo_key->key)); 454 memcpy(driver_mlo_key->pn, fw_mlo_key->pn, sizeof(fw_mlo_key->pn)); 455 } 456 } 457 458 static bool 459 iwl_mld_handle_wowlan_info_notif(struct iwl_mld *mld, 460 struct iwl_mld_wowlan_status *wowlan_status, 461 struct iwl_rx_packet *pkt) 462 { 463 const struct iwl_wowlan_info_notif *notif = (void *)pkt->data; 464 u32 len = iwl_rx_packet_payload_len(pkt); 465 u32 len_with_mlo_keys; 466 467 if (IWL_FW_CHECK(mld, len < sizeof(*notif), 468 "Invalid wowlan_info_notif (expected=%zu got=%u)\n", 469 sizeof(*notif), len)) 470 return true; 471 472 /* Now that we know that we have at least sizeof(notif), 473 * check also the variable length part 474 */ 475 len_with_mlo_keys = sizeof(*notif) + 476 notif->num_mlo_link_keys * sizeof(notif->mlo_gtks[0]); 477 478 if (IWL_FW_CHECK(mld, len < len_with_mlo_keys, 479 "Invalid wowlan_info_notif (expected=%ud got=%u)\n", 480 len_with_mlo_keys, len)) 481 return true; 482 483 if (IWL_FW_CHECK(mld, notif->tid_offloaded_tx != IWL_WOWLAN_OFFLOAD_TID, 484 "Invalid tid_offloaded_tx %d\n", 485 wowlan_status->tid_offloaded_tx)) 486 return true; 487 488 iwl_mld_convert_gtk_resume_data(mld, wowlan_status, notif->gtk, 489 ¬if->gtk[0].sc); 490 iwl_mld_convert_ptk_resume_seq(mld, wowlan_status, ¬if->gtk[0].sc); 491 /* only one igtk is passed by FW */ 492 iwl_mld_convert_igtk_resume_data(wowlan_status, ¬if->igtk[0]); 493 iwl_mld_convert_bigtk_resume_data(wowlan_status, notif->bigtk); 494 495 wowlan_status->replay_ctr = le64_to_cpu(notif->replay_ctr); 496 wowlan_status->pattern_number = le16_to_cpu(notif->pattern_number); 497 498 wowlan_status->tid_offloaded_tx = notif->tid_offloaded_tx; 499 wowlan_status->last_qos_seq = le16_to_cpu(notif->qos_seq_ctr); 500 wowlan_status->num_of_gtk_rekeys = 501 le32_to_cpu(notif->num_of_gtk_rekeys); 502 wowlan_status->wakeup_reasons = le32_to_cpu(notif->wakeup_reasons); 503 504 iwl_mld_convert_mlo_keys(mld, notif, wowlan_status); 505 506 return false; 507 } 508 509 static bool 510 iwl_mld_handle_wake_pkt_notif(struct iwl_mld *mld, 511 struct iwl_mld_wowlan_status *wowlan_status, 512 struct iwl_rx_packet *pkt) 513 { 514 const struct iwl_wowlan_wake_pkt_notif *notif = (void *)pkt->data; 515 u32 actual_size, len = iwl_rx_packet_payload_len(pkt); 516 u32 expected_size = le32_to_cpu(notif->wake_packet_length); 517 518 if (IWL_FW_CHECK(mld, len < sizeof(*notif), 519 "Invalid WoWLAN wake packet notification (expected size=%zu got=%u)\n", 520 sizeof(*notif), len)) 521 return true; 522 523 if (IWL_FW_CHECK(mld, !(wowlan_status->wakeup_reasons & 524 IWL_WOWLAN_WAKEUP_REASON_HAS_WAKEUP_PKT), 525 "Got wake packet but wakeup reason is %x\n", 526 wowlan_status->wakeup_reasons)) 527 return true; 528 529 actual_size = len - offsetof(struct iwl_wowlan_wake_pkt_notif, 530 wake_packet); 531 532 /* actual_size got the padding from the notification, remove it. */ 533 if (expected_size < actual_size) 534 actual_size = expected_size; 535 wowlan_status->wake_packet = kmemdup(notif->wake_packet, actual_size, 536 GFP_ATOMIC); 537 if (!wowlan_status->wake_packet) 538 return true; 539 540 wowlan_status->wake_packet_length = expected_size; 541 wowlan_status->wake_packet_bufsize = actual_size; 542 543 return false; 544 } 545 546 static void 547 iwl_mld_set_wake_packet(struct iwl_mld *mld, 548 struct ieee80211_vif *vif, 549 const struct iwl_mld_wowlan_status *wowlan_status, 550 struct cfg80211_wowlan_wakeup *wakeup, 551 struct sk_buff **_pkt) 552 { 553 int pkt_bufsize = wowlan_status->wake_packet_bufsize; 554 int expected_pktlen = wowlan_status->wake_packet_length; 555 const u8 *pktdata = wowlan_status->wake_packet; 556 const struct ieee80211_hdr *hdr = (const void *)pktdata; 557 int truncated = expected_pktlen - pkt_bufsize; 558 559 if (ieee80211_is_data(hdr->frame_control)) { 560 int hdrlen = ieee80211_hdrlen(hdr->frame_control); 561 int ivlen = 0, icvlen = 4; /* also FCS */ 562 563 struct sk_buff *pkt = alloc_skb(pkt_bufsize, GFP_KERNEL); 564 *_pkt = pkt; 565 if (!pkt) 566 return; 567 568 skb_put_data(pkt, pktdata, hdrlen); 569 pktdata += hdrlen; 570 pkt_bufsize -= hdrlen; 571 572 /* if truncated, FCS/ICV is (partially) gone */ 573 if (truncated >= icvlen) { 574 truncated -= icvlen; 575 icvlen = 0; 576 } else { 577 icvlen -= truncated; 578 truncated = 0; 579 } 580 581 pkt_bufsize -= ivlen + icvlen; 582 pktdata += ivlen; 583 584 skb_put_data(pkt, pktdata, pkt_bufsize); 585 586 if (ieee80211_data_to_8023(pkt, vif->addr, vif->type)) 587 return; 588 wakeup->packet = pkt->data; 589 wakeup->packet_present_len = pkt->len; 590 wakeup->packet_len = pkt->len - truncated; 591 wakeup->packet_80211 = false; 592 } else { 593 int fcslen = 4; 594 595 if (truncated >= 4) { 596 truncated -= 4; 597 fcslen = 0; 598 } else { 599 fcslen -= truncated; 600 truncated = 0; 601 } 602 pkt_bufsize -= fcslen; 603 wakeup->packet = wowlan_status->wake_packet; 604 wakeup->packet_present_len = pkt_bufsize; 605 wakeup->packet_len = expected_pktlen - truncated; 606 wakeup->packet_80211 = true; 607 } 608 } 609 610 static void 611 iwl_mld_report_wowlan_wakeup(struct iwl_mld *mld, 612 struct ieee80211_vif *vif, 613 struct iwl_mld_wowlan_status *wowlan_status) 614 { 615 struct sk_buff *pkt = NULL; 616 struct cfg80211_wowlan_wakeup wakeup = { 617 .pattern_idx = -1, 618 }; 619 u32 reasons = wowlan_status->wakeup_reasons; 620 621 if (reasons == IWL_WOWLAN_WAKEUP_BY_NON_WIRELESS) { 622 ieee80211_report_wowlan_wakeup(vif, NULL, GFP_KERNEL); 623 return; 624 } 625 626 pm_wakeup_event(mld->dev, 0); 627 628 if (reasons & IWL_WOWLAN_WAKEUP_BY_MAGIC_PACKET) 629 wakeup.magic_pkt = true; 630 631 if (reasons & IWL_WOWLAN_WAKEUP_BY_PATTERN) 632 wakeup.pattern_idx = 633 wowlan_status->pattern_number; 634 635 if (reasons & (IWL_WOWLAN_WAKEUP_BY_DISCONNECTION_ON_MISSED_BEACON | 636 IWL_WOWLAN_WAKEUP_BY_DISCONNECTION_ON_DEAUTH | 637 IWL_WOWLAN_WAKEUP_BY_GTK_REKEY_FAILURE)) 638 wakeup.disconnect = true; 639 640 if (reasons & IWL_WOWLAN_WAKEUP_BY_GTK_REKEY_FAILURE) 641 wakeup.gtk_rekey_failure = true; 642 643 if (reasons & IWL_WOWLAN_WAKEUP_BY_RFKILL_DEASSERTED) 644 wakeup.rfkill_release = true; 645 646 if (reasons & IWL_WOWLAN_WAKEUP_BY_EAPOL_REQUEST) 647 wakeup.eap_identity_req = true; 648 649 if (reasons & IWL_WOWLAN_WAKEUP_BY_FOUR_WAY_HANDSHAKE) 650 wakeup.four_way_handshake = true; 651 652 if (reasons & IWL_WOWLAN_WAKEUP_BY_REM_WAKE_LINK_LOSS) 653 wakeup.tcp_connlost = true; 654 655 if (reasons & IWL_WOWLAN_WAKEUP_BY_REM_WAKE_SIGNATURE_TABLE) 656 wakeup.tcp_nomoretokens = true; 657 658 if (reasons & IWL_WOWLAN_WAKEUP_BY_REM_WAKE_WAKEUP_PACKET) 659 wakeup.tcp_match = true; 660 661 if (reasons & IWL_WAKEUP_BY_11W_UNPROTECTED_DEAUTH_OR_DISASSOC) 662 wakeup.unprot_deauth_disassoc = true; 663 664 if (wowlan_status->wake_packet) 665 iwl_mld_set_wake_packet(mld, vif, wowlan_status, &wakeup, &pkt); 666 667 ieee80211_report_wowlan_wakeup(vif, &wakeup, GFP_KERNEL); 668 kfree_skb(pkt); 669 } 670 671 static void 672 iwl_mld_set_key_rx_seq_tids(struct ieee80211_key_conf *key, 673 struct ieee80211_key_seq *seq) 674 { 675 int tid; 676 677 for (tid = 0; tid < IWL_MAX_TID_COUNT; tid++) 678 ieee80211_set_key_rx_seq(key, tid, &seq[tid]); 679 } 680 681 static void 682 iwl_mld_set_key_rx_seq(struct ieee80211_key_conf *key, 683 struct iwl_mld_mcast_key_data *key_data) 684 { 685 switch (key->cipher) { 686 case WLAN_CIPHER_SUITE_CCMP: 687 case WLAN_CIPHER_SUITE_GCMP: 688 case WLAN_CIPHER_SUITE_GCMP_256: 689 iwl_mld_set_key_rx_seq_tids(key, 690 key_data->gtk.aes_seq); 691 break; 692 case WLAN_CIPHER_SUITE_TKIP: 693 iwl_mld_set_key_rx_seq_tids(key, 694 key_data->gtk.tkip_seq); 695 break; 696 case WLAN_CIPHER_SUITE_BIP_GMAC_128: 697 case WLAN_CIPHER_SUITE_BIP_GMAC_256: 698 case WLAN_CIPHER_SUITE_BIP_CMAC_256: 699 case WLAN_CIPHER_SUITE_AES_CMAC: 700 /* igtk/bigtk ciphers*/ 701 ieee80211_set_key_rx_seq(key, 0, 702 &key_data->igtk_bigtk.cmac_gmac_seq); 703 break; 704 default: 705 WARN_ON(1); 706 } 707 } 708 709 static void 710 iwl_mld_update_ptk_rx_seq(struct iwl_mld *mld, 711 struct iwl_mld_wowlan_status *wowlan_status, 712 struct ieee80211_sta *sta, 713 struct ieee80211_key_conf *key, 714 bool is_tkip) 715 { 716 struct iwl_mld_sta *mld_sta = 717 iwl_mld_sta_from_mac80211(sta); 718 struct iwl_mld_ptk_pn *mld_ptk_pn = 719 wiphy_dereference(mld->wiphy, 720 mld_sta->ptk_pn[key->keyidx]); 721 722 iwl_mld_set_key_rx_seq_tids(key, is_tkip ? 723 wowlan_status->ptk.tkip_seq : 724 wowlan_status->ptk.aes_seq); 725 if (is_tkip) 726 return; 727 728 if (WARN_ON(!mld_ptk_pn)) 729 return; 730 731 for (int tid = 0; tid < IWL_MAX_TID_COUNT; tid++) { 732 for (int i = 1; i < mld->trans->info.num_rxqs; i++) 733 memcpy(mld_ptk_pn->q[i].pn[tid], 734 wowlan_status->ptk.aes_seq[tid].ccmp.pn, 735 IEEE80211_CCMP_PN_LEN); 736 } 737 } 738 739 static void 740 iwl_mld_resume_keys_iter(struct ieee80211_hw *hw, 741 struct ieee80211_vif *vif, 742 struct ieee80211_sta *sta, 743 struct ieee80211_key_conf *key, 744 void *_data) 745 { 746 struct iwl_mld_resume_key_iter_data *data = _data; 747 struct iwl_mld_wowlan_status *wowlan_status = data->wowlan_status; 748 u8 status_idx; 749 750 if (data->unhandled_cipher) 751 return; 752 753 switch (key->cipher) { 754 case WLAN_CIPHER_SUITE_WEP40: 755 case WLAN_CIPHER_SUITE_WEP104: 756 /* ignore WEP completely, nothing to do */ 757 return; 758 case WLAN_CIPHER_SUITE_CCMP: 759 case WLAN_CIPHER_SUITE_GCMP: 760 case WLAN_CIPHER_SUITE_GCMP_256: 761 case WLAN_CIPHER_SUITE_TKIP: 762 if (sta) { 763 iwl_mld_update_ptk_rx_seq(data->mld, wowlan_status, 764 sta, key, 765 key->cipher == 766 WLAN_CIPHER_SUITE_TKIP); 767 return; 768 } 769 770 status_idx = key->keyidx == wowlan_status->gtk[1].id; 771 iwl_mld_set_key_rx_seq(key, &wowlan_status->gtk[status_idx]); 772 break; 773 case WLAN_CIPHER_SUITE_BIP_GMAC_128: 774 case WLAN_CIPHER_SUITE_BIP_GMAC_256: 775 case WLAN_CIPHER_SUITE_BIP_CMAC_256: 776 case WLAN_CIPHER_SUITE_AES_CMAC: 777 if (key->keyidx == 4 || key->keyidx == 5) { 778 if (key->keyidx == wowlan_status->igtk.id) 779 iwl_mld_set_key_rx_seq(key, &wowlan_status->igtk); 780 } 781 if (key->keyidx == 6 || key->keyidx == 7) { 782 status_idx = key->keyidx == wowlan_status->bigtk[1].id; 783 iwl_mld_set_key_rx_seq(key, &wowlan_status->bigtk[status_idx]); 784 } 785 break; 786 default: 787 data->unhandled_cipher = true; 788 return; 789 } 790 data->num_keys++; 791 } 792 793 static void 794 iwl_mld_add_mcast_rekey(struct ieee80211_vif *vif, 795 struct iwl_mld *mld, 796 struct iwl_mld_mcast_key_data *key_data, 797 struct ieee80211_bss_conf *link_conf) 798 { 799 struct ieee80211_key_conf *key_config; 800 int link_id = vif->active_links ? __ffs(vif->active_links) : -1; 801 802 if (!key_data->len) 803 return; 804 805 key_config = ieee80211_gtk_rekey_add(vif, key_data->id, key_data->key, 806 sizeof(key_data->key), link_id); 807 if (IS_ERR(key_config)) 808 return; 809 810 iwl_mld_set_key_rx_seq(key_config, key_data); 811 812 /* The FW holds only one igtk so we keep track of the valid one */ 813 if (key_config->keyidx == 4 || key_config->keyidx == 5) { 814 struct iwl_mld_link *mld_link = 815 iwl_mld_link_from_mac80211(link_conf); 816 817 /* If we had more than one rekey, mac80211 will tell us to 818 * remove the old and add the new so we will update the IGTK in 819 * drv_set_key 820 */ 821 if (mld_link->igtk && mld_link->igtk != key_config) { 822 /* mark the old IGTK as not in FW */ 823 mld_link->igtk->hw_key_idx = STA_KEY_IDX_INVALID; 824 mld_link->igtk = key_config; 825 } 826 } 827 828 /* Also keep track of the new BIGTK */ 829 if (key_config->keyidx == 6 || key_config->keyidx == 7) 830 iwl_mld_track_bigtk(mld, vif, key_config, true); 831 } 832 833 static void 834 iwl_mld_add_all_rekeys(struct ieee80211_vif *vif, 835 struct iwl_mld_wowlan_status *wowlan_status, 836 struct iwl_mld_resume_key_iter_data *key_iter_data, 837 struct ieee80211_bss_conf *link_conf) 838 { 839 int i; 840 841 for (i = 0; i < ARRAY_SIZE(wowlan_status->gtk); i++) 842 iwl_mld_add_mcast_rekey(vif, key_iter_data->mld, 843 &wowlan_status->gtk[i], 844 link_conf); 845 846 iwl_mld_add_mcast_rekey(vif, key_iter_data->mld, 847 &wowlan_status->igtk, link_conf); 848 849 for (i = 0; i < ARRAY_SIZE(wowlan_status->bigtk); i++) 850 iwl_mld_add_mcast_rekey(vif, key_iter_data->mld, 851 &wowlan_status->bigtk[i], 852 link_conf); 853 } 854 855 static void iwl_mld_mlo_rekey(struct iwl_mld *mld, 856 struct iwl_mld_wowlan_status *wowlan_status, 857 struct ieee80211_vif *vif) 858 { 859 struct iwl_mld_old_mlo_keys *old_keys __free(kfree) = NULL; 860 861 IWL_DEBUG_WOWLAN(mld, "Num of MLO Keys: %d\n", wowlan_status->num_mlo_keys); 862 863 if (!wowlan_status->num_mlo_keys) 864 return; 865 866 for (int i = 0; i < wowlan_status->num_mlo_keys; i++) { 867 struct iwl_mld_wowlan_mlo_key *mlo_key = &wowlan_status->mlo_keys[i]; 868 struct ieee80211_key_conf *key; 869 struct ieee80211_key_seq seq; 870 u8 link_id = mlo_key->link_id; 871 872 if (IWL_FW_CHECK(mld, mlo_key->link_id >= IEEE80211_MLD_MAX_NUM_LINKS || 873 mlo_key->idx >= 8 || 874 mlo_key->type >= WOWLAN_MLO_GTK_KEY_NUM_TYPES, 875 "Invalid MLO key link_id %d, idx %d, type %d\n", 876 mlo_key->link_id, mlo_key->idx, mlo_key->type)) 877 continue; 878 879 if (!(vif->valid_links & BIT(link_id)) || 880 (vif->active_links & BIT(link_id))) 881 continue; 882 883 IWL_DEBUG_WOWLAN(mld, "Add MLO key id %d, link id %d\n", 884 mlo_key->idx, link_id); 885 886 key = ieee80211_gtk_rekey_add(vif, mlo_key->idx, mlo_key->key, 887 sizeof(mlo_key->key), link_id); 888 889 if (IS_ERR(key)) 890 continue; 891 892 /* 893 * mac80211 expects the PN in big-endian 894 * also note that seq is a union of all cipher types 895 * (ccmp, gcmp, cmac, gmac), and they all have the same 896 * pn field (of length 6) so just copy it to ccmp.pn. 897 */ 898 for (int j = 5; j >= 0; j--) 899 seq.ccmp.pn[5 - j] = mlo_key->pn[j]; 900 901 /* group keys are non-QoS and use TID 0 */ 902 ieee80211_set_key_rx_seq(key, 0, &seq); 903 } 904 } 905 906 static bool 907 iwl_mld_update_sec_keys(struct iwl_mld *mld, 908 struct ieee80211_vif *vif, 909 struct iwl_mld_wowlan_status *wowlan_status) 910 { 911 int link_id = vif->active_links ? __ffs(vif->active_links) : 0; 912 struct ieee80211_bss_conf *link_conf = 913 link_conf_dereference_protected(vif, link_id); 914 __be64 replay_ctr = cpu_to_be64(wowlan_status->replay_ctr); 915 struct iwl_mld_resume_key_iter_data key_iter_data = { 916 .mld = mld, 917 .wowlan_status = wowlan_status, 918 }; 919 920 if (WARN_ON(!link_conf)) 921 return false; 922 923 ieee80211_iter_keys(mld->hw, vif, iwl_mld_resume_keys_iter, 924 &key_iter_data); 925 926 if (key_iter_data.unhandled_cipher) 927 return false; 928 929 IWL_DEBUG_WOWLAN(mld, 930 "Number of installed keys: %d, Number of rekeys: %d\n", 931 key_iter_data.num_keys, 932 wowlan_status->num_of_gtk_rekeys); 933 934 if (!key_iter_data.num_keys || !wowlan_status->num_of_gtk_rekeys) 935 return true; 936 937 iwl_mld_add_all_rekeys(vif, wowlan_status, &key_iter_data, 938 link_conf); 939 940 iwl_mld_mlo_rekey(mld, wowlan_status, vif); 941 942 ieee80211_gtk_rekey_notify(vif, link_conf->bssid, 943 (void *)&replay_ctr, GFP_KERNEL); 944 return true; 945 } 946 947 static bool 948 iwl_mld_process_wowlan_status(struct iwl_mld *mld, 949 struct ieee80211_vif *vif, 950 struct iwl_mld_wowlan_status *wowlan_status) 951 { 952 struct iwl_mld_vif *mld_vif = iwl_mld_vif_from_mac80211(vif); 953 struct ieee80211_sta *ap_sta = mld_vif->ap_sta; 954 struct iwl_mld_txq *mld_txq; 955 956 iwl_mld_report_wowlan_wakeup(mld, vif, wowlan_status); 957 958 if (WARN_ON(!ap_sta)) 959 return false; 960 961 mld_txq = 962 iwl_mld_txq_from_mac80211(ap_sta->txq[wowlan_status->tid_offloaded_tx]); 963 964 /* Update the pointers of the Tx queue that may have moved during 965 * suspend if the firmware sent frames. 966 * The firmware stores last-used value, we store next value. 967 */ 968 WARN_ON(!mld_txq->status.allocated); 969 iwl_trans_set_q_ptrs(mld->trans, mld_txq->fw_id, 970 (wowlan_status->last_qos_seq + 971 0x10) >> 4); 972 973 if (!iwl_mld_update_sec_keys(mld, vif, wowlan_status)) 974 return false; 975 976 if (wowlan_status->wakeup_reasons & 977 (IWL_WOWLAN_WAKEUP_BY_DISCONNECTION_ON_MISSED_BEACON | 978 IWL_WOWLAN_WAKEUP_BY_DISCONNECTION_ON_DEAUTH | 979 IWL_WOWLAN_WAKEUP_BY_GTK_REKEY_FAILURE)) 980 return false; 981 982 return true; 983 } 984 985 static bool 986 iwl_mld_netdetect_match_info_handler(struct iwl_mld *mld, 987 struct iwl_mld_resume_data *resume_data, 988 struct iwl_rx_packet *pkt) 989 { 990 struct iwl_mld_netdetect_res *results = resume_data->netdetect_res; 991 const struct iwl_scan_offload_match_info *notif = (void *)pkt->data; 992 u32 len = iwl_rx_packet_payload_len(pkt); 993 994 if (IWL_FW_CHECK(mld, !mld->netdetect, 995 "Got scan match info notif when mld->netdetect==%d\n", 996 mld->netdetect)) 997 return true; 998 999 if (IWL_FW_CHECK(mld, len < sizeof(*notif), 1000 "Invalid scan offload match notif of length: %d\n", 1001 len)) 1002 return true; 1003 1004 if (IWL_FW_CHECK(mld, resume_data->wowlan_status->wakeup_reasons != 1005 IWL_WOWLAN_WAKEUP_BY_NON_WIRELESS, 1006 "Ignore scan match info: unexpected wakeup reason (expected=0x%x got=0x%x)\n", 1007 IWL_WOWLAN_WAKEUP_BY_NON_WIRELESS, 1008 resume_data->wowlan_status->wakeup_reasons)) 1009 return true; 1010 1011 results->matched_profiles = le32_to_cpu(notif->matched_profiles); 1012 IWL_DEBUG_WOWLAN(mld, "number of matched profiles=%u\n", 1013 results->matched_profiles); 1014 1015 if (results->matched_profiles) 1016 memcpy(results->matches, notif->matches, 1017 NETDETECT_QUERY_BUF_LEN); 1018 1019 /* No scan should be active at this point */ 1020 mld->scan.status = 0; 1021 memset(mld->scan.uid_status, 0, sizeof(mld->scan.uid_status)); 1022 return false; 1023 } 1024 1025 static void 1026 iwl_mld_set_netdetect_info(struct iwl_mld *mld, 1027 const struct cfg80211_sched_scan_request *netdetect_cfg, 1028 struct cfg80211_wowlan_nd_info *netdetect_info, 1029 struct iwl_mld_netdetect_res *netdetect_res, 1030 unsigned long matched_profiles) 1031 { 1032 int i; 1033 1034 for_each_set_bit(i, &matched_profiles, netdetect_cfg->n_match_sets) { 1035 struct cfg80211_wowlan_nd_match *match; 1036 int idx, j, n_channels = 0; 1037 struct iwl_scan_offload_profile_match *matches = 1038 (void *)netdetect_res->matches; 1039 1040 for (int k = 0; k < SCAN_OFFLOAD_MATCHING_CHANNELS_LEN; k++) 1041 n_channels += 1042 hweight8(matches[i].matching_channels[k]); 1043 match = kzalloc(struct_size(match, channels, n_channels), 1044 GFP_KERNEL); 1045 if (!match) 1046 return; 1047 1048 netdetect_info->matches[netdetect_info->n_matches] = match; 1049 netdetect_info->n_matches++; 1050 1051 /* We inverted the order of the SSIDs in the scan 1052 * request, so invert the index here. 1053 */ 1054 idx = netdetect_cfg->n_match_sets - i - 1; 1055 match->ssid.ssid_len = 1056 netdetect_cfg->match_sets[idx].ssid.ssid_len; 1057 memcpy(match->ssid.ssid, 1058 netdetect_cfg->match_sets[idx].ssid.ssid, 1059 match->ssid.ssid_len); 1060 1061 if (netdetect_cfg->n_channels < n_channels) 1062 continue; 1063 1064 for_each_set_bit(j, 1065 (unsigned long *)&matches[i].matching_channels[0], 1066 sizeof(matches[i].matching_channels)) { 1067 match->channels[match->n_channels] = 1068 netdetect_cfg->channels[j]->center_freq; 1069 match->n_channels++; 1070 } 1071 } 1072 } 1073 1074 static void 1075 iwl_mld_process_netdetect_res(struct iwl_mld *mld, 1076 struct ieee80211_vif *vif, 1077 struct iwl_mld_resume_data *resume_data) 1078 { 1079 struct cfg80211_wowlan_nd_info *netdetect_info = NULL; 1080 const struct cfg80211_sched_scan_request *netdetect_cfg; 1081 struct cfg80211_wowlan_wakeup wakeup = { 1082 .pattern_idx = -1, 1083 }; 1084 struct cfg80211_wowlan_wakeup *wakeup_report = &wakeup; 1085 unsigned long matched_profiles; 1086 u32 wakeup_reasons; 1087 int n_matches; 1088 1089 lockdep_assert_wiphy(mld->wiphy); 1090 1091 if (WARN_ON(!mld->wiphy->wowlan_config || 1092 !mld->wiphy->wowlan_config->nd_config)) { 1093 IWL_DEBUG_WOWLAN(mld, 1094 "Netdetect isn't configured on resume flow\n"); 1095 goto out; 1096 } 1097 1098 netdetect_cfg = mld->wiphy->wowlan_config->nd_config; 1099 wakeup_reasons = resume_data->wowlan_status->wakeup_reasons; 1100 1101 if (wakeup_reasons & IWL_WOWLAN_WAKEUP_BY_RFKILL_DEASSERTED) 1102 wakeup.rfkill_release = true; 1103 1104 if (wakeup_reasons != IWL_WOWLAN_WAKEUP_BY_NON_WIRELESS) 1105 goto out; 1106 1107 if (!resume_data->netdetect_res->matched_profiles) { 1108 IWL_DEBUG_WOWLAN(mld, 1109 "Netdetect results aren't valid\n"); 1110 wakeup_report = NULL; 1111 goto out; 1112 } 1113 1114 matched_profiles = resume_data->netdetect_res->matched_profiles; 1115 if (!netdetect_cfg->n_match_sets) { 1116 IWL_DEBUG_WOWLAN(mld, 1117 "No netdetect match sets are configured\n"); 1118 goto out; 1119 } 1120 n_matches = hweight_long(matched_profiles); 1121 netdetect_info = kzalloc(struct_size(netdetect_info, matches, 1122 n_matches), GFP_KERNEL); 1123 if (netdetect_info) 1124 iwl_mld_set_netdetect_info(mld, netdetect_cfg, netdetect_info, 1125 resume_data->netdetect_res, 1126 matched_profiles); 1127 1128 wakeup.net_detect = netdetect_info; 1129 out: 1130 ieee80211_report_wowlan_wakeup(vif, wakeup_report, GFP_KERNEL); 1131 if (netdetect_info) { 1132 for (int i = 0; i < netdetect_info->n_matches; i++) 1133 kfree(netdetect_info->matches[i]); 1134 kfree(netdetect_info); 1135 } 1136 } 1137 1138 static bool iwl_mld_handle_d3_notif(struct iwl_notif_wait_data *notif_wait, 1139 struct iwl_rx_packet *pkt, void *data) 1140 { 1141 struct iwl_mld_resume_data *resume_data = data; 1142 struct iwl_mld *mld = 1143 container_of(notif_wait, struct iwl_mld, notif_wait); 1144 1145 switch (WIDE_ID(pkt->hdr.group_id, pkt->hdr.cmd)) { 1146 case WIDE_ID(PROT_OFFLOAD_GROUP, WOWLAN_INFO_NOTIFICATION): { 1147 if (resume_data->notifs_received & IWL_D3_NOTIF_WOWLAN_INFO) { 1148 IWL_DEBUG_WOWLAN(mld, 1149 "got additional wowlan_info notif\n"); 1150 break; 1151 } 1152 resume_data->notif_handling_err = 1153 iwl_mld_handle_wowlan_info_notif(mld, 1154 resume_data->wowlan_status, 1155 pkt); 1156 resume_data->notifs_received |= IWL_D3_NOTIF_WOWLAN_INFO; 1157 1158 if (resume_data->wowlan_status->wakeup_reasons & 1159 IWL_WOWLAN_WAKEUP_REASON_HAS_WAKEUP_PKT) 1160 resume_data->notifs_expected |= 1161 IWL_D3_NOTIF_WOWLAN_WAKE_PKT; 1162 break; 1163 } 1164 case WIDE_ID(PROT_OFFLOAD_GROUP, WOWLAN_WAKE_PKT_NOTIFICATION): { 1165 if (resume_data->notifs_received & 1166 IWL_D3_NOTIF_WOWLAN_WAKE_PKT) { 1167 /* We shouldn't get two wake packet notifications */ 1168 IWL_DEBUG_WOWLAN(mld, 1169 "Got additional wowlan wake packet notification\n"); 1170 break; 1171 } 1172 resume_data->notif_handling_err = 1173 iwl_mld_handle_wake_pkt_notif(mld, 1174 resume_data->wowlan_status, 1175 pkt); 1176 resume_data->notifs_received |= IWL_D3_NOTIF_WOWLAN_WAKE_PKT; 1177 break; 1178 } 1179 case WIDE_ID(SCAN_GROUP, OFFLOAD_MATCH_INFO_NOTIF): { 1180 if (resume_data->notifs_received & IWL_D3_ND_MATCH_INFO) { 1181 IWL_ERR(mld, 1182 "Got additional netdetect match info\n"); 1183 break; 1184 } 1185 1186 resume_data->notif_handling_err = 1187 iwl_mld_netdetect_match_info_handler(mld, resume_data, 1188 pkt); 1189 resume_data->notifs_received |= IWL_D3_ND_MATCH_INFO; 1190 break; 1191 } 1192 case WIDE_ID(PROT_OFFLOAD_GROUP, D3_END_NOTIFICATION): { 1193 struct iwl_d3_end_notif *notif = (void *)pkt->data; 1194 1195 resume_data->d3_end_flags = le32_to_cpu(notif->flags); 1196 resume_data->notifs_received |= IWL_D3_NOTIF_D3_END_NOTIF; 1197 break; 1198 } 1199 default: 1200 WARN_ON(1); 1201 } 1202 1203 return resume_data->notifs_received == resume_data->notifs_expected; 1204 } 1205 1206 #define IWL_MLD_D3_NOTIF_TIMEOUT (HZ / 3) 1207 1208 static int iwl_mld_wait_d3_notif(struct iwl_mld *mld, 1209 struct iwl_mld_resume_data *resume_data, 1210 bool with_wowlan) 1211 { 1212 static const u16 wowlan_resume_notif[] = { 1213 WIDE_ID(PROT_OFFLOAD_GROUP, WOWLAN_INFO_NOTIFICATION), 1214 WIDE_ID(PROT_OFFLOAD_GROUP, WOWLAN_WAKE_PKT_NOTIFICATION), 1215 WIDE_ID(SCAN_GROUP, OFFLOAD_MATCH_INFO_NOTIF), 1216 WIDE_ID(PROT_OFFLOAD_GROUP, D3_END_NOTIFICATION) 1217 }; 1218 static const u16 d3_resume_notif[] = { 1219 WIDE_ID(PROT_OFFLOAD_GROUP, D3_END_NOTIFICATION) 1220 }; 1221 struct iwl_notification_wait wait_d3_notif; 1222 enum iwl_d3_status d3_status; 1223 int ret; 1224 1225 if (with_wowlan) 1226 iwl_init_notification_wait(&mld->notif_wait, &wait_d3_notif, 1227 wowlan_resume_notif, 1228 ARRAY_SIZE(wowlan_resume_notif), 1229 iwl_mld_handle_d3_notif, 1230 resume_data); 1231 else 1232 iwl_init_notification_wait(&mld->notif_wait, &wait_d3_notif, 1233 d3_resume_notif, 1234 ARRAY_SIZE(d3_resume_notif), 1235 iwl_mld_handle_d3_notif, 1236 resume_data); 1237 1238 ret = iwl_trans_d3_resume(mld->trans, &d3_status, false, false); 1239 if (ret || d3_status != IWL_D3_STATUS_ALIVE) { 1240 if (d3_status != IWL_D3_STATUS_ALIVE) { 1241 IWL_INFO(mld, "Device was reset during suspend\n"); 1242 ret = -ENOENT; 1243 } else { 1244 IWL_ERR(mld, "Transport resume failed\n"); 1245 } 1246 iwl_remove_notification(&mld->notif_wait, &wait_d3_notif); 1247 return ret; 1248 } 1249 1250 ret = iwl_wait_notification(&mld->notif_wait, &wait_d3_notif, 1251 IWL_MLD_D3_NOTIF_TIMEOUT); 1252 if (ret) 1253 IWL_ERR(mld, "Couldn't get the d3 notif %d\n", ret); 1254 1255 if (resume_data->notif_handling_err) 1256 ret = -EIO; 1257 1258 return ret; 1259 } 1260 1261 int iwl_mld_no_wowlan_suspend(struct iwl_mld *mld) 1262 { 1263 struct iwl_d3_manager_config d3_cfg_cmd_data = {}; 1264 int ret; 1265 1266 if (mld->debug_max_sleep) { 1267 d3_cfg_cmd_data.wakeup_host_timer = 1268 cpu_to_le32(mld->debug_max_sleep); 1269 d3_cfg_cmd_data.wakeup_flags = 1270 cpu_to_le32(IWL_WAKEUP_D3_HOST_TIMER); 1271 } 1272 1273 lockdep_assert_wiphy(mld->wiphy); 1274 1275 IWL_DEBUG_WOWLAN(mld, "Starting the no wowlan suspend flow\n"); 1276 1277 iwl_mld_low_latency_stop(mld); 1278 1279 /* This will happen if iwl_mld_supsend failed with FW error */ 1280 if (mld->trans->state == IWL_TRANS_NO_FW && 1281 test_bit(STATUS_FW_ERROR, &mld->trans->status)) 1282 return -ENODEV; 1283 1284 ret = iwl_mld_update_device_power(mld, true); 1285 if (ret) { 1286 IWL_ERR(mld, 1287 "d3 suspend: couldn't send power_device %d\n", ret); 1288 goto out; 1289 } 1290 1291 ret = iwl_mld_send_cmd_pdu(mld, D3_CONFIG_CMD, 1292 &d3_cfg_cmd_data); 1293 if (ret) { 1294 IWL_ERR(mld, 1295 "d3 suspend: couldn't send D3_CONFIG_CMD %d\n", ret); 1296 goto out; 1297 } 1298 1299 ret = iwl_trans_d3_suspend(mld->trans, false, false); 1300 if (ret) { 1301 IWL_ERR(mld, "d3 suspend: trans_d3_suspend failed %d\n", ret); 1302 } else { 1303 /* Async notification might send hcmds, which is not allowed in suspend */ 1304 iwl_mld_cancel_async_notifications(mld); 1305 mld->fw_status.in_d3 = true; 1306 } 1307 1308 out: 1309 if (ret) { 1310 mld->trans->state = IWL_TRANS_NO_FW; 1311 set_bit(STATUS_FW_ERROR, &mld->trans->status); 1312 } 1313 1314 return ret; 1315 } 1316 1317 int iwl_mld_no_wowlan_resume(struct iwl_mld *mld) 1318 { 1319 struct iwl_mld_resume_data resume_data = { 1320 .notifs_expected = 1321 IWL_D3_NOTIF_D3_END_NOTIF, 1322 }; 1323 int ret; 1324 1325 lockdep_assert_wiphy(mld->wiphy); 1326 1327 IWL_DEBUG_WOWLAN(mld, "Starting the no wowlan resume flow\n"); 1328 1329 mld->fw_status.in_d3 = false; 1330 iwl_fw_dbg_read_d3_debug_data(&mld->fwrt); 1331 1332 ret = iwl_mld_wait_d3_notif(mld, &resume_data, false); 1333 1334 if (!ret && (resume_data.d3_end_flags & IWL_D0I3_RESET_REQUIRE)) 1335 return -ENODEV; 1336 1337 if (ret) { 1338 mld->trans->state = IWL_TRANS_NO_FW; 1339 set_bit(STATUS_FW_ERROR, &mld->trans->status); 1340 return ret; 1341 } 1342 iwl_mld_low_latency_restart(mld); 1343 1344 return iwl_mld_update_device_power(mld, false); 1345 } 1346 1347 static void 1348 iwl_mld_aes_seq_to_le64_pn(struct ieee80211_key_conf *key, 1349 __le64 *key_rsc) 1350 { 1351 for (int i = 0; i < IWL_MAX_TID_COUNT; i++) { 1352 struct ieee80211_key_seq seq; 1353 u8 *pn = key->cipher == WLAN_CIPHER_SUITE_CCMP ? seq.ccmp.pn : 1354 seq.gcmp.pn; 1355 1356 ieee80211_get_key_rx_seq(key, i, &seq); 1357 key_rsc[i] = cpu_to_le64((u64)pn[5] | 1358 ((u64)pn[4] << 8) | 1359 ((u64)pn[3] << 16) | 1360 ((u64)pn[2] << 24) | 1361 ((u64)pn[1] << 32) | 1362 ((u64)pn[0] << 40)); 1363 } 1364 } 1365 1366 static void 1367 iwl_mld_suspend_set_ucast_pn(struct iwl_mld *mld, struct ieee80211_sta *sta, 1368 struct ieee80211_key_conf *key, __le64 *key_rsc) 1369 { 1370 struct iwl_mld_sta *mld_sta = 1371 iwl_mld_sta_from_mac80211(sta); 1372 struct iwl_mld_ptk_pn *mld_ptk_pn; 1373 1374 if (WARN_ON(key->keyidx >= ARRAY_SIZE(mld_sta->ptk_pn))) 1375 return; 1376 1377 mld_ptk_pn = wiphy_dereference(mld->wiphy, 1378 mld_sta->ptk_pn[key->keyidx]); 1379 if (WARN_ON(!mld_ptk_pn)) 1380 return; 1381 1382 for (int tid = 0; tid < IWL_MAX_TID_COUNT; tid++) { 1383 struct ieee80211_key_seq seq; 1384 u8 *max_pn = seq.ccmp.pn; 1385 1386 /* get the PN from mac80211, used on the default queue */ 1387 ieee80211_get_key_rx_seq(key, tid, &seq); 1388 1389 /* and use the internal data for all queues */ 1390 for (int que = 1; que < mld->trans->info.num_rxqs; que++) { 1391 u8 *cur_pn = mld_ptk_pn->q[que].pn[tid]; 1392 1393 if (memcmp(max_pn, cur_pn, IEEE80211_CCMP_PN_LEN) < 0) 1394 max_pn = cur_pn; 1395 } 1396 key_rsc[tid] = cpu_to_le64((u64)max_pn[5] | 1397 ((u64)max_pn[4] << 8) | 1398 ((u64)max_pn[3] << 16) | 1399 ((u64)max_pn[2] << 24) | 1400 ((u64)max_pn[1] << 32) | 1401 ((u64)max_pn[0] << 40)); 1402 } 1403 } 1404 1405 static void 1406 iwl_mld_suspend_convert_tkip_ipn(struct ieee80211_key_conf *key, 1407 __le64 *rsc) 1408 { 1409 struct ieee80211_key_seq seq; 1410 1411 for (int i = 0; i < IWL_MAX_TID_COUNT; i++) { 1412 ieee80211_get_key_rx_seq(key, i, &seq); 1413 rsc[i] = 1414 cpu_to_le64(((u64)seq.tkip.iv32 << 16) | 1415 seq.tkip.iv16); 1416 } 1417 } 1418 1419 static void 1420 iwl_mld_suspend_key_data_iter(struct ieee80211_hw *hw, 1421 struct ieee80211_vif *vif, 1422 struct ieee80211_sta *sta, 1423 struct ieee80211_key_conf *key, 1424 void *_data) 1425 { 1426 struct iwl_mld *mld = IWL_MAC80211_GET_MLD(hw); 1427 struct iwl_mld_suspend_key_iter_data *data = _data; 1428 __le64 *key_rsc; 1429 __le32 cipher = 0; 1430 1431 switch (key->cipher) { 1432 case WLAN_CIPHER_SUITE_CCMP: 1433 cipher = cpu_to_le32(STA_KEY_FLG_CCM); 1434 fallthrough; 1435 case WLAN_CIPHER_SUITE_GCMP: 1436 case WLAN_CIPHER_SUITE_GCMP_256: 1437 if (!cipher) 1438 cipher = cpu_to_le32(STA_KEY_FLG_GCMP); 1439 fallthrough; 1440 case WLAN_CIPHER_SUITE_TKIP: 1441 if (!cipher) 1442 cipher = cpu_to_le32(STA_KEY_FLG_TKIP); 1443 if (sta) { 1444 key_rsc = data->rsc->ucast_rsc; 1445 if (key->cipher == WLAN_CIPHER_SUITE_TKIP) 1446 iwl_mld_suspend_convert_tkip_ipn(key, key_rsc); 1447 else 1448 iwl_mld_suspend_set_ucast_pn(mld, sta, key, 1449 key_rsc); 1450 1451 data->have_rsc = true; 1452 return; 1453 } 1454 /* We're iterating from old to new, there're 4 possible 1455 * gtk ids, and only the last two keys matter 1456 */ 1457 if (WARN_ON(data->gtks >= 1458 ARRAY_SIZE(data->found_gtk_idx))) 1459 return; 1460 1461 if (WARN_ON(key->keyidx >= 1462 ARRAY_SIZE(data->rsc->mcast_key_id_map))) 1463 return; 1464 data->gtk_cipher = cipher; 1465 data->found_gtk_idx[data->gtks] = key->keyidx; 1466 key_rsc = data->rsc->mcast_rsc[data->gtks % 2]; 1467 data->rsc->mcast_key_id_map[key->keyidx] = 1468 data->gtks % 2; 1469 1470 if (data->gtks >= 2) { 1471 int prev = data->gtks % 2; 1472 int prev_idx = data->found_gtk_idx[prev]; 1473 1474 data->rsc->mcast_key_id_map[prev_idx] = 1475 IWL_MCAST_KEY_MAP_INVALID; 1476 } 1477 1478 if (key->cipher == WLAN_CIPHER_SUITE_TKIP) 1479 iwl_mld_suspend_convert_tkip_ipn(key, key_rsc); 1480 else 1481 iwl_mld_aes_seq_to_le64_pn(key, key_rsc); 1482 1483 data->gtks++; 1484 data->have_rsc = true; 1485 break; 1486 case WLAN_CIPHER_SUITE_BIP_GMAC_128: 1487 case WLAN_CIPHER_SUITE_BIP_GMAC_256: 1488 cipher = cpu_to_le32(STA_KEY_FLG_GCMP); 1489 fallthrough; 1490 case WLAN_CIPHER_SUITE_BIP_CMAC_256: 1491 case WLAN_CIPHER_SUITE_AES_CMAC: 1492 if (!cipher) 1493 cipher = cpu_to_le32(STA_KEY_FLG_CCM); 1494 if (key->keyidx == 4 || key->keyidx == 5) 1495 data->igtk_cipher = cipher; 1496 1497 if (key->keyidx == 6 || key->keyidx == 7) 1498 data->bigtk_cipher = cipher; 1499 1500 break; 1501 } 1502 } 1503 1504 static int 1505 iwl_mld_send_kek_kck_cmd(struct iwl_mld *mld, 1506 struct iwl_mld_vif *mld_vif, 1507 struct iwl_mld_suspend_key_iter_data data, 1508 int ap_sta_id) 1509 { 1510 struct iwl_wowlan_kek_kck_material_cmd_v4 kek_kck_cmd = {}; 1511 struct iwl_mld_rekey_data *rekey_data = 1512 &mld_vif->wowlan_data.rekey_data; 1513 1514 memcpy(kek_kck_cmd.kck, rekey_data->kck, 1515 rekey_data->kck_len); 1516 kek_kck_cmd.kck_len = cpu_to_le16(rekey_data->kck_len); 1517 memcpy(kek_kck_cmd.kek, rekey_data->kek, 1518 rekey_data->kek_len); 1519 kek_kck_cmd.kek_len = cpu_to_le16(rekey_data->kek_len); 1520 kek_kck_cmd.replay_ctr = rekey_data->replay_ctr; 1521 kek_kck_cmd.akm = cpu_to_le32(rekey_data->akm); 1522 kek_kck_cmd.sta_id = cpu_to_le32(ap_sta_id); 1523 kek_kck_cmd.gtk_cipher = data.gtk_cipher; 1524 kek_kck_cmd.igtk_cipher = data.igtk_cipher; 1525 kek_kck_cmd.bigtk_cipher = data.bigtk_cipher; 1526 1527 IWL_DEBUG_WOWLAN(mld, "setting akm %d\n", 1528 rekey_data->akm); 1529 1530 return iwl_mld_send_cmd_pdu(mld, WOWLAN_KEK_KCK_MATERIAL, 1531 &kek_kck_cmd); 1532 } 1533 1534 static int 1535 iwl_mld_suspend_send_security_cmds(struct iwl_mld *mld, 1536 struct ieee80211_vif *vif, 1537 struct iwl_mld_vif *mld_vif, 1538 int ap_sta_id) 1539 { 1540 struct iwl_mld_suspend_key_iter_data data = {}; 1541 int ret; 1542 1543 data.rsc = kzalloc(sizeof(*data.rsc), GFP_KERNEL); 1544 if (!data.rsc) 1545 return -ENOMEM; 1546 1547 memset(data.rsc->mcast_key_id_map, IWL_MCAST_KEY_MAP_INVALID, 1548 ARRAY_SIZE(data.rsc->mcast_key_id_map)); 1549 1550 data.rsc->sta_id = cpu_to_le32(ap_sta_id); 1551 ieee80211_iter_keys(mld->hw, vif, 1552 iwl_mld_suspend_key_data_iter, 1553 &data); 1554 1555 if (data.have_rsc) 1556 ret = iwl_mld_send_cmd_pdu(mld, WOWLAN_TSC_RSC_PARAM, 1557 data.rsc); 1558 else 1559 ret = 0; 1560 1561 if (!ret && mld_vif->wowlan_data.rekey_data.valid) 1562 ret = iwl_mld_send_kek_kck_cmd(mld, mld_vif, data, ap_sta_id); 1563 1564 kfree(data.rsc); 1565 1566 return ret; 1567 } 1568 1569 static void 1570 iwl_mld_set_wowlan_config_cmd(struct iwl_mld *mld, 1571 struct cfg80211_wowlan *wowlan, 1572 struct iwl_wowlan_config_cmd *wowlan_config_cmd, 1573 struct ieee80211_sta *ap_sta, 1574 struct ieee80211_bss_conf *link) 1575 { 1576 wowlan_config_cmd->is_11n_connection = 1577 ap_sta->deflink.ht_cap.ht_supported; 1578 wowlan_config_cmd->flags = ENABLE_L3_FILTERING | 1579 ENABLE_NBNS_FILTERING | ENABLE_DHCP_FILTERING; 1580 1581 if (ap_sta->mfp) 1582 wowlan_config_cmd->flags |= IS_11W_ASSOC; 1583 1584 if (iwl_mld_beacon_protection_enabled(mld, link)) 1585 wowlan_config_cmd->flags |= HAS_BEACON_PROTECTION; 1586 1587 if (wowlan->disconnect) 1588 wowlan_config_cmd->wakeup_filter |= 1589 cpu_to_le32(IWL_WOWLAN_WAKEUP_BEACON_MISS | 1590 IWL_WOWLAN_WAKEUP_LINK_CHANGE); 1591 if (wowlan->magic_pkt) 1592 wowlan_config_cmd->wakeup_filter |= 1593 cpu_to_le32(IWL_WOWLAN_WAKEUP_MAGIC_PACKET); 1594 if (wowlan->gtk_rekey_failure) 1595 wowlan_config_cmd->wakeup_filter |= 1596 cpu_to_le32(IWL_WOWLAN_WAKEUP_GTK_REKEY_FAIL); 1597 if (wowlan->eap_identity_req) 1598 wowlan_config_cmd->wakeup_filter |= 1599 cpu_to_le32(IWL_WOWLAN_WAKEUP_EAP_IDENT_REQ); 1600 if (wowlan->four_way_handshake) 1601 wowlan_config_cmd->wakeup_filter |= 1602 cpu_to_le32(IWL_WOWLAN_WAKEUP_4WAY_HANDSHAKE); 1603 if (wowlan->n_patterns) 1604 wowlan_config_cmd->wakeup_filter |= 1605 cpu_to_le32(IWL_WOWLAN_WAKEUP_PATTERN_MATCH); 1606 1607 if (wowlan->rfkill_release) 1608 wowlan_config_cmd->wakeup_filter |= 1609 cpu_to_le32(IWL_WOWLAN_WAKEUP_RF_KILL_DEASSERT); 1610 1611 if (wowlan->any) { 1612 wowlan_config_cmd->wakeup_filter |= 1613 cpu_to_le32(IWL_WOWLAN_WAKEUP_BEACON_MISS | 1614 IWL_WOWLAN_WAKEUP_LINK_CHANGE | 1615 IWL_WOWLAN_WAKEUP_RX_FRAME | 1616 IWL_WOWLAN_WAKEUP_BCN_FILTERING); 1617 } 1618 } 1619 1620 static int iwl_mld_send_patterns(struct iwl_mld *mld, 1621 struct cfg80211_wowlan *wowlan, 1622 int ap_sta_id) 1623 { 1624 struct iwl_wowlan_patterns_cmd *pattern_cmd; 1625 struct iwl_host_cmd cmd = { 1626 .id = WOWLAN_PATTERNS, 1627 .dataflags[0] = IWL_HCMD_DFL_NOCOPY, 1628 }; 1629 int ret; 1630 1631 if (!wowlan->n_patterns) 1632 return 0; 1633 1634 cmd.len[0] = struct_size(pattern_cmd, patterns, wowlan->n_patterns); 1635 1636 pattern_cmd = kzalloc(cmd.len[0], GFP_KERNEL); 1637 if (!pattern_cmd) 1638 return -ENOMEM; 1639 1640 pattern_cmd->n_patterns = wowlan->n_patterns; 1641 pattern_cmd->sta_id = ap_sta_id; 1642 1643 for (int i = 0; i < wowlan->n_patterns; i++) { 1644 int mask_len = DIV_ROUND_UP(wowlan->patterns[i].pattern_len, 8); 1645 1646 pattern_cmd->patterns[i].pattern_type = 1647 WOWLAN_PATTERN_TYPE_BITMASK; 1648 1649 memcpy(&pattern_cmd->patterns[i].u.bitmask.mask, 1650 wowlan->patterns[i].mask, mask_len); 1651 memcpy(&pattern_cmd->patterns[i].u.bitmask.pattern, 1652 wowlan->patterns[i].pattern, 1653 wowlan->patterns[i].pattern_len); 1654 pattern_cmd->patterns[i].u.bitmask.mask_size = mask_len; 1655 pattern_cmd->patterns[i].u.bitmask.pattern_size = 1656 wowlan->patterns[i].pattern_len; 1657 } 1658 1659 cmd.data[0] = pattern_cmd; 1660 ret = iwl_mld_send_cmd(mld, &cmd); 1661 kfree(pattern_cmd); 1662 return ret; 1663 } 1664 1665 static int 1666 iwl_mld_send_proto_offload(struct iwl_mld *mld, 1667 struct ieee80211_vif *vif, 1668 u8 ap_sta_id) 1669 { 1670 struct iwl_proto_offload_cmd_v4 *cmd __free(kfree); 1671 struct iwl_host_cmd hcmd = { 1672 .id = PROT_OFFLOAD_CONFIG_CMD, 1673 .dataflags[0] = IWL_HCMD_DFL_NOCOPY, 1674 .len[0] = sizeof(*cmd), 1675 }; 1676 u32 enabled = 0; 1677 1678 cmd = kzalloc(hcmd.len[0], GFP_KERNEL); 1679 1680 #if IS_ENABLED(CONFIG_IPV6) 1681 struct iwl_mld_vif *mld_vif = iwl_mld_vif_from_mac80211(vif); 1682 struct iwl_mld_wowlan_data *wowlan_data = &mld_vif->wowlan_data; 1683 struct iwl_ns_config *nsc; 1684 struct iwl_targ_addr *addrs; 1685 int n_nsc, n_addrs; 1686 int i, c; 1687 int num_skipped = 0; 1688 1689 nsc = cmd->ns_config; 1690 n_nsc = IWL_PROTO_OFFLOAD_NUM_NS_CONFIG_V3L; 1691 addrs = cmd->targ_addrs; 1692 n_addrs = IWL_PROTO_OFFLOAD_NUM_IPV6_ADDRS_V3L; 1693 1694 /* For each address we have (and that will fit) fill a target 1695 * address struct and combine for NS offload structs with the 1696 * solicited node addresses. 1697 */ 1698 for (i = 0, c = 0; 1699 i < wowlan_data->num_target_ipv6_addrs && 1700 i < n_addrs && c < n_nsc; i++) { 1701 int j; 1702 struct in6_addr solicited_addr; 1703 1704 /* Because ns is offloaded skip tentative address to avoid 1705 * violating RFC4862. 1706 */ 1707 if (test_bit(i, wowlan_data->tentative_addrs)) { 1708 num_skipped++; 1709 continue; 1710 } 1711 1712 addrconf_addr_solict_mult(&wowlan_data->target_ipv6_addrs[i], 1713 &solicited_addr); 1714 for (j = 0; j < n_nsc && j < c; j++) 1715 if (ipv6_addr_cmp(&nsc[j].dest_ipv6_addr, 1716 &solicited_addr) == 0) 1717 break; 1718 if (j == c) 1719 c++; 1720 addrs[i].addr = wowlan_data->target_ipv6_addrs[i]; 1721 addrs[i].config_num = cpu_to_le32(j); 1722 nsc[j].dest_ipv6_addr = solicited_addr; 1723 memcpy(nsc[j].target_mac_addr, vif->addr, ETH_ALEN); 1724 } 1725 1726 if (wowlan_data->num_target_ipv6_addrs - num_skipped) 1727 enabled |= IWL_D3_PROTO_IPV6_VALID; 1728 1729 cmd->num_valid_ipv6_addrs = cpu_to_le32(i - num_skipped); 1730 if (enabled & IWL_D3_PROTO_IPV6_VALID) 1731 enabled |= IWL_D3_PROTO_OFFLOAD_NS; 1732 #endif 1733 1734 if (vif->cfg.arp_addr_cnt) { 1735 enabled |= IWL_D3_PROTO_OFFLOAD_ARP | IWL_D3_PROTO_IPV4_VALID; 1736 cmd->common.host_ipv4_addr = vif->cfg.arp_addr_list[0]; 1737 ether_addr_copy(cmd->common.arp_mac_addr, vif->addr); 1738 } 1739 1740 enabled |= IWL_D3_PROTO_OFFLOAD_BTM; 1741 cmd->common.enabled = cpu_to_le32(enabled); 1742 cmd->sta_id = cpu_to_le32(ap_sta_id); 1743 hcmd.data[0] = cmd; 1744 return iwl_mld_send_cmd(mld, &hcmd); 1745 } 1746 1747 static int 1748 iwl_mld_wowlan_config(struct iwl_mld *mld, struct ieee80211_vif *bss_vif, 1749 struct cfg80211_wowlan *wowlan) 1750 { 1751 struct iwl_mld_vif *mld_vif = iwl_mld_vif_from_mac80211(bss_vif); 1752 struct ieee80211_sta *ap_sta = mld_vif->ap_sta; 1753 struct iwl_wowlan_config_cmd wowlan_config_cmd = { 1754 .offloading_tid = IWL_WOWLAN_OFFLOAD_TID, 1755 }; 1756 u32 sta_id_mask; 1757 int ap_sta_id, ret; 1758 int link_id = iwl_mld_get_primary_link(bss_vif); 1759 struct ieee80211_bss_conf *link_conf; 1760 1761 ret = iwl_mld_block_emlsr_sync(mld, bss_vif, 1762 IWL_MLD_EMLSR_BLOCKED_WOWLAN, link_id); 1763 if (ret) 1764 return ret; 1765 1766 link_conf = link_conf_dereference_protected(bss_vif, link_id); 1767 1768 if (WARN_ON(!ap_sta || !link_conf)) 1769 return -EINVAL; 1770 1771 sta_id_mask = iwl_mld_fw_sta_id_mask(mld, ap_sta); 1772 if (WARN_ON(hweight32(sta_id_mask) != 1)) 1773 return -EINVAL; 1774 1775 ap_sta_id = __ffs(sta_id_mask); 1776 wowlan_config_cmd.sta_id = ap_sta_id; 1777 1778 ret = iwl_mld_ensure_queue(mld, 1779 ap_sta->txq[wowlan_config_cmd.offloading_tid]); 1780 if (ret) 1781 return ret; 1782 1783 iwl_mld_set_wowlan_config_cmd(mld, wowlan, 1784 &wowlan_config_cmd, ap_sta, link_conf); 1785 ret = iwl_mld_send_cmd_pdu(mld, WOWLAN_CONFIGURATION, 1786 &wowlan_config_cmd); 1787 if (ret) 1788 return ret; 1789 1790 ret = iwl_mld_suspend_send_security_cmds(mld, bss_vif, mld_vif, 1791 ap_sta_id); 1792 if (ret) 1793 return ret; 1794 1795 ret = iwl_mld_send_patterns(mld, wowlan, ap_sta_id); 1796 if (ret) 1797 return ret; 1798 1799 ret = iwl_mld_send_proto_offload(mld, bss_vif, ap_sta_id); 1800 if (ret) 1801 return ret; 1802 1803 iwl_mld_enable_beacon_filter(mld, link_conf, true); 1804 return iwl_mld_update_mac_power(mld, bss_vif, true); 1805 } 1806 1807 int iwl_mld_wowlan_suspend(struct iwl_mld *mld, struct cfg80211_wowlan *wowlan) 1808 { 1809 struct ieee80211_vif *bss_vif; 1810 1811 lockdep_assert_wiphy(mld->wiphy); 1812 1813 if (WARN_ON(!wowlan)) 1814 return 1; 1815 1816 IWL_DEBUG_WOWLAN(mld, "Starting the wowlan suspend flow\n"); 1817 1818 bss_vif = iwl_mld_get_bss_vif(mld); 1819 if (WARN_ON(!bss_vif)) 1820 return 1; 1821 1822 if (!bss_vif->cfg.assoc) { 1823 int ret; 1824 /* If we're not associated, this must be netdetect */ 1825 if (WARN_ON(!wowlan->nd_config)) 1826 return 1; 1827 1828 ret = iwl_mld_netdetect_config(mld, bss_vif, wowlan); 1829 if (!ret) 1830 mld->netdetect = true; 1831 1832 return ret; 1833 } 1834 1835 return iwl_mld_wowlan_config(mld, bss_vif, wowlan); 1836 } 1837 1838 /* Returns 0 on success, 1 if an error occurred in firmware during d3, 1839 * A negative value is expected only in unrecovreable cases. 1840 */ 1841 int iwl_mld_wowlan_resume(struct iwl_mld *mld) 1842 { 1843 struct ieee80211_vif *bss_vif; 1844 struct ieee80211_bss_conf *link_conf; 1845 struct iwl_mld_netdetect_res netdetect_res; 1846 struct iwl_mld_resume_data resume_data = { 1847 .notifs_expected = 1848 IWL_D3_NOTIF_WOWLAN_INFO | 1849 IWL_D3_NOTIF_D3_END_NOTIF, 1850 .netdetect_res = &netdetect_res, 1851 }; 1852 int link_id; 1853 int ret; 1854 bool fw_err = false; 1855 1856 lockdep_assert_wiphy(mld->wiphy); 1857 1858 IWL_DEBUG_WOWLAN(mld, "Starting the wowlan resume flow\n"); 1859 1860 if (!mld->fw_status.in_d3) { 1861 IWL_DEBUG_WOWLAN(mld, 1862 "Device_powered_off() was called during wowlan\n"); 1863 goto err; 1864 } 1865 1866 mld->fw_status.resuming = true; 1867 mld->fw_status.in_d3 = false; 1868 mld->scan.last_start_time_jiffies = jiffies; 1869 1870 bss_vif = iwl_mld_get_bss_vif(mld); 1871 if (WARN_ON(!bss_vif)) 1872 goto err; 1873 1874 /* We can't have several links upon wowlan entry, 1875 * this is enforced in the suspend flow. 1876 */ 1877 WARN_ON(hweight16(bss_vif->active_links) > 1); 1878 link_id = bss_vif->active_links ? __ffs(bss_vif->active_links) : 0; 1879 link_conf = link_conf_dereference_protected(bss_vif, link_id); 1880 1881 if (WARN_ON(!link_conf)) 1882 goto err; 1883 1884 iwl_fw_dbg_read_d3_debug_data(&mld->fwrt); 1885 1886 resume_data.wowlan_status = kzalloc(sizeof(*resume_data.wowlan_status), 1887 GFP_KERNEL); 1888 if (!resume_data.wowlan_status) 1889 return -ENOMEM; 1890 1891 if (mld->netdetect) 1892 resume_data.notifs_expected |= IWL_D3_ND_MATCH_INFO; 1893 1894 ret = iwl_mld_wait_d3_notif(mld, &resume_data, true); 1895 if (ret) { 1896 IWL_ERR(mld, "Couldn't get the d3 notifs %d\n", ret); 1897 fw_err = true; 1898 goto err; 1899 } 1900 1901 if (resume_data.d3_end_flags & IWL_D0I3_RESET_REQUIRE) { 1902 mld->fw_status.in_hw_restart = true; 1903 goto process_wakeup_results; 1904 } 1905 1906 iwl_mld_update_changed_regdomain(mld); 1907 iwl_mld_update_mac_power(mld, bss_vif, false); 1908 iwl_mld_enable_beacon_filter(mld, link_conf, false); 1909 iwl_mld_update_device_power(mld, false); 1910 1911 if (mld->netdetect) 1912 ret = iwl_mld_scan_stop(mld, IWL_MLD_SCAN_NETDETECT, false); 1913 1914 process_wakeup_results: 1915 if (mld->netdetect) { 1916 iwl_mld_process_netdetect_res(mld, bss_vif, &resume_data); 1917 mld->netdetect = false; 1918 } else { 1919 bool keep_connection = 1920 iwl_mld_process_wowlan_status(mld, bss_vif, 1921 resume_data.wowlan_status); 1922 1923 /* EMLSR state will be cleared if the connection is not kept */ 1924 if (keep_connection) 1925 iwl_mld_unblock_emlsr(mld, bss_vif, 1926 IWL_MLD_EMLSR_BLOCKED_WOWLAN); 1927 else 1928 ieee80211_resume_disconnect(bss_vif); 1929 } 1930 1931 goto out; 1932 1933 err: 1934 if (fw_err) { 1935 mld->trans->state = IWL_TRANS_NO_FW; 1936 set_bit(STATUS_FW_ERROR, &mld->trans->status); 1937 } 1938 1939 mld->fw_status.in_hw_restart = true; 1940 ret = 1; 1941 out: 1942 mld->fw_status.resuming = false; 1943 1944 if (resume_data.wowlan_status) { 1945 kfree(resume_data.wowlan_status->wake_packet); 1946 kfree(resume_data.wowlan_status); 1947 } 1948 1949 return ret; 1950 } 1951