iwlegacy: rename iwl to il

iwl_legacy prefix result in long function names, what cause that we
have frequent line split and not readable code. Also iwl_foo symbols
are duplicated in iwlwifi driver, what is annoying when editing
kernel tree with cscope.

Signed-off-by: Stanislaw Gruszka <sgruszka@redhat.com>

1 files changed, 78 insertions, 78 deletions

diff --git a/drivers/net/wireless/iwlegacy/iwl-eeprom.c b/drivers/net/wireless/iwlegacy/iwl-eeprom.c
index 5bf3f49b74ab..1075f1d7f016 100644
--- a/drivers/net/wireless/iwlegacy/iwl-eeprom.c
+++ b/drivers/net/wireless/iwlegacy/iwl-eeprom.c
@@ -81,7 +81,7 @@
  * EEPROM contents to the specific channel number supported for each
  * band.
  *
- * For example, iwl_priv->eeprom.band_3_channels[4] from the band_3
+ * For example, il_priv->eeprom.band_3_channels[4] from the band_3
  * definition below maps to physical channel 42 in the 5.2GHz spectrum.
  * The specific geography and calibration information for that channel
  * is contained in the eeprom map itself.
@@ -142,18 +142,18 @@ static const u8 iwlegacy_eeprom_band_7[] = {       /* 5.2 ht40 channel */
  *
 ******************************************************************************/
 
-static int iwl_legacy_eeprom_verify_signature(struct iwl_priv *priv)
+static int il_eeprom_verify_signature(struct il_priv *priv)
 {
-	u32 gp = iwl_read32(priv, CSR_EEPROM_GP) & CSR_EEPROM_GP_VALID_MSK;
+	u32 gp = il_read32(priv, CSR_EEPROM_GP) & CSR_EEPROM_GP_VALID_MSK;
 	int ret = 0;
 
-	IWL_DEBUG_EEPROM(priv, "EEPROM signature=0x%08x\n", gp);
+	IL_DEBUG_EEPROM(priv, "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:
-		IWL_ERR(priv, "bad EEPROM signature,"
+		IL_ERR(priv, "bad EEPROM signature,"
 			"EEPROM_GP=0x%08x\n", gp);
 		ret = -ENOENT;
 		break;
@@ -162,39 +162,39 @@ static int iwl_legacy_eeprom_verify_signature(struct iwl_priv *priv)
 }
 
 const u8
-*iwl_legacy_eeprom_query_addr(const struct iwl_priv *priv, size_t offset)
+*il_eeprom_query_addr(const struct il_priv *priv, size_t offset)
 {
 	BUG_ON(offset >= priv->cfg->base_params->eeprom_size);
 	return &priv->eeprom[offset];
 }
-EXPORT_SYMBOL(iwl_legacy_eeprom_query_addr);
+EXPORT_SYMBOL(il_eeprom_query_addr);
 
-u16 iwl_legacy_eeprom_query16(const struct iwl_priv *priv, size_t offset)
+u16 il_eeprom_query16(const struct il_priv *priv, size_t offset)
 {
 	if (!priv->eeprom)
 		return 0;
 	return (u16)priv->eeprom[offset] | ((u16)priv->eeprom[offset + 1] << 8);
 }
-EXPORT_SYMBOL(iwl_legacy_eeprom_query16);
+EXPORT_SYMBOL(il_eeprom_query16);
 
 /**
- * iwl_legacy_eeprom_init - read EEPROM contents
+ * il_eeprom_init - read EEPROM contents
  *
  * Load the EEPROM contents from adapter into priv->eeprom
  *
  * NOTE:  This routine uses the non-debug IO access functions.
  */
-int iwl_legacy_eeprom_init(struct iwl_priv *priv)
+int il_eeprom_init(struct il_priv *priv)
 {
 	__le16 *e;
-	u32 gp = iwl_read32(priv, CSR_EEPROM_GP);
+	u32 gp = il_read32(priv, CSR_EEPROM_GP);
 	int sz;
 	int ret;
 	u16 addr;
 
 	/* allocate eeprom */
 	sz = priv->cfg->base_params->eeprom_size;
-	IWL_DEBUG_EEPROM(priv, "NVM size = %d\n", sz);
+	IL_DEBUG_EEPROM(priv, "NVM size = %d\n", sz);
 	priv->eeprom = kzalloc(sz, GFP_KERNEL);
 	if (!priv->eeprom) {
 		ret = -ENOMEM;
@@ -204,9 +204,9 @@ int iwl_legacy_eeprom_init(struct iwl_priv *priv)
 
 	priv->cfg->ops->lib->apm_ops.init(priv);
 
-	ret = iwl_legacy_eeprom_verify_signature(priv);
+	ret = il_eeprom_verify_signature(priv);
 	if (ret < 0) {
-		IWL_ERR(priv, "EEPROM not found, EEPROM_GP=0x%08x\n", gp);
+		IL_ERR(priv, "EEPROM not found, EEPROM_GP=0x%08x\n", gp);
 		ret = -ENOENT;
 		goto err;
 	}
@@ -214,7 +214,7 @@ int iwl_legacy_eeprom_init(struct iwl_priv *priv)
 	/* Make sure driver (instead of uCode) is allowed to read EEPROM */
 	ret = priv->cfg->ops->lib->eeprom_ops.acquire_semaphore(priv);
 	if (ret < 0) {
-		IWL_ERR(priv, "Failed to acquire EEPROM semaphore.\n");
+		IL_ERR(priv, "Failed to acquire EEPROM semaphore.\n");
 		ret = -ENOENT;
 		goto err;
 	}
@@ -223,25 +223,25 @@ int iwl_legacy_eeprom_init(struct iwl_priv *priv)
 	for (addr = 0; addr < sz; addr += sizeof(u16)) {
 		u32 r;
 
-		_iwl_legacy_write32(priv, CSR_EEPROM_REG,
+		_il_write32(priv, CSR_EEPROM_REG,
 			     CSR_EEPROM_REG_MSK_ADDR & (addr << 1));
 
-		ret = iwl_poll_bit(priv, CSR_EEPROM_REG,
+		ret = il_poll_bit(priv, CSR_EEPROM_REG,
 					  CSR_EEPROM_REG_READ_VALID_MSK,
 					  CSR_EEPROM_REG_READ_VALID_MSK,
-					  IWL_EEPROM_ACCESS_TIMEOUT);
+					  IL_EEPROM_ACCESS_TIMEOUT);
 		if (ret < 0) {
-			IWL_ERR(priv, "Time out reading EEPROM[%d]\n",
+			IL_ERR(priv, "Time out reading EEPROM[%d]\n",
 							addr);
 			goto done;
 		}
-		r = _iwl_legacy_read_direct32(priv, CSR_EEPROM_REG);
+		r = _il_read_direct32(priv, CSR_EEPROM_REG);
 		e[addr / 2] = cpu_to_le16(r >> 16);
 	}
 
-	IWL_DEBUG_EEPROM(priv, "NVM Type: %s, version: 0x%x\n",
+	IL_DEBUG_EEPROM(priv, "NVM Type: %s, version: 0x%x\n",
 		       "EEPROM",
-		       iwl_legacy_eeprom_query16(priv, EEPROM_VERSION));
+		       il_eeprom_query16(priv, EEPROM_VERSION));
 
 	ret = 0;
 done:
@@ -249,24 +249,24 @@ done:
 
 err:
 	if (ret)
-		iwl_legacy_eeprom_free(priv);
+		il_eeprom_free(priv);
 	/* Reset chip to save power until we load uCode during "up". */
-	iwl_legacy_apm_stop(priv);
+	il_apm_stop(priv);
 alloc_err:
 	return ret;
 }
-EXPORT_SYMBOL(iwl_legacy_eeprom_init);
+EXPORT_SYMBOL(il_eeprom_init);
 
-void iwl_legacy_eeprom_free(struct iwl_priv *priv)
+void il_eeprom_free(struct il_priv *priv)
 {
 	kfree(priv->eeprom);
 	priv->eeprom = NULL;
 }
-EXPORT_SYMBOL(iwl_legacy_eeprom_free);
+EXPORT_SYMBOL(il_eeprom_free);
 
-static void iwl_legacy_init_band_reference(const struct iwl_priv *priv,
+static void il_init_band_reference(const struct il_priv *priv,
 			int eep_band, int *eeprom_ch_count,
-			const struct iwl_eeprom_channel **eeprom_ch_info,
+			const struct il_eeprom_channel **eeprom_ch_info,
 			const u8 **eeprom_ch_index)
 {
 	u32 offset = priv->cfg->ops->lib->
@@ -274,44 +274,44 @@ static void iwl_legacy_init_band_reference(const struct iwl_priv *priv,
 	switch (eep_band) {
 	case 1:		/* 2.4GHz band */
 		*eeprom_ch_count = ARRAY_SIZE(iwlegacy_eeprom_band_1);
-		*eeprom_ch_info = (struct iwl_eeprom_channel *)
-				iwl_legacy_eeprom_query_addr(priv, offset);
+		*eeprom_ch_info = (struct il_eeprom_channel *)
+				il_eeprom_query_addr(priv, 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 iwl_eeprom_channel *)
-				iwl_legacy_eeprom_query_addr(priv, offset);
+		*eeprom_ch_info = (struct il_eeprom_channel *)
+				il_eeprom_query_addr(priv, 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 iwl_eeprom_channel *)
-				iwl_legacy_eeprom_query_addr(priv, offset);
+		*eeprom_ch_info = (struct il_eeprom_channel *)
+				il_eeprom_query_addr(priv, 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 iwl_eeprom_channel *)
-				iwl_legacy_eeprom_query_addr(priv, offset);
+		*eeprom_ch_info = (struct il_eeprom_channel *)
+				il_eeprom_query_addr(priv, 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 iwl_eeprom_channel *)
-				iwl_legacy_eeprom_query_addr(priv, offset);
+		*eeprom_ch_info = (struct il_eeprom_channel *)
+				il_eeprom_query_addr(priv, 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 iwl_eeprom_channel *)
-				iwl_legacy_eeprom_query_addr(priv, offset);
+		*eeprom_ch_info = (struct il_eeprom_channel *)
+				il_eeprom_query_addr(priv, 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 iwl_eeprom_channel *)
-				iwl_legacy_eeprom_query_addr(priv, offset);
+		*eeprom_ch_info = (struct il_eeprom_channel *)
+				il_eeprom_query_addr(priv, offset);
 		*eeprom_ch_index = iwlegacy_eeprom_band_7;
 		break;
 	default:
@@ -322,27 +322,27 @@ static void iwl_legacy_init_band_reference(const struct iwl_priv *priv,
 #define CHECK_AND_PRINT(x) ((eeprom_ch->flags & EEPROM_CHANNEL_##x) \
 			    ? # x " " : "")
 /**
- * iwl_legacy_mod_ht40_chan_info - Copy ht40 channel info into driver's priv.
+ * il_mod_ht40_chan_info - Copy ht40 channel info into driver's priv.
  *
  * Does not set up a command, or touch hardware.
  */
-static int iwl_legacy_mod_ht40_chan_info(struct iwl_priv *priv,
+static int il_mod_ht40_chan_info(struct il_priv *priv,
 			      enum ieee80211_band band, u16 channel,
-			      const struct iwl_eeprom_channel *eeprom_ch,
+			      const struct il_eeprom_channel *eeprom_ch,
 			      u8 clear_ht40_extension_channel)
 {
-	struct iwl_channel_info *ch_info;
+	struct il_channel_info *ch_info;
 
-	ch_info = (struct iwl_channel_info *)
-			iwl_legacy_get_channel_info(priv, band, channel);
+	ch_info = (struct il_channel_info *)
+			il_get_channel_info(priv, band, channel);
 
-	if (!iwl_legacy_is_channel_valid(ch_info))
+	if (!il_is_channel_valid(ch_info))
 		return -1;
 
-	IWL_DEBUG_EEPROM(priv, "HT40 Ch. %d [%sGHz] %s%s%s%s%s(0x%02x %ddBm):"
+	IL_DEBUG_EEPROM(priv, "HT40 Ch. %d [%sGHz] %s%s%s%s%s(0x%02x %ddBm):"
 			" Ad-Hoc %ssupported\n",
 			ch_info->channel,
-			iwl_legacy_is_channel_a_band(ch_info) ?
+			il_is_channel_a_band(ch_info) ?
 			"5.2" : "2.4",
 			CHECK_AND_PRINT(IBSS),
 			CHECK_AND_PRINT(ACTIVE),
@@ -369,22 +369,22 @@ static int iwl_legacy_mod_ht40_chan_info(struct iwl_priv *priv,
 			    ? # x " " : "")
 
 /**
- * iwl_legacy_init_channel_map - Set up driver's info for all possible channels
+ * il_init_channel_map - Set up driver's info for all possible channels
  */
-int iwl_legacy_init_channel_map(struct iwl_priv *priv)
+int il_init_channel_map(struct il_priv *priv)
 {
 	int eeprom_ch_count = 0;
 	const u8 *eeprom_ch_index = NULL;
-	const struct iwl_eeprom_channel *eeprom_ch_info = NULL;
+	const struct il_eeprom_channel *eeprom_ch_info = NULL;
 	int band, ch;
-	struct iwl_channel_info *ch_info;
+	struct il_channel_info *ch_info;
 
 	if (priv->channel_count) {
-		IWL_DEBUG_EEPROM(priv, "Channel map already initialized.\n");
+		IL_DEBUG_EEPROM(priv, "Channel map already initialized.\n");
 		return 0;
 	}
 
-	IWL_DEBUG_EEPROM(priv, "Initializing regulatory info from EEPROM\n");
+	IL_DEBUG_EEPROM(priv, "Initializing regulatory info from EEPROM\n");
 
 	priv->channel_count =
 	    ARRAY_SIZE(iwlegacy_eeprom_band_1) +
@@ -393,13 +393,13 @@ int iwl_legacy_init_channel_map(struct iwl_priv *priv)
 	    ARRAY_SIZE(iwlegacy_eeprom_band_4) +
 	    ARRAY_SIZE(iwlegacy_eeprom_band_5);
 
-	IWL_DEBUG_EEPROM(priv, "Parsing data for %d channels.\n",
+	IL_DEBUG_EEPROM(priv, "Parsing data for %d channels.\n",
 			priv->channel_count);
 
-	priv->channel_info = kzalloc(sizeof(struct iwl_channel_info) *
+	priv->channel_info = kzalloc(sizeof(struct il_channel_info) *
 				     priv->channel_count, GFP_KERNEL);
 	if (!priv->channel_info) {
-		IWL_ERR(priv, "Could not allocate channel_info\n");
+		IL_ERR(priv, "Could not allocate channel_info\n");
 		priv->channel_count = 0;
 		return -ENOMEM;
 	}
@@ -411,7 +411,7 @@ int iwl_legacy_init_channel_map(struct iwl_priv *priv)
 	 * what just in the EEPROM) */
 	for (band = 1; band <= 5; band++) {
 
-		iwl_legacy_init_band_reference(priv, band, &eeprom_ch_count,
+		il_init_band_reference(priv, band, &eeprom_ch_count,
 					&eeprom_ch_info, &eeprom_ch_index);
 
 		/* Loop through each band adding each of the channels */
@@ -432,13 +432,13 @@ int iwl_legacy_init_channel_map(struct iwl_priv *priv)
 			ch_info->ht40_extension_channel =
 					IEEE80211_CHAN_NO_HT40;
 
-			if (!(iwl_legacy_is_channel_valid(ch_info))) {
-				IWL_DEBUG_EEPROM(priv,
+			if (!(il_is_channel_valid(ch_info))) {
+				IL_DEBUG_EEPROM(priv,
 					       "Ch. %d Flags %x [%sGHz] - "
 					       "No traffic\n",
 					       ch_info->channel,
 					       ch_info->flags,
-					       iwl_legacy_is_channel_a_band(ch_info) ?
+					       il_is_channel_a_band(ch_info) ?
 					       "5.2" : "2.4");
 				ch_info++;
 				continue;
@@ -450,11 +450,11 @@ int iwl_legacy_init_channel_map(struct iwl_priv *priv)
 			ch_info->scan_power = eeprom_ch_info[ch].max_power_avg;
 			ch_info->min_power = 0;
 
-			IWL_DEBUG_EEPROM(priv, "Ch. %d [%sGHz] "
+			IL_DEBUG_EEPROM(priv, "Ch. %d [%sGHz] "
 				       "%s%s%s%s%s%s(0x%02x %ddBm):"
 				       " Ad-Hoc %ssupported\n",
 				       ch_info->channel,
-				       iwl_legacy_is_channel_a_band(ch_info) ?
+				       il_is_channel_a_band(ch_info) ?
 				       "5.2" : "2.4",
 				       CHECK_AND_PRINT_I(VALID),
 				       CHECK_AND_PRINT_I(IBSS),
@@ -485,7 +485,7 @@ int iwl_legacy_init_channel_map(struct iwl_priv *priv)
 	for (band = 6; band <= 7; band++) {
 		enum ieee80211_band ieeeband;
 
-		iwl_legacy_init_band_reference(priv, band, &eeprom_ch_count,
+		il_init_band_reference(priv, 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 iwl_legacy_init_channel_map(struct iwl_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 */
-			iwl_legacy_mod_ht40_chan_info(priv, ieeeband,
+			il_mod_ht40_chan_info(priv, ieeeband,
 						eeprom_ch_index[ch],
 						&eeprom_ch_info[ch],
 						IEEE80211_CHAN_NO_HT40PLUS);
 
 			/* Set up driver's info for upper half */
-			iwl_legacy_mod_ht40_chan_info(priv, ieeeband,
+			il_mod_ht40_chan_info(priv, ieeeband,
 						eeprom_ch_index[ch] + 4,
 						&eeprom_ch_info[ch],
 						IEEE80211_CHAN_NO_HT40MINUS);
@@ -510,25 +510,25 @@ int iwl_legacy_init_channel_map(struct iwl_priv *priv)
 
 	return 0;
 }
-EXPORT_SYMBOL(iwl_legacy_init_channel_map);
+EXPORT_SYMBOL(il_init_channel_map);
 
 /*
- * iwl_legacy_free_channel_map - undo allocations in iwl_legacy_init_channel_map
+ * il_free_channel_map - undo allocations in il_init_channel_map
  */
-void iwl_legacy_free_channel_map(struct iwl_priv *priv)
+void il_free_channel_map(struct il_priv *priv)
 {
 	kfree(priv->channel_info);
 	priv->channel_count = 0;
 }
-EXPORT_SYMBOL(iwl_legacy_free_channel_map);
+EXPORT_SYMBOL(il_free_channel_map);
 
 /**
- * iwl_legacy_get_channel_info - Find driver's private channel info
+ * il_get_channel_info - Find driver's private channel info
  *
  * Based on band and channel number.
  */
 const struct
-iwl_channel_info *iwl_legacy_get_channel_info(const struct iwl_priv *priv,
+il_channel_info *il_get_channel_info(const struct il_priv *priv,
 					enum ieee80211_band band, u16 channel)
 {
 	int i;
@@ -550,4 +550,4 @@ iwl_channel_info *iwl_legacy_get_channel_info(const struct iwl_priv *priv,
 
 	return NULL;
 }
-EXPORT_SYMBOL(iwl_legacy_get_channel_info);
+EXPORT_SYMBOL(il_get_channel_info);