summaryrefslogtreecommitdiff
path: root/drivers/net/wireless/iwlegacy/iwl-eeprom.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/net/wireless/iwlegacy/iwl-eeprom.c')
-rw-r--r--drivers/net/wireless/iwlegacy/iwl-eeprom.c158
1 files changed, 79 insertions, 79 deletions
diff --git a/drivers/net/wireless/iwlegacy/iwl-eeprom.c b/drivers/net/wireless/iwlegacy/iwl-eeprom.c
index 1075f1d7f016..5edec73a505e 100644
--- a/drivers/net/wireless/iwlegacy/iwl-eeprom.c
+++ b/drivers/net/wireless/iwlegacy/iwl-eeprom.c
@@ -87,7 +87,7 @@
* is contained in the eeprom map itself.
*
* During init, we copy the eeprom information and channel map
- * information into priv->channel_info_24/52 and priv->channel_map_24/52
+ * information into il->channel_info_24/52 and il->channel_map_24/52
*
* channel_map_24/52 provides the index in the channel_info array for a
* given channel. We have to have two separate maps as there is channel
@@ -142,18 +142,18 @@ static const u8 iwlegacy_eeprom_band_7[] = { /* 5.2 ht40 channel */
*
******************************************************************************/
-static int il_eeprom_verify_signature(struct il_priv *priv)
+static int il_eeprom_verify_signature(struct il_priv *il)
{
- u32 gp = il_read32(priv, CSR_EEPROM_GP) & CSR_EEPROM_GP_VALID_MSK;
+ u32 gp = il_read32(il, CSR_EEPROM_GP) & CSR_EEPROM_GP_VALID_MSK;
int ret = 0;
- IL_DEBUG_EEPROM(priv, "EEPROM signature=0x%08x\n", gp);
+ IL_DEBUG_EEPROM(il, "EEPROM signature=0x%08x\n", gp);
switch (gp) {
case CSR_EEPROM_GP_GOOD_SIG_EEP_LESS_THAN_4K:
case CSR_EEPROM_GP_GOOD_SIG_EEP_MORE_THAN_4K:
break;
default:
- IL_ERR(priv, "bad EEPROM signature,"
+ IL_ERR(il, "bad EEPROM signature,"
"EEPROM_GP=0x%08x\n", gp);
ret = -ENOENT;
break;
@@ -162,59 +162,59 @@ static int il_eeprom_verify_signature(struct il_priv *priv)
}
const u8
-*il_eeprom_query_addr(const struct il_priv *priv, size_t offset)
+*il_eeprom_query_addr(const struct il_priv *il, size_t offset)
{
- BUG_ON(offset >= priv->cfg->base_params->eeprom_size);
- return &priv->eeprom[offset];
+ BUG_ON(offset >= il->cfg->base_params->eeprom_size);
+ return &il->eeprom[offset];
}
EXPORT_SYMBOL(il_eeprom_query_addr);
-u16 il_eeprom_query16(const struct il_priv *priv, size_t offset)
+u16 il_eeprom_query16(const struct il_priv *il, size_t offset)
{
- if (!priv->eeprom)
+ if (!il->eeprom)
return 0;
- return (u16)priv->eeprom[offset] | ((u16)priv->eeprom[offset + 1] << 8);
+ return (u16)il->eeprom[offset] | ((u16)il->eeprom[offset + 1] << 8);
}
EXPORT_SYMBOL(il_eeprom_query16);
/**
* il_eeprom_init - read EEPROM contents
*
- * Load the EEPROM contents from adapter into priv->eeprom
+ * Load the EEPROM contents from adapter into il->eeprom
*
* NOTE: This routine uses the non-debug IO access functions.
*/
-int il_eeprom_init(struct il_priv *priv)
+int il_eeprom_init(struct il_priv *il)
{
__le16 *e;
- u32 gp = il_read32(priv, CSR_EEPROM_GP);
+ u32 gp = il_read32(il, CSR_EEPROM_GP);
int sz;
int ret;
u16 addr;
/* allocate eeprom */
- sz = priv->cfg->base_params->eeprom_size;
- IL_DEBUG_EEPROM(priv, "NVM size = %d\n", sz);
- priv->eeprom = kzalloc(sz, GFP_KERNEL);
- if (!priv->eeprom) {
+ sz = il->cfg->base_params->eeprom_size;
+ IL_DEBUG_EEPROM(il, "NVM size = %d\n", sz);
+ il->eeprom = kzalloc(sz, GFP_KERNEL);
+ if (!il->eeprom) {
ret = -ENOMEM;
goto alloc_err;
}
- e = (__le16 *)priv->eeprom;
+ e = (__le16 *)il->eeprom;
- priv->cfg->ops->lib->apm_ops.init(priv);
+ il->cfg->ops->lib->apm_ops.init(il);
- ret = il_eeprom_verify_signature(priv);
+ ret = il_eeprom_verify_signature(il);
if (ret < 0) {
- IL_ERR(priv, "EEPROM not found, EEPROM_GP=0x%08x\n", gp);
+ IL_ERR(il, "EEPROM not found, EEPROM_GP=0x%08x\n", gp);
ret = -ENOENT;
goto err;
}
/* Make sure driver (instead of uCode) is allowed to read EEPROM */
- ret = priv->cfg->ops->lib->eeprom_ops.acquire_semaphore(priv);
+ ret = il->cfg->ops->lib->eeprom_ops.acquire_semaphore(il);
if (ret < 0) {
- IL_ERR(priv, "Failed to acquire EEPROM semaphore.\n");
+ IL_ERR(il, "Failed to acquire EEPROM semaphore.\n");
ret = -ENOENT;
goto err;
}
@@ -223,95 +223,95 @@ int il_eeprom_init(struct il_priv *priv)
for (addr = 0; addr < sz; addr += sizeof(u16)) {
u32 r;
- _il_write32(priv, CSR_EEPROM_REG,
+ _il_write32(il, CSR_EEPROM_REG,
CSR_EEPROM_REG_MSK_ADDR & (addr << 1));
- ret = il_poll_bit(priv, CSR_EEPROM_REG,
+ ret = il_poll_bit(il, CSR_EEPROM_REG,
CSR_EEPROM_REG_READ_VALID_MSK,
CSR_EEPROM_REG_READ_VALID_MSK,
IL_EEPROM_ACCESS_TIMEOUT);
if (ret < 0) {
- IL_ERR(priv, "Time out reading EEPROM[%d]\n",
+ IL_ERR(il, "Time out reading EEPROM[%d]\n",
addr);
goto done;
}
- r = _il_read_direct32(priv, CSR_EEPROM_REG);
+ r = _il_read_direct32(il, CSR_EEPROM_REG);
e[addr / 2] = cpu_to_le16(r >> 16);
}
- IL_DEBUG_EEPROM(priv, "NVM Type: %s, version: 0x%x\n",
+ IL_DEBUG_EEPROM(il, "NVM Type: %s, version: 0x%x\n",
"EEPROM",
- il_eeprom_query16(priv, EEPROM_VERSION));
+ il_eeprom_query16(il, EEPROM_VERSION));
ret = 0;
done:
- priv->cfg->ops->lib->eeprom_ops.release_semaphore(priv);
+ il->cfg->ops->lib->eeprom_ops.release_semaphore(il);
err:
if (ret)
- il_eeprom_free(priv);
+ il_eeprom_free(il);
/* Reset chip to save power until we load uCode during "up". */
- il_apm_stop(priv);
+ il_apm_stop(il);
alloc_err:
return ret;
}
EXPORT_SYMBOL(il_eeprom_init);
-void il_eeprom_free(struct il_priv *priv)
+void il_eeprom_free(struct il_priv *il)
{
- kfree(priv->eeprom);
- priv->eeprom = NULL;
+ kfree(il->eeprom);
+ il->eeprom = NULL;
}
EXPORT_SYMBOL(il_eeprom_free);
-static void il_init_band_reference(const struct il_priv *priv,
+static void il_init_band_reference(const struct il_priv *il,
int eep_band, int *eeprom_ch_count,
const struct il_eeprom_channel **eeprom_ch_info,
const u8 **eeprom_ch_index)
{
- u32 offset = priv->cfg->ops->lib->
+ u32 offset = il->cfg->ops->lib->
eeprom_ops.regulatory_bands[eep_band - 1];
switch (eep_band) {
case 1: /* 2.4GHz band */
*eeprom_ch_count = ARRAY_SIZE(iwlegacy_eeprom_band_1);
*eeprom_ch_info = (struct il_eeprom_channel *)
- il_eeprom_query_addr(priv, offset);
+ il_eeprom_query_addr(il, offset);
*eeprom_ch_index = iwlegacy_eeprom_band_1;
break;
case 2: /* 4.9GHz band */
*eeprom_ch_count = ARRAY_SIZE(iwlegacy_eeprom_band_2);
*eeprom_ch_info = (struct il_eeprom_channel *)
- il_eeprom_query_addr(priv, offset);
+ il_eeprom_query_addr(il, offset);
*eeprom_ch_index = iwlegacy_eeprom_band_2;
break;
case 3: /* 5.2GHz band */
*eeprom_ch_count = ARRAY_SIZE(iwlegacy_eeprom_band_3);
*eeprom_ch_info = (struct il_eeprom_channel *)
- il_eeprom_query_addr(priv, offset);
+ il_eeprom_query_addr(il, offset);
*eeprom_ch_index = iwlegacy_eeprom_band_3;
break;
case 4: /* 5.5GHz band */
*eeprom_ch_count = ARRAY_SIZE(iwlegacy_eeprom_band_4);
*eeprom_ch_info = (struct il_eeprom_channel *)
- il_eeprom_query_addr(priv, offset);
+ il_eeprom_query_addr(il, offset);
*eeprom_ch_index = iwlegacy_eeprom_band_4;
break;
case 5: /* 5.7GHz band */
*eeprom_ch_count = ARRAY_SIZE(iwlegacy_eeprom_band_5);
*eeprom_ch_info = (struct il_eeprom_channel *)
- il_eeprom_query_addr(priv, offset);
+ il_eeprom_query_addr(il, offset);
*eeprom_ch_index = iwlegacy_eeprom_band_5;
break;
case 6: /* 2.4GHz ht40 channels */
*eeprom_ch_count = ARRAY_SIZE(iwlegacy_eeprom_band_6);
*eeprom_ch_info = (struct il_eeprom_channel *)
- il_eeprom_query_addr(priv, offset);
+ il_eeprom_query_addr(il, offset);
*eeprom_ch_index = iwlegacy_eeprom_band_6;
break;
case 7: /* 5 GHz ht40 channels */
*eeprom_ch_count = ARRAY_SIZE(iwlegacy_eeprom_band_7);
*eeprom_ch_info = (struct il_eeprom_channel *)
- il_eeprom_query_addr(priv, offset);
+ il_eeprom_query_addr(il, offset);
*eeprom_ch_index = iwlegacy_eeprom_band_7;
break;
default:
@@ -322,11 +322,11 @@ static void il_init_band_reference(const struct il_priv *priv,
#define CHECK_AND_PRINT(x) ((eeprom_ch->flags & EEPROM_CHANNEL_##x) \
? # x " " : "")
/**
- * il_mod_ht40_chan_info - Copy ht40 channel info into driver's priv.
+ * il_mod_ht40_chan_info - Copy ht40 channel info into driver's il.
*
* Does not set up a command, or touch hardware.
*/
-static int il_mod_ht40_chan_info(struct il_priv *priv,
+static int il_mod_ht40_chan_info(struct il_priv *il,
enum ieee80211_band band, u16 channel,
const struct il_eeprom_channel *eeprom_ch,
u8 clear_ht40_extension_channel)
@@ -334,12 +334,12 @@ static int il_mod_ht40_chan_info(struct il_priv *priv,
struct il_channel_info *ch_info;
ch_info = (struct il_channel_info *)
- il_get_channel_info(priv, band, channel);
+ il_get_channel_info(il, band, channel);
if (!il_is_channel_valid(ch_info))
return -1;
- IL_DEBUG_EEPROM(priv, "HT40 Ch. %d [%sGHz] %s%s%s%s%s(0x%02x %ddBm):"
+ IL_DEBUG_EEPROM(il, "HT40 Ch. %d [%sGHz] %s%s%s%s%s(0x%02x %ddBm):"
" Ad-Hoc %ssupported\n",
ch_info->channel,
il_is_channel_a_band(ch_info) ?
@@ -371,7 +371,7 @@ static int il_mod_ht40_chan_info(struct il_priv *priv,
/**
* il_init_channel_map - Set up driver's info for all possible channels
*/
-int il_init_channel_map(struct il_priv *priv)
+int il_init_channel_map(struct il_priv *il)
{
int eeprom_ch_count = 0;
const u8 *eeprom_ch_index = NULL;
@@ -379,39 +379,39 @@ int il_init_channel_map(struct il_priv *priv)
int band, ch;
struct il_channel_info *ch_info;
- if (priv->channel_count) {
- IL_DEBUG_EEPROM(priv, "Channel map already initialized.\n");
+ if (il->channel_count) {
+ IL_DEBUG_EEPROM(il, "Channel map already initialized.\n");
return 0;
}
- IL_DEBUG_EEPROM(priv, "Initializing regulatory info from EEPROM\n");
+ IL_DEBUG_EEPROM(il, "Initializing regulatory info from EEPROM\n");
- priv->channel_count =
+ il->channel_count =
ARRAY_SIZE(iwlegacy_eeprom_band_1) +
ARRAY_SIZE(iwlegacy_eeprom_band_2) +
ARRAY_SIZE(iwlegacy_eeprom_band_3) +
ARRAY_SIZE(iwlegacy_eeprom_band_4) +
ARRAY_SIZE(iwlegacy_eeprom_band_5);
- IL_DEBUG_EEPROM(priv, "Parsing data for %d channels.\n",
- priv->channel_count);
+ IL_DEBUG_EEPROM(il, "Parsing data for %d channels.\n",
+ il->channel_count);
- priv->channel_info = kzalloc(sizeof(struct il_channel_info) *
- priv->channel_count, GFP_KERNEL);
- if (!priv->channel_info) {
- IL_ERR(priv, "Could not allocate channel_info\n");
- priv->channel_count = 0;
+ il->channel_info = kzalloc(sizeof(struct il_channel_info) *
+ il->channel_count, GFP_KERNEL);
+ if (!il->channel_info) {
+ IL_ERR(il, "Could not allocate channel_info\n");
+ il->channel_count = 0;
return -ENOMEM;
}
- ch_info = priv->channel_info;
+ ch_info = il->channel_info;
/* Loop through the 5 EEPROM bands adding them in order to the
* channel map we maintain (that contains additional information than
* what just in the EEPROM) */
for (band = 1; band <= 5; band++) {
- il_init_band_reference(priv, band, &eeprom_ch_count,
+ il_init_band_reference(il, band, &eeprom_ch_count,
&eeprom_ch_info, &eeprom_ch_index);
/* Loop through each band adding each of the channels */
@@ -433,7 +433,7 @@ int il_init_channel_map(struct il_priv *priv)
IEEE80211_CHAN_NO_HT40;
if (!(il_is_channel_valid(ch_info))) {
- IL_DEBUG_EEPROM(priv,
+ IL_DEBUG_EEPROM(il,
"Ch. %d Flags %x [%sGHz] - "
"No traffic\n",
ch_info->channel,
@@ -450,7 +450,7 @@ int il_init_channel_map(struct il_priv *priv)
ch_info->scan_power = eeprom_ch_info[ch].max_power_avg;
ch_info->min_power = 0;
- IL_DEBUG_EEPROM(priv, "Ch. %d [%sGHz] "
+ IL_DEBUG_EEPROM(il, "Ch. %d [%sGHz] "
"%s%s%s%s%s%s(0x%02x %ddBm):"
" Ad-Hoc %ssupported\n",
ch_info->channel,
@@ -475,9 +475,9 @@ int il_init_channel_map(struct il_priv *priv)
}
/* Check if we do have HT40 channels */
- if (priv->cfg->ops->lib->eeprom_ops.regulatory_bands[5] ==
+ if (il->cfg->ops->lib->eeprom_ops.regulatory_bands[5] ==
EEPROM_REGULATORY_BAND_NO_HT40 &&
- priv->cfg->ops->lib->eeprom_ops.regulatory_bands[6] ==
+ il->cfg->ops->lib->eeprom_ops.regulatory_bands[6] ==
EEPROM_REGULATORY_BAND_NO_HT40)
return 0;
@@ -485,7 +485,7 @@ int il_init_channel_map(struct il_priv *priv)
for (band = 6; band <= 7; band++) {
enum ieee80211_band ieeeband;
- il_init_band_reference(priv, band, &eeprom_ch_count,
+ il_init_band_reference(il, band, &eeprom_ch_count,
&eeprom_ch_info, &eeprom_ch_index);
/* EEPROM band 6 is 2.4, band 7 is 5 GHz */
@@ -495,13 +495,13 @@ int il_init_channel_map(struct il_priv *priv)
/* Loop through each band adding each of the channels */
for (ch = 0; ch < eeprom_ch_count; ch++) {
/* Set up driver's info for lower half */
- il_mod_ht40_chan_info(priv, ieeeband,
+ il_mod_ht40_chan_info(il, ieeeband,
eeprom_ch_index[ch],
&eeprom_ch_info[ch],
IEEE80211_CHAN_NO_HT40PLUS);
/* Set up driver's info for upper half */
- il_mod_ht40_chan_info(priv, ieeeband,
+ il_mod_ht40_chan_info(il, ieeeband,
eeprom_ch_index[ch] + 4,
&eeprom_ch_info[ch],
IEEE80211_CHAN_NO_HT40MINUS);
@@ -515,34 +515,34 @@ EXPORT_SYMBOL(il_init_channel_map);
/*
* il_free_channel_map - undo allocations in il_init_channel_map
*/
-void il_free_channel_map(struct il_priv *priv)
+void il_free_channel_map(struct il_priv *il)
{
- kfree(priv->channel_info);
- priv->channel_count = 0;
+ kfree(il->channel_info);
+ il->channel_count = 0;
}
EXPORT_SYMBOL(il_free_channel_map);
/**
- * il_get_channel_info - Find driver's private channel info
+ * il_get_channel_info - Find driver's ilate channel info
*
* Based on band and channel number.
*/
const struct
-il_channel_info *il_get_channel_info(const struct il_priv *priv,
+il_channel_info *il_get_channel_info(const struct il_priv *il,
enum ieee80211_band band, u16 channel)
{
int i;
switch (band) {
case IEEE80211_BAND_5GHZ:
- for (i = 14; i < priv->channel_count; i++) {
- if (priv->channel_info[i].channel == channel)
- return &priv->channel_info[i];
+ for (i = 14; i < il->channel_count; i++) {
+ if (il->channel_info[i].channel == channel)
+ return &il->channel_info[i];
}
break;
case IEEE80211_BAND_2GHZ:
if (channel >= 1 && channel <= 14)
- return &priv->channel_info[channel - 1];
+ return &il->channel_info[channel - 1];
break;
default:
BUG();
generated by cgit v1.2.3 (git 2.39.0) at 2025-01-23 01:35:41 +0300