| 1 |
// SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause |
| 2 |
/* |
| 3 |
* Copyright (C) 2012-2014, 2018-2026 Intel Corporation |
| 4 |
* Copyright (C) 2013-2014 Intel Mobile Communications GmbH |
| 5 |
* Copyright (C) 2015-2017 Intel Deutschland GmbH |
| 6 |
*/ |
| 7 |
#include <linux/etherdevice.h> |
| 8 |
#include <linux/crc32.h> |
| 9 |
#include <net/mac80211.h> |
| 10 |
#include "iwl-io.h" |
| 11 |
#include "iwl-prph.h" |
| 12 |
#include "fw-api.h" |
| 13 |
#include "mvm.h" |
| 14 |
#include "time-event.h" |
| 15 |
#include "iwl-utils.h" |
| 16 |
|
| 17 |
const u8 iwl_mvm_ac_to_tx_fifo[] = { |
| 18 |
IWL_MVM_TX_FIFO_VO, |
| 19 |
IWL_MVM_TX_FIFO_VI, |
| 20 |
IWL_MVM_TX_FIFO_BE, |
| 21 |
IWL_MVM_TX_FIFO_BK, |
| 22 |
}; |
| 23 |
|
| 24 |
const u8 iwl_mvm_ac_to_gen2_tx_fifo[] = { |
| 25 |
IWL_GEN2_EDCA_TX_FIFO_VO, |
| 26 |
IWL_GEN2_EDCA_TX_FIFO_VI, |
| 27 |
IWL_GEN2_EDCA_TX_FIFO_BE, |
| 28 |
IWL_GEN2_EDCA_TX_FIFO_BK, |
| 29 |
IWL_GEN2_TRIG_TX_FIFO_VO, |
| 30 |
IWL_GEN2_TRIG_TX_FIFO_VI, |
| 31 |
IWL_GEN2_TRIG_TX_FIFO_BE, |
| 32 |
IWL_GEN2_TRIG_TX_FIFO_BK, |
| 33 |
}; |
| 34 |
|
| 35 |
const u8 iwl_mvm_ac_to_bz_tx_fifo[] = { |
| 36 |
IWL_BZ_EDCA_TX_FIFO_VO, |
| 37 |
IWL_BZ_EDCA_TX_FIFO_VI, |
| 38 |
IWL_BZ_EDCA_TX_FIFO_BE, |
| 39 |
IWL_BZ_EDCA_TX_FIFO_BK, |
| 40 |
IWL_BZ_TRIG_TX_FIFO_VO, |
| 41 |
IWL_BZ_TRIG_TX_FIFO_VI, |
| 42 |
IWL_BZ_TRIG_TX_FIFO_BE, |
| 43 |
IWL_BZ_TRIG_TX_FIFO_BK, |
| 44 |
}; |
| 45 |
|
| 46 |
struct iwl_mvm_mac_iface_iterator_data { |
| 47 |
struct iwl_mvm *mvm; |
| 48 |
struct ieee80211_vif *vif; |
| 49 |
unsigned long available_mac_ids[BITS_TO_LONGS(NUM_MAC_INDEX_DRIVER)]; |
| 50 |
unsigned long available_tsf_ids[BITS_TO_LONGS(NUM_TSF_IDS)]; |
| 51 |
enum iwl_tsf_id preferred_tsf; |
| 52 |
bool found_vif; |
| 53 |
}; |
| 54 |
|
| 55 |
static void iwl_mvm_mac_tsf_id_iter(void *_data, u8 *mac, |
| 56 |
struct ieee80211_vif *vif) |
| 57 |
{ |
| 58 |
struct iwl_mvm_mac_iface_iterator_data *data = _data; |
| 59 |
struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); |
| 60 |
u16 min_bi; |
| 61 |
|
| 62 |
/* Skip the interface for which we are trying to assign a tsf_id */ |
| 63 |
if (vif == data->vif) |
| 64 |
return; |
| 65 |
|
| 66 |
/* |
| 67 |
* The TSF is a hardware/firmware resource, there are 4 and |
| 68 |
* the driver should assign and free them as needed. However, |
| 69 |
* there are cases where 2 MACs should share the same TSF ID |
| 70 |
* for the purpose of clock sync, an optimization to avoid |
| 71 |
* clock drift causing overlapping TBTTs/DTIMs for a GO and |
| 72 |
* client in the system. |
| 73 |
* |
| 74 |
* The firmware will decide according to the MAC type which |
| 75 |
* will be the leader and follower. Clients that need to sync |
| 76 |
* with a remote station will be the leader, and an AP or GO |
| 77 |
* will be the follower. |
| 78 |
* |
| 79 |
* Depending on the new interface type it can be following |
| 80 |
* or become the leader of an existing interface. |
| 81 |
*/ |
| 82 |
switch (data->vif->type) { |
| 83 |
case NL80211_IFTYPE_STATION: |
| 84 |
/* |
| 85 |
* The new interface is a client, so if the one we're iterating |
| 86 |
* is an AP, and the beacon interval of the AP is a multiple or |
| 87 |
* divisor of the beacon interval of the client, the same TSF |
| 88 |
* should be used to avoid drift between the new client and |
| 89 |
* existing AP. The existing AP will get drift updates from the |
| 90 |
* new client context in this case. |
| 91 |
*/ |
| 92 |
if (vif->type != NL80211_IFTYPE_AP || |
| 93 |
data->preferred_tsf != NUM_TSF_IDS || |
| 94 |
!test_bit(mvmvif->tsf_id, data->available_tsf_ids)) |
| 95 |
break; |
| 96 |
|
| 97 |
min_bi = min(data->vif->bss_conf.beacon_int, |
| 98 |
vif->bss_conf.beacon_int); |
| 99 |
|
| 100 |
if (!min_bi) |
| 101 |
break; |
| 102 |
|
| 103 |
if ((data->vif->bss_conf.beacon_int - |
| 104 |
vif->bss_conf.beacon_int) % min_bi == 0) { |
| 105 |
data->preferred_tsf = mvmvif->tsf_id; |
| 106 |
return; |
| 107 |
} |
| 108 |
break; |
| 109 |
|
| 110 |
case NL80211_IFTYPE_AP: |
| 111 |
/* |
| 112 |
* The new interface is AP/GO, so if its beacon interval is a |
| 113 |
* multiple or a divisor of the beacon interval of an existing |
| 114 |
* interface, it should get drift updates from an existing |
| 115 |
* client or use the same TSF as an existing GO. There's no |
| 116 |
* drift between TSFs internally but if they used different |
| 117 |
* TSFs then a new client MAC could update one of them and |
| 118 |
* cause drift that way. |
| 119 |
*/ |
| 120 |
if ((vif->type != NL80211_IFTYPE_AP && |
| 121 |
vif->type != NL80211_IFTYPE_STATION) || |
| 122 |
data->preferred_tsf != NUM_TSF_IDS || |
| 123 |
!test_bit(mvmvif->tsf_id, data->available_tsf_ids)) |
| 124 |
break; |
| 125 |
|
| 126 |
min_bi = min(data->vif->bss_conf.beacon_int, |
| 127 |
vif->bss_conf.beacon_int); |
| 128 |
|
| 129 |
if (!min_bi) |
| 130 |
break; |
| 131 |
|
| 132 |
if ((data->vif->bss_conf.beacon_int - |
| 133 |
vif->bss_conf.beacon_int) % min_bi == 0) { |
| 134 |
data->preferred_tsf = mvmvif->tsf_id; |
| 135 |
return; |
| 136 |
} |
| 137 |
break; |
| 138 |
default: |
| 139 |
/* |
| 140 |
* For all other interface types there's no need to |
| 141 |
* take drift into account. Either they're exclusive |
| 142 |
* like IBSS and monitor, or we don't care much about |
| 143 |
* their TSF (like P2P Device), but we won't be able |
| 144 |
* to share the TSF resource. |
| 145 |
*/ |
| 146 |
break; |
| 147 |
} |
| 148 |
|
| 149 |
/* |
| 150 |
* Unless we exited above, we can't share the TSF resource |
| 151 |
* that the virtual interface we're iterating over is using |
| 152 |
* with the new one, so clear the available bit and if this |
| 153 |
* was the preferred one, reset that as well. |
| 154 |
*/ |
| 155 |
__clear_bit(mvmvif->tsf_id, data->available_tsf_ids); |
| 156 |
|
| 157 |
if (data->preferred_tsf == mvmvif->tsf_id) |
| 158 |
data->preferred_tsf = NUM_TSF_IDS; |
| 159 |
} |
| 160 |
|
| 161 |
static void iwl_mvm_mac_iface_iterator(void *_data, u8 *mac, |
| 162 |
struct ieee80211_vif *vif) |
| 163 |
{ |
| 164 |
struct iwl_mvm_mac_iface_iterator_data *data = _data; |
| 165 |
struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); |
| 166 |
|
| 167 |
/* Iterator may already find the interface being added -- skip it */ |
| 168 |
if (vif == data->vif) { |
| 169 |
data->found_vif = true; |
| 170 |
return; |
| 171 |
} |
| 172 |
|
| 173 |
/* Mark MAC IDs as used by clearing the available bit, and |
| 174 |
* (below) mark TSFs as used if their existing use is not |
| 175 |
* compatible with the new interface type. |
| 176 |
* No locking or atomic bit operations are needed since the |
| 177 |
* data is on the stack of the caller function. |
| 178 |
*/ |
| 179 |
__clear_bit(mvmvif->id, data->available_mac_ids); |
| 180 |
|
| 181 |
/* find a suitable tsf_id */ |
| 182 |
iwl_mvm_mac_tsf_id_iter(_data, mac, vif); |
| 183 |
} |
| 184 |
|
| 185 |
void iwl_mvm_mac_ctxt_recalc_tsf_id(struct iwl_mvm *mvm, |
| 186 |
struct ieee80211_vif *vif) |
| 187 |
{ |
| 188 |
struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); |
| 189 |
struct iwl_mvm_mac_iface_iterator_data data = { |
| 190 |
.mvm = mvm, |
| 191 |
.vif = vif, |
| 192 |
.available_tsf_ids = { (1 << NUM_TSF_IDS) - 1 }, |
| 193 |
/* no preference yet */ |
| 194 |
.preferred_tsf = NUM_TSF_IDS, |
| 195 |
}; |
| 196 |
|
| 197 |
ieee80211_iterate_active_interfaces_atomic( |
| 198 |
mvm->hw, IEEE80211_IFACE_ITER_RESUME_ALL, |
| 199 |
iwl_mvm_mac_tsf_id_iter, &data); |
| 200 |
|
| 201 |
if (data.preferred_tsf != NUM_TSF_IDS) |
| 202 |
mvmvif->tsf_id = data.preferred_tsf; |
| 203 |
else if (!test_bit(mvmvif->tsf_id, data.available_tsf_ids)) |
| 204 |
mvmvif->tsf_id = find_first_bit(data.available_tsf_ids, |
| 205 |
NUM_TSF_IDS); |
| 206 |
} |
| 207 |
|
| 208 |
int iwl_mvm_mac_ctxt_init(struct iwl_mvm *mvm, struct ieee80211_vif *vif) |
| 209 |
{ |
| 210 |
struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); |
| 211 |
struct iwl_mvm_mac_iface_iterator_data data = { |
| 212 |
.mvm = mvm, |
| 213 |
.vif = vif, |
| 214 |
.available_mac_ids = { (1 << NUM_MAC_INDEX_DRIVER) - 1 }, |
| 215 |
.available_tsf_ids = { (1 << NUM_TSF_IDS) - 1 }, |
| 216 |
/* no preference yet */ |
| 217 |
.preferred_tsf = NUM_TSF_IDS, |
| 218 |
.found_vif = false, |
| 219 |
}; |
| 220 |
int ret; |
| 221 |
|
| 222 |
lockdep_assert_held(&mvm->mutex); |
| 223 |
|
| 224 |
/* |
| 225 |
* Allocate a MAC ID and a TSF for this MAC, along with the queues |
| 226 |
* and other resources. |
| 227 |
*/ |
| 228 |
|
| 229 |
/* |
| 230 |
* Before the iterator, we start with all MAC IDs and TSFs available. |
| 231 |
* |
| 232 |
* During iteration, all MAC IDs are cleared that are in use by other |
| 233 |
* virtual interfaces, and all TSF IDs are cleared that can't be used |
| 234 |
* by this new virtual interface because they're used by an interface |
| 235 |
* that can't share it with the new one. |
| 236 |
* At the same time, we check if there's a preferred TSF in the case |
| 237 |
* that we should share it with another interface. |
| 238 |
*/ |
| 239 |
|
| 240 |
/* MAC ID 0 should be used only for the managed/IBSS vif with non-MLO |
| 241 |
* FW API |
| 242 |
*/ |
| 243 |
if (!mvm->mld_api_is_used) { |
| 244 |
switch (vif->type) { |
| 245 |
case NL80211_IFTYPE_ADHOC: |
| 246 |
break; |
| 247 |
case NL80211_IFTYPE_STATION: |
| 248 |
if (!vif->p2p) |
| 249 |
break; |
| 250 |
fallthrough; |
| 251 |
default: |
| 252 |
__clear_bit(0, data.available_mac_ids); |
| 253 |
} |
| 254 |
} |
| 255 |
|
| 256 |
ieee80211_iterate_active_interfaces_atomic( |
| 257 |
mvm->hw, IEEE80211_IFACE_ITER_RESUME_ALL, |
| 258 |
iwl_mvm_mac_iface_iterator, &data); |
| 259 |
|
| 260 |
/* |
| 261 |
* In the case we're getting here during resume, it's similar to |
| 262 |
* firmware restart, and with RESUME_ALL the iterator will find |
| 263 |
* the vif being added already. |
| 264 |
* We don't want to reassign any IDs in either case since doing |
| 265 |
* so would probably assign different IDs (as interfaces aren't |
| 266 |
* necessarily added in the same order), but the old IDs were |
| 267 |
* preserved anyway, so skip ID assignment for both resume and |
| 268 |
* recovery. |
| 269 |
*/ |
| 270 |
if (data.found_vif) |
| 271 |
return 0; |
| 272 |
|
| 273 |
/* Therefore, in recovery, we can't get here */ |
| 274 |
if (WARN_ON_ONCE(test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status))) |
| 275 |
return -EBUSY; |
| 276 |
|
| 277 |
mvmvif->id = find_first_bit(data.available_mac_ids, |
| 278 |
NUM_MAC_INDEX_DRIVER); |
| 279 |
if (mvmvif->id == NUM_MAC_INDEX_DRIVER) { |
| 280 |
IWL_ERR(mvm, "Failed to init MAC context - no free ID!\n"); |
| 281 |
ret = -EIO; |
| 282 |
goto exit_fail; |
| 283 |
} |
| 284 |
|
| 285 |
if (data.preferred_tsf != NUM_TSF_IDS) |
| 286 |
mvmvif->tsf_id = data.preferred_tsf; |
| 287 |
else |
| 288 |
mvmvif->tsf_id = find_first_bit(data.available_tsf_ids, |
| 289 |
NUM_TSF_IDS); |
| 290 |
if (mvmvif->tsf_id == NUM_TSF_IDS) { |
| 291 |
IWL_ERR(mvm, "Failed to init MAC context - no free TSF!\n"); |
| 292 |
ret = -EIO; |
| 293 |
goto exit_fail; |
| 294 |
} |
| 295 |
|
| 296 |
mvmvif->color = 0; |
| 297 |
|
| 298 |
INIT_LIST_HEAD(&mvmvif->time_event_data.list); |
| 299 |
mvmvif->time_event_data.id = TE_MAX; |
| 300 |
mvmvif->roc_activity = ROC_NUM_ACTIVITIES; |
| 301 |
|
| 302 |
iwl_mvm_init_link(&mvmvif->deflink); |
| 303 |
|
| 304 |
/* No need to allocate data queues to P2P Device MAC */ |
| 305 |
if (vif->type == NL80211_IFTYPE_P2P_DEVICE) |
| 306 |
return 0; |
| 307 |
|
| 308 |
/* Allocate the CAB queue for softAP and GO interfaces */ |
| 309 |
if (vif->type == NL80211_IFTYPE_AP || |
| 310 |
vif->type == NL80211_IFTYPE_ADHOC) { |
| 311 |
/* |
| 312 |
* For TVQM this will be overwritten later with the FW assigned |
| 313 |
* queue value (when queue is enabled). |
| 314 |
*/ |
| 315 |
mvmvif->deflink.cab_queue = IWL_MVM_DQA_GCAST_QUEUE; |
| 316 |
} |
| 317 |
|
| 318 |
return 0; |
| 319 |
|
| 320 |
exit_fail: |
| 321 |
memset(mvmvif, 0, sizeof(struct iwl_mvm_vif)); |
| 322 |
return ret; |
| 323 |
} |
| 324 |
|
| 325 |
static void iwl_mvm_ack_rates(struct iwl_mvm *mvm, |
| 326 |
struct ieee80211_vif *vif, |
| 327 |
enum nl80211_band band, |
| 328 |
u8 *cck_rates, u8 *ofdm_rates) |
| 329 |
{ |
| 330 |
struct ieee80211_supported_band *sband; |
| 331 |
unsigned long basic = vif->bss_conf.basic_rates; |
| 332 |
int lowest_present_ofdm = 100; |
| 333 |
int lowest_present_cck = 100; |
| 334 |
u8 cck = 0; |
| 335 |
u8 ofdm = 0; |
| 336 |
int i; |
| 337 |
|
| 338 |
sband = mvm->hw->wiphy->bands[band]; |
| 339 |
|
| 340 |
for_each_set_bit(i, &basic, BITS_PER_LONG) { |
| 341 |
int hw = sband->bitrates[i].hw_value; |
| 342 |
if (hw >= IWL_FIRST_OFDM_RATE) { |
| 343 |
ofdm |= BIT(hw - IWL_FIRST_OFDM_RATE); |
| 344 |
if (lowest_present_ofdm > hw) |
| 345 |
lowest_present_ofdm = hw; |
| 346 |
} else { |
| 347 |
BUILD_BUG_ON(IWL_FIRST_CCK_RATE != 0); |
| 348 |
|
| 349 |
cck |= BIT(hw); |
| 350 |
if (lowest_present_cck > hw) |
| 351 |
lowest_present_cck = hw; |
| 352 |
} |
| 353 |
} |
| 354 |
|
| 355 |
/* |
| 356 |
* Now we've got the basic rates as bitmaps in the ofdm and cck |
| 357 |
* variables. This isn't sufficient though, as there might not |
| 358 |
* be all the right rates in the bitmap. E.g. if the only basic |
| 359 |
* rates are 5.5 Mbps and 11 Mbps, we still need to add 1 Mbps |
| 360 |
* and 6 Mbps because the 802.11-2007 standard says in 9.6: |
| 361 |
* |
| 362 |
* [...] a STA responding to a received frame shall transmit |
| 363 |
* its Control Response frame [...] at the highest rate in the |
| 364 |
* BSSBasicRateSet parameter that is less than or equal to the |
| 365 |
* rate of the immediately previous frame in the frame exchange |
| 366 |
* sequence ([...]) and that is of the same modulation class |
| 367 |
* ([...]) as the received frame. If no rate contained in the |
| 368 |
* BSSBasicRateSet parameter meets these conditions, then the |
| 369 |
* control frame sent in response to a received frame shall be |
| 370 |
* transmitted at the highest mandatory rate of the PHY that is |
| 371 |
* less than or equal to the rate of the received frame, and |
| 372 |
* that is of the same modulation class as the received frame. |
| 373 |
* |
| 374 |
* As a consequence, we need to add all mandatory rates that are |
| 375 |
* lower than all of the basic rates to these bitmaps. |
| 376 |
*/ |
| 377 |
|
| 378 |
if (IWL_RATE_24M_INDEX < lowest_present_ofdm) |
| 379 |
ofdm |= IWL_RATE_BIT_MSK(24) >> IWL_FIRST_OFDM_RATE; |
| 380 |
if (IWL_RATE_12M_INDEX < lowest_present_ofdm) |
| 381 |
ofdm |= IWL_RATE_BIT_MSK(12) >> IWL_FIRST_OFDM_RATE; |
| 382 |
/* 6M already there or needed so always add */ |
| 383 |
ofdm |= IWL_RATE_BIT_MSK(6) >> IWL_FIRST_OFDM_RATE; |
| 384 |
|
| 385 |
/* |
| 386 |
* CCK is a bit more complex with DSSS vs. HR/DSSS vs. ERP. |
| 387 |
* Note, however: |
| 388 |
* - if no CCK rates are basic, it must be ERP since there must |
| 389 |
* be some basic rates at all, so they're OFDM => ERP PHY |
| 390 |
* (or we're in 5 GHz, and the cck bitmap will never be used) |
| 391 |
* - if 11M is a basic rate, it must be ERP as well, so add 5.5M |
| 392 |
* - if 5.5M is basic, 1M and 2M are mandatory |
| 393 |
* - if 2M is basic, 1M is mandatory |
| 394 |
* - if 1M is basic, that's the only valid ACK rate. |
| 395 |
* As a consequence, it's not as complicated as it sounds, just add |
| 396 |
* any lower rates to the ACK rate bitmap. |
| 397 |
*/ |
| 398 |
if (IWL_RATE_11M_INDEX < lowest_present_cck) |
| 399 |
cck |= IWL_RATE_BIT_MSK(11) >> IWL_FIRST_CCK_RATE; |
| 400 |
if (IWL_RATE_5M_INDEX < lowest_present_cck) |
| 401 |
cck |= IWL_RATE_BIT_MSK(5) >> IWL_FIRST_CCK_RATE; |
| 402 |
if (IWL_RATE_2M_INDEX < lowest_present_cck) |
| 403 |
cck |= IWL_RATE_BIT_MSK(2) >> IWL_FIRST_CCK_RATE; |
| 404 |
/* 1M already there or needed so always add */ |
| 405 |
cck |= IWL_RATE_BIT_MSK(1) >> IWL_FIRST_CCK_RATE; |
| 406 |
|
| 407 |
*cck_rates = cck; |
| 408 |
*ofdm_rates = ofdm; |
| 409 |
} |
| 410 |
|
| 411 |
void iwl_mvm_set_fw_basic_rates(struct iwl_mvm *mvm, struct ieee80211_vif *vif, |
| 412 |
struct iwl_mvm_vif_link_info *link_info, |
| 413 |
__le32 *cck_rates, __le32 *ofdm_rates) |
| 414 |
{ |
| 415 |
struct iwl_mvm_phy_ctxt *phy_ctxt; |
| 416 |
u8 cck_ack_rates = 0, ofdm_ack_rates = 0; |
| 417 |
enum nl80211_band band = NL80211_BAND_2GHZ; |
| 418 |
|
| 419 |
phy_ctxt = link_info->phy_ctxt; |
| 420 |
if (phy_ctxt && phy_ctxt->channel) |
| 421 |
band = phy_ctxt->channel->band; |
| 422 |
|
| 423 |
iwl_mvm_ack_rates(mvm, vif, band, &cck_ack_rates, &ofdm_ack_rates); |
| 424 |
|
| 425 |
*cck_rates = cpu_to_le32((u32)cck_ack_rates); |
| 426 |
*ofdm_rates = cpu_to_le32((u32)ofdm_ack_rates); |
| 427 |
} |
| 428 |
|
| 429 |
void iwl_mvm_set_fw_protection_flags(struct iwl_mvm *mvm, |
| 430 |
struct ieee80211_vif *vif, |
| 431 |
struct ieee80211_bss_conf *link_conf, |
| 432 |
__le32 *protection_flags, u32 ht_flag, |
| 433 |
u32 tgg_flag) |
| 434 |
{ |
| 435 |
/* for both sta and ap, ht_operation_mode hold the protection_mode */ |
| 436 |
u8 protection_mode = link_conf->ht_operation_mode & |
| 437 |
IEEE80211_HT_OP_MODE_PROTECTION; |
| 438 |
bool ht_enabled = !!(link_conf->ht_operation_mode & |
| 439 |
IEEE80211_HT_OP_MODE_PROTECTION); |
| 440 |
|
| 441 |
if (link_conf->use_cts_prot) |
| 442 |
*protection_flags |= cpu_to_le32(tgg_flag); |
| 443 |
|
| 444 |
IWL_DEBUG_RATE(mvm, "use_cts_prot %d, ht_operation_mode %d\n", |
| 445 |
link_conf->use_cts_prot, |
| 446 |
link_conf->ht_operation_mode); |
| 447 |
|
| 448 |
if (!ht_enabled) |
| 449 |
return; |
| 450 |
|
| 451 |
IWL_DEBUG_RATE(mvm, "protection mode set to %d\n", protection_mode); |
| 452 |
/* |
| 453 |
* See section 9.23.3.1 of IEEE 80211-2012. |
| 454 |
* Nongreenfield HT STAs Present is not supported. |
| 455 |
*/ |
| 456 |
switch (protection_mode) { |
| 457 |
case IEEE80211_HT_OP_MODE_PROTECTION_NONE: |
| 458 |
break; |
| 459 |
case IEEE80211_HT_OP_MODE_PROTECTION_NONMEMBER: |
| 460 |
case IEEE80211_HT_OP_MODE_PROTECTION_NONHT_MIXED: |
| 461 |
*protection_flags |= cpu_to_le32(ht_flag); |
| 462 |
break; |
| 463 |
case IEEE80211_HT_OP_MODE_PROTECTION_20MHZ: |
| 464 |
/* Protect when channel wider than 20MHz */ |
| 465 |
if (link_conf->chanreq.oper.width > NL80211_CHAN_WIDTH_20) |
| 466 |
*protection_flags |= cpu_to_le32(ht_flag); |
| 467 |
break; |
| 468 |
default: |
| 469 |
IWL_ERR(mvm, "Illegal protection mode %d\n", |
| 470 |
protection_mode); |
| 471 |
break; |
| 472 |
} |
| 473 |
} |
| 474 |
|
| 475 |
void iwl_mvm_set_fw_qos_params(struct iwl_mvm *mvm, struct ieee80211_vif *vif, |
| 476 |
struct ieee80211_bss_conf *link_conf, |
| 477 |
struct iwl_ac_qos *ac, __le32 *qos_flags) |
| 478 |
{ |
| 479 |
struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); |
| 480 |
struct iwl_mvm_vif_link_info *mvm_link = |
| 481 |
mvmvif->link[link_conf->link_id]; |
| 482 |
int i; |
| 483 |
|
| 484 |
if (!mvm_link) |
| 485 |
return; |
| 486 |
|
| 487 |
for (i = 0; i < IEEE80211_NUM_ACS; i++) { |
| 488 |
u8 txf = iwl_mvm_mac_ac_to_tx_fifo(mvm, i); |
| 489 |
u8 ucode_ac = iwl_mvm_mac80211_ac_to_ucode_ac(i); |
| 490 |
|
| 491 |
ac[ucode_ac].cw_min = |
| 492 |
cpu_to_le16(mvm_link->queue_params[i].cw_min); |
| 493 |
ac[ucode_ac].cw_max = |
| 494 |
cpu_to_le16(mvm_link->queue_params[i].cw_max); |
| 495 |
ac[ucode_ac].edca_txop = |
| 496 |
cpu_to_le16(mvm_link->queue_params[i].txop * 32); |
| 497 |
ac[ucode_ac].aifsn = mvm_link->queue_params[i].aifs; |
| 498 |
ac[ucode_ac].fifos_mask = BIT(txf); |
| 499 |
} |
| 500 |
|
| 501 |
if (link_conf->qos) |
| 502 |
*qos_flags |= cpu_to_le32(MAC_QOS_FLG_UPDATE_EDCA); |
| 503 |
|
| 504 |
if (link_conf->chanreq.oper.width != NL80211_CHAN_WIDTH_20_NOHT) |
| 505 |
*qos_flags |= cpu_to_le32(MAC_QOS_FLG_TGN); |
| 506 |
} |
| 507 |
|
| 508 |
int iwl_mvm_get_mac_type(struct ieee80211_vif *vif) |
| 509 |
{ |
| 510 |
u32 mac_type = FW_MAC_TYPE_BSS_STA; |
| 511 |
|
| 512 |
switch (vif->type) { |
| 513 |
case NL80211_IFTYPE_STATION: |
| 514 |
if (vif->p2p) |
| 515 |
mac_type = FW_MAC_TYPE_P2P_STA; |
| 516 |
else |
| 517 |
mac_type = FW_MAC_TYPE_BSS_STA; |
| 518 |
break; |
| 519 |
case NL80211_IFTYPE_AP: |
| 520 |
mac_type = FW_MAC_TYPE_GO; |
| 521 |
break; |
| 522 |
case NL80211_IFTYPE_MONITOR: |
| 523 |
mac_type = FW_MAC_TYPE_LISTENER; |
| 524 |
break; |
| 525 |
case NL80211_IFTYPE_P2P_DEVICE: |
| 526 |
mac_type = FW_MAC_TYPE_P2P_DEVICE; |
| 527 |
break; |
| 528 |
case NL80211_IFTYPE_ADHOC: |
| 529 |
mac_type = FW_MAC_TYPE_IBSS; |
| 530 |
break; |
| 531 |
default: |
| 532 |
WARN_ON_ONCE(1); |
| 533 |
} |
| 534 |
return mac_type; |
| 535 |
} |
| 536 |
|
| 537 |
static void iwl_mvm_mac_ctxt_cmd_common(struct iwl_mvm *mvm, |
| 538 |
struct ieee80211_vif *vif, |
| 539 |
struct iwl_mac_ctx_cmd *cmd, |
| 540 |
const u8 *bssid_override, |
| 541 |
u32 action) |
| 542 |
{ |
| 543 |
struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); |
| 544 |
const u8 *bssid = bssid_override ?: vif->bss_conf.bssid; |
| 545 |
u32 ht_flag; |
| 546 |
|
| 547 |
cmd->id_and_color = cpu_to_le32(FW_CMD_ID_AND_COLOR(mvmvif->id, |
| 548 |
mvmvif->color)); |
| 549 |
cmd->action = cpu_to_le32(action); |
| 550 |
cmd->mac_type = cpu_to_le32(iwl_mvm_get_mac_type(vif)); |
| 551 |
|
| 552 |
cmd->tsf_id = cpu_to_le32(mvmvif->tsf_id); |
| 553 |
|
| 554 |
memcpy(cmd->node_addr, vif->addr, ETH_ALEN); |
| 555 |
|
| 556 |
if (bssid) |
| 557 |
memcpy(cmd->bssid_addr, bssid, ETH_ALEN); |
| 558 |
else |
| 559 |
eth_broadcast_addr(cmd->bssid_addr); |
| 560 |
|
| 561 |
iwl_mvm_set_fw_basic_rates(mvm, vif, &mvmvif->deflink, &cmd->cck_rates, |
| 562 |
&cmd->ofdm_rates); |
| 563 |
|
| 564 |
cmd->cck_short_preamble = |
| 565 |
cpu_to_le32(vif->bss_conf.use_short_preamble ? |
| 566 |
MAC_FLG_SHORT_PREAMBLE : 0); |
| 567 |
cmd->short_slot = |
| 568 |
cpu_to_le32(vif->bss_conf.use_short_slot ? |
| 569 |
MAC_FLG_SHORT_SLOT : 0); |
| 570 |
|
| 571 |
cmd->filter_flags = 0; |
| 572 |
|
| 573 |
iwl_mvm_set_fw_qos_params(mvm, vif, &vif->bss_conf, cmd->ac, |
| 574 |
&cmd->qos_flags); |
| 575 |
|
| 576 |
/* The fw does not distinguish between ht and fat */ |
| 577 |
ht_flag = MAC_PROT_FLG_HT_PROT | MAC_PROT_FLG_FAT_PROT; |
| 578 |
iwl_mvm_set_fw_protection_flags(mvm, vif, &vif->bss_conf, |
| 579 |
&cmd->protection_flags, |
| 580 |
ht_flag, MAC_PROT_FLG_TGG_PROTECT); |
| 581 |
} |
| 582 |
|
| 583 |
static int iwl_mvm_mac_ctxt_send_cmd(struct iwl_mvm *mvm, |
| 584 |
struct iwl_mac_ctx_cmd *cmd) |
| 585 |
{ |
| 586 |
int ret = iwl_mvm_send_cmd_pdu(mvm, MAC_CONTEXT_CMD, 0, |
| 587 |
sizeof(*cmd), cmd); |
| 588 |
if (ret) |
| 589 |
IWL_ERR(mvm, "Failed to send MAC_CONTEXT_CMD (action:%d): %d\n", |
| 590 |
le32_to_cpu(cmd->action), ret); |
| 591 |
return ret; |
| 592 |
} |
| 593 |
|
| 594 |
void iwl_mvm_set_fw_dtim_tbtt(struct iwl_mvm *mvm, struct ieee80211_vif *vif, |
| 595 |
struct ieee80211_bss_conf *link_conf, |
| 596 |
__le64 *dtim_tsf, __le32 *dtim_time, |
| 597 |
__le32 *assoc_beacon_arrive_time) |
| 598 |
{ |
| 599 |
u32 dtim_offs; |
| 600 |
|
| 601 |
/* |
| 602 |
* The DTIM count counts down, so when it is N that means N |
| 603 |
* more beacon intervals happen until the DTIM TBTT. Therefore |
| 604 |
* add this to the current time. If that ends up being in the |
| 605 |
* future, the firmware will handle it. |
| 606 |
* |
| 607 |
* Also note that the system_timestamp (which we get here as |
| 608 |
* "sync_device_ts") and TSF timestamp aren't at exactly the |
| 609 |
* same offset in the frame -- the TSF is at the first symbol |
| 610 |
* of the TSF, the system timestamp is at signal acquisition |
| 611 |
* time. This means there's an offset between them of at most |
| 612 |
* a few hundred microseconds (24 * 8 bits + PLCP time gives |
| 613 |
* 384us in the longest case), this is currently not relevant |
| 614 |
* as the firmware wakes up around 2ms before the TBTT. |
| 615 |
*/ |
| 616 |
dtim_offs = link_conf->sync_dtim_count * |
| 617 |
link_conf->beacon_int; |
| 618 |
/* convert TU to usecs */ |
| 619 |
dtim_offs *= 1024; |
| 620 |
|
| 621 |
*dtim_tsf = |
| 622 |
cpu_to_le64(link_conf->sync_tsf + dtim_offs); |
| 623 |
*dtim_time = |
| 624 |
cpu_to_le32(link_conf->sync_device_ts + dtim_offs); |
| 625 |
*assoc_beacon_arrive_time = |
| 626 |
cpu_to_le32(link_conf->sync_device_ts); |
| 627 |
|
| 628 |
IWL_DEBUG_INFO(mvm, "DTIM TBTT is 0x%llx/0x%x, offset %d\n", |
| 629 |
le64_to_cpu(*dtim_tsf), |
| 630 |
le32_to_cpu(*dtim_time), |
| 631 |
dtim_offs); |
| 632 |
} |
| 633 |
|
| 634 |
__le32 iwl_mvm_mac_ctxt_cmd_p2p_sta_get_oppps_ctwin(struct iwl_mvm *mvm, |
| 635 |
struct ieee80211_vif *vif) |
| 636 |
{ |
| 637 |
struct ieee80211_p2p_noa_attr *noa = |
| 638 |
&vif->bss_conf.p2p_noa_attr; |
| 639 |
|
| 640 |
return cpu_to_le32(noa->oppps_ctwindow & |
| 641 |
IEEE80211_P2P_OPPPS_CTWINDOW_MASK); |
| 642 |
} |
| 643 |
|
| 644 |
u32 iwl_mvm_mac_ctxt_cmd_sta_get_twt_policy(struct iwl_mvm *mvm, |
| 645 |
struct ieee80211_vif *vif) |
| 646 |
{ |
| 647 |
u32 twt_policy = 0; |
| 648 |
|
| 649 |
if (vif->bss_conf.twt_requester && IWL_MVM_USE_TWT) |
| 650 |
twt_policy |= TWT_SUPPORTED; |
| 651 |
if (vif->bss_conf.twt_protected) |
| 652 |
twt_policy |= PROTECTED_TWT_SUPPORTED; |
| 653 |
if (vif->bss_conf.twt_broadcast) |
| 654 |
twt_policy |= BROADCAST_TWT_SUPPORTED; |
| 655 |
|
| 656 |
return twt_policy; |
| 657 |
} |
| 658 |
|
| 659 |
static int iwl_mvm_mac_ctxt_cmd_sta(struct iwl_mvm *mvm, |
| 660 |
struct ieee80211_vif *vif, |
| 661 |
u32 action, bool force_assoc_off, |
| 662 |
const u8 *bssid_override) |
| 663 |
{ |
| 664 |
struct iwl_mac_ctx_cmd cmd = {}; |
| 665 |
struct iwl_mac_data_sta *ctxt_sta; |
| 666 |
|
| 667 |
WARN_ON(vif->type != NL80211_IFTYPE_STATION); |
| 668 |
|
| 669 |
/* Fill the common data for all mac context types */ |
| 670 |
iwl_mvm_mac_ctxt_cmd_common(mvm, vif, &cmd, bssid_override, action); |
| 671 |
|
| 672 |
/* |
| 673 |
* We always want to hear MCAST frames, if we're not authorized yet, |
| 674 |
* we'll drop them. |
| 675 |
*/ |
| 676 |
cmd.filter_flags |= cpu_to_le32(MAC_FILTER_ACCEPT_GRP); |
| 677 |
|
| 678 |
if (vif->p2p) { |
| 679 |
cmd.p2p_sta.ctwin = |
| 680 |
iwl_mvm_mac_ctxt_cmd_p2p_sta_get_oppps_ctwin(mvm, vif); |
| 681 |
|
| 682 |
ctxt_sta = &cmd.p2p_sta.sta; |
| 683 |
} else { |
| 684 |
ctxt_sta = &cmd.sta; |
| 685 |
} |
| 686 |
|
| 687 |
/* We need the dtim_period to set the MAC as associated */ |
| 688 |
if (vif->cfg.assoc && vif->bss_conf.dtim_period && |
| 689 |
!force_assoc_off) { |
| 690 |
struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); |
| 691 |
|
| 692 |
iwl_mvm_set_fw_dtim_tbtt(mvm, vif, &vif->bss_conf, |
| 693 |
&ctxt_sta->dtim_tsf, |
| 694 |
&ctxt_sta->dtim_time, |
| 695 |
&ctxt_sta->assoc_beacon_arrive_time); |
| 696 |
|
| 697 |
ctxt_sta->is_assoc = cpu_to_le32(1); |
| 698 |
|
| 699 |
if (!mvmvif->authorized && |
| 700 |
fw_has_capa(&mvm->fw->ucode_capa, |
| 701 |
IWL_UCODE_TLV_CAPA_COEX_HIGH_PRIO)) |
| 702 |
ctxt_sta->data_policy |= |
| 703 |
cpu_to_le32(COEX_HIGH_PRIORITY_ENABLE); |
| 704 |
} else { |
| 705 |
ctxt_sta->is_assoc = cpu_to_le32(0); |
| 706 |
|
| 707 |
/* Allow beacons to pass through as long as we are not |
| 708 |
* associated, or we do not have dtim period information. |
| 709 |
*/ |
| 710 |
cmd.filter_flags |= cpu_to_le32(MAC_FILTER_IN_BEACON); |
| 711 |
} |
| 712 |
|
| 713 |
ctxt_sta->bi = cpu_to_le32(vif->bss_conf.beacon_int); |
| 714 |
ctxt_sta->dtim_interval = cpu_to_le32(vif->bss_conf.beacon_int * |
| 715 |
vif->bss_conf.dtim_period); |
| 716 |
|
| 717 |
ctxt_sta->listen_interval = cpu_to_le32(mvm->hw->conf.listen_interval); |
| 718 |
ctxt_sta->assoc_id = cpu_to_le32(vif->cfg.aid); |
| 719 |
|
| 720 |
if (vif->probe_req_reg && vif->cfg.assoc && vif->p2p) |
| 721 |
cmd.filter_flags |= cpu_to_le32(MAC_FILTER_IN_PROBE_REQUEST); |
| 722 |
|
| 723 |
if (vif->bss_conf.he_support && !iwlwifi_mod_params.disable_11ax) { |
| 724 |
cmd.filter_flags |= cpu_to_le32(MAC_FILTER_IN_11AX); |
| 725 |
ctxt_sta->data_policy |= |
| 726 |
cpu_to_le32(iwl_mvm_mac_ctxt_cmd_sta_get_twt_policy(mvm, vif)); |
| 727 |
} |
| 728 |
|
| 729 |
|
| 730 |
return iwl_mvm_mac_ctxt_send_cmd(mvm, &cmd); |
| 731 |
} |
| 732 |
|
| 733 |
static int iwl_mvm_mac_ctxt_cmd_listener(struct iwl_mvm *mvm, |
| 734 |
struct ieee80211_vif *vif, |
| 735 |
u32 action) |
| 736 |
{ |
| 737 |
struct iwl_mac_ctx_cmd cmd = {}; |
| 738 |
u32 tfd_queue_msk = 0; |
| 739 |
int ret; |
| 740 |
|
| 741 |
WARN_ON(vif->type != NL80211_IFTYPE_MONITOR); |
| 742 |
|
| 743 |
iwl_mvm_mac_ctxt_cmd_common(mvm, vif, &cmd, NULL, action); |
| 744 |
|
| 745 |
cmd.filter_flags = cpu_to_le32(MAC_FILTER_IN_PROMISC | |
| 746 |
MAC_FILTER_IN_CONTROL_AND_MGMT | |
| 747 |
MAC_FILTER_IN_BEACON | |
| 748 |
MAC_FILTER_IN_PROBE_REQUEST | |
| 749 |
MAC_FILTER_IN_CRC32 | |
| 750 |
MAC_FILTER_ACCEPT_GRP); |
| 751 |
ieee80211_hw_set(mvm->hw, RX_INCLUDES_FCS); |
| 752 |
|
| 753 |
/* |
| 754 |
* the queue mask is only relevant for old TX API, and |
| 755 |
* mvm->snif_queue isn't set here (it's still set to |
| 756 |
* IWL_MVM_INVALID_QUEUE so the BIT() of it is UB) |
| 757 |
*/ |
| 758 |
if (!iwl_mvm_has_new_tx_api(mvm)) |
| 759 |
tfd_queue_msk = BIT(mvm->snif_queue); |
| 760 |
|
| 761 |
/* Allocate sniffer station */ |
| 762 |
ret = iwl_mvm_allocate_int_sta(mvm, &mvm->snif_sta, tfd_queue_msk, |
| 763 |
vif->type, IWL_STA_GENERAL_PURPOSE); |
| 764 |
if (ret) |
| 765 |
return ret; |
| 766 |
|
| 767 |
return iwl_mvm_mac_ctxt_send_cmd(mvm, &cmd); |
| 768 |
} |
| 769 |
|
| 770 |
static int iwl_mvm_mac_ctxt_cmd_ibss(struct iwl_mvm *mvm, |
| 771 |
struct ieee80211_vif *vif, |
| 772 |
u32 action) |
| 773 |
{ |
| 774 |
struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); |
| 775 |
struct iwl_mac_ctx_cmd cmd = {}; |
| 776 |
|
| 777 |
WARN_ON(vif->type != NL80211_IFTYPE_ADHOC); |
| 778 |
|
| 779 |
iwl_mvm_mac_ctxt_cmd_common(mvm, vif, &cmd, NULL, action); |
| 780 |
|
| 781 |
cmd.filter_flags = cpu_to_le32(MAC_FILTER_IN_BEACON | |
| 782 |
MAC_FILTER_IN_PROBE_REQUEST | |
| 783 |
MAC_FILTER_ACCEPT_GRP); |
| 784 |
|
| 785 |
/* cmd.ibss.beacon_time/cmd.ibss.beacon_tsf are curently ignored */ |
| 786 |
cmd.ibss.bi = cpu_to_le32(vif->bss_conf.beacon_int); |
| 787 |
|
| 788 |
/* TODO: Assumes that the beacon id == mac context id */ |
| 789 |
cmd.ibss.beacon_template = cpu_to_le32(mvmvif->id); |
| 790 |
|
| 791 |
return iwl_mvm_mac_ctxt_send_cmd(mvm, &cmd); |
| 792 |
} |
| 793 |
|
| 794 |
struct iwl_mvm_go_iterator_data { |
| 795 |
bool go_active; |
| 796 |
}; |
| 797 |
|
| 798 |
static void iwl_mvm_go_iterator(void *_data, u8 *mac, struct ieee80211_vif *vif) |
| 799 |
{ |
| 800 |
struct iwl_mvm_go_iterator_data *data = _data; |
| 801 |
struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); |
| 802 |
|
| 803 |
if (vif->type == NL80211_IFTYPE_AP && vif->p2p && |
| 804 |
mvmvif->ap_ibss_active) |
| 805 |
data->go_active = true; |
| 806 |
} |
| 807 |
|
| 808 |
__le32 iwl_mac_ctxt_p2p_dev_has_extended_disc(struct iwl_mvm *mvm, |
| 809 |
struct ieee80211_vif *vif) |
| 810 |
{ |
| 811 |
struct iwl_mvm_go_iterator_data data = {}; |
| 812 |
|
| 813 |
/* |
| 814 |
* This flag should be set to true when the P2P Device is |
| 815 |
* discoverable and there is at least another active P2P GO. Settings |
| 816 |
* this flag will allow the P2P Device to be discoverable on other |
| 817 |
* channels in addition to its listen channel. |
| 818 |
* Note that this flag should not be set in other cases as it opens the |
| 819 |
* Rx filters on all MAC and increases the number of interrupts. |
| 820 |
*/ |
| 821 |
ieee80211_iterate_active_interfaces_atomic( |
| 822 |
mvm->hw, IEEE80211_IFACE_ITER_RESUME_ALL, |
| 823 |
iwl_mvm_go_iterator, &data); |
| 824 |
|
| 825 |
return cpu_to_le32(data.go_active ? 1 : 0); |
| 826 |
} |
| 827 |
|
| 828 |
static int iwl_mvm_mac_ctxt_cmd_p2p_device(struct iwl_mvm *mvm, |
| 829 |
struct ieee80211_vif *vif, |
| 830 |
u32 action) |
| 831 |
{ |
| 832 |
struct iwl_mac_ctx_cmd cmd = {}; |
| 833 |
|
| 834 |
WARN_ON(vif->type != NL80211_IFTYPE_P2P_DEVICE); |
| 835 |
|
| 836 |
iwl_mvm_mac_ctxt_cmd_common(mvm, vif, &cmd, NULL, action); |
| 837 |
|
| 838 |
cmd.p2p_dev.is_disc_extended = |
| 839 |
iwl_mac_ctxt_p2p_dev_has_extended_disc(mvm, vif); |
| 840 |
|
| 841 |
/* Override the filter flags to accept only probe requests */ |
| 842 |
cmd.filter_flags = cpu_to_le32(MAC_FILTER_IN_PROBE_REQUEST); |
| 843 |
|
| 844 |
return iwl_mvm_mac_ctxt_send_cmd(mvm, &cmd); |
| 845 |
} |
| 846 |
|
| 847 |
void iwl_mvm_mac_ctxt_set_tim(struct iwl_mvm *mvm, |
| 848 |
__le32 *tim_index, __le32 *tim_size, |
| 849 |
u8 *beacon, u32 frame_size) |
| 850 |
{ |
| 851 |
u32 tim_idx; |
| 852 |
struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *)beacon; |
| 853 |
|
| 854 |
/* The index is relative to frame start but we start looking at the |
| 855 |
* variable-length part of the beacon. */ |
| 856 |
tim_idx = mgmt->u.beacon.variable - beacon; |
| 857 |
|
| 858 |
/* Parse variable-length elements of beacon to find WLAN_EID_TIM */ |
| 859 |
while ((tim_idx < (frame_size - 2)) && |
| 860 |
(beacon[tim_idx] != WLAN_EID_TIM)) |
| 861 |
tim_idx += beacon[tim_idx+1] + 2; |
| 862 |
|
| 863 |
/* If TIM field was found, set variables */ |
| 864 |
if ((tim_idx < (frame_size - 1)) && (beacon[tim_idx] == WLAN_EID_TIM)) { |
| 865 |
*tim_index = cpu_to_le32(tim_idx); |
| 866 |
*tim_size = cpu_to_le32((u32)beacon[tim_idx + 1]); |
| 867 |
} else { |
| 868 |
IWL_WARN(mvm, "Unable to find TIM Element in beacon\n"); |
| 869 |
} |
| 870 |
} |
| 871 |
|
| 872 |
u8 iwl_mvm_mac_ctxt_get_lowest_rate(struct iwl_mvm *mvm, |
| 873 |
struct ieee80211_tx_info *info, |
| 874 |
struct ieee80211_vif *vif) |
| 875 |
{ |
| 876 |
struct ieee80211_supported_band *sband; |
| 877 |
unsigned long basic = vif->bss_conf.basic_rates; |
| 878 |
u16 lowest_cck = IWL_RATE_COUNT, lowest_ofdm = IWL_RATE_COUNT; |
| 879 |
u32 link_id = u32_get_bits(info->control.flags, |
| 880 |
IEEE80211_TX_CTRL_MLO_LINK); |
| 881 |
u8 band = info->band; |
| 882 |
u8 rate; |
| 883 |
u32 i; |
| 884 |
|
| 885 |
if (link_id < IEEE80211_LINK_UNSPECIFIED) { |
| 886 |
struct ieee80211_bss_conf *link_conf; |
| 887 |
|
| 888 |
rcu_read_lock(); |
| 889 |
link_conf = rcu_dereference(vif->link_conf[link_id]); |
| 890 |
if (link_conf) { |
| 891 |
basic = link_conf->basic_rates; |
| 892 |
if (link_conf->chanreq.oper.chan) |
| 893 |
band = link_conf->chanreq.oper.chan->band; |
| 894 |
} |
| 895 |
rcu_read_unlock(); |
| 896 |
} |
| 897 |
|
| 898 |
sband = mvm->hw->wiphy->bands[band]; |
| 899 |
for_each_set_bit(i, &basic, BITS_PER_LONG) { |
| 900 |
u16 hw = sband->bitrates[i].hw_value; |
| 901 |
|
| 902 |
if (hw >= IWL_FIRST_OFDM_RATE) { |
| 903 |
if (lowest_ofdm > hw) |
| 904 |
lowest_ofdm = hw; |
| 905 |
} else if (lowest_cck > hw) { |
| 906 |
lowest_cck = hw; |
| 907 |
} |
| 908 |
} |
| 909 |
|
| 910 |
if (band == NL80211_BAND_2GHZ && !vif->p2p && |
| 911 |
vif->type != NL80211_IFTYPE_P2P_DEVICE && |
| 912 |
!(info->flags & IEEE80211_TX_CTL_NO_CCK_RATE)) { |
| 913 |
if (lowest_cck != IWL_RATE_COUNT) |
| 914 |
rate = lowest_cck; |
| 915 |
else if (lowest_ofdm != IWL_RATE_COUNT) |
| 916 |
rate = lowest_ofdm; |
| 917 |
else |
| 918 |
rate = IWL_RATE_1M_INDEX; |
| 919 |
} else if (lowest_ofdm != IWL_RATE_COUNT) { |
| 920 |
rate = lowest_ofdm; |
| 921 |
} else { |
| 922 |
rate = IWL_RATE_6M_INDEX; |
| 923 |
} |
| 924 |
|
| 925 |
return rate; |
| 926 |
} |
| 927 |
|
| 928 |
u16 iwl_mvm_mac_ctxt_get_beacon_flags(const struct iwl_fw *fw, u8 rate_idx) |
| 929 |
{ |
| 930 |
bool is_new_rate = iwl_fw_lookup_cmd_ver(fw, BEACON_TEMPLATE_CMD, 0) > 10; |
| 931 |
u16 flags = 0; |
| 932 |
|
| 933 |
if (rate_idx <= IWL_LAST_CCK_RATE) |
| 934 |
flags |= is_new_rate ? IWL_MAC_BEACON_CCK |
| 935 |
: IWL_MAC_BEACON_CCK_V1; |
| 936 |
|
| 937 |
if (iwl_fw_lookup_cmd_ver(fw, TX_CMD, 0) > 8) |
| 938 |
flags |= iwl_mvm_mac80211_idx_to_hwrate(fw, rate_idx); |
| 939 |
else |
| 940 |
flags |= iwl_fw_rate_idx_to_plcp(rate_idx); |
| 941 |
|
| 942 |
return flags; |
| 943 |
} |
| 944 |
|
| 945 |
u8 iwl_mvm_mac_ctxt_get_beacon_rate(struct iwl_mvm *mvm, |
| 946 |
struct ieee80211_tx_info *info, |
| 947 |
struct ieee80211_vif *vif) |
| 948 |
{ |
| 949 |
struct ieee80211_supported_band *sband = |
| 950 |
mvm->hw->wiphy->bands[info->band]; |
| 951 |
u32 legacy = vif->bss_conf.beacon_tx_rate.control[info->band].legacy; |
| 952 |
|
| 953 |
/* if beacon rate was configured try using it */ |
| 954 |
if (hweight32(legacy) == 1) { |
| 955 |
u32 rate = ffs(legacy) - 1; |
| 956 |
|
| 957 |
return sband->bitrates[rate].hw_value; |
| 958 |
} |
| 959 |
|
| 960 |
return iwl_mvm_mac_ctxt_get_lowest_rate(mvm, info, vif); |
| 961 |
} |
| 962 |
|
| 963 |
static void iwl_mvm_mac_ctxt_set_tx(struct iwl_mvm *mvm, |
| 964 |
struct ieee80211_vif *vif, |
| 965 |
struct sk_buff *beacon, |
| 966 |
struct iwl_tx_cmd_v6_params *tx_params) |
| 967 |
{ |
| 968 |
struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); |
| 969 |
struct ieee80211_tx_info *info; |
| 970 |
u32 rate_n_flags = 0; |
| 971 |
u8 rate; |
| 972 |
u32 tx_flags; |
| 973 |
|
| 974 |
info = IEEE80211_SKB_CB(beacon); |
| 975 |
|
| 976 |
/* Set up TX command fields */ |
| 977 |
tx_params->len = cpu_to_le16((u16)beacon->len); |
| 978 |
tx_params->sta_id = mvmvif->deflink.bcast_sta.sta_id; |
| 979 |
tx_params->life_time = cpu_to_le32(TX_CMD_LIFE_TIME_INFINITE); |
| 980 |
tx_flags = TX_CMD_FLG_SEQ_CTL | TX_CMD_FLG_TSF; |
| 981 |
tx_flags |= |
| 982 |
iwl_mvm_bt_coex_tx_prio(mvm, (void *)beacon->data, info, 0) << |
| 983 |
TX_CMD_FLG_BT_PRIO_POS; |
| 984 |
tx_params->tx_flags = cpu_to_le32(tx_flags); |
| 985 |
|
| 986 |
if (!fw_has_capa(&mvm->fw->ucode_capa, |
| 987 |
IWL_UCODE_TLV_CAPA_BEACON_ANT_SELECTION)) { |
| 988 |
iwl_mvm_toggle_tx_ant(mvm, &mvm->mgmt_last_antenna_idx); |
| 989 |
|
| 990 |
rate_n_flags |= BIT(mvm->mgmt_last_antenna_idx) << |
| 991 |
RATE_MCS_ANT_POS; |
| 992 |
} |
| 993 |
|
| 994 |
rate = iwl_mvm_mac_ctxt_get_beacon_rate(mvm, info, vif); |
| 995 |
|
| 996 |
if (rate < IWL_FIRST_OFDM_RATE) |
| 997 |
rate_n_flags |= RATE_MCS_MOD_TYPE_CCK; |
| 998 |
else |
| 999 |
rate_n_flags |= RATE_MCS_MOD_TYPE_LEGACY_OFDM; |
| 1000 |
|
| 1001 |
rate_n_flags |= iwl_mvm_mac80211_idx_to_hwrate(mvm->fw, rate); |
| 1002 |
|
| 1003 |
tx_params->rate_n_flags = iwl_mvm_v3_rate_to_fw(rate_n_flags, |
| 1004 |
mvm->fw_rates_ver); |
| 1005 |
} |
| 1006 |
|
| 1007 |
int iwl_mvm_mac_ctxt_send_beacon_cmd(struct iwl_mvm *mvm, |
| 1008 |
struct sk_buff *beacon, |
| 1009 |
void *data, int len) |
| 1010 |
{ |
| 1011 |
struct iwl_host_cmd cmd = { |
| 1012 |
.id = BEACON_TEMPLATE_CMD, |
| 1013 |
.flags = CMD_ASYNC, |
| 1014 |
}; |
| 1015 |
|
| 1016 |
cmd.len[0] = len; |
| 1017 |
cmd.data[0] = data; |
| 1018 |
cmd.dataflags[0] = 0; |
| 1019 |
cmd.len[1] = beacon->len; |
| 1020 |
cmd.data[1] = beacon->data; |
| 1021 |
cmd.dataflags[1] = IWL_HCMD_DFL_DUP; |
| 1022 |
|
| 1023 |
return iwl_mvm_send_cmd(mvm, &cmd); |
| 1024 |
} |
| 1025 |
|
| 1026 |
static int iwl_mvm_mac_ctxt_send_beacon_v6(struct iwl_mvm *mvm, |
| 1027 |
struct ieee80211_vif *vif, |
| 1028 |
struct sk_buff *beacon) |
| 1029 |
{ |
| 1030 |
struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); |
| 1031 |
struct iwl_mac_beacon_cmd_v6 beacon_cmd = {}; |
| 1032 |
|
| 1033 |
iwl_mvm_mac_ctxt_set_tx(mvm, vif, beacon, &beacon_cmd.tx); |
| 1034 |
|
| 1035 |
beacon_cmd.template_id = cpu_to_le32((u32)mvmvif->id); |
| 1036 |
|
| 1037 |
if (vif->type == NL80211_IFTYPE_AP) |
| 1038 |
iwl_mvm_mac_ctxt_set_tim(mvm, &beacon_cmd.tim_idx, |
| 1039 |
&beacon_cmd.tim_size, |
| 1040 |
beacon->data, beacon->len); |
| 1041 |
|
| 1042 |
return iwl_mvm_mac_ctxt_send_beacon_cmd(mvm, beacon, &beacon_cmd, |
| 1043 |
sizeof(beacon_cmd)); |
| 1044 |
} |
| 1045 |
|
| 1046 |
static int iwl_mvm_mac_ctxt_send_beacon_v7(struct iwl_mvm *mvm, |
| 1047 |
struct ieee80211_vif *vif, |
| 1048 |
struct sk_buff *beacon) |
| 1049 |
{ |
| 1050 |
struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); |
| 1051 |
struct iwl_mac_beacon_cmd_v7 beacon_cmd = {}; |
| 1052 |
|
| 1053 |
iwl_mvm_mac_ctxt_set_tx(mvm, vif, beacon, &beacon_cmd.tx); |
| 1054 |
|
| 1055 |
beacon_cmd.template_id = cpu_to_le32((u32)mvmvif->id); |
| 1056 |
|
| 1057 |
if (vif->type == NL80211_IFTYPE_AP) |
| 1058 |
iwl_mvm_mac_ctxt_set_tim(mvm, &beacon_cmd.tim_idx, |
| 1059 |
&beacon_cmd.tim_size, |
| 1060 |
beacon->data, beacon->len); |
| 1061 |
|
| 1062 |
beacon_cmd.csa_offset = |
| 1063 |
cpu_to_le32(iwl_find_ie_offset(beacon->data, |
| 1064 |
WLAN_EID_CHANNEL_SWITCH, |
| 1065 |
beacon->len)); |
| 1066 |
beacon_cmd.ecsa_offset = |
| 1067 |
cpu_to_le32(iwl_find_ie_offset(beacon->data, |
| 1068 |
WLAN_EID_EXT_CHANSWITCH_ANN, |
| 1069 |
beacon->len)); |
| 1070 |
|
| 1071 |
return iwl_mvm_mac_ctxt_send_beacon_cmd(mvm, beacon, &beacon_cmd, |
| 1072 |
sizeof(beacon_cmd)); |
| 1073 |
} |
| 1074 |
|
| 1075 |
bool iwl_mvm_enable_fils(struct iwl_mvm *mvm, |
| 1076 |
struct ieee80211_vif *vif, |
| 1077 |
struct ieee80211_chanctx_conf *ctx) |
| 1078 |
{ |
| 1079 |
if (vif->type != NL80211_IFTYPE_AP || IWL_MVM_DISABLE_AP_FILS) |
| 1080 |
return false; |
| 1081 |
|
| 1082 |
if (cfg80211_channel_is_psc(ctx->def.chan)) |
| 1083 |
return true; |
| 1084 |
|
| 1085 |
return (ctx->def.chan->band == NL80211_BAND_6GHZ && |
| 1086 |
ctx->def.width >= NL80211_CHAN_WIDTH_80); |
| 1087 |
} |
| 1088 |
|
| 1089 |
static int iwl_mvm_mac_ctxt_send_beacon_v9(struct iwl_mvm *mvm, |
| 1090 |
struct ieee80211_vif *vif, |
| 1091 |
struct sk_buff *beacon, |
| 1092 |
struct ieee80211_bss_conf *link_conf) |
| 1093 |
{ |
| 1094 |
struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); |
| 1095 |
struct ieee80211_tx_info *info = IEEE80211_SKB_CB(beacon); |
| 1096 |
struct iwl_mac_beacon_cmd beacon_cmd = {}; |
| 1097 |
u8 rate = iwl_mvm_mac_ctxt_get_beacon_rate(mvm, info, vif); |
| 1098 |
u16 flags; |
| 1099 |
struct ieee80211_chanctx_conf *ctx; |
| 1100 |
int channel; |
| 1101 |
flags = iwl_mvm_mac_ctxt_get_beacon_flags(mvm->fw, rate); |
| 1102 |
|
| 1103 |
/* Enable FILS on PSC channels only */ |
| 1104 |
rcu_read_lock(); |
| 1105 |
ctx = rcu_dereference(link_conf->chanctx_conf); |
| 1106 |
channel = ieee80211_frequency_to_channel(ctx->def.chan->center_freq); |
| 1107 |
WARN_ON(channel == 0); |
| 1108 |
if (iwl_mvm_enable_fils(mvm, vif, ctx)) { |
| 1109 |
flags |= iwl_fw_lookup_cmd_ver(mvm->fw, BEACON_TEMPLATE_CMD, |
| 1110 |
0) > 10 ? |
| 1111 |
IWL_MAC_BEACON_FILS : |
| 1112 |
IWL_MAC_BEACON_FILS_V1; |
| 1113 |
beacon_cmd.short_ssid = |
| 1114 |
cpu_to_le32(~crc32_le(~0, vif->cfg.ssid, |
| 1115 |
vif->cfg.ssid_len)); |
| 1116 |
} |
| 1117 |
rcu_read_unlock(); |
| 1118 |
|
| 1119 |
beacon_cmd.flags = cpu_to_le16(flags); |
| 1120 |
beacon_cmd.byte_cnt = cpu_to_le16((u16)beacon->len); |
| 1121 |
|
| 1122 |
if (WARN_ON(!mvmvif->link[link_conf->link_id])) |
| 1123 |
return -EINVAL; |
| 1124 |
|
| 1125 |
if (iwl_fw_lookup_cmd_ver(mvm->fw, BEACON_TEMPLATE_CMD, 0) > 12) |
| 1126 |
beacon_cmd.link_id = |
| 1127 |
cpu_to_le32(mvmvif->link[link_conf->link_id]->fw_link_id); |
| 1128 |
else |
| 1129 |
beacon_cmd.link_id = cpu_to_le32((u32)mvmvif->id); |
| 1130 |
|
| 1131 |
if (vif->type == NL80211_IFTYPE_AP) |
| 1132 |
iwl_mvm_mac_ctxt_set_tim(mvm, &beacon_cmd.tim_idx, |
| 1133 |
&beacon_cmd.tim_size, |
| 1134 |
beacon->data, beacon->len); |
| 1135 |
|
| 1136 |
beacon_cmd.csa_offset = |
| 1137 |
cpu_to_le32(iwl_find_ie_offset(beacon->data, |
| 1138 |
WLAN_EID_CHANNEL_SWITCH, |
| 1139 |
beacon->len)); |
| 1140 |
beacon_cmd.ecsa_offset = |
| 1141 |
cpu_to_le32(iwl_find_ie_offset(beacon->data, |
| 1142 |
WLAN_EID_EXT_CHANSWITCH_ANN, |
| 1143 |
beacon->len)); |
| 1144 |
|
| 1145 |
if (vif->type == NL80211_IFTYPE_AP && |
| 1146 |
iwl_fw_lookup_cmd_ver(mvm->fw, BEACON_TEMPLATE_CMD, 0) >= 14) |
| 1147 |
beacon_cmd.btwt_offset = |
| 1148 |
cpu_to_le32(iwl_find_ie_offset(beacon->data, |
| 1149 |
WLAN_EID_S1G_TWT, |
| 1150 |
beacon->len)); |
| 1151 |
|
| 1152 |
return iwl_mvm_mac_ctxt_send_beacon_cmd(mvm, beacon, &beacon_cmd, |
| 1153 |
sizeof(beacon_cmd)); |
| 1154 |
} |
| 1155 |
|
| 1156 |
static int iwl_mvm_mac_ctxt_send_beacon(struct iwl_mvm *mvm, |
| 1157 |
struct ieee80211_vif *vif, |
| 1158 |
struct sk_buff *beacon, |
| 1159 |
struct ieee80211_bss_conf *link_conf) |
| 1160 |
{ |
| 1161 |
if (WARN_ON(!beacon)) |
| 1162 |
return -EINVAL; |
| 1163 |
|
| 1164 |
if (IWL_MVM_NON_TRANSMITTING_AP) |
| 1165 |
return 0; |
| 1166 |
|
| 1167 |
if (!fw_has_capa(&mvm->fw->ucode_capa, |
| 1168 |
IWL_UCODE_TLV_CAPA_CSA_AND_TBTT_OFFLOAD)) |
| 1169 |
return iwl_mvm_mac_ctxt_send_beacon_v6(mvm, vif, beacon); |
| 1170 |
|
| 1171 |
if (fw_has_api(&mvm->fw->ucode_capa, |
| 1172 |
IWL_UCODE_TLV_API_NEW_BEACON_TEMPLATE)) |
| 1173 |
return iwl_mvm_mac_ctxt_send_beacon_v9(mvm, vif, beacon, |
| 1174 |
link_conf); |
| 1175 |
|
| 1176 |
return iwl_mvm_mac_ctxt_send_beacon_v7(mvm, vif, beacon); |
| 1177 |
} |
| 1178 |
|
| 1179 |
/* The beacon template for the AP/GO/IBSS has changed and needs update */ |
| 1180 |
int iwl_mvm_mac_ctxt_beacon_changed(struct iwl_mvm *mvm, |
| 1181 |
struct ieee80211_vif *vif, |
| 1182 |
struct ieee80211_bss_conf *link_conf) |
| 1183 |
{ |
| 1184 |
struct sk_buff *beacon; |
| 1185 |
int ret; |
| 1186 |
|
| 1187 |
WARN_ON(vif->type != NL80211_IFTYPE_AP && |
| 1188 |
vif->type != NL80211_IFTYPE_ADHOC); |
| 1189 |
|
| 1190 |
beacon = ieee80211_beacon_get_template(mvm->hw, vif, NULL, |
| 1191 |
link_conf->link_id); |
| 1192 |
if (!beacon) |
| 1193 |
return -ENOMEM; |
| 1194 |
|
| 1195 |
#ifdef CONFIG_IWLWIFI_DEBUGFS |
| 1196 |
if (mvm->beacon_inject_active) { |
| 1197 |
dev_kfree_skb(beacon); |
| 1198 |
return -EBUSY; |
| 1199 |
} |
| 1200 |
#endif |
| 1201 |
|
| 1202 |
ret = iwl_mvm_mac_ctxt_send_beacon(mvm, vif, beacon, link_conf); |
| 1203 |
dev_kfree_skb(beacon); |
| 1204 |
return ret; |
| 1205 |
} |
| 1206 |
|
| 1207 |
struct iwl_mvm_mac_ap_iterator_data { |
| 1208 |
struct iwl_mvm *mvm; |
| 1209 |
struct ieee80211_vif *vif; |
| 1210 |
u32 beacon_device_ts; |
| 1211 |
u16 beacon_int; |
| 1212 |
}; |
| 1213 |
|
| 1214 |
/* Find the beacon_device_ts and beacon_int for a managed interface */ |
| 1215 |
static void iwl_mvm_mac_ap_iterator(void *_data, u8 *mac, |
| 1216 |
struct ieee80211_vif *vif) |
| 1217 |
{ |
| 1218 |
struct iwl_mvm_mac_ap_iterator_data *data = _data; |
| 1219 |
|
| 1220 |
if (vif->type != NL80211_IFTYPE_STATION || !vif->cfg.assoc) |
| 1221 |
return; |
| 1222 |
|
| 1223 |
/* Station client has higher priority over P2P client*/ |
| 1224 |
if (vif->p2p && data->beacon_device_ts) |
| 1225 |
return; |
| 1226 |
|
| 1227 |
data->beacon_device_ts = vif->bss_conf.sync_device_ts; |
| 1228 |
data->beacon_int = vif->bss_conf.beacon_int; |
| 1229 |
} |
| 1230 |
|
| 1231 |
/* |
| 1232 |
* Fill the filter flags for mac context of type AP or P2P GO. |
| 1233 |
*/ |
| 1234 |
void iwl_mvm_mac_ctxt_cmd_ap_set_filter_flags(struct iwl_mvm *mvm, |
| 1235 |
struct iwl_mvm_vif *mvmvif, |
| 1236 |
__le32 *filter_flags, |
| 1237 |
int accept_probe_req_flag, |
| 1238 |
int accept_beacon_flag) |
| 1239 |
{ |
| 1240 |
/* |
| 1241 |
* in AP mode, pass probe requests and beacons from other APs |
| 1242 |
* (needed for ht protection); when there're no any associated |
| 1243 |
* station don't ask FW to pass beacons to prevent unnecessary |
| 1244 |
* wake-ups. |
| 1245 |
*/ |
| 1246 |
*filter_flags |= cpu_to_le32(accept_probe_req_flag); |
| 1247 |
if (mvmvif->ap_assoc_sta_count || !mvm->drop_bcn_ap_mode) { |
| 1248 |
*filter_flags |= cpu_to_le32(accept_beacon_flag); |
| 1249 |
IWL_DEBUG_HC(mvm, "Asking FW to pass beacons\n"); |
| 1250 |
} else { |
| 1251 |
IWL_DEBUG_HC(mvm, "No need to receive beacons\n"); |
| 1252 |
} |
| 1253 |
} |
| 1254 |
|
| 1255 |
/* |
| 1256 |
* Fill the specific data for mac context of type AP of P2P GO |
| 1257 |
*/ |
| 1258 |
static void iwl_mvm_mac_ctxt_cmd_fill_ap(struct iwl_mvm *mvm, |
| 1259 |
struct ieee80211_vif *vif, |
| 1260 |
struct iwl_mac_ctx_cmd *cmd, |
| 1261 |
struct iwl_mac_data_ap *ctxt_ap, |
| 1262 |
bool add) |
| 1263 |
{ |
| 1264 |
struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); |
| 1265 |
struct iwl_mvm_mac_ap_iterator_data data = { |
| 1266 |
.mvm = mvm, |
| 1267 |
.vif = vif, |
| 1268 |
.beacon_device_ts = 0 |
| 1269 |
}; |
| 1270 |
|
| 1271 |
/* in AP mode, the MCAST FIFO takes the EDCA params from VO */ |
| 1272 |
cmd->ac[IWL_MVM_TX_FIFO_VO].fifos_mask |= BIT(IWL_MVM_TX_FIFO_MCAST); |
| 1273 |
|
| 1274 |
iwl_mvm_mac_ctxt_cmd_ap_set_filter_flags(mvm, mvmvif, |
| 1275 |
&cmd->filter_flags, |
| 1276 |
MAC_FILTER_IN_PROBE_REQUEST, |
| 1277 |
MAC_FILTER_IN_BEACON); |
| 1278 |
|
| 1279 |
ctxt_ap->bi = cpu_to_le32(vif->bss_conf.beacon_int); |
| 1280 |
ctxt_ap->dtim_interval = cpu_to_le32(vif->bss_conf.beacon_int * |
| 1281 |
vif->bss_conf.dtim_period); |
| 1282 |
|
| 1283 |
if (!fw_has_api(&mvm->fw->ucode_capa, |
| 1284 |
IWL_UCODE_TLV_API_STA_TYPE)) |
| 1285 |
ctxt_ap->mcast_qid = cpu_to_le32(mvmvif->deflink.cab_queue); |
| 1286 |
|
| 1287 |
/* |
| 1288 |
* Only set the beacon time when the MAC is being added, when we |
| 1289 |
* just modify the MAC then we should keep the time -- the firmware |
| 1290 |
* can otherwise have a "jumping" TBTT. |
| 1291 |
*/ |
| 1292 |
if (add) { |
| 1293 |
/* |
| 1294 |
* If there is a station/P2P client interface which is |
| 1295 |
* associated, set the AP's TBTT far enough from the station's |
| 1296 |
* TBTT. Otherwise, set it to the current system time |
| 1297 |
*/ |
| 1298 |
ieee80211_iterate_active_interfaces_atomic( |
| 1299 |
mvm->hw, IEEE80211_IFACE_ITER_RESUME_ALL, |
| 1300 |
iwl_mvm_mac_ap_iterator, &data); |
| 1301 |
|
| 1302 |
if (data.beacon_device_ts) { |
| 1303 |
u32 rand = get_random_u32_inclusive(36, 63); |
| 1304 |
mvmvif->ap_beacon_time = data.beacon_device_ts + |
| 1305 |
ieee80211_tu_to_usec(data.beacon_int * rand / |
| 1306 |
100); |
| 1307 |
} else { |
| 1308 |
mvmvif->ap_beacon_time = iwl_mvm_get_systime(mvm); |
| 1309 |
} |
| 1310 |
} |
| 1311 |
|
| 1312 |
ctxt_ap->beacon_time = cpu_to_le32(mvmvif->ap_beacon_time); |
| 1313 |
ctxt_ap->beacon_tsf = 0; /* unused */ |
| 1314 |
|
| 1315 |
/* TODO: Assume that the beacon id == mac context id */ |
| 1316 |
ctxt_ap->beacon_template = cpu_to_le32(mvmvif->id); |
| 1317 |
} |
| 1318 |
|
| 1319 |
static int iwl_mvm_mac_ctxt_cmd_ap(struct iwl_mvm *mvm, |
| 1320 |
struct ieee80211_vif *vif, |
| 1321 |
u32 action) |
| 1322 |
{ |
| 1323 |
struct iwl_mac_ctx_cmd cmd = {}; |
| 1324 |
|
| 1325 |
WARN_ON(vif->type != NL80211_IFTYPE_AP || vif->p2p); |
| 1326 |
|
| 1327 |
/* Fill the common data for all mac context types */ |
| 1328 |
iwl_mvm_mac_ctxt_cmd_common(mvm, vif, &cmd, NULL, action); |
| 1329 |
|
| 1330 |
/* Fill the data specific for ap mode */ |
| 1331 |
iwl_mvm_mac_ctxt_cmd_fill_ap(mvm, vif, &cmd, &cmd.ap, |
| 1332 |
action == FW_CTXT_ACTION_ADD); |
| 1333 |
|
| 1334 |
return iwl_mvm_mac_ctxt_send_cmd(mvm, &cmd); |
| 1335 |
} |
| 1336 |
|
| 1337 |
static int iwl_mvm_mac_ctxt_cmd_go(struct iwl_mvm *mvm, |
| 1338 |
struct ieee80211_vif *vif, |
| 1339 |
u32 action) |
| 1340 |
{ |
| 1341 |
struct iwl_mac_ctx_cmd cmd = {}; |
| 1342 |
struct ieee80211_p2p_noa_attr *noa = &vif->bss_conf.p2p_noa_attr; |
| 1343 |
|
| 1344 |
WARN_ON(vif->type != NL80211_IFTYPE_AP || !vif->p2p); |
| 1345 |
|
| 1346 |
/* Fill the common data for all mac context types */ |
| 1347 |
iwl_mvm_mac_ctxt_cmd_common(mvm, vif, &cmd, NULL, action); |
| 1348 |
|
| 1349 |
/* Fill the data specific for GO mode */ |
| 1350 |
iwl_mvm_mac_ctxt_cmd_fill_ap(mvm, vif, &cmd, &cmd.go.ap, |
| 1351 |
action == FW_CTXT_ACTION_ADD); |
| 1352 |
|
| 1353 |
cmd.go.ctwin = cpu_to_le32(noa->oppps_ctwindow & |
| 1354 |
IEEE80211_P2P_OPPPS_CTWINDOW_MASK); |
| 1355 |
cmd.go.opp_ps_enabled = |
| 1356 |
cpu_to_le32(!!(noa->oppps_ctwindow & |
| 1357 |
IEEE80211_P2P_OPPPS_ENABLE_BIT)); |
| 1358 |
|
| 1359 |
return iwl_mvm_mac_ctxt_send_cmd(mvm, &cmd); |
| 1360 |
} |
| 1361 |
|
| 1362 |
static int iwl_mvm_mac_ctx_send(struct iwl_mvm *mvm, struct ieee80211_vif *vif, |
| 1363 |
u32 action, bool force_assoc_off, |
| 1364 |
const u8 *bssid_override) |
| 1365 |
{ |
| 1366 |
switch (vif->type) { |
| 1367 |
case NL80211_IFTYPE_STATION: |
| 1368 |
return iwl_mvm_mac_ctxt_cmd_sta(mvm, vif, action, |
| 1369 |
force_assoc_off, |
| 1370 |
bssid_override); |
| 1371 |
case NL80211_IFTYPE_AP: |
| 1372 |
if (!vif->p2p) |
| 1373 |
return iwl_mvm_mac_ctxt_cmd_ap(mvm, vif, action); |
| 1374 |
else |
| 1375 |
return iwl_mvm_mac_ctxt_cmd_go(mvm, vif, action); |
| 1376 |
case NL80211_IFTYPE_MONITOR: |
| 1377 |
return iwl_mvm_mac_ctxt_cmd_listener(mvm, vif, action); |
| 1378 |
case NL80211_IFTYPE_P2P_DEVICE: |
| 1379 |
return iwl_mvm_mac_ctxt_cmd_p2p_device(mvm, vif, action); |
| 1380 |
case NL80211_IFTYPE_ADHOC: |
| 1381 |
return iwl_mvm_mac_ctxt_cmd_ibss(mvm, vif, action); |
| 1382 |
default: |
| 1383 |
break; |
| 1384 |
} |
| 1385 |
|
| 1386 |
return -EOPNOTSUPP; |
| 1387 |
} |
| 1388 |
|
| 1389 |
int iwl_mvm_mac_ctxt_add(struct iwl_mvm *mvm, struct ieee80211_vif *vif) |
| 1390 |
{ |
| 1391 |
struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); |
| 1392 |
int ret; |
| 1393 |
|
| 1394 |
if (WARN_ONCE(mvmvif->uploaded, "Adding active MAC %pM/%d\n", |
| 1395 |
vif->addr, ieee80211_vif_type_p2p(vif))) |
| 1396 |
return -EIO; |
| 1397 |
|
| 1398 |
ret = iwl_mvm_mac_ctx_send(mvm, vif, FW_CTXT_ACTION_ADD, |
| 1399 |
true, NULL); |
| 1400 |
if (ret) |
| 1401 |
return ret; |
| 1402 |
|
| 1403 |
/* will only do anything at resume from D3 time */ |
| 1404 |
iwl_mvm_set_last_nonqos_seq(mvm, vif); |
| 1405 |
|
| 1406 |
mvmvif->uploaded = true; |
| 1407 |
return 0; |
| 1408 |
} |
| 1409 |
|
| 1410 |
int iwl_mvm_mac_ctxt_changed(struct iwl_mvm *mvm, struct ieee80211_vif *vif, |
| 1411 |
bool force_assoc_off, const u8 *bssid_override) |
| 1412 |
{ |
| 1413 |
struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); |
| 1414 |
|
| 1415 |
if (WARN_ONCE(!mvmvif->uploaded, "Changing inactive MAC %pM/%d\n", |
| 1416 |
vif->addr, ieee80211_vif_type_p2p(vif))) |
| 1417 |
return -EIO; |
| 1418 |
|
| 1419 |
return iwl_mvm_mac_ctx_send(mvm, vif, FW_CTXT_ACTION_MODIFY, |
| 1420 |
force_assoc_off, bssid_override); |
| 1421 |
} |
| 1422 |
|
| 1423 |
int iwl_mvm_mac_ctxt_remove(struct iwl_mvm *mvm, struct ieee80211_vif *vif) |
| 1424 |
{ |
| 1425 |
struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); |
| 1426 |
struct iwl_mac_ctx_cmd cmd; |
| 1427 |
int ret; |
| 1428 |
|
| 1429 |
if (WARN_ONCE(!mvmvif->uploaded, "Removing inactive MAC %pM/%d\n", |
| 1430 |
vif->addr, ieee80211_vif_type_p2p(vif))) |
| 1431 |
return -EIO; |
| 1432 |
|
| 1433 |
memset(&cmd, 0, sizeof(cmd)); |
| 1434 |
|
| 1435 |
cmd.id_and_color = cpu_to_le32(FW_CMD_ID_AND_COLOR(mvmvif->id, |
| 1436 |
mvmvif->color)); |
| 1437 |
cmd.action = cpu_to_le32(FW_CTXT_ACTION_REMOVE); |
| 1438 |
|
| 1439 |
ret = iwl_mvm_mac_ctxt_send_cmd(mvm, &cmd); |
| 1440 |
if (ret) |
| 1441 |
return ret; |
| 1442 |
|
| 1443 |
mvmvif->uploaded = false; |
| 1444 |
|
| 1445 |
if (vif->type == NL80211_IFTYPE_MONITOR) { |
| 1446 |
__clear_bit(IEEE80211_HW_RX_INCLUDES_FCS, mvm->hw->flags); |
| 1447 |
iwl_mvm_dealloc_snif_sta(mvm); |
| 1448 |
} |
| 1449 |
|
| 1450 |
return 0; |
| 1451 |
} |
| 1452 |
|
| 1453 |
static void iwl_mvm_csa_count_down(struct iwl_mvm *mvm, |
| 1454 |
struct ieee80211_vif *csa_vif, u32 gp2, |
| 1455 |
bool tx_success) |
| 1456 |
{ |
| 1457 |
struct iwl_mvm_vif *mvmvif = |
| 1458 |
iwl_mvm_vif_from_mac80211(csa_vif); |
| 1459 |
|
| 1460 |
/* Don't start to countdown from a failed beacon */ |
| 1461 |
if (!tx_success && !mvmvif->csa_countdown) |
| 1462 |
return; |
| 1463 |
|
| 1464 |
mvmvif->csa_countdown = true; |
| 1465 |
|
| 1466 |
if (!ieee80211_beacon_cntdwn_is_complete(csa_vif, 0)) { |
| 1467 |
int c = ieee80211_beacon_update_cntdwn(csa_vif, 0); |
| 1468 |
|
| 1469 |
iwl_mvm_mac_ctxt_beacon_changed(mvm, csa_vif, |
| 1470 |
&csa_vif->bss_conf); |
| 1471 |
if (csa_vif->p2p && |
| 1472 |
!iwl_mvm_te_scheduled(&mvmvif->time_event_data) && gp2 && |
| 1473 |
tx_success) { |
| 1474 |
u32 rel_time = (c + 1) * |
| 1475 |
csa_vif->bss_conf.beacon_int - |
| 1476 |
IWL_MVM_CHANNEL_SWITCH_TIME_GO; |
| 1477 |
u32 apply_time = gp2 + rel_time * 1024; |
| 1478 |
|
| 1479 |
iwl_mvm_schedule_csa_period(mvm, csa_vif, |
| 1480 |
IWL_MVM_CHANNEL_SWITCH_TIME_GO - |
| 1481 |
IWL_MVM_CHANNEL_SWITCH_MARGIN, |
| 1482 |
apply_time); |
| 1483 |
} |
| 1484 |
} else if (!iwl_mvm_te_scheduled(&mvmvif->time_event_data)) { |
| 1485 |
/* we don't have CSA NoA scheduled yet, switch now */ |
| 1486 |
ieee80211_csa_finish(csa_vif, 0); |
| 1487 |
RCU_INIT_POINTER(mvm->csa_vif, NULL); |
| 1488 |
} |
| 1489 |
} |
| 1490 |
|
| 1491 |
void iwl_mvm_rx_beacon_notif(struct iwl_mvm *mvm, |
| 1492 |
struct iwl_rx_cmd_buffer *rxb) |
| 1493 |
{ |
| 1494 |
struct iwl_rx_packet *pkt = rxb_addr(rxb); |
| 1495 |
unsigned int pkt_len = iwl_rx_packet_payload_len(pkt); |
| 1496 |
struct iwl_extended_beacon_notif *beacon = (void *)pkt->data; |
| 1497 |
struct iwl_extended_beacon_notif_v5 *beacon_v5 = (void *)pkt->data; |
| 1498 |
struct ieee80211_vif *csa_vif; |
| 1499 |
struct ieee80211_vif *tx_blocked_vif; |
| 1500 |
struct agg_tx_status *agg_status; |
| 1501 |
u16 status; |
| 1502 |
|
| 1503 |
lockdep_assert_held(&mvm->mutex); |
| 1504 |
|
| 1505 |
mvm->ap_last_beacon_gp2 = le32_to_cpu(beacon->gp2); |
| 1506 |
|
| 1507 |
if (!iwl_mvm_is_short_beacon_notif_supported(mvm)) { |
| 1508 |
struct iwl_tx_resp *beacon_notify_hdr = |
| 1509 |
&beacon_v5->beacon_notify_hdr; |
| 1510 |
|
| 1511 |
if (unlikely(pkt_len < sizeof(*beacon_v5))) |
| 1512 |
return; |
| 1513 |
|
| 1514 |
mvm->ibss_manager = beacon_v5->ibss_mgr_status != 0; |
| 1515 |
agg_status = iwl_mvm_get_agg_status(mvm, beacon_notify_hdr); |
| 1516 |
status = le16_to_cpu(agg_status->status) & TX_STATUS_MSK; |
| 1517 |
IWL_DEBUG_RX(mvm, |
| 1518 |
"beacon status %#x retries:%d tsf:0x%016llX gp2:0x%X rate:%d\n", |
| 1519 |
status, beacon_notify_hdr->failure_frame, |
| 1520 |
le64_to_cpu(beacon->tsf), |
| 1521 |
mvm->ap_last_beacon_gp2, |
| 1522 |
le32_to_cpu(beacon_notify_hdr->initial_rate)); |
| 1523 |
} else { |
| 1524 |
if (unlikely(pkt_len < sizeof(*beacon))) |
| 1525 |
return; |
| 1526 |
|
| 1527 |
mvm->ibss_manager = beacon->ibss_mgr_status != 0; |
| 1528 |
status = le32_to_cpu(beacon->status) & TX_STATUS_MSK; |
| 1529 |
IWL_DEBUG_RX(mvm, |
| 1530 |
"beacon status %#x tsf:0x%016llX gp2:0x%X\n", |
| 1531 |
status, le64_to_cpu(beacon->tsf), |
| 1532 |
mvm->ap_last_beacon_gp2); |
| 1533 |
} |
| 1534 |
|
| 1535 |
csa_vif = rcu_dereference_protected(mvm->csa_vif, |
| 1536 |
lockdep_is_held(&mvm->mutex)); |
| 1537 |
if (unlikely(csa_vif && csa_vif->bss_conf.csa_active)) |
| 1538 |
iwl_mvm_csa_count_down(mvm, csa_vif, mvm->ap_last_beacon_gp2, |
| 1539 |
(status == TX_STATUS_SUCCESS)); |
| 1540 |
|
| 1541 |
tx_blocked_vif = rcu_dereference_protected(mvm->csa_tx_blocked_vif, |
| 1542 |
lockdep_is_held(&mvm->mutex)); |
| 1543 |
if (unlikely(tx_blocked_vif)) { |
| 1544 |
struct iwl_mvm_vif *mvmvif = |
| 1545 |
iwl_mvm_vif_from_mac80211(tx_blocked_vif); |
| 1546 |
|
| 1547 |
/* |
| 1548 |
* The channel switch is started and we have blocked the |
| 1549 |
* stations. If this is the first beacon (the timeout wasn't |
| 1550 |
* set), set the unblock timeout, otherwise countdown |
| 1551 |
*/ |
| 1552 |
if (!mvm->csa_tx_block_bcn_timeout) |
| 1553 |
mvm->csa_tx_block_bcn_timeout = |
| 1554 |
IWL_MVM_CS_UNBLOCK_TX_TIMEOUT; |
| 1555 |
else |
| 1556 |
mvm->csa_tx_block_bcn_timeout--; |
| 1557 |
|
| 1558 |
/* Check if the timeout is expired, and unblock tx */ |
| 1559 |
if (mvm->csa_tx_block_bcn_timeout == 0) { |
| 1560 |
iwl_mvm_modify_all_sta_disable_tx(mvm, mvmvif, false); |
| 1561 |
RCU_INIT_POINTER(mvm->csa_tx_blocked_vif, NULL); |
| 1562 |
} |
| 1563 |
} |
| 1564 |
} |
| 1565 |
|
| 1566 |
static void |
| 1567 |
iwl_mvm_handle_missed_beacons_notif(struct iwl_mvm *mvm, |
| 1568 |
const struct iwl_missed_beacons_notif *mb, |
| 1569 |
struct iwl_rx_packet *pkt) |
| 1570 |
{ |
| 1571 |
struct iwl_fw_dbg_trigger_missed_bcon *bcon_trig; |
| 1572 |
struct iwl_fw_dbg_trigger_tlv *trigger; |
| 1573 |
u32 stop_trig_missed_bcon, stop_trig_missed_bcon_since_rx; |
| 1574 |
u32 rx_missed_bcon, rx_missed_bcon_since_rx; |
| 1575 |
struct ieee80211_vif *vif; |
| 1576 |
/* Id can be mac/link id depending on the notification version */ |
| 1577 |
u32 id = le32_to_cpu(mb->link_id); |
| 1578 |
union iwl_dbg_tlv_tp_data tp_data = { .fw_pkt = pkt }; |
| 1579 |
u32 mac_type; |
| 1580 |
u8 notif_ver = iwl_fw_lookup_notif_ver(mvm->fw, LEGACY_GROUP, |
| 1581 |
MISSED_BEACONS_NOTIFICATION, |
| 1582 |
0); |
| 1583 |
u8 new_notif_ver = iwl_fw_lookup_notif_ver(mvm->fw, MAC_CONF_GROUP, |
| 1584 |
MISSED_BEACONS_NOTIF, 0); |
| 1585 |
|
| 1586 |
/* If the firmware uses the new notification (from MAC_CONF_GROUP), |
| 1587 |
* refer to that notification's version. |
| 1588 |
* Note that the new notification from MAC_CONF_GROUP starts from |
| 1589 |
* version 5. |
| 1590 |
*/ |
| 1591 |
if (new_notif_ver) |
| 1592 |
notif_ver = new_notif_ver; |
| 1593 |
|
| 1594 |
IWL_DEBUG_INFO(mvm, |
| 1595 |
"missed bcn %s_id=%u, consecutive=%u (%u)\n", |
| 1596 |
notif_ver < 4 ? "mac" : "link", |
| 1597 |
id, |
| 1598 |
le32_to_cpu(mb->consec_missed_beacons), |
| 1599 |
le32_to_cpu(mb->consec_missed_beacons_since_last_rx)); |
| 1600 |
|
| 1601 |
/* |
| 1602 |
* starting from version 4 the ID is link ID, but driver |
| 1603 |
* uses link ID == MAC ID, so always treat as MAC ID |
| 1604 |
*/ |
| 1605 |
vif = iwl_mvm_rcu_dereference_vif_id(mvm, id, false); |
| 1606 |
if (!vif) |
| 1607 |
return; |
| 1608 |
|
| 1609 |
mac_type = iwl_mvm_get_mac_type(vif); |
| 1610 |
|
| 1611 |
IWL_DEBUG_INFO(mvm, "missed beacon mac_type=%u,\n", mac_type); |
| 1612 |
|
| 1613 |
rx_missed_bcon = le32_to_cpu(mb->consec_missed_beacons); |
| 1614 |
rx_missed_bcon_since_rx = |
| 1615 |
le32_to_cpu(mb->consec_missed_beacons_since_last_rx); |
| 1616 |
/* |
| 1617 |
* TODO: the threshold should be adjusted based on latency conditions, |
| 1618 |
* and/or in case of a CS flow on one of the other AP vifs. |
| 1619 |
*/ |
| 1620 |
if (rx_missed_bcon >= IWL_MVM_MISSED_BEACONS_THRESHOLD_LONG) { |
| 1621 |
if (rx_missed_bcon_since_rx >= IWL_MVM_MISSED_BEACONS_SINCE_RX_THOLD) { |
| 1622 |
iwl_mvm_connection_loss(mvm, vif, "missed beacons"); |
| 1623 |
} else { |
| 1624 |
IWL_WARN(mvm, |
| 1625 |
"missed beacons exceeds threshold, but receiving data. Stay connected, Expect bugs.\n"); |
| 1626 |
IWL_WARN(mvm, |
| 1627 |
"missed_beacons:%d, missed_beacons_since_rx:%d\n", |
| 1628 |
rx_missed_bcon, rx_missed_bcon_since_rx); |
| 1629 |
} |
| 1630 |
} else if (rx_missed_bcon_since_rx > IWL_MVM_MISSED_BEACONS_THRESHOLD) { |
| 1631 |
if (!iwl_mvm_has_new_tx_api(mvm)) |
| 1632 |
ieee80211_beacon_loss(vif); |
| 1633 |
else |
| 1634 |
ieee80211_cqm_beacon_loss_notify(vif, GFP_ATOMIC); |
| 1635 |
} |
| 1636 |
|
| 1637 |
iwl_dbg_tlv_time_point(&mvm->fwrt, |
| 1638 |
IWL_FW_INI_TIME_POINT_MISSED_BEACONS, &tp_data); |
| 1639 |
|
| 1640 |
trigger = iwl_fw_dbg_trigger_on(&mvm->fwrt, ieee80211_vif_to_wdev(vif), |
| 1641 |
FW_DBG_TRIGGER_MISSED_BEACONS); |
| 1642 |
if (!trigger) |
| 1643 |
return; |
| 1644 |
|
| 1645 |
bcon_trig = (void *)trigger->data; |
| 1646 |
stop_trig_missed_bcon = le32_to_cpu(bcon_trig->stop_consec_missed_bcon); |
| 1647 |
stop_trig_missed_bcon_since_rx = |
| 1648 |
le32_to_cpu(bcon_trig->stop_consec_missed_bcon_since_rx); |
| 1649 |
|
| 1650 |
/* TODO: implement start trigger */ |
| 1651 |
|
| 1652 |
if (rx_missed_bcon_since_rx >= stop_trig_missed_bcon_since_rx || |
| 1653 |
rx_missed_bcon >= stop_trig_missed_bcon) |
| 1654 |
iwl_fw_dbg_collect_trig(&mvm->fwrt, trigger, NULL); |
| 1655 |
} |
| 1656 |
|
| 1657 |
void iwl_mvm_rx_missed_beacons_notif(struct iwl_mvm *mvm, |
| 1658 |
struct iwl_rx_cmd_buffer *rxb) |
| 1659 |
{ |
| 1660 |
struct iwl_rx_packet *pkt = rxb_addr(rxb); |
| 1661 |
|
| 1662 |
iwl_mvm_handle_missed_beacons_notif(mvm, (const void *)pkt->data, pkt); |
| 1663 |
} |
| 1664 |
|
| 1665 |
void iwl_mvm_rx_missed_beacons_notif_legacy(struct iwl_mvm *mvm, |
| 1666 |
struct iwl_rx_cmd_buffer *rxb) |
| 1667 |
{ |
| 1668 |
struct iwl_rx_packet *pkt = rxb_addr(rxb); |
| 1669 |
const struct iwl_missed_beacons_notif_v4 *mb_v4 = |
| 1670 |
(const void *)pkt->data; |
| 1671 |
struct iwl_missed_beacons_notif mb = { |
| 1672 |
.link_id = mb_v4->link_id, |
| 1673 |
.consec_missed_beacons = mb_v4->consec_missed_beacons, |
| 1674 |
.consec_missed_beacons_since_last_rx = |
| 1675 |
mb_v4->consec_missed_beacons_since_last_rx, |
| 1676 |
.other_link_id = cpu_to_le32(IWL_MVM_FW_LINK_ID_INVALID), |
| 1677 |
}; |
| 1678 |
|
| 1679 |
iwl_mvm_handle_missed_beacons_notif(mvm, &mb, pkt); |
| 1680 |
} |
| 1681 |
|
| 1682 |
void iwl_mvm_rx_stored_beacon_notif(struct iwl_mvm *mvm, |
| 1683 |
struct iwl_rx_cmd_buffer *rxb) |
| 1684 |
{ |
| 1685 |
struct iwl_rx_packet *pkt = rxb_addr(rxb); |
| 1686 |
unsigned int pkt_len = iwl_rx_packet_payload_len(pkt); |
| 1687 |
struct iwl_stored_beacon_notif_common *sb = (void *)pkt->data; |
| 1688 |
struct ieee80211_rx_status rx_status; |
| 1689 |
struct sk_buff *skb; |
| 1690 |
u8 *data; |
| 1691 |
u32 size = le32_to_cpu(sb->byte_count); |
| 1692 |
int ver = iwl_fw_lookup_cmd_ver(mvm->fw, |
| 1693 |
WIDE_ID(PROT_OFFLOAD_GROUP, STORED_BEACON_NTF), |
| 1694 |
0); |
| 1695 |
|
| 1696 |
if (size == 0) |
| 1697 |
return; |
| 1698 |
|
| 1699 |
/* handle per-version differences */ |
| 1700 |
if (ver <= 2) { |
| 1701 |
struct iwl_stored_beacon_notif_v2 *sb_v2 = (void *)pkt->data; |
| 1702 |
|
| 1703 |
if (pkt_len < struct_size(sb_v2, data, size)) |
| 1704 |
return; |
| 1705 |
|
| 1706 |
data = sb_v2->data; |
| 1707 |
} else { |
| 1708 |
struct iwl_stored_beacon_notif *sb_v3 = (void *)pkt->data; |
| 1709 |
|
| 1710 |
if (pkt_len < struct_size(sb_v3, data, size)) |
| 1711 |
return; |
| 1712 |
|
| 1713 |
data = sb_v3->data; |
| 1714 |
} |
| 1715 |
|
| 1716 |
skb = alloc_skb(size, GFP_ATOMIC); |
| 1717 |
if (!skb) { |
| 1718 |
IWL_ERR(mvm, "alloc_skb failed\n"); |
| 1719 |
return; |
| 1720 |
} |
| 1721 |
|
| 1722 |
/* update rx_status according to the notification's metadata */ |
| 1723 |
memset(&rx_status, 0, sizeof(rx_status)); |
| 1724 |
rx_status.mactime = le64_to_cpu(sb->tsf); |
| 1725 |
/* TSF as indicated by the firmware is at INA time */ |
| 1726 |
rx_status.flag |= RX_FLAG_MACTIME_PLCP_START; |
| 1727 |
rx_status.device_timestamp = le32_to_cpu(sb->system_time); |
| 1728 |
rx_status.band = |
| 1729 |
(sb->band & cpu_to_le16(RX_RES_PHY_FLAGS_BAND_24)) ? |
| 1730 |
NL80211_BAND_2GHZ : NL80211_BAND_5GHZ; |
| 1731 |
rx_status.freq = |
| 1732 |
ieee80211_channel_to_frequency(le16_to_cpu(sb->channel), |
| 1733 |
rx_status.band); |
| 1734 |
|
| 1735 |
/* copy the data */ |
| 1736 |
skb_put_data(skb, data, size); |
| 1737 |
memcpy(IEEE80211_SKB_RXCB(skb), &rx_status, sizeof(rx_status)); |
| 1738 |
|
| 1739 |
/* pass it as regular rx to mac80211 */ |
| 1740 |
ieee80211_rx_napi(mvm->hw, NULL, skb, NULL); |
| 1741 |
} |
| 1742 |
|
| 1743 |
void iwl_mvm_probe_resp_data_notif(struct iwl_mvm *mvm, |
| 1744 |
struct iwl_rx_cmd_buffer *rxb) |
| 1745 |
{ |
| 1746 |
struct iwl_rx_packet *pkt = rxb_addr(rxb); |
| 1747 |
struct iwl_probe_resp_data_notif *notif = (void *)pkt->data; |
| 1748 |
struct iwl_probe_resp_data *old_data, *new_data; |
| 1749 |
u32 id = le32_to_cpu(notif->mac_id); |
| 1750 |
struct ieee80211_vif *vif; |
| 1751 |
struct iwl_mvm_vif *mvmvif; |
| 1752 |
|
| 1753 |
IWL_DEBUG_INFO(mvm, "Probe response data notif: noa %d, csa %d\n", |
| 1754 |
notif->noa_active, notif->csa_counter); |
| 1755 |
|
| 1756 |
vif = iwl_mvm_rcu_dereference_vif_id(mvm, id, false); |
| 1757 |
if (!vif) |
| 1758 |
return; |
| 1759 |
|
| 1760 |
mvmvif = iwl_mvm_vif_from_mac80211(vif); |
| 1761 |
|
| 1762 |
/* |
| 1763 |
* len_low should be 2 + n*13 (where n is the number of descriptors. |
| 1764 |
* 13 is the size of a NoA descriptor). We can have either one or two |
| 1765 |
* descriptors. |
| 1766 |
*/ |
| 1767 |
if (IWL_FW_CHECK(mvm, notif->noa_active && |
| 1768 |
notif->noa_attr.len_low != 2 + |
| 1769 |
sizeof(struct ieee80211_p2p_noa_desc) && |
| 1770 |
notif->noa_attr.len_low != 2 + |
| 1771 |
sizeof(struct ieee80211_p2p_noa_desc) * 2, |
| 1772 |
"Invalid noa_attr.len_low (%d)\n", |
| 1773 |
notif->noa_attr.len_low)) |
| 1774 |
return; |
| 1775 |
|
| 1776 |
new_data = kzalloc_obj(*new_data); |
| 1777 |
if (!new_data) |
| 1778 |
return; |
| 1779 |
|
| 1780 |
memcpy(&new_data->notif, notif, sizeof(new_data->notif)); |
| 1781 |
|
| 1782 |
/* noa_attr contains 1 reserved byte, need to substruct it */ |
| 1783 |
new_data->noa_len = sizeof(struct ieee80211_vendor_ie) + |
| 1784 |
sizeof(new_data->notif.noa_attr) - 1; |
| 1785 |
|
| 1786 |
/* |
| 1787 |
* If it's a one time NoA, only one descriptor is needed, |
| 1788 |
* adjust the length according to len_low. |
| 1789 |
*/ |
| 1790 |
if (new_data->notif.noa_attr.len_low == |
| 1791 |
sizeof(struct ieee80211_p2p_noa_desc) + 2) |
| 1792 |
new_data->noa_len -= sizeof(struct ieee80211_p2p_noa_desc); |
| 1793 |
|
| 1794 |
old_data = rcu_dereference_protected(mvmvif->deflink.probe_resp_data, |
| 1795 |
lockdep_is_held(&mvmvif->mvm->mutex)); |
| 1796 |
rcu_assign_pointer(mvmvif->deflink.probe_resp_data, new_data); |
| 1797 |
|
| 1798 |
if (old_data) |
| 1799 |
kfree_rcu(old_data, rcu_head); |
| 1800 |
|
| 1801 |
if (notif->csa_counter != IWL_PROBE_RESP_DATA_NO_CSA && |
| 1802 |
notif->csa_counter >= 1) |
| 1803 |
ieee80211_beacon_set_cntdwn(vif, notif->csa_counter); |
| 1804 |
} |
| 1805 |
|
| 1806 |
void iwl_mvm_channel_switch_start_notif(struct iwl_mvm *mvm, |
| 1807 |
struct iwl_rx_cmd_buffer *rxb) |
| 1808 |
{ |
| 1809 |
struct iwl_rx_packet *pkt = rxb_addr(rxb); |
| 1810 |
struct ieee80211_vif *csa_vif, *vif; |
| 1811 |
struct iwl_mvm_vif *mvmvif, *csa_mvmvif; |
| 1812 |
u32 id_n_color, csa_id; |
| 1813 |
/* save mac_id or link_id to use later to cancel csa if needed */ |
| 1814 |
u32 id; |
| 1815 |
u32 mac_link_id = 0; |
| 1816 |
u8 notif_ver = iwl_fw_lookup_notif_ver(mvm->fw, MAC_CONF_GROUP, |
| 1817 |
CHANNEL_SWITCH_START_NOTIF, 0); |
| 1818 |
bool csa_active; |
| 1819 |
|
| 1820 |
rcu_read_lock(); |
| 1821 |
|
| 1822 |
if (notif_ver < 3) { |
| 1823 |
struct iwl_channel_switch_start_notif_v1 *notif = (void *)pkt->data; |
| 1824 |
u32 mac_id; |
| 1825 |
|
| 1826 |
id_n_color = le32_to_cpu(notif->id_and_color); |
| 1827 |
mac_id = id_n_color & FW_CTXT_ID_MSK; |
| 1828 |
|
| 1829 |
vif = iwl_mvm_rcu_dereference_vif_id(mvm, mac_id, true); |
| 1830 |
if (!vif) |
| 1831 |
goto out_unlock; |
| 1832 |
|
| 1833 |
id = mac_id; |
| 1834 |
csa_active = vif->bss_conf.csa_active; |
| 1835 |
} else { |
| 1836 |
struct iwl_channel_switch_start_notif *notif = (void *)pkt->data; |
| 1837 |
u32 link_id = le32_to_cpu(notif->link_id); |
| 1838 |
|
| 1839 |
/* we use link ID == MAC ID */ |
| 1840 |
vif = iwl_mvm_rcu_dereference_vif_id(mvm, link_id, true); |
| 1841 |
if (!vif) |
| 1842 |
goto out_unlock; |
| 1843 |
|
| 1844 |
id = link_id; |
| 1845 |
mac_link_id = vif->bss_conf.link_id; |
| 1846 |
csa_active = vif->bss_conf.csa_active; |
| 1847 |
} |
| 1848 |
|
| 1849 |
mvmvif = iwl_mvm_vif_from_mac80211(vif); |
| 1850 |
if (notif_ver >= 3) |
| 1851 |
id_n_color = FW_CMD_ID_AND_COLOR(mvmvif->id, mvmvif->color); |
| 1852 |
|
| 1853 |
switch (vif->type) { |
| 1854 |
case NL80211_IFTYPE_AP: |
| 1855 |
csa_vif = rcu_dereference(mvm->csa_vif); |
| 1856 |
if (WARN_ON(!csa_vif || !csa_vif->bss_conf.csa_active || |
| 1857 |
csa_vif != vif)) |
| 1858 |
goto out_unlock; |
| 1859 |
|
| 1860 |
csa_mvmvif = iwl_mvm_vif_from_mac80211(csa_vif); |
| 1861 |
csa_id = FW_CMD_ID_AND_COLOR(csa_mvmvif->id, csa_mvmvif->color); |
| 1862 |
if (WARN(csa_id != id_n_color, |
| 1863 |
"channel switch noa notification on unexpected vif (csa_vif=%d, notif=%d)", |
| 1864 |
csa_id, id_n_color)) |
| 1865 |
goto out_unlock; |
| 1866 |
|
| 1867 |
IWL_DEBUG_INFO(mvm, "Channel Switch Started Notification\n"); |
| 1868 |
|
| 1869 |
schedule_delayed_work(&mvm->cs_tx_unblock_dwork, |
| 1870 |
msecs_to_jiffies(IWL_MVM_CS_UNBLOCK_TX_TIMEOUT * |
| 1871 |
csa_vif->bss_conf.beacon_int)); |
| 1872 |
|
| 1873 |
ieee80211_csa_finish(csa_vif, 0); |
| 1874 |
|
| 1875 |
rcu_read_unlock(); |
| 1876 |
|
| 1877 |
RCU_INIT_POINTER(mvm->csa_vif, NULL); |
| 1878 |
return; |
| 1879 |
case NL80211_IFTYPE_STATION: |
| 1880 |
/* |
| 1881 |
* if we don't know about an ongoing channel switch, |
| 1882 |
* make sure FW cancels it |
| 1883 |
*/ |
| 1884 |
if (iwl_fw_lookup_notif_ver(mvm->fw, MAC_CONF_GROUP, |
| 1885 |
CHANNEL_SWITCH_ERROR_NOTIF, |
| 1886 |
0) && !csa_active) { |
| 1887 |
IWL_DEBUG_INFO(mvm, "Channel Switch was canceled\n"); |
| 1888 |
iwl_mvm_cancel_channel_switch(mvm, vif, id); |
| 1889 |
break; |
| 1890 |
} |
| 1891 |
|
| 1892 |
iwl_mvm_csa_client_absent(mvm, vif); |
| 1893 |
cancel_delayed_work(&mvmvif->csa_work); |
| 1894 |
ieee80211_chswitch_done(vif, true, mac_link_id); |
| 1895 |
break; |
| 1896 |
default: |
| 1897 |
/* should never happen */ |
| 1898 |
WARN_ON_ONCE(1); |
| 1899 |
break; |
| 1900 |
} |
| 1901 |
out_unlock: |
| 1902 |
rcu_read_unlock(); |
| 1903 |
} |
| 1904 |
|
| 1905 |
void iwl_mvm_channel_switch_error_notif(struct iwl_mvm *mvm, |
| 1906 |
struct iwl_rx_cmd_buffer *rxb) |
| 1907 |
{ |
| 1908 |
struct iwl_rx_packet *pkt = rxb_addr(rxb); |
| 1909 |
struct iwl_channel_switch_error_notif *notif = (void *)pkt->data; |
| 1910 |
struct ieee80211_vif *vif; |
| 1911 |
u32 id = le32_to_cpu(notif->link_id); |
| 1912 |
u32 csa_err_mask = le32_to_cpu(notif->csa_err_mask); |
| 1913 |
|
| 1914 |
rcu_read_lock(); |
| 1915 |
vif = iwl_mvm_rcu_dereference_vif_id(mvm, id, true); |
| 1916 |
if (!vif) { |
| 1917 |
rcu_read_unlock(); |
| 1918 |
return; |
| 1919 |
} |
| 1920 |
|
| 1921 |
IWL_DEBUG_INFO(mvm, "FW reports CSA error: id=%u, csa_err_mask=%u\n", |
| 1922 |
id, csa_err_mask); |
| 1923 |
if (csa_err_mask & (CS_ERR_COUNT_ERROR | |
| 1924 |
CS_ERR_LONG_DELAY_AFTER_CS | |
| 1925 |
CS_ERR_TX_BLOCK_TIMER_EXPIRED)) |
| 1926 |
ieee80211_channel_switch_disconnect(vif); |
| 1927 |
rcu_read_unlock(); |
| 1928 |
} |