drivers/net/wireless/iwlwifi/iwl-nvm-parse.c

   1 /******************************************************************************
   2  *
   3  * This file is provided under a dual BSD/GPLv2 license.  When using or
   4  * redistributing this file, you may do so under either license.
   5  *
   6  * GPL LICENSE SUMMARY
   7  *
   8  * Copyright(c) 2008 - 2013 Intel Corporation. All rights reserved.
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of version 2 of the GNU General Public License as
  12  * published by the Free Software Foundation.
  13  *
  14  * This program is distributed in the hope that it will be useful, but
  15  * WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
  22  * USA
  23  *
  24  * The full GNU General Public License is included in this distribution
  25  * in the file called COPYING.
  26  *
  27  * Contact Information:
  28  *  Intel Linux Wireless <ilw@linux.intel.com>
  29  * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
  30  *
  31  * BSD LICENSE
  32  *
  33  * Copyright(c) 2005 - 2013 Intel Corporation. All rights reserved.
  34  * All rights reserved.
  35  *
  36  * Redistribution and use in source and binary forms, with or without
  37  * modification, are permitted provided that the following conditions
  38  * are met:
  39  *
  40  *  * Redistributions of source code must retain the above copyright
  41  *    notice, this list of conditions and the following disclaimer.
  42  *  * Redistributions in binary form must reproduce the above copyright
  43  *    notice, this list of conditions and the following disclaimer in
  44  *    the documentation and/or other materials provided with the
  45  *    distribution.
  46  *  * Neither the name Intel Corporation nor the names of its
  47  *    contributors may be used to endorse or promote products derived
  48  *    from this software without specific prior written permission.
  49  *
  50  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  51  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  52  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  53  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  54  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  55  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  56  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  57  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  58  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  59  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  60  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  61  *****************************************************************************/
  62 #include <linux/types.h>
  63 #include <linux/slab.h>
  64 #include <linux/export.h>
  65 #include "iwl-drv.h"
  66 #include "iwl-modparams.h"
  67 #include "iwl-nvm-parse.h"
  68
  69 /* NVM offsets (in words) definitions */
  70 enum wkp_nvm_offsets {
  71         /* NVM HW-Section offset (in words) definitions */
  72         HW_ADDR = 0x15,
  73
  74 /* NVM SW-Section offset (in words) definitions */
  75         NVM_SW_SECTION = 0x1C0,
  76         NVM_VERSION = 0,
  77         RADIO_CFG = 1,
  78         SKU = 2,
  79         N_HW_ADDRS = 3,
  80         NVM_CHANNELS = 0x1E0 - NVM_SW_SECTION,
  81
  82 /* NVM calibration section offset (in words) definitions */
  83         NVM_CALIB_SECTION = 0x2B8,
  84         XTAL_CALIB = 0x316 - NVM_CALIB_SECTION
  85 };
  86
  87 /* SKU Capabilities (actual values from NVM definition) */
  88 enum nvm_sku_bits {
  89         NVM_SKU_CAP_BAND_24GHZ  = BIT(0),
  90         NVM_SKU_CAP_BAND_52GHZ  = BIT(1),
  91         NVM_SKU_CAP_11N_ENABLE  = BIT(2),
  92 };
  93
  94 /* radio config bits (actual values from NVM definition) */
  95 #define NVM_RF_CFG_DASH_MSK(x)   (x & 0x3)         /* bits 0-1   */
  96 #define NVM_RF_CFG_STEP_MSK(x)   ((x >> 2)  & 0x3) /* bits 2-3   */
  97 #define NVM_RF_CFG_TYPE_MSK(x)   ((x >> 4)  & 0x3) /* bits 4-5   */
  98 #define NVM_RF_CFG_PNUM_MSK(x)   ((x >> 6)  & 0x3) /* bits 6-7   */
  99 #define NVM_RF_CFG_TX_ANT_MSK(x) ((x >> 8)  & 0xF) /* bits 8-11  */
 100 #define NVM_RF_CFG_RX_ANT_MSK(x) ((x >> 12) & 0xF) /* bits 12-15 */
 101
 102 /*
 103  * These are the channel numbers in the order that they are stored in the NVM
 104  */
 105 static const u8 iwl_nvm_channels[] = {
 106         /* 2.4 GHz */
 107         1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
 108         /* 5 GHz */
 109         36, 40, 44 , 48, 52, 56, 60, 64,
 110         100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140, 144,
 111         149, 153, 157, 161, 165
 112 };
 113
 114 #define IWL_NUM_CHANNELS        ARRAY_SIZE(iwl_nvm_channels)
 115 #define NUM_2GHZ_CHANNELS       14
 116 #define FIRST_2GHZ_HT_MINUS     5
 117 #define LAST_2GHZ_HT_PLUS       9
 118 #define LAST_5GHZ_HT            161
 119
 120
 121 /* rate data (static) */
 122 static struct ieee80211_rate iwl_cfg80211_rates[] = {
 123         { .bitrate = 1 * 10, .hw_value = 0, .hw_value_short = 0, },
 124         { .bitrate = 2 * 10, .hw_value = 1, .hw_value_short = 1,
 125           .flags = IEEE80211_RATE_SHORT_PREAMBLE, },
 126         { .bitrate = 5.5 * 10, .hw_value = 2, .hw_value_short = 2,
 127           .flags = IEEE80211_RATE_SHORT_PREAMBLE, },
 128         { .bitrate = 11 * 10, .hw_value = 3, .hw_value_short = 3,
 129           .flags = IEEE80211_RATE_SHORT_PREAMBLE, },
 130         { .bitrate = 6 * 10, .hw_value = 4, .hw_value_short = 4, },
 131         { .bitrate = 9 * 10, .hw_value = 5, .hw_value_short = 5, },
 132         { .bitrate = 12 * 10, .hw_value = 6, .hw_value_short = 6, },
 133         { .bitrate = 18 * 10, .hw_value = 7, .hw_value_short = 7, },
 134         { .bitrate = 24 * 10, .hw_value = 8, .hw_value_short = 8, },
 135         { .bitrate = 36 * 10, .hw_value = 9, .hw_value_short = 9, },
 136         { .bitrate = 48 * 10, .hw_value = 10, .hw_value_short = 10, },
 137         { .bitrate = 54 * 10, .hw_value = 11, .hw_value_short = 11, },
 138 };
 139 #define RATES_24_OFFS   0
 140 #define N_RATES_24      ARRAY_SIZE(iwl_cfg80211_rates)
 141 #define RATES_52_OFFS   4
 142 #define N_RATES_52      (N_RATES_24 - RATES_52_OFFS)
 143
 144 /**
 145  * enum iwl_nvm_channel_flags - channel flags in NVM
 146  * @NVM_CHANNEL_VALID: channel is usable for this SKU/geo
 147  * @NVM_CHANNEL_IBSS: usable as an IBSS channel
 148  * @NVM_CHANNEL_ACTIVE: active scanning allowed
 149  * @NVM_CHANNEL_RADAR: radar detection required
 150  * @NVM_CHANNEL_DFS: dynamic freq selection candidate
 151  * @NVM_CHANNEL_WIDE: 20 MHz channel okay (?)
 152  * @NVM_CHANNEL_40MHZ: 40 MHz channel okay (?)
 153  * @NVM_CHANNEL_80MHZ: 80 MHz channel okay (?)
 154  * @NVM_CHANNEL_160MHZ: 160 MHz channel okay (?)
 155  */
 156 enum iwl_nvm_channel_flags {
 157         NVM_CHANNEL_VALID = BIT(0),
 158         NVM_CHANNEL_IBSS = BIT(1),
 159         NVM_CHANNEL_ACTIVE = BIT(3),
 160         NVM_CHANNEL_RADAR = BIT(4),
 161         NVM_CHANNEL_DFS = BIT(7),
 162         NVM_CHANNEL_WIDE = BIT(8),
 163         NVM_CHANNEL_40MHZ = BIT(9),
 164         NVM_CHANNEL_80MHZ = BIT(10),
 165         NVM_CHANNEL_160MHZ = BIT(11),
 166 };
 167
 168 #define CHECK_AND_PRINT_I(x)    \
 169         ((ch_flags & NVM_CHANNEL_##x) ? # x " " : "")
 170
 171 static int iwl_init_channel_map(struct device *dev, const struct iwl_cfg *cfg,
 172                                 struct iwl_nvm_data *data,
 173                                 const __le16 * const nvm_ch_flags)
 174 {
 175         int ch_idx;
 176         int n_channels = 0;
 177         struct ieee80211_channel *channel;
 178         u16 ch_flags;
 179         bool is_5ghz;
 180
 181         for (ch_idx = 0; ch_idx < IWL_NUM_CHANNELS; ch_idx++) {
 182                 ch_flags = __le16_to_cpup(nvm_ch_flags + ch_idx);
 183                 if (!(ch_flags & NVM_CHANNEL_VALID)) {
 184                         IWL_DEBUG_EEPROM(dev,
 185                                          "Ch. %d Flags %x [%sGHz] - No traffic\n",
 186                                          iwl_nvm_channels[ch_idx],
 187                                          ch_flags,
 188                                          (ch_idx >= NUM_2GHZ_CHANNELS) ?
 189                                          "5.2" : "2.4");
 190                         continue;
 191                 }
 192
 193                 channel = &data->channels[n_channels];
 194                 n_channels++;
 195
 196                 channel->hw_value = iwl_nvm_channels[ch_idx];
 197                 channel->band = (ch_idx < NUM_2GHZ_CHANNELS) ?
 198                                 IEEE80211_BAND_2GHZ : IEEE80211_BAND_5GHZ;
 199                 channel->center_freq =
 200                         ieee80211_channel_to_frequency(
 201                                 channel->hw_value, channel->band);
 202
 203                 /* TODO: Need to be dependent to the NVM */
 204                 channel->flags = IEEE80211_CHAN_NO_HT40;
 205                 if (ch_idx < NUM_2GHZ_CHANNELS &&
 206                     (ch_flags & NVM_CHANNEL_40MHZ)) {
 207                         if (iwl_nvm_channels[ch_idx] <= LAST_2GHZ_HT_PLUS)
 208                                 channel->flags &= ~IEEE80211_CHAN_NO_HT40PLUS;
 209                         if (iwl_nvm_channels[ch_idx] >= FIRST_2GHZ_HT_MINUS)
 210                                 channel->flags &= ~IEEE80211_CHAN_NO_HT40MINUS;
 211                 } else if (iwl_nvm_channels[ch_idx] <= LAST_5GHZ_HT &&
 212                            (ch_flags & NVM_CHANNEL_40MHZ)) {
 213                         if ((ch_idx - NUM_2GHZ_CHANNELS) % 2 == 0)
 214                                 channel->flags &= ~IEEE80211_CHAN_NO_HT40PLUS;
 215                         else
 216                                 channel->flags &= ~IEEE80211_CHAN_NO_HT40MINUS;
 217                 }
 218                 if (!(ch_flags & NVM_CHANNEL_80MHZ))
 219                         channel->flags |= IEEE80211_CHAN_NO_80MHZ;
 220                 if (!(ch_flags & NVM_CHANNEL_160MHZ))
 221                         channel->flags |= IEEE80211_CHAN_NO_160MHZ;
 222
 223                 if (!(ch_flags & NVM_CHANNEL_IBSS))
 224                         channel->flags |= IEEE80211_CHAN_NO_IBSS;
 225
 226                 if (!(ch_flags & NVM_CHANNEL_ACTIVE))
 227                         channel->flags |= IEEE80211_CHAN_PASSIVE_SCAN;
 228
 229                 if (ch_flags & NVM_CHANNEL_RADAR)
 230                         channel->flags |= IEEE80211_CHAN_RADAR;
 231
 232                 /* Initialize regulatory-based run-time data */
 233
 234                 /* TODO: read the real value from the NVM */
 235                 channel->max_power = 0;
 236                 is_5ghz = channel->band == IEEE80211_BAND_5GHZ;
 237                 IWL_DEBUG_EEPROM(dev,
 238                                  "Ch. %d [%sGHz] %s%s%s%s%s%s(0x%02x %ddBm): Ad-Hoc %ssupported\n",
 239                                  channel->hw_value,
 240                                  is_5ghz ? "5.2" : "2.4",
 241                                  CHECK_AND_PRINT_I(VALID),
 242                                  CHECK_AND_PRINT_I(IBSS),
 243                                  CHECK_AND_PRINT_I(ACTIVE),
 244                                  CHECK_AND_PRINT_I(RADAR),
 245                                  CHECK_AND_PRINT_I(WIDE),
 246                                  CHECK_AND_PRINT_I(DFS),
 247                                  ch_flags,
 248                                  channel->max_power,
 249                                  ((ch_flags & NVM_CHANNEL_IBSS) &&
 250                                   !(ch_flags & NVM_CHANNEL_RADAR))
 251                                         ? "" : "not ");
 252         }
 253
 254         return n_channels;
 255 }
 256
 257 static void iwl_init_vht_hw_capab(const struct iwl_cfg *cfg,
 258                                   struct iwl_nvm_data *data,
 259                                   struct ieee80211_sta_vht_cap *vht_cap)
 260 {
 261         /* For now, assume new devices with NVM are VHT capable */
 262
 263         vht_cap->vht_supported = true;
 264
 265         vht_cap->cap = IEEE80211_VHT_CAP_SHORT_GI_80 |
 266                        IEEE80211_VHT_CAP_RXSTBC_1 |
 267                        IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE |
 268                        7 << IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_SHIFT;
 269
 270         if (iwlwifi_mod_params.amsdu_size_8K)
 271                 vht_cap->cap |= IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_7991;
 272
 273         vht_cap->vht_mcs.rx_mcs_map =
 274                 cpu_to_le16(IEEE80211_VHT_MCS_SUPPORT_0_9 << 0 |
 275                             IEEE80211_VHT_MCS_SUPPORT_0_9 << 2 |
 276                             IEEE80211_VHT_MCS_NOT_SUPPORTED << 4 |
 277                             IEEE80211_VHT_MCS_NOT_SUPPORTED << 6 |
 278                             IEEE80211_VHT_MCS_NOT_SUPPORTED << 8 |
 279                             IEEE80211_VHT_MCS_NOT_SUPPORTED << 10 |
 280                             IEEE80211_VHT_MCS_NOT_SUPPORTED << 12 |
 281                             IEEE80211_VHT_MCS_NOT_SUPPORTED << 14);
 282
 283         if (data->valid_rx_ant == 1 || cfg->rx_with_siso_diversity) {
 284                 vht_cap->cap |= IEEE80211_VHT_CAP_RX_ANTENNA_PATTERN |
 285                                 IEEE80211_VHT_CAP_TX_ANTENNA_PATTERN;
 286                 /* this works because NOT_SUPPORTED == 3 */
 287                 vht_cap->vht_mcs.rx_mcs_map |=
 288                         cpu_to_le16(IEEE80211_VHT_MCS_NOT_SUPPORTED << 2);
 289         }
 290
 291         vht_cap->vht_mcs.tx_mcs_map = vht_cap->vht_mcs.rx_mcs_map;
 292 }
 293
 294 static void iwl_init_sbands(struct device *dev, const struct iwl_cfg *cfg,
 295                             struct iwl_nvm_data *data, const __le16 *nvm_sw)
 296 {
 297         int n_channels = iwl_init_channel_map(dev, cfg, data,
 298                         &nvm_sw[NVM_CHANNELS]);
 299         int n_used = 0;
 300         struct ieee80211_supported_band *sband;
 301
 302         sband = &data->bands[IEEE80211_BAND_2GHZ];
 303         sband->band = IEEE80211_BAND_2GHZ;
 304         sband->bitrates = &iwl_cfg80211_rates[RATES_24_OFFS];
 305         sband->n_bitrates = N_RATES_24;
 306         n_used += iwl_init_sband_channels(data, sband, n_channels,
 307                                           IEEE80211_BAND_2GHZ);
 308         iwl_init_ht_hw_capab(cfg, data, &sband->ht_cap, IEEE80211_BAND_2GHZ);
 309
 310         sband = &data->bands[IEEE80211_BAND_5GHZ];
 311         sband->band = IEEE80211_BAND_5GHZ;
 312         sband->bitrates = &iwl_cfg80211_rates[RATES_52_OFFS];
 313         sband->n_bitrates = N_RATES_52;
 314         n_used += iwl_init_sband_channels(data, sband, n_channels,
 315                                           IEEE80211_BAND_5GHZ);
 316         iwl_init_ht_hw_capab(cfg, data, &sband->ht_cap, IEEE80211_BAND_5GHZ);
 317         iwl_init_vht_hw_capab(cfg, data, &sband->vht_cap);
 318
 319         if (n_channels != n_used)
 320                 IWL_ERR_DEV(dev, "NVM: used only %d of %d channels\n",
 321                             n_used, n_channels);
 322 }
 323
 324 struct iwl_nvm_data *
 325 iwl_parse_nvm_data(struct device *dev, const struct iwl_cfg *cfg,
 326                    const __le16 *nvm_hw, const __le16 *nvm_sw,
 327                    const __le16 *nvm_calib)
 328 {
 329         struct iwl_nvm_data *data;
 330         u8 hw_addr[ETH_ALEN];
 331         u16 radio_cfg, sku;
 332
 333         data = kzalloc(sizeof(*data) +
 334                        sizeof(struct ieee80211_channel) * IWL_NUM_CHANNELS,
 335                        GFP_KERNEL);
 336         if (!data)
 337                 return NULL;
 338
 339         data->nvm_version = le16_to_cpup(nvm_sw + NVM_VERSION);
 340
 341         radio_cfg = le16_to_cpup(nvm_sw + RADIO_CFG);
 342         data->radio_cfg_type = NVM_RF_CFG_TYPE_MSK(radio_cfg);
 343         data->radio_cfg_step = NVM_RF_CFG_STEP_MSK(radio_cfg);
 344         data->radio_cfg_dash = NVM_RF_CFG_DASH_MSK(radio_cfg);
 345         data->radio_cfg_pnum = NVM_RF_CFG_PNUM_MSK(radio_cfg);
 346         data->valid_tx_ant = NVM_RF_CFG_TX_ANT_MSK(radio_cfg);
 347         data->valid_rx_ant = NVM_RF_CFG_RX_ANT_MSK(radio_cfg);
 348
 349         sku = le16_to_cpup(nvm_sw + SKU);
 350         data->sku_cap_band_24GHz_enable = sku & NVM_SKU_CAP_BAND_24GHZ;
 351         data->sku_cap_band_52GHz_enable = sku & NVM_SKU_CAP_BAND_52GHZ;
 352         data->sku_cap_11n_enable = sku & NVM_SKU_CAP_11N_ENABLE;
 353         if (iwlwifi_mod_params.disable_11n & IWL_DISABLE_HT_ALL)
 354                 data->sku_cap_11n_enable = false;
 355
 356         /* check overrides (some devices have wrong NVM) */
 357         if (cfg->valid_tx_ant)
 358                 data->valid_tx_ant = cfg->valid_tx_ant;
 359         if (cfg->valid_rx_ant)
 360                 data->valid_rx_ant = cfg->valid_rx_ant;
 361
 362         if (!data->valid_tx_ant || !data->valid_rx_ant) {
 363                 IWL_ERR_DEV(dev, "invalid antennas (0x%x, 0x%x)\n",
 364                             data->valid_tx_ant, data->valid_rx_ant);
 365                 kfree(data);
 366                 return NULL;
 367         }
 368
 369         data->n_hw_addrs = le16_to_cpup(nvm_sw + N_HW_ADDRS);
 370
 371         data->xtal_calib[0] = *(nvm_calib + XTAL_CALIB);
 372         data->xtal_calib[1] = *(nvm_calib + XTAL_CALIB + 1);
 373
 374         /* The byte order is little endian 16 bit, meaning 214365 */
 375         memcpy(hw_addr, nvm_hw + HW_ADDR, ETH_ALEN);
 376         data->hw_addr[0] = hw_addr[1];
 377         data->hw_addr[1] = hw_addr[0];
 378         data->hw_addr[2] = hw_addr[3];
 379         data->hw_addr[3] = hw_addr[2];
 380         data->hw_addr[4] = hw_addr[5];
 381         data->hw_addr[5] = hw_addr[4];
 382
 383         iwl_init_sbands(dev, cfg, data, nvm_sw);
 384
 385         data->calib_version = 255;   /* TODO:
 386                                         this value will prevent some checks from
 387                                         failing, we need to check if this
 388                                         field is still needed, and if it does,
 389                                         where is it in the NVM*/
 390
 391         return data;
 392 }
 393 IWL_EXPORT_SYMBOL(iwl_parse_nvm_data);