1 // SPDX-License-Identifier: GPL-2.0-only 2 /****************************************************************************** 3 * 4 * Copyright(c) 2003 - 2014 Intel Corporation. All rights reserved. 5 * Copyright(c) 2015 Intel Deutschland GmbH 6 *****************************************************************************/ 7 8 #include <linux/etherdevice.h> 9 #include "iwl-trans.h" 10 #include "iwl-modparams.h" 11 #include "dev.h" 12 #include "agn.h" 13 #include "calib.h" 14 15 /* 16 * initialize rxon structure with default values from eeprom 17 */ 18 void iwl_connection_init_rx_config(struct iwl_priv *priv, 19 struct iwl_rxon_context *ctx) 20 { 21 memset(&ctx->staging, 0, sizeof(ctx->staging)); 22 23 if (!ctx->vif) { 24 ctx->staging.dev_type = ctx->unused_devtype; 25 } else 26 switch (ctx->vif->type) { 27 case NL80211_IFTYPE_AP: 28 ctx->staging.dev_type = ctx->ap_devtype; 29 break; 30 31 case NL80211_IFTYPE_STATION: 32 ctx->staging.dev_type = ctx->station_devtype; 33 ctx->staging.filter_flags = RXON_FILTER_ACCEPT_GRP_MSK; 34 break; 35 36 case NL80211_IFTYPE_ADHOC: 37 ctx->staging.dev_type = ctx->ibss_devtype; 38 ctx->staging.flags = RXON_FLG_SHORT_PREAMBLE_MSK; 39 ctx->staging.filter_flags = RXON_FILTER_BCON_AWARE_MSK | 40 RXON_FILTER_ACCEPT_GRP_MSK; 41 break; 42 43 case NL80211_IFTYPE_MONITOR: 44 ctx->staging.dev_type = RXON_DEV_TYPE_SNIFFER; 45 break; 46 47 default: 48 IWL_ERR(priv, "Unsupported interface type %d\n", 49 ctx->vif->type); 50 break; 51 } 52 53 #if 0 54 /* TODO: Figure out when short_preamble would be set and cache from 55 * that */ 56 if (!hw_to_local(priv->hw)->short_preamble) 57 ctx->staging.flags &= ~RXON_FLG_SHORT_PREAMBLE_MSK; 58 else 59 ctx->staging.flags |= RXON_FLG_SHORT_PREAMBLE_MSK; 60 #endif 61 62 ctx->staging.channel = 63 cpu_to_le16(priv->hw->conf.chandef.chan->hw_value); 64 priv->band = priv->hw->conf.chandef.chan->band; 65 66 iwl_set_flags_for_band(priv, ctx, priv->band, ctx->vif); 67 68 /* clear both MIX and PURE40 mode flag */ 69 ctx->staging.flags &= ~(RXON_FLG_CHANNEL_MODE_MIXED | 70 RXON_FLG_CHANNEL_MODE_PURE_40); 71 if (ctx->vif) 72 memcpy(ctx->staging.node_addr, ctx->vif->addr, ETH_ALEN); 73 74 ctx->staging.ofdm_ht_single_stream_basic_rates = 0xff; 75 ctx->staging.ofdm_ht_dual_stream_basic_rates = 0xff; 76 ctx->staging.ofdm_ht_triple_stream_basic_rates = 0xff; 77 } 78 79 static int iwlagn_disable_bss(struct iwl_priv *priv, 80 struct iwl_rxon_context *ctx, 81 struct iwl_rxon_cmd *send) 82 { 83 __le32 old_filter = send->filter_flags; 84 int ret; 85 86 send->filter_flags &= ~RXON_FILTER_ASSOC_MSK; 87 ret = iwl_dvm_send_cmd_pdu(priv, ctx->rxon_cmd, 88 0, sizeof(*send), send); 89 90 send->filter_flags = old_filter; 91 92 if (ret) 93 IWL_DEBUG_QUIET_RFKILL(priv, 94 "Error clearing ASSOC_MSK on BSS (%d)\n", ret); 95 96 return ret; 97 } 98 99 static int iwlagn_disable_pan(struct iwl_priv *priv, 100 struct iwl_rxon_context *ctx, 101 struct iwl_rxon_cmd *send) 102 { 103 struct iwl_notification_wait disable_wait; 104 __le32 old_filter = send->filter_flags; 105 u8 old_dev_type = send->dev_type; 106 int ret; 107 static const u16 deactivate_cmd[] = { 108 REPLY_WIPAN_DEACTIVATION_COMPLETE 109 }; 110 111 iwl_init_notification_wait(&priv->notif_wait, &disable_wait, 112 deactivate_cmd, ARRAY_SIZE(deactivate_cmd), 113 NULL, NULL); 114 115 send->filter_flags &= ~RXON_FILTER_ASSOC_MSK; 116 send->dev_type = RXON_DEV_TYPE_P2P; 117 ret = iwl_dvm_send_cmd_pdu(priv, ctx->rxon_cmd, 118 0, sizeof(*send), send); 119 120 send->filter_flags = old_filter; 121 send->dev_type = old_dev_type; 122 123 if (ret) { 124 IWL_ERR(priv, "Error disabling PAN (%d)\n", ret); 125 iwl_remove_notification(&priv->notif_wait, &disable_wait); 126 } else { 127 ret = iwl_wait_notification(&priv->notif_wait, 128 &disable_wait, HZ); 129 if (ret) 130 IWL_ERR(priv, "Timed out waiting for PAN disable\n"); 131 } 132 133 return ret; 134 } 135 136 static int iwlagn_disconn_pan(struct iwl_priv *priv, 137 struct iwl_rxon_context *ctx, 138 struct iwl_rxon_cmd *send) 139 { 140 __le32 old_filter = send->filter_flags; 141 int ret; 142 143 send->filter_flags &= ~RXON_FILTER_ASSOC_MSK; 144 ret = iwl_dvm_send_cmd_pdu(priv, ctx->rxon_cmd, 0, 145 sizeof(*send), send); 146 147 send->filter_flags = old_filter; 148 149 return ret; 150 } 151 152 static void iwlagn_update_qos(struct iwl_priv *priv, 153 struct iwl_rxon_context *ctx) 154 { 155 int ret; 156 157 if (!ctx->is_active) 158 return; 159 160 ctx->qos_data.def_qos_parm.qos_flags = 0; 161 162 if (ctx->qos_data.qos_active) 163 ctx->qos_data.def_qos_parm.qos_flags |= 164 QOS_PARAM_FLG_UPDATE_EDCA_MSK; 165 166 if (ctx->ht.enabled) 167 ctx->qos_data.def_qos_parm.qos_flags |= QOS_PARAM_FLG_TGN_MSK; 168 169 IWL_DEBUG_INFO(priv, "send QoS cmd with Qos active=%d FLAGS=0x%X\n", 170 ctx->qos_data.qos_active, 171 ctx->qos_data.def_qos_parm.qos_flags); 172 173 ret = iwl_dvm_send_cmd_pdu(priv, ctx->qos_cmd, 0, 174 sizeof(struct iwl_qosparam_cmd), 175 &ctx->qos_data.def_qos_parm); 176 if (ret) 177 IWL_DEBUG_QUIET_RFKILL(priv, "Failed to update QoS\n"); 178 } 179 180 static int iwlagn_update_beacon(struct iwl_priv *priv, 181 struct ieee80211_vif *vif) 182 { 183 lockdep_assert_held(&priv->mutex); 184 185 dev_kfree_skb(priv->beacon_skb); 186 priv->beacon_skb = ieee80211_beacon_get(priv->hw, vif, 0); 187 if (!priv->beacon_skb) 188 return -ENOMEM; 189 return iwlagn_send_beacon_cmd(priv); 190 } 191 192 static int iwlagn_send_rxon_assoc(struct iwl_priv *priv, 193 struct iwl_rxon_context *ctx) 194 { 195 int ret = 0; 196 struct iwl_rxon_assoc_cmd rxon_assoc; 197 const struct iwl_rxon_cmd *rxon1 = &ctx->staging; 198 const struct iwl_rxon_cmd *rxon2 = &ctx->active; 199 200 if ((rxon1->flags == rxon2->flags) && 201 (rxon1->filter_flags == rxon2->filter_flags) && 202 (rxon1->cck_basic_rates == rxon2->cck_basic_rates) && 203 (rxon1->ofdm_ht_single_stream_basic_rates == 204 rxon2->ofdm_ht_single_stream_basic_rates) && 205 (rxon1->ofdm_ht_dual_stream_basic_rates == 206 rxon2->ofdm_ht_dual_stream_basic_rates) && 207 (rxon1->ofdm_ht_triple_stream_basic_rates == 208 rxon2->ofdm_ht_triple_stream_basic_rates) && 209 (rxon1->acquisition_data == rxon2->acquisition_data) && 210 (rxon1->rx_chain == rxon2->rx_chain) && 211 (rxon1->ofdm_basic_rates == rxon2->ofdm_basic_rates)) { 212 IWL_DEBUG_INFO(priv, "Using current RXON_ASSOC. Not resending.\n"); 213 return 0; 214 } 215 216 rxon_assoc.flags = ctx->staging.flags; 217 rxon_assoc.filter_flags = ctx->staging.filter_flags; 218 rxon_assoc.ofdm_basic_rates = ctx->staging.ofdm_basic_rates; 219 rxon_assoc.cck_basic_rates = ctx->staging.cck_basic_rates; 220 rxon_assoc.reserved1 = 0; 221 rxon_assoc.reserved2 = 0; 222 rxon_assoc.reserved3 = 0; 223 rxon_assoc.ofdm_ht_single_stream_basic_rates = 224 ctx->staging.ofdm_ht_single_stream_basic_rates; 225 rxon_assoc.ofdm_ht_dual_stream_basic_rates = 226 ctx->staging.ofdm_ht_dual_stream_basic_rates; 227 rxon_assoc.rx_chain_select_flags = ctx->staging.rx_chain; 228 rxon_assoc.ofdm_ht_triple_stream_basic_rates = 229 ctx->staging.ofdm_ht_triple_stream_basic_rates; 230 rxon_assoc.acquisition_data = ctx->staging.acquisition_data; 231 232 ret = iwl_dvm_send_cmd_pdu(priv, ctx->rxon_assoc_cmd, 233 CMD_ASYNC, sizeof(rxon_assoc), &rxon_assoc); 234 return ret; 235 } 236 237 static u16 iwl_adjust_beacon_interval(u16 beacon_val, u16 max_beacon_val) 238 { 239 u16 new_val; 240 u16 beacon_factor; 241 242 /* 243 * If mac80211 hasn't given us a beacon interval, program 244 * the default into the device (not checking this here 245 * would cause the adjustment below to return the maximum 246 * value, which may break PAN.) 247 */ 248 if (!beacon_val) 249 return DEFAULT_BEACON_INTERVAL; 250 251 /* 252 * If the beacon interval we obtained from the peer 253 * is too large, we'll have to wake up more often 254 * (and in IBSS case, we'll beacon too much) 255 * 256 * For example, if max_beacon_val is 4096, and the 257 * requested beacon interval is 7000, we'll have to 258 * use 3500 to be able to wake up on the beacons. 259 * 260 * This could badly influence beacon detection stats. 261 */ 262 263 beacon_factor = (beacon_val + max_beacon_val) / max_beacon_val; 264 new_val = beacon_val / beacon_factor; 265 266 if (!new_val) 267 new_val = max_beacon_val; 268 269 return new_val; 270 } 271 272 static int iwl_send_rxon_timing(struct iwl_priv *priv, 273 struct iwl_rxon_context *ctx) 274 { 275 u64 tsf; 276 s32 interval_tm, rem; 277 struct ieee80211_conf *conf = NULL; 278 u16 beacon_int; 279 struct ieee80211_vif *vif = ctx->vif; 280 281 conf = &priv->hw->conf; 282 283 lockdep_assert_held(&priv->mutex); 284 285 memset(&ctx->timing, 0, sizeof(struct iwl_rxon_time_cmd)); 286 287 ctx->timing.timestamp = cpu_to_le64(priv->timestamp); 288 ctx->timing.listen_interval = cpu_to_le16(conf->listen_interval); 289 290 beacon_int = vif ? vif->bss_conf.beacon_int : 0; 291 292 /* 293 * TODO: For IBSS we need to get atim_window from mac80211, 294 * for now just always use 0 295 */ 296 ctx->timing.atim_window = 0; 297 298 if (ctx->ctxid == IWL_RXON_CTX_PAN && 299 (!ctx->vif || ctx->vif->type != NL80211_IFTYPE_STATION) && 300 iwl_is_associated(priv, IWL_RXON_CTX_BSS) && 301 priv->contexts[IWL_RXON_CTX_BSS].vif && 302 priv->contexts[IWL_RXON_CTX_BSS].vif->bss_conf.beacon_int) { 303 ctx->timing.beacon_interval = 304 priv->contexts[IWL_RXON_CTX_BSS].timing.beacon_interval; 305 beacon_int = le16_to_cpu(ctx->timing.beacon_interval); 306 } else if (ctx->ctxid == IWL_RXON_CTX_BSS && 307 iwl_is_associated(priv, IWL_RXON_CTX_PAN) && 308 priv->contexts[IWL_RXON_CTX_PAN].vif && 309 priv->contexts[IWL_RXON_CTX_PAN].vif->bss_conf.beacon_int && 310 (!iwl_is_associated_ctx(ctx) || !ctx->vif || 311 !ctx->vif->bss_conf.beacon_int)) { 312 ctx->timing.beacon_interval = 313 priv->contexts[IWL_RXON_CTX_PAN].timing.beacon_interval; 314 beacon_int = le16_to_cpu(ctx->timing.beacon_interval); 315 } else { 316 beacon_int = iwl_adjust_beacon_interval(beacon_int, 317 IWL_MAX_UCODE_BEACON_INTERVAL * TIME_UNIT); 318 ctx->timing.beacon_interval = cpu_to_le16(beacon_int); 319 } 320 321 ctx->beacon_int = beacon_int; 322 323 tsf = priv->timestamp; /* tsf is modifed by do_div: copy it */ 324 interval_tm = beacon_int * TIME_UNIT; 325 rem = do_div(tsf, interval_tm); 326 ctx->timing.beacon_init_val = cpu_to_le32(interval_tm - rem); 327 328 ctx->timing.dtim_period = vif ? (vif->bss_conf.dtim_period ?: 1) : 1; 329 330 IWL_DEBUG_ASSOC(priv, 331 "beacon interval %d beacon timer %d beacon tim %d\n", 332 le16_to_cpu(ctx->timing.beacon_interval), 333 le32_to_cpu(ctx->timing.beacon_init_val), 334 le16_to_cpu(ctx->timing.atim_window)); 335 336 return iwl_dvm_send_cmd_pdu(priv, ctx->rxon_timing_cmd, 337 0, sizeof(ctx->timing), &ctx->timing); 338 } 339 340 static int iwlagn_rxon_disconn(struct iwl_priv *priv, 341 struct iwl_rxon_context *ctx) 342 { 343 int ret; 344 struct iwl_rxon_cmd *active = (void *)&ctx->active; 345 346 if (ctx->ctxid == IWL_RXON_CTX_BSS) { 347 ret = iwlagn_disable_bss(priv, ctx, &ctx->staging); 348 } else { 349 ret = iwlagn_disable_pan(priv, ctx, &ctx->staging); 350 if (ret) 351 return ret; 352 if (ctx->vif) { 353 ret = iwl_send_rxon_timing(priv, ctx); 354 if (ret) { 355 IWL_ERR(priv, "Failed to send timing (%d)!\n", ret); 356 return ret; 357 } 358 ret = iwlagn_disconn_pan(priv, ctx, &ctx->staging); 359 } 360 } 361 if (ret) 362 return ret; 363 364 /* 365 * Un-assoc RXON clears the station table and WEP 366 * keys, so we have to restore those afterwards. 367 */ 368 iwl_clear_ucode_stations(priv, ctx); 369 /* update -- might need P2P now */ 370 iwl_update_bcast_station(priv, ctx); 371 iwl_restore_stations(priv, ctx); 372 ret = iwl_restore_default_wep_keys(priv, ctx); 373 if (ret) { 374 IWL_ERR(priv, "Failed to restore WEP keys (%d)\n", ret); 375 return ret; 376 } 377 378 memcpy(active, &ctx->staging, sizeof(*active)); 379 return 0; 380 } 381 382 static int iwl_set_tx_power(struct iwl_priv *priv, s8 tx_power, bool force) 383 { 384 int ret; 385 s8 prev_tx_power; 386 bool defer; 387 struct iwl_rxon_context *ctx = &priv->contexts[IWL_RXON_CTX_BSS]; 388 389 if (priv->calib_disabled & IWL_TX_POWER_CALIB_DISABLED) 390 return 0; 391 392 lockdep_assert_held(&priv->mutex); 393 394 if (priv->tx_power_user_lmt == tx_power && !force) 395 return 0; 396 397 if (tx_power < IWLAGN_TX_POWER_TARGET_POWER_MIN) { 398 IWL_WARN(priv, 399 "Requested user TXPOWER %d below lower limit %d.\n", 400 tx_power, 401 IWLAGN_TX_POWER_TARGET_POWER_MIN); 402 return -EINVAL; 403 } 404 405 if (tx_power > DIV_ROUND_UP(priv->nvm_data->max_tx_pwr_half_dbm, 2)) { 406 IWL_WARN(priv, 407 "Requested user TXPOWER %d above upper limit %d.\n", 408 tx_power, priv->nvm_data->max_tx_pwr_half_dbm); 409 return -EINVAL; 410 } 411 412 if (!iwl_is_ready_rf(priv)) 413 return -EIO; 414 415 /* scan complete and commit_rxon use tx_power_next value, 416 * it always need to be updated for newest request */ 417 priv->tx_power_next = tx_power; 418 419 /* do not set tx power when scanning or channel changing */ 420 defer = test_bit(STATUS_SCANNING, &priv->status) || 421 memcmp(&ctx->active, &ctx->staging, sizeof(ctx->staging)); 422 if (defer && !force) { 423 IWL_DEBUG_INFO(priv, "Deferring tx power set\n"); 424 return 0; 425 } 426 427 prev_tx_power = priv->tx_power_user_lmt; 428 priv->tx_power_user_lmt = tx_power; 429 430 ret = iwlagn_send_tx_power(priv); 431 432 /* if fail to set tx_power, restore the orig. tx power */ 433 if (ret) { 434 priv->tx_power_user_lmt = prev_tx_power; 435 priv->tx_power_next = prev_tx_power; 436 } 437 return ret; 438 } 439 440 static int iwlagn_rxon_connect(struct iwl_priv *priv, 441 struct iwl_rxon_context *ctx) 442 { 443 int ret; 444 struct iwl_rxon_cmd *active = (void *)&ctx->active; 445 446 /* RXON timing must be before associated RXON */ 447 if (ctx->ctxid == IWL_RXON_CTX_BSS) { 448 ret = iwl_send_rxon_timing(priv, ctx); 449 if (ret) { 450 IWL_ERR(priv, "Failed to send timing (%d)!\n", ret); 451 return ret; 452 } 453 } 454 /* QoS info may be cleared by previous un-assoc RXON */ 455 iwlagn_update_qos(priv, ctx); 456 457 /* 458 * We'll run into this code path when beaconing is 459 * enabled, but then we also need to send the beacon 460 * to the device. 461 */ 462 if (ctx->vif && (ctx->vif->type == NL80211_IFTYPE_AP)) { 463 ret = iwlagn_update_beacon(priv, ctx->vif); 464 if (ret) { 465 IWL_ERR(priv, 466 "Error sending required beacon (%d)!\n", 467 ret); 468 return ret; 469 } 470 } 471 472 priv->start_calib = 0; 473 /* 474 * Apply the new configuration. 475 * 476 * Associated RXON doesn't clear the station table in uCode, 477 * so we don't need to restore stations etc. after this. 478 */ 479 ret = iwl_dvm_send_cmd_pdu(priv, ctx->rxon_cmd, 0, 480 sizeof(struct iwl_rxon_cmd), &ctx->staging); 481 if (ret) { 482 IWL_ERR(priv, "Error setting new RXON (%d)\n", ret); 483 return ret; 484 } 485 memcpy(active, &ctx->staging, sizeof(*active)); 486 487 /* IBSS beacon needs to be sent after setting assoc */ 488 if (ctx->vif && (ctx->vif->type == NL80211_IFTYPE_ADHOC)) 489 if (iwlagn_update_beacon(priv, ctx->vif)) 490 IWL_ERR(priv, "Error sending IBSS beacon\n"); 491 iwl_init_sensitivity(priv); 492 493 /* 494 * If we issue a new RXON command which required a tune then 495 * we must send a new TXPOWER command or we won't be able to 496 * Tx any frames. 497 * 498 * It's expected we set power here if channel is changing. 499 */ 500 ret = iwl_set_tx_power(priv, priv->tx_power_next, true); 501 if (ret) { 502 IWL_ERR(priv, "Error sending TX power (%d)\n", ret); 503 return ret; 504 } 505 506 return 0; 507 } 508 509 int iwlagn_set_pan_params(struct iwl_priv *priv) 510 { 511 struct iwl_wipan_params_cmd cmd; 512 struct iwl_rxon_context *ctx_bss, *ctx_pan; 513 int slot0 = 300, slot1 = 0; 514 int ret; 515 516 if (priv->valid_contexts == BIT(IWL_RXON_CTX_BSS)) 517 return 0; 518 519 BUILD_BUG_ON(NUM_IWL_RXON_CTX != 2); 520 521 lockdep_assert_held(&priv->mutex); 522 523 ctx_bss = &priv->contexts[IWL_RXON_CTX_BSS]; 524 ctx_pan = &priv->contexts[IWL_RXON_CTX_PAN]; 525 526 /* 527 * If the PAN context is inactive, then we don't need 528 * to update the PAN parameters, the last thing we'll 529 * have done before it goes inactive is making the PAN 530 * parameters be WLAN-only. 531 */ 532 if (!ctx_pan->is_active) 533 return 0; 534 535 memset(&cmd, 0, sizeof(cmd)); 536 537 /* only 2 slots are currently allowed */ 538 cmd.num_slots = 2; 539 540 cmd.slots[0].type = 0; /* BSS */ 541 cmd.slots[1].type = 1; /* PAN */ 542 543 if (ctx_bss->vif && ctx_pan->vif) { 544 int bcnint = ctx_pan->beacon_int; 545 int dtim = ctx_pan->vif->bss_conf.dtim_period ?: 1; 546 547 /* should be set, but seems unused?? */ 548 cmd.flags |= cpu_to_le16(IWL_WIPAN_PARAMS_FLG_SLOTTED_MODE); 549 550 if (ctx_pan->vif->type == NL80211_IFTYPE_AP && 551 bcnint && 552 bcnint != ctx_bss->beacon_int) { 553 IWL_ERR(priv, 554 "beacon intervals don't match (%d, %d)\n", 555 ctx_bss->beacon_int, ctx_pan->beacon_int); 556 } else 557 bcnint = max_t(int, bcnint, 558 ctx_bss->beacon_int); 559 if (!bcnint) 560 bcnint = DEFAULT_BEACON_INTERVAL; 561 slot0 = bcnint / 2; 562 slot1 = bcnint - slot0; 563 564 if (test_bit(STATUS_SCAN_HW, &priv->status) || 565 (!ctx_bss->vif->cfg.idle && 566 !ctx_bss->vif->cfg.assoc)) { 567 slot0 = dtim * bcnint * 3 - IWL_MIN_SLOT_TIME; 568 slot1 = IWL_MIN_SLOT_TIME; 569 } else if (!ctx_pan->vif->cfg.idle && 570 !ctx_pan->vif->cfg.assoc) { 571 slot1 = dtim * bcnint * 3 - IWL_MIN_SLOT_TIME; 572 slot0 = IWL_MIN_SLOT_TIME; 573 } 574 } else if (ctx_pan->vif) { 575 slot0 = 0; 576 slot1 = max_t(int, 1, ctx_pan->vif->bss_conf.dtim_period) * 577 ctx_pan->beacon_int; 578 slot1 = max_t(int, DEFAULT_BEACON_INTERVAL, slot1); 579 580 if (test_bit(STATUS_SCAN_HW, &priv->status)) { 581 slot0 = slot1 * 3 - IWL_MIN_SLOT_TIME; 582 slot1 = IWL_MIN_SLOT_TIME; 583 } 584 } 585 586 cmd.slots[0].width = cpu_to_le16(slot0); 587 cmd.slots[1].width = cpu_to_le16(slot1); 588 589 ret = iwl_dvm_send_cmd_pdu(priv, REPLY_WIPAN_PARAMS, 0, 590 sizeof(cmd), &cmd); 591 if (ret) 592 IWL_ERR(priv, "Error setting PAN parameters (%d)\n", ret); 593 594 return ret; 595 } 596 597 static void _iwl_set_rxon_ht(struct iwl_priv *priv, 598 struct iwl_ht_config *ht_conf, 599 struct iwl_rxon_context *ctx) 600 { 601 struct iwl_rxon_cmd *rxon = &ctx->staging; 602 603 if (!ctx->ht.enabled) { 604 rxon->flags &= ~(RXON_FLG_CHANNEL_MODE_MSK | 605 RXON_FLG_CTRL_CHANNEL_LOC_HI_MSK | 606 RXON_FLG_HT40_PROT_MSK | 607 RXON_FLG_HT_PROT_MSK); 608 return; 609 } 610 611 /* FIXME: if the definition of ht.protection changed, the "translation" 612 * will be needed for rxon->flags 613 */ 614 rxon->flags |= cpu_to_le32(ctx->ht.protection << 615 RXON_FLG_HT_OPERATING_MODE_POS); 616 617 /* Set up channel bandwidth: 618 * 20 MHz only, 20/40 mixed or pure 40 if ht40 ok */ 619 /* clear the HT channel mode before set the mode */ 620 rxon->flags &= ~(RXON_FLG_CHANNEL_MODE_MSK | 621 RXON_FLG_CTRL_CHANNEL_LOC_HI_MSK); 622 if (iwl_is_ht40_tx_allowed(priv, ctx, NULL)) { 623 /* pure ht40 */ 624 if (ctx->ht.protection == 625 IEEE80211_HT_OP_MODE_PROTECTION_20MHZ) { 626 rxon->flags |= RXON_FLG_CHANNEL_MODE_PURE_40; 627 /* 628 * Note: control channel is opposite of extension 629 * channel 630 */ 631 switch (ctx->ht.extension_chan_offset) { 632 case IEEE80211_HT_PARAM_CHA_SEC_ABOVE: 633 rxon->flags &= 634 ~RXON_FLG_CTRL_CHANNEL_LOC_HI_MSK; 635 break; 636 case IEEE80211_HT_PARAM_CHA_SEC_BELOW: 637 rxon->flags |= 638 RXON_FLG_CTRL_CHANNEL_LOC_HI_MSK; 639 break; 640 } 641 } else { 642 /* 643 * Note: control channel is opposite of extension 644 * channel 645 */ 646 switch (ctx->ht.extension_chan_offset) { 647 case IEEE80211_HT_PARAM_CHA_SEC_ABOVE: 648 rxon->flags &= 649 ~(RXON_FLG_CTRL_CHANNEL_LOC_HI_MSK); 650 rxon->flags |= RXON_FLG_CHANNEL_MODE_MIXED; 651 break; 652 case IEEE80211_HT_PARAM_CHA_SEC_BELOW: 653 rxon->flags |= RXON_FLG_CTRL_CHANNEL_LOC_HI_MSK; 654 rxon->flags |= RXON_FLG_CHANNEL_MODE_MIXED; 655 break; 656 case IEEE80211_HT_PARAM_CHA_SEC_NONE: 657 default: 658 /* 659 * channel location only valid if in Mixed 660 * mode 661 */ 662 IWL_ERR(priv, 663 "invalid extension channel offset\n"); 664 break; 665 } 666 } 667 } else { 668 rxon->flags |= RXON_FLG_CHANNEL_MODE_LEGACY; 669 } 670 671 iwlagn_set_rxon_chain(priv, ctx); 672 673 IWL_DEBUG_ASSOC(priv, "rxon flags 0x%X operation mode :0x%X " 674 "extension channel offset 0x%x\n", 675 le32_to_cpu(rxon->flags), ctx->ht.protection, 676 ctx->ht.extension_chan_offset); 677 } 678 679 void iwl_set_rxon_ht(struct iwl_priv *priv, struct iwl_ht_config *ht_conf) 680 { 681 struct iwl_rxon_context *ctx; 682 683 for_each_context(priv, ctx) 684 _iwl_set_rxon_ht(priv, ht_conf, ctx); 685 } 686 687 /* 688 * iwl_set_rxon_channel - Set the band and channel values in staging RXON 689 * @ch: requested channel as a pointer to struct ieee80211_channel 690 691 * NOTE: Does not commit to the hardware; it sets appropriate bit fields 692 * in the staging RXON flag structure based on the ch->band 693 */ 694 void iwl_set_rxon_channel(struct iwl_priv *priv, struct ieee80211_channel *ch, 695 struct iwl_rxon_context *ctx) 696 { 697 enum nl80211_band band = ch->band; 698 u16 channel = ch->hw_value; 699 700 if ((le16_to_cpu(ctx->staging.channel) == channel) && 701 (priv->band == band)) 702 return; 703 704 ctx->staging.channel = cpu_to_le16(channel); 705 if (band == NL80211_BAND_5GHZ) 706 ctx->staging.flags &= ~RXON_FLG_BAND_24G_MSK; 707 else 708 ctx->staging.flags |= RXON_FLG_BAND_24G_MSK; 709 710 priv->band = band; 711 712 IWL_DEBUG_INFO(priv, "Staging channel set to %d [%d]\n", channel, band); 713 714 } 715 716 void iwl_set_flags_for_band(struct iwl_priv *priv, 717 struct iwl_rxon_context *ctx, 718 enum nl80211_band band, 719 struct ieee80211_vif *vif) 720 { 721 if (band == NL80211_BAND_5GHZ) { 722 ctx->staging.flags &= 723 ~(RXON_FLG_BAND_24G_MSK | RXON_FLG_AUTO_DETECT_MSK 724 | RXON_FLG_CCK_MSK); 725 ctx->staging.flags |= RXON_FLG_SHORT_SLOT_MSK; 726 } else { 727 /* Copied from iwl_post_associate() */ 728 if (vif && vif->bss_conf.use_short_slot) 729 ctx->staging.flags |= RXON_FLG_SHORT_SLOT_MSK; 730 else 731 ctx->staging.flags &= ~RXON_FLG_SHORT_SLOT_MSK; 732 733 ctx->staging.flags |= RXON_FLG_BAND_24G_MSK; 734 ctx->staging.flags |= RXON_FLG_AUTO_DETECT_MSK; 735 ctx->staging.flags &= ~RXON_FLG_CCK_MSK; 736 } 737 } 738 739 static void iwl_set_rxon_hwcrypto(struct iwl_priv *priv, 740 struct iwl_rxon_context *ctx, int hw_decrypt) 741 { 742 struct iwl_rxon_cmd *rxon = &ctx->staging; 743 744 if (hw_decrypt) 745 rxon->filter_flags &= ~RXON_FILTER_DIS_DECRYPT_MSK; 746 else 747 rxon->filter_flags |= RXON_FILTER_DIS_DECRYPT_MSK; 748 749 } 750 751 /* validate RXON structure is valid */ 752 static int iwl_check_rxon_cmd(struct iwl_priv *priv, 753 struct iwl_rxon_context *ctx) 754 { 755 struct iwl_rxon_cmd *rxon = &ctx->staging; 756 u32 errors = 0; 757 758 if (rxon->flags & RXON_FLG_BAND_24G_MSK) { 759 if (rxon->flags & RXON_FLG_TGJ_NARROW_BAND_MSK) { 760 IWL_WARN(priv, "check 2.4G: wrong narrow\n"); 761 errors |= BIT(0); 762 } 763 if (rxon->flags & RXON_FLG_RADAR_DETECT_MSK) { 764 IWL_WARN(priv, "check 2.4G: wrong radar\n"); 765 errors |= BIT(1); 766 } 767 } else { 768 if (!(rxon->flags & RXON_FLG_SHORT_SLOT_MSK)) { 769 IWL_WARN(priv, "check 5.2G: not short slot!\n"); 770 errors |= BIT(2); 771 } 772 if (rxon->flags & RXON_FLG_CCK_MSK) { 773 IWL_WARN(priv, "check 5.2G: CCK!\n"); 774 errors |= BIT(3); 775 } 776 } 777 if ((rxon->node_addr[0] | rxon->bssid_addr[0]) & 0x1) { 778 IWL_WARN(priv, "mac/bssid mcast!\n"); 779 errors |= BIT(4); 780 } 781 782 /* make sure basic rates 6Mbps and 1Mbps are supported */ 783 if ((rxon->ofdm_basic_rates & IWL_RATE_6M_MASK) == 0 && 784 (rxon->cck_basic_rates & IWL_RATE_1M_MASK) == 0) { 785 IWL_WARN(priv, "neither 1 nor 6 are basic\n"); 786 errors |= BIT(5); 787 } 788 789 if (le16_to_cpu(rxon->assoc_id) > 2007) { 790 IWL_WARN(priv, "aid > 2007\n"); 791 errors |= BIT(6); 792 } 793 794 if ((rxon->flags & (RXON_FLG_CCK_MSK | RXON_FLG_SHORT_SLOT_MSK)) 795 == (RXON_FLG_CCK_MSK | RXON_FLG_SHORT_SLOT_MSK)) { 796 IWL_WARN(priv, "CCK and short slot\n"); 797 errors |= BIT(7); 798 } 799 800 if ((rxon->flags & (RXON_FLG_CCK_MSK | RXON_FLG_AUTO_DETECT_MSK)) 801 == (RXON_FLG_CCK_MSK | RXON_FLG_AUTO_DETECT_MSK)) { 802 IWL_WARN(priv, "CCK and auto detect\n"); 803 errors |= BIT(8); 804 } 805 806 if ((rxon->flags & (RXON_FLG_AUTO_DETECT_MSK | 807 RXON_FLG_TGG_PROTECT_MSK)) == 808 RXON_FLG_TGG_PROTECT_MSK) { 809 IWL_WARN(priv, "TGg but no auto-detect\n"); 810 errors |= BIT(9); 811 } 812 813 if (rxon->channel == 0) { 814 IWL_WARN(priv, "zero channel is invalid\n"); 815 errors |= BIT(10); 816 } 817 818 WARN(errors, "Invalid RXON (%#x), channel %d", 819 errors, le16_to_cpu(rxon->channel)); 820 821 return errors ? -EINVAL : 0; 822 } 823 824 /* 825 * iwl_full_rxon_required - check if full RXON (vs RXON_ASSOC) cmd is needed 826 * @priv: staging_rxon is compared to active_rxon 827 * 828 * If the RXON structure is changing enough to require a new tune, 829 * or is clearing the RXON_FILTER_ASSOC_MSK, then return 1 to indicate that 830 * a new tune (full RXON command, rather than RXON_ASSOC cmd) is required. 831 */ 832 static int iwl_full_rxon_required(struct iwl_priv *priv, 833 struct iwl_rxon_context *ctx) 834 { 835 const struct iwl_rxon_cmd *staging = &ctx->staging; 836 const struct iwl_rxon_cmd *active = &ctx->active; 837 838 #define CHK(cond) \ 839 if ((cond)) { \ 840 IWL_DEBUG_INFO(priv, "need full RXON - " #cond "\n"); \ 841 return 1; \ 842 } 843 844 #define CHK_NEQ(c1, c2) \ 845 if ((c1) != (c2)) { \ 846 IWL_DEBUG_INFO(priv, "need full RXON - " \ 847 #c1 " != " #c2 " - %d != %d\n", \ 848 (c1), (c2)); \ 849 return 1; \ 850 } 851 852 /* These items are only settable from the full RXON command */ 853 CHK(!iwl_is_associated_ctx(ctx)); 854 CHK(!ether_addr_equal(staging->bssid_addr, active->bssid_addr)); 855 CHK(!ether_addr_equal(staging->node_addr, active->node_addr)); 856 CHK(!ether_addr_equal(staging->wlap_bssid_addr, 857 active->wlap_bssid_addr)); 858 CHK_NEQ(staging->dev_type, active->dev_type); 859 CHK_NEQ(staging->channel, active->channel); 860 CHK_NEQ(staging->air_propagation, active->air_propagation); 861 CHK_NEQ(staging->ofdm_ht_single_stream_basic_rates, 862 active->ofdm_ht_single_stream_basic_rates); 863 CHK_NEQ(staging->ofdm_ht_dual_stream_basic_rates, 864 active->ofdm_ht_dual_stream_basic_rates); 865 CHK_NEQ(staging->ofdm_ht_triple_stream_basic_rates, 866 active->ofdm_ht_triple_stream_basic_rates); 867 CHK_NEQ(staging->assoc_id, active->assoc_id); 868 869 /* flags, filter_flags, ofdm_basic_rates, and cck_basic_rates can 870 * be updated with the RXON_ASSOC command -- however only some 871 * flag transitions are allowed using RXON_ASSOC */ 872 873 /* Check if we are not switching bands */ 874 CHK_NEQ(staging->flags & RXON_FLG_BAND_24G_MSK, 875 active->flags & RXON_FLG_BAND_24G_MSK); 876 877 /* Check if we are switching association toggle */ 878 CHK_NEQ(staging->filter_flags & RXON_FILTER_ASSOC_MSK, 879 active->filter_flags & RXON_FILTER_ASSOC_MSK); 880 881 #undef CHK 882 #undef CHK_NEQ 883 884 return 0; 885 } 886 887 #ifdef CONFIG_IWLWIFI_DEBUG 888 void iwl_print_rx_config_cmd(struct iwl_priv *priv, 889 enum iwl_rxon_context_id ctxid) 890 { 891 struct iwl_rxon_context *ctx = &priv->contexts[ctxid]; 892 struct iwl_rxon_cmd *rxon = &ctx->staging; 893 894 IWL_DEBUG_RADIO(priv, "RX CONFIG:\n"); 895 iwl_print_hex_dump(priv, IWL_DL_RADIO, (u8 *) rxon, sizeof(*rxon)); 896 IWL_DEBUG_RADIO(priv, "u16 channel: 0x%x\n", 897 le16_to_cpu(rxon->channel)); 898 IWL_DEBUG_RADIO(priv, "u32 flags: 0x%08X\n", 899 le32_to_cpu(rxon->flags)); 900 IWL_DEBUG_RADIO(priv, "u32 filter_flags: 0x%08x\n", 901 le32_to_cpu(rxon->filter_flags)); 902 IWL_DEBUG_RADIO(priv, "u8 dev_type: 0x%x\n", rxon->dev_type); 903 IWL_DEBUG_RADIO(priv, "u8 ofdm_basic_rates: 0x%02x\n", 904 rxon->ofdm_basic_rates); 905 IWL_DEBUG_RADIO(priv, "u8 cck_basic_rates: 0x%02x\n", 906 rxon->cck_basic_rates); 907 IWL_DEBUG_RADIO(priv, "u8[6] node_addr: %pM\n", rxon->node_addr); 908 IWL_DEBUG_RADIO(priv, "u8[6] bssid_addr: %pM\n", rxon->bssid_addr); 909 IWL_DEBUG_RADIO(priv, "u16 assoc_id: 0x%x\n", 910 le16_to_cpu(rxon->assoc_id)); 911 } 912 #endif 913 914 static void iwl_calc_basic_rates(struct iwl_priv *priv, 915 struct iwl_rxon_context *ctx) 916 { 917 int lowest_present_ofdm = 100; 918 int lowest_present_cck = 100; 919 u8 cck = 0; 920 u8 ofdm = 0; 921 922 if (ctx->vif) { 923 struct ieee80211_supported_band *sband; 924 unsigned long basic = ctx->vif->bss_conf.basic_rates; 925 int i; 926 927 sband = priv->hw->wiphy->bands[priv->hw->conf.chandef.chan->band]; 928 929 for_each_set_bit(i, &basic, BITS_PER_LONG) { 930 int hw = sband->bitrates[i].hw_value; 931 if (hw >= IWL_FIRST_OFDM_RATE) { 932 ofdm |= BIT(hw - IWL_FIRST_OFDM_RATE); 933 if (lowest_present_ofdm > hw) 934 lowest_present_ofdm = hw; 935 } else { 936 BUILD_BUG_ON(IWL_FIRST_CCK_RATE != 0); 937 938 cck |= BIT(hw); 939 if (lowest_present_cck > hw) 940 lowest_present_cck = hw; 941 } 942 } 943 } 944 945 /* 946 * Now we've got the basic rates as bitmaps in the ofdm and cck 947 * variables. This isn't sufficient though, as there might not 948 * be all the right rates in the bitmap. E.g. if the only basic 949 * rates are 5.5 Mbps and 11 Mbps, we still need to add 1 Mbps 950 * and 6 Mbps because the 802.11-2007 standard says in 9.6: 951 * 952 * [...] a STA responding to a received frame shall transmit 953 * its Control Response frame [...] at the highest rate in the 954 * BSSBasicRateSet parameter that is less than or equal to the 955 * rate of the immediately previous frame in the frame exchange 956 * sequence ([...]) and that is of the same modulation class 957 * ([...]) as the received frame. If no rate contained in the 958 * BSSBasicRateSet parameter meets these conditions, then the 959 * control frame sent in response to a received frame shall be 960 * transmitted at the highest mandatory rate of the PHY that is 961 * less than or equal to the rate of the received frame, and 962 * that is of the same modulation class as the received frame. 963 * 964 * As a consequence, we need to add all mandatory rates that are 965 * lower than all of the basic rates to these bitmaps. 966 */ 967 968 if (IWL_RATE_24M_INDEX < lowest_present_ofdm) 969 ofdm |= IWL_RATE_24M_MASK >> IWL_FIRST_OFDM_RATE; 970 if (IWL_RATE_12M_INDEX < lowest_present_ofdm) 971 ofdm |= IWL_RATE_12M_MASK >> IWL_FIRST_OFDM_RATE; 972 /* 6M already there or needed so always add */ 973 ofdm |= IWL_RATE_6M_MASK >> IWL_FIRST_OFDM_RATE; 974 975 /* 976 * CCK is a bit more complex with DSSS vs. HR/DSSS vs. ERP. 977 * Note, however: 978 * - if no CCK rates are basic, it must be ERP since there must 979 * be some basic rates at all, so they're OFDM => ERP PHY 980 * (or we're in 5 GHz, and the cck bitmap will never be used) 981 * - if 11M is a basic rate, it must be ERP as well, so add 5.5M 982 * - if 5.5M is basic, 1M and 2M are mandatory 983 * - if 2M is basic, 1M is mandatory 984 * - if 1M is basic, that's the only valid ACK rate. 985 * As a consequence, it's not as complicated as it sounds, just add 986 * any lower rates to the ACK rate bitmap. 987 */ 988 if (IWL_RATE_11M_INDEX < lowest_present_cck) 989 cck |= IWL_RATE_11M_MASK >> IWL_FIRST_CCK_RATE; 990 if (IWL_RATE_5M_INDEX < lowest_present_cck) 991 cck |= IWL_RATE_5M_MASK >> IWL_FIRST_CCK_RATE; 992 if (IWL_RATE_2M_INDEX < lowest_present_cck) 993 cck |= IWL_RATE_2M_MASK >> IWL_FIRST_CCK_RATE; 994 /* 1M already there or needed so always add */ 995 cck |= IWL_RATE_1M_MASK >> IWL_FIRST_CCK_RATE; 996 997 IWL_DEBUG_RATE(priv, "Set basic rates cck:0x%.2x ofdm:0x%.2x\n", 998 cck, ofdm); 999 1000 /* "basic_rates" is a misnomer here -- should be called ACK rates */ 1001 ctx->staging.cck_basic_rates = cck; 1002 ctx->staging.ofdm_basic_rates = ofdm; 1003 } 1004 1005 /* 1006 * iwlagn_commit_rxon - commit staging_rxon to hardware 1007 * 1008 * The RXON command in staging_rxon is committed to the hardware and 1009 * the active_rxon structure is updated with the new data. This 1010 * function correctly transitions out of the RXON_ASSOC_MSK state if 1011 * a HW tune is required based on the RXON structure changes. 1012 * 1013 * The connect/disconnect flow should be as the following: 1014 * 1015 * 1. make sure send RXON command with association bit unset if not connect 1016 * this should include the channel and the band for the candidate 1017 * to be connected to 1018 * 2. Add Station before RXON association with the AP 1019 * 3. RXON_timing has to send before RXON for connection 1020 * 4. full RXON command - associated bit set 1021 * 5. use RXON_ASSOC command to update any flags changes 1022 */ 1023 int iwlagn_commit_rxon(struct iwl_priv *priv, struct iwl_rxon_context *ctx) 1024 { 1025 /* cast away the const for active_rxon in this function */ 1026 struct iwl_rxon_cmd *active = (void *)&ctx->active; 1027 bool new_assoc = !!(ctx->staging.filter_flags & RXON_FILTER_ASSOC_MSK); 1028 int ret; 1029 1030 lockdep_assert_held(&priv->mutex); 1031 1032 if (!iwl_is_alive(priv)) 1033 return -EBUSY; 1034 1035 /* This function hardcodes a bunch of dual-mode assumptions */ 1036 BUILD_BUG_ON(NUM_IWL_RXON_CTX != 2); 1037 1038 if (!ctx->is_active) 1039 return 0; 1040 1041 /* always get timestamp with Rx frame */ 1042 ctx->staging.flags |= RXON_FLG_TSF2HOST_MSK; 1043 1044 /* recalculate basic rates */ 1045 iwl_calc_basic_rates(priv, ctx); 1046 1047 /* 1048 * force CTS-to-self frames protection if RTS-CTS is not preferred 1049 * one aggregation protection method 1050 */ 1051 if (!priv->hw_params.use_rts_for_aggregation) 1052 ctx->staging.flags |= RXON_FLG_SELF_CTS_EN; 1053 1054 if ((ctx->vif && ctx->vif->bss_conf.use_short_slot) || 1055 !(ctx->staging.flags & RXON_FLG_BAND_24G_MSK)) 1056 ctx->staging.flags |= RXON_FLG_SHORT_SLOT_MSK; 1057 else 1058 ctx->staging.flags &= ~RXON_FLG_SHORT_SLOT_MSK; 1059 1060 iwl_print_rx_config_cmd(priv, ctx->ctxid); 1061 ret = iwl_check_rxon_cmd(priv, ctx); 1062 if (ret) { 1063 IWL_ERR(priv, "Invalid RXON configuration. Not committing.\n"); 1064 return -EINVAL; 1065 } 1066 1067 /* 1068 * receive commit_rxon request 1069 * abort any previous channel switch if still in process 1070 */ 1071 if (test_bit(STATUS_CHANNEL_SWITCH_PENDING, &priv->status) && 1072 (priv->switch_channel != ctx->staging.channel)) { 1073 IWL_DEBUG_11H(priv, "abort channel switch on %d\n", 1074 le16_to_cpu(priv->switch_channel)); 1075 iwl_chswitch_done(priv, false); 1076 } 1077 1078 /* 1079 * If we don't need to send a full RXON, we can use 1080 * iwl_rxon_assoc_cmd which is used to reconfigure filter 1081 * and other flags for the current radio configuration. 1082 */ 1083 if (!iwl_full_rxon_required(priv, ctx)) { 1084 ret = iwlagn_send_rxon_assoc(priv, ctx); 1085 if (ret) { 1086 IWL_ERR(priv, "Error setting RXON_ASSOC (%d)\n", ret); 1087 return ret; 1088 } 1089 1090 memcpy(active, &ctx->staging, sizeof(*active)); 1091 /* 1092 * We do not commit tx power settings while channel changing, 1093 * do it now if after settings changed. 1094 */ 1095 iwl_set_tx_power(priv, priv->tx_power_next, false); 1096 1097 /* make sure we are in the right PS state */ 1098 iwl_power_update_mode(priv, true); 1099 1100 return 0; 1101 } 1102 1103 iwl_set_rxon_hwcrypto(priv, ctx, !iwlwifi_mod_params.swcrypto); 1104 1105 IWL_DEBUG_INFO(priv, 1106 "Going to commit RXON\n" 1107 " * with%s RXON_FILTER_ASSOC_MSK\n" 1108 " * channel = %d\n" 1109 " * bssid = %pM\n", 1110 (new_assoc ? "" : "out"), 1111 le16_to_cpu(ctx->staging.channel), 1112 ctx->staging.bssid_addr); 1113 1114 /* 1115 * Always clear associated first, but with the correct config. 1116 * This is required as for example station addition for the 1117 * AP station must be done after the BSSID is set to correctly 1118 * set up filters in the device. 1119 */ 1120 ret = iwlagn_rxon_disconn(priv, ctx); 1121 if (ret) 1122 return ret; 1123 1124 ret = iwlagn_set_pan_params(priv); 1125 if (ret) 1126 return ret; 1127 1128 if (new_assoc) 1129 return iwlagn_rxon_connect(priv, ctx); 1130 1131 return 0; 1132 } 1133 1134 void iwlagn_config_ht40(struct ieee80211_conf *conf, 1135 struct iwl_rxon_context *ctx) 1136 { 1137 if (conf_is_ht40_minus(conf)) { 1138 ctx->ht.extension_chan_offset = 1139 IEEE80211_HT_PARAM_CHA_SEC_BELOW; 1140 ctx->ht.is_40mhz = true; 1141 } else if (conf_is_ht40_plus(conf)) { 1142 ctx->ht.extension_chan_offset = 1143 IEEE80211_HT_PARAM_CHA_SEC_ABOVE; 1144 ctx->ht.is_40mhz = true; 1145 } else { 1146 ctx->ht.extension_chan_offset = 1147 IEEE80211_HT_PARAM_CHA_SEC_NONE; 1148 ctx->ht.is_40mhz = false; 1149 } 1150 } 1151 1152 int iwlagn_mac_config(struct ieee80211_hw *hw, u32 changed) 1153 { 1154 struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw); 1155 struct iwl_rxon_context *ctx; 1156 struct ieee80211_conf *conf = &hw->conf; 1157 struct ieee80211_channel *channel = conf->chandef.chan; 1158 int ret = 0; 1159 1160 IWL_DEBUG_MAC80211(priv, "enter: changed %#x\n", changed); 1161 1162 mutex_lock(&priv->mutex); 1163 1164 if (unlikely(test_bit(STATUS_SCANNING, &priv->status))) { 1165 IWL_DEBUG_MAC80211(priv, "leave - scanning\n"); 1166 goto out; 1167 } 1168 1169 if (!iwl_is_ready(priv)) { 1170 IWL_DEBUG_MAC80211(priv, "leave - not ready\n"); 1171 goto out; 1172 } 1173 1174 if (changed & (IEEE80211_CONF_CHANGE_SMPS | 1175 IEEE80211_CONF_CHANGE_CHANNEL)) { 1176 /* mac80211 uses static for non-HT which is what we want */ 1177 priv->current_ht_config.smps = conf->smps_mode; 1178 1179 /* 1180 * Recalculate chain counts. 1181 * 1182 * If monitor mode is enabled then mac80211 will 1183 * set up the SM PS mode to OFF if an HT channel is 1184 * configured. 1185 */ 1186 for_each_context(priv, ctx) 1187 iwlagn_set_rxon_chain(priv, ctx); 1188 } 1189 1190 if (changed & IEEE80211_CONF_CHANGE_CHANNEL) { 1191 for_each_context(priv, ctx) { 1192 /* Configure HT40 channels */ 1193 if (ctx->ht.enabled != conf_is_ht(conf)) 1194 ctx->ht.enabled = conf_is_ht(conf); 1195 1196 if (ctx->ht.enabled) { 1197 /* if HT40 is used, it should not change 1198 * after associated except channel switch */ 1199 if (!ctx->ht.is_40mhz || 1200 !iwl_is_associated_ctx(ctx)) 1201 iwlagn_config_ht40(conf, ctx); 1202 } else 1203 ctx->ht.is_40mhz = false; 1204 1205 /* 1206 * Default to no protection. Protection mode will 1207 * later be set from BSS config in iwl_ht_conf 1208 */ 1209 ctx->ht.protection = IEEE80211_HT_OP_MODE_PROTECTION_NONE; 1210 1211 /* if we are switching from ht to 2.4 clear flags 1212 * from any ht related info since 2.4 does not 1213 * support ht */ 1214 if (le16_to_cpu(ctx->staging.channel) != 1215 channel->hw_value) 1216 ctx->staging.flags = 0; 1217 1218 iwl_set_rxon_channel(priv, channel, ctx); 1219 iwl_set_rxon_ht(priv, &priv->current_ht_config); 1220 1221 iwl_set_flags_for_band(priv, ctx, channel->band, 1222 ctx->vif); 1223 } 1224 1225 iwl_update_bcast_stations(priv); 1226 } 1227 1228 if (changed & (IEEE80211_CONF_CHANGE_PS | 1229 IEEE80211_CONF_CHANGE_IDLE)) { 1230 ret = iwl_power_update_mode(priv, false); 1231 if (ret) 1232 IWL_DEBUG_MAC80211(priv, "Error setting sleep level\n"); 1233 } 1234 1235 if (changed & IEEE80211_CONF_CHANGE_POWER) { 1236 IWL_DEBUG_MAC80211(priv, "TX Power old=%d new=%d\n", 1237 priv->tx_power_user_lmt, conf->power_level); 1238 1239 iwl_set_tx_power(priv, conf->power_level, false); 1240 } 1241 1242 for_each_context(priv, ctx) { 1243 if (!memcmp(&ctx->staging, &ctx->active, sizeof(ctx->staging))) 1244 continue; 1245 iwlagn_commit_rxon(priv, ctx); 1246 } 1247 out: 1248 mutex_unlock(&priv->mutex); 1249 IWL_DEBUG_MAC80211(priv, "leave\n"); 1250 1251 return ret; 1252 } 1253 1254 static void iwlagn_check_needed_chains(struct iwl_priv *priv, 1255 struct iwl_rxon_context *ctx, 1256 struct ieee80211_bss_conf *bss_conf) 1257 { 1258 struct ieee80211_vif *vif = ctx->vif; 1259 struct iwl_rxon_context *tmp; 1260 struct ieee80211_sta *sta; 1261 struct iwl_ht_config *ht_conf = &priv->current_ht_config; 1262 struct ieee80211_sta_ht_cap *ht_cap; 1263 bool need_multiple; 1264 1265 lockdep_assert_held(&priv->mutex); 1266 1267 switch (vif->type) { 1268 case NL80211_IFTYPE_STATION: 1269 rcu_read_lock(); 1270 sta = ieee80211_find_sta(vif, bss_conf->bssid); 1271 if (!sta) { 1272 /* 1273 * If at all, this can only happen through a race 1274 * when the AP disconnects us while we're still 1275 * setting up the connection, in that case mac80211 1276 * will soon tell us about that. 1277 */ 1278 need_multiple = false; 1279 rcu_read_unlock(); 1280 break; 1281 } 1282 1283 ht_cap = &sta->deflink.ht_cap; 1284 1285 need_multiple = true; 1286 1287 /* 1288 * If the peer advertises no support for receiving 2 and 3 1289 * stream MCS rates, it can't be transmitting them either. 1290 */ 1291 if (ht_cap->mcs.rx_mask[1] == 0 && 1292 ht_cap->mcs.rx_mask[2] == 0) { 1293 need_multiple = false; 1294 } else if (!(ht_cap->mcs.tx_params & 1295 IEEE80211_HT_MCS_TX_DEFINED)) { 1296 /* If it can't TX MCS at all ... */ 1297 need_multiple = false; 1298 } else if (ht_cap->mcs.tx_params & 1299 IEEE80211_HT_MCS_TX_RX_DIFF) { 1300 int maxstreams; 1301 1302 /* 1303 * But if it can receive them, it might still not 1304 * be able to transmit them, which is what we need 1305 * to check here -- so check the number of streams 1306 * it advertises for TX (if different from RX). 1307 */ 1308 1309 maxstreams = (ht_cap->mcs.tx_params & 1310 IEEE80211_HT_MCS_TX_MAX_STREAMS_MASK); 1311 maxstreams >>= 1312 IEEE80211_HT_MCS_TX_MAX_STREAMS_SHIFT; 1313 maxstreams += 1; 1314 1315 if (maxstreams <= 1) 1316 need_multiple = false; 1317 } 1318 1319 rcu_read_unlock(); 1320 break; 1321 case NL80211_IFTYPE_ADHOC: 1322 /* currently */ 1323 need_multiple = false; 1324 break; 1325 default: 1326 /* only AP really */ 1327 need_multiple = true; 1328 break; 1329 } 1330 1331 ctx->ht_need_multiple_chains = need_multiple; 1332 1333 if (!need_multiple) { 1334 /* check all contexts */ 1335 for_each_context(priv, tmp) { 1336 if (!tmp->vif) 1337 continue; 1338 if (tmp->ht_need_multiple_chains) { 1339 need_multiple = true; 1340 break; 1341 } 1342 } 1343 } 1344 1345 ht_conf->single_chain_sufficient = !need_multiple; 1346 } 1347 1348 static void iwlagn_chain_noise_reset(struct iwl_priv *priv) 1349 { 1350 struct iwl_chain_noise_data *data = &priv->chain_noise_data; 1351 int ret; 1352 1353 if (priv->calib_disabled & IWL_CHAIN_NOISE_CALIB_DISABLED) 1354 return; 1355 1356 if ((data->state == IWL_CHAIN_NOISE_ALIVE) && 1357 iwl_is_any_associated(priv)) { 1358 struct iwl_calib_chain_noise_reset_cmd cmd; 1359 1360 /* clear data for chain noise calibration algorithm */ 1361 data->chain_noise_a = 0; 1362 data->chain_noise_b = 0; 1363 data->chain_noise_c = 0; 1364 data->chain_signal_a = 0; 1365 data->chain_signal_b = 0; 1366 data->chain_signal_c = 0; 1367 data->beacon_count = 0; 1368 1369 memset(&cmd, 0, sizeof(cmd)); 1370 iwl_set_calib_hdr(&cmd.hdr, 1371 priv->phy_calib_chain_noise_reset_cmd); 1372 ret = iwl_dvm_send_cmd_pdu(priv, 1373 REPLY_PHY_CALIBRATION_CMD, 1374 0, sizeof(cmd), &cmd); 1375 if (ret) 1376 IWL_ERR(priv, 1377 "Could not send REPLY_PHY_CALIBRATION_CMD\n"); 1378 data->state = IWL_CHAIN_NOISE_ACCUMULATE; 1379 IWL_DEBUG_CALIB(priv, "Run chain_noise_calibrate\n"); 1380 } 1381 } 1382 1383 void iwlagn_bss_info_changed(struct ieee80211_hw *hw, 1384 struct ieee80211_vif *vif, 1385 struct ieee80211_bss_conf *bss_conf, 1386 u64 changes) 1387 { 1388 struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw); 1389 struct iwl_rxon_context *ctx = iwl_rxon_ctx_from_vif(vif); 1390 int ret; 1391 bool force = false; 1392 1393 mutex_lock(&priv->mutex); 1394 1395 if (changes & BSS_CHANGED_IDLE && vif->cfg.idle) { 1396 /* 1397 * If we go idle, then clearly no "passive-no-rx" 1398 * workaround is needed any more, this is a reset. 1399 */ 1400 iwlagn_lift_passive_no_rx(priv); 1401 } 1402 1403 if (unlikely(!iwl_is_ready(priv))) { 1404 IWL_DEBUG_MAC80211(priv, "leave - not ready\n"); 1405 mutex_unlock(&priv->mutex); 1406 return; 1407 } 1408 1409 if (unlikely(!ctx->vif)) { 1410 IWL_DEBUG_MAC80211(priv, "leave - vif is NULL\n"); 1411 mutex_unlock(&priv->mutex); 1412 return; 1413 } 1414 1415 if (changes & BSS_CHANGED_BEACON_INT) 1416 force = true; 1417 1418 if (changes & BSS_CHANGED_QOS) { 1419 ctx->qos_data.qos_active = bss_conf->qos; 1420 iwlagn_update_qos(priv, ctx); 1421 } 1422 1423 ctx->staging.assoc_id = cpu_to_le16(vif->cfg.aid); 1424 if (vif->bss_conf.use_short_preamble) 1425 ctx->staging.flags |= RXON_FLG_SHORT_PREAMBLE_MSK; 1426 else 1427 ctx->staging.flags &= ~RXON_FLG_SHORT_PREAMBLE_MSK; 1428 1429 if (changes & BSS_CHANGED_ASSOC) { 1430 if (vif->cfg.assoc) { 1431 priv->timestamp = bss_conf->sync_tsf; 1432 ctx->staging.filter_flags |= RXON_FILTER_ASSOC_MSK; 1433 } else { 1434 ctx->staging.filter_flags &= ~RXON_FILTER_ASSOC_MSK; 1435 1436 if (ctx->ctxid == IWL_RXON_CTX_BSS) 1437 priv->have_rekey_data = false; 1438 } 1439 1440 iwlagn_bt_coex_rssi_monitor(priv); 1441 } 1442 1443 if (ctx->ht.enabled) { 1444 ctx->ht.protection = bss_conf->ht_operation_mode & 1445 IEEE80211_HT_OP_MODE_PROTECTION; 1446 ctx->ht.non_gf_sta_present = !!(bss_conf->ht_operation_mode & 1447 IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT); 1448 iwlagn_check_needed_chains(priv, ctx, bss_conf); 1449 iwl_set_rxon_ht(priv, &priv->current_ht_config); 1450 } 1451 1452 iwlagn_set_rxon_chain(priv, ctx); 1453 1454 if (bss_conf->use_cts_prot && (priv->band != NL80211_BAND_5GHZ)) 1455 ctx->staging.flags |= RXON_FLG_TGG_PROTECT_MSK; 1456 else 1457 ctx->staging.flags &= ~RXON_FLG_TGG_PROTECT_MSK; 1458 1459 if (bss_conf->use_cts_prot) 1460 ctx->staging.flags |= RXON_FLG_SELF_CTS_EN; 1461 else 1462 ctx->staging.flags &= ~RXON_FLG_SELF_CTS_EN; 1463 1464 memcpy(ctx->staging.bssid_addr, bss_conf->bssid, ETH_ALEN); 1465 1466 if (vif->type == NL80211_IFTYPE_AP || 1467 vif->type == NL80211_IFTYPE_ADHOC) { 1468 if (vif->bss_conf.enable_beacon) { 1469 ctx->staging.filter_flags |= RXON_FILTER_ASSOC_MSK; 1470 priv->beacon_ctx = ctx; 1471 } else { 1472 ctx->staging.filter_flags &= ~RXON_FILTER_ASSOC_MSK; 1473 priv->beacon_ctx = NULL; 1474 } 1475 } 1476 1477 /* 1478 * If the ucode decides to do beacon filtering before 1479 * association, it will lose beacons that are needed 1480 * before sending frames out on passive channels. This 1481 * causes association failures on those channels. Enable 1482 * receiving beacons in such cases. 1483 */ 1484 1485 if (vif->type == NL80211_IFTYPE_STATION) { 1486 if (!vif->cfg.assoc) 1487 ctx->staging.filter_flags |= RXON_FILTER_BCON_AWARE_MSK; 1488 else 1489 ctx->staging.filter_flags &= 1490 ~RXON_FILTER_BCON_AWARE_MSK; 1491 } 1492 1493 if (force || memcmp(&ctx->staging, &ctx->active, sizeof(ctx->staging))) 1494 iwlagn_commit_rxon(priv, ctx); 1495 1496 if (changes & BSS_CHANGED_ASSOC && vif->cfg.assoc) { 1497 /* 1498 * The chain noise calibration will enable PM upon 1499 * completion. If calibration has already been run 1500 * then we need to enable power management here. 1501 */ 1502 if (priv->chain_noise_data.state == IWL_CHAIN_NOISE_DONE) 1503 iwl_power_update_mode(priv, false); 1504 1505 /* Enable RX differential gain and sensitivity calibrations */ 1506 iwlagn_chain_noise_reset(priv); 1507 priv->start_calib = 1; 1508 } 1509 1510 if (changes & BSS_CHANGED_IBSS) { 1511 ret = iwlagn_manage_ibss_station(priv, vif, 1512 vif->cfg.ibss_joined); 1513 if (ret) 1514 IWL_ERR(priv, "failed to %s IBSS station %pM\n", 1515 vif->cfg.ibss_joined ? "add" : "remove", 1516 bss_conf->bssid); 1517 } 1518 1519 if (changes & BSS_CHANGED_BEACON && priv->beacon_ctx == ctx) { 1520 if (iwlagn_update_beacon(priv, vif)) 1521 IWL_ERR(priv, "Error updating beacon\n"); 1522 } 1523 1524 mutex_unlock(&priv->mutex); 1525 } 1526 1527 void iwlagn_post_scan(struct iwl_priv *priv) 1528 { 1529 struct iwl_rxon_context *ctx; 1530 1531 /* 1532 * We do not commit power settings while scan is pending, 1533 * do it now if the settings changed. 1534 */ 1535 iwl_power_set_mode(priv, &priv->power_data.sleep_cmd_next, false); 1536 iwl_set_tx_power(priv, priv->tx_power_next, false); 1537 1538 /* 1539 * Since setting the RXON may have been deferred while 1540 * performing the scan, fire one off if needed 1541 */ 1542 for_each_context(priv, ctx) 1543 if (memcmp(&ctx->staging, &ctx->active, sizeof(ctx->staging))) 1544 iwlagn_commit_rxon(priv, ctx); 1545 1546 iwlagn_set_pan_params(priv); 1547 } 1548