drivers/net/wireless/iwlwifi/iwl-core.c

   1 /******************************************************************************
   2  *
   3  * GPL LICENSE SUMMARY
   4  *
   5  * Copyright(c) 2008 Intel Corporation. All rights reserved.
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of version 2 of the GNU General Public License as
   9  * published by the Free Software Foundation.
  10  *
  11  * This program is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
  19  * USA
  20  *
  21  * The full GNU General Public License is included in this distribution
  22  * in the file called LICENSE.GPL.
  23  *
  24  * Contact Information:
  25  * Tomas Winkler <tomas.winkler@intel.com>
  26  * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
  27  *****************************************************************************/
  28
  29 #include <linux/kernel.h>
  30 #include <linux/module.h>
  31 #include <linux/version.h>
  32 #include <net/mac80211.h>
  33
  34 struct iwl_priv; /* FIXME: remove */
  35 #include "iwl-debug.h"
  36 #include "iwl-eeprom.h"
  37 #include "iwl-dev.h" /* FIXME: remove */
  38 #include "iwl-core.h"
  39 #include "iwl-io.h"
  40 #include "iwl-rfkill.h"
  41 #include "iwl-power.h"
  42
  43
  44 MODULE_DESCRIPTION("iwl core");
  45 MODULE_VERSION(IWLWIFI_VERSION);
  46 MODULE_AUTHOR(DRV_COPYRIGHT);
  47 MODULE_LICENSE("GPL");
  48
  49 #ifdef CONFIG_IWLWIFI_DEBUG
  50 u32 iwl_debug_level;
  51 EXPORT_SYMBOL(iwl_debug_level);
  52 #endif
  53
  54 #define IWL_DECLARE_RATE_INFO(r, s, ip, in, rp, rn, pp, np)    \
  55         [IWL_RATE_##r##M_INDEX] = { IWL_RATE_##r##M_PLCP,      \
  56                                     IWL_RATE_SISO_##s##M_PLCP, \
  57                                     IWL_RATE_MIMO2_##s##M_PLCP,\
  58                                     IWL_RATE_MIMO3_##s##M_PLCP,\
  59                                     IWL_RATE_##r##M_IEEE,      \
  60                                     IWL_RATE_##ip##M_INDEX,    \
  61                                     IWL_RATE_##in##M_INDEX,    \
  62                                     IWL_RATE_##rp##M_INDEX,    \
  63                                     IWL_RATE_##rn##M_INDEX,    \
  64                                     IWL_RATE_##pp##M_INDEX,    \
  65                                     IWL_RATE_##np##M_INDEX }
  66
  67 /*
  68  * Parameter order:
  69  *   rate, ht rate, prev rate, next rate, prev tgg rate, next tgg rate
  70  *
  71  * If there isn't a valid next or previous rate then INV is used which
  72  * maps to IWL_RATE_INVALID
  73  *
  74  */
  75 const struct iwl4965_rate_info iwl4965_rates[IWL_RATE_COUNT] = {
  76         IWL_DECLARE_RATE_INFO(1, INV, INV, 2, INV, 2, INV, 2),    /*  1mbps */
  77         IWL_DECLARE_RATE_INFO(2, INV, 1, 5, 1, 5, 1, 5),          /*  2mbps */
  78         IWL_DECLARE_RATE_INFO(5, INV, 2, 6, 2, 11, 2, 11),        /*5.5mbps */
  79         IWL_DECLARE_RATE_INFO(11, INV, 9, 12, 9, 12, 5, 18),      /* 11mbps */
  80         IWL_DECLARE_RATE_INFO(6, 6, 5, 9, 5, 11, 5, 11),        /*  6mbps */
  81         IWL_DECLARE_RATE_INFO(9, 6, 6, 11, 6, 11, 5, 11),       /*  9mbps */
  82         IWL_DECLARE_RATE_INFO(12, 12, 11, 18, 11, 18, 11, 18),   /* 12mbps */
  83         IWL_DECLARE_RATE_INFO(18, 18, 12, 24, 12, 24, 11, 24),   /* 18mbps */
  84         IWL_DECLARE_RATE_INFO(24, 24, 18, 36, 18, 36, 18, 36),   /* 24mbps */
  85         IWL_DECLARE_RATE_INFO(36, 36, 24, 48, 24, 48, 24, 48),   /* 36mbps */
  86         IWL_DECLARE_RATE_INFO(48, 48, 36, 54, 36, 54, 36, 54),   /* 48mbps */
  87         IWL_DECLARE_RATE_INFO(54, 54, 48, INV, 48, INV, 48, INV),/* 54mbps */
  88         IWL_DECLARE_RATE_INFO(60, 60, 48, INV, 48, INV, 48, INV),/* 60mbps */
  89         /* FIXME:RS:          ^^    should be INV (legacy) */
  90 };
  91 EXPORT_SYMBOL(iwl4965_rates);
  92
  93 /* This function both allocates and initializes hw and priv. */
  94 struct ieee80211_hw *iwl_alloc_all(struct iwl_cfg *cfg,
  95                 struct ieee80211_ops *hw_ops)
  96 {
  97         struct iwl_priv *priv;
  98
  99         /* mac80211 allocates memory for this device instance, including
 100          *   space for this driver's private structure */
 101         struct ieee80211_hw *hw =
 102                 ieee80211_alloc_hw(sizeof(struct iwl_priv), hw_ops);
 103         if (hw == NULL) {
 104                 IWL_ERROR("Can not allocate network device\n");
 105                 goto out;
 106         }
 107
 108         priv = hw->priv;
 109         priv->hw = hw;
 110
 111 out:
 112         return hw;
 113 }
 114 EXPORT_SYMBOL(iwl_alloc_all);
 115
 116 void iwl_hw_detect(struct iwl_priv *priv)
 117 {
 118         priv->hw_rev = _iwl_read32(priv, CSR_HW_REV);
 119         priv->hw_wa_rev = _iwl_read32(priv, CSR_HW_REV_WA_REG);
 120         pci_read_config_byte(priv->pci_dev, PCI_REVISION_ID, &priv->rev_id);
 121 }
 122 EXPORT_SYMBOL(iwl_hw_detect);
 123
 124 /**
 125  * iwlcore_clear_stations_table - Clear the driver's station table
 126  *
 127  * NOTE:  This does not clear or otherwise alter the device's station table.
 128  */
 129 void iwlcore_clear_stations_table(struct iwl_priv *priv)
 130 {
 131         unsigned long flags;
 132
 133         spin_lock_irqsave(&priv->sta_lock, flags);
 134
 135         priv->num_stations = 0;
 136         memset(priv->stations, 0, sizeof(priv->stations));
 137
 138         spin_unlock_irqrestore(&priv->sta_lock, flags);
 139 }
 140 EXPORT_SYMBOL(iwlcore_clear_stations_table);
 141
 142 void iwl_reset_qos(struct iwl_priv *priv)
 143 {
 144         u16 cw_min = 15;
 145         u16 cw_max = 1023;
 146         u8 aifs = 2;
 147         u8 is_legacy = 0;
 148         unsigned long flags;
 149         int i;
 150
 151         spin_lock_irqsave(&priv->lock, flags);
 152         priv->qos_data.qos_active = 0;
 153
 154         if (priv->iw_mode == IEEE80211_IF_TYPE_IBSS) {
 155                 if (priv->qos_data.qos_enable)
 156                         priv->qos_data.qos_active = 1;
 157                 if (!(priv->active_rate & 0xfff0)) {
 158                         cw_min = 31;
 159                         is_legacy = 1;
 160                 }
 161         } else if (priv->iw_mode == IEEE80211_IF_TYPE_AP) {
 162                 if (priv->qos_data.qos_enable)
 163                         priv->qos_data.qos_active = 1;
 164         } else if (!(priv->staging_rxon.flags & RXON_FLG_SHORT_SLOT_MSK)) {
 165                 cw_min = 31;
 166                 is_legacy = 1;
 167         }
 168
 169         if (priv->qos_data.qos_active)
 170                 aifs = 3;
 171
 172         priv->qos_data.def_qos_parm.ac[0].cw_min = cpu_to_le16(cw_min);
 173         priv->qos_data.def_qos_parm.ac[0].cw_max = cpu_to_le16(cw_max);
 174         priv->qos_data.def_qos_parm.ac[0].aifsn = aifs;
 175         priv->qos_data.def_qos_parm.ac[0].edca_txop = 0;
 176         priv->qos_data.def_qos_parm.ac[0].reserved1 = 0;
 177
 178         if (priv->qos_data.qos_active) {
 179                 i = 1;
 180                 priv->qos_data.def_qos_parm.ac[i].cw_min = cpu_to_le16(cw_min);
 181                 priv->qos_data.def_qos_parm.ac[i].cw_max = cpu_to_le16(cw_max);
 182                 priv->qos_data.def_qos_parm.ac[i].aifsn = 7;
 183                 priv->qos_data.def_qos_parm.ac[i].edca_txop = 0;
 184                 priv->qos_data.def_qos_parm.ac[i].reserved1 = 0;
 185
 186                 i = 2;
 187                 priv->qos_data.def_qos_parm.ac[i].cw_min =
 188                         cpu_to_le16((cw_min + 1) / 2 - 1);
 189                 priv->qos_data.def_qos_parm.ac[i].cw_max =
 190                         cpu_to_le16(cw_max);
 191                 priv->qos_data.def_qos_parm.ac[i].aifsn = 2;
 192                 if (is_legacy)
 193                         priv->qos_data.def_qos_parm.ac[i].edca_txop =
 194                                 cpu_to_le16(6016);
 195                 else
 196                         priv->qos_data.def_qos_parm.ac[i].edca_txop =
 197                                 cpu_to_le16(3008);
 198                 priv->qos_data.def_qos_parm.ac[i].reserved1 = 0;
 199
 200                 i = 3;
 201                 priv->qos_data.def_qos_parm.ac[i].cw_min =
 202                         cpu_to_le16((cw_min + 1) / 4 - 1);
 203                 priv->qos_data.def_qos_parm.ac[i].cw_max =
 204                         cpu_to_le16((cw_max + 1) / 2 - 1);
 205                 priv->qos_data.def_qos_parm.ac[i].aifsn = 2;
 206                 priv->qos_data.def_qos_parm.ac[i].reserved1 = 0;
 207                 if (is_legacy)
 208                         priv->qos_data.def_qos_parm.ac[i].edca_txop =
 209                                 cpu_to_le16(3264);
 210                 else
 211                         priv->qos_data.def_qos_parm.ac[i].edca_txop =
 212                                 cpu_to_le16(1504);
 213         } else {
 214                 for (i = 1; i < 4; i++) {
 215                         priv->qos_data.def_qos_parm.ac[i].cw_min =
 216                                 cpu_to_le16(cw_min);
 217                         priv->qos_data.def_qos_parm.ac[i].cw_max =
 218                                 cpu_to_le16(cw_max);
 219                         priv->qos_data.def_qos_parm.ac[i].aifsn = aifs;
 220                         priv->qos_data.def_qos_parm.ac[i].edca_txop = 0;
 221                         priv->qos_data.def_qos_parm.ac[i].reserved1 = 0;
 222                 }
 223         }
 224         IWL_DEBUG_QOS("set QoS to default \n");
 225
 226         spin_unlock_irqrestore(&priv->lock, flags);
 227 }
 228 EXPORT_SYMBOL(iwl_reset_qos);
 229
 230 #ifdef CONFIG_IWL4965_HT
 231 static void iwlcore_init_ht_hw_capab(const struct iwl_priv *priv,
 232                               struct ieee80211_ht_info *ht_info,
 233                               enum ieee80211_band band)
 234 {
 235         ht_info->cap = 0;
 236         memset(ht_info->supp_mcs_set, 0, 16);
 237
 238         ht_info->ht_supported = 1;
 239
 240         if (priv->hw_params.fat_channel & BIT(band)) {
 241                 ht_info->cap |= (u16)IEEE80211_HT_CAP_SUP_WIDTH;
 242                 ht_info->cap |= (u16)IEEE80211_HT_CAP_SGI_40;
 243                 ht_info->supp_mcs_set[4] = 0x01;
 244         }
 245         ht_info->cap |= (u16)IEEE80211_HT_CAP_GRN_FLD;
 246         ht_info->cap |= (u16)IEEE80211_HT_CAP_SGI_20;
 247         ht_info->cap |= (u16)(IEEE80211_HT_CAP_MIMO_PS &
 248                              (IWL_MIMO_PS_NONE << 2));
 249
 250         if (priv->cfg->mod_params->amsdu_size_8K)
 251                 ht_info->cap |= (u16)IEEE80211_HT_CAP_MAX_AMSDU;
 252
 253         ht_info->ampdu_factor = CFG_HT_RX_AMPDU_FACTOR_DEF;
 254         ht_info->ampdu_density = CFG_HT_MPDU_DENSITY_DEF;
 255
 256         ht_info->supp_mcs_set[0] = 0xFF;
 257         if (priv->hw_params.tx_chains_num >= 2)
 258                 ht_info->supp_mcs_set[1] = 0xFF;
 259         if (priv->hw_params.tx_chains_num >= 3)
 260                 ht_info->supp_mcs_set[2] = 0xFF;
 261 }
 262 #else
 263 static inline void iwlcore_init_ht_hw_capab(const struct iwl_priv *priv,
 264                               struct ieee80211_ht_info *ht_info,
 265                               enum ieee80211_band band)
 266 {
 267 }
 268 #endif /* CONFIG_IWL4965_HT */
 269
 270 static void iwlcore_init_hw_rates(struct iwl_priv *priv,
 271                               struct ieee80211_rate *rates)
 272 {
 273         int i;
 274
 275         for (i = 0; i < IWL_RATE_COUNT; i++) {
 276                 rates[i].bitrate = iwl4965_rates[i].ieee * 5;
 277                 rates[i].hw_value = i; /* Rate scaling will work on indexes */
 278                 rates[i].hw_value_short = i;
 279                 rates[i].flags = 0;
 280                 if ((i > IWL_LAST_OFDM_RATE) || (i < IWL_FIRST_OFDM_RATE)) {
 281                         /*
 282                          * If CCK != 1M then set short preamble rate flag.
 283                          */
 284                         rates[i].flags |=
 285                                 (iwl4965_rates[i].plcp == IWL_RATE_1M_PLCP) ?
 286                                         0 : IEEE80211_RATE_SHORT_PREAMBLE;
 287                 }
 288         }
 289 }
 290
 291 /**
 292  * iwlcore_init_geos - Initialize mac80211's geo/channel info based from eeprom
 293  */
 294 static int iwlcore_init_geos(struct iwl_priv *priv)
 295 {
 296         struct iwl_channel_info *ch;
 297         struct ieee80211_supported_band *sband;
 298         struct ieee80211_channel *channels;
 299         struct ieee80211_channel *geo_ch;
 300         struct ieee80211_rate *rates;
 301         int i = 0;
 302
 303         if (priv->bands[IEEE80211_BAND_2GHZ].n_bitrates ||
 304             priv->bands[IEEE80211_BAND_5GHZ].n_bitrates) {
 305                 IWL_DEBUG_INFO("Geography modes already initialized.\n");
 306                 set_bit(STATUS_GEO_CONFIGURED, &priv->status);
 307                 return 0;
 308         }
 309
 310         channels = kzalloc(sizeof(struct ieee80211_channel) *
 311                            priv->channel_count, GFP_KERNEL);
 312         if (!channels)
 313                 return -ENOMEM;
 314
 315         rates = kzalloc((sizeof(struct ieee80211_rate) * (IWL_RATE_COUNT + 1)),
 316                         GFP_KERNEL);
 317         if (!rates) {
 318                 kfree(channels);
 319                 return -ENOMEM;
 320         }
 321
 322         /* 5.2GHz channels start after the 2.4GHz channels */
 323         sband = &priv->bands[IEEE80211_BAND_5GHZ];
 324         sband->channels = &channels[ARRAY_SIZE(iwl_eeprom_band_1)];
 325         /* just OFDM */
 326         sband->bitrates = &rates[IWL_FIRST_OFDM_RATE];
 327         sband->n_bitrates = IWL_RATE_COUNT - IWL_FIRST_OFDM_RATE;
 328
 329         iwlcore_init_ht_hw_capab(priv, &sband->ht_info, IEEE80211_BAND_5GHZ);
 330
 331         sband = &priv->bands[IEEE80211_BAND_2GHZ];
 332         sband->channels = channels;
 333         /* OFDM & CCK */
 334         sband->bitrates = rates;
 335         sband->n_bitrates = IWL_RATE_COUNT;
 336
 337         iwlcore_init_ht_hw_capab(priv, &sband->ht_info, IEEE80211_BAND_2GHZ);
 338
 339         priv->ieee_channels = channels;
 340         priv->ieee_rates = rates;
 341
 342         iwlcore_init_hw_rates(priv, rates);
 343
 344         for (i = 0;  i < priv->channel_count; i++) {
 345                 ch = &priv->channel_info[i];
 346
 347                 /* FIXME: might be removed if scan is OK */
 348                 if (!is_channel_valid(ch))
 349                         continue;
 350
 351                 if (is_channel_a_band(ch))
 352                         sband =  &priv->bands[IEEE80211_BAND_5GHZ];
 353                 else
 354                         sband =  &priv->bands[IEEE80211_BAND_2GHZ];
 355
 356                 geo_ch = &sband->channels[sband->n_channels++];
 357
 358                 geo_ch->center_freq =
 359                                 ieee80211_channel_to_frequency(ch->channel);
 360                 geo_ch->max_power = ch->max_power_avg;
 361                 geo_ch->max_antenna_gain = 0xff;
 362                 geo_ch->hw_value = ch->channel;
 363
 364                 if (is_channel_valid(ch)) {
 365                         if (!(ch->flags & EEPROM_CHANNEL_IBSS))
 366                                 geo_ch->flags |= IEEE80211_CHAN_NO_IBSS;
 367
 368                         if (!(ch->flags & EEPROM_CHANNEL_ACTIVE))
 369                                 geo_ch->flags |= IEEE80211_CHAN_PASSIVE_SCAN;
 370
 371                         if (ch->flags & EEPROM_CHANNEL_RADAR)
 372                                 geo_ch->flags |= IEEE80211_CHAN_RADAR;
 373
 374                         if (ch->max_power_avg > priv->max_channel_txpower_limit)
 375                                 priv->max_channel_txpower_limit =
 376                                     ch->max_power_avg;
 377                 } else {
 378                         geo_ch->flags |= IEEE80211_CHAN_DISABLED;
 379                 }
 380
 381                 /* Save flags for reg domain usage */
 382                 geo_ch->orig_flags = geo_ch->flags;
 383
 384                 IWL_DEBUG_INFO("Channel %d Freq=%d[%sGHz] %s flag=0%X\n",
 385                                 ch->channel, geo_ch->center_freq,
 386                                 is_channel_a_band(ch) ?  "5.2" : "2.4",
 387                                 geo_ch->flags & IEEE80211_CHAN_DISABLED ?
 388                                 "restricted" : "valid",
 389                                  geo_ch->flags);
 390         }
 391
 392         if ((priv->bands[IEEE80211_BAND_5GHZ].n_channels == 0) &&
 393              priv->cfg->sku & IWL_SKU_A) {
 394                 printk(KERN_INFO DRV_NAME
 395                        ": Incorrectly detected BG card as ABG.  Please send "
 396                        "your PCI ID 0x%04X:0x%04X to maintainer.\n",
 397                        priv->pci_dev->device, priv->pci_dev->subsystem_device);
 398                 priv->cfg->sku &= ~IWL_SKU_A;
 399         }
 400
 401         printk(KERN_INFO DRV_NAME
 402                ": Tunable channels: %d 802.11bg, %d 802.11a channels\n",
 403                priv->bands[IEEE80211_BAND_2GHZ].n_channels,
 404                priv->bands[IEEE80211_BAND_5GHZ].n_channels);
 405
 406         if (priv->bands[IEEE80211_BAND_2GHZ].n_channels)
 407                 priv->hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
 408                         &priv->bands[IEEE80211_BAND_2GHZ];
 409         if (priv->bands[IEEE80211_BAND_5GHZ].n_channels)
 410                 priv->hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
 411                         &priv->bands[IEEE80211_BAND_5GHZ];
 412
 413         set_bit(STATUS_GEO_CONFIGURED, &priv->status);
 414
 415         return 0;
 416 }
 417
 418 /*
 419  * iwlcore_free_geos - undo allocations in iwlcore_init_geos
 420  */
 421 void iwlcore_free_geos(struct iwl_priv *priv)
 422 {
 423         kfree(priv->ieee_channels);
 424         kfree(priv->ieee_rates);
 425         clear_bit(STATUS_GEO_CONFIGURED, &priv->status);
 426 }
 427 EXPORT_SYMBOL(iwlcore_free_geos);
 428
 429 #ifdef CONFIG_IWL4965_HT
 430 static u8 is_single_rx_stream(struct iwl_priv *priv)
 431 {
 432         return !priv->current_ht_config.is_ht ||
 433                ((priv->current_ht_config.supp_mcs_set[1] == 0) &&
 434                 (priv->current_ht_config.supp_mcs_set[2] == 0)) ||
 435                priv->ps_mode == IWL_MIMO_PS_STATIC;
 436 }
 437 #else
 438 static inline u8 is_single_rx_stream(struct iwl_priv *priv)
 439 {
 440         return 1;
 441 }
 442 #endif  /*CONFIG_IWL4965_HT */
 443
 444 /*
 445  * Determine how many receiver/antenna chains to use.
 446  * More provides better reception via diversity.  Fewer saves power.
 447  * MIMO (dual stream) requires at least 2, but works better with 3.
 448  * This does not determine *which* chains to use, just how many.
 449  */
 450 static int iwlcore_get_rx_chain_counter(struct iwl_priv *priv,
 451                                         u8 *idle_state, u8 *rx_state)
 452 {
 453         u8 is_single = is_single_rx_stream(priv);
 454         u8 is_cam = test_bit(STATUS_POWER_PMI, &priv->status) ? 0 : 1;
 455
 456         /* # of Rx chains to use when expecting MIMO. */
 457         if (is_single || (!is_cam && (priv->ps_mode == IWL_MIMO_PS_STATIC)))
 458                 *rx_state = 2;
 459         else
 460                 *rx_state = 3;
 461
 462         /* # Rx chains when idling and maybe trying to save power */
 463         switch (priv->ps_mode) {
 464         case IWL_MIMO_PS_STATIC:
 465         case IWL_MIMO_PS_DYNAMIC:
 466                 *idle_state = (is_cam) ? 2 : 1;
 467                 break;
 468         case IWL_MIMO_PS_NONE:
 469                 *idle_state = (is_cam) ? *rx_state : 1;
 470                 break;
 471         default:
 472                 *idle_state = 1;
 473                 break;
 474         }
 475
 476         return 0;
 477 }
 478
 479 /**
 480  * iwl_set_rxon_chain - Set up Rx chain usage in "staging" RXON image
 481  *
 482  * Selects how many and which Rx receivers/antennas/chains to use.
 483  * This should not be used for scan command ... it puts data in wrong place.
 484  */
 485 void iwl_set_rxon_chain(struct iwl_priv *priv)
 486 {
 487         u8 is_single = is_single_rx_stream(priv);
 488         u8 idle_state, rx_state;
 489
 490         priv->staging_rxon.rx_chain = 0;
 491         rx_state = idle_state = 3;
 492
 493         /* Tell uCode which antennas are actually connected.
 494          * Before first association, we assume all antennas are connected.
 495          * Just after first association, iwl_chain_noise_calibration()
 496          *    checks which antennas actually *are* connected. */
 497         priv->staging_rxon.rx_chain |=
 498                     cpu_to_le16(priv->hw_params.valid_rx_ant <<
 499                                                  RXON_RX_CHAIN_VALID_POS);
 500
 501         /* How many receivers should we use? */
 502         iwlcore_get_rx_chain_counter(priv, &idle_state, &rx_state);
 503         priv->staging_rxon.rx_chain |=
 504                 cpu_to_le16(rx_state << RXON_RX_CHAIN_MIMO_CNT_POS);
 505         priv->staging_rxon.rx_chain |=
 506                 cpu_to_le16(idle_state << RXON_RX_CHAIN_CNT_POS);
 507
 508         if (!is_single && (rx_state >= 2) &&
 509             !test_bit(STATUS_POWER_PMI, &priv->status))
 510                 priv->staging_rxon.rx_chain |= RXON_RX_CHAIN_MIMO_FORCE_MSK;
 511         else
 512                 priv->staging_rxon.rx_chain &= ~RXON_RX_CHAIN_MIMO_FORCE_MSK;
 513
 514         IWL_DEBUG_ASSOC("rx chain %X\n", priv->staging_rxon.rx_chain);
 515 }
 516 EXPORT_SYMBOL(iwl_set_rxon_chain);
 517
 518 /**
 519  * iwlcore_set_rxon_channel - Set the phymode and channel values in staging RXON
 520  * @phymode: MODE_IEEE80211A sets to 5.2GHz; all else set to 2.4GHz
 521  * @channel: Any channel valid for the requested phymode
 522
 523  * In addition to setting the staging RXON, priv->phymode is also set.
 524  *
 525  * NOTE:  Does not commit to the hardware; it sets appropriate bit fields
 526  * in the staging RXON flag structure based on the phymode
 527  */
 528 int iwl_set_rxon_channel(struct iwl_priv *priv,
 529                                 enum ieee80211_band band,
 530                                 u16 channel)
 531 {
 532         if (!iwl_get_channel_info(priv, band, channel)) {
 533                 IWL_DEBUG_INFO("Could not set channel to %d [%d]\n",
 534                                channel, band);
 535                 return -EINVAL;
 536         }
 537
 538         if ((le16_to_cpu(priv->staging_rxon.channel) == channel) &&
 539             (priv->band == band))
 540                 return 0;
 541
 542         priv->staging_rxon.channel = cpu_to_le16(channel);
 543         if (band == IEEE80211_BAND_5GHZ)
 544                 priv->staging_rxon.flags &= ~RXON_FLG_BAND_24G_MSK;
 545         else
 546                 priv->staging_rxon.flags |= RXON_FLG_BAND_24G_MSK;
 547
 548         priv->band = band;
 549
 550         IWL_DEBUG_INFO("Staging channel set to %d [%d]\n", channel, band);
 551
 552         return 0;
 553 }
 554 EXPORT_SYMBOL(iwl_set_rxon_channel);
 555
 556 static void iwlcore_init_hw(struct iwl_priv *priv)
 557 {
 558         struct ieee80211_hw *hw = priv->hw;
 559         hw->rate_control_algorithm = "iwl-4965-rs";
 560
 561         /* Tell mac80211 and its clients (e.g. Wireless Extensions)
 562          *       the range of signal quality values that we'll provide.
 563          * Negative values for level/noise indicate that we'll provide dBm.
 564          * For WE, at least, non-0 values here *enable* display of values
 565          *       in app (iwconfig). */
 566         hw->max_rssi = -20; /* signal level, negative indicates dBm */
 567         hw->max_noise = -20;    /* noise level, negative indicates dBm */
 568         hw->max_signal = 100;   /* link quality indication (%) */
 569
 570         /* Tell mac80211 our Tx characteristics */
 571         hw->flags = IEEE80211_HW_HOST_GEN_BEACON_TEMPLATE;
 572
 573         /* Default value; 4 EDCA QOS priorities */
 574         hw->queues = 4;
 575 #ifdef CONFIG_IWL4965_HT
 576         /* Enhanced value; more queues, to support 11n aggregation */
 577         hw->ampdu_queues = 12;
 578 #endif /* CONFIG_IWL4965_HT */
 579 }
 580
 581 static int iwlcore_init_drv(struct iwl_priv *priv)
 582 {
 583         int ret;
 584         int i;
 585
 586         priv->retry_rate = 1;
 587         priv->ibss_beacon = NULL;
 588
 589         spin_lock_init(&priv->lock);
 590         spin_lock_init(&priv->power_data.lock);
 591         spin_lock_init(&priv->sta_lock);
 592         spin_lock_init(&priv->hcmd_lock);
 593         spin_lock_init(&priv->lq_mngr.lock);
 594
 595         for (i = 0; i < IWL_IBSS_MAC_HASH_SIZE; i++)
 596                 INIT_LIST_HEAD(&priv->ibss_mac_hash[i]);
 597
 598         INIT_LIST_HEAD(&priv->free_frames);
 599
 600         mutex_init(&priv->mutex);
 601
 602         /* Clear the driver's (not device's) station table */
 603         iwlcore_clear_stations_table(priv);
 604
 605         priv->data_retry_limit = -1;
 606         priv->ieee_channels = NULL;
 607         priv->ieee_rates = NULL;
 608         priv->band = IEEE80211_BAND_2GHZ;
 609
 610         priv->iw_mode = IEEE80211_IF_TYPE_STA;
 611
 612         priv->use_ant_b_for_management_frame = 1; /* start with ant B */
 613         priv->ps_mode = IWL_MIMO_PS_NONE;
 614
 615         /* Choose which receivers/antennas to use */
 616         iwl_set_rxon_chain(priv);
 617
 618         iwl_reset_qos(priv);
 619
 620         priv->qos_data.qos_active = 0;
 621         priv->qos_data.qos_cap.val = 0;
 622
 623         iwl_set_rxon_channel(priv, IEEE80211_BAND_2GHZ, 6);
 624
 625         priv->rates_mask = IWL_RATES_MASK;
 626         /* If power management is turned on, default to AC mode */
 627         priv->power_mode = IWL_POWER_AC;
 628         priv->user_txpower_limit = IWL_DEFAULT_TX_POWER;
 629
 630         ret = iwl_init_channel_map(priv);
 631         if (ret) {
 632                 IWL_ERROR("initializing regulatory failed: %d\n", ret);
 633                 goto err;
 634         }
 635
 636         ret = iwlcore_init_geos(priv);
 637         if (ret) {
 638                 IWL_ERROR("initializing geos failed: %d\n", ret);
 639                 goto err_free_channel_map;
 640         }
 641
 642         ret = ieee80211_register_hw(priv->hw);
 643         if (ret) {
 644                 IWL_ERROR("Failed to register network device (error %d)\n",
 645                                 ret);
 646                 goto err_free_geos;
 647         }
 648
 649         priv->hw->conf.beacon_int = 100;
 650         priv->mac80211_registered = 1;
 651
 652         return 0;
 653
 654 err_free_geos:
 655         iwlcore_free_geos(priv);
 656 err_free_channel_map:
 657         iwl_free_channel_map(priv);
 658 err:
 659         return ret;
 660 }
 661
 662 int iwl_setup(struct iwl_priv *priv)
 663 {
 664         int ret = 0;
 665         iwlcore_init_hw(priv);
 666         ret = iwlcore_init_drv(priv);
 667         return ret;
 668 }
 669 EXPORT_SYMBOL(iwl_setup);
 670
 671 /* Low level driver call this function to update iwlcore with
 672  * driver status.
 673  */
 674 int iwlcore_low_level_notify(struct iwl_priv *priv,
 675                               enum iwlcore_card_notify notify)
 676 {
 677         int ret;
 678         switch (notify) {
 679         case IWLCORE_INIT_EVT:
 680                 ret = iwl_rfkill_init(priv);
 681                 if (ret)
 682                         IWL_ERROR("Unable to initialize RFKILL system. "
 683                                   "Ignoring error: %d\n", ret);
 684                 iwl_power_initialize(priv);
 685                 break;
 686         case IWLCORE_START_EVT:
 687                 iwl_power_update_mode(priv, 1);
 688                 break;
 689         case IWLCORE_STOP_EVT:
 690                 break;
 691         case IWLCORE_REMOVE_EVT:
 692                 iwl_rfkill_unregister(priv);
 693                 break;
 694         }
 695
 696         return 0;
 697 }
 698 EXPORT_SYMBOL(iwlcore_low_level_notify);
 699
 700 int iwl_send_statistics_request(struct iwl_priv *priv, u8 flags)
 701 {
 702         u32 stat_flags = 0;
 703         struct iwl_host_cmd cmd = {
 704                 .id = REPLY_STATISTICS_CMD,
 705                 .meta.flags = flags,
 706                 .len = sizeof(stat_flags),
 707                 .data = (u8 *) &stat_flags,
 708         };
 709         return iwl_send_cmd(priv, &cmd);
 710 }
 711 EXPORT_SYMBOL(iwl_send_statistics_request);
 712
 713 /**
 714  * iwl_verify_inst_sparse - verify runtime uCode image in card vs. host,
 715  *   using sample data 100 bytes apart.  If these sample points are good,
 716  *   it's a pretty good bet that everything between them is good, too.
 717  */
 718 static int iwlcore_verify_inst_sparse(struct iwl_priv *priv, __le32 *image, u32 len)
 719 {
 720         u32 val;
 721         int ret = 0;
 722         u32 errcnt = 0;
 723         u32 i;
 724
 725         IWL_DEBUG_INFO("ucode inst image size is %u\n", len);
 726
 727         ret = iwl_grab_nic_access(priv);
 728         if (ret)
 729                 return ret;
 730
 731         for (i = 0; i < len; i += 100, image += 100/sizeof(u32)) {
 732                 /* read data comes through single port, auto-incr addr */
 733                 /* NOTE: Use the debugless read so we don't flood kernel log
 734                  * if IWL_DL_IO is set */
 735                 iwl_write_direct32(priv, HBUS_TARG_MEM_RADDR,
 736                         i + RTC_INST_LOWER_BOUND);
 737                 val = _iwl_read_direct32(priv, HBUS_TARG_MEM_RDAT);
 738                 if (val != le32_to_cpu(*image)) {
 739                         ret = -EIO;
 740                         errcnt++;
 741                         if (errcnt >= 3)
 742                                 break;
 743                 }
 744         }
 745
 746         iwl_release_nic_access(priv);
 747
 748         return ret;
 749 }
 750
 751 /**
 752  * iwlcore_verify_inst_full - verify runtime uCode image in card vs. host,
 753  *     looking at all data.
 754  */
 755 static int iwl_verify_inst_full(struct iwl_priv *priv, __le32 *image,
 756                                  u32 len)
 757 {
 758         u32 val;
 759         u32 save_len = len;
 760         int ret = 0;
 761         u32 errcnt;
 762
 763         IWL_DEBUG_INFO("ucode inst image size is %u\n", len);
 764
 765         ret = iwl_grab_nic_access(priv);
 766         if (ret)
 767                 return ret;
 768
 769         iwl_write_direct32(priv, HBUS_TARG_MEM_RADDR, RTC_INST_LOWER_BOUND);
 770
 771         errcnt = 0;
 772         for (; len > 0; len -= sizeof(u32), image++) {
 773                 /* read data comes through single port, auto-incr addr */
 774                 /* NOTE: Use the debugless read so we don't flood kernel log
 775                  * if IWL_DL_IO is set */
 776                 val = _iwl_read_direct32(priv, HBUS_TARG_MEM_RDAT);
 777                 if (val != le32_to_cpu(*image)) {
 778                         IWL_ERROR("uCode INST section is invalid at "
 779                                   "offset 0x%x, is 0x%x, s/b 0x%x\n",
 780                                   save_len - len, val, le32_to_cpu(*image));
 781                         ret = -EIO;
 782                         errcnt++;
 783                         if (errcnt >= 20)
 784                                 break;
 785                 }
 786         }
 787
 788         iwl_release_nic_access(priv);
 789
 790         if (!errcnt)
 791                 IWL_DEBUG_INFO
 792                     ("ucode image in INSTRUCTION memory is good\n");
 793
 794         return ret;
 795 }
 796
 797 /**
 798  * iwl_verify_ucode - determine which instruction image is in SRAM,
 799  *    and verify its contents
 800  */
 801 int iwl_verify_ucode(struct iwl_priv *priv)
 802 {
 803         __le32 *image;
 804         u32 len;
 805         int ret;
 806
 807         /* Try bootstrap */
 808         image = (__le32 *)priv->ucode_boot.v_addr;
 809         len = priv->ucode_boot.len;
 810         ret = iwlcore_verify_inst_sparse(priv, image, len);
 811         if (!ret) {
 812                 IWL_DEBUG_INFO("Bootstrap uCode is good in inst SRAM\n");
 813                 return 0;
 814         }
 815
 816         /* Try initialize */
 817         image = (__le32 *)priv->ucode_init.v_addr;
 818         len = priv->ucode_init.len;
 819         ret = iwlcore_verify_inst_sparse(priv, image, len);
 820         if (!ret) {
 821                 IWL_DEBUG_INFO("Initialize uCode is good in inst SRAM\n");
 822                 return 0;
 823         }
 824
 825         /* Try runtime/protocol */
 826         image = (__le32 *)priv->ucode_code.v_addr;
 827         len = priv->ucode_code.len;
 828         ret = iwlcore_verify_inst_sparse(priv, image, len);
 829         if (!ret) {
 830                 IWL_DEBUG_INFO("Runtime uCode is good in inst SRAM\n");
 831                 return 0;
 832         }
 833
 834         IWL_ERROR("NO VALID UCODE IMAGE IN INSTRUCTION SRAM!!\n");
 835
 836         /* Since nothing seems to match, show first several data entries in
 837          * instruction SRAM, so maybe visual inspection will give a clue.
 838          * Selection of bootstrap image (vs. other images) is arbitrary. */
 839         image = (__le32 *)priv->ucode_boot.v_addr;
 840         len = priv->ucode_boot.len;
 841         ret = iwl_verify_inst_full(priv, image, len);
 842
 843         return ret;
 844 }
 845 EXPORT_SYMBOL(iwl_verify_ucode);
 846