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, 221 insertions, 221 deletions

diff --git a/drivers/net/wireless/iwlegacy/iwl-4965-tx.c b/drivers/net/wireless/iwlegacy/iwl-4965-tx.c
index e421fdf..3fdb9d9 100644
--- a/drivers/net/wireless/iwlegacy/iwl-4965-tx.c
+++ b/drivers/net/wireless/iwlegacy/iwl-4965-tx.c
@@ -77,7 +77,7 @@ static const u8 tid_to_ac[] = {
 	IEEE80211_AC_VO
 };
 
-static inline int iwl4965_get_ac_from_tid(u16 tid)
+static inline int il4965_get_ac_from_tid(u16 tid)
 {
 	if (likely(tid < ARRAY_SIZE(tid_to_ac)))
 		return tid_to_ac[tid];
@@ -87,7 +87,7 @@ static inline int iwl4965_get_ac_from_tid(u16 tid)
 }
 
 static inline int
-iwl4965_get_fifo_from_tid(struct iwl_rxon_context *ctx, u16 tid)
+il4965_get_fifo_from_tid(struct il_rxon_context *ctx, u16 tid)
 {
 	if (likely(tid < ARRAY_SIZE(tid_to_ac)))
 		return ctx->ac_to_fifo[tid_to_ac[tid]];
@@ -99,9 +99,9 @@ iwl4965_get_fifo_from_tid(struct iwl_rxon_context *ctx, u16 tid)
 /*
  * handle build REPLY_TX command notification.
  */
-static void iwl4965_tx_cmd_build_basic(struct iwl_priv *priv,
+static void il4965_tx_cmd_build_basic(struct il_priv *priv,
 					struct sk_buff *skb,
-					struct iwl_tx_cmd *tx_cmd,
+					struct il_tx_cmd *tx_cmd,
 					struct ieee80211_tx_info *info,
 					struct ieee80211_hdr *hdr,
 					u8 std_id)
@@ -137,7 +137,7 @@ static void iwl4965_tx_cmd_build_basic(struct iwl_priv *priv,
 		tx_flags |= TX_CMD_FLG_SEQ_CTL_MSK;
 	}
 
-	iwl_legacy_tx_cmd_protection(priv, info, fc, &tx_flags);
+	il_tx_cmd_protection(priv, info, fc, &tx_flags);
 
 	tx_flags &= ~(TX_CMD_FLG_ANT_SEL_MSK);
 	if (ieee80211_is_mgmt(fc)) {
@@ -156,8 +156,8 @@ static void iwl4965_tx_cmd_build_basic(struct iwl_priv *priv,
 
 #define RTS_DFAULT_RETRY_LIMIT		60
 
-static void iwl4965_tx_cmd_build_rate(struct iwl_priv *priv,
-			      struct iwl_tx_cmd *tx_cmd,
+static void il4965_tx_cmd_build_rate(struct il_priv *priv,
+			      struct il_tx_cmd *tx_cmd,
 			      struct ieee80211_tx_info *info,
 			      __le16 fc)
 {
@@ -196,34 +196,34 @@ static void iwl4965_tx_cmd_build_rate(struct iwl_priv *priv,
 	 */
 	rate_idx = info->control.rates[0].idx;
 	if (info->control.rates[0].flags & IEEE80211_TX_RC_MCS ||
-			(rate_idx < 0) || (rate_idx > IWL_RATE_COUNT_LEGACY))
+			(rate_idx < 0) || (rate_idx > IL_RATE_COUNT_LEGACY))
 		rate_idx = rate_lowest_index(&priv->bands[info->band],
 				info->control.sta);
 	/* For 5 GHZ band, remap mac80211 rate indices into driver indices */
 	if (info->band == IEEE80211_BAND_5GHZ)
-		rate_idx += IWL_FIRST_OFDM_RATE;
+		rate_idx += IL_FIRST_OFDM_RATE;
 	/* Get PLCP rate for tx_cmd->rate_n_flags */
 	rate_plcp = iwlegacy_rates[rate_idx].plcp;
 	/* Zero out flags for this packet */
 	rate_flags = 0;
 
 	/* Set CCK flag as needed */
-	if ((rate_idx >= IWL_FIRST_CCK_RATE) && (rate_idx <= IWL_LAST_CCK_RATE))
+	if ((rate_idx >= IL_FIRST_CCK_RATE) && (rate_idx <= IL_LAST_CCK_RATE))
 		rate_flags |= RATE_MCS_CCK_MSK;
 
 	/* Set up antennas */
-	priv->mgmt_tx_ant = iwl4965_toggle_tx_ant(priv, priv->mgmt_tx_ant,
+	priv->mgmt_tx_ant = il4965_toggle_tx_ant(priv, priv->mgmt_tx_ant,
 				      priv->hw_params.valid_tx_ant);
 
-	rate_flags |= iwl4965_ant_idx_to_flags(priv->mgmt_tx_ant);
+	rate_flags |= il4965_ant_idx_to_flags(priv->mgmt_tx_ant);
 
 	/* Set the rate in the TX cmd */
-	tx_cmd->rate_n_flags = iwl4965_hw_set_rate_n_flags(rate_plcp, rate_flags);
+	tx_cmd->rate_n_flags = il4965_hw_set_rate_n_flags(rate_plcp, rate_flags);
 }
 
-static void iwl4965_tx_cmd_build_hwcrypto(struct iwl_priv *priv,
+static void il4965_tx_cmd_build_hwcrypto(struct il_priv *priv,
 				      struct ieee80211_tx_info *info,
-				      struct iwl_tx_cmd *tx_cmd,
+				      struct il_tx_cmd *tx_cmd,
 				      struct sk_buff *skb_frag,
 				      int sta_id)
 {
@@ -235,13 +235,13 @@ static void iwl4965_tx_cmd_build_hwcrypto(struct iwl_priv *priv,
 		memcpy(tx_cmd->key, keyconf->key, keyconf->keylen);
 		if (info->flags & IEEE80211_TX_CTL_AMPDU)
 			tx_cmd->tx_flags |= TX_CMD_FLG_AGG_CCMP_MSK;
-		IWL_DEBUG_TX(priv, "tx_cmd with AES hwcrypto\n");
+		IL_DEBUG_TX(priv, "tx_cmd with AES hwcrypto\n");
 		break;
 
 	case WLAN_CIPHER_SUITE_TKIP:
 		tx_cmd->sec_ctl = TX_CMD_SEC_TKIP;
 		ieee80211_get_tkip_p2k(keyconf, skb_frag, tx_cmd->key);
-		IWL_DEBUG_TX(priv, "tx_cmd with tkip hwcrypto\n");
+		IL_DEBUG_TX(priv, "tx_cmd with tkip hwcrypto\n");
 		break;
 
 	case WLAN_CIPHER_SUITE_WEP104:
@@ -253,12 +253,12 @@ static void iwl4965_tx_cmd_build_hwcrypto(struct iwl_priv *priv,
 
 		memcpy(&tx_cmd->key[3], keyconf->key, keyconf->keylen);
 
-		IWL_DEBUG_TX(priv, "Configuring packet for WEP encryption "
+		IL_DEBUG_TX(priv, "Configuring packet for WEP encryption "
 			     "with key %d\n", keyconf->keyidx);
 		break;
 
 	default:
-		IWL_ERR(priv, "Unknown encode cipher %x\n", keyconf->cipher);
+		IL_ERR(priv, "Unknown encode cipher %x\n", keyconf->cipher);
 		break;
 	}
 }
@@ -266,18 +266,18 @@ static void iwl4965_tx_cmd_build_hwcrypto(struct iwl_priv *priv,
 /*
  * start REPLY_TX command process
  */
-int iwl4965_tx_skb(struct iwl_priv *priv, struct sk_buff *skb)
+int il4965_tx_skb(struct il_priv *priv, struct sk_buff *skb)
 {
 	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
 	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
 	struct ieee80211_sta *sta = info->control.sta;
-	struct iwl_station_priv *sta_priv = NULL;
-	struct iwl_tx_queue *txq;
-	struct iwl_queue *q;
-	struct iwl_device_cmd *out_cmd;
-	struct iwl_cmd_meta *out_meta;
-	struct iwl_tx_cmd *tx_cmd;
-	struct iwl_rxon_context *ctx = &priv->contexts[IWL_RXON_CTX_BSS];
+	struct il_station_priv *sta_priv = NULL;
+	struct il_tx_queue *txq;
+	struct il_queue *q;
+	struct il_device_cmd *out_cmd;
+	struct il_cmd_meta *out_meta;
+	struct il_tx_cmd *tx_cmd;
+	struct il_rxon_context *ctx = &priv->contexts[IL_RXON_CTX_BSS];
 	int txq_id;
 	dma_addr_t phys_addr;
 	dma_addr_t txcmd_phys;
@@ -294,11 +294,11 @@ int iwl4965_tx_skb(struct iwl_priv *priv, struct sk_buff *skb)
 	bool is_agg = false;
 
 	if (info->control.vif)
-		ctx = iwl_legacy_rxon_ctx_from_vif(info->control.vif);
+		ctx = il_rxon_ctx_from_vif(info->control.vif);
 
 	spin_lock_irqsave(&priv->lock, flags);
-	if (iwl_legacy_is_rfkill(priv)) {
-		IWL_DEBUG_DROP(priv, "Dropping - RF KILL\n");
+	if (il_is_rfkill(priv)) {
+		IL_DEBUG_DROP(priv, "Dropping - RF KILL\n");
 		goto drop_unlock;
 	}
 
@@ -306,11 +306,11 @@ int iwl4965_tx_skb(struct iwl_priv *priv, struct sk_buff *skb)
 
 #ifdef CONFIG_IWLWIFI_LEGACY_DEBUG
 	if (ieee80211_is_auth(fc))
-		IWL_DEBUG_TX(priv, "Sending AUTH frame\n");
+		IL_DEBUG_TX(priv, "Sending AUTH frame\n");
 	else if (ieee80211_is_assoc_req(fc))
-		IWL_DEBUG_TX(priv, "Sending ASSOC frame\n");
+		IL_DEBUG_TX(priv, "Sending ASSOC frame\n");
 	else if (ieee80211_is_reassoc_req(fc))
-		IWL_DEBUG_TX(priv, "Sending REASSOC frame\n");
+		IL_DEBUG_TX(priv, "Sending REASSOC frame\n");
 #endif
 
 	hdr_len = ieee80211_hdrlen(fc);
@@ -320,16 +320,16 @@ int iwl4965_tx_skb(struct iwl_priv *priv, struct sk_buff *skb)
 		sta_id = ctx->bcast_sta_id;
 	else {
 		/* Find index into station table for destination station */
-		sta_id = iwl_legacy_sta_id_or_broadcast(priv, ctx, info->control.sta);
+		sta_id = il_sta_id_or_broadcast(priv, ctx, info->control.sta);
 
-		if (sta_id == IWL_INVALID_STATION) {
-			IWL_DEBUG_DROP(priv, "Dropping - INVALID STATION: %pM\n",
+		if (sta_id == IL_INVALID_STATION) {
+			IL_DEBUG_DROP(priv, "Dropping - INVALID STATION: %pM\n",
 				       hdr->addr1);
 			goto drop_unlock;
 		}
 	}
 
-	IWL_DEBUG_TX(priv, "station Id %d\n", sta_id);
+	IL_DEBUG_TX(priv, "station Id %d\n", sta_id);
 
 	if (sta)
 		sta_priv = (void *)sta->drv_priv;
@@ -345,7 +345,7 @@ int iwl4965_tx_skb(struct iwl_priv *priv, struct sk_buff *skb)
 		 * For now set the counter to just 1 since we do not
 		 * support uAPSD yet.
 		 */
-		iwl4965_sta_modify_sleep_tx_count(priv, sta_id, 1);
+		il4965_sta_modify_sleep_tx_count(priv, sta_id, 1);
 	}
 
 	/*
@@ -381,7 +381,7 @@ int iwl4965_tx_skb(struct iwl_priv *priv, struct sk_buff *skb)
 		seq_number += 0x10;
 		/* aggregation is on for this <sta,tid> */
 		if (info->flags & IEEE80211_TX_CTL_AMPDU &&
-		    priv->stations[sta_id].tid[tid].agg.state == IWL_AGG_ON) {
+		    priv->stations[sta_id].tid[tid].agg.state == IL_AGG_ON) {
 			txq_id = priv->stations[sta_id].tid[tid].agg.txq_id;
 			is_agg = true;
 		}
@@ -390,7 +390,7 @@ int iwl4965_tx_skb(struct iwl_priv *priv, struct sk_buff *skb)
 	txq = &priv->txq[txq_id];
 	q = &txq->q;
 
-	if (unlikely(iwl_legacy_queue_space(q) < q->high_mark)) {
+	if (unlikely(il_queue_space(q) < q->high_mark)) {
 		spin_unlock(&priv->sta_lock);
 		goto drop_unlock;
 	}
@@ -404,7 +404,7 @@ int iwl4965_tx_skb(struct iwl_priv *priv, struct sk_buff *skb)
 	spin_unlock(&priv->sta_lock);
 
 	/* Set up driver data for this TFD */
-	memset(&(txq->txb[q->write_ptr]), 0, sizeof(struct iwl_tx_info));
+	memset(&(txq->txb[q->write_ptr]), 0, sizeof(struct il_tx_info));
 	txq->txb[q->write_ptr].skb = skb;
 	txq->txb[q->write_ptr].ctx = ctx;
 
@@ -413,7 +413,7 @@ int iwl4965_tx_skb(struct iwl_priv *priv, struct sk_buff *skb)
 	out_meta = &txq->meta[q->write_ptr];
 	tx_cmd = &out_cmd->cmd.tx;
 	memset(&out_cmd->hdr, 0, sizeof(out_cmd->hdr));
-	memset(tx_cmd, 0, sizeof(struct iwl_tx_cmd));
+	memset(tx_cmd, 0, sizeof(struct il_tx_cmd));
 
 	/*
 	 * Set up the Tx-command (not MAC!) header.
@@ -434,15 +434,15 @@ int iwl4965_tx_skb(struct iwl_priv *priv, struct sk_buff *skb)
 	tx_cmd->len = cpu_to_le16(len);
 
 	if (info->control.hw_key)
-		iwl4965_tx_cmd_build_hwcrypto(priv, info, tx_cmd, skb, sta_id);
+		il4965_tx_cmd_build_hwcrypto(priv, info, tx_cmd, skb, sta_id);
 
 	/* TODO need this for burst mode later on */
-	iwl4965_tx_cmd_build_basic(priv, skb, tx_cmd, info, hdr, sta_id);
-	iwl_legacy_dbg_log_tx_data_frame(priv, len, hdr);
+	il4965_tx_cmd_build_basic(priv, skb, tx_cmd, info, hdr, sta_id);
+	il_dbg_log_tx_data_frame(priv, len, hdr);
 
-	iwl4965_tx_cmd_build_rate(priv, tx_cmd, info, fc);
+	il4965_tx_cmd_build_rate(priv, tx_cmd, info, fc);
 
-	iwl_legacy_update_stats(priv, true, fc, len);
+	il_update_stats(priv, true, fc, len);
 	/*
 	 * Use the first empty entry in this queue's command buffer array
 	 * to contain the Tx command and MAC header concatenated together
@@ -452,8 +452,8 @@ int iwl4965_tx_skb(struct iwl_priv *priv, struct sk_buff *skb)
 	 * of the MAC header (device reads on dword boundaries).
 	 * We'll tell device about this padding later.
 	 */
-	len = sizeof(struct iwl_tx_cmd) +
-		sizeof(struct iwl_cmd_header) + hdr_len;
+	len = sizeof(struct il_tx_cmd) +
+		sizeof(struct il_cmd_header) + hdr_len;
 	firstlen = (len + 3) & ~3;
 
 	/* Tell NIC about any 2-byte padding after MAC header */
@@ -490,20 +490,20 @@ int iwl4965_tx_skb(struct iwl_priv *priv, struct sk_buff *skb)
 							   0, 0);
 	}
 
-	scratch_phys = txcmd_phys + sizeof(struct iwl_cmd_header) +
-				offsetof(struct iwl_tx_cmd, scratch);
+	scratch_phys = txcmd_phys + sizeof(struct il_cmd_header) +
+				offsetof(struct il_tx_cmd, scratch);
 
 	/* take back ownership of DMA buffer to enable update */
 	pci_dma_sync_single_for_cpu(priv->pci_dev, txcmd_phys,
 				    firstlen, PCI_DMA_BIDIRECTIONAL);
 	tx_cmd->dram_lsb_ptr = cpu_to_le32(scratch_phys);
-	tx_cmd->dram_msb_ptr = iwl_legacy_get_dma_hi_addr(scratch_phys);
+	tx_cmd->dram_msb_ptr = il_get_dma_hi_addr(scratch_phys);
 
-	IWL_DEBUG_TX(priv, "sequence nr = 0X%x\n",
+	IL_DEBUG_TX(priv, "sequence nr = 0X%x\n",
 		     le16_to_cpu(out_cmd->hdr.sequence));
-	IWL_DEBUG_TX(priv, "tx_flags = 0X%x\n", le32_to_cpu(tx_cmd->tx_flags));
-	iwl_print_hex_dump(priv, IWL_DL_TX, (u8 *)tx_cmd, sizeof(*tx_cmd));
-	iwl_print_hex_dump(priv, IWL_DL_TX, (u8 *)tx_cmd->hdr, hdr_len);
+	IL_DEBUG_TX(priv, "tx_flags = 0X%x\n", le32_to_cpu(tx_cmd->tx_flags));
+	il_print_hex_dump(priv, IL_DL_TX, (u8 *)tx_cmd, sizeof(*tx_cmd));
+	il_print_hex_dump(priv, IL_DL_TX, (u8 *)tx_cmd->hdr, hdr_len);
 
 	/* Set up entry for this TFD in Tx byte-count array */
 	if (info->flags & IEEE80211_TX_CTL_AMPDU)
@@ -514,8 +514,8 @@ int iwl4965_tx_skb(struct iwl_priv *priv, struct sk_buff *skb)
 				       firstlen, PCI_DMA_BIDIRECTIONAL);
 
 	/* Tell device the write index *just past* this latest filled TFD */
-	q->write_ptr = iwl_legacy_queue_inc_wrap(q->write_ptr, q->n_bd);
-	iwl_legacy_txq_update_write_ptr(priv, txq);
+	q->write_ptr = il_queue_inc_wrap(q->write_ptr, q->n_bd);
+	il_txq_update_write_ptr(priv, txq);
 	spin_unlock_irqrestore(&priv->lock, flags);
 
 	/*
@@ -535,15 +535,15 @@ int iwl4965_tx_skb(struct iwl_priv *priv, struct sk_buff *skb)
 	if (sta_priv && sta_priv->client && !is_agg)
 		atomic_inc(&sta_priv->pending_frames);
 
-	if ((iwl_legacy_queue_space(q) < q->high_mark) &&
+	if ((il_queue_space(q) < q->high_mark) &&
 			priv->mac80211_registered) {
 		if (wait_write_ptr) {
 			spin_lock_irqsave(&priv->lock, flags);
 			txq->need_update = 1;
-			iwl_legacy_txq_update_write_ptr(priv, txq);
+			il_txq_update_write_ptr(priv, txq);
 			spin_unlock_irqrestore(&priv->lock, flags);
 		} else {
-			iwl_legacy_stop_queue(priv, txq);
+			il_stop_queue(priv, txq);
 		}
 	}
 
@@ -554,8 +554,8 @@ drop_unlock:
 	return -1;
 }
 
-static inline int iwl4965_alloc_dma_ptr(struct iwl_priv *priv,
-				    struct iwl_dma_ptr *ptr, size_t size)
+static inline int il4965_alloc_dma_ptr(struct il_priv *priv,
+				    struct il_dma_ptr *ptr, size_t size)
 {
 	ptr->addr = dma_alloc_coherent(&priv->pci_dev->dev, size, &ptr->dma,
 				       GFP_KERNEL);
@@ -565,8 +565,8 @@ static inline int iwl4965_alloc_dma_ptr(struct iwl_priv *priv,
 	return 0;
 }
 
-static inline void iwl4965_free_dma_ptr(struct iwl_priv *priv,
-				    struct iwl_dma_ptr *ptr)
+static inline void il4965_free_dma_ptr(struct il_priv *priv,
+				    struct il_dma_ptr *ptr)
 {
 	if (unlikely(!ptr->addr))
 		return;
@@ -576,11 +576,11 @@ static inline void iwl4965_free_dma_ptr(struct iwl_priv *priv,
 }
 
 /**
- * iwl4965_hw_txq_ctx_free - Free TXQ Context
+ * il4965_hw_txq_ctx_free - Free TXQ Context
  *
  * Destroy all TX DMA queues and structures
  */
-void iwl4965_hw_txq_ctx_free(struct iwl_priv *priv)
+void il4965_hw_txq_ctx_free(struct il_priv *priv)
 {
 	int txq_id;
 
@@ -588,59 +588,59 @@ void iwl4965_hw_txq_ctx_free(struct iwl_priv *priv)
 	if (priv->txq) {
 		for (txq_id = 0; txq_id < priv->hw_params.max_txq_num; txq_id++)
 			if (txq_id == priv->cmd_queue)
-				iwl_legacy_cmd_queue_free(priv);
+				il_cmd_queue_free(priv);
 			else
-				iwl_legacy_tx_queue_free(priv, txq_id);
+				il_tx_queue_free(priv, txq_id);
 	}
-	iwl4965_free_dma_ptr(priv, &priv->kw);
+	il4965_free_dma_ptr(priv, &priv->kw);
 
-	iwl4965_free_dma_ptr(priv, &priv->scd_bc_tbls);
+	il4965_free_dma_ptr(priv, &priv->scd_bc_tbls);
 
 	/* free tx queue structure */
-	iwl_legacy_txq_mem(priv);
+	il_txq_mem(priv);
 }
 
 /**
- * iwl4965_txq_ctx_alloc - allocate TX queue context
+ * il4965_txq_ctx_alloc - allocate TX queue context
  * Allocate all Tx DMA structures and initialize them
  *
  * @param priv
  * @return error code
  */
-int iwl4965_txq_ctx_alloc(struct iwl_priv *priv)
+int il4965_txq_ctx_alloc(struct il_priv *priv)
 {
 	int ret;
 	int txq_id, slots_num;
 	unsigned long flags;
 
 	/* Free all tx/cmd queues and keep-warm buffer */
-	iwl4965_hw_txq_ctx_free(priv);
+	il4965_hw_txq_ctx_free(priv);
 
-	ret = iwl4965_alloc_dma_ptr(priv, &priv->scd_bc_tbls,
+	ret = il4965_alloc_dma_ptr(priv, &priv->scd_bc_tbls,
 				priv->hw_params.scd_bc_tbls_size);
 	if (ret) {
-		IWL_ERR(priv, "Scheduler BC Table allocation failed\n");
+		IL_ERR(priv, "Scheduler BC Table allocation failed\n");
 		goto error_bc_tbls;
 	}
 	/* Alloc keep-warm buffer */
-	ret = iwl4965_alloc_dma_ptr(priv, &priv->kw, IWL_KW_SIZE);
+	ret = il4965_alloc_dma_ptr(priv, &priv->kw, IL_KW_SIZE);
 	if (ret) {
-		IWL_ERR(priv, "Keep Warm allocation failed\n");
+		IL_ERR(priv, "Keep Warm allocation failed\n");
 		goto error_kw;
 	}
 
 	/* allocate tx queue structure */
-	ret = iwl_legacy_alloc_txq_mem(priv);
+	ret = il_alloc_txq_mem(priv);
 	if (ret)
 		goto error;
 
 	spin_lock_irqsave(&priv->lock, flags);
 
 	/* Turn off all Tx DMA fifos */
-	iwl4965_txq_set_sched(priv, 0);
+	il4965_txq_set_sched(priv, 0);
 
 	/* Tell NIC where to find the "keep warm" buffer */
-	iwl_legacy_write_direct32(priv, FH_KW_MEM_ADDR_REG, priv->kw.dma >> 4);
+	il_write_direct32(priv, FH_KW_MEM_ADDR_REG, priv->kw.dma >> 4);
 
 	spin_unlock_irqrestore(&priv->lock, flags);
 
@@ -648,11 +648,11 @@ int iwl4965_txq_ctx_alloc(struct iwl_priv *priv)
 	for (txq_id = 0; txq_id < priv->hw_params.max_txq_num; txq_id++) {
 		slots_num = (txq_id == priv->cmd_queue) ?
 					TFD_CMD_SLOTS : TFD_TX_CMD_SLOTS;
-		ret = iwl_legacy_tx_queue_init(priv,
+		ret = il_tx_queue_init(priv,
 					&priv->txq[txq_id], slots_num,
 				       txq_id);
 		if (ret) {
-			IWL_ERR(priv, "Tx %d queue init failed\n", txq_id);
+			IL_ERR(priv, "Tx %d queue init failed\n", txq_id);
 			goto error;
 		}
 	}
@@ -660,15 +660,15 @@ int iwl4965_txq_ctx_alloc(struct iwl_priv *priv)
 	return ret;
 
  error:
-	iwl4965_hw_txq_ctx_free(priv);
-	iwl4965_free_dma_ptr(priv, &priv->kw);
+	il4965_hw_txq_ctx_free(priv);
+	il4965_free_dma_ptr(priv, &priv->kw);
  error_kw:
-	iwl4965_free_dma_ptr(priv, &priv->scd_bc_tbls);
+	il4965_free_dma_ptr(priv, &priv->scd_bc_tbls);
  error_bc_tbls:
 	return ret;
 }
 
-void iwl4965_txq_ctx_reset(struct iwl_priv *priv)
+void il4965_txq_ctx_reset(struct il_priv *priv)
 {
 	int txq_id, slots_num;
 	unsigned long flags;
@@ -676,10 +676,10 @@ void iwl4965_txq_ctx_reset(struct iwl_priv *priv)
 	spin_lock_irqsave(&priv->lock, flags);
 
 	/* Turn off all Tx DMA fifos */
-	iwl4965_txq_set_sched(priv, 0);
+	il4965_txq_set_sched(priv, 0);
 
 	/* Tell NIC where to find the "keep warm" buffer */
-	iwl_legacy_write_direct32(priv, FH_KW_MEM_ADDR_REG, priv->kw.dma >> 4);
+	il_write_direct32(priv, FH_KW_MEM_ADDR_REG, priv->kw.dma >> 4);
 
 	spin_unlock_irqrestore(&priv->lock, flags);
 
@@ -687,15 +687,15 @@ void iwl4965_txq_ctx_reset(struct iwl_priv *priv)
 	for (txq_id = 0; txq_id < priv->hw_params.max_txq_num; txq_id++) {
 		slots_num = txq_id == priv->cmd_queue ?
 			    TFD_CMD_SLOTS : TFD_TX_CMD_SLOTS;
-		iwl_legacy_tx_queue_reset(priv, &priv->txq[txq_id],
+		il_tx_queue_reset(priv, &priv->txq[txq_id],
 						slots_num, txq_id);
 	}
 }
 
 /**
- * iwl4965_txq_ctx_stop - Stop all Tx DMA channels
+ * il4965_txq_ctx_stop - Stop all Tx DMA channels
  */
-void iwl4965_txq_ctx_stop(struct iwl_priv *priv)
+void il4965_txq_ctx_stop(struct il_priv *priv)
 {
 	int ch, txq_id;
 	unsigned long flags;
@@ -703,18 +703,18 @@ void iwl4965_txq_ctx_stop(struct iwl_priv *priv)
 	/* Turn off all Tx DMA fifos */
 	spin_lock_irqsave(&priv->lock, flags);
 
-	iwl4965_txq_set_sched(priv, 0);
+	il4965_txq_set_sched(priv, 0);
 
 	/* Stop each Tx DMA channel, and wait for it to be idle */
 	for (ch = 0; ch < priv->hw_params.dma_chnl_num; ch++) {
-		iwl_legacy_write_direct32(priv,
+		il_write_direct32(priv,
 				FH_TCSR_CHNL_TX_CONFIG_REG(ch), 0x0);
-		if (iwl_poll_direct_bit(priv, FH_TSSR_TX_STATUS_REG,
+		if (il_poll_direct_bit(priv, FH_TSSR_TX_STATUS_REG,
 				    FH_TSSR_TX_STATUS_REG_MSK_CHNL_IDLE(ch),
 				    1000))
-			IWL_ERR(priv, "Failing on timeout while stopping"
+			IL_ERR(priv, "Failing on timeout while stopping"
 			    " DMA channel %d [0x%08x]", ch,
-			    iwl_legacy_read_direct32(priv,
+			    il_read_direct32(priv,
 					FH_TSSR_TX_STATUS_REG));
 	}
 	spin_unlock_irqrestore(&priv->lock, flags);
@@ -725,9 +725,9 @@ void iwl4965_txq_ctx_stop(struct iwl_priv *priv)
 	/* Unmap DMA from host system and free skb's */
 	for (txq_id = 0; txq_id < priv->hw_params.max_txq_num; txq_id++)
 		if (txq_id == priv->cmd_queue)
-			iwl_legacy_cmd_queue_unmap(priv);
+			il_cmd_queue_unmap(priv);
 		else
-			iwl_legacy_tx_queue_unmap(priv, txq_id);
+			il_tx_queue_unmap(priv, txq_id);
 }
 
 /*
@@ -736,7 +736,7 @@ void iwl4965_txq_ctx_stop(struct iwl_priv *priv)
  * Should never return anything < 7, because they should already
  * be in use as EDCA AC (0-3), Command (4), reserved (5, 6)
  */
-static int iwl4965_txq_ctx_activate_free(struct iwl_priv *priv)
+static int il4965_txq_ctx_activate_free(struct il_priv *priv)
 {
 	int txq_id;
 
@@ -747,53 +747,53 @@ static int iwl4965_txq_ctx_activate_free(struct iwl_priv *priv)
 }
 
 /**
- * iwl4965_tx_queue_stop_scheduler - Stop queue, but keep configuration
+ * il4965_tx_queue_stop_scheduler - Stop queue, but keep configuration
  */
-static void iwl4965_tx_queue_stop_scheduler(struct iwl_priv *priv,
+static void il4965_tx_queue_stop_scheduler(struct il_priv *priv,
 					    u16 txq_id)
 {
 	/* Simply stop the queue, but don't change any configuration;
 	 * the SCD_ACT_EN bit is the write-enable mask for the ACTIVE bit. */
-	iwl_legacy_write_prph(priv,
+	il_write_prph(priv,
 		IWL49_SCD_QUEUE_STATUS_BITS(txq_id),
 		(0 << IWL49_SCD_QUEUE_STTS_REG_POS_ACTIVE)|
 		(1 << IWL49_SCD_QUEUE_STTS_REG_POS_SCD_ACT_EN));
 }
 
 /**
- * iwl4965_tx_queue_set_q2ratid - Map unique receiver/tid combination to a queue
+ * il4965_tx_queue_set_q2ratid - Map unique receiver/tid combination to a queue
  */
-static int iwl4965_tx_queue_set_q2ratid(struct iwl_priv *priv, u16 ra_tid,
+static int il4965_tx_queue_set_q2ratid(struct il_priv *priv, u16 ra_tid,
 					u16 txq_id)
 {
 	u32 tbl_dw_addr;
 	u32 tbl_dw;
 	u16 scd_q2ratid;
 
-	scd_q2ratid = ra_tid & IWL_SCD_QUEUE_RA_TID_MAP_RATID_MSK;
+	scd_q2ratid = ra_tid & IL_SCD_QUEUE_RA_TID_MAP_RATID_MSK;
 
 	tbl_dw_addr = priv->scd_base_addr +
 			IWL49_SCD_TRANSLATE_TBL_OFFSET_QUEUE(txq_id);
 
-	tbl_dw = iwl_legacy_read_targ_mem(priv, tbl_dw_addr);
+	tbl_dw = il_read_targ_mem(priv, tbl_dw_addr);
 
 	if (txq_id & 0x1)
 		tbl_dw = (scd_q2ratid << 16) | (tbl_dw & 0x0000FFFF);
 	else
 		tbl_dw = scd_q2ratid | (tbl_dw & 0xFFFF0000);
 
-	iwl_legacy_write_targ_mem(priv, tbl_dw_addr, tbl_dw);
+	il_write_targ_mem(priv, tbl_dw_addr, tbl_dw);
 
 	return 0;
 }
 
 /**
- * iwl4965_tx_queue_agg_enable - Set up & enable aggregation for selected queue
+ * il4965_tx_queue_agg_enable - Set up & enable aggregation for selected queue
  *
  * NOTE:  txq_id must be greater than IWL49_FIRST_AMPDU_QUEUE,
  *        i.e. it must be one of the higher queues used for aggregation
  */
-static int iwl4965_txq_agg_enable(struct iwl_priv *priv, int txq_id,
+static int il4965_txq_agg_enable(struct il_priv *priv, int txq_id,
 				  int tx_fifo, int sta_id, int tid, u16 ssn_idx)
 {
 	unsigned long flags;
@@ -803,7 +803,7 @@ static int iwl4965_txq_agg_enable(struct iwl_priv *priv, int txq_id,
 	if ((IWL49_FIRST_AMPDU_QUEUE > txq_id) ||
 	    (IWL49_FIRST_AMPDU_QUEUE +
 		priv->cfg->base_params->num_of_ampdu_queues <= txq_id)) {
-		IWL_WARN(priv,
+		IL_WARN(priv,
 			"queue number out of range: %d, must be %d to %d\n",
 			txq_id, IWL49_FIRST_AMPDU_QUEUE,
 			IWL49_FIRST_AMPDU_QUEUE +
@@ -814,42 +814,42 @@ static int iwl4965_txq_agg_enable(struct iwl_priv *priv, int txq_id,
 	ra_tid = BUILD_RAxTID(sta_id, tid);
 
 	/* Modify device's station table to Tx this TID */
-	ret = iwl4965_sta_tx_modify_enable_tid(priv, sta_id, tid);
+	ret = il4965_sta_tx_modify_enable_tid(priv, sta_id, tid);
 	if (ret)
 		return ret;
 
 	spin_lock_irqsave(&priv->lock, flags);
 
 	/* Stop this Tx queue before configuring it */
-	iwl4965_tx_queue_stop_scheduler(priv, txq_id);
+	il4965_tx_queue_stop_scheduler(priv, txq_id);
 
 	/* Map receiver-address / traffic-ID to this queue */
-	iwl4965_tx_queue_set_q2ratid(priv, ra_tid, txq_id);
+	il4965_tx_queue_set_q2ratid(priv, ra_tid, txq_id);
 
 	/* Set this queue as a chain-building queue */
-	iwl_legacy_set_bits_prph(priv, IWL49_SCD_QUEUECHAIN_SEL, (1 << txq_id));
+	il_set_bits_prph(priv, IWL49_SCD_QUEUECHAIN_SEL, (1 << txq_id));
 
 	/* Place first TFD at index corresponding to start sequence number.
 	 * Assumes that ssn_idx is valid (!= 0xFFF) */
 	priv->txq[txq_id].q.read_ptr = (ssn_idx & 0xff);
 	priv->txq[txq_id].q.write_ptr = (ssn_idx & 0xff);
-	iwl4965_set_wr_ptrs(priv, txq_id, ssn_idx);
+	il4965_set_wr_ptrs(priv, txq_id, ssn_idx);
 
 	/* Set up Tx window size and frame limit for this queue */
-	iwl_legacy_write_targ_mem(priv,
+	il_write_targ_mem(priv,
 		priv->scd_base_addr + IWL49_SCD_CONTEXT_QUEUE_OFFSET(txq_id),
 		(SCD_WIN_SIZE << IWL49_SCD_QUEUE_CTX_REG1_WIN_SIZE_POS) &
 		IWL49_SCD_QUEUE_CTX_REG1_WIN_SIZE_MSK);
 
-	iwl_legacy_write_targ_mem(priv, priv->scd_base_addr +
+	il_write_targ_mem(priv, priv->scd_base_addr +
 		IWL49_SCD_CONTEXT_QUEUE_OFFSET(txq_id) + sizeof(u32),
 		(SCD_FRAME_LIMIT << IWL49_SCD_QUEUE_CTX_REG2_FRAME_LIMIT_POS)
 		& IWL49_SCD_QUEUE_CTX_REG2_FRAME_LIMIT_MSK);
 
-	iwl_legacy_set_bits_prph(priv, IWL49_SCD_INTERRUPT_MASK, (1 << txq_id));
+	il_set_bits_prph(priv, IWL49_SCD_INTERRUPT_MASK, (1 << txq_id));
 
 	/* Set up Status area in SRAM, map to Tx DMA/FIFO, activate the queue */
-	iwl4965_tx_queue_set_status(priv, &priv->txq[txq_id], tx_fifo, 1);
+	il4965_tx_queue_set_status(priv, &priv->txq[txq_id], tx_fifo, 1);
 
 	spin_unlock_irqrestore(&priv->lock, flags);
 
@@ -857,7 +857,7 @@ static int iwl4965_txq_agg_enable(struct iwl_priv *priv, int txq_id,
 }
 
 
-int iwl4965_tx_agg_start(struct iwl_priv *priv, struct ieee80211_vif *vif,
+int il4965_tx_agg_start(struct il_priv *priv, struct ieee80211_vif *vif,
 			struct ieee80211_sta *sta, u16 tid, u16 *ssn)
 {
 	int sta_id;
@@ -865,31 +865,31 @@ int iwl4965_tx_agg_start(struct iwl_priv *priv, struct ieee80211_vif *vif,
 	int txq_id;
 	int ret;
 	unsigned long flags;
-	struct iwl_tid_data *tid_data;
+	struct il_tid_data *tid_data;
 
-	tx_fifo = iwl4965_get_fifo_from_tid(iwl_legacy_rxon_ctx_from_vif(vif), tid);
+	tx_fifo = il4965_get_fifo_from_tid(il_rxon_ctx_from_vif(vif), tid);
 	if (unlikely(tx_fifo < 0))
 		return tx_fifo;
 
-	IWL_WARN(priv, "%s on ra = %pM tid = %d\n",
+	IL_WARN(priv, "%s on ra = %pM tid = %d\n",
 			__func__, sta->addr, tid);
 
-	sta_id = iwl_legacy_sta_id(sta);
-	if (sta_id == IWL_INVALID_STATION) {
-		IWL_ERR(priv, "Start AGG on invalid station\n");
+	sta_id = il_sta_id(sta);
+	if (sta_id == IL_INVALID_STATION) {
+		IL_ERR(priv, "Start AGG on invalid station\n");
 		return -ENXIO;
 	}
 	if (unlikely(tid >= MAX_TID_COUNT))
 		return -EINVAL;
 
-	if (priv->stations[sta_id].tid[tid].agg.state != IWL_AGG_OFF) {
-		IWL_ERR(priv, "Start AGG when state is not IWL_AGG_OFF !\n");
+	if (priv->stations[sta_id].tid[tid].agg.state != IL_AGG_OFF) {
+		IL_ERR(priv, "Start AGG when state is not IL_AGG_OFF !\n");
 		return -ENXIO;
 	}
 
-	txq_id = iwl4965_txq_ctx_activate_free(priv);
+	txq_id = il4965_txq_ctx_activate_free(priv);
 	if (txq_id == -1) {
-		IWL_ERR(priv, "No free aggregation queue available\n");
+		IL_ERR(priv, "No free aggregation queue available\n");
 		return -ENXIO;
 	}
 
@@ -897,11 +897,11 @@ int iwl4965_tx_agg_start(struct iwl_priv *priv, struct ieee80211_vif *vif,
 	tid_data = &priv->stations[sta_id].tid[tid];
 	*ssn = SEQ_TO_SN(tid_data->seq_number);
 	tid_data->agg.txq_id = txq_id;
-	iwl_legacy_set_swq_id(&priv->txq[txq_id],
-				iwl4965_get_ac_from_tid(tid), txq_id);
+	il_set_swq_id(&priv->txq[txq_id],
+				il4965_get_ac_from_tid(tid), txq_id);
 	spin_unlock_irqrestore(&priv->sta_lock, flags);
 
-	ret = iwl4965_txq_agg_enable(priv, txq_id, tx_fifo,
+	ret = il4965_txq_agg_enable(priv, txq_id, tx_fifo,
 						  sta_id, tid, *ssn);
 	if (ret)
 		return ret;
@@ -909,14 +909,14 @@ int iwl4965_tx_agg_start(struct iwl_priv *priv, struct ieee80211_vif *vif,
 	spin_lock_irqsave(&priv->sta_lock, flags);
 	tid_data = &priv->stations[sta_id].tid[tid];
 	if (tid_data->tfds_in_queue == 0) {
-		IWL_DEBUG_HT(priv, "HW queue is empty\n");
-		tid_data->agg.state = IWL_AGG_ON;
+		IL_DEBUG_HT(priv, "HW queue is empty\n");
+		tid_data->agg.state = IL_AGG_ON;
 		ieee80211_start_tx_ba_cb_irqsafe(vif, sta->addr, tid);
 	} else {
-		IWL_DEBUG_HT(priv,
+		IL_DEBUG_HT(priv,
 			"HW queue is NOT empty: %d packets in HW queue\n",
 			     tid_data->tfds_in_queue);
-		tid_data->agg.state = IWL_EMPTYING_HW_QUEUE_ADDBA;
+		tid_data->agg.state = IL_EMPTYING_HW_QUEUE_ADDBA;
 	}
 	spin_unlock_irqrestore(&priv->sta_lock, flags);
 	return ret;
@@ -926,13 +926,13 @@ int iwl4965_tx_agg_start(struct iwl_priv *priv, struct ieee80211_vif *vif,
  * txq_id must be greater than IWL49_FIRST_AMPDU_QUEUE
  * priv->lock must be held by the caller
  */
-static int iwl4965_txq_agg_disable(struct iwl_priv *priv, u16 txq_id,
+static int il4965_txq_agg_disable(struct il_priv *priv, u16 txq_id,
 				   u16 ssn_idx, u8 tx_fifo)
 {
 	if ((IWL49_FIRST_AMPDU_QUEUE > txq_id) ||
 	    (IWL49_FIRST_AMPDU_QUEUE +
 		priv->cfg->base_params->num_of_ampdu_queues <= txq_id)) {
-		IWL_WARN(priv,
+		IL_WARN(priv,
 			"queue number out of range: %d, must be %d to %d\n",
 			txq_id, IWL49_FIRST_AMPDU_QUEUE,
 			IWL49_FIRST_AMPDU_QUEUE +
@@ -940,40 +940,40 @@ static int iwl4965_txq_agg_disable(struct iwl_priv *priv, u16 txq_id,
 		return -EINVAL;
 	}
 
-	iwl4965_tx_queue_stop_scheduler(priv, txq_id);
+	il4965_tx_queue_stop_scheduler(priv, txq_id);
 
-	iwl_legacy_clear_bits_prph(priv,
+	il_clear_bits_prph(priv,
 			IWL49_SCD_QUEUECHAIN_SEL, (1 << txq_id));
 
 	priv->txq[txq_id].q.read_ptr = (ssn_idx & 0xff);
 	priv->txq[txq_id].q.write_ptr = (ssn_idx & 0xff);
 	/* supposes that ssn_idx is valid (!= 0xFFF) */
-	iwl4965_set_wr_ptrs(priv, txq_id, ssn_idx);
+	il4965_set_wr_ptrs(priv, txq_id, ssn_idx);
 
-	iwl_legacy_clear_bits_prph(priv,
+	il_clear_bits_prph(priv,
 			 IWL49_SCD_INTERRUPT_MASK, (1 << txq_id));
-	iwl_txq_ctx_deactivate(priv, txq_id);
-	iwl4965_tx_queue_set_status(priv, &priv->txq[txq_id], tx_fifo, 0);
+	il_txq_ctx_deactivate(priv, txq_id);
+	il4965_tx_queue_set_status(priv, &priv->txq[txq_id], tx_fifo, 0);
 
 	return 0;
 }
 
-int iwl4965_tx_agg_stop(struct iwl_priv *priv, struct ieee80211_vif *vif,
+int il4965_tx_agg_stop(struct il_priv *priv, struct ieee80211_vif *vif,
 		       struct ieee80211_sta *sta, u16 tid)
 {
 	int tx_fifo_id, txq_id, sta_id, ssn;
-	struct iwl_tid_data *tid_data;
+	struct il_tid_data *tid_data;
 	int write_ptr, read_ptr;
 	unsigned long flags;
 
-	tx_fifo_id = iwl4965_get_fifo_from_tid(iwl_legacy_rxon_ctx_from_vif(vif), tid);
+	tx_fifo_id = il4965_get_fifo_from_tid(il_rxon_ctx_from_vif(vif), tid);
 	if (unlikely(tx_fifo_id < 0))
 		return tx_fifo_id;
 
-	sta_id = iwl_legacy_sta_id(sta);
+	sta_id = il_sta_id(sta);
 
-	if (sta_id == IWL_INVALID_STATION) {
-		IWL_ERR(priv, "Invalid station for AGG tid %d\n", tid);
+	if (sta_id == IL_INVALID_STATION) {
+		IL_ERR(priv, "Invalid station for AGG tid %d\n", tid);
 		return -ENXIO;
 	}
 
@@ -984,19 +984,19 @@ int iwl4965_tx_agg_stop(struct iwl_priv *priv, struct ieee80211_vif *vif,
 	txq_id = tid_data->agg.txq_id;
 
 	switch (priv->stations[sta_id].tid[tid].agg.state) {
-	case IWL_EMPTYING_HW_QUEUE_ADDBA:
+	case IL_EMPTYING_HW_QUEUE_ADDBA:
 		/*
 		 * This can happen if the peer stops aggregation
 		 * again before we've had a chance to drain the
 		 * queue we selected previously, i.e. before the
 		 * session was really started completely.
 		 */
-		IWL_DEBUG_HT(priv, "AGG stop before setup done\n");
+		IL_DEBUG_HT(priv, "AGG stop before setup done\n");
 		goto turn_off;
-	case IWL_AGG_ON:
+	case IL_AGG_ON:
 		break;
 	default:
-		IWL_WARN(priv, "Stopping AGG while state not ON or starting\n");
+		IL_WARN(priv, "Stopping AGG while state not ON or starting\n");
 	}
 
 	write_ptr = priv->txq[txq_id].q.write_ptr;
@@ -1004,16 +1004,16 @@ int iwl4965_tx_agg_stop(struct iwl_priv *priv, struct ieee80211_vif *vif,
 
 	/* The queue is not empty */
 	if (write_ptr != read_ptr) {
-		IWL_DEBUG_HT(priv, "Stopping a non empty AGG HW QUEUE\n");
+		IL_DEBUG_HT(priv, "Stopping a non empty AGG HW QUEUE\n");
 		priv->stations[sta_id].tid[tid].agg.state =
-				IWL_EMPTYING_HW_QUEUE_DELBA;
+				IL_EMPTYING_HW_QUEUE_DELBA;
 		spin_unlock_irqrestore(&priv->sta_lock, flags);
 		return 0;
 	}
 
-	IWL_DEBUG_HT(priv, "HW queue is empty\n");
+	IL_DEBUG_HT(priv, "HW queue is empty\n");
  turn_off:
-	priv->stations[sta_id].tid[tid].agg.state = IWL_AGG_OFF;
+	priv->stations[sta_id].tid[tid].agg.state = IL_AGG_OFF;
 
 	/* do not restore/save irqs */
 	spin_unlock(&priv->sta_lock);
@@ -1026,7 +1026,7 @@ int iwl4965_tx_agg_stop(struct iwl_priv *priv, struct ieee80211_vif *vif,
 	 * to deactivate the uCode queue, just return "success" to allow
 	 *  mac80211 to clean up it own data.
 	 */
-	iwl4965_txq_agg_disable(priv, txq_id, ssn, tx_fifo_id);
+	il4965_txq_agg_disable(priv, txq_id, ssn, tx_fifo_id);
 	spin_unlock_irqrestore(&priv->lock, flags);
 
 	ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid);
@@ -1034,39 +1034,39 @@ int iwl4965_tx_agg_stop(struct iwl_priv *priv, struct ieee80211_vif *vif,
 	return 0;
 }
 
-int iwl4965_txq_check_empty(struct iwl_priv *priv,
+int il4965_txq_check_empty(struct il_priv *priv,
 			   int sta_id, u8 tid, int txq_id)
 {
-	struct iwl_queue *q = &priv->txq[txq_id].q;
+	struct il_queue *q = &priv->txq[txq_id].q;
 	u8 *addr = priv->stations[sta_id].sta.sta.addr;
-	struct iwl_tid_data *tid_data = &priv->stations[sta_id].tid[tid];
-	struct iwl_rxon_context *ctx;
+	struct il_tid_data *tid_data = &priv->stations[sta_id].tid[tid];
+	struct il_rxon_context *ctx;
 
 	ctx = &priv->contexts[priv->stations[sta_id].ctxid];
 
 	lockdep_assert_held(&priv->sta_lock);
 
 	switch (priv->stations[sta_id].tid[tid].agg.state) {
-	case IWL_EMPTYING_HW_QUEUE_DELBA:
+	case IL_EMPTYING_HW_QUEUE_DELBA:
 		/* We are reclaiming the last packet of the */
 		/* aggregated HW queue */
 		if ((txq_id  == tid_data->agg.txq_id) &&
 		    (q->read_ptr == q->write_ptr)) {
 			u16 ssn = SEQ_TO_SN(tid_data->seq_number);
-			int tx_fifo = iwl4965_get_fifo_from_tid(ctx, tid);
-			IWL_DEBUG_HT(priv,
+			int tx_fifo = il4965_get_fifo_from_tid(ctx, tid);
+			IL_DEBUG_HT(priv,
 				"HW queue empty: continue DELBA flow\n");
-			iwl4965_txq_agg_disable(priv, txq_id, ssn, tx_fifo);
-			tid_data->agg.state = IWL_AGG_OFF;
+			il4965_txq_agg_disable(priv, txq_id, ssn, tx_fifo);
+			tid_data->agg.state = IL_AGG_OFF;
 			ieee80211_stop_tx_ba_cb_irqsafe(ctx->vif, addr, tid);
 		}
 		break;
-	case IWL_EMPTYING_HW_QUEUE_ADDBA:
+	case IL_EMPTYING_HW_QUEUE_ADDBA:
 		/* We are reclaiming the last packet of the queue */
 		if (tid_data->tfds_in_queue == 0) {
-			IWL_DEBUG_HT(priv,
+			IL_DEBUG_HT(priv,
 				"HW queue empty: continue ADDBA flow\n");
-			tid_data->agg.state = IWL_AGG_ON;
+			tid_data->agg.state = IL_AGG_ON;
 			ieee80211_start_tx_ba_cb_irqsafe(ctx->vif, addr, tid);
 		}
 		break;
@@ -1075,12 +1075,12 @@ int iwl4965_txq_check_empty(struct iwl_priv *priv,
 	return 0;
 }
 
-static void iwl4965_non_agg_tx_status(struct iwl_priv *priv,
-				     struct iwl_rxon_context *ctx,
+static void il4965_non_agg_tx_status(struct il_priv *priv,
+				     struct il_rxon_context *ctx,
 				     const u8 *addr1)
 {
 	struct ieee80211_sta *sta;
-	struct iwl_station_priv *sta_priv;
+	struct il_station_priv *sta_priv;
 
 	rcu_read_lock();
 	sta = ieee80211_find_sta(ctx->vif, addr1);
@@ -1095,35 +1095,35 @@ static void iwl4965_non_agg_tx_status(struct iwl_priv *priv,
 }
 
 static void
-iwl4965_tx_status(struct iwl_priv *priv, struct iwl_tx_info *tx_info,
+il4965_tx_status(struct il_priv *priv, struct il_tx_info *tx_info,
 			     bool is_agg)
 {
 	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) tx_info->skb->data;
 
 	if (!is_agg)
-		iwl4965_non_agg_tx_status(priv, tx_info->ctx, hdr->addr1);
+		il4965_non_agg_tx_status(priv, tx_info->ctx, hdr->addr1);
 
 	ieee80211_tx_status_irqsafe(priv->hw, tx_info->skb);
 }
 
-int iwl4965_tx_queue_reclaim(struct iwl_priv *priv, int txq_id, int index)
+int il4965_tx_queue_reclaim(struct il_priv *priv, int txq_id, int index)
 {
-	struct iwl_tx_queue *txq = &priv->txq[txq_id];
-	struct iwl_queue *q = &txq->q;
-	struct iwl_tx_info *tx_info;
+	struct il_tx_queue *txq = &priv->txq[txq_id];
+	struct il_queue *q = &txq->q;
+	struct il_tx_info *tx_info;
 	int nfreed = 0;
 	struct ieee80211_hdr *hdr;
 
-	if ((index >= q->n_bd) || (iwl_legacy_queue_used(q, index) == 0)) {
-		IWL_ERR(priv, "Read index for DMA queue txq id (%d), index %d, "
+	if ((index >= q->n_bd) || (il_queue_used(q, index) == 0)) {
+		IL_ERR(priv, "Read index for DMA queue txq id (%d), index %d, "
 			  "is out of range [0-%d] %d %d.\n", txq_id,
 			  index, q->n_bd, q->write_ptr, q->read_ptr);
 		return 0;
 	}
 
-	for (index = iwl_legacy_queue_inc_wrap(index, q->n_bd);
+	for (index = il_queue_inc_wrap(index, q->n_bd);
 	     q->read_ptr != index;
-	     q->read_ptr = iwl_legacy_queue_inc_wrap(q->read_ptr, q->n_bd)) {
+	     q->read_ptr = il_queue_inc_wrap(q->read_ptr, q->n_bd)) {
 
 		tx_info = &txq->txb[txq->q.read_ptr];
 
@@ -1134,7 +1134,7 @@ int iwl4965_tx_queue_reclaim(struct iwl_priv *priv, int txq_id, int index)
 		if (ieee80211_is_data_qos(hdr->frame_control))
 			nfreed++;
 
-		iwl4965_tx_status(priv, tx_info,
+		il4965_tx_status(priv, tx_info,
 				 txq_id >= IWL4965_FIRST_AMPDU_QUEUE);
 		tx_info->skb = NULL;
 
@@ -1144,14 +1144,14 @@ int iwl4965_tx_queue_reclaim(struct iwl_priv *priv, int txq_id, int index)
 }
 
 /**
- * iwl4965_tx_status_reply_compressed_ba - Update tx status from block-ack
+ * il4965_tx_status_reply_compressed_ba - Update tx status from block-ack
  *
  * Go through block-ack's bitmap of ACK'd frames, update driver's record of
  * ACK vs. not.  This gets sent to mac80211, then to rate scaling algo.
  */
-static int iwl4965_tx_status_reply_compressed_ba(struct iwl_priv *priv,
-				 struct iwl_ht_agg *agg,
-				 struct iwl_compressed_ba_resp *ba_resp)
+static int il4965_tx_status_reply_compressed_ba(struct il_priv *priv,
+				 struct il_ht_agg *agg,
+				 struct il_compressed_ba_resp *ba_resp)
 
 {
 	int i, sh, ack;
@@ -1163,13 +1163,13 @@ static int iwl4965_tx_status_reply_compressed_ba(struct iwl_priv *priv,
 
 	if (unlikely(!agg->wait_for_ba))  {
 		if (unlikely(ba_resp->bitmap))
-			IWL_ERR(priv, "Received BA when not expected\n");
+			IL_ERR(priv, "Received BA when not expected\n");
 		return -EINVAL;
 	}
 
 	/* Mark that the expected block-ack response arrived */
 	agg->wait_for_ba = 0;
-	IWL_DEBUG_TX_REPLY(priv, "BA %d %d\n", agg->start_idx,
+	IL_DEBUG_TX_REPLY(priv, "BA %d %d\n", agg->start_idx,
 							ba_resp->seq_ctl);
 
 	/* Calculate shift to align block-ack bits with our Tx window bits */
@@ -1178,7 +1178,7 @@ static int iwl4965_tx_status_reply_compressed_ba(struct iwl_priv *priv,
 		sh += 0x100;
 
 	if (agg->frame_count > (64 - sh)) {
-		IWL_DEBUG_TX_REPLY(priv, "more frames than bitmap size");
+		IL_DEBUG_TX_REPLY(priv, "more frames than bitmap size");
 		return -1;
 	}
 
@@ -1195,7 +1195,7 @@ static int iwl4965_tx_status_reply_compressed_ba(struct iwl_priv *priv,
 	while (sent_bitmap) {
 		ack = sent_bitmap & 1ULL;
 		successes += ack;
-		IWL_DEBUG_TX_REPLY(priv, "%s ON i=%d idx=%d raw=%d\n",
+		IL_DEBUG_TX_REPLY(priv, "%s ON i=%d idx=%d raw=%d\n",
 			ack ? "ACK" : "NACK", i,
 			(agg->start_idx + i) & 0xff,
 			agg->start_idx + i);
@@ -1203,7 +1203,7 @@ static int iwl4965_tx_status_reply_compressed_ba(struct iwl_priv *priv,
 		++i;
 	}
 
-	IWL_DEBUG_TX_REPLY(priv, "Bitmap %llx\n",
+	IL_DEBUG_TX_REPLY(priv, "Bitmap %llx\n",
 				   (unsigned long long)bitmap);
 
 	info = IEEE80211_SKB_CB(priv->txq[scd_flow].txb[agg->start_idx].skb);
@@ -1212,7 +1212,7 @@ static int iwl4965_tx_status_reply_compressed_ba(struct iwl_priv *priv,
 	info->flags |= IEEE80211_TX_STAT_AMPDU;
 	info->status.ampdu_ack_len = successes;
 	info->status.ampdu_len = agg->frame_count;
-	iwl4965_hwrate_to_tx_control(priv, agg->rate_n_flags, info);
+	il4965_hwrate_to_tx_control(priv, agg->rate_n_flags, info);
 
 	return 0;
 }
@@ -1220,7 +1220,7 @@ static int iwl4965_tx_status_reply_compressed_ba(struct iwl_priv *priv,
 /**
  * translate ucode response to mac80211 tx status control values
  */
-void iwl4965_hwrate_to_tx_control(struct iwl_priv *priv, u32 rate_n_flags,
+void il4965_hwrate_to_tx_control(struct il_priv *priv, u32 rate_n_flags,
 				  struct ieee80211_tx_info *info)
 {
 	struct ieee80211_tx_rate *r = &info->control.rates[0];
@@ -1237,22 +1237,22 @@ void iwl4965_hwrate_to_tx_control(struct iwl_priv *priv, u32 rate_n_flags,
 		r->flags |= IEEE80211_TX_RC_DUP_DATA;
 	if (rate_n_flags & RATE_MCS_SGI_MSK)
 		r->flags |= IEEE80211_TX_RC_SHORT_GI;
-	r->idx = iwl4965_hwrate_to_mac80211_idx(rate_n_flags, info->band);
+	r->idx = il4965_hwrate_to_mac80211_idx(rate_n_flags, info->band);
 }
 
 /**
- * iwl4965_rx_reply_compressed_ba - Handler for REPLY_COMPRESSED_BA
+ * il4965_rx_reply_compressed_ba - Handler for REPLY_COMPRESSED_BA
  *
  * Handles block-acknowledge notification from device, which reports success
  * of frames sent via aggregation.
  */
-void iwl4965_rx_reply_compressed_ba(struct iwl_priv *priv,
-					   struct iwl_rx_mem_buffer *rxb)
+void il4965_rx_reply_compressed_ba(struct il_priv *priv,
+					   struct il_rx_mem_buffer *rxb)
 {
-	struct iwl_rx_packet *pkt = rxb_addr(rxb);
-	struct iwl_compressed_ba_resp *ba_resp = &pkt->u.compressed_ba;
-	struct iwl_tx_queue *txq = NULL;
-	struct iwl_ht_agg *agg;
+	struct il_rx_packet *pkt = rxb_addr(rxb);
+	struct il_compressed_ba_resp *ba_resp = &pkt->u.compressed_ba;
+	struct il_tx_queue *txq = NULL;
+	struct il_ht_agg *agg;
 	int index;
 	int sta_id;
 	int tid;
@@ -1266,7 +1266,7 @@ void iwl4965_rx_reply_compressed_ba(struct iwl_priv *priv,
 	u16 ba_resp_scd_ssn = le16_to_cpu(ba_resp->scd_ssn);
 
 	if (scd_flow >= priv->hw_params.max_txq_num) {
-		IWL_ERR(priv,
+		IL_ERR(priv,
 			"BUG_ON scd_flow is bigger than number of queues\n");
 		return;
 	}
@@ -1282,23 +1282,23 @@ void iwl4965_rx_reply_compressed_ba(struct iwl_priv *priv,
 		 * since it is possible happen very often and in order
 		 * not to fill the syslog, don't enable the logging by default
 		 */
-		IWL_DEBUG_TX_REPLY(priv,
+		IL_DEBUG_TX_REPLY(priv,
 			"BA scd_flow %d does not match txq_id %d\n",
 			scd_flow, agg->txq_id);
 		return;
 	}
 
 	/* Find index just before block-ack window */
-	index = iwl_legacy_queue_dec_wrap(ba_resp_scd_ssn & 0xff, txq->q.n_bd);
+	index = il_queue_dec_wrap(ba_resp_scd_ssn & 0xff, txq->q.n_bd);
 
 	spin_lock_irqsave(&priv->sta_lock, flags);
 
-	IWL_DEBUG_TX_REPLY(priv, "REPLY_COMPRESSED_BA [%d] Received from %pM, "
+	IL_DEBUG_TX_REPLY(priv, "REPLY_COMPRESSED_BA [%d] Received from %pM, "
 			   "sta_id = %d\n",
 			   agg->wait_for_ba,
 			   (u8 *) &ba_resp->sta_addr_lo32,
 			   ba_resp->sta_id);
-	IWL_DEBUG_TX_REPLY(priv, "TID = %d, SeqCtl = %d, bitmap = 0x%llx,"
+	IL_DEBUG_TX_REPLY(priv, "TID = %d, SeqCtl = %d, bitmap = 0x%llx,"
 			"scd_flow = "
 			   "%d, scd_ssn = %d\n",
 			   ba_resp->tid,
@@ -1306,34 +1306,34 @@ void iwl4965_rx_reply_compressed_ba(struct iwl_priv *priv,
 			   (unsigned long long)le64_to_cpu(ba_resp->bitmap),
 			   ba_resp->scd_flow,
 			   ba_resp->scd_ssn);
-	IWL_DEBUG_TX_REPLY(priv, "DAT start_idx = %d, bitmap = 0x%llx\n",
+	IL_DEBUG_TX_REPLY(priv, "DAT start_idx = %d, bitmap = 0x%llx\n",
 			   agg->start_idx,
 			   (unsigned long long)agg->bitmap);
 
 	/* Update driver's record of ACK vs. not for each frame in window */
-	iwl4965_tx_status_reply_compressed_ba(priv, agg, ba_resp);
+	il4965_tx_status_reply_compressed_ba(priv, agg, ba_resp);
 
 	/* Release all TFDs before the SSN, i.e. all TFDs in front of
 	 * block-ack window (we assume that they've been successfully
 	 * transmitted ... if not, it's too late anyway). */
 	if (txq->q.read_ptr != (ba_resp_scd_ssn & 0xff)) {
 		/* calculate mac80211 ampdu sw queue to wake */
-		int freed = iwl4965_tx_queue_reclaim(priv, scd_flow, index);
-		iwl4965_free_tfds_in_queue(priv, sta_id, tid, freed);
+		int freed = il4965_tx_queue_reclaim(priv, scd_flow, index);
+		il4965_free_tfds_in_queue(priv, sta_id, tid, freed);
 
-		if ((iwl_legacy_queue_space(&txq->q) > txq->q.low_mark) &&
+		if ((il_queue_space(&txq->q) > txq->q.low_mark) &&
 		    priv->mac80211_registered &&
-		    (agg->state != IWL_EMPTYING_HW_QUEUE_DELBA))
-			iwl_legacy_wake_queue(priv, txq);
+		    (agg->state != IL_EMPTYING_HW_QUEUE_DELBA))
+			il_wake_queue(priv, txq);
 
-		iwl4965_txq_check_empty(priv, sta_id, tid, scd_flow);
+		il4965_txq_check_empty(priv, sta_id, tid, scd_flow);
 	}
 
 	spin_unlock_irqrestore(&priv->sta_lock, flags);
 }
 
 #ifdef CONFIG_IWLWIFI_LEGACY_DEBUG
-const char *iwl4965_get_tx_fail_reason(u32 status)
+const char *il4965_get_tx_fail_reason(u32 status)
 {
 #define TX_STATUS_FAIL(x) case TX_STATUS_FAIL_ ## x: return #x
 #define TX_STATUS_POSTPONE(x) case TX_STATUS_POSTPONE_ ## x: return #x