aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorJohannes Berg <johannes.berg@intel.com>2012-05-21 05:55:54 -0400
committerJohannes Berg <johannes.berg@intel.com>2012-06-06 07:24:19 -0400
commit26a7ca9a71a3f7e1826de96b1a1e907123e11b07 (patch)
tree7ab52c58fdd876bacf112c1bfceeac865f196704
parent08838cdeca65e754af5c755a05f6cdb1c632eda8 (diff)
iwlwifi: refactor EEPROM reading/parsing
The EEPROM reading/parsing code is all mixed in the driver today, and the EEPROM is parsed only when we access data from it. This is problematic because the NVM needs to be parsed and that is independent of reading it. Also, the NVM format for new devices will be different and probably require a new parser. Therefore refactor the reading and parsing and create two independent components. Reading the EEPROM requires direct hardware accesses and therefore access to the transport, but parsing is independent and can be done on an NVM blob. Reviewed-by: Emmanuel Grumbach <emmanuel.grumbach@intel.com> Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Diffstat
-rw-r--r--drivers/net/wireless/iwlwifi/Makefile1
-rw-r--r--drivers/net/wireless/iwlwifi/dvm/Makefile2
-rw-r--r--drivers/net/wireless/iwlwifi/dvm/agn.h5
-rw-r--r--drivers/net/wireless/iwlwifi/dvm/calib.c17
-rw-r--r--drivers/net/wireless/iwlwifi/dvm/debugfs.c23
-rw-r--r--drivers/net/wireless/iwlwifi/dvm/dev.h128
-rw-r--r--drivers/net/wireless/iwlwifi/dvm/devices.c128
-rw-r--r--drivers/net/wireless/iwlwifi/dvm/eeprom.c1163
-rw-r--r--drivers/net/wireless/iwlwifi/dvm/eeprom.h269
-rw-r--r--drivers/net/wireless/iwlwifi/dvm/lib.c8
-rw-r--r--drivers/net/wireless/iwlwifi/dvm/mac80211.c9
-rw-r--r--drivers/net/wireless/iwlwifi/dvm/main.c301
-rw-r--r--drivers/net/wireless/iwlwifi/dvm/power.c1
-rw-r--r--drivers/net/wireless/iwlwifi/dvm/rs.c44
-rw-r--r--drivers/net/wireless/iwlwifi/dvm/rx.c1
-rw-r--r--drivers/net/wireless/iwlwifi/dvm/rxon.c4
-rw-r--r--drivers/net/wireless/iwlwifi/dvm/scan.c10
-rw-r--r--drivers/net/wireless/iwlwifi/dvm/sta.c30
-rw-r--r--drivers/net/wireless/iwlwifi/dvm/testmode.c10
-rw-r--r--drivers/net/wireless/iwlwifi/dvm/tt.c1
-rw-r--r--drivers/net/wireless/iwlwifi/dvm/tx.c10
-rw-r--r--drivers/net/wireless/iwlwifi/dvm/ucode.c25
-rw-r--r--drivers/net/wireless/iwlwifi/iwl-config.h19
-rw-r--r--drivers/net/wireless/iwlwifi/iwl-debug.h5
-rw-r--r--drivers/net/wireless/iwlwifi/iwl-eeprom-parse.c900
-rw-r--r--drivers/net/wireless/iwlwifi/iwl-eeprom-parse.h138
-rw-r--r--drivers/net/wireless/iwlwifi/iwl-eeprom-read.c463
-rw-r--r--drivers/net/wireless/iwlwifi/iwl-eeprom-read.h70
-rw-r--r--drivers/net/wireless/iwlwifi/pcie/1000.c14
-rw-r--r--drivers/net/wireless/iwlwifi/pcie/2000.c17
-rw-r--r--drivers/net/wireless/iwlwifi/pcie/5000.c15
-rw-r--r--drivers/net/wireless/iwlwifi/pcie/6000.c19
32 files changed, 1854 insertions, 1996 deletions
diff --git a/drivers/net/wireless/iwlwifi/Makefile b/drivers/net/wireless/iwlwifi/Makefile
index 7ba6b8dc1cbd..98c8f6449649 100644
--- a/drivers/net/wireless/iwlwifi/Makefile
+++ b/drivers/net/wireless/iwlwifi/Makefile
@@ -8,6 +8,7 @@ iwlwifi-objs += iwl-io.o
8iwlwifi-objs += iwl-drv.o 8iwlwifi-objs += iwl-drv.o
9iwlwifi-objs += iwl-debug.o 9iwlwifi-objs += iwl-debug.o
10iwlwifi-objs += iwl-notif-wait.o 10iwlwifi-objs += iwl-notif-wait.o
11iwlwifi-objs += iwl-eeprom-read.o iwl-eeprom-parse.o
11iwlwifi-objs += pcie/drv.o pcie/rx.o pcie/tx.o pcie/trans.o 12iwlwifi-objs += pcie/drv.o pcie/rx.o pcie/tx.o pcie/trans.o
12iwlwifi-objs += pcie/1000.o pcie/2000.o pcie/5000.o pcie/6000.o 13iwlwifi-objs += pcie/1000.o pcie/2000.o pcie/5000.o pcie/6000.o
13 14
diff --git a/drivers/net/wireless/iwlwifi/dvm/Makefile b/drivers/net/wireless/iwlwifi/dvm/Makefile
index 13f8282f4d0e..5ff76b204141 100644
--- a/drivers/net/wireless/iwlwifi/dvm/Makefile
+++ b/drivers/net/wireless/iwlwifi/dvm/Makefile
@@ -3,7 +3,7 @@ obj-$(CONFIG_IWLDVM) += iwldvm.o
3iwldvm-objs += main.o rs.o mac80211.o ucode.o tx.o 3iwldvm-objs += main.o rs.o mac80211.o ucode.o tx.o
4iwldvm-objs += lib.o calib.o tt.o sta.o rx.o 4iwldvm-objs += lib.o calib.o tt.o sta.o rx.o
5 5
6iwldvm-objs += eeprom.o power.o 6iwldvm-objs += power.o
7iwldvm-objs += scan.o led.o 7iwldvm-objs += scan.o led.o
8iwldvm-objs += rxon.o devices.o 8iwldvm-objs += rxon.o devices.o
9 9
diff --git a/drivers/net/wireless/iwlwifi/dvm/agn.h b/drivers/net/wireless/iwlwifi/dvm/agn.h
index 9a8dd1a579d0..2ae3608472a6 100644
--- a/drivers/net/wireless/iwlwifi/dvm/agn.h
+++ b/drivers/net/wireless/iwlwifi/dvm/agn.h
@@ -92,7 +92,6 @@ extern struct iwl_lib_ops iwl6030_lib;
92#define STATUS_CT_KILL 1 92#define STATUS_CT_KILL 1
93#define STATUS_ALIVE 2 93#define STATUS_ALIVE 2
94#define STATUS_READY 3 94#define STATUS_READY 3
95#define STATUS_GEO_CONFIGURED 4
96#define STATUS_EXIT_PENDING 5 95#define STATUS_EXIT_PENDING 5
97#define STATUS_STATISTICS 6 96#define STATUS_STATISTICS 6
98#define STATUS_SCANNING 7 97#define STATUS_SCANNING 7
@@ -443,10 +442,8 @@ static inline void iwl_print_rx_config_cmd(struct iwl_priv *priv,
443 442
444static inline int iwl_is_ready(struct iwl_priv *priv) 443static inline int iwl_is_ready(struct iwl_priv *priv)
445{ 444{
446 /* The adapter is 'ready' if READY and GEO_CONFIGURED bits are 445 /* The adapter is 'ready' if READY EXIT_PENDING is not set */
447 * set but EXIT_PENDING is not */
448 return test_bit(STATUS_READY, &priv->status) && 446 return test_bit(STATUS_READY, &priv->status) &&
449 test_bit(STATUS_GEO_CONFIGURED, &priv->status) &&
450 !test_bit(STATUS_EXIT_PENDING, &priv->status); 447 !test_bit(STATUS_EXIT_PENDING, &priv->status);
451} 448}
452 449
diff --git a/drivers/net/wireless/iwlwifi/dvm/calib.c b/drivers/net/wireless/iwlwifi/dvm/calib.c
index 7eb3fa3df7c4..f2dd671d7dc8 100644
--- a/drivers/net/wireless/iwlwifi/dvm/calib.c
+++ b/drivers/net/wireless/iwlwifi/dvm/calib.c
@@ -833,14 +833,14 @@ static void iwl_find_disconn_antenna(struct iwl_priv *priv, u32* average_sig,
833 * To be safe, simply mask out any chains that we know 833 * To be safe, simply mask out any chains that we know
834 * are not on the device. 834 * are not on the device.
835 */ 835 */
836 active_chains &= priv->hw_params.valid_rx_ant; 836 active_chains &= priv->eeprom_data->valid_rx_ant;
837 837
838 num_tx_chains = 0; 838 num_tx_chains = 0;
839 for (i = 0; i < NUM_RX_CHAINS; i++) { 839 for (i = 0; i < NUM_RX_CHAINS; i++) {
840 /* loops on all the bits of 840 /* loops on all the bits of
841 * priv->hw_setting.valid_tx_ant */ 841 * priv->hw_setting.valid_tx_ant */
842 u8 ant_msk = (1 << i); 842 u8 ant_msk = (1 << i);
843 if (!(priv->hw_params.valid_tx_ant & ant_msk)) 843 if (!(priv->eeprom_data->valid_tx_ant & ant_msk))
844 continue; 844 continue;
845 845
846 num_tx_chains++; 846 num_tx_chains++;
@@ -854,7 +854,7 @@ static void iwl_find_disconn_antenna(struct iwl_priv *priv, u32* average_sig,
854 * connect the first valid tx chain 854 * connect the first valid tx chain
855 */ 855 */
856 first_chain = 856 first_chain =
857 find_first_chain(priv->hw_params.valid_tx_ant); 857 find_first_chain(priv->eeprom_data->valid_tx_ant);
858 data->disconn_array[first_chain] = 0; 858 data->disconn_array[first_chain] = 0;
859 active_chains |= BIT(first_chain); 859 active_chains |= BIT(first_chain);
860 IWL_DEBUG_CALIB(priv, 860 IWL_DEBUG_CALIB(priv,
@@ -864,13 +864,13 @@ static void iwl_find_disconn_antenna(struct iwl_priv *priv, u32* average_sig,
864 } 864 }
865 } 865 }
866 866
867 if (active_chains != priv->hw_params.valid_rx_ant && 867 if (active_chains != priv->eeprom_data->valid_rx_ant &&
868 active_chains != priv->chain_noise_data.active_chains) 868 active_chains != priv->chain_noise_data.active_chains)
869 IWL_DEBUG_CALIB(priv, 869 IWL_DEBUG_CALIB(priv,
870 "Detected that not all antennas are connected! " 870 "Detected that not all antennas are connected! "
871 "Connected: %#x, valid: %#x.\n", 871 "Connected: %#x, valid: %#x.\n",
872 active_chains, 872 active_chains,
873 priv->hw_params.valid_rx_ant); 873 priv->eeprom_data->valid_rx_ant);
874 874
875 /* Save for use within RXON, TX, SCAN commands, etc. */ 875 /* Save for use within RXON, TX, SCAN commands, etc. */
876 data->active_chains = active_chains; 876 data->active_chains = active_chains;
@@ -1055,7 +1055,7 @@ void iwl_chain_noise_calibration(struct iwl_priv *priv)
1055 priv->cfg->bt_params->advanced_bt_coexist) { 1055 priv->cfg->bt_params->advanced_bt_coexist) {
1056 /* Disable disconnected antenna algorithm for advanced 1056 /* Disable disconnected antenna algorithm for advanced
1057 bt coex, assuming valid antennas are connected */ 1057 bt coex, assuming valid antennas are connected */
1058 data->active_chains = priv->hw_params.valid_rx_ant; 1058 data->active_chains = priv->eeprom_data->valid_rx_ant;
1059 for (i = 0; i < NUM_RX_CHAINS; i++) 1059 for (i = 0; i < NUM_RX_CHAINS; i++)
1060 if (!(data->active_chains & (1<<i))) 1060 if (!(data->active_chains & (1<<i)))
1061 data->disconn_array[i] = 1; 1061 data->disconn_array[i] = 1;
@@ -1084,8 +1084,9 @@ void iwl_chain_noise_calibration(struct iwl_priv *priv)
1084 IWL_DEBUG_CALIB(priv, "min_average_noise = %d, antenna %d\n", 1084 IWL_DEBUG_CALIB(priv, "min_average_noise = %d, antenna %d\n",
1085 min_average_noise, min_average_noise_antenna_i); 1085 min_average_noise, min_average_noise_antenna_i);
1086 1086
1087 iwlagn_gain_computation(priv, average_noise, 1087 iwlagn_gain_computation(
1088 find_first_chain(priv->hw_params.valid_rx_ant)); 1088 priv, average_noise,
1089 find_first_chain(priv->eeprom_data->valid_rx_ant));
1089 1090
1090 /* Some power changes may have been made during the calibration. 1091 /* Some power changes may have been made during the calibration.
1091 * Update and commit the RXON 1092 * Update and commit the RXON
diff --git a/drivers/net/wireless/iwlwifi/dvm/debugfs.c b/drivers/net/wireless/iwlwifi/dvm/debugfs.c
index 2268adddf4c0..8a2d9e643b14 100644
--- a/drivers/net/wireless/iwlwifi/dvm/debugfs.c
+++ b/drivers/net/wireless/iwlwifi/dvm/debugfs.c
@@ -303,13 +303,13 @@ static ssize_t iwl_dbgfs_nvm_read(struct file *file,
303 const u8 *ptr; 303 const u8 *ptr;
304 char *buf; 304 char *buf;
305 u16 eeprom_ver; 305 u16 eeprom_ver;
306 size_t eeprom_len = priv->cfg->base_params->eeprom_size; 306 size_t eeprom_len = priv->eeprom_blob_size;
307 buf_size = 4 * eeprom_len + 256; 307 buf_size = 4 * eeprom_len + 256;
308 308
309 if (eeprom_len % 16) 309 if (eeprom_len % 16)
310 return -ENODATA; 310 return -ENODATA;
311 311
312 ptr = priv->eeprom; 312 ptr = priv->eeprom_blob;
313 if (!ptr) 313 if (!ptr)
314 return -ENOMEM; 314 return -ENOMEM;
315 315
@@ -318,11 +318,9 @@ static ssize_t iwl_dbgfs_nvm_read(struct file *file,
318 if (!buf) 318 if (!buf)
319 return -ENOMEM; 319 return -ENOMEM;
320 320
321 eeprom_ver = iwl_eeprom_query16(priv, EEPROM_VERSION); 321 eeprom_ver = priv->eeprom_data->eeprom_version;
322 pos += scnprintf(buf + pos, buf_size - pos, "NVM Type: %s, " 322 pos += scnprintf(buf + pos, buf_size - pos,
323 "version: 0x%x\n", 323 "NVM version: 0x%x\n", eeprom_ver);
324 (priv->nvm_device_type == NVM_DEVICE_TYPE_OTP)
325 ? "OTP" : "EEPROM", eeprom_ver);
326 for (ofs = 0 ; ofs < eeprom_len ; ofs += 16) { 324 for (ofs = 0 ; ofs < eeprom_len ; ofs += 16) {
327 pos += scnprintf(buf + pos, buf_size - pos, "0x%.4x ", ofs); 325 pos += scnprintf(buf + pos, buf_size - pos, "0x%.4x ", ofs);
328 hex_dump_to_buffer(ptr + ofs, 16 , 16, 2, buf + pos, 326 hex_dump_to_buffer(ptr + ofs, 16 , 16, 2, buf + pos,
@@ -347,9 +345,6 @@ static ssize_t iwl_dbgfs_channels_read(struct file *file, char __user *user_buf,
347 char *buf; 345 char *buf;
348 ssize_t ret; 346 ssize_t ret;
349 347
350 if (!test_bit(STATUS_GEO_CONFIGURED, &priv->status))
351 return -EAGAIN;
352
353 buf = kzalloc(bufsz, GFP_KERNEL); 348 buf = kzalloc(bufsz, GFP_KERNEL);
354 if (!buf) 349 if (!buf)
355 return -ENOMEM; 350 return -ENOMEM;
@@ -422,8 +417,6 @@ static ssize_t iwl_dbgfs_status_read(struct file *file,
422 test_bit(STATUS_ALIVE, &priv->status)); 417 test_bit(STATUS_ALIVE, &priv->status));
423 pos += scnprintf(buf + pos, bufsz - pos, "STATUS_READY:\t\t %d\n", 418 pos += scnprintf(buf + pos, bufsz - pos, "STATUS_READY:\t\t %d\n",
424 test_bit(STATUS_READY, &priv->status)); 419 test_bit(STATUS_READY, &priv->status));
425 pos += scnprintf(buf + pos, bufsz - pos, "STATUS_GEO_CONFIGURED:\t %d\n",
426 test_bit(STATUS_GEO_CONFIGURED, &priv->status));
427 pos += scnprintf(buf + pos, bufsz - pos, "STATUS_EXIT_PENDING:\t %d\n", 420 pos += scnprintf(buf + pos, bufsz - pos, "STATUS_EXIT_PENDING:\t %d\n",
428 test_bit(STATUS_EXIT_PENDING, &priv->status)); 421 test_bit(STATUS_EXIT_PENDING, &priv->status));
429 pos += scnprintf(buf + pos, bufsz - pos, "STATUS_STATISTICS:\t %d\n", 422 pos += scnprintf(buf + pos, bufsz - pos, "STATUS_STATISTICS:\t %d\n",
@@ -1337,17 +1330,17 @@ static ssize_t iwl_dbgfs_ucode_tx_stats_read(struct file *file,
1337 if (tx->tx_power.ant_a || tx->tx_power.ant_b || tx->tx_power.ant_c) { 1330 if (tx->tx_power.ant_a || tx->tx_power.ant_b || tx->tx_power.ant_c) {
1338 pos += scnprintf(buf + pos, bufsz - pos, 1331 pos += scnprintf(buf + pos, bufsz - pos,
1339 "tx power: (1/2 dB step)\n"); 1332 "tx power: (1/2 dB step)\n");
1340 if ((priv->hw_params.valid_tx_ant & ANT_A) && 1333 if ((priv->eeprom_data->valid_tx_ant & ANT_A) &&
1341 tx->tx_power.ant_a) 1334 tx->tx_power.ant_a)
1342 pos += scnprintf(buf + pos, bufsz - pos, 1335 pos += scnprintf(buf + pos, bufsz - pos,
1343 fmt_hex, "antenna A:", 1336 fmt_hex, "antenna A:",
1344 tx->tx_power.ant_a); 1337 tx->tx_power.ant_a);
1345 if ((priv->hw_params.valid_tx_ant & ANT_B) && 1338 if ((priv->eeprom_data->valid_tx_ant & ANT_B) &&
1346 tx->tx_power.ant_b) 1339 tx->tx_power.ant_b)
1347 pos += scnprintf(buf + pos, bufsz - pos, 1340 pos += scnprintf(buf + pos, bufsz - pos,
1348 fmt_hex, "antenna B:", 1341 fmt_hex, "antenna B:",
1349 tx->tx_power.ant_b); 1342 tx->tx_power.ant_b);
1350 if ((priv->hw_params.valid_tx_ant & ANT_C) && 1343 if ((priv->eeprom_data->valid_tx_ant & ANT_C) &&
1351 tx->tx_power.ant_c) 1344 tx->tx_power.ant_c)
1352 pos += scnprintf(buf + pos, bufsz - pos, 1345 pos += scnprintf(buf + pos, bufsz - pos,
1353 fmt_hex, "antenna C:", 1346 fmt_hex, "antenna C:",
diff --git a/drivers/net/wireless/iwlwifi/dvm/dev.h b/drivers/net/wireless/iwlwifi/dvm/dev.h
index c29e6378a11d..89f2e1040e7f 100644
--- a/drivers/net/wireless/iwlwifi/dvm/dev.h
+++ b/drivers/net/wireless/iwlwifi/dvm/dev.h
@@ -39,6 +39,7 @@
39#include <linux/mutex.h> 39#include <linux/mutex.h>
40 40
41#include "iwl-fw.h" 41#include "iwl-fw.h"
42#include "iwl-eeprom-parse.h"
42#include "iwl-csr.h" 43#include "iwl-csr.h"
43#include "iwl-debug.h" 44#include "iwl-debug.h"
44#include "iwl-agn-hw.h" 45#include "iwl-agn-hw.h"
@@ -46,7 +47,6 @@
46#include "iwl-notif-wait.h" 47#include "iwl-notif-wait.h"
47#include "iwl-trans.h" 48#include "iwl-trans.h"
48 49
49#include "eeprom.h"
50#include "led.h" 50#include "led.h"
51#include "power.h" 51#include "power.h"
52#include "rs.h" 52#include "rs.h"
@@ -89,33 +89,6 @@
89#define IWL_NUM_SCAN_RATES (2) 89#define IWL_NUM_SCAN_RATES (2)
90 90
91/* 91/*
92 * One for each channel, holds all channel setup data
93 * Some of the fields (e.g. eeprom and flags/max_power_avg) are redundant
94 * with one another!
95 */
96struct iwl_channel_info {
97 struct iwl_eeprom_channel eeprom; /* EEPROM regulatory limit */
98 struct iwl_eeprom_channel ht40_eeprom; /* EEPROM regulatory limit for
99 * HT40 channel */
100
101 u8 channel; /* channel number */
102 u8 flags; /* flags copied from EEPROM */
103 s8 max_power_avg; /* (dBm) regul. eeprom, normal Tx, any rate */
104 s8 curr_txpow; /* (dBm) regulatory/spectrum/user (not h/w) limit */
105 s8 min_power; /* always 0 */
106 s8 scan_power; /* (dBm) regul. eeprom, direct scans, any rate */
107
108 u8 group_index; /* 0-4, maps channel to group1/2/3/4/5 */
109 u8 band_index; /* 0-4, maps channel to band1/2/3/4/5 */
110 enum ieee80211_band band;
111
112 /* HT40 channel info */
113 s8 ht40_max_power_avg; /* (dBm) regul. eeprom, normal Tx, any rate */
114 u8 ht40_flags; /* flags copied from EEPROM */
115 u8 ht40_extension_channel; /* HT_IE_EXT_CHANNEL_* */
116};
117
118/*
119 * Minimum number of queues. MAX_NUM is defined in hw specific files. 92 * Minimum number of queues. MAX_NUM is defined in hw specific files.
120 * Set the minimum to accommodate 93 * Set the minimum to accommodate
121 * - 4 standard TX queues 94 * - 4 standard TX queues
@@ -154,29 +127,6 @@ union iwl_ht_rate_supp {
154 }; 127 };
155}; 128};
156 129
157#define CFG_HT_RX_AMPDU_FACTOR_8K (0x0)
158#define CFG_HT_RX_AMPDU_FACTOR_16K (0x1)
159#define CFG_HT_RX_AMPDU_FACTOR_32K (0x2)
160#define CFG_HT_RX_AMPDU_FACTOR_64K (0x3)
161#define CFG_HT_RX_AMPDU_FACTOR_DEF CFG_HT_RX_AMPDU_FACTOR_64K
162#define CFG_HT_RX_AMPDU_FACTOR_MAX CFG_HT_RX_AMPDU_FACTOR_64K
163#define CFG_HT_RX_AMPDU_FACTOR_MIN CFG_HT_RX_AMPDU_FACTOR_8K
164
165/*
166 * Maximal MPDU density for TX aggregation
167 * 4 - 2us density
168 * 5 - 4us density
169 * 6 - 8us density
170 * 7 - 16us density
171 */
172#define CFG_HT_MPDU_DENSITY_2USEC (0x4)
173#define CFG_HT_MPDU_DENSITY_4USEC (0x5)
174#define CFG_HT_MPDU_DENSITY_8USEC (0x6)
175#define CFG_HT_MPDU_DENSITY_16USEC (0x7)
176#define CFG_HT_MPDU_DENSITY_DEF CFG_HT_MPDU_DENSITY_4USEC
177#define CFG_HT_MPDU_DENSITY_MAX CFG_HT_MPDU_DENSITY_16USEC
178#define CFG_HT_MPDU_DENSITY_MIN (0x1)
179
180struct iwl_ht_config { 130struct iwl_ht_config {
181 bool single_chain_sufficient; 131 bool single_chain_sufficient;
182 enum ieee80211_smps_mode smps; /* current smps mode */ 132 enum ieee80211_smps_mode smps; /* current smps mode */
@@ -446,23 +396,6 @@ enum {
446 MEASUREMENT_ACTIVE = (1 << 1), 396 MEASUREMENT_ACTIVE = (1 << 1),
447}; 397};
448 398
449enum iwl_nvm_type {
450 NVM_DEVICE_TYPE_EEPROM = 0,
451 NVM_DEVICE_TYPE_OTP,
452};
453
454/*
455 * Two types of OTP memory access modes
456 * IWL_OTP_ACCESS_ABSOLUTE - absolute address mode,
457 * based on physical memory addressing
458 * IWL_OTP_ACCESS_RELATIVE - relative address mode,
459 * based on logical memory addressing
460 */
461enum iwl_access_mode {
462 IWL_OTP_ACCESS_ABSOLUTE,
463 IWL_OTP_ACCESS_RELATIVE,
464};
465
466/* reply_tx_statistics (for _agn devices) */ 399/* reply_tx_statistics (for _agn devices) */
467struct reply_tx_error_statistics { 400struct reply_tx_error_statistics {
468 u32 pp_delay; 401 u32 pp_delay;
@@ -633,8 +566,6 @@ enum iwl_scan_type {
633 * 566 *
634 * @tx_chains_num: Number of TX chains 567 * @tx_chains_num: Number of TX chains
635 * @rx_chains_num: Number of RX chains 568 * @rx_chains_num: Number of RX chains
636 * @valid_tx_ant: usable antennas for TX
637 * @valid_rx_ant: usable antennas for RX
638 * @sku: sku read from EEPROM 569 * @sku: sku read from EEPROM
639 * @ct_kill_threshold: temperature threshold - in hw dependent unit 570 * @ct_kill_threshold: temperature threshold - in hw dependent unit
640 * @ct_kill_exit_threshold: when to reeable the device - in hw dependent unit 571 * @ct_kill_exit_threshold: when to reeable the device - in hw dependent unit
@@ -645,8 +576,6 @@ enum iwl_scan_type {
645struct iwl_hw_params { 576struct iwl_hw_params {
646 u8 tx_chains_num; 577 u8 tx_chains_num;
647 u8 rx_chains_num; 578 u8 rx_chains_num;
648 u8 valid_tx_ant;
649 u8 valid_rx_ant;
650 bool use_rts_for_aggregation; 579 bool use_rts_for_aggregation;
651 u16 sku; 580 u16 sku;
652 u32 ct_kill_threshold; 581 u32 ct_kill_threshold;
@@ -663,9 +592,6 @@ struct iwl_lib_ops {
663 /* device specific configuration */ 592 /* device specific configuration */
664 void (*nic_config)(struct iwl_priv *priv); 593 void (*nic_config)(struct iwl_priv *priv);
665 594
666 /* eeprom operations (as defined in eeprom.h) */
667 struct iwl_eeprom_ops eeprom_ops;
668
669 /* temperature */ 595 /* temperature */
670 void (*temperature)(struct iwl_priv *priv); 596 void (*temperature)(struct iwl_priv *priv);
671}; 597};
@@ -734,8 +660,6 @@ struct iwl_priv {
734 660
735 /* ieee device used by generic ieee processing code */ 661 /* ieee device used by generic ieee processing code */
736 struct ieee80211_hw *hw; 662 struct ieee80211_hw *hw;
737 struct ieee80211_channel *ieee_channels;
738 struct ieee80211_rate *ieee_rates;
739 663
740 struct list_head calib_results; 664 struct list_head calib_results;
741 665
@@ -754,8 +678,6 @@ struct iwl_priv {
754 678
755 struct iwl_notif_wait_data notif_wait; 679 struct iwl_notif_wait_data notif_wait;
756 680
757 struct ieee80211_supported_band bands[IEEE80211_NUM_BANDS];
758
759 /* spectrum measurement report caching */ 681 /* spectrum measurement report caching */
760 struct iwl_spectrum_notification measure_report; 682 struct iwl_spectrum_notification measure_report;
761 u8 measurement_status; 683 u8 measurement_status;
@@ -786,11 +708,6 @@ struct iwl_priv {
786 bool ucode_loaded; 708 bool ucode_loaded;
787 bool init_ucode_run; /* Don't run init uCode again */ 709 bool init_ucode_run; /* Don't run init uCode again */
788 710
789 /* we allocate array of iwl_channel_info for NIC's valid channels.
790 * Access via channel # using indirect index array */
791 struct iwl_channel_info *channel_info; /* channel info array */
792 u8 channel_count; /* # of channels */
793
794 u8 plcp_delta_threshold; 711 u8 plcp_delta_threshold;
795 712
796 /* thermal calibration */ 713 /* thermal calibration */
@@ -950,10 +867,8 @@ struct iwl_priv {
950 867
951 struct delayed_work scan_check; 868 struct delayed_work scan_check;
952 869
953 /* TX Power */ 870 /* TX Power settings */
954 s8 tx_power_user_lmt; 871 s8 tx_power_user_lmt;
955 s8 tx_power_device_lmt;
956 s8 tx_power_lmt_in_half_dbm; /* max tx power in half-dBm format */
957 s8 tx_power_next; 872 s8 tx_power_next;
958 873
959#ifdef CONFIG_IWLWIFI_DEBUGFS 874#ifdef CONFIG_IWLWIFI_DEBUGFS
@@ -964,9 +879,10 @@ struct iwl_priv {
964 void *wowlan_sram; 879 void *wowlan_sram;
965#endif /* CONFIG_IWLWIFI_DEBUGFS */ 880#endif /* CONFIG_IWLWIFI_DEBUGFS */
966 881
967 /* eeprom -- this is in the card's little endian byte order */ 882 struct iwl_eeprom_data *eeprom_data;
968 u8 *eeprom; 883 /* eeprom blob for debugfs/testmode */
969 enum iwl_nvm_type nvm_device_type; 884 u8 *eeprom_blob;
885 size_t eeprom_blob_size;
970 886
971 struct work_struct txpower_work; 887 struct work_struct txpower_work;
972 u32 calib_disabled; 888 u32 calib_disabled;
@@ -1034,36 +950,4 @@ static inline int iwl_is_any_associated(struct iwl_priv *priv)
1034 return false; 950 return false;
1035} 951}
1036 952
1037static inline int is_channel_valid(const struct iwl_channel_info *ch_info)
1038{
1039 if (ch_info == NULL)
1040 return 0;
1041 return (ch_info->flags & EEPROM_CHANNEL_VALID) ? 1 : 0;
1042}
1043
1044static inline int is_channel_radar(const struct iwl_channel_info *ch_info)
1045{
1046 return (ch_info->flags & EEPROM_CHANNEL_RADAR) ? 1 : 0;
1047}
1048
1049static inline u8 is_channel_a_band(const struct iwl_channel_info *ch_info)
1050{
1051 return ch_info->band == IEEE80211_BAND_5GHZ;
1052}
1053
1054static inline u8 is_channel_bg_band(const struct iwl_channel_info *ch_info)
1055{
1056 return ch_info->band == IEEE80211_BAND_2GHZ;
1057}
1058
1059static inline int is_channel_passive(const struct iwl_channel_info *ch)
1060{
1061 return (!(ch->flags & EEPROM_CHANNEL_ACTIVE)) ? 1 : 0;
1062}
1063
1064static inline int is_channel_ibss(const struct iwl_channel_info *ch)
1065{
1066 return ((ch->flags & EEPROM_CHANNEL_IBSS)) ? 1 : 0;
1067}
1068
1069#endif /* __iwl_dev_h__ */ 953#endif /* __iwl_dev_h__ */
diff --git a/drivers/net/wireless/iwlwifi/dvm/devices.c b/drivers/net/wireless/iwlwifi/dvm/devices.c
index ddf053c5713d..747e576950f4 100644
--- a/drivers/net/wireless/iwlwifi/dvm/devices.c
+++ b/drivers/net/wireless/iwlwifi/dvm/devices.c
@@ -29,11 +29,48 @@
29 */ 29 */
30#include "iwl-io.h" 30#include "iwl-io.h"
31#include "iwl-prph.h" 31#include "iwl-prph.h"
32#include "iwl-eeprom-parse.h"
32 33
33#include "agn.h" 34#include "agn.h"
34#include "dev.h" 35#include "dev.h"
35#include "commands.h" 36#include "commands.h"
36 37
38
39#define EEPROM_RF_CONFIG_TYPE_MAX 0x3
40
41static void iwl_rf_config(struct iwl_priv *priv)
42{
43 u16 radio_cfg = priv->eeprom_data->radio_cfg;
44
45 /* write radio config values to register */
46 if (EEPROM_RF_CFG_TYPE_MSK(radio_cfg) <= EEPROM_RF_CONFIG_TYPE_MAX) {
47 u32 reg_val =
48 EEPROM_RF_CFG_TYPE_MSK(radio_cfg) <<
49 CSR_HW_IF_CONFIG_REG_POS_PHY_TYPE |
50 EEPROM_RF_CFG_STEP_MSK(radio_cfg) <<
51 CSR_HW_IF_CONFIG_REG_POS_PHY_STEP |
52 EEPROM_RF_CFG_DASH_MSK(radio_cfg) <<
53 CSR_HW_IF_CONFIG_REG_POS_PHY_DASH;
54
55 iwl_set_bits_mask(priv->trans, CSR_HW_IF_CONFIG_REG,
56 CSR_HW_IF_CONFIG_REG_MSK_PHY_TYPE |
57 CSR_HW_IF_CONFIG_REG_MSK_PHY_STEP |
58 CSR_HW_IF_CONFIG_REG_MSK_PHY_DASH, reg_val);
59
60 IWL_INFO(priv, "Radio type=0x%x-0x%x-0x%x\n",
61 EEPROM_RF_CFG_TYPE_MSK(radio_cfg),
62 EEPROM_RF_CFG_STEP_MSK(radio_cfg),
63 EEPROM_RF_CFG_DASH_MSK(radio_cfg));
64 } else {
65 WARN_ON(1);
66 }
67
68 /* set CSR_HW_CONFIG_REG for uCode use */
69 iwl_set_bit(priv->trans, CSR_HW_IF_CONFIG_REG,
70 CSR_HW_IF_CONFIG_REG_BIT_RADIO_SI |
71 CSR_HW_IF_CONFIG_REG_BIT_MAC_SI);
72}
73
37/* 74/*
38 * 1000 series 75 * 1000 series
39 * =========== 76 * ===========
@@ -180,17 +217,6 @@ static void iwl1000_hw_set_hw_params(struct iwl_priv *priv)
180struct iwl_lib_ops iwl1000_lib = { 217struct iwl_lib_ops iwl1000_lib = {
181 .set_hw_params = iwl1000_hw_set_hw_params, 218 .set_hw_params = iwl1000_hw_set_hw_params,
182 .nic_config = iwl1000_nic_config, 219 .nic_config = iwl1000_nic_config,
183 .eeprom_ops = {
184 .regulatory_bands = {
185 EEPROM_REG_BAND_1_CHANNELS,
186 EEPROM_REG_BAND_2_CHANNELS,
187 EEPROM_REG_BAND_3_CHANNELS,
188 EEPROM_REG_BAND_4_CHANNELS,
189 EEPROM_REG_BAND_5_CHANNELS,
190 EEPROM_REG_BAND_24_HT40_CHANNELS,
191 EEPROM_REGULATORY_BAND_NO_HT40,
192 },
193 },
194 .temperature = iwlagn_temperature, 220 .temperature = iwlagn_temperature,
195}; 221};
196 222
@@ -251,36 +277,12 @@ static void iwl2000_hw_set_hw_params(struct iwl_priv *priv)
251struct iwl_lib_ops iwl2000_lib = { 277struct iwl_lib_ops iwl2000_lib = {
252 .set_hw_params = iwl2000_hw_set_hw_params, 278 .set_hw_params = iwl2000_hw_set_hw_params,
253 .nic_config = iwl2000_nic_config, 279 .nic_config = iwl2000_nic_config,
254 .eeprom_ops = {
255 .regulatory_bands = {
256 EEPROM_REG_BAND_1_CHANNELS,
257 EEPROM_REG_BAND_2_CHANNELS,
258 EEPROM_REG_BAND_3_CHANNELS,
259 EEPROM_REG_BAND_4_CHANNELS,
260 EEPROM_REG_BAND_5_CHANNELS,
261 EEPROM_6000_REG_BAND_24_HT40_CHANNELS,
262 EEPROM_REGULATORY_BAND_NO_HT40,
263 },
264 .enhanced_txpower = true,
265 },
266 .temperature = iwlagn_temperature, 280 .temperature = iwlagn_temperature,
267}; 281};
268 282
269struct iwl_lib_ops iwl2030_lib = { 283struct iwl_lib_ops iwl2030_lib = {
270 .set_hw_params = iwl2000_hw_set_hw_params, 284 .set_hw_params = iwl2000_hw_set_hw_params,
271 .nic_config = iwl2000_nic_config, 285 .nic_config = iwl2000_nic_config,
272 .eeprom_ops = {
273 .regulatory_bands = {
274 EEPROM_REG_BAND_1_CHANNELS,
275 EEPROM_REG_BAND_2_CHANNELS,
276 EEPROM_REG_BAND_3_CHANNELS,
277 EEPROM_REG_BAND_4_CHANNELS,
278 EEPROM_REG_BAND_5_CHANNELS,
279 EEPROM_6000_REG_BAND_24_HT40_CHANNELS,
280 EEPROM_REGULATORY_BAND_NO_HT40,
281 },
282 .enhanced_txpower = true,
283 },
284 .temperature = iwlagn_temperature, 286 .temperature = iwlagn_temperature,
285}; 287};
286 288
@@ -357,11 +359,9 @@ static struct iwl_sensitivity_ranges iwl5150_sensitivity = {
357static s32 iwl_temp_calib_to_offset(struct iwl_priv *priv) 359static s32 iwl_temp_calib_to_offset(struct iwl_priv *priv)
358{ 360{
359 u16 temperature, voltage; 361 u16 temperature, voltage;
360 __le16 *temp_calib = (__le16 *)iwl_eeprom_query_addr(priv,
361 EEPROM_KELVIN_TEMPERATURE);
362 362
363 temperature = le16_to_cpu(temp_calib[0]); 363 temperature = le16_to_cpu(priv->eeprom_data->kelvin_temperature);
364 voltage = le16_to_cpu(temp_calib[1]); 364 voltage = le16_to_cpu(priv->eeprom_data->kelvin_voltage);
365 365
366 /* offset = temp - volt / coeff */ 366 /* offset = temp - volt / coeff */
367 return (s32)(temperature - 367 return (s32)(temperature -
@@ -478,17 +478,6 @@ struct iwl_lib_ops iwl5000_lib = {
478 .set_hw_params = iwl5000_hw_set_hw_params, 478 .set_hw_params = iwl5000_hw_set_hw_params,
479 .set_channel_switch = iwl5000_hw_channel_switch, 479 .set_channel_switch = iwl5000_hw_channel_switch,
480 .nic_config = iwl5000_nic_config, 480 .nic_config = iwl5000_nic_config,
481 .eeprom_ops = {
482 .regulatory_bands = {
483 EEPROM_REG_BAND_1_CHANNELS,
484 EEPROM_REG_BAND_2_CHANNELS,
485 EEPROM_REG_BAND_3_CHANNELS,
486 EEPROM_REG_BAND_4_CHANNELS,
487 EEPROM_REG_BAND_5_CHANNELS,
488 EEPROM_REG_BAND_24_HT40_CHANNELS,
489 EEPROM_REG_BAND_52_HT40_CHANNELS
490 },
491 },
492 .temperature = iwlagn_temperature, 481 .temperature = iwlagn_temperature,
493}; 482};
494 483
@@ -496,17 +485,6 @@ struct iwl_lib_ops iwl5150_lib = {
496 .set_hw_params = iwl5150_hw_set_hw_params, 485 .set_hw_params = iwl5150_hw_set_hw_params,
497 .set_channel_switch = iwl5000_hw_channel_switch, 486 .set_channel_switch = iwl5000_hw_channel_switch,
498 .nic_config = iwl5000_nic_config, 487 .nic_config = iwl5000_nic_config,
499 .eeprom_ops = {
500 .regulatory_bands = {
501 EEPROM_REG_BAND_1_CHANNELS,
502 EEPROM_REG_BAND_2_CHANNELS,
503 EEPROM_REG_BAND_3_CHANNELS,
504 EEPROM_REG_BAND_4_CHANNELS,
505 EEPROM_REG_BAND_5_CHANNELS,
506 EEPROM_REG_BAND_24_HT40_CHANNELS,
507 EEPROM_REG_BAND_52_HT40_CHANNELS
508 },
509 },
510 .temperature = iwl5150_temperature, 488 .temperature = iwl5150_temperature,
511}; 489};
512 490
@@ -541,13 +519,13 @@ static void iwl6000_nic_config(struct iwl_priv *priv)
541 break; 519 break;
542 case IWL_DEVICE_FAMILY_6050: 520 case IWL_DEVICE_FAMILY_6050:
543 /* Indicate calibration version to uCode. */ 521 /* Indicate calibration version to uCode. */
544 if (iwl_eeprom_calib_version(priv) >= 6) 522 if (priv->eeprom_data->calib_version >= 6)
545 iwl_set_bit(priv->trans, CSR_GP_DRIVER_REG, 523 iwl_set_bit(priv->trans, CSR_GP_DRIVER_REG,
546 CSR_GP_DRIVER_REG_BIT_CALIB_VERSION6); 524 CSR_GP_DRIVER_REG_BIT_CALIB_VERSION6);
547 break; 525 break;
548 case IWL_DEVICE_FAMILY_6150: 526 case IWL_DEVICE_FAMILY_6150:
549 /* Indicate calibration version to uCode. */ 527 /* Indicate calibration version to uCode. */
550 if (iwl_eeprom_calib_version(priv) >= 6) 528 if (priv->eeprom_data->calib_version >= 6)
551 iwl_set_bit(priv->trans, CSR_GP_DRIVER_REG, 529 iwl_set_bit(priv->trans, CSR_GP_DRIVER_REG,
552 CSR_GP_DRIVER_REG_BIT_CALIB_VERSION6); 530 CSR_GP_DRIVER_REG_BIT_CALIB_VERSION6);
553 iwl_set_bit(priv->trans, CSR_GP_DRIVER_REG, 531 iwl_set_bit(priv->trans, CSR_GP_DRIVER_REG,
@@ -658,18 +636,6 @@ struct iwl_lib_ops iwl6000_lib = {
658 .set_hw_params = iwl6000_hw_set_hw_params, 636 .set_hw_params = iwl6000_hw_set_hw_params,
659 .set_channel_switch = iwl6000_hw_channel_switch, 637 .set_channel_switch = iwl6000_hw_channel_switch,
660 .nic_config = iwl6000_nic_config, 638 .nic_config = iwl6000_nic_config,
661 .eeprom_ops = {
662 .regulatory_bands = {
663 EEPROM_REG_BAND_1_CHANNELS,
664 EEPROM_REG_BAND_2_CHANNELS,
665 EEPROM_REG_BAND_3_CHANNELS,
666 EEPROM_REG_BAND_4_CHANNELS,
667 EEPROM_REG_BAND_5_CHANNELS,
668 EEPROM_6000_REG_BAND_24_HT40_CHANNELS,
669 EEPROM_REG_BAND_52_HT40_CHANNELS
670 },
671 .enhanced_txpower = true,
672 },
673 .temperature = iwlagn_temperature, 639 .temperature = iwlagn_temperature,
674}; 640};
675 641
@@ -677,17 +643,5 @@ struct iwl_lib_ops iwl6030_lib = {
677 .set_hw_params = iwl6000_hw_set_hw_params, 643 .set_hw_params = iwl6000_hw_set_hw_params,
678 .set_channel_switch = iwl6000_hw_channel_switch, 644 .set_channel_switch = iwl6000_hw_channel_switch,
679 .nic_config = iwl6000_nic_config, 645 .nic_config = iwl6000_nic_config,
680 .eeprom_ops = {
681 .regulatory_bands = {
682 EEPROM_REG_BAND_1_CHANNELS,
683 EEPROM_REG_BAND_2_CHANNELS,
684 EEPROM_REG_BAND_3_CHANNELS,
685 EEPROM_REG_BAND_4_CHANNELS,
686 EEPROM_REG_BAND_5_CHANNELS,
687 EEPROM_6000_REG_BAND_24_HT40_CHANNELS,
688 EEPROM_REG_BAND_52_HT40_CHANNELS
689 },
690 .enhanced_txpower = true,
691 },
692 .temperature = iwlagn_temperature, 646 .temperature = iwlagn_temperature,
693}; 647};
diff --git a/drivers/net/wireless/iwlwifi/dvm/eeprom.c b/drivers/net/wireless/iwlwifi/dvm/eeprom.c
deleted file mode 100644
index b382b16b89d7..000000000000
--- a/drivers/net/wireless/iwlwifi/dvm/eeprom.c
+++ /dev/null
@@ -1,1163 +0,0 @@
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 - 2012 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 LICENSE.GPL.
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 - 2012 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
63
64#include <linux/kernel.h>
65#include <linux/module.h>
66#include <linux/slab.h>
67#include <linux/init.h>
68#include <net/mac80211.h>
69#include "iwl-io.h"
70#include "iwl-prph.h"
71#include "iwl-debug.h"
72#include "dev.h"
73#include "agn.h"
74#include "eeprom.h"
75
76/************************** EEPROM BANDS ****************************
77 *
78 * The iwl_eeprom_band definitions below provide the mapping from the
79 * EEPROM contents to the specific channel number supported for each
80 * band.
81 *
82 * For example, iwl_priv->eeprom.band_3_channels[4] from the band_3
83 * definition below maps to physical channel 42 in the 5.2GHz spectrum.
84 * The specific geography and calibration information for that channel
85 * is contained in the eeprom map itself.
86 *
87 * During init, we copy the eeprom information and channel map
88 * information into priv->channel_info_24/52 and priv->channel_map_24/52
89 *
90 * channel_map_24/52 provides the index in the channel_info array for a
91 * given channel. We have to have two separate maps as there is channel
92 * overlap with the 2.4GHz and 5.2GHz spectrum as seen in band_1 and
93 * band_2
94 *
95 * A value of 0xff stored in the channel_map indicates that the channel
96 * is not supported by the hardware at all.
97 *
98 * A value of 0xfe in the channel_map indicates that the channel is not
99 * valid for Tx with the current hardware. This means that
100 * while the system can tune and receive on a given channel, it may not
101 * be able to associate or transmit any frames on that
102 * channel. There is no corresponding channel information for that
103 * entry.
104 *
105 *********************************************************************/
106
107/* 2.4 GHz */
108const u8 iwl_eeprom_band_1[14] = {
109 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14
110};
111
112/* 5.2 GHz bands */
113static const u8 iwl_eeprom_band_2[] = { /* 4915-5080MHz */
114 183, 184, 185, 187, 188, 189, 192, 196, 7, 8, 11, 12, 16
115};
116
117static const u8 iwl_eeprom_band_3[] = { /* 5170-5320MHz */
118 34, 36, 38, 40, 42, 44, 46, 48, 52, 56, 60, 64
119};
120
121static const u8 iwl_eeprom_band_4[] = { /* 5500-5700MHz */
122 100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140
123};
124
125static const u8 iwl_eeprom_band_5[] = { /* 5725-5825MHz */
126 145, 149, 153, 157, 161, 165
127};
128
129static const u8 iwl_eeprom_band_6[] = { /* 2.4 ht40 channel */
130 1, 2, 3, 4, 5, 6, 7
131};
132
133static const u8 iwl_eeprom_band_7[] = { /* 5.2 ht40 channel */
134 36, 44, 52, 60, 100, 108, 116, 124, 132, 149, 157
135};
136
137/******************************************************************************
138 *
139 * generic NVM functions
140 *
141******************************************************************************/
142
143/*
144 * The device's EEPROM semaphore prevents conflicts between driver and uCode
145 * when accessing the EEPROM; each access is a series of pulses to/from the
146 * EEPROM chip, not a single event, so even reads could conflict if they
147 * weren't arbitrated by the semaphore.
148 */
149
150#define EEPROM_SEM_TIMEOUT 10 /* milliseconds */
151#define EEPROM_SEM_RETRY_LIMIT 1000 /* number of attempts (not time) */
152
153static int iwl_eeprom_acquire_semaphore(struct iwl_trans *trans)
154{
155 u16 count;
156 int ret;
157
158 for (count = 0; count < EEPROM_SEM_RETRY_LIMIT; count++) {
159 /* Request semaphore */
160 iwl_set_bit(trans, CSR_HW_IF_CONFIG_REG,
161 CSR_HW_IF_CONFIG_REG_BIT_EEPROM_OWN_SEM);
162
163 /* See if we got it */
164 ret = iwl_poll_bit(trans, CSR_HW_IF_CONFIG_REG,
165 CSR_HW_IF_CONFIG_REG_BIT_EEPROM_OWN_SEM,
166 CSR_HW_IF_CONFIG_REG_BIT_EEPROM_OWN_SEM,
167 EEPROM_SEM_TIMEOUT);
168 if (ret >= 0) {
169 IWL_DEBUG_EEPROM(trans,
170 "Acquired semaphore after %d tries.\n",
171 count+1);
172 return ret;
173 }
174 }
175
176 return ret;
177}
178
179static void iwl_eeprom_release_semaphore(struct iwl_trans *trans)
180{
181 iwl_clear_bit(trans, CSR_HW_IF_CONFIG_REG,
182 CSR_HW_IF_CONFIG_REG_BIT_EEPROM_OWN_SEM);
183
184}
185
186static int iwl_eeprom_verify_signature(struct iwl_priv *priv)
187{
188 u32 gp = iwl_read32(priv->trans, CSR_EEPROM_GP) &
189 CSR_EEPROM_GP_VALID_MSK;
190 int ret = 0;
191
192 IWL_DEBUG_EEPROM(priv, "EEPROM signature=0x%08x\n", gp);
193 switch (gp) {
194 case CSR_EEPROM_GP_BAD_SIG_EEP_GOOD_SIG_OTP:
195 if (priv->nvm_device_type != NVM_DEVICE_TYPE_OTP) {
196 IWL_ERR(priv, "EEPROM with bad signature: 0x%08x\n",
197 gp);
198 ret = -ENOENT;
199 }
200 break;
201 case CSR_EEPROM_GP_GOOD_SIG_EEP_LESS_THAN_4K:
202 case CSR_EEPROM_GP_GOOD_SIG_EEP_MORE_THAN_4K:
203 if (priv->nvm_device_type != NVM_DEVICE_TYPE_EEPROM) {
204 IWL_ERR(priv, "OTP with bad signature: 0x%08x\n", gp);
205 ret = -ENOENT;
206 }
207 break;
208 case CSR_EEPROM_GP_BAD_SIGNATURE_BOTH_EEP_AND_OTP:
209 default:
210 IWL_ERR(priv, "bad EEPROM/OTP signature, type=%s, "
211 "EEPROM_GP=0x%08x\n",
212 (priv->nvm_device_type == NVM_DEVICE_TYPE_OTP)
213 ? "OTP" : "EEPROM", gp);
214 ret = -ENOENT;
215 break;
216 }
217 return ret;
218}
219
220u16 iwl_eeprom_query16(struct iwl_priv *priv, size_t offset)
221{
222 if (!priv->eeprom)
223 return 0;
224 return (u16)priv->eeprom[offset] | ((u16)priv->eeprom[offset + 1] << 8);
225}
226
227int iwl_eeprom_check_version(struct iwl_priv *priv)
228{
229 u16 eeprom_ver;
230 u16 calib_ver;
231
232 eeprom_ver = iwl_eeprom_query16(priv, EEPROM_VERSION);
233 calib_ver = iwl_eeprom_calib_version(priv);
234
235 if (eeprom_ver < priv->cfg->eeprom_ver ||
236 calib_ver < priv->cfg->eeprom_calib_ver)
237 goto err;
238
239 IWL_INFO(priv, "device EEPROM VER=0x%x, CALIB=0x%x\n",
240 eeprom_ver, calib_ver);
241
242 return 0;
243err:
244 IWL_ERR(priv, "Unsupported (too old) EEPROM VER=0x%x < 0x%x "
245 "CALIB=0x%x < 0x%x\n",
246 eeprom_ver, priv->cfg->eeprom_ver,
247 calib_ver, priv->cfg->eeprom_calib_ver);
248 return -EINVAL;
249
250}
251
252int iwl_eeprom_init_hw_params(struct iwl_priv *priv)
253{
254 u16 radio_cfg;
255
256 priv->hw_params.sku = iwl_eeprom_query16(priv, EEPROM_SKU_CAP);
257 if (priv->hw_params.sku & EEPROM_SKU_CAP_11N_ENABLE &&
258 !priv->cfg->ht_params) {
259 IWL_ERR(priv, "Invalid 11n configuration\n");
260 return -EINVAL;
261 }
262
263 if (!priv->hw_params.sku) {
264 IWL_ERR(priv, "Invalid device sku\n");
265 return -EINVAL;
266 }
267
268 IWL_INFO(priv, "Device SKU: 0x%X\n", priv->hw_params.sku);
269
270 radio_cfg = iwl_eeprom_query16(priv, EEPROM_RADIO_CONFIG);
271
272 priv->hw_params.valid_tx_ant = EEPROM_RF_CFG_TX_ANT_MSK(radio_cfg);
273 priv->hw_params.valid_rx_ant = EEPROM_RF_CFG_RX_ANT_MSK(radio_cfg);
274
275 /* check overrides (some devices have wrong EEPROM) */
276 if (priv->cfg->valid_tx_ant)
277 priv->hw_params.valid_tx_ant = priv->cfg->valid_tx_ant;
278 if (priv->cfg->valid_rx_ant)
279 priv->hw_params.valid_rx_ant = priv->cfg->valid_rx_ant;
280
281 if (!priv->hw_params.valid_tx_ant || !priv->hw_params.valid_rx_ant) {
282 IWL_ERR(priv, "Invalid chain (0x%X, 0x%X)\n",
283 priv->hw_params.valid_tx_ant,
284 priv->hw_params.valid_rx_ant);
285 return -EINVAL;
286 }
287
288 priv->hw_params.tx_chains_num =
289 num_of_ant(priv->hw_params.valid_tx_ant);
290 if (priv->cfg->rx_with_siso_diversity)
291 priv->hw_params.rx_chains_num = 1;
292 else
293 priv->hw_params.rx_chains_num =
294 num_of_ant(priv->hw_params.valid_rx_ant);
295
296 IWL_INFO(priv, "Valid Tx ant: 0x%X, Valid Rx ant: 0x%X\n",
297 priv->hw_params.valid_tx_ant, priv->hw_params.valid_rx_ant);
298
299 return 0;
300}
301
302u16 iwl_eeprom_calib_version(struct iwl_priv *priv)
303{
304 struct iwl_eeprom_calib_hdr *hdr;
305
306 hdr = (struct iwl_eeprom_calib_hdr *)iwl_eeprom_query_addr(priv,
307 EEPROM_CALIB_ALL);
308 return hdr->version;
309}
310
311static u32 eeprom_indirect_address(struct iwl_priv *priv, u32 address)
312{
313 u16 offset = 0;
314
315 if ((address & INDIRECT_ADDRESS) == 0)
316 return address;
317
318 switch (address & INDIRECT_TYPE_MSK) {
319 case INDIRECT_HOST:
320 offset = iwl_eeprom_query16(priv, EEPROM_LINK_HOST);
321 break;
322 case INDIRECT_GENERAL:
323 offset = iwl_eeprom_query16(priv, EEPROM_LINK_GENERAL);
324 break;
325 case INDIRECT_REGULATORY:
326 offset = iwl_eeprom_query16(priv, EEPROM_LINK_REGULATORY);
327 break;
328 case INDIRECT_TXP_LIMIT:
329 offset = iwl_eeprom_query16(priv, EEPROM_LINK_TXP_LIMIT);
330 break;
331 case INDIRECT_TXP_LIMIT_SIZE:
332 offset = iwl_eeprom_query16(priv, EEPROM_LINK_TXP_LIMIT_SIZE);
333 break;
334 case INDIRECT_CALIBRATION:
335 offset = iwl_eeprom_query16(priv, EEPROM_LINK_CALIBRATION);
336 break;
337 case INDIRECT_PROCESS_ADJST:
338 offset = iwl_eeprom_query16(priv, EEPROM_LINK_PROCESS_ADJST);
339 break;
340 case INDIRECT_OTHERS:
341 offset = iwl_eeprom_query16(priv, EEPROM_LINK_OTHERS);
342 break;
343 default:
344 IWL_ERR(priv, "illegal indirect type: 0x%X\n",
345 address & INDIRECT_TYPE_MSK);
346 break;
347 }
348
349 /* translate the offset from words to byte */
350 return (address & ADDRESS_MSK) + (offset << 1);
351}
352
353const u8 *iwl_eeprom_query_addr(struct iwl_priv *priv, size_t offset)
354{
355 u32 address = eeprom_indirect_address(priv, offset);
356 BUG_ON(address >= priv->cfg->base_params->eeprom_size);
357 return &priv->eeprom[address];
358}
359
360void iwl_eeprom_get_mac(struct iwl_priv *priv, u8 *mac)
361{
362 const u8 *addr = iwl_eeprom_query_addr(priv,
363 EEPROM_MAC_ADDRESS);
364 memcpy(mac, addr, ETH_ALEN);
365}
366
367/******************************************************************************
368 *
369 * OTP related functions
370 *
371******************************************************************************/
372
373static void iwl_set_otp_access(struct iwl_trans *trans,
374 enum iwl_access_mode mode)
375{
376 iwl_read32(trans, CSR_OTP_GP_REG);
377
378 if (mode == IWL_OTP_ACCESS_ABSOLUTE)
379 iwl_clear_bit(trans, CSR_OTP_GP_REG,
380 CSR_OTP_GP_REG_OTP_ACCESS_MODE);
381 else
382 iwl_set_bit(trans, CSR_OTP_GP_REG,
383 CSR_OTP_GP_REG_OTP_ACCESS_MODE);
384}
385
386static int iwl_get_nvm_type(struct iwl_trans *trans, u32 hw_rev)
387{
388 u32 otpgp;
389 int nvm_type;
390
391 /* OTP only valid for CP/PP and after */
392 switch (hw_rev & CSR_HW_REV_TYPE_MSK) {
393 case CSR_HW_REV_TYPE_NONE:
394 IWL_ERR(trans, "Unknown hardware type\n");
395 return -ENOENT;
396 case CSR_HW_REV_TYPE_5300:
397 case CSR_HW_REV_TYPE_5350:
398 case CSR_HW_REV_TYPE_5100:
399 case CSR_HW_REV_TYPE_5150:
400 nvm_type = NVM_DEVICE_TYPE_EEPROM;
401 break;
402 default:
403 otpgp = iwl_read32(trans, CSR_OTP_GP_REG);
404 if (otpgp & CSR_OTP_GP_REG_DEVICE_SELECT)
405 nvm_type = NVM_DEVICE_TYPE_OTP;
406 else
407 nvm_type = NVM_DEVICE_TYPE_EEPROM;
408 break;
409 }
410 return nvm_type;
411}
412
413static int iwl_init_otp_access(struct iwl_trans *trans)
414{
415 int ret;
416
417 /* Enable 40MHz radio clock */
418 iwl_write32(trans, CSR_GP_CNTRL,
419 iwl_read32(trans, CSR_GP_CNTRL) |
420 CSR_GP_CNTRL_REG_FLAG_INIT_DONE);
421
422 /* wait for clock to be ready */
423 ret = iwl_poll_bit(trans, CSR_GP_CNTRL,
424 CSR_GP_CNTRL_REG_FLAG_MAC_CLOCK_READY,
425 CSR_GP_CNTRL_REG_FLAG_MAC_CLOCK_READY,
426 25000);
427 if (ret < 0)
428 IWL_ERR(trans, "Time out access OTP\n");
429 else {
430 iwl_set_bits_prph(trans, APMG_PS_CTRL_REG,
431 APMG_PS_CTRL_VAL_RESET_REQ);
432 udelay(5);
433 iwl_clear_bits_prph(trans, APMG_PS_CTRL_REG,
434 APMG_PS_CTRL_VAL_RESET_REQ);
435
436 /*
437 * CSR auto clock gate disable bit -
438 * this is only applicable for HW with OTP shadow RAM
439 */
440 if (trans->cfg->base_params->shadow_ram_support)
441 iwl_set_bit(trans, CSR_DBG_LINK_PWR_MGMT_REG,
442 CSR_RESET_LINK_PWR_MGMT_DISABLED);
443 }
444 return ret;
445}
446
447static int iwl_read_otp_word(struct iwl_trans *trans, u16 addr,
448 __le16 *eeprom_data)
449{
450 int ret = 0;
451 u32 r;
452 u32 otpgp;
453
454 iwl_write32(trans, CSR_EEPROM_REG,
455 CSR_EEPROM_REG_MSK_ADDR & (addr << 1));
456 ret = iwl_poll_bit(trans, CSR_EEPROM_REG,
457 CSR_EEPROM_REG_READ_VALID_MSK,
458 CSR_EEPROM_REG_READ_VALID_MSK,
459 IWL_EEPROM_ACCESS_TIMEOUT);
460 if (ret < 0) {
461 IWL_ERR(trans, "Time out reading OTP[%d]\n", addr);
462 return ret;
463 }
464 r = iwl_read32(trans, CSR_EEPROM_REG);
465 /* check for ECC errors: */
466 otpgp = iwl_read32(trans, CSR_OTP_GP_REG);
467 if (otpgp & CSR_OTP_GP_REG_ECC_UNCORR_STATUS_MSK) {
468 /* stop in this case */
469 /* set the uncorrectable OTP ECC bit for acknowledgement */
470 iwl_set_bit(trans, CSR_OTP_GP_REG,
471 CSR_OTP_GP_REG_ECC_UNCORR_STATUS_MSK);
472 IWL_ERR(trans, "Uncorrectable OTP ECC error, abort OTP read\n");
473 return -EINVAL;
474 }
475 if (otpgp & CSR_OTP_GP_REG_ECC_CORR_STATUS_MSK) {
476 /* continue in this case */
477 /* set the correctable OTP ECC bit for acknowledgement */
478 iwl_set_bit(trans, CSR_OTP_GP_REG,
479 CSR_OTP_GP_REG_ECC_CORR_STATUS_MSK);
480 IWL_ERR(trans, "Correctable OTP ECC error, continue read\n");
481 }
482 *eeprom_data = cpu_to_le16(r >> 16);
483 return 0;
484}
485
486/*
487 * iwl_is_otp_empty: check for empty OTP
488 */
489static bool iwl_is_otp_empty(struct iwl_trans *trans)
490{
491 u16 next_link_addr = 0;
492 __le16 link_value;
493 bool is_empty = false;
494
495 /* locate the beginning of OTP link list */
496 if (!iwl_read_otp_word(trans, next_link_addr, &link_value)) {
497 if (!link_value) {
498 IWL_ERR(trans, "OTP is empty\n");
499 is_empty = true;
500 }
501 } else {
502 IWL_ERR(trans, "Unable to read first block of OTP list.\n");
503 is_empty = true;
504 }
505
506 return is_empty;
507}
508
509
510/*
511 * iwl_find_otp_image: find EEPROM image in OTP
512 * finding the OTP block that contains the EEPROM image.
513 * the last valid block on the link list (the block _before_ the last block)
514 * is the block we should read and used to configure the device.
515 * If all the available OTP blocks are full, the last block will be the block
516 * we should read and used to configure the device.
517 * only perform this operation if shadow RAM is disabled
518 */
519static int iwl_find_otp_image(struct iwl_trans *trans,
520 u16 *validblockaddr)
521{
522 u16 next_link_addr = 0, valid_addr;
523 __le16 link_value = 0;
524 int usedblocks = 0;
525
526 /* set addressing mode to absolute to traverse the link list */
527 iwl_set_otp_access(trans, IWL_OTP_ACCESS_ABSOLUTE);
528
529 /* checking for empty OTP or error */
530 if (iwl_is_otp_empty(trans))
531 return -EINVAL;
532
533 /*
534 * start traverse link list
535 * until reach the max number of OTP blocks
536 * different devices have different number of OTP blocks
537 */
538 do {
539 /* save current valid block address
540 * check for more block on the link list
541 */
542 valid_addr = next_link_addr;
543 next_link_addr = le16_to_cpu(link_value) * sizeof(u16);
544 IWL_DEBUG_EEPROM(trans, "OTP blocks %d addr 0x%x\n",
545 usedblocks, next_link_addr);
546 if (iwl_read_otp_word(trans, next_link_addr, &link_value))
547 return -EINVAL;
548 if (!link_value) {
549 /*
550 * reach the end of link list, return success and
551 * set address point to the starting address
552 * of the image
553 */
554 *validblockaddr = valid_addr;
555 /* skip first 2 bytes (link list pointer) */
556 *validblockaddr += 2;
557 return 0;
558 }
559 /* more in the link list, continue */
560 usedblocks++;
561 } while (usedblocks <= trans->cfg->base_params->max_ll_items);
562
563 /* OTP has no valid blocks */
564 IWL_DEBUG_EEPROM(trans, "OTP has no valid blocks\n");
565 return -EINVAL;
566}
567
568/******************************************************************************
569 *
570 * Tx Power related functions
571 *
572******************************************************************************/
573/**
574 * iwl_get_max_txpower_avg - get the highest tx power from all chains.
575 * find the highest tx power from all chains for the channel
576 */
577static s8 iwl_get_max_txpower_avg(const struct iwl_cfg *cfg,
578 struct iwl_eeprom_enhanced_txpwr *enhanced_txpower,
579 int element, s8 *max_txpower_in_half_dbm)
580{
581 s8 max_txpower_avg = 0; /* (dBm) */
582
583 /* Take the highest tx power from any valid chains */
584 if ((cfg->valid_tx_ant & ANT_A) &&
585 (enhanced_txpower[element].chain_a_max > max_txpower_avg))
586 max_txpower_avg = enhanced_txpower[element].chain_a_max;
587 if ((cfg->valid_tx_ant & ANT_B) &&
588 (enhanced_txpower[element].chain_b_max > max_txpower_avg))
589 max_txpower_avg = enhanced_txpower[element].chain_b_max;
590 if ((cfg->valid_tx_ant & ANT_C) &&
591 (enhanced_txpower[element].chain_c_max > max_txpower_avg))
592 max_txpower_avg = enhanced_txpower[element].chain_c_max;
593 if (((cfg->valid_tx_ant == ANT_AB) |
594 (cfg->valid_tx_ant == ANT_BC) |
595 (cfg->valid_tx_ant == ANT_AC)) &&
596 (enhanced_txpower[element].mimo2_max > max_txpower_avg))
597 max_txpower_avg = enhanced_txpower[element].mimo2_max;
598 if ((cfg->valid_tx_ant == ANT_ABC) &&
599 (enhanced_txpower[element].mimo3_max > max_txpower_avg))
600 max_txpower_avg = enhanced_txpower[element].mimo3_max;
601
602 /*
603 * max. tx power in EEPROM is in 1/2 dBm format
604 * convert from 1/2 dBm to dBm (round-up convert)
605 * but we also do not want to loss 1/2 dBm resolution which
606 * will impact performance
607 */
608 *max_txpower_in_half_dbm = max_txpower_avg;
609 return (max_txpower_avg & 0x01) + (max_txpower_avg >> 1);
610}
611
612static void
613iwl_eeprom_enh_txp_read_element(struct iwl_priv *priv,
614 struct iwl_eeprom_enhanced_txpwr *txp,
615 s8 max_txpower_avg)
616{
617 int ch_idx;
618 bool is_ht40 = txp->flags & IWL_EEPROM_ENH_TXP_FL_40MHZ;
619 enum ieee80211_band band;
620
621 band = txp->flags & IWL_EEPROM_ENH_TXP_FL_BAND_52G ?
622 IEEE80211_BAND_5GHZ : IEEE80211_BAND_2GHZ;
623
624 for (ch_idx = 0; ch_idx < priv->channel_count; ch_idx++) {
625 struct iwl_channel_info *ch_info = &priv->channel_info[ch_idx];
626
627 /* update matching channel or from common data only */
628 if (txp->channel != 0 && ch_info->channel != txp->channel)
629 continue;
630
631 /* update matching band only */
632 if (band != ch_info->band)
633 continue;
634
635 if (ch_info->max_power_avg < max_txpower_avg && !is_ht40) {
636 ch_info->max_power_avg = max_txpower_avg;
637 ch_info->curr_txpow = max_txpower_avg;
638 ch_info->scan_power = max_txpower_avg;
639 }
640
641 if (is_ht40 && ch_info->ht40_max_power_avg < max_txpower_avg)
642 ch_info->ht40_max_power_avg = max_txpower_avg;
643 }
644}
645
646#define EEPROM_TXP_OFFS (0x00 | INDIRECT_ADDRESS | INDIRECT_TXP_LIMIT)
647#define EEPROM_TXP_ENTRY_LEN sizeof(struct iwl_eeprom_enhanced_txpwr)
648#define EEPROM_TXP_SZ_OFFS (0x00 | INDIRECT_ADDRESS | INDIRECT_TXP_LIMIT_SIZE)
649
650#define TXP_CHECK_AND_PRINT(x) ((txp->flags & IWL_EEPROM_ENH_TXP_FL_##x) \
651 ? # x " " : "")
652
653static void iwl_eeprom_enhanced_txpower(struct iwl_priv *priv)
654{
655 struct iwl_eeprom_enhanced_txpwr *txp_array, *txp;
656 int idx, entries;
657 __le16 *txp_len;
658 s8 max_txp_avg, max_txp_avg_halfdbm;
659
660 BUILD_BUG_ON(sizeof(struct iwl_eeprom_enhanced_txpwr) != 8);
661
662 /* the length is in 16-bit words, but we want entries */
663 txp_len = (__le16 *) iwl_eeprom_query_addr(priv, EEPROM_TXP_SZ_OFFS);
664 entries = le16_to_cpup(txp_len) * 2 / EEPROM_TXP_ENTRY_LEN;
665
666 txp_array = (void *) iwl_eeprom_query_addr(priv, EEPROM_TXP_OFFS);
667
668 for (idx = 0; idx < entries; idx++) {
669 txp = &txp_array[idx];
670 /* skip invalid entries */
671 if (!(txp->flags & IWL_EEPROM_ENH_TXP_FL_VALID))
672 continue;
673
674 IWL_DEBUG_EEPROM(priv, "%s %d:\t %s%s%s%s%s%s%s%s (0x%02x)\n",
675 (txp->channel && (txp->flags &
676 IWL_EEPROM_ENH_TXP_FL_COMMON_TYPE)) ?
677 "Common " : (txp->channel) ?
678 "Channel" : "Common",
679 (txp->channel),
680 TXP_CHECK_AND_PRINT(VALID),
681 TXP_CHECK_AND_PRINT(BAND_52G),
682 TXP_CHECK_AND_PRINT(OFDM),
683 TXP_CHECK_AND_PRINT(40MHZ),
684 TXP_CHECK_AND_PRINT(HT_AP),
685 TXP_CHECK_AND_PRINT(RES1),
686 TXP_CHECK_AND_PRINT(RES2),
687 TXP_CHECK_AND_PRINT(COMMON_TYPE),
688 txp->flags);
689 IWL_DEBUG_EEPROM(priv, "\t\t chain_A: 0x%02x "
690 "chain_B: 0X%02x chain_C: 0X%02x\n",
691 txp->chain_a_max, txp->chain_b_max,
692 txp->chain_c_max);
693 IWL_DEBUG_EEPROM(priv, "\t\t MIMO2: 0x%02x "
694 "MIMO3: 0x%02x High 20_on_40: 0x%02x "
695 "Low 20_on_40: 0x%02x\n",
696 txp->mimo2_max, txp->mimo3_max,
697 ((txp->delta_20_in_40 & 0xf0) >> 4),
698 (txp->delta_20_in_40 & 0x0f));
699
700 max_txp_avg = iwl_get_max_txpower_avg(priv->cfg, txp_array, idx,
701 &max_txp_avg_halfdbm);
702
703 /*
704 * Update the user limit values values to the highest
705 * power supported by any channel
706 */
707 if (max_txp_avg > priv->tx_power_user_lmt)
708 priv->tx_power_user_lmt = max_txp_avg;
709 if (max_txp_avg_halfdbm > priv->tx_power_lmt_in_half_dbm)
710 priv->tx_power_lmt_in_half_dbm = max_txp_avg_halfdbm;
711
712 iwl_eeprom_enh_txp_read_element(priv, txp, max_txp_avg);
713 }
714}
715
716/**
717 * iwl_eeprom_init - read EEPROM contents
718 *
719 * Load the EEPROM contents from adapter into priv->eeprom
720 *
721 * NOTE: This routine uses the non-debug IO access functions.
722 */
723int iwl_eeprom_init(struct iwl_priv *priv, u32 hw_rev)
724{
725 __le16 *e;
726 u32 gp = iwl_read32(priv->trans, CSR_EEPROM_GP);
727 int sz;
728 int ret;
729 u16 addr;
730 u16 validblockaddr = 0;
731 u16 cache_addr = 0;
732
733 priv->nvm_device_type = iwl_get_nvm_type(priv->trans, hw_rev);
734 if (priv->nvm_device_type == -ENOENT)
735 return -ENOENT;
736 /* allocate eeprom */
737 sz = priv->cfg->base_params->eeprom_size;
738 IWL_DEBUG_EEPROM(priv, "NVM size = %d\n", sz);
739 priv->eeprom = kzalloc(sz, GFP_KERNEL);
740 if (!priv->eeprom) {
741 ret = -ENOMEM;
742 goto alloc_err;
743 }
744 e = (__le16 *)priv->eeprom;
745
746 ret = iwl_eeprom_verify_signature(priv);
747 if (ret < 0) {
748 IWL_ERR(priv, "EEPROM not found, EEPROM_GP=0x%08x\n", gp);
749 ret = -ENOENT;
750 goto err;
751 }
752
753 /* Make sure driver (instead of uCode) is allowed to read EEPROM */
754 ret = iwl_eeprom_acquire_semaphore(priv->trans);
755 if (ret < 0) {
756 IWL_ERR(priv, "Failed to acquire EEPROM semaphore.\n");
757 ret = -ENOENT;
758 goto err;
759 }
760
761 if (priv->nvm_device_type == NVM_DEVICE_TYPE_OTP) {
762
763 ret = iwl_init_otp_access(priv->trans);
764 if (ret) {
765 IWL_ERR(priv, "Failed to initialize OTP access.\n");
766 ret = -ENOENT;
767 goto done;
768 }
769 iwl_write32(priv->trans, CSR_EEPROM_GP,
770 iwl_read32(priv->trans, CSR_EEPROM_GP) &
771 ~CSR_EEPROM_GP_IF_OWNER_MSK);
772
773 iwl_set_bit(priv->trans, CSR_OTP_GP_REG,
774 CSR_OTP_GP_REG_ECC_CORR_STATUS_MSK |
775 CSR_OTP_GP_REG_ECC_UNCORR_STATUS_MSK);
776 /* traversing the linked list if no shadow ram supported */
777 if (!priv->cfg->base_params->shadow_ram_support) {
778 if (iwl_find_otp_image(priv->trans, &validblockaddr)) {
779 ret = -ENOENT;
780 goto done;
781 }
782 }
783 for (addr = validblockaddr; addr < validblockaddr + sz;
784 addr += sizeof(u16)) {
785 __le16 eeprom_data;
786
787 ret = iwl_read_otp_word(priv->trans, addr,
788 &eeprom_data);
789 if (ret)
790 goto done;
791 e[cache_addr / 2] = eeprom_data;
792 cache_addr += sizeof(u16);
793 }
794 } else {
795 /* eeprom is an array of 16bit values */
796 for (addr = 0; addr < sz; addr += sizeof(u16)) {
797 u32 r;
798
799 iwl_write32(priv->trans, CSR_EEPROM_REG,
800 CSR_EEPROM_REG_MSK_ADDR & (addr << 1));
801
802 ret = iwl_poll_bit(priv->trans, CSR_EEPROM_REG,
803 CSR_EEPROM_REG_READ_VALID_MSK,
804 CSR_EEPROM_REG_READ_VALID_MSK,
805 IWL_EEPROM_ACCESS_TIMEOUT);
806 if (ret < 0) {
807 IWL_ERR(priv,
808 "Time out reading EEPROM[%d]\n", addr);
809 goto done;
810 }
811 r = iwl_read32(priv->trans, CSR_EEPROM_REG);
812 e[addr / 2] = cpu_to_le16(r >> 16);
813 }
814 }
815
816 IWL_DEBUG_EEPROM(priv, "NVM Type: %s, version: 0x%x\n",
817 (priv->nvm_device_type == NVM_DEVICE_TYPE_OTP)
818 ? "OTP" : "EEPROM",
819 iwl_eeprom_query16(priv, EEPROM_VERSION));
820
821 ret = 0;
822done:
823 iwl_eeprom_release_semaphore(priv->trans);
824
825err:
826 if (ret)
827 iwl_eeprom_free(priv);
828alloc_err:
829 return ret;
830}
831
832void iwl_eeprom_free(struct iwl_priv *priv)
833{
834 kfree(priv->eeprom);
835 priv->eeprom = NULL;
836}
837
838static void iwl_init_band_reference(struct iwl_priv *priv,
839 int eep_band, int *eeprom_ch_count,
840 const struct iwl_eeprom_channel **eeprom_ch_info,
841 const u8 **eeprom_ch_index)
842{
843 u32 offset = priv->lib->
844 eeprom_ops.regulatory_bands[eep_band - 1];
845 switch (eep_band) {
846 case 1: /* 2.4GHz band */
847 *eeprom_ch_count = ARRAY_SIZE(iwl_eeprom_band_1);
848 *eeprom_ch_info = (struct iwl_eeprom_channel *)
849 iwl_eeprom_query_addr(priv, offset);
850 *eeprom_ch_index = iwl_eeprom_band_1;
851 break;
852 case 2: /* 4.9GHz band */
853 *eeprom_ch_count = ARRAY_SIZE(iwl_eeprom_band_2);
854 *eeprom_ch_info = (struct iwl_eeprom_channel *)
855 iwl_eeprom_query_addr(priv, offset);
856 *eeprom_ch_index = iwl_eeprom_band_2;
857 break;
858 case 3: /* 5.2GHz band */
859 *eeprom_ch_count = ARRAY_SIZE(iwl_eeprom_band_3);
860 *eeprom_ch_info = (struct iwl_eeprom_channel *)
861 iwl_eeprom_query_addr(priv, offset);
862 *eeprom_ch_index = iwl_eeprom_band_3;
863 break;
864 case 4: /* 5.5GHz band */
865 *eeprom_ch_count = ARRAY_SIZE(iwl_eeprom_band_4);
866 *eeprom_ch_info = (struct iwl_eeprom_channel *)
867 iwl_eeprom_query_addr(priv, offset);
868 *eeprom_ch_index = iwl_eeprom_band_4;
869 break;
870 case 5: /* 5.7GHz band */
871 *eeprom_ch_count = ARRAY_SIZE(iwl_eeprom_band_5);
872 *eeprom_ch_info = (struct iwl_eeprom_channel *)
873 iwl_eeprom_query_addr(priv, offset);
874 *eeprom_ch_index = iwl_eeprom_band_5;
875 break;
876 case 6: /* 2.4GHz ht40 channels */
877 *eeprom_ch_count = ARRAY_SIZE(iwl_eeprom_band_6);
878 *eeprom_ch_info = (struct iwl_eeprom_channel *)
879 iwl_eeprom_query_addr(priv, offset);
880 *eeprom_ch_index = iwl_eeprom_band_6;
881 break;
882 case 7: /* 5 GHz ht40 channels */
883 *eeprom_ch_count = ARRAY_SIZE(iwl_eeprom_band_7);
884 *eeprom_ch_info = (struct iwl_eeprom_channel *)
885 iwl_eeprom_query_addr(priv, offset);
886 *eeprom_ch_index = iwl_eeprom_band_7;
887 break;
888 default:
889 BUG();
890 return;
891 }
892}
893
894#define CHECK_AND_PRINT(x) ((eeprom_ch->flags & EEPROM_CHANNEL_##x) \
895 ? # x " " : "")
896/**
897 * iwl_mod_ht40_chan_info - Copy ht40 channel info into driver's priv.
898 *
899 * Does not set up a command, or touch hardware.
900 */
901static int iwl_mod_ht40_chan_info(struct iwl_priv *priv,
902 enum ieee80211_band band, u16 channel,
903 const struct iwl_eeprom_channel *eeprom_ch,
904 u8 clear_ht40_extension_channel)
905{
906 struct iwl_channel_info *ch_info;
907
908 ch_info = (struct iwl_channel_info *)
909 iwl_get_channel_info(priv, band, channel);
910
911 if (!is_channel_valid(ch_info))
912 return -1;
913
914 IWL_DEBUG_EEPROM(priv, "HT40 Ch. %d [%sGHz] %s%s%s%s%s(0x%02x %ddBm):"
915 " Ad-Hoc %ssupported\n",
916 ch_info->channel,
917 is_channel_a_band(ch_info) ?
918 "5.2" : "2.4",
919 CHECK_AND_PRINT(IBSS),
920 CHECK_AND_PRINT(ACTIVE),
921 CHECK_AND_PRINT(RADAR),
922 CHECK_AND_PRINT(WIDE),
923 CHECK_AND_PRINT(DFS),
924 eeprom_ch->flags,
925 eeprom_ch->max_power_avg,
926 ((eeprom_ch->flags & EEPROM_CHANNEL_IBSS)
927 && !(eeprom_ch->flags & EEPROM_CHANNEL_RADAR)) ?
928 "" : "not ");
929
930 ch_info->ht40_eeprom = *eeprom_ch;
931 ch_info->ht40_max_power_avg = eeprom_ch->max_power_avg;
932 ch_info->ht40_flags = eeprom_ch->flags;
933 if (eeprom_ch->flags & EEPROM_CHANNEL_VALID)
934 ch_info->ht40_extension_channel &= ~clear_ht40_extension_channel;
935
936 return 0;
937}
938
939#define CHECK_AND_PRINT_I(x) ((eeprom_ch_info[ch].flags & EEPROM_CHANNEL_##x) \
940 ? # x " " : "")
941
942/**
943 * iwl_init_channel_map - Set up driver's info for all possible channels
944 */
945int iwl_init_channel_map(struct iwl_priv *priv)
946{
947 int eeprom_ch_count = 0;
948 const u8 *eeprom_ch_index = NULL;
949 const struct iwl_eeprom_channel *eeprom_ch_info = NULL;
950 int band, ch;
951 struct iwl_channel_info *ch_info;
952
953 if (priv->channel_count) {
954 IWL_DEBUG_EEPROM(priv, "Channel map already initialized.\n");
955 return 0;
956 }
957
958 IWL_DEBUG_EEPROM(priv, "Initializing regulatory info from EEPROM\n");
959
960 priv->channel_count =
961 ARRAY_SIZE(iwl_eeprom_band_1) +
962 ARRAY_SIZE(iwl_eeprom_band_2) +
963 ARRAY_SIZE(iwl_eeprom_band_3) +
964 ARRAY_SIZE(iwl_eeprom_band_4) +
965 ARRAY_SIZE(iwl_eeprom_band_5);
966
967 IWL_DEBUG_EEPROM(priv, "Parsing data for %d channels.\n",
968 priv->channel_count);
969
970 priv->channel_info = kcalloc(priv->channel_count,
971 sizeof(struct iwl_channel_info),
972 GFP_KERNEL);
973 if (!priv->channel_info) {
974 IWL_ERR(priv, "Could not allocate channel_info\n");
975 priv->channel_count = 0;
976 return -ENOMEM;
977 }
978
979 ch_info = priv->channel_info;
980
981 /* Loop through the 5 EEPROM bands adding them in order to the
982 * channel map we maintain (that contains additional information than
983 * what just in the EEPROM) */
984 for (band = 1; band <= 5; band++) {
985
986 iwl_init_band_reference(priv, band, &eeprom_ch_count,
987 &eeprom_ch_info, &eeprom_ch_index);
988
989 /* Loop through each band adding each of the channels */
990 for (ch = 0; ch < eeprom_ch_count; ch++) {
991 ch_info->channel = eeprom_ch_index[ch];
992 ch_info->band = (band == 1) ? IEEE80211_BAND_2GHZ :
993 IEEE80211_BAND_5GHZ;
994
995 /* permanently store EEPROM's channel regulatory flags
996 * and max power in channel info database. */
997 ch_info->eeprom = eeprom_ch_info[ch];
998
999 /* Copy the run-time flags so they are there even on
1000 * invalid channels */
1001 ch_info->flags = eeprom_ch_info[ch].flags;
1002 /* First write that ht40 is not enabled, and then enable
1003 * one by one */
1004 ch_info->ht40_extension_channel =
1005 IEEE80211_CHAN_NO_HT40;
1006
1007 if (!(is_channel_valid(ch_info))) {
1008 IWL_DEBUG_EEPROM(priv,
1009 "Ch. %d Flags %x [%sGHz] - "
1010 "No traffic\n",
1011 ch_info->channel,
1012 ch_info->flags,
1013 is_channel_a_band(ch_info) ?
1014 "5.2" : "2.4");
1015 ch_info++;
1016 continue;
1017 }
1018
1019 /* Initialize regulatory-based run-time data */
1020 ch_info->max_power_avg = ch_info->curr_txpow =
1021 eeprom_ch_info[ch].max_power_avg;
1022 ch_info->scan_power = eeprom_ch_info[ch].max_power_avg;
1023 ch_info->min_power = 0;
1024
1025 IWL_DEBUG_EEPROM(priv, "Ch. %d [%sGHz] "
1026 "%s%s%s%s%s%s(0x%02x %ddBm):"
1027 " Ad-Hoc %ssupported\n",
1028 ch_info->channel,
1029 is_channel_a_band(ch_info) ?
1030 "5.2" : "2.4",
1031 CHECK_AND_PRINT_I(VALID),
1032 CHECK_AND_PRINT_I(IBSS),
1033 CHECK_AND_PRINT_I(ACTIVE),
1034 CHECK_AND_PRINT_I(RADAR),
1035 CHECK_AND_PRINT_I(WIDE),
1036 CHECK_AND_PRINT_I(DFS),
1037 eeprom_ch_info[ch].flags,
1038 eeprom_ch_info[ch].max_power_avg,
1039 ((eeprom_ch_info[ch].
1040 flags & EEPROM_CHANNEL_IBSS)
1041 && !(eeprom_ch_info[ch].
1042 flags & EEPROM_CHANNEL_RADAR))
1043 ? "" : "not ");
1044
1045 ch_info++;
1046 }
1047 }
1048
1049 /* Check if we do have HT40 channels */
1050 if (priv->lib->eeprom_ops.regulatory_bands[5] ==
1051 EEPROM_REGULATORY_BAND_NO_HT40 &&
1052 priv->lib->eeprom_ops.regulatory_bands[6] ==
1053 EEPROM_REGULATORY_BAND_NO_HT40)
1054 return 0;
1055
1056 /* Two additional EEPROM bands for 2.4 and 5 GHz HT40 channels */
1057 for (band = 6; band <= 7; band++) {
1058 enum ieee80211_band ieeeband;
1059
1060 iwl_init_band_reference(priv, band, &eeprom_ch_count,
1061 &eeprom_ch_info, &eeprom_ch_index);
1062
1063 /* EEPROM band 6 is 2.4, band 7 is 5 GHz */
1064 ieeeband =
1065 (band == 6) ? IEEE80211_BAND_2GHZ : IEEE80211_BAND_5GHZ;
1066
1067 /* Loop through each band adding each of the channels */
1068 for (ch = 0; ch < eeprom_ch_count; ch++) {
1069 /* Set up driver's info for lower half */
1070 iwl_mod_ht40_chan_info(priv, ieeeband,
1071 eeprom_ch_index[ch],
1072 &eeprom_ch_info[ch],
1073 IEEE80211_CHAN_NO_HT40PLUS);
1074
1075 /* Set up driver's info for upper half */
1076 iwl_mod_ht40_chan_info(priv, ieeeband,
1077 eeprom_ch_index[ch] + 4,
1078 &eeprom_ch_info[ch],
1079 IEEE80211_CHAN_NO_HT40MINUS);
1080 }
1081 }
1082
1083 /* for newer device (6000 series and up)
1084 * EEPROM contain enhanced tx power information
1085 * driver need to process addition information
1086 * to determine the max channel tx power limits
1087 */
1088 if (priv->lib->eeprom_ops.enhanced_txpower)
1089 iwl_eeprom_enhanced_txpower(priv);
1090
1091 return 0;
1092}
1093
1094/*
1095 * iwl_free_channel_map - undo allocations in iwl_init_channel_map
1096 */
1097void iwl_free_channel_map(struct iwl_priv *priv)
1098{
1099 kfree(priv->channel_info);
1100 priv->channel_count = 0;
1101}
1102
1103/**
1104 * iwl_get_channel_info - Find driver's private channel info
1105 *
1106 * Based on band and channel number.
1107 */
1108const struct iwl_channel_info *iwl_get_channel_info(const struct iwl_priv *priv,
1109 enum ieee80211_band band, u16 channel)
1110{
1111 int i;
1112
1113 switch (band) {
1114 case IEEE80211_BAND_5GHZ:
1115 for (i = 14; i < priv->channel_count; i++) {
1116 if (priv->channel_info[i].channel == channel)
1117 return &priv->channel_info[i];
1118 }
1119 break;
1120 case IEEE80211_BAND_2GHZ:
1121 if (channel >= 1 && channel <= 14)
1122 return &priv->channel_info[channel - 1];
1123 break;
1124 default:
1125 BUG();
1126 }
1127
1128 return NULL;
1129}
1130
1131void iwl_rf_config(struct iwl_priv *priv)
1132{
1133 u16 radio_cfg;
1134
1135 radio_cfg = iwl_eeprom_query16(priv, EEPROM_RADIO_CONFIG);
1136
1137 /* write radio config values to register */
1138 if (EEPROM_RF_CFG_TYPE_MSK(radio_cfg) <= EEPROM_RF_CONFIG_TYPE_MAX) {
1139 u32 reg_val =
1140 EEPROM_RF_CFG_TYPE_MSK(radio_cfg) <<
1141 CSR_HW_IF_CONFIG_REG_POS_PHY_TYPE |
1142 EEPROM_RF_CFG_STEP_MSK(radio_cfg) <<
1143 CSR_HW_IF_CONFIG_REG_POS_PHY_STEP |
1144 EEPROM_RF_CFG_DASH_MSK(radio_cfg) <<
1145 CSR_HW_IF_CONFIG_REG_POS_PHY_DASH;
1146
1147 iwl_set_bits_mask(priv->trans, CSR_HW_IF_CONFIG_REG,
1148 CSR_HW_IF_CONFIG_REG_MSK_PHY_TYPE |
1149 CSR_HW_IF_CONFIG_REG_MSK_PHY_STEP |
1150 CSR_HW_IF_CONFIG_REG_MSK_PHY_DASH, reg_val);
1151
1152 IWL_INFO(priv, "Radio type=0x%x-0x%x-0x%x\n",
1153 EEPROM_RF_CFG_TYPE_MSK(radio_cfg),
1154 EEPROM_RF_CFG_STEP_MSK(radio_cfg),
1155 EEPROM_RF_CFG_DASH_MSK(radio_cfg));
1156 } else
1157 WARN_ON(1);
1158
1159 /* set CSR_HW_CONFIG_REG for uCode use */
1160 iwl_set_bit(priv->trans, CSR_HW_IF_CONFIG_REG,
1161 CSR_HW_IF_CONFIG_REG_BIT_RADIO_SI |
1162 CSR_HW_IF_CONFIG_REG_BIT_MAC_SI);
1163}
diff --git a/drivers/net/wireless/iwlwifi/dvm/eeprom.h b/drivers/net/wireless/iwlwifi/dvm/eeprom.h
deleted file mode 100644
index 64bfd947caeb..000000000000
--- a/drivers/net/wireless/iwlwifi/dvm/eeprom.h
+++ /dev/null
@@ -1,269 +0,0 @@
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 - 2012 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 LICENSE.GPL.
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 - 2012 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
63#ifndef __iwl_eeprom_h__
64#define __iwl_eeprom_h__
65
66#include <net/mac80211.h>
67
68struct iwl_priv;
69
70/*
71 * EEPROM access time values:
72 *
73 * Driver initiates EEPROM read by writing byte address << 1 to CSR_EEPROM_REG.
74 * Driver then polls CSR_EEPROM_REG for CSR_EEPROM_REG_READ_VALID_MSK (0x1).
75 * When polling, wait 10 uSec between polling loops, up to a maximum 5000 uSec.
76 * Driver reads 16-bit value from bits 31-16 of CSR_EEPROM_REG.
77 */
78#define IWL_EEPROM_ACCESS_TIMEOUT 5000 /* uSec */
79
80#define IWL_EEPROM_SEM_TIMEOUT 10 /* microseconds */
81#define IWL_EEPROM_SEM_RETRY_LIMIT 1000 /* number of attempts (not time) */
82
83
84/*
85 * Regulatory channel usage flags in EEPROM struct iwl4965_eeprom_channel.flags.
86 *
87 * IBSS and/or AP operation is allowed *only* on those channels with
88 * (VALID && IBSS && ACTIVE && !RADAR). This restriction is in place because
89 * RADAR detection is not supported by the 4965 driver, but is a
90 * requirement for establishing a new network for legal operation on channels
91 * requiring RADAR detection or restricting ACTIVE scanning.
92 *
93 * NOTE: "WIDE" flag does not indicate anything about "HT40" 40 MHz channels.
94 * It only indicates that 20 MHz channel use is supported; HT40 channel
95 * usage is indicated by a separate set of regulatory flags for each
96 * HT40 channel pair.
97 *
98 * NOTE: Using a channel inappropriately will result in a uCode error!
99 */
100#define IWL_NUM_TX_CALIB_GROUPS 5
101enum {
102 EEPROM_CHANNEL_VALID = (1 << 0), /* usable for this SKU/geo */
103 EEPROM_CHANNEL_IBSS = (1 << 1), /* usable as an IBSS channel */
104 /* Bit 2 Reserved */
105 EEPROM_CHANNEL_ACTIVE = (1 << 3), /* active scanning allowed */
106 EEPROM_CHANNEL_RADAR = (1 << 4), /* radar detection required */
107 EEPROM_CHANNEL_WIDE = (1 << 5), /* 20 MHz channel okay */
108 /* Bit 6 Reserved (was Narrow Channel) */
109 EEPROM_CHANNEL_DFS = (1 << 7), /* dynamic freq selection candidate */
110};
111
112/* SKU Capabilities */
113#define EEPROM_SKU_CAP_BAND_24GHZ (1 << 4)
114#define EEPROM_SKU_CAP_BAND_52GHZ (1 << 5)
115#define EEPROM_SKU_CAP_11N_ENABLE (1 << 6)
116#define EEPROM_SKU_CAP_AMT_ENABLE (1 << 7)
117#define EEPROM_SKU_CAP_IPAN_ENABLE (1 << 8)
118
119/* *regulatory* channel data format in eeprom, one for each channel.
120 * There are separate entries for HT40 (40 MHz) vs. normal (20 MHz) channels. */
121struct iwl_eeprom_channel {
122 u8 flags; /* EEPROM_CHANNEL_* flags copied from EEPROM */
123 s8 max_power_avg; /* max power (dBm) on this chnl, limit 31 */
124} __packed;
125
126enum iwl_eeprom_enhanced_txpwr_flags {
127 IWL_EEPROM_ENH_TXP_FL_VALID = BIT(0),
128 IWL_EEPROM_ENH_TXP_FL_BAND_52G = BIT(1),
129 IWL_EEPROM_ENH_TXP_FL_OFDM = BIT(2),
130 IWL_EEPROM_ENH_TXP_FL_40MHZ = BIT(3),
131 IWL_EEPROM_ENH_TXP_FL_HT_AP = BIT(4),
132 IWL_EEPROM_ENH_TXP_FL_RES1 = BIT(5),
133 IWL_EEPROM_ENH_TXP_FL_RES2 = BIT(6),
134 IWL_EEPROM_ENH_TXP_FL_COMMON_TYPE = BIT(7),
135};
136
137/**
138 * iwl_eeprom_enhanced_txpwr structure
139 * This structure presents the enhanced regulatory tx power limit layout
140 * in eeprom image
141 * Enhanced regulatory tx power portion of eeprom image can be broken down
142 * into individual structures; each one is 8 bytes in size and contain the
143 * following information
144 * @flags: entry flags
145 * @channel: channel number
146 * @chain_a_max_pwr: chain a max power in 1/2 dBm
147 * @chain_b_max_pwr: chain b max power in 1/2 dBm
148 * @chain_c_max_pwr: chain c max power in 1/2 dBm
149 * @delta_20_in_40: 20-in-40 deltas (hi/lo)
150 * @mimo2_max_pwr: mimo2 max power in 1/2 dBm
151 * @mimo3_max_pwr: mimo3 max power in 1/2 dBm
152 *
153 */
154struct iwl_eeprom_enhanced_txpwr {
155 u8 flags;
156 u8 channel;
157 s8 chain_a_max;
158 s8 chain_b_max;
159 s8 chain_c_max;
160 u8 delta_20_in_40;
161 s8 mimo2_max;
162 s8 mimo3_max;
163} __packed;
164
165/* calibration */
166struct iwl_eeprom_calib_hdr {
167 u8 version;
168 u8 pa_type;
169 __le16 voltage;
170} __packed;
171
172#define EEPROM_CALIB_ALL (INDIRECT_ADDRESS | INDIRECT_CALIBRATION)
173#define EEPROM_XTAL ((2*0x128) | EEPROM_CALIB_ALL)
174
175/* temperature */
176#define EEPROM_KELVIN_TEMPERATURE ((2*0x12A) | EEPROM_CALIB_ALL)
177#define EEPROM_RAW_TEMPERATURE ((2*0x12B) | EEPROM_CALIB_ALL)
178
179
180/* agn links */
181#define EEPROM_LINK_HOST (2*0x64)
182#define EEPROM_LINK_GENERAL (2*0x65)
183#define EEPROM_LINK_REGULATORY (2*0x66)
184#define EEPROM_LINK_CALIBRATION (2*0x67)
185#define EEPROM_LINK_PROCESS_ADJST (2*0x68)
186#define EEPROM_LINK_OTHERS (2*0x69)
187#define EEPROM_LINK_TXP_LIMIT (2*0x6a)
188#define EEPROM_LINK_TXP_LIMIT_SIZE (2*0x6b)
189
190/* agn regulatory - indirect access */
191#define EEPROM_REG_BAND_1_CHANNELS ((0x08)\
192 | INDIRECT_ADDRESS | INDIRECT_REGULATORY) /* 28 bytes */
193#define EEPROM_REG_BAND_2_CHANNELS ((0x26)\
194 | INDIRECT_ADDRESS | INDIRECT_REGULATORY) /* 26 bytes */
195#define EEPROM_REG_BAND_3_CHANNELS ((0x42)\
196 | INDIRECT_ADDRESS | INDIRECT_REGULATORY) /* 24 bytes */
197#define EEPROM_REG_BAND_4_CHANNELS ((0x5C)\
198 | INDIRECT_ADDRESS | INDIRECT_REGULATORY) /* 22 bytes */
199#define EEPROM_REG_BAND_5_CHANNELS ((0x74)\
200 | INDIRECT_ADDRESS | INDIRECT_REGULATORY) /* 12 bytes */
201#define EEPROM_REG_BAND_24_HT40_CHANNELS ((0x82)\
202 | INDIRECT_ADDRESS | INDIRECT_REGULATORY) /* 14 bytes */
203#define EEPROM_REG_BAND_52_HT40_CHANNELS ((0x92)\
204 | INDIRECT_ADDRESS | INDIRECT_REGULATORY) /* 22 bytes */
205
206/* 6000 regulatory - indirect access */
207#define EEPROM_6000_REG_BAND_24_HT40_CHANNELS ((0x80)\
208 | INDIRECT_ADDRESS | INDIRECT_REGULATORY) /* 14 bytes */
209/* 2.4 GHz */
210extern const u8 iwl_eeprom_band_1[14];
211
212#define ADDRESS_MSK 0x0000FFFF
213#define INDIRECT_TYPE_MSK 0x000F0000
214#define INDIRECT_HOST 0x00010000
215#define INDIRECT_GENERAL 0x00020000
216#define INDIRECT_REGULATORY 0x00030000
217#define INDIRECT_CALIBRATION 0x00040000
218#define INDIRECT_PROCESS_ADJST 0x00050000
219#define INDIRECT_OTHERS 0x00060000
220#define INDIRECT_TXP_LIMIT 0x00070000
221#define INDIRECT_TXP_LIMIT_SIZE 0x00080000
222#define INDIRECT_ADDRESS 0x00100000
223
224/* General */
225#define EEPROM_DEVICE_ID (2*0x08) /* 2 bytes */
226#define EEPROM_SUBSYSTEM_ID (2*0x0A) /* 2 bytes */
227#define EEPROM_MAC_ADDRESS (2*0x15) /* 6 bytes */
228#define EEPROM_BOARD_REVISION (2*0x35) /* 2 bytes */
229#define EEPROM_BOARD_PBA_NUMBER (2*0x3B+1) /* 9 bytes */
230#define EEPROM_VERSION (2*0x44) /* 2 bytes */
231#define EEPROM_SKU_CAP (2*0x45) /* 2 bytes */
232#define EEPROM_OEM_MODE (2*0x46) /* 2 bytes */
233#define EEPROM_RADIO_CONFIG (2*0x48) /* 2 bytes */
234#define EEPROM_NUM_MAC_ADDRESS (2*0x4C) /* 2 bytes */
235
236/* The following masks are to be applied on EEPROM_RADIO_CONFIG */
237#define EEPROM_RF_CFG_TYPE_MSK(x) (x & 0x3) /* bits 0-1 */
238#define EEPROM_RF_CFG_STEP_MSK(x) ((x >> 2) & 0x3) /* bits 2-3 */
239#define EEPROM_RF_CFG_DASH_MSK(x) ((x >> 4) & 0x3) /* bits 4-5 */
240#define EEPROM_RF_CFG_PNUM_MSK(x) ((x >> 6) & 0x3) /* bits 6-7 */
241#define EEPROM_RF_CFG_TX_ANT_MSK(x) ((x >> 8) & 0xF) /* bits 8-11 */
242#define EEPROM_RF_CFG_RX_ANT_MSK(x) ((x >> 12) & 0xF) /* bits 12-15 */
243
244#define EEPROM_RF_CONFIG_TYPE_MAX 0x3
245
246#define EEPROM_REGULATORY_BAND_NO_HT40 (0)
247
248struct iwl_eeprom_ops {
249 const u32 regulatory_bands[7];
250 bool enhanced_txpower;
251};
252
253
254int iwl_eeprom_init(struct iwl_priv *priv, u32 hw_rev);
255void iwl_eeprom_free(struct iwl_priv *priv);
256int iwl_eeprom_check_version(struct iwl_priv *priv);
257int iwl_eeprom_init_hw_params(struct iwl_priv *priv);
258u16 iwl_eeprom_calib_version(struct iwl_priv *priv);
259const u8 *iwl_eeprom_query_addr(struct iwl_priv *priv, size_t offset);
260u16 iwl_eeprom_query16(struct iwl_priv *priv, size_t offset);
261void iwl_eeprom_get_mac(struct iwl_priv *priv, u8 *mac);
262int iwl_init_channel_map(struct iwl_priv *priv);
263void iwl_free_channel_map(struct iwl_priv *priv);
264const struct iwl_channel_info *iwl_get_channel_info(
265 const struct iwl_priv *priv,
266 enum ieee80211_band band, u16 channel);
267void iwl_rf_config(struct iwl_priv *priv);
268
269#endif /* __iwl_eeprom_h__ */
diff --git a/drivers/net/wireless/iwlwifi/dvm/lib.c b/drivers/net/wireless/iwlwifi/dvm/lib.c
index 4ac9af7eb853..cb1ca7a25dd5 100644
--- a/drivers/net/wireless/iwlwifi/dvm/lib.c
+++ b/drivers/net/wireless/iwlwifi/dvm/lib.c
@@ -59,8 +59,7 @@ int iwlagn_send_tx_power(struct iwl_priv *priv)
59 /* half dBm need to multiply */ 59 /* half dBm need to multiply */
60 tx_power_cmd.global_lmt = (s8)(2 * priv->tx_power_user_lmt); 60 tx_power_cmd.global_lmt = (s8)(2 * priv->tx_power_user_lmt);
61 61
62 if (priv->tx_power_lmt_in_half_dbm && 62 if (tx_power_cmd.global_lmt > priv->eeprom_data->max_tx_pwr_half_dbm) {
63 priv->tx_power_lmt_in_half_dbm < tx_power_cmd.global_lmt) {
64 /* 63 /*
65 * For the newer devices which using enhanced/extend tx power 64 * For the newer devices which using enhanced/extend tx power
66 * table in EEPROM, the format is in half dBm. driver need to 65 * table in EEPROM, the format is in half dBm. driver need to
@@ -72,7 +71,8 @@ int iwlagn_send_tx_power(struct iwl_priv *priv)
72 * "tx_power_user_lmt" is higher than EEPROM value (in 71 * "tx_power_user_lmt" is higher than EEPROM value (in
73 * half-dBm format), lower the tx power based on EEPROM 72 * half-dBm format), lower the tx power based on EEPROM
74 */ 73 */
75 tx_power_cmd.global_lmt = priv->tx_power_lmt_in_half_dbm; 74 tx_power_cmd.global_lmt =
75 priv->eeprom_data->max_tx_pwr_half_dbm;
76 } 76 }
77 tx_power_cmd.flags = IWLAGN_TX_POWER_NO_CLOSED; 77 tx_power_cmd.flags = IWLAGN_TX_POWER_NO_CLOSED;
78 tx_power_cmd.srv_chan_lmt = IWLAGN_TX_POWER_AUTO; 78 tx_power_cmd.srv_chan_lmt = IWLAGN_TX_POWER_AUTO;
@@ -824,7 +824,7 @@ void iwlagn_set_rxon_chain(struct iwl_priv *priv, struct iwl_rxon_context *ctx)
824 if (priv->chain_noise_data.active_chains) 824 if (priv->chain_noise_data.active_chains)
825 active_chains = priv->chain_noise_data.active_chains; 825 active_chains = priv->chain_noise_data.active_chains;
826 else 826 else
827 active_chains = priv->hw_params.valid_rx_ant; 827 active_chains = priv->eeprom_data->valid_rx_ant;
828 828
829 if (priv->cfg->bt_params && 829 if (priv->cfg->bt_params &&
830 priv->cfg->bt_params->advanced_bt_coexist && 830 priv->cfg->bt_params->advanced_bt_coexist &&
diff --git a/drivers/net/wireless/iwlwifi/dvm/mac80211.c b/drivers/net/wireless/iwlwifi/dvm/mac80211.c
index 32a823d7497f..f60be3993e81 100644
--- a/drivers/net/wireless/iwlwifi/dvm/mac80211.c
+++ b/drivers/net/wireless/iwlwifi/dvm/mac80211.c
@@ -48,7 +48,6 @@
48#include "iwl-op-mode.h" 48#include "iwl-op-mode.h"
49#include "iwl-modparams.h" 49#include "iwl-modparams.h"
50 50
51#include "eeprom.h"
52#include "dev.h" 51#include "dev.h"
53#include "calib.h" 52#include "calib.h"
54#include "agn.h" 53#include "agn.h"
@@ -238,12 +237,12 @@ int iwlagn_mac_setup_register(struct iwl_priv *priv,
238 237
239 hw->max_listen_interval = IWL_CONN_MAX_LISTEN_INTERVAL; 238 hw->max_listen_interval = IWL_CONN_MAX_LISTEN_INTERVAL;
240 239
241 if (priv->bands[IEEE80211_BAND_2GHZ].n_channels) 240 if (priv->eeprom_data->bands[IEEE80211_BAND_2GHZ].n_channels)
242 priv->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = 241 priv->hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
243 &priv->bands[IEEE80211_BAND_2GHZ]; 242 &priv->eeprom_data->bands[IEEE80211_BAND_2GHZ];
244 if (priv->bands[IEEE80211_BAND_5GHZ].n_channels) 243 if (priv->eeprom_data->bands[IEEE80211_BAND_5GHZ].n_channels)
245 priv->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = 244 priv->hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
246 &priv->bands[IEEE80211_BAND_5GHZ]; 245 &priv->eeprom_data->bands[IEEE80211_BAND_5GHZ];
247 246
248 hw->wiphy->hw_version = priv->trans->hw_id; 247 hw->wiphy->hw_version = priv->trans->hw_id;
249 248
diff --git a/drivers/net/wireless/iwlwifi/dvm/main.c b/drivers/net/wireless/iwlwifi/dvm/main.c
index 10a2800687bc..ebdc8b93bc04 100644
--- a/drivers/net/wireless/iwlwifi/dvm/main.c
+++ b/drivers/net/wireless/iwlwifi/dvm/main.c
@@ -44,13 +44,14 @@
44 44
45#include <asm/div64.h> 45#include <asm/div64.h>
46 46
47#include "iwl-eeprom-read.h"
48#include "iwl-eeprom-parse.h"
47#include "iwl-io.h" 49#include "iwl-io.h"
48#include "iwl-trans.h" 50#include "iwl-trans.h"
49#include "iwl-op-mode.h" 51#include "iwl-op-mode.h"
50#include "iwl-drv.h" 52#include "iwl-drv.h"
51#include "iwl-modparams.h" 53#include "iwl-modparams.h"
52 54
53#include "eeprom.h"
54#include "dev.h" 55#include "dev.h"
55#include "calib.h" 56#include "calib.h"
56#include "agn.h" 57#include "agn.h"
@@ -180,7 +181,7 @@ int iwlagn_send_beacon_cmd(struct iwl_priv *priv)
180 rate = info->control.rates[0].idx; 181 rate = info->control.rates[0].idx;
181 182
182 priv->mgmt_tx_ant = iwl_toggle_tx_ant(priv, priv->mgmt_tx_ant, 183 priv->mgmt_tx_ant = iwl_toggle_tx_ant(priv, priv->mgmt_tx_ant,
183 priv->hw_params.valid_tx_ant); 184 priv->eeprom_data->valid_tx_ant);
184 rate_flags = iwl_ant_idx_to_flags(priv->mgmt_tx_ant); 185 rate_flags = iwl_ant_idx_to_flags(priv->mgmt_tx_ant);
185 186
186 /* In mac80211, rates for 5 GHz start at 0 */ 187 /* In mac80211, rates for 5 GHz start at 0 */
@@ -814,7 +815,7 @@ int iwl_alive_start(struct iwl_priv *priv)
814 ieee80211_wake_queues(priv->hw); 815 ieee80211_wake_queues(priv->hw);
815 816
816 /* Configure Tx antenna selection based on H/W config */ 817 /* Configure Tx antenna selection based on H/W config */
817 iwlagn_send_tx_ant_config(priv, priv->hw_params.valid_tx_ant); 818 iwlagn_send_tx_ant_config(priv, priv->eeprom_data->valid_tx_ant);
818 819
819 if (iwl_is_associated_ctx(ctx) && !priv->wowlan) { 820 if (iwl_is_associated_ctx(ctx) && !priv->wowlan) {
820 struct iwl_rxon_cmd *active_rxon = 821 struct iwl_rxon_cmd *active_rxon =
@@ -938,8 +939,6 @@ void iwl_down(struct iwl_priv *priv)
938 /* Clear out all status bits but a few that are stable across reset */ 939 /* Clear out all status bits but a few that are stable across reset */
939 priv->status &= test_bit(STATUS_RF_KILL_HW, &priv->status) << 940 priv->status &= test_bit(STATUS_RF_KILL_HW, &priv->status) <<
940 STATUS_RF_KILL_HW | 941 STATUS_RF_KILL_HW |
941 test_bit(STATUS_GEO_CONFIGURED, &priv->status) <<
942 STATUS_GEO_CONFIGURED |
943 test_bit(STATUS_FW_ERROR, &priv->status) << 942 test_bit(STATUS_FW_ERROR, &priv->status) <<
944 STATUS_FW_ERROR | 943 STATUS_FW_ERROR |
945 test_bit(STATUS_EXIT_PENDING, &priv->status) << 944 test_bit(STATUS_EXIT_PENDING, &priv->status) <<
@@ -1126,227 +1125,14 @@ void iwl_cancel_deferred_work(struct iwl_priv *priv)
1126 del_timer_sync(&priv->ucode_trace); 1125 del_timer_sync(&priv->ucode_trace);
1127} 1126}
1128 1127
1129static void iwl_init_hw_rates(struct ieee80211_rate *rates)
1130{
1131 int i;
1132
1133 for (i = 0; i < IWL_RATE_COUNT_LEGACY; i++) {
1134 rates[i].bitrate = iwl_rates[i].ieee * 5;
1135 rates[i].hw_value = i; /* Rate scaling will work on indexes */
1136 rates[i].hw_value_short = i;
1137 rates[i].flags = 0;
1138 if ((i >= IWL_FIRST_CCK_RATE) && (i <= IWL_LAST_CCK_RATE)) {
1139 /*
1140 * If CCK != 1M then set short preamble rate flag.
1141 */
1142 rates[i].flags |=
1143 (iwl_rates[i].plcp == IWL_RATE_1M_PLCP) ?
1144 0 : IEEE80211_RATE_SHORT_PREAMBLE;
1145 }
1146 }
1147}
1148
1149#define MAX_BIT_RATE_40_MHZ 150 /* Mbps */
1150#define MAX_BIT_RATE_20_MHZ 72 /* Mbps */
1151static void iwl_init_ht_hw_capab(const struct iwl_priv *priv,
1152 struct ieee80211_sta_ht_cap *ht_info,
1153 enum ieee80211_band band)
1154{
1155 u16 max_bit_rate = 0;
1156 u8 rx_chains_num = priv->hw_params.rx_chains_num;
1157 u8 tx_chains_num = priv->hw_params.tx_chains_num;
1158
1159 ht_info->cap = 0;
1160 ht_info->ht_supported = false;
1161 memset(&ht_info->mcs, 0, sizeof(ht_info->mcs));
1162
1163 if (!priv->cfg->ht_params)
1164 return;
1165
1166 ht_info->ht_supported = true;
1167
1168 if (priv->cfg->ht_params->ht_greenfield_support)
1169 ht_info->cap |= IEEE80211_HT_CAP_GRN_FLD;
1170 ht_info->cap |= IEEE80211_HT_CAP_SGI_20;
1171 max_bit_rate = MAX_BIT_RATE_20_MHZ;
1172 if (priv->cfg->ht_params->ht40_bands & BIT(band)) {
1173 ht_info->cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
1174 ht_info->cap |= IEEE80211_HT_CAP_SGI_40;
1175 ht_info->mcs.rx_mask[4] = 0x01;
1176 max_bit_rate = MAX_BIT_RATE_40_MHZ;
1177 }
1178
1179 if (iwlwifi_mod_params.amsdu_size_8K)
1180 ht_info->cap |= IEEE80211_HT_CAP_MAX_AMSDU;
1181
1182 ht_info->ampdu_factor = CFG_HT_RX_AMPDU_FACTOR_DEF;
1183 ht_info->ampdu_density = CFG_HT_MPDU_DENSITY_DEF;
1184
1185 ht_info->mcs.rx_mask[0] = 0xFF;
1186 if (rx_chains_num >= 2)
1187 ht_info->mcs.rx_mask[1] = 0xFF;
1188 if (rx_chains_num >= 3)
1189 ht_info->mcs.rx_mask[2] = 0xFF;
1190
1191 /* Highest supported Rx data rate */
1192 max_bit_rate *= rx_chains_num;
1193 WARN_ON(max_bit_rate & ~IEEE80211_HT_MCS_RX_HIGHEST_MASK);
1194 ht_info->mcs.rx_highest = cpu_to_le16(max_bit_rate);
1195
1196 /* Tx MCS capabilities */
1197 ht_info->mcs.tx_params = IEEE80211_HT_MCS_TX_DEFINED;
1198 if (tx_chains_num != rx_chains_num) {
1199 ht_info->mcs.tx_params |= IEEE80211_HT_MCS_TX_RX_DIFF;
1200 ht_info->mcs.tx_params |= ((tx_chains_num - 1) <<
1201 IEEE80211_HT_MCS_TX_MAX_STREAMS_SHIFT);
1202 }
1203}
1204
1205/**
1206 * iwl_init_geos - Initialize mac80211's geo/channel info based from eeprom
1207 */
1208static int iwl_init_geos(struct iwl_priv *priv)
1209{
1210 struct iwl_channel_info *ch;
1211 struct ieee80211_supported_band *sband;
1212 struct ieee80211_channel *channels;
1213 struct ieee80211_channel *geo_ch;
1214 struct ieee80211_rate *rates;
1215 int i = 0;
1216 s8 max_tx_power = IWLAGN_TX_POWER_TARGET_POWER_MIN;
1217
1218 if (priv->bands[IEEE80211_BAND_2GHZ].n_bitrates ||
1219 priv->bands[IEEE80211_BAND_5GHZ].n_bitrates) {
1220 IWL_DEBUG_INFO(priv, "Geography modes already initialized.\n");
1221 set_bit(STATUS_GEO_CONFIGURED, &priv->status);
1222 return 0;
1223 }
1224
1225 channels = kcalloc(priv->channel_count,
1226 sizeof(struct ieee80211_channel), GFP_KERNEL);
1227 if (!channels)
1228 return -ENOMEM;
1229
1230 rates = kcalloc(IWL_RATE_COUNT_LEGACY, sizeof(struct ieee80211_rate),
1231 GFP_KERNEL);
1232 if (!rates) {
1233 kfree(channels);
1234 return -ENOMEM;
1235 }
1236
1237 /* 5.2GHz channels start after the 2.4GHz channels */
1238 sband = &priv->bands[IEEE80211_BAND_5GHZ];
1239 sband->channels = &channels[ARRAY_SIZE(iwl_eeprom_band_1)];
1240 /* just OFDM */
1241 sband->bitrates = &rates[IWL_FIRST_OFDM_RATE];
1242 sband->n_bitrates = IWL_RATE_COUNT_LEGACY - IWL_FIRST_OFDM_RATE;
1243
1244 if (priv->hw_params.sku & EEPROM_SKU_CAP_11N_ENABLE)
1245 iwl_init_ht_hw_capab(priv, &sband->ht_cap,
1246 IEEE80211_BAND_5GHZ);
1247
1248 sband = &priv->bands[IEEE80211_BAND_2GHZ];
1249 sband->channels = channels;
1250 /* OFDM & CCK */
1251 sband->bitrates = rates;
1252 sband->n_bitrates = IWL_RATE_COUNT_LEGACY;
1253
1254 if (priv->hw_params.sku & EEPROM_SKU_CAP_11N_ENABLE)
1255 iwl_init_ht_hw_capab(priv, &sband->ht_cap,
1256 IEEE80211_BAND_2GHZ);
1257
1258 priv->ieee_channels = channels;
1259 priv->ieee_rates = rates;
1260
1261 for (i = 0; i < priv->channel_count; i++) {
1262 ch = &priv->channel_info[i];
1263
1264 /* FIXME: might be removed if scan is OK */
1265 if (!is_channel_valid(ch))
1266 continue;
1267
1268 sband = &priv->bands[ch->band];
1269
1270 geo_ch = &sband->channels[sband->n_channels++];
1271
1272 geo_ch->center_freq =
1273 ieee80211_channel_to_frequency(ch->channel, ch->band);
1274 geo_ch->max_power = ch->max_power_avg;
1275 geo_ch->max_antenna_gain = 0xff;
1276 geo_ch->hw_value = ch->channel;
1277
1278 if (is_channel_valid(ch)) {
1279 if (!(ch->flags & EEPROM_CHANNEL_IBSS))
1280 geo_ch->flags |= IEEE80211_CHAN_NO_IBSS;
1281
1282 if (!(ch->flags & EEPROM_CHANNEL_ACTIVE))
1283 geo_ch->flags |= IEEE80211_CHAN_PASSIVE_SCAN;
1284
1285 if (ch->flags & EEPROM_CHANNEL_RADAR)
1286 geo_ch->flags |= IEEE80211_CHAN_RADAR;
1287
1288 geo_ch->flags |= ch->ht40_extension_channel;
1289
1290 if (ch->max_power_avg > max_tx_power)
1291 max_tx_power = ch->max_power_avg;
1292 } else {
1293 geo_ch->flags |= IEEE80211_CHAN_DISABLED;
1294 }
1295
1296 IWL_DEBUG_INFO(priv, "Channel %d Freq=%d[%sGHz] %s flag=0x%X\n",
1297 ch->channel, geo_ch->center_freq,
1298 is_channel_a_band(ch) ? "5.2" : "2.4",
1299 geo_ch->flags & IEEE80211_CHAN_DISABLED ?
1300 "restricted" : "valid",
1301 geo_ch->flags);
1302 }
1303
1304 priv->tx_power_device_lmt = max_tx_power;
1305 priv->tx_power_user_lmt = max_tx_power;
1306 priv->tx_power_next = max_tx_power;
1307
1308 if ((priv->bands[IEEE80211_BAND_5GHZ].n_channels == 0) &&
1309 priv->hw_params.sku & EEPROM_SKU_CAP_BAND_52GHZ) {
1310 IWL_INFO(priv, "Incorrectly detected BG card as ABG. "
1311 "Please send your %s to maintainer.\n",
1312 priv->trans->hw_id_str);
1313 priv->hw_params.sku &= ~EEPROM_SKU_CAP_BAND_52GHZ;
1314 }
1315
1316 if (iwlwifi_mod_params.disable_5ghz)
1317 priv->bands[IEEE80211_BAND_5GHZ].n_channels = 0;
1318
1319 IWL_INFO(priv, "Tunable channels: %d 802.11bg, %d 802.11a channels\n",
1320 priv->bands[IEEE80211_BAND_2GHZ].n_channels,
1321 priv->bands[IEEE80211_BAND_5GHZ].n_channels);
1322
1323 set_bit(STATUS_GEO_CONFIGURED, &priv->status);
1324
1325 return 0;
1326}
1327
1328/*
1329 * iwl_free_geos - undo allocations in iwl_init_geos
1330 */
1331static void iwl_free_geos(struct iwl_priv *priv)
1332{
1333 kfree(priv->ieee_channels);
1334 kfree(priv->ieee_rates);
1335 clear_bit(STATUS_GEO_CONFIGURED, &priv->status);
1336}
1337
1338static int iwl_init_drv(struct iwl_priv *priv) 1128static int iwl_init_drv(struct iwl_priv *priv)
1339{ 1129{
1340 int ret;
1341
1342 spin_lock_init(&priv->sta_lock); 1130 spin_lock_init(&priv->sta_lock);
1343 1131
1344 mutex_init(&priv->mutex); 1132 mutex_init(&priv->mutex);
1345 1133
1346 INIT_LIST_HEAD(&priv->calib_results); 1134 INIT_LIST_HEAD(&priv->calib_results);
1347 1135
1348 priv->ieee_channels = NULL;
1349 priv->ieee_rates = NULL;
1350 priv->band = IEEE80211_BAND_2GHZ; 1136 priv->band = IEEE80211_BAND_2GHZ;
1351 1137
1352 priv->plcp_delta_threshold = 1138 priv->plcp_delta_threshold =
@@ -1377,31 +1163,11 @@ static int iwl_init_drv(struct iwl_priv *priv)
1377 priv->dynamic_frag_thresh = BT_FRAG_THRESHOLD_DEF; 1163 priv->dynamic_frag_thresh = BT_FRAG_THRESHOLD_DEF;
1378 } 1164 }
1379 1165
1380 ret = iwl_init_channel_map(priv);
1381 if (ret) {
1382 IWL_ERR(priv, "initializing regulatory failed: %d\n", ret);
1383 goto err;
1384 }
1385
1386 ret = iwl_init_geos(priv);
1387 if (ret) {
1388 IWL_ERR(priv, "initializing geos failed: %d\n", ret);
1389 goto err_free_channel_map;
1390 }
1391 iwl_init_hw_rates(priv->ieee_rates);
1392
1393 return 0; 1166 return 0;
1394
1395err_free_channel_map:
1396 iwl_free_channel_map(priv);
1397err:
1398 return ret;
1399} 1167}
1400 1168
1401static void iwl_uninit_drv(struct iwl_priv *priv) 1169static void iwl_uninit_drv(struct iwl_priv *priv)
1402{ 1170{
1403 iwl_free_geos(priv);
1404 iwl_free_channel_map(priv);
1405 kfree(priv->scan_cmd); 1171 kfree(priv->scan_cmd);
1406 kfree(priv->beacon_cmd); 1172 kfree(priv->beacon_cmd);
1407 kfree(rcu_dereference_raw(priv->noa_data)); 1173 kfree(rcu_dereference_raw(priv->noa_data));
@@ -1460,6 +1226,42 @@ static void iwl_option_config(struct iwl_priv *priv)
1460#endif 1226#endif
1461} 1227}
1462 1228
1229static int iwl_eeprom_init_hw_params(struct iwl_priv *priv)
1230{
1231 u16 radio_cfg;
1232
1233 priv->hw_params.sku = priv->eeprom_data->sku;
1234
1235 if (priv->hw_params.sku & EEPROM_SKU_CAP_11N_ENABLE &&
1236 !priv->cfg->ht_params) {
1237 IWL_ERR(priv, "Invalid 11n configuration\n");
1238 return -EINVAL;
1239 }
1240
1241 if (!priv->hw_params.sku) {
1242 IWL_ERR(priv, "Invalid device sku\n");
1243 return -EINVAL;
1244 }
1245
1246 IWL_INFO(priv, "Device SKU: 0x%X\n", priv->hw_params.sku);
1247
1248 radio_cfg = priv->eeprom_data->radio_cfg;
1249
1250 priv->hw_params.tx_chains_num =
1251 num_of_ant(priv->eeprom_data->valid_tx_ant);
1252 if (priv->cfg->rx_with_siso_diversity)
1253 priv->hw_params.rx_chains_num = 1;
1254 else
1255 priv->hw_params.rx_chains_num =
1256 num_of_ant(priv->eeprom_data->valid_rx_ant);
1257
1258 IWL_INFO(priv, "Valid Tx ant: 0x%X, Valid Rx ant: 0x%X\n",
1259 priv->eeprom_data->valid_tx_ant,
1260 priv->eeprom_data->valid_rx_ant);
1261
1262 return 0;
1263}
1264
1463static struct iwl_op_mode *iwl_op_mode_dvm_start(struct iwl_trans *trans, 1265static struct iwl_op_mode *iwl_op_mode_dvm_start(struct iwl_trans *trans,
1464 const struct iwl_cfg *cfg, 1266 const struct iwl_cfg *cfg,
1465 const struct iwl_fw *fw) 1267 const struct iwl_fw *fw)
@@ -1605,25 +1407,33 @@ static struct iwl_op_mode *iwl_op_mode_dvm_start(struct iwl_trans *trans,
1605 goto out_free_hw; 1407 goto out_free_hw;
1606 1408
1607 /* Read the EEPROM */ 1409 /* Read the EEPROM */
1608 if (iwl_eeprom_init(priv, priv->trans->hw_rev)) { 1410 if (iwl_read_eeprom(priv->trans, &priv->eeprom_blob,
1411 &priv->eeprom_blob_size)) {
1609 IWL_ERR(priv, "Unable to init EEPROM\n"); 1412 IWL_ERR(priv, "Unable to init EEPROM\n");
1610 goto out_free_hw; 1413 goto out_free_hw;
1611 } 1414 }
1415
1612 /* Reset chip to save power until we load uCode during "up". */ 1416 /* Reset chip to save power until we load uCode during "up". */
1613 iwl_trans_stop_hw(priv->trans, false); 1417 iwl_trans_stop_hw(priv->trans, false);
1614 1418
1615 if (iwl_eeprom_check_version(priv)) 1419 priv->eeprom_data = iwl_parse_eeprom_data(priv->trans->dev, priv->cfg,
1420 priv->eeprom_blob,
1421 priv->eeprom_blob_size);
1422 if (!priv->eeprom_data)
1423 goto out_free_eeprom_blob;
1424
1425 if (iwl_eeprom_check_version(priv->eeprom_data, priv->trans))
1616 goto out_free_eeprom; 1426 goto out_free_eeprom;
1617 1427
1618 if (iwl_eeprom_init_hw_params(priv)) 1428 if (iwl_eeprom_init_hw_params(priv))
1619 goto out_free_eeprom; 1429 goto out_free_eeprom;
1620 1430
1621 /* extract MAC Address */ 1431 /* extract MAC Address */
1622 iwl_eeprom_get_mac(priv, priv->addresses[0].addr); 1432 memcpy(priv->addresses[0].addr, priv->eeprom_data->hw_addr, ETH_ALEN);
1623 IWL_DEBUG_INFO(priv, "MAC address: %pM\n", priv->addresses[0].addr); 1433 IWL_DEBUG_INFO(priv, "MAC address: %pM\n", priv->addresses[0].addr);
1624 priv->hw->wiphy->addresses = priv->addresses; 1434 priv->hw->wiphy->addresses = priv->addresses;
1625 priv->hw->wiphy->n_addresses = 1; 1435 priv->hw->wiphy->n_addresses = 1;
1626 num_mac = iwl_eeprom_query16(priv, EEPROM_NUM_MAC_ADDRESS); 1436 num_mac = priv->eeprom_data->n_hw_addrs;
1627 if (num_mac > 1) { 1437 if (num_mac > 1) {
1628 memcpy(priv->addresses[1].addr, priv->addresses[0].addr, 1438 memcpy(priv->addresses[1].addr, priv->addresses[0].addr,
1629 ETH_ALEN); 1439 ETH_ALEN);
@@ -1717,8 +1527,10 @@ out_destroy_workqueue:
1717 destroy_workqueue(priv->workqueue); 1527 destroy_workqueue(priv->workqueue);
1718 priv->workqueue = NULL; 1528 priv->workqueue = NULL;
1719 iwl_uninit_drv(priv); 1529 iwl_uninit_drv(priv);
1530out_free_eeprom_blob:
1531 kfree(priv->eeprom_blob);
1720out_free_eeprom: 1532out_free_eeprom:
1721 iwl_eeprom_free(priv); 1533 iwl_free_eeprom_data(priv->eeprom_data);
1722out_free_hw: 1534out_free_hw:
1723 ieee80211_free_hw(priv->hw); 1535 ieee80211_free_hw(priv->hw);
1724out: 1536out:
@@ -1743,7 +1555,8 @@ static void iwl_op_mode_dvm_stop(struct iwl_op_mode *op_mode)
1743 priv->ucode_loaded = false; 1555 priv->ucode_loaded = false;
1744 iwl_trans_stop_device(priv->trans); 1556 iwl_trans_stop_device(priv->trans);
1745 1557
1746 iwl_eeprom_free(priv); 1558 kfree(priv->eeprom_blob);
1559 iwl_free_eeprom_data(priv->eeprom_data);
1747 1560
1748 /*netif_stop_queue(dev); */ 1561 /*netif_stop_queue(dev); */
1749 flush_workqueue(priv->workqueue); 1562 flush_workqueue(priv->workqueue);
diff --git a/drivers/net/wireless/iwlwifi/dvm/power.c b/drivers/net/wireless/iwlwifi/dvm/power.c
index 72c940759ac7..518cf3715809 100644
--- a/drivers/net/wireless/iwlwifi/dvm/power.c
+++ b/drivers/net/wireless/iwlwifi/dvm/power.c
@@ -36,7 +36,6 @@
36#include "iwl-debug.h" 36#include "iwl-debug.h"
37#include "iwl-trans.h" 37#include "iwl-trans.h"
38#include "iwl-modparams.h" 38#include "iwl-modparams.h"
39#include "eeprom.h"
40#include "dev.h" 39#include "dev.h"
41#include "agn.h" 40#include "agn.h"
42#include "commands.h" 41#include "commands.h"
diff --git a/drivers/net/wireless/iwlwifi/dvm/rs.c b/drivers/net/wireless/iwlwifi/dvm/rs.c
index af102910e689..6fddd2785e6e 100644
--- a/drivers/net/wireless/iwlwifi/dvm/rs.c
+++ b/drivers/net/wireless/iwlwifi/dvm/rs.c
@@ -817,7 +817,7 @@ static u32 rs_get_lower_rate(struct iwl_lq_sta *lq_sta,
817 817
818 if (num_of_ant(tbl->ant_type) > 1) 818 if (num_of_ant(tbl->ant_type) > 1)
819 tbl->ant_type = 819 tbl->ant_type =
820 first_antenna(priv->hw_params.valid_tx_ant); 820 first_antenna(priv->eeprom_data->valid_tx_ant);
821 821
822 tbl->is_ht40 = 0; 822 tbl->is_ht40 = 0;
823 tbl->is_SGI = 0; 823 tbl->is_SGI = 0;
@@ -1445,7 +1445,7 @@ static int rs_move_legacy_other(struct iwl_priv *priv,
1445 u32 sz = (sizeof(struct iwl_scale_tbl_info) - 1445 u32 sz = (sizeof(struct iwl_scale_tbl_info) -
1446 (sizeof(struct iwl_rate_scale_data) * IWL_RATE_COUNT)); 1446 (sizeof(struct iwl_rate_scale_data) * IWL_RATE_COUNT));
1447 u8 start_action; 1447 u8 start_action;
1448 u8 valid_tx_ant = priv->hw_params.valid_tx_ant; 1448 u8 valid_tx_ant = priv->eeprom_data->valid_tx_ant;
1449 u8 tx_chains_num = priv->hw_params.tx_chains_num; 1449 u8 tx_chains_num = priv->hw_params.tx_chains_num;
1450 int ret = 0; 1450 int ret = 0;
1451 u8 update_search_tbl_counter = 0; 1451 u8 update_search_tbl_counter = 0;
@@ -1463,7 +1463,7 @@ static int rs_move_legacy_other(struct iwl_priv *priv,
1463 case IWL_BT_COEX_TRAFFIC_LOAD_CONTINUOUS: 1463 case IWL_BT_COEX_TRAFFIC_LOAD_CONTINUOUS:
1464 /* avoid antenna B and MIMO */ 1464 /* avoid antenna B and MIMO */
1465 valid_tx_ant = 1465 valid_tx_ant =
1466 first_antenna(priv->hw_params.valid_tx_ant); 1466 first_antenna(priv->eeprom_data->valid_tx_ant);
1467 if (tbl->action >= IWL_LEGACY_SWITCH_ANTENNA2 && 1467 if (tbl->action >= IWL_LEGACY_SWITCH_ANTENNA2 &&
1468 tbl->action != IWL_LEGACY_SWITCH_SISO) 1468 tbl->action != IWL_LEGACY_SWITCH_SISO)
1469 tbl->action = IWL_LEGACY_SWITCH_SISO; 1469 tbl->action = IWL_LEGACY_SWITCH_SISO;
@@ -1487,7 +1487,7 @@ static int rs_move_legacy_other(struct iwl_priv *priv,
1487 else if (tbl->action >= IWL_LEGACY_SWITCH_ANTENNA2) 1487 else if (tbl->action >= IWL_LEGACY_SWITCH_ANTENNA2)
1488 tbl->action = IWL_LEGACY_SWITCH_SISO; 1488 tbl->action = IWL_LEGACY_SWITCH_SISO;
1489 valid_tx_ant = 1489 valid_tx_ant =
1490 first_antenna(priv->hw_params.valid_tx_ant); 1490 first_antenna(priv->eeprom_data->valid_tx_ant);
1491 } 1491 }
1492 1492
1493 start_action = tbl->action; 1493 start_action = tbl->action;
@@ -1621,7 +1621,7 @@ static int rs_move_siso_to_other(struct iwl_priv *priv,
1621 u32 sz = (sizeof(struct iwl_scale_tbl_info) - 1621 u32 sz = (sizeof(struct iwl_scale_tbl_info) -
1622 (sizeof(struct iwl_rate_scale_data) * IWL_RATE_COUNT)); 1622 (sizeof(struct iwl_rate_scale_data) * IWL_RATE_COUNT));
1623 u8 start_action; 1623 u8 start_action;
1624 u8 valid_tx_ant = priv->hw_params.valid_tx_ant; 1624 u8 valid_tx_ant = priv->eeprom_data->valid_tx_ant;
1625 u8 tx_chains_num = priv->hw_params.tx_chains_num; 1625 u8 tx_chains_num = priv->hw_params.tx_chains_num;
1626 u8 update_search_tbl_counter = 0; 1626 u8 update_search_tbl_counter = 0;
1627 int ret; 1627 int ret;
@@ -1639,7 +1639,7 @@ static int rs_move_siso_to_other(struct iwl_priv *priv,
1639 case IWL_BT_COEX_TRAFFIC_LOAD_CONTINUOUS: 1639 case IWL_BT_COEX_TRAFFIC_LOAD_CONTINUOUS:
1640 /* avoid antenna B and MIMO */ 1640 /* avoid antenna B and MIMO */
1641 valid_tx_ant = 1641 valid_tx_ant =
1642 first_antenna(priv->hw_params.valid_tx_ant); 1642 first_antenna(priv->eeprom_data->valid_tx_ant);
1643 if (tbl->action != IWL_SISO_SWITCH_ANTENNA1) 1643 if (tbl->action != IWL_SISO_SWITCH_ANTENNA1)
1644 tbl->action = IWL_SISO_SWITCH_ANTENNA1; 1644 tbl->action = IWL_SISO_SWITCH_ANTENNA1;
1645 break; 1645 break;
@@ -1657,7 +1657,7 @@ static int rs_move_siso_to_other(struct iwl_priv *priv,
1657 /* configure as 1x1 if bt full concurrency */ 1657 /* configure as 1x1 if bt full concurrency */
1658 if (priv->bt_full_concurrent) { 1658 if (priv->bt_full_concurrent) {
1659 valid_tx_ant = 1659 valid_tx_ant =
1660 first_antenna(priv->hw_params.valid_tx_ant); 1660 first_antenna(priv->eeprom_data->valid_tx_ant);
1661 if (tbl->action >= IWL_LEGACY_SWITCH_ANTENNA2) 1661 if (tbl->action >= IWL_LEGACY_SWITCH_ANTENNA2)
1662 tbl->action = IWL_SISO_SWITCH_ANTENNA1; 1662 tbl->action = IWL_SISO_SWITCH_ANTENNA1;
1663 } 1663 }
@@ -1793,7 +1793,7 @@ static int rs_move_mimo2_to_other(struct iwl_priv *priv,
1793 u32 sz = (sizeof(struct iwl_scale_tbl_info) - 1793 u32 sz = (sizeof(struct iwl_scale_tbl_info) -
1794 (sizeof(struct iwl_rate_scale_data) * IWL_RATE_COUNT)); 1794 (sizeof(struct iwl_rate_scale_data) * IWL_RATE_COUNT));
1795 u8 start_action; 1795 u8 start_action;
1796 u8 valid_tx_ant = priv->hw_params.valid_tx_ant; 1796 u8 valid_tx_ant = priv->eeprom_data->valid_tx_ant;
1797 u8 tx_chains_num = priv->hw_params.tx_chains_num; 1797 u8 tx_chains_num = priv->hw_params.tx_chains_num;
1798 u8 update_search_tbl_counter = 0; 1798 u8 update_search_tbl_counter = 0;
1799 int ret; 1799 int ret;
@@ -1963,7 +1963,7 @@ static int rs_move_mimo3_to_other(struct iwl_priv *priv,
1963 u32 sz = (sizeof(struct iwl_scale_tbl_info) - 1963 u32 sz = (sizeof(struct iwl_scale_tbl_info) -
1964 (sizeof(struct iwl_rate_scale_data) * IWL_RATE_COUNT)); 1964 (sizeof(struct iwl_rate_scale_data) * IWL_RATE_COUNT));
1965 u8 start_action; 1965 u8 start_action;
1966 u8 valid_tx_ant = priv->hw_params.valid_tx_ant; 1966 u8 valid_tx_ant = priv->eeprom_data->valid_tx_ant;
1967 u8 tx_chains_num = priv->hw_params.tx_chains_num; 1967 u8 tx_chains_num = priv->hw_params.tx_chains_num;
1968 int ret; 1968 int ret;
1969 u8 update_search_tbl_counter = 0; 1969 u8 update_search_tbl_counter = 0;
@@ -2697,7 +2697,7 @@ static void rs_initialize_lq(struct iwl_priv *priv,
2697 2697
2698 i = lq_sta->last_txrate_idx; 2698 i = lq_sta->last_txrate_idx;
2699 2699
2700 valid_tx_ant = priv->hw_params.valid_tx_ant; 2700 valid_tx_ant = priv->eeprom_data->valid_tx_ant;
2701 2701
2702 if (!lq_sta->search_better_tbl) 2702 if (!lq_sta->search_better_tbl)
2703 active_tbl = lq_sta->active_tbl; 2703 active_tbl = lq_sta->active_tbl;
@@ -2891,15 +2891,15 @@ void iwl_rs_rate_init(struct iwl_priv *priv, struct ieee80211_sta *sta, u8 sta_i
2891 2891
2892 /* These values will be overridden later */ 2892 /* These values will be overridden later */
2893 lq_sta->lq.general_params.single_stream_ant_msk = 2893 lq_sta->lq.general_params.single_stream_ant_msk =
2894 first_antenna(priv->hw_params.valid_tx_ant); 2894 first_antenna(priv->eeprom_data->valid_tx_ant);
2895 lq_sta->lq.general_params.dual_stream_ant_msk = 2895 lq_sta->lq.general_params.dual_stream_ant_msk =
2896 priv->hw_params.valid_tx_ant & 2896 priv->eeprom_data->valid_tx_ant &
2897 ~first_antenna(priv->hw_params.valid_tx_ant); 2897 ~first_antenna(priv->eeprom_data->valid_tx_ant);
2898 if (!lq_sta->lq.general_params.dual_stream_ant_msk) { 2898 if (!lq_sta->lq.general_params.dual_stream_ant_msk) {
2899 lq_sta->lq.general_params.dual_stream_ant_msk = ANT_AB; 2899 lq_sta->lq.general_params.dual_stream_ant_msk = ANT_AB;
2900 } else if (num_of_ant(priv->hw_params.valid_tx_ant) == 2) { 2900 } else if (num_of_ant(priv->eeprom_data->valid_tx_ant) == 2) {
2901 lq_sta->lq.general_params.dual_stream_ant_msk = 2901 lq_sta->lq.general_params.dual_stream_ant_msk =
2902 priv->hw_params.valid_tx_ant; 2902 priv->eeprom_data->valid_tx_ant;
2903 } 2903 }
2904 2904
2905 /* as default allow aggregation for all tids */ 2905 /* as default allow aggregation for all tids */
@@ -2945,7 +2945,7 @@ static void rs_fill_link_cmd(struct iwl_priv *priv,
2945 if (priv && priv->bt_full_concurrent) { 2945 if (priv && priv->bt_full_concurrent) {
2946 /* 1x1 only */ 2946 /* 1x1 only */
2947 tbl_type.ant_type = 2947 tbl_type.ant_type =
2948 first_antenna(priv->hw_params.valid_tx_ant); 2948 first_antenna(priv->eeprom_data->valid_tx_ant);
2949 } 2949 }
2950 2950
2951 /* How many times should we repeat the initial rate? */ 2951 /* How many times should we repeat the initial rate? */
@@ -2977,7 +2977,7 @@ static void rs_fill_link_cmd(struct iwl_priv *priv,
2977 if (priv->bt_full_concurrent) 2977 if (priv->bt_full_concurrent)
2978 valid_tx_ant = ANT_A; 2978 valid_tx_ant = ANT_A;
2979 else 2979 else
2980 valid_tx_ant = priv->hw_params.valid_tx_ant; 2980 valid_tx_ant = priv->eeprom_data->valid_tx_ant;
2981 } 2981 }
2982 2982
2983 /* Fill rest of rate table */ 2983 /* Fill rest of rate table */
@@ -3011,7 +3011,7 @@ static void rs_fill_link_cmd(struct iwl_priv *priv,
3011 if (priv && priv->bt_full_concurrent) { 3011 if (priv && priv->bt_full_concurrent) {
3012 /* 1x1 only */ 3012 /* 1x1 only */
3013 tbl_type.ant_type = 3013 tbl_type.ant_type =
3014 first_antenna(priv->hw_params.valid_tx_ant); 3014 first_antenna(priv->eeprom_data->valid_tx_ant);
3015 } 3015 }
3016 3016
3017 /* Indicate to uCode which entries might be MIMO. 3017 /* Indicate to uCode which entries might be MIMO.
@@ -3098,7 +3098,7 @@ static void rs_dbgfs_set_mcs(struct iwl_lq_sta *lq_sta,
3098 u8 ant_sel_tx; 3098 u8 ant_sel_tx;
3099 3099
3100 priv = lq_sta->drv; 3100 priv = lq_sta->drv;
3101 valid_tx_ant = priv->hw_params.valid_tx_ant; 3101 valid_tx_ant = priv->eeprom_data->valid_tx_ant;
3102 if (lq_sta->dbg_fixed_rate) { 3102 if (lq_sta->dbg_fixed_rate) {
3103 ant_sel_tx = 3103 ant_sel_tx =
3104 ((lq_sta->dbg_fixed_rate & RATE_MCS_ANT_ABC_MSK) 3104 ((lq_sta->dbg_fixed_rate & RATE_MCS_ANT_ABC_MSK)
@@ -3169,9 +3169,9 @@ static ssize_t rs_sta_dbgfs_scale_table_read(struct file *file,
3169 desc += sprintf(buff+desc, "fixed rate 0x%X\n", 3169 desc += sprintf(buff+desc, "fixed rate 0x%X\n",
3170 lq_sta->dbg_fixed_rate); 3170 lq_sta->dbg_fixed_rate);
3171 desc += sprintf(buff+desc, "valid_tx_ant %s%s%s\n", 3171 desc += sprintf(buff+desc, "valid_tx_ant %s%s%s\n",
3172 (priv->hw_params.valid_tx_ant & ANT_A) ? "ANT_A," : "", 3172 (priv->eeprom_data->valid_tx_ant & ANT_A) ? "ANT_A," : "",
3173 (priv->hw_params.valid_tx_ant & ANT_B) ? "ANT_B," : "", 3173 (priv->eeprom_data->valid_tx_ant & ANT_B) ? "ANT_B," : "",
3174 (priv->hw_params.valid_tx_ant & ANT_C) ? "ANT_C" : ""); 3174 (priv->eeprom_data->valid_tx_ant & ANT_C) ? "ANT_C" : "");
3175 desc += sprintf(buff+desc, "lq type %s\n", 3175 desc += sprintf(buff+desc, "lq type %s\n",
3176 (is_legacy(tbl->lq_type)) ? "legacy" : "HT"); 3176 (is_legacy(tbl->lq_type)) ? "legacy" : "HT");
3177 if (is_Ht(tbl->lq_type)) { 3177 if (is_Ht(tbl->lq_type)) {
diff --git a/drivers/net/wireless/iwlwifi/dvm/rx.c b/drivers/net/wireless/iwlwifi/dvm/rx.c
index d61980248408..0ed90bb8b56a 100644
--- a/drivers/net/wireless/iwlwifi/dvm/rx.c
+++ b/drivers/net/wireless/iwlwifi/dvm/rx.c
@@ -33,7 +33,6 @@
33#include <net/mac80211.h> 33#include <net/mac80211.h>
34#include <asm/unaligned.h> 34#include <asm/unaligned.h>
35#include "iwl-io.h" 35#include "iwl-io.h"
36#include "eeprom.h"
37#include "dev.h" 36#include "dev.h"
38#include "calib.h" 37#include "calib.h"
39#include "agn.h" 38#include "agn.h"
diff --git a/drivers/net/wireless/iwlwifi/dvm/rxon.c b/drivers/net/wireless/iwlwifi/dvm/rxon.c
index 4f55689ac6a7..6ee940f497f9 100644
--- a/drivers/net/wireless/iwlwifi/dvm/rxon.c
+++ b/drivers/net/wireless/iwlwifi/dvm/rxon.c
@@ -420,10 +420,10 @@ static int iwl_set_tx_power(struct iwl_priv *priv, s8 tx_power, bool force)
420 return -EINVAL; 420 return -EINVAL;
421 } 421 }
422 422
423 if (tx_power > priv->tx_power_device_lmt) { 423 if (tx_power > DIV_ROUND_UP(priv->eeprom_data->max_tx_pwr_half_dbm, 2)) {
424 IWL_WARN(priv, 424 IWL_WARN(priv,
425 "Requested user TXPOWER %d above upper limit %d.\n", 425 "Requested user TXPOWER %d above upper limit %d.\n",
426 tx_power, priv->tx_power_device_lmt); 426 tx_power, priv->eeprom_data->max_tx_pwr_half_dbm);
427 return -EINVAL; 427 return -EINVAL;
428 } 428 }
429 429
diff --git a/drivers/net/wireless/iwlwifi/dvm/scan.c b/drivers/net/wireless/iwlwifi/dvm/scan.c
index 7ee7f32b0fab..2f271c96ed39 100644
--- a/drivers/net/wireless/iwlwifi/dvm/scan.c
+++ b/drivers/net/wireless/iwlwifi/dvm/scan.c
@@ -30,7 +30,6 @@
30#include <linux/etherdevice.h> 30#include <linux/etherdevice.h>
31#include <net/mac80211.h> 31#include <net/mac80211.h>
32 32
33#include "eeprom.h"
34#include "dev.h" 33#include "dev.h"
35#include "agn.h" 34#include "agn.h"
36 35
@@ -65,7 +64,6 @@ static int iwl_send_scan_abort(struct iwl_priv *priv)
65 * to receive scan abort command or it does not perform 64 * to receive scan abort command or it does not perform
66 * hardware scan currently */ 65 * hardware scan currently */
67 if (!test_bit(STATUS_READY, &priv->status) || 66 if (!test_bit(STATUS_READY, &priv->status) ||
68 !test_bit(STATUS_GEO_CONFIGURED, &priv->status) ||
69 !test_bit(STATUS_SCAN_HW, &priv->status) || 67 !test_bit(STATUS_SCAN_HW, &priv->status) ||
70 test_bit(STATUS_FW_ERROR, &priv->status)) 68 test_bit(STATUS_FW_ERROR, &priv->status))
71 return -EIO; 69 return -EIO;
@@ -648,12 +646,12 @@ static int iwlagn_request_scan(struct iwl_priv *priv, struct ieee80211_vif *vif)
648 u16 rx_chain = 0; 646 u16 rx_chain = 0;
649 enum ieee80211_band band; 647 enum ieee80211_band band;
650 u8 n_probes = 0; 648 u8 n_probes = 0;
651 u8 rx_ant = priv->hw_params.valid_rx_ant; 649 u8 rx_ant = priv->eeprom_data->valid_rx_ant;
652 u8 rate; 650 u8 rate;
653 bool is_active = false; 651 bool is_active = false;
654 int chan_mod; 652 int chan_mod;
655 u8 active_chains; 653 u8 active_chains;
656 u8 scan_tx_antennas = priv->hw_params.valid_tx_ant; 654 u8 scan_tx_antennas = priv->eeprom_data->valid_tx_ant;
657 int ret; 655 int ret;
658 int scan_cmd_size = sizeof(struct iwl_scan_cmd) + 656 int scan_cmd_size = sizeof(struct iwl_scan_cmd) +
659 MAX_SCAN_CHANNEL * sizeof(struct iwl_scan_channel) + 657 MAX_SCAN_CHANNEL * sizeof(struct iwl_scan_channel) +
@@ -863,7 +861,7 @@ static int iwlagn_request_scan(struct iwl_priv *priv, struct ieee80211_vif *vif)
863 861
864 /* MIMO is not used here, but value is required */ 862 /* MIMO is not used here, but value is required */
865 rx_chain |= 863 rx_chain |=
866 priv->hw_params.valid_rx_ant << RXON_RX_CHAIN_VALID_POS; 864 priv->eeprom_data->valid_rx_ant << RXON_RX_CHAIN_VALID_POS;
867 rx_chain |= rx_ant << RXON_RX_CHAIN_FORCE_MIMO_SEL_POS; 865 rx_chain |= rx_ant << RXON_RX_CHAIN_FORCE_MIMO_SEL_POS;
868 rx_chain |= rx_ant << RXON_RX_CHAIN_FORCE_SEL_POS; 866 rx_chain |= rx_ant << RXON_RX_CHAIN_FORCE_SEL_POS;
869 rx_chain |= 0x1 << RXON_RX_CHAIN_DRIVER_FORCE_POS; 867 rx_chain |= 0x1 << RXON_RX_CHAIN_DRIVER_FORCE_POS;
@@ -980,7 +978,7 @@ static int iwlagn_request_scan(struct iwl_priv *priv, struct ieee80211_vif *vif)
980 978
981void iwl_init_scan_params(struct iwl_priv *priv) 979void iwl_init_scan_params(struct iwl_priv *priv)
982{ 980{
983 u8 ant_idx = fls(priv->hw_params.valid_tx_ant) - 1; 981 u8 ant_idx = fls(priv->eeprom_data->valid_tx_ant) - 1;
984 if (!priv->scan_tx_ant[IEEE80211_BAND_5GHZ]) 982 if (!priv->scan_tx_ant[IEEE80211_BAND_5GHZ])
985 priv->scan_tx_ant[IEEE80211_BAND_5GHZ] = ant_idx; 983 priv->scan_tx_ant[IEEE80211_BAND_5GHZ] = ant_idx;
986 if (!priv->scan_tx_ant[IEEE80211_BAND_2GHZ]) 984 if (!priv->scan_tx_ant[IEEE80211_BAND_2GHZ])
diff --git a/drivers/net/wireless/iwlwifi/dvm/sta.c b/drivers/net/wireless/iwlwifi/dvm/sta.c
index c6b343fdf5f9..286ce4e18068 100644
--- a/drivers/net/wireless/iwlwifi/dvm/sta.c
+++ b/drivers/net/wireless/iwlwifi/dvm/sta.c
@@ -177,17 +177,23 @@ bool iwl_is_ht40_tx_allowed(struct iwl_priv *priv,
177 if (!ctx->ht.enabled || !ctx->ht.is_40mhz) 177 if (!ctx->ht.enabled || !ctx->ht.is_40mhz)
178 return false; 178 return false;
179 179
180#ifdef CONFIG_IWLWIFI_DEBUGFS
181 if (priv->disable_ht40)
182 return false;
183#endif
184
180 /* 185 /*
181 * We do not check for IEEE80211_HT_CAP_SUP_WIDTH_20_40 186 * Remainder of this function checks ht_cap, but if it's
182 * the bit will not set if it is pure 40MHz case 187 * NULL then we can do HT40 (special case for RXON)
183 */ 188 */
184 if (ht_cap && !ht_cap->ht_supported) 189 if (!ht_cap)
190 return true;
191
192 if (!ht_cap->ht_supported)
185 return false; 193 return false;
186 194
187#ifdef CONFIG_IWLWIFI_DEBUGFS 195 if (!(ht_cap->cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40))
188 if (priv->disable_ht40)
189 return false; 196 return false;
190#endif
191 197
192 return true; 198 return true;
193} 199}
@@ -627,23 +633,23 @@ static void iwl_sta_fill_lq(struct iwl_priv *priv, struct iwl_rxon_context *ctx,
627 if (r >= IWL_FIRST_CCK_RATE && r <= IWL_LAST_CCK_RATE) 633 if (r >= IWL_FIRST_CCK_RATE && r <= IWL_LAST_CCK_RATE)
628 rate_flags |= RATE_MCS_CCK_MSK; 634 rate_flags |= RATE_MCS_CCK_MSK;
629 635
630 rate_flags |= first_antenna(priv->hw_params.valid_tx_ant) << 636 rate_flags |= first_antenna(priv->eeprom_data->valid_tx_ant) <<
631 RATE_MCS_ANT_POS; 637 RATE_MCS_ANT_POS;
632 rate_n_flags = iwl_hw_set_rate_n_flags(iwl_rates[r].plcp, rate_flags); 638 rate_n_flags = iwl_hw_set_rate_n_flags(iwl_rates[r].plcp, rate_flags);
633 for (i = 0; i < LINK_QUAL_MAX_RETRY_NUM; i++) 639 for (i = 0; i < LINK_QUAL_MAX_RETRY_NUM; i++)
634 link_cmd->rs_table[i].rate_n_flags = rate_n_flags; 640 link_cmd->rs_table[i].rate_n_flags = rate_n_flags;
635 641
636 link_cmd->general_params.single_stream_ant_msk = 642 link_cmd->general_params.single_stream_ant_msk =
637 first_antenna(priv->hw_params.valid_tx_ant); 643 first_antenna(priv->eeprom_data->valid_tx_ant);
638 644
639 link_cmd->general_params.dual_stream_ant_msk = 645 link_cmd->general_params.dual_stream_ant_msk =
640 priv->hw_params.valid_tx_ant & 646 priv->eeprom_data->valid_tx_ant &
641 ~first_antenna(priv->hw_params.valid_tx_ant); 647 ~first_antenna(priv->eeprom_data->valid_tx_ant);
642 if (!link_cmd->general_params.dual_stream_ant_msk) { 648 if (!link_cmd->general_params.dual_stream_ant_msk) {
643 link_cmd->general_params.dual_stream_ant_msk = ANT_AB; 649 link_cmd->general_params.dual_stream_ant_msk = ANT_AB;
644 } else if (num_of_ant(priv->hw_params.valid_tx_ant) == 2) { 650 } else if (num_of_ant(priv->eeprom_data->valid_tx_ant) == 2) {
645 link_cmd->general_params.dual_stream_ant_msk = 651 link_cmd->general_params.dual_stream_ant_msk =
646 priv->hw_params.valid_tx_ant; 652 priv->eeprom_data->valid_tx_ant;
647 } 653 }
648 654
649 link_cmd->agg_params.agg_dis_start_th = 655 link_cmd->agg_params.agg_dis_start_th =
diff --git a/drivers/net/wireless/iwlwifi/dvm/testmode.c b/drivers/net/wireless/iwlwifi/dvm/testmode.c
index 59cfe9a8eea5..a7b59590bb53 100644
--- a/drivers/net/wireless/iwlwifi/dvm/testmode.c
+++ b/drivers/net/wireless/iwlwifi/dvm/testmode.c
@@ -534,9 +534,9 @@ static int iwl_testmode_driver(struct ieee80211_hw *hw, struct nlattr **tb)
534 break; 534 break;
535 535
536 case IWL_TM_CMD_APP2DEV_GET_EEPROM: 536 case IWL_TM_CMD_APP2DEV_GET_EEPROM:
537 if (priv->eeprom) { 537 if (priv->eeprom_blob) {
538 skb = cfg80211_testmode_alloc_reply_skb(hw->wiphy, 538 skb = cfg80211_testmode_alloc_reply_skb(hw->wiphy,
539 priv->cfg->base_params->eeprom_size + 20); 539 priv->eeprom_blob_size + 20);
540 if (!skb) { 540 if (!skb) {
541 IWL_ERR(priv, "Memory allocation fail\n"); 541 IWL_ERR(priv, "Memory allocation fail\n");
542 return -ENOMEM; 542 return -ENOMEM;
@@ -544,15 +544,15 @@ static int iwl_testmode_driver(struct ieee80211_hw *hw, struct nlattr **tb)
544 if (nla_put_u32(skb, IWL_TM_ATTR_COMMAND, 544 if (nla_put_u32(skb, IWL_TM_ATTR_COMMAND,
545 IWL_TM_CMD_DEV2APP_EEPROM_RSP) || 545 IWL_TM_CMD_DEV2APP_EEPROM_RSP) ||
546 nla_put(skb, IWL_TM_ATTR_EEPROM, 546 nla_put(skb, IWL_TM_ATTR_EEPROM,
547 priv->cfg->base_params->eeprom_size, 547 priv->eeprom_blob_size,
548 priv->eeprom)) 548 priv->eeprom_blob))
549 goto nla_put_failure; 549 goto nla_put_failure;
550 status = cfg80211_testmode_reply(skb); 550 status = cfg80211_testmode_reply(skb);
551 if (status < 0) 551 if (status < 0)
552 IWL_ERR(priv, "Error sending msg : %d\n", 552 IWL_ERR(priv, "Error sending msg : %d\n",
553 status); 553 status);
554 } else 554 } else
555 return -EFAULT; 555 return -ENODATA;
556 break; 556 break;
557 557
558 case IWL_TM_CMD_APP2DEV_FIXRATE_REQ: 558 case IWL_TM_CMD_APP2DEV_FIXRATE_REQ:
diff --git a/drivers/net/wireless/iwlwifi/dvm/tt.c b/drivers/net/wireless/iwlwifi/dvm/tt.c
index 55418899bc4e..eb864433e59d 100644
--- a/drivers/net/wireless/iwlwifi/dvm/tt.c
+++ b/drivers/net/wireless/iwlwifi/dvm/tt.c
@@ -36,7 +36,6 @@
36#include "iwl-modparams.h" 36#include "iwl-modparams.h"
37#include "iwl-debug.h" 37#include "iwl-debug.h"
38#include "agn.h" 38#include "agn.h"
39#include "eeprom.h"
40#include "dev.h" 39#include "dev.h"
41#include "commands.h" 40#include "commands.h"
42#include "tt.h" 41#include "tt.h"
diff --git a/drivers/net/wireless/iwlwifi/dvm/tx.c b/drivers/net/wireless/iwlwifi/dvm/tx.c
index 7e3bd6281551..0dfaf649b257 100644
--- a/drivers/net/wireless/iwlwifi/dvm/tx.c
+++ b/drivers/net/wireless/iwlwifi/dvm/tx.c
@@ -186,7 +186,8 @@ static void iwlagn_tx_cmd_build_rate(struct iwl_priv *priv,
186 rate_idx = info->control.rates[0].idx; 186 rate_idx = info->control.rates[0].idx;
187 if (info->control.rates[0].flags & IEEE80211_TX_RC_MCS || 187 if (info->control.rates[0].flags & IEEE80211_TX_RC_MCS ||
188 (rate_idx < 0) || (rate_idx > IWL_RATE_COUNT_LEGACY)) 188 (rate_idx < 0) || (rate_idx > IWL_RATE_COUNT_LEGACY))
189 rate_idx = rate_lowest_index(&priv->bands[info->band], 189 rate_idx = rate_lowest_index(
190 &priv->eeprom_data->bands[info->band],
190 info->control.sta); 191 info->control.sta);
191 /* For 5 GHZ band, remap mac80211 rate indices into driver indices */ 192 /* For 5 GHZ band, remap mac80211 rate indices into driver indices */
192 if (info->band == IEEE80211_BAND_5GHZ) 193 if (info->band == IEEE80211_BAND_5GHZ)
@@ -206,10 +207,11 @@ static void iwlagn_tx_cmd_build_rate(struct iwl_priv *priv,
206 priv->bt_full_concurrent) { 207 priv->bt_full_concurrent) {
207 /* operated as 1x1 in full concurrency mode */ 208 /* operated as 1x1 in full concurrency mode */
208 priv->mgmt_tx_ant = iwl_toggle_tx_ant(priv, priv->mgmt_tx_ant, 209 priv->mgmt_tx_ant = iwl_toggle_tx_ant(priv, priv->mgmt_tx_ant,
209 first_antenna(priv->hw_params.valid_tx_ant)); 210 first_antenna(priv->eeprom_data->valid_tx_ant));
210 } else 211 } else
211 priv->mgmt_tx_ant = iwl_toggle_tx_ant(priv, priv->mgmt_tx_ant, 212 priv->mgmt_tx_ant = iwl_toggle_tx_ant(
212 priv->hw_params.valid_tx_ant); 213 priv, priv->mgmt_tx_ant,
214 priv->eeprom_data->valid_tx_ant);
213 rate_flags |= iwl_ant_idx_to_flags(priv->mgmt_tx_ant); 215 rate_flags |= iwl_ant_idx_to_flags(priv->mgmt_tx_ant);
214 216
215 /* Set the rate in the TX cmd */ 217 /* Set the rate in the TX cmd */
diff --git a/drivers/net/wireless/iwlwifi/dvm/ucode.c b/drivers/net/wireless/iwlwifi/dvm/ucode.c
index 5a2e186c7ded..b3a314ba48c7 100644
--- a/drivers/net/wireless/iwlwifi/dvm/ucode.c
+++ b/drivers/net/wireless/iwlwifi/dvm/ucode.c
@@ -61,8 +61,7 @@ iwl_get_ucode_image(struct iwl_priv *priv, enum iwl_ucode_type ucode_type)
61static int iwl_set_Xtal_calib(struct iwl_priv *priv) 61static int iwl_set_Xtal_calib(struct iwl_priv *priv)
62{ 62{
63 struct iwl_calib_xtal_freq_cmd cmd; 63 struct iwl_calib_xtal_freq_cmd cmd;
64 __le16 *xtal_calib = 64 __le16 *xtal_calib = priv->eeprom_data->xtal_calib;
65 (__le16 *)iwl_eeprom_query_addr(priv, EEPROM_XTAL);
66 65
67 iwl_set_calib_hdr(&cmd.hdr, IWL_PHY_CALIBRATE_CRYSTAL_FRQ_CMD); 66 iwl_set_calib_hdr(&cmd.hdr, IWL_PHY_CALIBRATE_CRYSTAL_FRQ_CMD);
68 cmd.cap_pin1 = le16_to_cpu(xtal_calib[0]); 67 cmd.cap_pin1 = le16_to_cpu(xtal_calib[0]);
@@ -73,12 +72,10 @@ static int iwl_set_Xtal_calib(struct iwl_priv *priv)
73static int iwl_set_temperature_offset_calib(struct iwl_priv *priv) 72static int iwl_set_temperature_offset_calib(struct iwl_priv *priv)
74{ 73{
75 struct iwl_calib_temperature_offset_cmd cmd; 74 struct iwl_calib_temperature_offset_cmd cmd;
76 __le16 *offset_calib =
77 (__le16 *)iwl_eeprom_query_addr(priv, EEPROM_RAW_TEMPERATURE);
78 75
79 memset(&cmd, 0, sizeof(cmd)); 76 memset(&cmd, 0, sizeof(cmd));
80 iwl_set_calib_hdr(&cmd.hdr, IWL_PHY_CALIBRATE_TEMP_OFFSET_CMD); 77 iwl_set_calib_hdr(&cmd.hdr, IWL_PHY_CALIBRATE_TEMP_OFFSET_CMD);
81 memcpy(&cmd.radio_sensor_offset, offset_calib, sizeof(*offset_calib)); 78 cmd.radio_sensor_offset = priv->eeprom_data->raw_temperature;
82 if (!(cmd.radio_sensor_offset)) 79 if (!(cmd.radio_sensor_offset))
83 cmd.radio_sensor_offset = DEFAULT_RADIO_SENSOR_OFFSET; 80 cmd.radio_sensor_offset = DEFAULT_RADIO_SENSOR_OFFSET;
84 81
@@ -90,27 +87,17 @@ static int iwl_set_temperature_offset_calib(struct iwl_priv *priv)
90static int iwl_set_temperature_offset_calib_v2(struct iwl_priv *priv) 87static int iwl_set_temperature_offset_calib_v2(struct iwl_priv *priv)
91{ 88{
92 struct iwl_calib_temperature_offset_v2_cmd cmd; 89 struct iwl_calib_temperature_offset_v2_cmd cmd;
93 __le16 *offset_calib_high = (__le16 *)iwl_eeprom_query_addr(priv,
94 EEPROM_KELVIN_TEMPERATURE);
95 __le16 *offset_calib_low =
96 (__le16 *)iwl_eeprom_query_addr(priv, EEPROM_RAW_TEMPERATURE);
97 struct iwl_eeprom_calib_hdr *hdr;
98 90
99 memset(&cmd, 0, sizeof(cmd)); 91 memset(&cmd, 0, sizeof(cmd));
100 iwl_set_calib_hdr(&cmd.hdr, IWL_PHY_CALIBRATE_TEMP_OFFSET_CMD); 92 iwl_set_calib_hdr(&cmd.hdr, IWL_PHY_CALIBRATE_TEMP_OFFSET_CMD);
101 hdr = (struct iwl_eeprom_calib_hdr *)iwl_eeprom_query_addr(priv, 93 cmd.radio_sensor_offset_high = priv->eeprom_data->kelvin_temperature;
102 EEPROM_CALIB_ALL); 94 cmd.radio_sensor_offset_low = priv->eeprom_data->raw_temperature;
103 memcpy(&cmd.radio_sensor_offset_high, offset_calib_high, 95 if (!cmd.radio_sensor_offset_low) {
104 sizeof(*offset_calib_high));
105 memcpy(&cmd.radio_sensor_offset_low, offset_calib_low,
106 sizeof(*offset_calib_low));
107 if (!(cmd.radio_sensor_offset_low)) {
108 IWL_DEBUG_CALIB(priv, "no info in EEPROM, use default\n"); 96 IWL_DEBUG_CALIB(priv, "no info in EEPROM, use default\n");
109 cmd.radio_sensor_offset_low = DEFAULT_RADIO_SENSOR_OFFSET; 97 cmd.radio_sensor_offset_low = DEFAULT_RADIO_SENSOR_OFFSET;
110 cmd.radio_sensor_offset_high = DEFAULT_RADIO_SENSOR_OFFSET; 98 cmd.radio_sensor_offset_high = DEFAULT_RADIO_SENSOR_OFFSET;
111 } 99 }
112 memcpy(&cmd.burntVoltageRef, &hdr->voltage, 100 cmd.burntVoltageRef = priv->eeprom_data->calib_voltage;
113 sizeof(hdr->voltage));
114 101
115 IWL_DEBUG_CALIB(priv, "Radio sensor offset high: %d\n", 102 IWL_DEBUG_CALIB(priv, "Radio sensor offset high: %d\n",
116 le16_to_cpu(cmd.radio_sensor_offset_high)); 103 le16_to_cpu(cmd.radio_sensor_offset_high));
diff --git a/drivers/net/wireless/iwlwifi/iwl-config.h b/drivers/net/wireless/iwlwifi/iwl-config.h
index af3a46126f01..e9accfccc050 100644
--- a/drivers/net/wireless/iwlwifi/iwl-config.h
+++ b/drivers/net/wireless/iwlwifi/iwl-config.h
@@ -194,6 +194,24 @@ struct iwl_ht_params {
194 u8 ht40_bands; 194 u8 ht40_bands;
195}; 195};
196 196
197/*
198 * information on how to parse the EEPROM
199 */
200#define EEPROM_REG_BAND_1_CHANNELS 0x08
201#define EEPROM_REG_BAND_2_CHANNELS 0x26
202#define EEPROM_REG_BAND_3_CHANNELS 0x42
203#define EEPROM_REG_BAND_4_CHANNELS 0x5C
204#define EEPROM_REG_BAND_5_CHANNELS 0x74
205#define EEPROM_REG_BAND_24_HT40_CHANNELS 0x82
206#define EEPROM_REG_BAND_52_HT40_CHANNELS 0x92
207#define EEPROM_6000_REG_BAND_24_HT40_CHANNELS 0x80
208#define EEPROM_REGULATORY_BAND_NO_HT40 0
209
210struct iwl_eeprom_params {
211 const u8 regulatory_bands[7];
212 bool enhanced_txpower;
213};
214
197/** 215/**
198 * struct iwl_cfg 216 * struct iwl_cfg
199 * @name: Offical name of the device 217 * @name: Offical name of the device
@@ -246,6 +264,7 @@ struct iwl_cfg {
246 /* params likely to change within a device family */ 264 /* params likely to change within a device family */
247 const struct iwl_ht_params *ht_params; 265 const struct iwl_ht_params *ht_params;
248 const struct iwl_bt_params *bt_params; 266 const struct iwl_bt_params *bt_params;
267 const struct iwl_eeprom_params *eeprom_params;
249 const bool need_temp_offset_calib; /* if used set to true */ 268 const bool need_temp_offset_calib; /* if used set to true */
250 const bool no_xtal_calib; 269 const bool no_xtal_calib;
251 enum iwl_led_mode led_mode; 270 enum iwl_led_mode led_mode;
diff --git a/drivers/net/wireless/iwlwifi/iwl-debug.h b/drivers/net/wireless/iwlwifi/iwl-debug.h
index f6bf91c8f773..42b20b0e83bc 100644
--- a/drivers/net/wireless/iwlwifi/iwl-debug.h
+++ b/drivers/net/wireless/iwlwifi/iwl-debug.h
@@ -45,6 +45,7 @@ void __iwl_crit(struct device *dev, const char *fmt, ...) __printf(2, 3);
45 45
46/* No matter what is m (priv, bus, trans), this will work */ 46/* No matter what is m (priv, bus, trans), this will work */
47#define IWL_ERR(m, f, a...) __iwl_err((m)->dev, false, false, f, ## a) 47#define IWL_ERR(m, f, a...) __iwl_err((m)->dev, false, false, f, ## a)
48#define IWL_ERR_DEV(d, f, a...) __iwl_err((d), false, false, f, ## a)
48#define IWL_WARN(m, f, a...) __iwl_warn((m)->dev, f, ## a) 49#define IWL_WARN(m, f, a...) __iwl_warn((m)->dev, f, ## a)
49#define IWL_INFO(m, f, a...) __iwl_info((m)->dev, f, ## a) 50#define IWL_INFO(m, f, a...) __iwl_info((m)->dev, f, ## a)
50#define IWL_CRIT(m, f, a...) __iwl_crit((m)->dev, f, ## a) 51#define IWL_CRIT(m, f, a...) __iwl_crit((m)->dev, f, ## a)
@@ -69,6 +70,8 @@ do { \
69 70
70#define IWL_DEBUG(m, level, fmt, args...) \ 71#define IWL_DEBUG(m, level, fmt, args...) \
71 __iwl_dbg((m)->dev, level, false, __func__, fmt, ##args) 72 __iwl_dbg((m)->dev, level, false, __func__, fmt, ##args)
73#define IWL_DEBUG_DEV(dev, level, fmt, args...) \
74 __iwl_dbg((dev), level, false, __func__, fmt, ##args)
72#define IWL_DEBUG_LIMIT(m, level, fmt, args...) \ 75#define IWL_DEBUG_LIMIT(m, level, fmt, args...) \
73 __iwl_dbg((m)->dev, level, true, __func__, fmt, ##args) 76 __iwl_dbg((m)->dev, level, true, __func__, fmt, ##args)
74 77
@@ -153,7 +156,7 @@ do { \
153#define IWL_DEBUG_LED(p, f, a...) IWL_DEBUG(p, IWL_DL_LED, f, ## a) 156#define IWL_DEBUG_LED(p, f, a...) IWL_DEBUG(p, IWL_DL_LED, f, ## a)
154#define IWL_DEBUG_WEP(p, f, a...) IWL_DEBUG(p, IWL_DL_WEP, f, ## a) 157#define IWL_DEBUG_WEP(p, f, a...) IWL_DEBUG(p, IWL_DL_WEP, f, ## a)
155#define IWL_DEBUG_HC(p, f, a...) IWL_DEBUG(p, IWL_DL_HCMD, f, ## a) 158#define IWL_DEBUG_HC(p, f, a...) IWL_DEBUG(p, IWL_DL_HCMD, f, ## a)
156#define IWL_DEBUG_EEPROM(p, f, a...) IWL_DEBUG(p, IWL_DL_EEPROM, f, ## a) 159#define IWL_DEBUG_EEPROM(d, f, a...) IWL_DEBUG_DEV(d, IWL_DL_EEPROM, f, ## a)
157#define IWL_DEBUG_CALIB(p, f, a...) IWL_DEBUG(p, IWL_DL_CALIB, f, ## a) 160#define IWL_DEBUG_CALIB(p, f, a...) IWL_DEBUG(p, IWL_DL_CALIB, f, ## a)
158#define IWL_DEBUG_FW(p, f, a...) IWL_DEBUG(p, IWL_DL_FW, f, ## a) 161#define IWL_DEBUG_FW(p, f, a...) IWL_DEBUG(p, IWL_DL_FW, f, ## a)
159#define IWL_DEBUG_RF_KILL(p, f, a...) IWL_DEBUG(p, IWL_DL_RF_KILL, f, ## a) 162#define IWL_DEBUG_RF_KILL(p, f, a...) IWL_DEBUG(p, IWL_DL_RF_KILL, f, ## a)
diff --git a/drivers/net/wireless/iwlwifi/iwl-eeprom-parse.c b/drivers/net/wireless/iwlwifi/iwl-eeprom-parse.c
new file mode 100644
index 000000000000..c87a05cbec12
--- /dev/null
+++ b/drivers/net/wireless/iwlwifi/iwl-eeprom-parse.c
@@ -0,0 +1,900 @@
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 - 2012 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 LICENSE.GPL.
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 - 2012 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-modparams.h"
66#include "iwl-eeprom-parse.h"
67
68/* EEPROM offset definitions */
69
70/* indirect access definitions */
71#define ADDRESS_MSK 0x0000FFFF
72#define INDIRECT_TYPE_MSK 0x000F0000
73#define INDIRECT_HOST 0x00010000
74#define INDIRECT_GENERAL 0x00020000
75#define INDIRECT_REGULATORY 0x00030000
76#define INDIRECT_CALIBRATION 0x00040000
77#define INDIRECT_PROCESS_ADJST 0x00050000
78#define INDIRECT_OTHERS 0x00060000
79#define INDIRECT_TXP_LIMIT 0x00070000
80#define INDIRECT_TXP_LIMIT_SIZE 0x00080000
81#define INDIRECT_ADDRESS 0x00100000
82
83/* corresponding link offsets in EEPROM */
84#define EEPROM_LINK_HOST (2*0x64)
85#define EEPROM_LINK_GENERAL (2*0x65)
86#define EEPROM_LINK_REGULATORY (2*0x66)
87#define EEPROM_LINK_CALIBRATION (2*0x67)
88#define EEPROM_LINK_PROCESS_ADJST (2*0x68)
89#define EEPROM_LINK_OTHERS (2*0x69)
90#define EEPROM_LINK_TXP_LIMIT (2*0x6a)
91#define EEPROM_LINK_TXP_LIMIT_SIZE (2*0x6b)
92
93/* General */
94#define EEPROM_DEVICE_ID (2*0x08) /* 2 bytes */
95#define EEPROM_SUBSYSTEM_ID (2*0x0A) /* 2 bytes */
96#define EEPROM_MAC_ADDRESS (2*0x15) /* 6 bytes */
97#define EEPROM_BOARD_REVISION (2*0x35) /* 2 bytes */
98#define EEPROM_BOARD_PBA_NUMBER (2*0x3B+1) /* 9 bytes */
99#define EEPROM_VERSION (2*0x44) /* 2 bytes */
100#define EEPROM_SKU_CAP (2*0x45) /* 2 bytes */
101#define EEPROM_OEM_MODE (2*0x46) /* 2 bytes */
102#define EEPROM_RADIO_CONFIG (2*0x48) /* 2 bytes */
103#define EEPROM_NUM_MAC_ADDRESS (2*0x4C) /* 2 bytes */
104
105/* calibration */
106struct iwl_eeprom_calib_hdr {
107 u8 version;
108 u8 pa_type;
109 __le16 voltage;
110} __packed;
111
112#define EEPROM_CALIB_ALL (INDIRECT_ADDRESS | INDIRECT_CALIBRATION)
113#define EEPROM_XTAL ((2*0x128) | EEPROM_CALIB_ALL)
114
115/* temperature */
116#define EEPROM_KELVIN_TEMPERATURE ((2*0x12A) | EEPROM_CALIB_ALL)
117#define EEPROM_RAW_TEMPERATURE ((2*0x12B) | EEPROM_CALIB_ALL)
118
119/*
120 * EEPROM bands
121 * These are the channel numbers from each band in the order
122 * that they are stored in the EEPROM band information. Note
123 * that EEPROM bands aren't the same as mac80211 bands, and
124 * there are even special "ht40 bands" in the EEPROM.
125 */
126static const u8 iwl_eeprom_band_1[14] = { /* 2.4 GHz */
127 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14
128};
129
130static const u8 iwl_eeprom_band_2[] = { /* 4915-5080MHz */
131 183, 184, 185, 187, 188, 189, 192, 196, 7, 8, 11, 12, 16
132};
133
134static const u8 iwl_eeprom_band_3[] = { /* 5170-5320MHz */
135 34, 36, 38, 40, 42, 44, 46, 48, 52, 56, 60, 64
136};
137
138static const u8 iwl_eeprom_band_4[] = { /* 5500-5700MHz */
139 100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140
140};
141
142static const u8 iwl_eeprom_band_5[] = { /* 5725-5825MHz */
143 145, 149, 153, 157, 161, 165
144};
145
146static const u8 iwl_eeprom_band_6[] = { /* 2.4 ht40 channel */
147 1, 2, 3, 4, 5, 6, 7
148};
149
150static const u8 iwl_eeprom_band_7[] = { /* 5.2 ht40 channel */
151 36, 44, 52, 60, 100, 108, 116, 124, 132, 149, 157
152};
153
154#define IWL_NUM_CHANNELS (ARRAY_SIZE(iwl_eeprom_band_1) + \
155 ARRAY_SIZE(iwl_eeprom_band_2) + \
156 ARRAY_SIZE(iwl_eeprom_band_3) + \
157 ARRAY_SIZE(iwl_eeprom_band_4) + \
158 ARRAY_SIZE(iwl_eeprom_band_5))
159
160/* rate data (static) */
161static struct ieee80211_rate iwl_cfg80211_rates[] = {
162 { .bitrate = 1 * 10, .hw_value = 0, .hw_value_short = 0, },
163 { .bitrate = 2 * 10, .hw_value = 1, .hw_value_short = 1,
164 .flags = IEEE80211_RATE_SHORT_PREAMBLE, },
165 { .bitrate = 5.5 * 10, .hw_value = 2, .hw_value_short = 2,
166 .flags = IEEE80211_RATE_SHORT_PREAMBLE, },
167 { .bitrate = 11 * 10, .hw_value = 3, .hw_value_short = 3,
168 .flags = IEEE80211_RATE_SHORT_PREAMBLE, },
169 { .bitrate = 6 * 10, .hw_value = 4, .hw_value_short = 4, },
170 { .bitrate = 9 * 10, .hw_value = 5, .hw_value_short = 5, },
171 { .bitrate = 12 * 10, .hw_value = 6, .hw_value_short = 6, },
172 { .bitrate = 18 * 10, .hw_value = 7, .hw_value_short = 7, },
173 { .bitrate = 24 * 10, .hw_value = 8, .hw_value_short = 8, },
174 { .bitrate = 36 * 10, .hw_value = 9, .hw_value_short = 9, },
175 { .bitrate = 48 * 10, .hw_value = 10, .hw_value_short = 10, },
176 { .bitrate = 54 * 10, .hw_value = 11, .hw_value_short = 11, },
177};
178#define RATES_24_OFFS 0
179#define N_RATES_24 ARRAY_SIZE(iwl_cfg80211_rates)
180#define RATES_52_OFFS 4
181#define N_RATES_52 (N_RATES_24 - RATES_52_OFFS)
182
183/* EEPROM reading functions */
184
185static u16 iwl_eeprom_query16(const u8 *eeprom, size_t eeprom_size, int offset)
186{
187 if (WARN_ON(offset + sizeof(u16) > eeprom_size))
188 return 0;
189 return le16_to_cpup((__le16 *)(eeprom + offset));
190}
191
192static u32 eeprom_indirect_address(const u8 *eeprom, size_t eeprom_size,
193 u32 address)
194{
195 u16 offset = 0;
196
197 if ((address & INDIRECT_ADDRESS) == 0)
198 return address;
199
200 switch (address & INDIRECT_TYPE_MSK) {
201 case INDIRECT_HOST:
202 offset = iwl_eeprom_query16(eeprom, eeprom_size,
203 EEPROM_LINK_HOST);
204 break;
205 case INDIRECT_GENERAL:
206 offset = iwl_eeprom_query16(eeprom, eeprom_size,
207 EEPROM_LINK_GENERAL);
208 break;
209 case INDIRECT_REGULATORY:
210 offset = iwl_eeprom_query16(eeprom, eeprom_size,
211 EEPROM_LINK_REGULATORY);
212 break;
213 case INDIRECT_TXP_LIMIT:
214 offset = iwl_eeprom_query16(eeprom, eeprom_size,
215 EEPROM_LINK_TXP_LIMIT);
216 break;
217 case INDIRECT_TXP_LIMIT_SIZE:
218 offset = iwl_eeprom_query16(eeprom, eeprom_size,
219 EEPROM_LINK_TXP_LIMIT_SIZE);
220 break;
221 case INDIRECT_CALIBRATION:
222 offset = iwl_eeprom_query16(eeprom, eeprom_size,
223 EEPROM_LINK_CALIBRATION);
224 break;
225 case INDIRECT_PROCESS_ADJST:
226 offset = iwl_eeprom_query16(eeprom, eeprom_size,
227 EEPROM_LINK_PROCESS_ADJST);
228 break;
229 case INDIRECT_OTHERS:
230 offset = iwl_eeprom_query16(eeprom, eeprom_size,
231 EEPROM_LINK_OTHERS);
232 break;
233 default:
234 WARN_ON(1);
235 break;
236 }
237
238 /* translate the offset from words to byte */
239 return (address & ADDRESS_MSK) + (offset << 1);
240}
241
242static const u8 *iwl_eeprom_query_addr(const u8 *eeprom, size_t eeprom_size,
243 u32 offset)
244{
245 u32 address = eeprom_indirect_address(eeprom, eeprom_size, offset);
246
247 if (WARN_ON(address >= eeprom_size))
248 return NULL;
249
250 return &eeprom[address];
251}
252
253static int iwl_eeprom_read_calib(const u8 *eeprom, size_t eeprom_size,
254 struct iwl_eeprom_data *data)
255{
256 struct iwl_eeprom_calib_hdr *hdr;
257
258 hdr = (void *)iwl_eeprom_query_addr(eeprom, eeprom_size,
259 EEPROM_CALIB_ALL);
260 if (!hdr)
261 return -ENODATA;
262 data->calib_version = hdr->version;
263 data->calib_voltage = hdr->voltage;
264
265 return 0;
266}
267
268/**
269 * enum iwl_eeprom_channel_flags - channel flags in EEPROM
270 * @EEPROM_CHANNEL_VALID: channel is usable for this SKU/geo
271 * @EEPROM_CHANNEL_IBSS: usable as an IBSS channel
272 * @EEPROM_CHANNEL_ACTIVE: active scanning allowed
273 * @EEPROM_CHANNEL_RADAR: radar detection required
274 * @EEPROM_CHANNEL_WIDE: 20 MHz channel okay (?)
275 * @EEPROM_CHANNEL_DFS: dynamic freq selection candidate
276 */
277enum iwl_eeprom_channel_flags {
278 EEPROM_CHANNEL_VALID = BIT(0),
279 EEPROM_CHANNEL_IBSS = BIT(1),
280 EEPROM_CHANNEL_ACTIVE = BIT(3),
281 EEPROM_CHANNEL_RADAR = BIT(4),
282 EEPROM_CHANNEL_WIDE = BIT(5),
283 EEPROM_CHANNEL_DFS = BIT(7),
284};
285
286/**
287 * struct iwl_eeprom_channel - EEPROM channel data
288 * @flags: %EEPROM_CHANNEL_* flags
289 * @max_power_avg: max power (in dBm) on this channel, at most 31 dBm
290 */
291struct iwl_eeprom_channel {
292 u8 flags;
293 s8 max_power_avg;
294} __packed;
295
296
297enum iwl_eeprom_enhanced_txpwr_flags {
298 IWL_EEPROM_ENH_TXP_FL_VALID = BIT(0),
299 IWL_EEPROM_ENH_TXP_FL_BAND_52G = BIT(1),
300 IWL_EEPROM_ENH_TXP_FL_OFDM = BIT(2),
301 IWL_EEPROM_ENH_TXP_FL_40MHZ = BIT(3),
302 IWL_EEPROM_ENH_TXP_FL_HT_AP = BIT(4),
303 IWL_EEPROM_ENH_TXP_FL_RES1 = BIT(5),
304 IWL_EEPROM_ENH_TXP_FL_RES2 = BIT(6),
305 IWL_EEPROM_ENH_TXP_FL_COMMON_TYPE = BIT(7),
306};
307
308/**
309 * iwl_eeprom_enhanced_txpwr structure
310 * @flags: entry flags
311 * @channel: channel number
312 * @chain_a_max_pwr: chain a max power in 1/2 dBm
313 * @chain_b_max_pwr: chain b max power in 1/2 dBm
314 * @chain_c_max_pwr: chain c max power in 1/2 dBm
315 * @delta_20_in_40: 20-in-40 deltas (hi/lo)
316 * @mimo2_max_pwr: mimo2 max power in 1/2 dBm
317 * @mimo3_max_pwr: mimo3 max power in 1/2 dBm
318 *
319 * This structure presents the enhanced regulatory tx power limit layout
320 * in an EEPROM image.
321 */
322struct iwl_eeprom_enhanced_txpwr {
323 u8 flags;
324 u8 channel;
325 s8 chain_a_max;
326 s8 chain_b_max;
327 s8 chain_c_max;
328 u8 delta_20_in_40;
329 s8 mimo2_max;
330 s8 mimo3_max;
331} __packed;
332
333static s8 iwl_get_max_txpwr_half_dbm(const struct iwl_eeprom_data *data,
334 struct iwl_eeprom_enhanced_txpwr *txp)
335{
336 s8 result = 0; /* (.5 dBm) */
337
338 /* Take the highest tx power from any valid chains */
339 if (data->valid_tx_ant & ANT_A && txp->chain_a_max > result)
340 result = txp->chain_a_max;
341
342 if (data->valid_tx_ant & ANT_B && txp->chain_b_max > result)
343 result = txp->chain_b_max;
344
345 if (data->valid_tx_ant & ANT_C && txp->chain_c_max > result)
346 result = txp->chain_c_max;
347
348 if ((data->valid_tx_ant == ANT_AB ||
349 data->valid_tx_ant == ANT_BC ||
350 data->valid_tx_ant == ANT_AC) && txp->mimo2_max > result)
351 result = txp->mimo2_max;
352
353 if (data->valid_tx_ant == ANT_ABC && txp->mimo3_max > result)
354 result = txp->mimo3_max;
355
356 return result;
357}
358
359#define EEPROM_TXP_OFFS (0x00 | INDIRECT_ADDRESS | INDIRECT_TXP_LIMIT)
360#define EEPROM_TXP_ENTRY_LEN sizeof(struct iwl_eeprom_enhanced_txpwr)
361#define EEPROM_TXP_SZ_OFFS (0x00 | INDIRECT_ADDRESS | INDIRECT_TXP_LIMIT_SIZE)
362
363#define TXP_CHECK_AND_PRINT(x) \
364 ((txp->flags & IWL_EEPROM_ENH_TXP_FL_##x) ? # x " " : "")
365
366static void
367iwl_eeprom_enh_txp_read_element(struct iwl_eeprom_data *data,
368 struct iwl_eeprom_enhanced_txpwr *txp,
369 int n_channels, s8 max_txpower_avg)
370{
371 int ch_idx;
372 enum ieee80211_band band;
373
374 band = txp->flags & IWL_EEPROM_ENH_TXP_FL_BAND_52G ?
375 IEEE80211_BAND_5GHZ : IEEE80211_BAND_2GHZ;
376
377 for (ch_idx = 0; ch_idx < n_channels; ch_idx++) {
378 struct ieee80211_channel *chan = &data->channels[ch_idx];
379
380 /* update matching channel or from common data only */
381 if (txp->channel != 0 && chan->hw_value != txp->channel)
382 continue;
383
384 /* update matching band only */
385 if (band != chan->band)
386 continue;
387
388 if (chan->max_power < max_txpower_avg &&
389 !(txp->flags & IWL_EEPROM_ENH_TXP_FL_40MHZ))
390 chan->max_power = max_txpower_avg;
391 }
392}
393
394static void iwl_eeprom_enhanced_txpower(struct device *dev,
395 struct iwl_eeprom_data *data,
396 const u8 *eeprom, size_t eeprom_size,
397 int n_channels)
398{
399 struct iwl_eeprom_enhanced_txpwr *txp_array, *txp;
400 int idx, entries;
401 __le16 *txp_len;
402 s8 max_txp_avg_halfdbm;
403
404 BUILD_BUG_ON(sizeof(struct iwl_eeprom_enhanced_txpwr) != 8);
405
406 /* the length is in 16-bit words, but we want entries */
407 txp_len = (__le16 *)iwl_eeprom_query_addr(eeprom, eeprom_size,
408 EEPROM_TXP_SZ_OFFS);
409 entries = le16_to_cpup(txp_len) * 2 / EEPROM_TXP_ENTRY_LEN;
410
411 txp_array = (void *)iwl_eeprom_query_addr(eeprom, eeprom_size,
412 EEPROM_TXP_OFFS);
413
414 for (idx = 0; idx < entries; idx++) {
415 txp = &txp_array[idx];
416 /* skip invalid entries */
417 if (!(txp->flags & IWL_EEPROM_ENH_TXP_FL_VALID))
418 continue;
419
420 IWL_DEBUG_EEPROM(dev, "%s %d:\t %s%s%s%s%s%s%s%s (0x%02x)\n",
421 (txp->channel && (txp->flags &
422 IWL_EEPROM_ENH_TXP_FL_COMMON_TYPE)) ?
423 "Common " : (txp->channel) ?
424 "Channel" : "Common",
425 (txp->channel),
426 TXP_CHECK_AND_PRINT(VALID),
427 TXP_CHECK_AND_PRINT(BAND_52G),
428 TXP_CHECK_AND_PRINT(OFDM),
429 TXP_CHECK_AND_PRINT(40MHZ),
430 TXP_CHECK_AND_PRINT(HT_AP),
431 TXP_CHECK_AND_PRINT(RES1),
432 TXP_CHECK_AND_PRINT(RES2),
433 TXP_CHECK_AND_PRINT(COMMON_TYPE),
434 txp->flags);
435 IWL_DEBUG_EEPROM(dev,
436 "\t\t chain_A: 0x%02x chain_B: 0X%02x chain_C: 0X%02x\n",
437 txp->chain_a_max, txp->chain_b_max,
438 txp->chain_c_max);
439 IWL_DEBUG_EEPROM(dev,
440 "\t\t MIMO2: 0x%02x MIMO3: 0x%02x High 20_on_40: 0x%02x Low 20_on_40: 0x%02x\n",
441 txp->mimo2_max, txp->mimo3_max,
442 ((txp->delta_20_in_40 & 0xf0) >> 4),
443 (txp->delta_20_in_40 & 0x0f));
444
445 max_txp_avg_halfdbm = iwl_get_max_txpwr_half_dbm(data, txp);
446
447 iwl_eeprom_enh_txp_read_element(data, txp, n_channels,
448 DIV_ROUND_UP(max_txp_avg_halfdbm, 2));
449
450 if (max_txp_avg_halfdbm > data->max_tx_pwr_half_dbm)
451 data->max_tx_pwr_half_dbm = max_txp_avg_halfdbm;
452 }
453}
454
455static void iwl_init_band_reference(const struct iwl_cfg *cfg,
456 const u8 *eeprom, size_t eeprom_size,
457 int eeprom_band, int *eeprom_ch_count,
458 const struct iwl_eeprom_channel **ch_info,
459 const u8 **eeprom_ch_array)
460{
461 u32 offset = cfg->eeprom_params->regulatory_bands[eeprom_band - 1];
462
463 offset |= INDIRECT_ADDRESS | INDIRECT_REGULATORY;
464
465 *ch_info = (void *)iwl_eeprom_query_addr(eeprom, eeprom_size, offset);
466
467 switch (eeprom_band) {
468 case 1: /* 2.4GHz band */
469 *eeprom_ch_count = ARRAY_SIZE(iwl_eeprom_band_1);
470 *eeprom_ch_array = iwl_eeprom_band_1;
471 break;
472 case 2: /* 4.9GHz band */
473 *eeprom_ch_count = ARRAY_SIZE(iwl_eeprom_band_2);
474 *eeprom_ch_array = iwl_eeprom_band_2;
475 break;
476 case 3: /* 5.2GHz band */
477 *eeprom_ch_count = ARRAY_SIZE(iwl_eeprom_band_3);
478 *eeprom_ch_array = iwl_eeprom_band_3;
479 break;
480 case 4: /* 5.5GHz band */
481 *eeprom_ch_count = ARRAY_SIZE(iwl_eeprom_band_4);
482 *eeprom_ch_array = iwl_eeprom_band_4;
483 break;
484 case 5: /* 5.7GHz band */
485 *eeprom_ch_count = ARRAY_SIZE(iwl_eeprom_band_5);
486 *eeprom_ch_array = iwl_eeprom_band_5;
487 break;
488 case 6: /* 2.4GHz ht40 channels */
489 *eeprom_ch_count = ARRAY_SIZE(iwl_eeprom_band_6);
490 *eeprom_ch_array = iwl_eeprom_band_6;
491 break;
492 case 7: /* 5 GHz ht40 channels */
493 *eeprom_ch_count = ARRAY_SIZE(iwl_eeprom_band_7);
494 *eeprom_ch_array = iwl_eeprom_band_7;
495 break;
496 default:
497 *eeprom_ch_count = 0;
498 *eeprom_ch_array = NULL;
499 WARN_ON(1);
500 }
501}
502
503#define CHECK_AND_PRINT(x) \
504 ((eeprom_ch->flags & EEPROM_CHANNEL_##x) ? # x " " : "")
505
506static void iwl_mod_ht40_chan_info(struct device *dev,
507 struct iwl_eeprom_data *data, int n_channels,
508 enum ieee80211_band band, u16 channel,
509 const struct iwl_eeprom_channel *eeprom_ch,
510 u8 clear_ht40_extension_channel)
511{
512 struct ieee80211_channel *chan = NULL;
513 int i;
514
515 for (i = 0; i < n_channels; i++) {
516 if (data->channels[i].band != band)
517 continue;
518 if (data->channels[i].hw_value != channel)
519 continue;
520 chan = &data->channels[i];
521 break;
522 }
523
524 if (!chan)
525 return;
526
527 IWL_DEBUG_EEPROM(dev,
528 "HT40 Ch. %d [%sGHz] %s%s%s%s%s(0x%02x %ddBm): Ad-Hoc %ssupported\n",
529 channel,
530 band == IEEE80211_BAND_5GHZ ? "5.2" : "2.4",
531 CHECK_AND_PRINT(IBSS),
532 CHECK_AND_PRINT(ACTIVE),
533 CHECK_AND_PRINT(RADAR),
534 CHECK_AND_PRINT(WIDE),
535 CHECK_AND_PRINT(DFS),
536 eeprom_ch->flags,
537 eeprom_ch->max_power_avg,
538 ((eeprom_ch->flags & EEPROM_CHANNEL_IBSS) &&
539 !(eeprom_ch->flags & EEPROM_CHANNEL_RADAR)) ? ""
540 : "not ");
541
542 if (eeprom_ch->flags & EEPROM_CHANNEL_VALID)
543 chan->flags &= ~clear_ht40_extension_channel;
544}
545
546#define CHECK_AND_PRINT_I(x) \
547 ((eeprom_ch_info[ch_idx].flags & EEPROM_CHANNEL_##x) ? # x " " : "")
548
549static int iwl_init_channel_map(struct device *dev, const struct iwl_cfg *cfg,
550 struct iwl_eeprom_data *data,
551 const u8 *eeprom, size_t eeprom_size)
552{
553 int band, ch_idx;
554 const struct iwl_eeprom_channel *eeprom_ch_info;
555 const u8 *eeprom_ch_array;
556 int eeprom_ch_count;
557 int n_channels = 0;
558
559 /*
560 * Loop through the 5 EEPROM bands and add them to the parse list
561 */
562 for (band = 1; band <= 5; band++) {
563 struct ieee80211_channel *channel;
564
565 iwl_init_band_reference(cfg, eeprom, eeprom_size, band,
566 &eeprom_ch_count, &eeprom_ch_info,
567 &eeprom_ch_array);
568
569 /* Loop through each band adding each of the channels */
570 for (ch_idx = 0; ch_idx < eeprom_ch_count; ch_idx++) {
571 const struct iwl_eeprom_channel *eeprom_ch;
572
573 eeprom_ch = &eeprom_ch_info[ch_idx];
574
575 if (!(eeprom_ch->flags & EEPROM_CHANNEL_VALID)) {
576 IWL_DEBUG_EEPROM(dev,
577 "Ch. %d Flags %x [%sGHz] - No traffic\n",
578 eeprom_ch_array[ch_idx],
579 eeprom_ch_info[ch_idx].flags,
580 (band != 1) ? "5.2" : "2.4");
581 continue;
582 }
583
584 channel = &data->channels[n_channels];
585 n_channels++;
586
587 channel->hw_value = eeprom_ch_array[ch_idx];
588 channel->band = (band == 1) ? IEEE80211_BAND_2GHZ
589 : IEEE80211_BAND_5GHZ;
590 channel->center_freq =
591 ieee80211_channel_to_frequency(
592 channel->hw_value, channel->band);
593
594 /* set no-HT40, will enable as appropriate later */
595 channel->flags = IEEE80211_CHAN_NO_HT40;
596
597 if (!(eeprom_ch->flags & EEPROM_CHANNEL_IBSS))
598 channel->flags |= IEEE80211_CHAN_NO_IBSS;
599
600 if (!(eeprom_ch->flags & EEPROM_CHANNEL_ACTIVE))
601 channel->flags |= IEEE80211_CHAN_PASSIVE_SCAN;
602
603 if (eeprom_ch->flags & EEPROM_CHANNEL_RADAR)
604 channel->flags |= IEEE80211_CHAN_RADAR;
605
606 /* Initialize regulatory-based run-time data */
607 channel->max_power =
608 eeprom_ch_info[ch_idx].max_power_avg;
609 IWL_DEBUG_EEPROM(dev,
610 "Ch. %d [%sGHz] %s%s%s%s%s%s(0x%02x %ddBm): Ad-Hoc %ssupported\n",
611 channel->hw_value,
612 (band != 1) ? "5.2" : "2.4",
613 CHECK_AND_PRINT_I(VALID),
614 CHECK_AND_PRINT_I(IBSS),
615 CHECK_AND_PRINT_I(ACTIVE),
616 CHECK_AND_PRINT_I(RADAR),
617 CHECK_AND_PRINT_I(WIDE),
618 CHECK_AND_PRINT_I(DFS),
619 eeprom_ch_info[ch_idx].flags,
620 eeprom_ch_info[ch_idx].max_power_avg,
621 ((eeprom_ch_info[ch_idx].flags &
622 EEPROM_CHANNEL_IBSS) &&
623 !(eeprom_ch_info[ch_idx].flags &
624 EEPROM_CHANNEL_RADAR))
625 ? "" : "not ");
626 }
627 }
628
629 if (cfg->eeprom_params->enhanced_txpower) {
630 /*
631 * for newer device (6000 series and up)
632 * EEPROM contain enhanced tx power information
633 * driver need to process addition information
634 * to determine the max channel tx power limits
635 */
636 iwl_eeprom_enhanced_txpower(dev, data, eeprom, eeprom_size,
637 n_channels);
638 } else {
639 /* All others use data from channel map */
640 int i;
641
642 data->max_tx_pwr_half_dbm = -128;
643
644 for (i = 0; i < n_channels; i++)
645 data->max_tx_pwr_half_dbm =
646 max_t(s8, data->max_tx_pwr_half_dbm,
647 data->channels[i].max_power * 2);
648 }
649
650 /* Check if we do have HT40 channels */
651 if (cfg->eeprom_params->regulatory_bands[5] ==
652 EEPROM_REGULATORY_BAND_NO_HT40 &&
653 cfg->eeprom_params->regulatory_bands[6] ==
654 EEPROM_REGULATORY_BAND_NO_HT40)
655 return n_channels;
656
657 /* Two additional EEPROM bands for 2.4 and 5 GHz HT40 channels */
658 for (band = 6; band <= 7; band++) {
659 enum ieee80211_band ieeeband;
660
661 iwl_init_band_reference(cfg, eeprom, eeprom_size, band,
662 &eeprom_ch_count, &eeprom_ch_info,
663 &eeprom_ch_array);
664
665 /* EEPROM band 6 is 2.4, band 7 is 5 GHz */
666 ieeeband = (band == 6) ? IEEE80211_BAND_2GHZ
667 : IEEE80211_BAND_5GHZ;
668
669 /* Loop through each band adding each of the channels */
670 for (ch_idx = 0; ch_idx < eeprom_ch_count; ch_idx++) {
671 /* Set up driver's info for lower half */
672 iwl_mod_ht40_chan_info(dev, data, n_channels, ieeeband,
673 eeprom_ch_array[ch_idx],
674 &eeprom_ch_info[ch_idx],
675 IEEE80211_CHAN_NO_HT40PLUS);
676
677 /* Set up driver's info for upper half */
678 iwl_mod_ht40_chan_info(dev, data, n_channels, ieeeband,
679 eeprom_ch_array[ch_idx] + 4,
680 &eeprom_ch_info[ch_idx],
681 IEEE80211_CHAN_NO_HT40MINUS);
682 }
683 }
684
685 return n_channels;
686}
687
688static int iwl_init_sband_channels(struct iwl_eeprom_data *data,
689 struct ieee80211_supported_band *sband,
690 int n_channels, enum ieee80211_band band)
691{
692 struct ieee80211_channel *chan = &data->channels[0];
693 int n = 0, idx = 0;
694
695 while (chan->band != band && idx < n_channels)
696 chan = &data->channels[++idx];
697
698 sband->channels = &data->channels[idx];
699
700 while (chan->band == band && idx < n_channels) {
701 chan = &data->channels[++idx];
702 n++;
703 }
704
705 sband->n_channels = n;
706
707 return n;
708}
709
710#define MAX_BIT_RATE_40_MHZ 150 /* Mbps */
711#define MAX_BIT_RATE_20_MHZ 72 /* Mbps */
712
713static void iwl_init_ht_hw_capab(const struct iwl_cfg *cfg,
714 struct iwl_eeprom_data *data,
715 struct ieee80211_sta_ht_cap *ht_info,
716 enum ieee80211_band band)
717{
718 int max_bit_rate = 0;
719 u8 rx_chains;
720 u8 tx_chains;
721
722 tx_chains = hweight8(data->valid_tx_ant);
723 if (cfg->rx_with_siso_diversity)
724 rx_chains = 1;
725 else
726 rx_chains = hweight8(data->valid_rx_ant);
727
728 if (!(data->sku & EEPROM_SKU_CAP_11N_ENABLE) || !cfg->ht_params) {
729 ht_info->ht_supported = false;
730 return;
731 }
732
733 ht_info->ht_supported = true;
734 ht_info->cap = 0;
735
736 if (iwlwifi_mod_params.amsdu_size_8K)
737 ht_info->cap |= IEEE80211_HT_CAP_MAX_AMSDU;
738
739 ht_info->ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
740 ht_info->ampdu_density = IEEE80211_HT_MPDU_DENSITY_4;
741
742 ht_info->mcs.rx_mask[0] = 0xFF;
743 if (rx_chains >= 2)
744 ht_info->mcs.rx_mask[1] = 0xFF;
745 if (rx_chains >= 3)
746 ht_info->mcs.rx_mask[2] = 0xFF;
747
748 if (cfg->ht_params->ht_greenfield_support)
749 ht_info->cap |= IEEE80211_HT_CAP_GRN_FLD;
750 ht_info->cap |= IEEE80211_HT_CAP_SGI_20;
751
752 max_bit_rate = MAX_BIT_RATE_20_MHZ;
753
754 if (cfg->ht_params->ht40_bands & BIT(band)) {
755 ht_info->cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
756 ht_info->cap |= IEEE80211_HT_CAP_SGI_40;
757 ht_info->mcs.rx_mask[4] = 0x01;
758 max_bit_rate = MAX_BIT_RATE_40_MHZ;
759 }
760
761 /* Highest supported Rx data rate */
762 max_bit_rate *= rx_chains;
763 WARN_ON(max_bit_rate & ~IEEE80211_HT_MCS_RX_HIGHEST_MASK);
764 ht_info->mcs.rx_highest = cpu_to_le16(max_bit_rate);
765
766 /* Tx MCS capabilities */
767 ht_info->mcs.tx_params = IEEE80211_HT_MCS_TX_DEFINED;
768 if (tx_chains != rx_chains) {
769 ht_info->mcs.tx_params |= IEEE80211_HT_MCS_TX_RX_DIFF;
770 ht_info->mcs.tx_params |= ((tx_chains - 1) <<
771 IEEE80211_HT_MCS_TX_MAX_STREAMS_SHIFT);
772 }
773}
774
775static void iwl_init_sbands(struct device *dev, const struct iwl_cfg *cfg,
776 struct iwl_eeprom_data *data,
777 const u8 *eeprom, size_t eeprom_size)
778{
779 int n_channels = iwl_init_channel_map(dev, cfg, data,
780 eeprom, eeprom_size);
781 int n_used = 0;
782 struct ieee80211_supported_band *sband;
783
784 sband = &data->bands[IEEE80211_BAND_2GHZ];
785 sband->band = IEEE80211_BAND_2GHZ;
786 sband->bitrates = &iwl_cfg80211_rates[RATES_24_OFFS];
787 sband->n_bitrates = N_RATES_24;
788 n_used += iwl_init_sband_channels(data, sband, n_channels,
789 IEEE80211_BAND_2GHZ);
790 iwl_init_ht_hw_capab(cfg, data, &sband->ht_cap, IEEE80211_BAND_2GHZ);
791
792 sband = &data->bands[IEEE80211_BAND_5GHZ];
793 sband->band = IEEE80211_BAND_5GHZ;
794 sband->bitrates = &iwl_cfg80211_rates[RATES_52_OFFS];
795 sband->n_bitrates = N_RATES_52;
796 n_used += iwl_init_sband_channels(data, sband, n_channels,
797 IEEE80211_BAND_5GHZ);
798 iwl_init_ht_hw_capab(cfg, data, &sband->ht_cap, IEEE80211_BAND_5GHZ);
799
800 if (n_channels != n_used)
801 IWL_ERR_DEV(dev, "EEPROM: used only %d of %d channels\n",
802 n_used, n_channels);
803}
804
805/* EEPROM data functions */
806
807struct iwl_eeprom_data *
808iwl_parse_eeprom_data(struct device *dev, const struct iwl_cfg *cfg,
809 const u8 *eeprom, size_t eeprom_size)
810{
811 struct iwl_eeprom_data *data;
812 const void *tmp;
813
814 if (WARN_ON(!cfg || !cfg->eeprom_params))
815 return NULL;
816
817 data = kzalloc(sizeof(*data) +
818 sizeof(struct ieee80211_channel) * IWL_NUM_CHANNELS,
819 GFP_KERNEL);
820 if (!data)
821 return NULL;
822
823 /* get MAC address(es) */
824 tmp = iwl_eeprom_query_addr(eeprom, eeprom_size, EEPROM_MAC_ADDRESS);
825 if (!tmp)
826 goto err_free;
827 memcpy(data->hw_addr, tmp, ETH_ALEN);
828 data->n_hw_addrs = iwl_eeprom_query16(eeprom, eeprom_size,
829 EEPROM_NUM_MAC_ADDRESS);
830
831 if (iwl_eeprom_read_calib(eeprom, eeprom_size, data))
832 goto err_free;
833
834 tmp = iwl_eeprom_query_addr(eeprom, eeprom_size, EEPROM_XTAL);
835 if (!tmp)
836 goto err_free;
837 memcpy(data->xtal_calib, tmp, sizeof(data->xtal_calib));
838
839 tmp = iwl_eeprom_query_addr(eeprom, eeprom_size,
840 EEPROM_RAW_TEMPERATURE);
841 if (!tmp)
842 goto err_free;
843 data->raw_temperature = *(__le16 *)tmp;
844
845 tmp = iwl_eeprom_query_addr(eeprom, eeprom_size,
846 EEPROM_KELVIN_TEMPERATURE);
847 if (!tmp)
848 goto err_free;
849 data->kelvin_temperature = *(__le16 *)tmp;
850 data->kelvin_voltage = *((__le16 *)tmp + 1);
851
852 data->radio_cfg = iwl_eeprom_query16(eeprom, eeprom_size,
853 EEPROM_RADIO_CONFIG);
854 data->sku = iwl_eeprom_query16(eeprom, eeprom_size,
855 EEPROM_SKU_CAP);
856 data->eeprom_version = iwl_eeprom_query16(eeprom, eeprom_size,
857 EEPROM_VERSION);
858
859 data->valid_tx_ant = EEPROM_RF_CFG_TX_ANT_MSK(data->radio_cfg);
860 data->valid_rx_ant = EEPROM_RF_CFG_RX_ANT_MSK(data->radio_cfg);
861
862 /* check overrides (some devices have wrong EEPROM) */
863 if (cfg->valid_tx_ant)
864 data->valid_tx_ant = cfg->valid_tx_ant;
865 if (cfg->valid_rx_ant)
866 data->valid_rx_ant = cfg->valid_rx_ant;
867
868 if (!data->valid_tx_ant || !data->valid_rx_ant) {
869 IWL_ERR_DEV(dev, "invalid antennas (0x%x, 0x%x)\n",
870 data->valid_tx_ant, data->valid_rx_ant);
871 goto err_free;
872 }
873
874 iwl_init_sbands(dev, cfg, data, eeprom, eeprom_size);
875
876 return data;
877 err_free:
878 kfree(data);
879 return NULL;
880}
881EXPORT_SYMBOL_GPL(iwl_parse_eeprom_data);
882
883/* helper functions */
884int iwl_eeprom_check_version(struct iwl_eeprom_data *data,
885 struct iwl_trans *trans)
886{
887 if (data->eeprom_version >= trans->cfg->eeprom_ver ||
888 data->calib_version >= trans->cfg->eeprom_calib_ver) {
889 IWL_INFO(trans, "device EEPROM VER=0x%x, CALIB=0x%x\n",
890 data->eeprom_version, data->calib_version);
891 return 0;
892 }
893
894 IWL_ERR(trans,
895 "Unsupported (too old) EEPROM VER=0x%x < 0x%x CALIB=0x%x < 0x%x\n",
896 data->eeprom_version, trans->cfg->eeprom_ver,
897 data->calib_version, trans->cfg->eeprom_calib_ver);
898 return -EINVAL;
899}
900EXPORT_SYMBOL_GPL(iwl_eeprom_check_version);
diff --git a/drivers/net/wireless/iwlwifi/iwl-eeprom-parse.h b/drivers/net/wireless/iwlwifi/iwl-eeprom-parse.h
new file mode 100644
index 000000000000..9c07c670a1ce
--- /dev/null
+++ b/drivers/net/wireless/iwlwifi/iwl-eeprom-parse.h
@@ -0,0 +1,138 @@
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 - 2012 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 LICENSE.GPL.
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 - 2012 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#ifndef __iwl_eeprom_parse_h__
63#define __iwl_eeprom_parse_h__
64
65#include <linux/types.h>
66#include <linux/if_ether.h>
67#include "iwl-trans.h"
68
69/* SKU Capabilities (actual values from EEPROM definition) */
70#define EEPROM_SKU_CAP_BAND_24GHZ (1 << 4)
71#define EEPROM_SKU_CAP_BAND_52GHZ (1 << 5)
72#define EEPROM_SKU_CAP_11N_ENABLE (1 << 6)
73#define EEPROM_SKU_CAP_AMT_ENABLE (1 << 7)
74#define EEPROM_SKU_CAP_IPAN_ENABLE (1 << 8)
75
76/* radio config bits (actual values from EEPROM definition) */
77#define EEPROM_RF_CFG_TYPE_MSK(x) (x & 0x3) /* bits 0-1 */
78#define EEPROM_RF_CFG_STEP_MSK(x) ((x >> 2) & 0x3) /* bits 2-3 */
79#define EEPROM_RF_CFG_DASH_MSK(x) ((x >> 4) & 0x3) /* bits 4-5 */
80#define EEPROM_RF_CFG_PNUM_MSK(x) ((x >> 6) & 0x3) /* bits 6-7 */
81#define EEPROM_RF_CFG_TX_ANT_MSK(x) ((x >> 8) & 0xF) /* bits 8-11 */
82#define EEPROM_RF_CFG_RX_ANT_MSK(x) ((x >> 12) & 0xF) /* bits 12-15 */
83
84struct iwl_eeprom_data {
85 int n_hw_addrs;
86 u8 hw_addr[ETH_ALEN];
87
88 u16 radio_config;
89
90 u8 calib_version;
91 __le16 calib_voltage;
92
93 __le16 raw_temperature;
94 __le16 kelvin_temperature;
95 __le16 kelvin_voltage;
96 __le16 xtal_calib[2];
97
98 u16 sku;
99 u16 radio_cfg;
100 u16 eeprom_version;
101 s8 max_tx_pwr_half_dbm;
102
103 u8 valid_tx_ant, valid_rx_ant;
104
105 struct ieee80211_supported_band bands[IEEE80211_NUM_BANDS];
106 struct ieee80211_channel channels[];
107};
108
109/**
110 * iwl_parse_eeprom_data - parse EEPROM data and return values
111 *
112 * @dev: device pointer we're parsing for, for debug only
113 * @cfg: device configuration for parsing and overrides
114 * @eeprom: the EEPROM data
115 * @eeprom_size: length of the EEPROM data
116 *
117 * This function parses all EEPROM values we need and then
118 * returns a (newly allocated) struct containing all the
119 * relevant values for driver use. The struct must be freed
120 * later with iwl_free_eeprom_data().
121 */
122struct iwl_eeprom_data *
123iwl_parse_eeprom_data(struct device *dev, const struct iwl_cfg *cfg,
124 const u8 *eeprom, size_t eeprom_size);
125
126/**
127 * iwl_free_eeprom_data - free EEPROM data
128 * @data: the data to free
129 */
130static inline void iwl_free_eeprom_data(struct iwl_eeprom_data *data)
131{
132 kfree(data);
133}
134
135int iwl_eeprom_check_version(struct iwl_eeprom_data *data,
136 struct iwl_trans *trans);
137
138#endif /* __iwl_eeprom_parse_h__ */
diff --git a/drivers/net/wireless/iwlwifi/iwl-eeprom-read.c b/drivers/net/wireless/iwlwifi/iwl-eeprom-read.c
new file mode 100644
index 000000000000..27c7da3c6ed1
--- /dev/null
+++ b/drivers/net/wireless/iwlwifi/iwl-eeprom-read.c
@@ -0,0 +1,463 @@
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 - 2012 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 LICENSE.GPL.
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 - 2012 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
66#include "iwl-debug.h"
67#include "iwl-eeprom-read.h"
68#include "iwl-io.h"
69#include "iwl-prph.h"
70#include "iwl-csr.h"
71
72/*
73 * EEPROM access time values:
74 *
75 * Driver initiates EEPROM read by writing byte address << 1 to CSR_EEPROM_REG.
76 * Driver then polls CSR_EEPROM_REG for CSR_EEPROM_REG_READ_VALID_MSK (0x1).
77 * When polling, wait 10 uSec between polling loops, up to a maximum 5000 uSec.
78 * Driver reads 16-bit value from bits 31-16 of CSR_EEPROM_REG.
79 */
80#define IWL_EEPROM_ACCESS_TIMEOUT 5000 /* uSec */
81
82#define IWL_EEPROM_SEM_TIMEOUT 10 /* microseconds */
83#define IWL_EEPROM_SEM_RETRY_LIMIT 1000 /* number of attempts (not time) */
84
85
86/*
87 * The device's EEPROM semaphore prevents conflicts between driver and uCode
88 * when accessing the EEPROM; each access is a series of pulses to/from the
89 * EEPROM chip, not a single event, so even reads could conflict if they
90 * weren't arbitrated by the semaphore.
91 */
92
93#define EEPROM_SEM_TIMEOUT 10 /* milliseconds */
94#define EEPROM_SEM_RETRY_LIMIT 1000 /* number of attempts (not time) */
95
96static int iwl_eeprom_acquire_semaphore(struct iwl_trans *trans)
97{
98 u16 count;
99 int ret;
100
101 for (count = 0; count < EEPROM_SEM_RETRY_LIMIT; count++) {
102 /* Request semaphore */
103 iwl_set_bit(trans, CSR_HW_IF_CONFIG_REG,
104 CSR_HW_IF_CONFIG_REG_BIT_EEPROM_OWN_SEM);
105
106 /* See if we got it */
107 ret = iwl_poll_bit(trans, CSR_HW_IF_CONFIG_REG,
108 CSR_HW_IF_CONFIG_REG_BIT_EEPROM_OWN_SEM,
109 CSR_HW_IF_CONFIG_REG_BIT_EEPROM_OWN_SEM,
110 EEPROM_SEM_TIMEOUT);
111 if (ret >= 0) {
112 IWL_DEBUG_EEPROM(trans->dev,
113 "Acquired semaphore after %d tries.\n",
114 count+1);
115 return ret;
116 }
117 }
118
119 return ret;
120}
121
122static void iwl_eeprom_release_semaphore(struct iwl_trans *trans)
123{
124 iwl_clear_bit(trans, CSR_HW_IF_CONFIG_REG,
125 CSR_HW_IF_CONFIG_REG_BIT_EEPROM_OWN_SEM);
126}
127
128static int iwl_eeprom_verify_signature(struct iwl_trans *trans, bool nvm_is_otp)
129{
130 u32 gp = iwl_read32(trans, CSR_EEPROM_GP) & CSR_EEPROM_GP_VALID_MSK;
131
132 IWL_DEBUG_EEPROM(trans->dev, "EEPROM signature=0x%08x\n", gp);
133
134 switch (gp) {
135 case CSR_EEPROM_GP_BAD_SIG_EEP_GOOD_SIG_OTP:
136 if (!nvm_is_otp) {
137 IWL_ERR(trans, "EEPROM with bad signature: 0x%08x\n",
138 gp);
139 return -ENOENT;
140 }
141 return 0;
142 case CSR_EEPROM_GP_GOOD_SIG_EEP_LESS_THAN_4K:
143 case CSR_EEPROM_GP_GOOD_SIG_EEP_MORE_THAN_4K:
144 if (nvm_is_otp) {
145 IWL_ERR(trans, "OTP with bad signature: 0x%08x\n", gp);
146 return -ENOENT;
147 }
148 return 0;
149 case CSR_EEPROM_GP_BAD_SIGNATURE_BOTH_EEP_AND_OTP:
150 default:
151 IWL_ERR(trans,
152 "bad EEPROM/OTP signature, type=%s, EEPROM_GP=0x%08x\n",
153 nvm_is_otp ? "OTP" : "EEPROM", gp);
154 return -ENOENT;
155 }
156}
157
158/******************************************************************************
159 *
160 * OTP related functions
161 *
162******************************************************************************/
163
164static void iwl_set_otp_access_absolute(struct iwl_trans *trans)
165{
166 iwl_read32(trans, CSR_OTP_GP_REG);
167
168 iwl_clear_bit(trans, CSR_OTP_GP_REG,
169 CSR_OTP_GP_REG_OTP_ACCESS_MODE);
170}
171
172static int iwl_nvm_is_otp(struct iwl_trans *trans)
173{
174 u32 otpgp;
175
176 /* OTP only valid for CP/PP and after */
177 switch (trans->hw_rev & CSR_HW_REV_TYPE_MSK) {
178 case CSR_HW_REV_TYPE_NONE:
179 IWL_ERR(trans, "Unknown hardware type\n");
180 return -EIO;
181 case CSR_HW_REV_TYPE_5300:
182 case CSR_HW_REV_TYPE_5350:
183 case CSR_HW_REV_TYPE_5100:
184 case CSR_HW_REV_TYPE_5150:
185 return 0;
186 default:
187 otpgp = iwl_read32(trans, CSR_OTP_GP_REG);
188 if (otpgp & CSR_OTP_GP_REG_DEVICE_SELECT)
189 return 1;
190 return 0;
191 }
192}
193
194static int iwl_init_otp_access(struct iwl_trans *trans)
195{
196 int ret;
197
198 /* Enable 40MHz radio clock */
199 iwl_write32(trans, CSR_GP_CNTRL,
200 iwl_read32(trans, CSR_GP_CNTRL) |
201 CSR_GP_CNTRL_REG_FLAG_INIT_DONE);
202
203 /* wait for clock to be ready */
204 ret = iwl_poll_bit(trans, CSR_GP_CNTRL,
205 CSR_GP_CNTRL_REG_FLAG_MAC_CLOCK_READY,
206 CSR_GP_CNTRL_REG_FLAG_MAC_CLOCK_READY,
207 25000);
208 if (ret < 0) {
209 IWL_ERR(trans, "Time out access OTP\n");
210 } else {
211 iwl_set_bits_prph(trans, APMG_PS_CTRL_REG,
212 APMG_PS_CTRL_VAL_RESET_REQ);
213 udelay(5);
214 iwl_clear_bits_prph(trans, APMG_PS_CTRL_REG,
215 APMG_PS_CTRL_VAL_RESET_REQ);
216
217 /*
218 * CSR auto clock gate disable bit -
219 * this is only applicable for HW with OTP shadow RAM
220 */
221 if (trans->cfg->base_params->shadow_ram_support)
222 iwl_set_bit(trans, CSR_DBG_LINK_PWR_MGMT_REG,
223 CSR_RESET_LINK_PWR_MGMT_DISABLED);
224 }
225 return ret;
226}
227
228static int iwl_read_otp_word(struct iwl_trans *trans, u16 addr,
229 __le16 *eeprom_data)
230{
231 int ret = 0;
232 u32 r;
233 u32 otpgp;
234
235 iwl_write32(trans, CSR_EEPROM_REG,
236 CSR_EEPROM_REG_MSK_ADDR & (addr << 1));
237 ret = iwl_poll_bit(trans, CSR_EEPROM_REG,
238 CSR_EEPROM_REG_READ_VALID_MSK,
239 CSR_EEPROM_REG_READ_VALID_MSK,
240 IWL_EEPROM_ACCESS_TIMEOUT);
241 if (ret < 0) {
242 IWL_ERR(trans, "Time out reading OTP[%d]\n", addr);
243 return ret;
244 }
245 r = iwl_read32(trans, CSR_EEPROM_REG);
246 /* check for ECC errors: */
247 otpgp = iwl_read32(trans, CSR_OTP_GP_REG);
248 if (otpgp & CSR_OTP_GP_REG_ECC_UNCORR_STATUS_MSK) {
249 /* stop in this case */
250 /* set the uncorrectable OTP ECC bit for acknowledgement */
251 iwl_set_bit(trans, CSR_OTP_GP_REG,
252 CSR_OTP_GP_REG_ECC_UNCORR_STATUS_MSK);
253 IWL_ERR(trans, "Uncorrectable OTP ECC error, abort OTP read\n");
254 return -EINVAL;
255 }
256 if (otpgp & CSR_OTP_GP_REG_ECC_CORR_STATUS_MSK) {
257 /* continue in this case */
258 /* set the correctable OTP ECC bit for acknowledgement */
259 iwl_set_bit(trans, CSR_OTP_GP_REG,
260 CSR_OTP_GP_REG_ECC_CORR_STATUS_MSK);
261 IWL_ERR(trans, "Correctable OTP ECC error, continue read\n");
262 }
263 *eeprom_data = cpu_to_le16(r >> 16);
264 return 0;
265}
266
267/*
268 * iwl_is_otp_empty: check for empty OTP
269 */
270static bool iwl_is_otp_empty(struct iwl_trans *trans)
271{
272 u16 next_link_addr = 0;
273 __le16 link_value;
274 bool is_empty = false;
275
276 /* locate the beginning of OTP link list */
277 if (!iwl_read_otp_word(trans, next_link_addr, &link_value)) {
278 if (!link_value) {
279 IWL_ERR(trans, "OTP is empty\n");
280 is_empty = true;
281 }
282 } else {
283 IWL_ERR(trans, "Unable to read first block of OTP list.\n");
284 is_empty = true;
285 }
286
287 return is_empty;
288}
289
290
291/*
292 * iwl_find_otp_image: find EEPROM image in OTP
293 * finding the OTP block that contains the EEPROM image.
294 * the last valid block on the link list (the block _before_ the last block)
295 * is the block we should read and used to configure the device.
296 * If all the available OTP blocks are full, the last block will be the block
297 * we should read and used to configure the device.
298 * only perform this operation if shadow RAM is disabled
299 */
300static int iwl_find_otp_image(struct iwl_trans *trans,
301 u16 *validblockaddr)
302{
303 u16 next_link_addr = 0, valid_addr;
304 __le16 link_value = 0;
305 int usedblocks = 0;
306
307 /* set addressing mode to absolute to traverse the link list */
308 iwl_set_otp_access_absolute(trans);
309
310 /* checking for empty OTP or error */
311 if (iwl_is_otp_empty(trans))
312 return -EINVAL;
313
314 /*
315 * start traverse link list
316 * until reach the max number of OTP blocks
317 * different devices have different number of OTP blocks
318 */
319 do {
320 /* save current valid block address
321 * check for more block on the link list
322 */
323 valid_addr = next_link_addr;
324 next_link_addr = le16_to_cpu(link_value) * sizeof(u16);
325 IWL_DEBUG_EEPROM(trans->dev, "OTP blocks %d addr 0x%x\n",
326 usedblocks, next_link_addr);
327 if (iwl_read_otp_word(trans, next_link_addr, &link_value))
328 return -EINVAL;
329 if (!link_value) {
330 /*
331 * reach the end of link list, return success and
332 * set address point to the starting address
333 * of the image
334 */
335 *validblockaddr = valid_addr;
336 /* skip first 2 bytes (link list pointer) */
337 *validblockaddr += 2;
338 return 0;
339 }
340 /* more in the link list, continue */
341 usedblocks++;
342 } while (usedblocks <= trans->cfg->base_params->max_ll_items);
343
344 /* OTP has no valid blocks */
345 IWL_DEBUG_EEPROM(trans->dev, "OTP has no valid blocks\n");
346 return -EINVAL;
347}
348
349/**
350 * iwl_read_eeprom - read EEPROM contents
351 *
352 * Load the EEPROM contents from adapter and return it
353 * and its size.
354 *
355 * NOTE: This routine uses the non-debug IO access functions.
356 */
357int iwl_read_eeprom(struct iwl_trans *trans, u8 **eeprom, size_t *eeprom_size)
358{
359 __le16 *e;
360 u32 gp = iwl_read32(trans, CSR_EEPROM_GP);
361 int sz;
362 int ret;
363 u16 addr;
364 u16 validblockaddr = 0;
365 u16 cache_addr = 0;
366 int nvm_is_otp;
367
368 if (!eeprom || !eeprom_size)
369 return -EINVAL;
370
371 nvm_is_otp = iwl_nvm_is_otp(trans);
372 if (nvm_is_otp < 0)
373 return nvm_is_otp;
374
375 sz = trans->cfg->base_params->eeprom_size;
376 IWL_DEBUG_EEPROM(trans->dev, "NVM size = %d\n", sz);
377
378 e = kmalloc(sz, GFP_KERNEL);
379 if (!e)
380 return -ENOMEM;
381
382 ret = iwl_eeprom_verify_signature(trans, nvm_is_otp);
383 if (ret < 0) {
384 IWL_ERR(trans, "EEPROM not found, EEPROM_GP=0x%08x\n", gp);
385 goto err_free;
386 }
387
388 /* Make sure driver (instead of uCode) is allowed to read EEPROM */
389 ret = iwl_eeprom_acquire_semaphore(trans);
390 if (ret < 0) {
391 IWL_ERR(trans, "Failed to acquire EEPROM semaphore.\n");
392 goto err_free;
393 }
394
395 if (nvm_is_otp) {
396 ret = iwl_init_otp_access(trans);
397 if (ret) {
398 IWL_ERR(trans, "Failed to initialize OTP access.\n");
399 goto err_unlock;
400 }
401
402 iwl_write32(trans, CSR_EEPROM_GP,
403 iwl_read32(trans, CSR_EEPROM_GP) &
404 ~CSR_EEPROM_GP_IF_OWNER_MSK);
405
406 iwl_set_bit(trans, CSR_OTP_GP_REG,
407 CSR_OTP_GP_REG_ECC_CORR_STATUS_MSK |
408 CSR_OTP_GP_REG_ECC_UNCORR_STATUS_MSK);
409 /* traversing the linked list if no shadow ram supported */
410 if (!trans->cfg->base_params->shadow_ram_support) {
411 ret = iwl_find_otp_image(trans, &validblockaddr);
412 if (ret)
413 goto err_unlock;
414 }
415 for (addr = validblockaddr; addr < validblockaddr + sz;
416 addr += sizeof(u16)) {
417 __le16 eeprom_data;
418
419 ret = iwl_read_otp_word(trans, addr, &eeprom_data);
420 if (ret)
421 goto err_unlock;
422 e[cache_addr / 2] = eeprom_data;
423 cache_addr += sizeof(u16);
424 }
425 } else {
426 /* eeprom is an array of 16bit values */
427 for (addr = 0; addr < sz; addr += sizeof(u16)) {
428 u32 r;
429
430 iwl_write32(trans, CSR_EEPROM_REG,
431 CSR_EEPROM_REG_MSK_ADDR & (addr << 1));
432
433 ret = iwl_poll_bit(trans, CSR_EEPROM_REG,
434 CSR_EEPROM_REG_READ_VALID_MSK,
435 CSR_EEPROM_REG_READ_VALID_MSK,
436 IWL_EEPROM_ACCESS_TIMEOUT);
437 if (ret < 0) {
438 IWL_ERR(trans,
439 "Time out reading EEPROM[%d]\n", addr);
440 goto err_unlock;
441 }
442 r = iwl_read32(trans, CSR_EEPROM_REG);
443 e[addr / 2] = cpu_to_le16(r >> 16);
444 }
445 }
446
447 IWL_DEBUG_EEPROM(trans->dev, "NVM Type: %s\n",
448 nvm_is_otp ? "OTP" : "EEPROM");
449
450 iwl_eeprom_release_semaphore(trans);
451
452 *eeprom_size = sz;
453 *eeprom = (u8 *)e;
454 return 0;
455
456 err_unlock:
457 iwl_eeprom_release_semaphore(trans);
458 err_free:
459 kfree(e);
460
461 return ret;
462}
463EXPORT_SYMBOL_GPL(iwl_read_eeprom);
diff --git a/drivers/net/wireless/iwlwifi/iwl-eeprom-read.h b/drivers/net/wireless/iwlwifi/iwl-eeprom-read.h
new file mode 100644
index 000000000000..1337c9d36fee
--- /dev/null
+++ b/drivers/net/wireless/iwlwifi/iwl-eeprom-read.h
@@ -0,0 +1,70 @@
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 - 2012 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 LICENSE.GPL.
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 - 2012 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
63#ifndef __iwl_eeprom_h__
64#define __iwl_eeprom_h__
65
66#include "iwl-trans.h"
67
68int iwl_read_eeprom(struct iwl_trans *trans, u8 **eeprom, size_t *eeprom_size);
69
70#endif /* __iwl_eeprom_h__ */
diff --git a/drivers/net/wireless/iwlwifi/pcie/1000.c b/drivers/net/wireless/iwlwifi/pcie/1000.c
index 174cf5e38962..0269ea6a5c35 100644
--- a/drivers/net/wireless/iwlwifi/pcie/1000.c
+++ b/drivers/net/wireless/iwlwifi/pcie/1000.c
@@ -74,6 +74,18 @@ static const struct iwl_ht_params iwl1000_ht_params = {
74 .ht40_bands = BIT(IEEE80211_BAND_2GHZ), 74 .ht40_bands = BIT(IEEE80211_BAND_2GHZ),
75}; 75};
76 76
77static const struct iwl_eeprom_params iwl1000_eeprom_params = {
78 .regulatory_bands = {
79 EEPROM_REG_BAND_1_CHANNELS,
80 EEPROM_REG_BAND_2_CHANNELS,
81 EEPROM_REG_BAND_3_CHANNELS,
82 EEPROM_REG_BAND_4_CHANNELS,
83 EEPROM_REG_BAND_5_CHANNELS,
84 EEPROM_REG_BAND_24_HT40_CHANNELS,
85 EEPROM_REGULATORY_BAND_NO_HT40,
86 }
87};
88
77#define IWL_DEVICE_1000 \ 89#define IWL_DEVICE_1000 \
78 .fw_name_pre = IWL1000_FW_PRE, \ 90 .fw_name_pre = IWL1000_FW_PRE, \
79 .ucode_api_max = IWL1000_UCODE_API_MAX, \ 91 .ucode_api_max = IWL1000_UCODE_API_MAX, \
@@ -85,6 +97,7 @@ static const struct iwl_ht_params iwl1000_ht_params = {
85 .eeprom_ver = EEPROM_1000_EEPROM_VERSION, \ 97 .eeprom_ver = EEPROM_1000_EEPROM_VERSION, \
86 .eeprom_calib_ver = EEPROM_1000_TX_POWER_VERSION, \ 98 .eeprom_calib_ver = EEPROM_1000_TX_POWER_VERSION, \
87 .base_params = &iwl1000_base_params, \ 99 .base_params = &iwl1000_base_params, \
100 .eeprom_params = &iwl1000_eeprom_params, \
88 .led_mode = IWL_LED_BLINK 101 .led_mode = IWL_LED_BLINK
89 102
90const struct iwl_cfg iwl1000_bgn_cfg = { 103const struct iwl_cfg iwl1000_bgn_cfg = {
@@ -109,6 +122,7 @@ const struct iwl_cfg iwl1000_bg_cfg = {
109 .eeprom_ver = EEPROM_1000_EEPROM_VERSION, \ 122 .eeprom_ver = EEPROM_1000_EEPROM_VERSION, \
110 .eeprom_calib_ver = EEPROM_1000_TX_POWER_VERSION, \ 123 .eeprom_calib_ver = EEPROM_1000_TX_POWER_VERSION, \
111 .base_params = &iwl1000_base_params, \ 124 .base_params = &iwl1000_base_params, \
125 .eeprom_params = &iwl1000_eeprom_params, \
112 .led_mode = IWL_LED_RF_STATE, \ 126 .led_mode = IWL_LED_RF_STATE, \
113 .rx_with_siso_diversity = true 127 .rx_with_siso_diversity = true
114 128
diff --git a/drivers/net/wireless/iwlwifi/pcie/2000.c b/drivers/net/wireless/iwlwifi/pcie/2000.c
index 8d4d7295aa46..fd4e78f56fa6 100644
--- a/drivers/net/wireless/iwlwifi/pcie/2000.c
+++ b/drivers/net/wireless/iwlwifi/pcie/2000.c
@@ -117,6 +117,19 @@ static const struct iwl_bt_params iwl2030_bt_params = {
117 .bt_session_2 = true, 117 .bt_session_2 = true,
118}; 118};
119 119
120static const struct iwl_eeprom_params iwl20x0_eeprom_params = {
121 .regulatory_bands = {
122 EEPROM_REG_BAND_1_CHANNELS,
123 EEPROM_REG_BAND_2_CHANNELS,
124 EEPROM_REG_BAND_3_CHANNELS,
125 EEPROM_REG_BAND_4_CHANNELS,
126 EEPROM_REG_BAND_5_CHANNELS,
127 EEPROM_6000_REG_BAND_24_HT40_CHANNELS,
128 EEPROM_REGULATORY_BAND_NO_HT40,
129 },
130 .enhanced_txpower = true,
131};
132
120#define IWL_DEVICE_2000 \ 133#define IWL_DEVICE_2000 \
121 .fw_name_pre = IWL2000_FW_PRE, \ 134 .fw_name_pre = IWL2000_FW_PRE, \
122 .ucode_api_max = IWL2000_UCODE_API_MAX, \ 135 .ucode_api_max = IWL2000_UCODE_API_MAX, \
@@ -128,6 +141,7 @@ static const struct iwl_bt_params iwl2030_bt_params = {
128 .eeprom_ver = EEPROM_2000_EEPROM_VERSION, \ 141 .eeprom_ver = EEPROM_2000_EEPROM_VERSION, \
129 .eeprom_calib_ver = EEPROM_2000_TX_POWER_VERSION, \ 142 .eeprom_calib_ver = EEPROM_2000_TX_POWER_VERSION, \
130 .base_params = &iwl2000_base_params, \ 143 .base_params = &iwl2000_base_params, \
144 .eeprom_params = &iwl20x0_eeprom_params, \
131 .need_temp_offset_calib = true, \ 145 .need_temp_offset_calib = true, \
132 .temp_offset_v2 = true, \ 146 .temp_offset_v2 = true, \
133 .led_mode = IWL_LED_RF_STATE 147 .led_mode = IWL_LED_RF_STATE
@@ -156,6 +170,7 @@ const struct iwl_cfg iwl2000_2bgn_d_cfg = {
156 .eeprom_calib_ver = EEPROM_2000_TX_POWER_VERSION, \ 170 .eeprom_calib_ver = EEPROM_2000_TX_POWER_VERSION, \
157 .base_params = &iwl2030_base_params, \ 171 .base_params = &iwl2030_base_params, \
158 .bt_params = &iwl2030_bt_params, \ 172 .bt_params = &iwl2030_bt_params, \
173 .eeprom_params = &iwl20x0_eeprom_params, \
159 .need_temp_offset_calib = true, \ 174 .need_temp_offset_calib = true, \
160 .temp_offset_v2 = true, \ 175 .temp_offset_v2 = true, \
161 .led_mode = IWL_LED_RF_STATE, \ 176 .led_mode = IWL_LED_RF_STATE, \
@@ -178,6 +193,7 @@ const struct iwl_cfg iwl2030_2bgn_cfg = {
178 .eeprom_ver = EEPROM_2000_EEPROM_VERSION, \ 193 .eeprom_ver = EEPROM_2000_EEPROM_VERSION, \
179 .eeprom_calib_ver = EEPROM_2000_TX_POWER_VERSION, \ 194 .eeprom_calib_ver = EEPROM_2000_TX_POWER_VERSION, \
180 .base_params = &iwl2000_base_params, \ 195 .base_params = &iwl2000_base_params, \
196 .eeprom_params = &iwl20x0_eeprom_params, \
181 .need_temp_offset_calib = true, \ 197 .need_temp_offset_calib = true, \
182 .temp_offset_v2 = true, \ 198 .temp_offset_v2 = true, \
183 .led_mode = IWL_LED_RF_STATE, \ 199 .led_mode = IWL_LED_RF_STATE, \
@@ -208,6 +224,7 @@ const struct iwl_cfg iwl105_bgn_d_cfg = {
208 .eeprom_calib_ver = EEPROM_2000_TX_POWER_VERSION, \ 224 .eeprom_calib_ver = EEPROM_2000_TX_POWER_VERSION, \
209 .base_params = &iwl2030_base_params, \ 225 .base_params = &iwl2030_base_params, \
210 .bt_params = &iwl2030_bt_params, \ 226 .bt_params = &iwl2030_bt_params, \
227 .eeprom_params = &iwl20x0_eeprom_params, \
211 .need_temp_offset_calib = true, \ 228 .need_temp_offset_calib = true, \
212 .temp_offset_v2 = true, \ 229 .temp_offset_v2 = true, \
213 .led_mode = IWL_LED_RF_STATE, \ 230 .led_mode = IWL_LED_RF_STATE, \
diff --git a/drivers/net/wireless/iwlwifi/pcie/5000.c b/drivers/net/wireless/iwlwifi/pcie/5000.c
index 75d90a9c184a..745a358ab8e8 100644
--- a/drivers/net/wireless/iwlwifi/pcie/5000.c
+++ b/drivers/net/wireless/iwlwifi/pcie/5000.c
@@ -72,6 +72,18 @@ static const struct iwl_ht_params iwl5000_ht_params = {
72 .ht40_bands = BIT(IEEE80211_BAND_2GHZ) | BIT(IEEE80211_BAND_5GHZ), 72 .ht40_bands = BIT(IEEE80211_BAND_2GHZ) | BIT(IEEE80211_BAND_5GHZ),
73}; 73};
74 74
75static const struct iwl_eeprom_params iwl5000_eeprom_params = {
76 .regulatory_bands = {
77 EEPROM_REG_BAND_1_CHANNELS,
78 EEPROM_REG_BAND_2_CHANNELS,
79 EEPROM_REG_BAND_3_CHANNELS,
80 EEPROM_REG_BAND_4_CHANNELS,
81 EEPROM_REG_BAND_5_CHANNELS,
82 EEPROM_REG_BAND_24_HT40_CHANNELS,
83 EEPROM_REG_BAND_52_HT40_CHANNELS
84 },
85};
86
75#define IWL_DEVICE_5000 \ 87#define IWL_DEVICE_5000 \
76 .fw_name_pre = IWL5000_FW_PRE, \ 88 .fw_name_pre = IWL5000_FW_PRE, \
77 .ucode_api_max = IWL5000_UCODE_API_MAX, \ 89 .ucode_api_max = IWL5000_UCODE_API_MAX, \
@@ -83,6 +95,7 @@ static const struct iwl_ht_params iwl5000_ht_params = {
83 .eeprom_ver = EEPROM_5000_EEPROM_VERSION, \ 95 .eeprom_ver = EEPROM_5000_EEPROM_VERSION, \
84 .eeprom_calib_ver = EEPROM_5000_TX_POWER_VERSION, \ 96 .eeprom_calib_ver = EEPROM_5000_TX_POWER_VERSION, \
85 .base_params = &iwl5000_base_params, \ 97 .base_params = &iwl5000_base_params, \
98 .eeprom_params = &iwl5000_eeprom_params, \
86 .led_mode = IWL_LED_BLINK 99 .led_mode = IWL_LED_BLINK
87 100
88const struct iwl_cfg iwl5300_agn_cfg = { 101const struct iwl_cfg iwl5300_agn_cfg = {
@@ -129,6 +142,7 @@ const struct iwl_cfg iwl5350_agn_cfg = {
129 .eeprom_ver = EEPROM_5050_EEPROM_VERSION, 142 .eeprom_ver = EEPROM_5050_EEPROM_VERSION,
130 .eeprom_calib_ver = EEPROM_5050_TX_POWER_VERSION, 143 .eeprom_calib_ver = EEPROM_5050_TX_POWER_VERSION,
131 .base_params = &iwl5000_base_params, 144 .base_params = &iwl5000_base_params,
145 .eeprom_params = &iwl5000_eeprom_params,
132 .ht_params = &iwl5000_ht_params, 146 .ht_params = &iwl5000_ht_params,
133 .led_mode = IWL_LED_BLINK, 147 .led_mode = IWL_LED_BLINK,
134 .internal_wimax_coex = true, 148 .internal_wimax_coex = true,
@@ -145,6 +159,7 @@ const struct iwl_cfg iwl5350_agn_cfg = {
145 .eeprom_ver = EEPROM_5050_EEPROM_VERSION, \ 159 .eeprom_ver = EEPROM_5050_EEPROM_VERSION, \
146 .eeprom_calib_ver = EEPROM_5050_TX_POWER_VERSION, \ 160 .eeprom_calib_ver = EEPROM_5050_TX_POWER_VERSION, \
147 .base_params = &iwl5000_base_params, \ 161 .base_params = &iwl5000_base_params, \
162 .eeprom_params = &iwl5000_eeprom_params, \
148 .no_xtal_calib = true, \ 163 .no_xtal_calib = true, \
149 .led_mode = IWL_LED_BLINK, \ 164 .led_mode = IWL_LED_BLINK, \
150 .internal_wimax_coex = true 165 .internal_wimax_coex = true
diff --git a/drivers/net/wireless/iwlwifi/pcie/6000.c b/drivers/net/wireless/iwlwifi/pcie/6000.c
index 7b9c02cc67e5..8dd8a6fe61e8 100644
--- a/drivers/net/wireless/iwlwifi/pcie/6000.c
+++ b/drivers/net/wireless/iwlwifi/pcie/6000.c
@@ -136,6 +136,19 @@ static const struct iwl_bt_params iwl6000_bt_params = {
136 .bt_sco_disable = true, 136 .bt_sco_disable = true,
137}; 137};
138 138
139static const struct iwl_eeprom_params iwl6000_eeprom_params = {
140 .regulatory_bands = {
141 EEPROM_REG_BAND_1_CHANNELS,
142 EEPROM_REG_BAND_2_CHANNELS,
143 EEPROM_REG_BAND_3_CHANNELS,
144 EEPROM_REG_BAND_4_CHANNELS,
145 EEPROM_REG_BAND_5_CHANNELS,
146 EEPROM_6000_REG_BAND_24_HT40_CHANNELS,
147 EEPROM_REG_BAND_52_HT40_CHANNELS
148 },
149 .enhanced_txpower = true,
150};
151
139#define IWL_DEVICE_6005 \ 152#define IWL_DEVICE_6005 \
140 .fw_name_pre = IWL6005_FW_PRE, \ 153 .fw_name_pre = IWL6005_FW_PRE, \
141 .ucode_api_max = IWL6000G2_UCODE_API_MAX, \ 154 .ucode_api_max = IWL6000G2_UCODE_API_MAX, \
@@ -147,6 +160,7 @@ static const struct iwl_bt_params iwl6000_bt_params = {
147 .eeprom_ver = EEPROM_6005_EEPROM_VERSION, \ 160 .eeprom_ver = EEPROM_6005_EEPROM_VERSION, \
148 .eeprom_calib_ver = EEPROM_6005_TX_POWER_VERSION, \ 161 .eeprom_calib_ver = EEPROM_6005_TX_POWER_VERSION, \
149 .base_params = &iwl6000_g2_base_params, \ 162 .base_params = &iwl6000_g2_base_params, \
163 .eeprom_params = &iwl6000_eeprom_params, \
150 .need_temp_offset_calib = true, \ 164 .need_temp_offset_calib = true, \
151 .led_mode = IWL_LED_RF_STATE 165 .led_mode = IWL_LED_RF_STATE
152 166
@@ -202,6 +216,7 @@ const struct iwl_cfg iwl6005_2agn_mow2_cfg = {
202 .eeprom_calib_ver = EEPROM_6030_TX_POWER_VERSION, \ 216 .eeprom_calib_ver = EEPROM_6030_TX_POWER_VERSION, \
203 .base_params = &iwl6000_g2_base_params, \ 217 .base_params = &iwl6000_g2_base_params, \
204 .bt_params = &iwl6000_bt_params, \ 218 .bt_params = &iwl6000_bt_params, \
219 .eeprom_params = &iwl6000_eeprom_params, \
205 .need_temp_offset_calib = true, \ 220 .need_temp_offset_calib = true, \
206 .led_mode = IWL_LED_RF_STATE, \ 221 .led_mode = IWL_LED_RF_STATE, \
207 .adv_pm = true \ 222 .adv_pm = true \
@@ -274,6 +289,7 @@ const struct iwl_cfg iwl130_bg_cfg = {
274 .eeprom_ver = EEPROM_6000_EEPROM_VERSION, \ 289 .eeprom_ver = EEPROM_6000_EEPROM_VERSION, \
275 .eeprom_calib_ver = EEPROM_6000_TX_POWER_VERSION, \ 290 .eeprom_calib_ver = EEPROM_6000_TX_POWER_VERSION, \
276 .base_params = &iwl6000_base_params, \ 291 .base_params = &iwl6000_base_params, \
292 .eeprom_params = &iwl6000_eeprom_params, \
277 .led_mode = IWL_LED_BLINK 293 .led_mode = IWL_LED_BLINK
278 294
279const struct iwl_cfg iwl6000i_2agn_cfg = { 295const struct iwl_cfg iwl6000i_2agn_cfg = {
@@ -304,6 +320,7 @@ const struct iwl_cfg iwl6000i_2bg_cfg = {
304 .eeprom_ver = EEPROM_6050_EEPROM_VERSION, \ 320 .eeprom_ver = EEPROM_6050_EEPROM_VERSION, \
305 .eeprom_calib_ver = EEPROM_6050_TX_POWER_VERSION, \ 321 .eeprom_calib_ver = EEPROM_6050_TX_POWER_VERSION, \
306 .base_params = &iwl6050_base_params, \ 322 .base_params = &iwl6050_base_params, \
323 .eeprom_params = &iwl6000_eeprom_params, \
307 .led_mode = IWL_LED_BLINK, \ 324 .led_mode = IWL_LED_BLINK, \
308 .internal_wimax_coex = true 325 .internal_wimax_coex = true
309 326
@@ -328,6 +345,7 @@ const struct iwl_cfg iwl6050_2abg_cfg = {
328 .eeprom_ver = EEPROM_6150_EEPROM_VERSION, \ 345 .eeprom_ver = EEPROM_6150_EEPROM_VERSION, \
329 .eeprom_calib_ver = EEPROM_6150_TX_POWER_VERSION, \ 346 .eeprom_calib_ver = EEPROM_6150_TX_POWER_VERSION, \
330 .base_params = &iwl6050_base_params, \ 347 .base_params = &iwl6050_base_params, \
348 .eeprom_params = &iwl6000_eeprom_params, \
331 .led_mode = IWL_LED_BLINK, \ 349 .led_mode = IWL_LED_BLINK, \
332 .internal_wimax_coex = true 350 .internal_wimax_coex = true
333 351
@@ -354,6 +372,7 @@ const struct iwl_cfg iwl6000_3agn_cfg = {
354 .eeprom_ver = EEPROM_6000_EEPROM_VERSION, 372 .eeprom_ver = EEPROM_6000_EEPROM_VERSION,
355 .eeprom_calib_ver = EEPROM_6000_TX_POWER_VERSION, 373 .eeprom_calib_ver = EEPROM_6000_TX_POWER_VERSION,
356 .base_params = &iwl6000_base_params, 374 .base_params = &iwl6000_base_params,
375 .eeprom_params = &iwl6000_eeprom_params,
357 .ht_params = &iwl6000_ht_params, 376 .ht_params = &iwl6000_ht_params,
358 .led_mode = IWL_LED_BLINK, 377 .led_mode = IWL_LED_BLINK,
359}; 378};
generated by cgit v1.2.2 (git 2.25.0) at 2025-03-30 00:45:19 -0400