1/****************************************************************************** 2 * 3 * Copyright(c) 2008 - 2014 Intel Corporation. All rights reserved. 4 * 5 * This program is free software; you can redistribute it and/or modify it 6 * under the terms of version 2 of the GNU General Public License as 7 * published by the Free Software Foundation. 8 * 9 * This program is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 12 * more details. 13 * 14 * You should have received a copy of the GNU General Public License along with 15 * this program; if not, write to the Free Software Foundation, Inc., 16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA 17 * 18 * The full GNU General Public License is included in this distribution in the 19 * file called LICENSE. 20 * 21 * Contact Information: 22 * Intel Linux Wireless <ilw@linux.intel.com> 23 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497 24 * 25 *****************************************************************************/ 26 27/* 28 * DVM device-specific data & functions 29 */ 30#include "iwl-io.h" 31#include "iwl-prph.h" 32#include "iwl-eeprom-parse.h" 33 34#include "agn.h" 35#include "dev.h" 36#include "commands.h" 37 38 39/* 40 * 1000 series 41 * =========== 42 */ 43 44/* 45 * For 1000, use advance thermal throttling critical temperature threshold, 46 * but legacy thermal management implementation for now. 47 * This is for the reason of 1000 uCode using advance thermal throttling API 48 * but not implement ct_kill_exit based on ct_kill exit temperature 49 * so the thermal throttling will still based on legacy thermal throttling 50 * management. 51 * The code here need to be modified once 1000 uCode has the advanced thermal 52 * throttling algorithm in place 53 */ 54static void iwl1000_set_ct_threshold(struct iwl_priv *priv) 55{ 56 /* want Celsius */ 57 priv->hw_params.ct_kill_threshold = CT_KILL_THRESHOLD_LEGACY; 58 priv->hw_params.ct_kill_exit_threshold = CT_KILL_EXIT_THRESHOLD; 59} 60 61/* NIC configuration for 1000 series */ 62static void iwl1000_nic_config(struct iwl_priv *priv) 63{ 64 /* Setting digital SVR for 1000 card to 1.32V */ 65 /* locking is acquired in iwl_set_bits_mask_prph() function */ 66 iwl_set_bits_mask_prph(priv->trans, APMG_DIGITAL_SVR_REG, 67 APMG_SVR_DIGITAL_VOLTAGE_1_32, 68 ~APMG_SVR_VOLTAGE_CONFIG_BIT_MSK); 69} 70 71/** 72 * iwl_beacon_time_mask_low - mask of lower 32 bit of beacon time 73 * @priv -- pointer to iwl_priv data structure 74 * @tsf_bits -- number of bits need to shift for masking) 75 */ 76static inline u32 iwl_beacon_time_mask_low(struct iwl_priv *priv, 77 u16 tsf_bits) 78{ 79 return (1 << tsf_bits) - 1; 80} 81 82/** 83 * iwl_beacon_time_mask_high - mask of higher 32 bit of beacon time 84 * @priv -- pointer to iwl_priv data structure 85 * @tsf_bits -- number of bits need to shift for masking) 86 */ 87static inline u32 iwl_beacon_time_mask_high(struct iwl_priv *priv, 88 u16 tsf_bits) 89{ 90 return ((1 << (32 - tsf_bits)) - 1) << tsf_bits; 91} 92 93/* 94 * extended beacon time format 95 * time in usec will be changed into a 32-bit value in extended:internal format 96 * the extended part is the beacon counts 97 * the internal part is the time in usec within one beacon interval 98 */ 99static u32 iwl_usecs_to_beacons(struct iwl_priv *priv, u32 usec, 100 u32 beacon_interval) 101{ 102 u32 quot; 103 u32 rem; 104 u32 interval = beacon_interval * TIME_UNIT; 105 106 if (!interval || !usec) 107 return 0; 108 109 quot = (usec / interval) & 110 (iwl_beacon_time_mask_high(priv, IWLAGN_EXT_BEACON_TIME_POS) >> 111 IWLAGN_EXT_BEACON_TIME_POS); 112 rem = (usec % interval) & iwl_beacon_time_mask_low(priv, 113 IWLAGN_EXT_BEACON_TIME_POS); 114 115 return (quot << IWLAGN_EXT_BEACON_TIME_POS) + rem; 116} 117 118/* base is usually what we get from ucode with each received frame, 119 * the same as HW timer counter counting down 120 */ 121static __le32 iwl_add_beacon_time(struct iwl_priv *priv, u32 base, 122 u32 addon, u32 beacon_interval) 123{ 124 u32 base_low = base & iwl_beacon_time_mask_low(priv, 125 IWLAGN_EXT_BEACON_TIME_POS); 126 u32 addon_low = addon & iwl_beacon_time_mask_low(priv, 127 IWLAGN_EXT_BEACON_TIME_POS); 128 u32 interval = beacon_interval * TIME_UNIT; 129 u32 res = (base & iwl_beacon_time_mask_high(priv, 130 IWLAGN_EXT_BEACON_TIME_POS)) + 131 (addon & iwl_beacon_time_mask_high(priv, 132 IWLAGN_EXT_BEACON_TIME_POS)); 133 134 if (base_low > addon_low) 135 res += base_low - addon_low; 136 else if (base_low < addon_low) { 137 res += interval + base_low - addon_low; 138 res += (1 << IWLAGN_EXT_BEACON_TIME_POS); 139 } else 140 res += (1 << IWLAGN_EXT_BEACON_TIME_POS); 141 142 return cpu_to_le32(res); 143} 144 145static const struct iwl_sensitivity_ranges iwl1000_sensitivity = { 146 .min_nrg_cck = 95, 147 .auto_corr_min_ofdm = 90, 148 .auto_corr_min_ofdm_mrc = 170, 149 .auto_corr_min_ofdm_x1 = 120, 150 .auto_corr_min_ofdm_mrc_x1 = 240, 151 152 .auto_corr_max_ofdm = 120, 153 .auto_corr_max_ofdm_mrc = 210, 154 .auto_corr_max_ofdm_x1 = 155, 155 .auto_corr_max_ofdm_mrc_x1 = 290, 156 157 .auto_corr_min_cck = 125, 158 .auto_corr_max_cck = 200, 159 .auto_corr_min_cck_mrc = 170, 160 .auto_corr_max_cck_mrc = 400, 161 .nrg_th_cck = 95, 162 .nrg_th_ofdm = 95, 163 164 .barker_corr_th_min = 190, 165 .barker_corr_th_min_mrc = 390, 166 .nrg_th_cca = 62, 167}; 168 169static void iwl1000_hw_set_hw_params(struct iwl_priv *priv) 170{ 171 iwl1000_set_ct_threshold(priv); 172 173 /* Set initial sensitivity parameters */ 174 priv->hw_params.sens = &iwl1000_sensitivity; 175} 176 177const struct iwl_dvm_cfg iwl_dvm_1000_cfg = { 178 .set_hw_params = iwl1000_hw_set_hw_params, 179 .nic_config = iwl1000_nic_config, 180 .temperature = iwlagn_temperature, 181 .support_ct_kill_exit = true, 182 .plcp_delta_threshold = IWL_MAX_PLCP_ERR_EXT_LONG_THRESHOLD_DEF, 183 .chain_noise_scale = 1000, 184}; 185 186 187/* 188 * 2000 series 189 * =========== 190 */ 191 192static void iwl2000_set_ct_threshold(struct iwl_priv *priv) 193{ 194 /* want Celsius */ 195 priv->hw_params.ct_kill_threshold = CT_KILL_THRESHOLD; 196 priv->hw_params.ct_kill_exit_threshold = CT_KILL_EXIT_THRESHOLD; 197} 198 199/* NIC configuration for 2000 series */ 200static void iwl2000_nic_config(struct iwl_priv *priv) 201{ 202 iwl_set_bit(priv->trans, CSR_GP_DRIVER_REG, 203 CSR_GP_DRIVER_REG_BIT_RADIO_IQ_INVER); 204} 205 206static const struct iwl_sensitivity_ranges iwl2000_sensitivity = { 207 .min_nrg_cck = 97, 208 .auto_corr_min_ofdm = 80, 209 .auto_corr_min_ofdm_mrc = 128, 210 .auto_corr_min_ofdm_x1 = 105, 211 .auto_corr_min_ofdm_mrc_x1 = 192, 212 213 .auto_corr_max_ofdm = 145, 214 .auto_corr_max_ofdm_mrc = 232, 215 .auto_corr_max_ofdm_x1 = 110, 216 .auto_corr_max_ofdm_mrc_x1 = 232, 217 218 .auto_corr_min_cck = 125, 219 .auto_corr_max_cck = 175, 220 .auto_corr_min_cck_mrc = 160, 221 .auto_corr_max_cck_mrc = 310, 222 .nrg_th_cck = 97, 223 .nrg_th_ofdm = 100, 224 225 .barker_corr_th_min = 190, 226 .barker_corr_th_min_mrc = 390, 227 .nrg_th_cca = 62, 228}; 229 230static void iwl2000_hw_set_hw_params(struct iwl_priv *priv) 231{ 232 iwl2000_set_ct_threshold(priv); 233 234 /* Set initial sensitivity parameters */ 235 priv->hw_params.sens = &iwl2000_sensitivity; 236} 237 238const struct iwl_dvm_cfg iwl_dvm_2000_cfg = { 239 .set_hw_params = iwl2000_hw_set_hw_params, 240 .nic_config = iwl2000_nic_config, 241 .temperature = iwlagn_temperature, 242 .adv_thermal_throttle = true, 243 .support_ct_kill_exit = true, 244 .plcp_delta_threshold = IWL_MAX_PLCP_ERR_THRESHOLD_DEF, 245 .chain_noise_scale = 1000, 246 .hd_v2 = true, 247 .need_temp_offset_calib = true, 248 .temp_offset_v2 = true, 249}; 250 251const struct iwl_dvm_cfg iwl_dvm_105_cfg = { 252 .set_hw_params = iwl2000_hw_set_hw_params, 253 .nic_config = iwl2000_nic_config, 254 .temperature = iwlagn_temperature, 255 .adv_thermal_throttle = true, 256 .support_ct_kill_exit = true, 257 .plcp_delta_threshold = IWL_MAX_PLCP_ERR_THRESHOLD_DEF, 258 .chain_noise_scale = 1000, 259 .hd_v2 = true, 260 .need_temp_offset_calib = true, 261 .temp_offset_v2 = true, 262 .adv_pm = true, 263}; 264 265static const struct iwl_dvm_bt_params iwl2030_bt_params = { 266 /* Due to bluetooth, we transmit 2.4 GHz probes only on antenna A */ 267 .advanced_bt_coexist = true, 268 .agg_time_limit = BT_AGG_THRESHOLD_DEF, 269 .bt_init_traffic_load = IWL_BT_COEX_TRAFFIC_LOAD_NONE, 270 .bt_prio_boost = IWLAGN_BT_PRIO_BOOST_DEFAULT32, 271 .bt_sco_disable = true, 272 .bt_session_2 = true, 273}; 274 275const struct iwl_dvm_cfg iwl_dvm_2030_cfg = { 276 .set_hw_params = iwl2000_hw_set_hw_params, 277 .nic_config = iwl2000_nic_config, 278 .temperature = iwlagn_temperature, 279 .adv_thermal_throttle = true, 280 .support_ct_kill_exit = true, 281 .plcp_delta_threshold = IWL_MAX_PLCP_ERR_THRESHOLD_DEF, 282 .chain_noise_scale = 1000, 283 .hd_v2 = true, 284 .bt_params = &iwl2030_bt_params, 285 .need_temp_offset_calib = true, 286 .temp_offset_v2 = true, 287 .adv_pm = true, 288}; 289 290/* 291 * 5000 series 292 * =========== 293 */ 294 295/* NIC configuration for 5000 series */ 296static const struct iwl_sensitivity_ranges iwl5000_sensitivity = { 297 .min_nrg_cck = 100, 298 .auto_corr_min_ofdm = 90, 299 .auto_corr_min_ofdm_mrc = 170, 300 .auto_corr_min_ofdm_x1 = 105, 301 .auto_corr_min_ofdm_mrc_x1 = 220, 302 303 .auto_corr_max_ofdm = 120, 304 .auto_corr_max_ofdm_mrc = 210, 305 .auto_corr_max_ofdm_x1 = 120, 306 .auto_corr_max_ofdm_mrc_x1 = 240, 307 308 .auto_corr_min_cck = 125, 309 .auto_corr_max_cck = 200, 310 .auto_corr_min_cck_mrc = 200, 311 .auto_corr_max_cck_mrc = 400, 312 .nrg_th_cck = 100, 313 .nrg_th_ofdm = 100, 314 315 .barker_corr_th_min = 190, 316 .barker_corr_th_min_mrc = 390, 317 .nrg_th_cca = 62, 318}; 319 320static const struct iwl_sensitivity_ranges iwl5150_sensitivity = { 321 .min_nrg_cck = 95, 322 .auto_corr_min_ofdm = 90, 323 .auto_corr_min_ofdm_mrc = 170, 324 .auto_corr_min_ofdm_x1 = 105, 325 .auto_corr_min_ofdm_mrc_x1 = 220, 326 327 .auto_corr_max_ofdm = 120, 328 .auto_corr_max_ofdm_mrc = 210, 329 /* max = min for performance bug in 5150 DSP */ 330 .auto_corr_max_ofdm_x1 = 105, 331 .auto_corr_max_ofdm_mrc_x1 = 220, 332 333 .auto_corr_min_cck = 125, 334 .auto_corr_max_cck = 200, 335 .auto_corr_min_cck_mrc = 170, 336 .auto_corr_max_cck_mrc = 400, 337 .nrg_th_cck = 95, 338 .nrg_th_ofdm = 95, 339 340 .barker_corr_th_min = 190, 341 .barker_corr_th_min_mrc = 390, 342 .nrg_th_cca = 62, 343}; 344 345#define IWL_5150_VOLTAGE_TO_TEMPERATURE_COEFF (-5) 346 347static s32 iwl_temp_calib_to_offset(struct iwl_priv *priv) 348{ 349 u16 temperature, voltage; 350 351 temperature = le16_to_cpu(priv->nvm_data->kelvin_temperature); 352 voltage = le16_to_cpu(priv->nvm_data->kelvin_voltage); 353 354 /* offset = temp - volt / coeff */ 355 return (s32)(temperature - 356 voltage / IWL_5150_VOLTAGE_TO_TEMPERATURE_COEFF); 357} 358 359static void iwl5150_set_ct_threshold(struct iwl_priv *priv) 360{ 361 const s32 volt2temp_coef = IWL_5150_VOLTAGE_TO_TEMPERATURE_COEFF; 362 s32 threshold = (s32)CELSIUS_TO_KELVIN(CT_KILL_THRESHOLD_LEGACY) - 363 iwl_temp_calib_to_offset(priv); 364 365 priv->hw_params.ct_kill_threshold = threshold * volt2temp_coef; 366} 367 368static void iwl5000_set_ct_threshold(struct iwl_priv *priv) 369{ 370 /* want Celsius */ 371 priv->hw_params.ct_kill_threshold = CT_KILL_THRESHOLD_LEGACY; 372} 373 374static void iwl5000_hw_set_hw_params(struct iwl_priv *priv) 375{ 376 iwl5000_set_ct_threshold(priv); 377 378 /* Set initial sensitivity parameters */ 379 priv->hw_params.sens = &iwl5000_sensitivity; 380} 381 382static void iwl5150_hw_set_hw_params(struct iwl_priv *priv) 383{ 384 iwl5150_set_ct_threshold(priv); 385 386 /* Set initial sensitivity parameters */ 387 priv->hw_params.sens = &iwl5150_sensitivity; 388} 389 390static void iwl5150_temperature(struct iwl_priv *priv) 391{ 392 u32 vt = 0; 393 s32 offset = iwl_temp_calib_to_offset(priv); 394 395 vt = le32_to_cpu(priv->statistics.common.temperature); 396 vt = vt / IWL_5150_VOLTAGE_TO_TEMPERATURE_COEFF + offset; 397 /* now vt hold the temperature in Kelvin */ 398 priv->temperature = KELVIN_TO_CELSIUS(vt); 399 iwl_tt_handler(priv); 400} 401 402static int iwl5000_hw_channel_switch(struct iwl_priv *priv, 403 struct ieee80211_channel_switch *ch_switch) 404{ 405 /* 406 * MULTI-FIXME 407 * See iwlagn_mac_channel_switch. 408 */ 409 struct iwl_rxon_context *ctx = &priv->contexts[IWL_RXON_CTX_BSS]; 410 struct iwl5000_channel_switch_cmd cmd; 411 u32 switch_time_in_usec, ucode_switch_time; 412 u16 ch; 413 u32 tsf_low; 414 u8 switch_count; 415 u16 beacon_interval = le16_to_cpu(ctx->timing.beacon_interval); 416 struct ieee80211_vif *vif = ctx->vif; 417 struct iwl_host_cmd hcmd = { 418 .id = REPLY_CHANNEL_SWITCH, 419 .len = { sizeof(cmd), }, 420 .data = { &cmd, }, 421 }; 422 423 cmd.band = priv->band == IEEE80211_BAND_2GHZ; 424 ch = ch_switch->chandef.chan->hw_value; 425 IWL_DEBUG_11H(priv, "channel switch from %d to %d\n", 426 ctx->active.channel, ch); 427 cmd.channel = cpu_to_le16(ch); 428 cmd.rxon_flags = ctx->staging.flags; 429 cmd.rxon_filter_flags = ctx->staging.filter_flags; 430 switch_count = ch_switch->count; 431 tsf_low = ch_switch->timestamp & 0x0ffffffff; 432 /* 433 * calculate the ucode channel switch time 434 * adding TSF as one of the factor for when to switch 435 */ 436 if ((priv->ucode_beacon_time > tsf_low) && beacon_interval) { 437 if (switch_count > ((priv->ucode_beacon_time - tsf_low) / 438 beacon_interval)) { 439 switch_count -= (priv->ucode_beacon_time - 440 tsf_low) / beacon_interval; 441 } else 442 switch_count = 0; 443 } 444 if (switch_count <= 1) 445 cmd.switch_time = cpu_to_le32(priv->ucode_beacon_time); 446 else { 447 switch_time_in_usec = 448 vif->bss_conf.beacon_int * switch_count * TIME_UNIT; 449 ucode_switch_time = iwl_usecs_to_beacons(priv, 450 switch_time_in_usec, 451 beacon_interval); 452 cmd.switch_time = iwl_add_beacon_time(priv, 453 priv->ucode_beacon_time, 454 ucode_switch_time, 455 beacon_interval); 456 } 457 IWL_DEBUG_11H(priv, "uCode time for the switch is 0x%x\n", 458 cmd.switch_time); 459 cmd.expect_beacon = 460 ch_switch->chandef.chan->flags & IEEE80211_CHAN_RADAR; 461 462 return iwl_dvm_send_cmd(priv, &hcmd); 463} 464 465const struct iwl_dvm_cfg iwl_dvm_5000_cfg = { 466 .set_hw_params = iwl5000_hw_set_hw_params, 467 .set_channel_switch = iwl5000_hw_channel_switch, 468 .temperature = iwlagn_temperature, 469 .plcp_delta_threshold = IWL_MAX_PLCP_ERR_LONG_THRESHOLD_DEF, 470 .chain_noise_scale = 1000, 471 .no_idle_support = true, 472}; 473 474const struct iwl_dvm_cfg iwl_dvm_5150_cfg = { 475 .set_hw_params = iwl5150_hw_set_hw_params, 476 .set_channel_switch = iwl5000_hw_channel_switch, 477 .temperature = iwl5150_temperature, 478 .plcp_delta_threshold = IWL_MAX_PLCP_ERR_LONG_THRESHOLD_DEF, 479 .chain_noise_scale = 1000, 480 .no_idle_support = true, 481 .no_xtal_calib = true, 482}; 483 484 485 486/* 487 * 6000 series 488 * =========== 489 */ 490 491static void iwl6000_set_ct_threshold(struct iwl_priv *priv) 492{ 493 /* want Celsius */ 494 priv->hw_params.ct_kill_threshold = CT_KILL_THRESHOLD; 495 priv->hw_params.ct_kill_exit_threshold = CT_KILL_EXIT_THRESHOLD; 496} 497 498/* NIC configuration for 6000 series */ 499static void iwl6000_nic_config(struct iwl_priv *priv) 500{ 501 switch (priv->cfg->device_family) { 502 case IWL_DEVICE_FAMILY_6005: 503 case IWL_DEVICE_FAMILY_6030: 504 case IWL_DEVICE_FAMILY_6000: 505 break; 506 case IWL_DEVICE_FAMILY_6000i: 507 /* 2x2 IPA phy type */ 508 iwl_write32(priv->trans, CSR_GP_DRIVER_REG, 509 CSR_GP_DRIVER_REG_BIT_RADIO_SKU_2x2_IPA); 510 break; 511 case IWL_DEVICE_FAMILY_6050: 512 /* Indicate calibration version to uCode. */ 513 if (priv->nvm_data->calib_version >= 6) 514 iwl_set_bit(priv->trans, CSR_GP_DRIVER_REG, 515 CSR_GP_DRIVER_REG_BIT_CALIB_VERSION6); 516 break; 517 case IWL_DEVICE_FAMILY_6150: 518 /* Indicate calibration version to uCode. */ 519 if (priv->nvm_data->calib_version >= 6) 520 iwl_set_bit(priv->trans, CSR_GP_DRIVER_REG, 521 CSR_GP_DRIVER_REG_BIT_CALIB_VERSION6); 522 iwl_set_bit(priv->trans, CSR_GP_DRIVER_REG, 523 CSR_GP_DRIVER_REG_BIT_6050_1x2); 524 break; 525 default: 526 WARN_ON(1); 527 } 528} 529 530static const struct iwl_sensitivity_ranges iwl6000_sensitivity = { 531 .min_nrg_cck = 110, 532 .auto_corr_min_ofdm = 80, 533 .auto_corr_min_ofdm_mrc = 128, 534 .auto_corr_min_ofdm_x1 = 105, 535 .auto_corr_min_ofdm_mrc_x1 = 192, 536 537 .auto_corr_max_ofdm = 145, 538 .auto_corr_max_ofdm_mrc = 232, 539 .auto_corr_max_ofdm_x1 = 110, 540 .auto_corr_max_ofdm_mrc_x1 = 232, 541 542 .auto_corr_min_cck = 125, 543 .auto_corr_max_cck = 175, 544 .auto_corr_min_cck_mrc = 160, 545 .auto_corr_max_cck_mrc = 310, 546 .nrg_th_cck = 110, 547 .nrg_th_ofdm = 110, 548 549 .barker_corr_th_min = 190, 550 .barker_corr_th_min_mrc = 336, 551 .nrg_th_cca = 62, 552}; 553 554static void iwl6000_hw_set_hw_params(struct iwl_priv *priv) 555{ 556 iwl6000_set_ct_threshold(priv); 557 558 /* Set initial sensitivity parameters */ 559 priv->hw_params.sens = &iwl6000_sensitivity; 560 561} 562 563static int iwl6000_hw_channel_switch(struct iwl_priv *priv, 564 struct ieee80211_channel_switch *ch_switch) 565{ 566 /* 567 * MULTI-FIXME 568 * See iwlagn_mac_channel_switch. 569 */ 570 struct iwl_rxon_context *ctx = &priv->contexts[IWL_RXON_CTX_BSS]; 571 struct iwl6000_channel_switch_cmd *cmd; 572 u32 switch_time_in_usec, ucode_switch_time; 573 u16 ch; 574 u32 tsf_low; 575 u8 switch_count; 576 u16 beacon_interval = le16_to_cpu(ctx->timing.beacon_interval); 577 struct ieee80211_vif *vif = ctx->vif; 578 struct iwl_host_cmd hcmd = { 579 .id = REPLY_CHANNEL_SWITCH, 580 .len = { sizeof(*cmd), }, 581 .dataflags[0] = IWL_HCMD_DFL_NOCOPY, 582 }; 583 int err; 584 585 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 586 if (!cmd) 587 return -ENOMEM; 588 589 hcmd.data[0] = cmd; 590 591 cmd->band = priv->band == IEEE80211_BAND_2GHZ; 592 ch = ch_switch->chandef.chan->hw_value; 593 IWL_DEBUG_11H(priv, "channel switch from %u to %u\n", 594 ctx->active.channel, ch); 595 cmd->channel = cpu_to_le16(ch); 596 cmd->rxon_flags = ctx->staging.flags; 597 cmd->rxon_filter_flags = ctx->staging.filter_flags; 598 switch_count = ch_switch->count; 599 tsf_low = ch_switch->timestamp & 0x0ffffffff; 600 /* 601 * calculate the ucode channel switch time 602 * adding TSF as one of the factor for when to switch 603 */ 604 if ((priv->ucode_beacon_time > tsf_low) && beacon_interval) { 605 if (switch_count > ((priv->ucode_beacon_time - tsf_low) / 606 beacon_interval)) { 607 switch_count -= (priv->ucode_beacon_time - 608 tsf_low) / beacon_interval; 609 } else 610 switch_count = 0; 611 } 612 if (switch_count <= 1) 613 cmd->switch_time = cpu_to_le32(priv->ucode_beacon_time); 614 else { 615 switch_time_in_usec = 616 vif->bss_conf.beacon_int * switch_count * TIME_UNIT; 617 ucode_switch_time = iwl_usecs_to_beacons(priv, 618 switch_time_in_usec, 619 beacon_interval); 620 cmd->switch_time = iwl_add_beacon_time(priv, 621 priv->ucode_beacon_time, 622 ucode_switch_time, 623 beacon_interval); 624 } 625 IWL_DEBUG_11H(priv, "uCode time for the switch is 0x%x\n", 626 cmd->switch_time); 627 cmd->expect_beacon = 628 ch_switch->chandef.chan->flags & IEEE80211_CHAN_RADAR; 629 630 err = iwl_dvm_send_cmd(priv, &hcmd); 631 kfree(cmd); 632 return err; 633} 634 635const struct iwl_dvm_cfg iwl_dvm_6000_cfg = { 636 .set_hw_params = iwl6000_hw_set_hw_params, 637 .set_channel_switch = iwl6000_hw_channel_switch, 638 .nic_config = iwl6000_nic_config, 639 .temperature = iwlagn_temperature, 640 .adv_thermal_throttle = true, 641 .support_ct_kill_exit = true, 642 .plcp_delta_threshold = IWL_MAX_PLCP_ERR_THRESHOLD_DEF, 643 .chain_noise_scale = 1000, 644}; 645 646const struct iwl_dvm_cfg iwl_dvm_6005_cfg = { 647 .set_hw_params = iwl6000_hw_set_hw_params, 648 .set_channel_switch = iwl6000_hw_channel_switch, 649 .nic_config = iwl6000_nic_config, 650 .temperature = iwlagn_temperature, 651 .adv_thermal_throttle = true, 652 .support_ct_kill_exit = true, 653 .plcp_delta_threshold = IWL_MAX_PLCP_ERR_THRESHOLD_DEF, 654 .chain_noise_scale = 1000, 655 .need_temp_offset_calib = true, 656}; 657 658const struct iwl_dvm_cfg iwl_dvm_6050_cfg = { 659 .set_hw_params = iwl6000_hw_set_hw_params, 660 .set_channel_switch = iwl6000_hw_channel_switch, 661 .nic_config = iwl6000_nic_config, 662 .temperature = iwlagn_temperature, 663 .adv_thermal_throttle = true, 664 .support_ct_kill_exit = true, 665 .plcp_delta_threshold = IWL_MAX_PLCP_ERR_THRESHOLD_DEF, 666 .chain_noise_scale = 1500, 667}; 668 669static const struct iwl_dvm_bt_params iwl6000_bt_params = { 670 /* Due to bluetooth, we transmit 2.4 GHz probes only on antenna A */ 671 .advanced_bt_coexist = true, 672 .agg_time_limit = BT_AGG_THRESHOLD_DEF, 673 .bt_init_traffic_load = IWL_BT_COEX_TRAFFIC_LOAD_NONE, 674 .bt_prio_boost = IWLAGN_BT_PRIO_BOOST_DEFAULT, 675 .bt_sco_disable = true, 676}; 677 678const struct iwl_dvm_cfg iwl_dvm_6030_cfg = { 679 .set_hw_params = iwl6000_hw_set_hw_params, 680 .set_channel_switch = iwl6000_hw_channel_switch, 681 .nic_config = iwl6000_nic_config, 682 .temperature = iwlagn_temperature, 683 .adv_thermal_throttle = true, 684 .support_ct_kill_exit = true, 685 .plcp_delta_threshold = IWL_MAX_PLCP_ERR_THRESHOLD_DEF, 686 .chain_noise_scale = 1000, 687 .bt_params = &iwl6000_bt_params, 688 .need_temp_offset_calib = true, 689 .adv_pm = true, 690}; 691