iwl3945: use iwl-io.h and delete iwl-3945-io.h

The patch deletes iwl-3945-io.h and uses iwl-io.h functions.

Signed-off-by: Abhijeet Kolekar <abhijeet.kolekar@intel.com>
Signed-off-by: Zhu Yi <yi.zhu@intel.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>

1 files changed, 115 insertions, 115 deletions

diff --git a/drivers/net/wireless/iwlwifi/iwl3945-base.c b/drivers/net/wireless/iwlwifi/iwl3945-base.c
index f80294e6bd9b..6bbc887449ca 100644
--- a/drivers/net/wireless/iwlwifi/iwl3945-base.c
+++ b/drivers/net/wireless/iwlwifi/iwl3945-base.c
@@ -1411,7 +1411,7 @@ static void get_eeprom_mac(struct iwl_priv *priv, u8 *mac)
  */
 static inline int iwl3945_eeprom_acquire_semaphore(struct iwl_priv *priv)
 {
-        _iwl3945_clear_bit(priv, CSR_EEPROM_GP, CSR_EEPROM_GP_IF_OWNER_MSK);
+        _iwl_clear_bit(priv, CSR_EEPROM_GP, CSR_EEPROM_GP_IF_OWNER_MSK);
         return 0;
 }
 
@@ -1425,7 +1425,7 @@ static inline int iwl3945_eeprom_acquire_semaphore(struct iwl_priv *priv)
 int iwl3945_eeprom_init(struct iwl_priv *priv)
 {
         u16 *e = (u16 *)&priv->eeprom39;
-        u32 gp = iwl3945_read32(priv, CSR_EEPROM_GP);
+        u32 gp = iwl_read32(priv, CSR_EEPROM_GP);
         int sz = sizeof(priv->eeprom39);
         int ret;
         u16 addr;
@@ -1452,10 +1452,10 @@ int iwl3945_eeprom_init(struct iwl_priv *priv)
         for (addr = 0; addr < sz; addr += sizeof(u16)) {
                 u32 r;
 
-                _iwl3945_write32(priv, CSR_EEPROM_REG,
+                _iwl_write32(priv, CSR_EEPROM_REG,
                                  CSR_EEPROM_REG_MSK_ADDR & (addr << 1));
-                _iwl3945_clear_bit(priv, CSR_EEPROM_REG, CSR_EEPROM_REG_BIT_CMD);
-                ret = iwl3945_poll_direct_bit(priv, CSR_EEPROM_REG,
+                _iwl_clear_bit(priv, CSR_EEPROM_REG, CSR_EEPROM_REG_BIT_CMD);
+                ret = iwl_poll_direct_bit(priv, CSR_EEPROM_REG,
                                               CSR_EEPROM_REG_READ_VALID_MSK,
                                               IWL_EEPROM_ACCESS_TIMEOUT);
                 if (ret < 0) {
@@ -1463,7 +1463,7 @@ int iwl3945_eeprom_init(struct iwl_priv *priv)
                         return ret;
                 }
 
-                r = _iwl3945_read_direct32(priv, CSR_EEPROM_REG);
+                r = _iwl_read_direct32(priv, CSR_EEPROM_REG);
                 e[addr / 2] = le16_to_cpu((__force __le16)(r >> 16));
         }
 
@@ -2663,7 +2663,7 @@ static void iwl3945_radio_kill_sw(struct iwl_priv *priv, int disable_radio)
                 /* FIXME: This is a workaround for AP */
                 if (priv->iw_mode != NL80211_IFTYPE_AP) {
                         spin_lock_irqsave(&priv->lock, flags);
-                        iwl3945_write32(priv, CSR_UCODE_DRV_GP1_SET,
+                        iwl_write32(priv, CSR_UCODE_DRV_GP1_SET,
                                     CSR_UCODE_SW_BIT_RFKILL);
                         spin_unlock_irqrestore(&priv->lock, flags);
                         iwl3945_send_card_state(priv, CARD_STATE_CMD_DISABLE, 0);
@@ -2673,7 +2673,7 @@ static void iwl3945_radio_kill_sw(struct iwl_priv *priv, int disable_radio)
         }
 
         spin_lock_irqsave(&priv->lock, flags);
-        iwl3945_write32(priv, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL);
+        iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL);
 
         clear_bit(STATUS_RF_KILL_SW, &priv->status);
         spin_unlock_irqrestore(&priv->lock, flags);
@@ -2682,9 +2682,9 @@ static void iwl3945_radio_kill_sw(struct iwl_priv *priv, int disable_radio)
         msleep(10);
 
         spin_lock_irqsave(&priv->lock, flags);
-        iwl3945_read32(priv, CSR_UCODE_DRV_GP1);
-        if (!iwl3945_grab_nic_access(priv))
-                iwl3945_release_nic_access(priv);
+        iwl_read32(priv, CSR_UCODE_DRV_GP1);
+        if (!iwl_grab_nic_access(priv))
+                iwl_release_nic_access(priv);
         spin_unlock_irqrestore(&priv->lock, flags);
 
         if (test_bit(STATUS_RF_KILL_HW, &priv->status)) {
@@ -3151,7 +3151,7 @@ static void iwl3945_rx_card_state_notif(struct iwl_priv *priv,
                           (flags & HW_CARD_DISABLED) ? "Kill" : "On",
                           (flags & SW_CARD_DISABLED) ? "Kill" : "On");
 
-        iwl3945_write32(priv, CSR_UCODE_DRV_GP1_SET,
+        iwl_write32(priv, CSR_UCODE_DRV_GP1_SET,
                     CSR_UCODE_DRV_GP1_BIT_CMD_BLOCKED);
 
         if (flags & HW_CARD_DISABLED)
@@ -3386,27 +3386,27 @@ int iwl3945_rx_queue_update_write_ptr(struct iwl_priv *priv, struct iwl_rx_queue
 
         /* If power-saving is in use, make sure device is awake */
         if (test_bit(STATUS_POWER_PMI, &priv->status)) {
-                reg = iwl3945_read32(priv, CSR_UCODE_DRV_GP1);
+                reg = iwl_read32(priv, CSR_UCODE_DRV_GP1);
 
                 if (reg & CSR_UCODE_DRV_GP1_BIT_MAC_SLEEP) {
-                        iwl3945_set_bit(priv, CSR_GP_CNTRL,
+                        iwl_set_bit(priv, CSR_GP_CNTRL,
                                     CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ);
                         goto exit_unlock;
                 }
 
-                rc = iwl3945_grab_nic_access(priv);
+                rc = iwl_grab_nic_access(priv);
                 if (rc)
                         goto exit_unlock;
 
                 /* Device expects a multiple of 8 */
-                iwl3945_write_direct32(priv, FH39_RSCSR_CHNL0_WPTR,
+                iwl_write_direct32(priv, FH39_RSCSR_CHNL0_WPTR,
                                      q->write & ~0x7);
-                iwl3945_release_nic_access(priv);
+                iwl_release_nic_access(priv);
 
         /* Else device is assumed to be awake */
         } else
                 /* Device expects a multiple of 8 */
-                iwl3945_write32(priv, FH39_RSCSR_CHNL0_WPTR, q->write & ~0x7);
+                iwl_write32(priv, FH39_RSCSR_CHNL0_WPTR, q->write & ~0x7);
 
 
         q->need_update = 0;
@@ -3843,27 +3843,27 @@ static int iwl3945_tx_queue_update_write_ptr(struct iwl_priv *priv,
                 /* wake up nic if it's powered down ...
                  * uCode will wake up, and interrupt us again, so next
                  * time we'll skip this part. */
-                reg = iwl3945_read32(priv, CSR_UCODE_DRV_GP1);
+                reg = iwl_read32(priv, CSR_UCODE_DRV_GP1);
 
                 if (reg & CSR_UCODE_DRV_GP1_BIT_MAC_SLEEP) {
                         IWL_DEBUG_INFO("Requesting wakeup, GP1 = 0x%x\n", reg);
-                        iwl3945_set_bit(priv, CSR_GP_CNTRL,
+                        iwl_set_bit(priv, CSR_GP_CNTRL,
                                     CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ);
                         return rc;
                 }
 
                 /* restore this queue's parameters in nic hardware. */
-                rc = iwl3945_grab_nic_access(priv);
+                rc = iwl_grab_nic_access(priv);
                 if (rc)
                         return rc;
-                iwl3945_write_direct32(priv, HBUS_TARG_WRPTR,
+                iwl_write_direct32(priv, HBUS_TARG_WRPTR,
                                      txq->q.write_ptr | (txq_id << 8));
-                iwl3945_release_nic_access(priv);
+                iwl_release_nic_access(priv);
 
         /* else not in power-save mode, uCode will never sleep when we're
          * trying to tx (during RFKILL, we're not trying to tx). */
         } else
-                iwl3945_write32(priv, HBUS_TARG_WRPTR,
+                iwl_write32(priv, HBUS_TARG_WRPTR,
                             txq->q.write_ptr | (txq_id << 8));
 
         txq->need_update = 0;
@@ -3895,7 +3895,7 @@ static void iwl3945_enable_interrupts(struct iwl_priv *priv)
 {
         IWL_DEBUG_ISR("Enabling interrupts\n");
         set_bit(STATUS_INT_ENABLED, &priv->status);
-        iwl3945_write32(priv, CSR_INT_MASK, CSR_INI_SET_MASK);
+        iwl_write32(priv, CSR_INT_MASK, CSR_INI_SET_MASK);
 }
 
 
@@ -3913,12 +3913,12 @@ static inline void iwl3945_disable_interrupts(struct iwl_priv *priv)
         clear_bit(STATUS_INT_ENABLED, &priv->status);
 
         /* disable interrupts from uCode/NIC to host */
-        iwl3945_write32(priv, CSR_INT_MASK, 0x00000000);
+        iwl_write32(priv, CSR_INT_MASK, 0x00000000);
 
         /* acknowledge/clear/reset any interrupts still pending
          * from uCode or flow handler (Rx/Tx DMA) */
-        iwl3945_write32(priv, CSR_INT, 0xffffffff);
-        iwl3945_write32(priv, CSR_FH_INT_STATUS, 0xffffffff);
+        iwl_write32(priv, CSR_INT, 0xffffffff);
+        iwl_write32(priv, CSR_FH_INT_STATUS, 0xffffffff);
         IWL_DEBUG_ISR("Disabled interrupts\n");
 }
 
@@ -3959,13 +3959,13 @@ static void iwl3945_dump_nic_error_log(struct iwl_priv *priv)
                 return;
         }
 
-        rc = iwl3945_grab_nic_access(priv);
+        rc = iwl_grab_nic_access(priv);
         if (rc) {
                 IWL_WARNING("Can not read from adapter at this time.\n");
                 return;
         }
 
-        count = iwl3945_read_targ_mem(priv, base);
+        count = iwl_read_targ_mem(priv, base);
 
         if (ERROR_START_OFFSET <= count * ERROR_ELEM_SIZE) {
                 IWL_ERROR("Start IWL Error Log Dump:\n");
@@ -3977,19 +3977,19 @@ static void iwl3945_dump_nic_error_log(struct iwl_priv *priv)
         for (i = ERROR_START_OFFSET;
              i < (count * ERROR_ELEM_SIZE) + ERROR_START_OFFSET;
              i += ERROR_ELEM_SIZE) {
-                desc = iwl3945_read_targ_mem(priv, base + i);
+                desc = iwl_read_targ_mem(priv, base + i);
                 time =
-                    iwl3945_read_targ_mem(priv, base + i + 1 * sizeof(u32));
+                    iwl_read_targ_mem(priv, base + i + 1 * sizeof(u32));
                 blink1 =
-                    iwl3945_read_targ_mem(priv, base + i + 2 * sizeof(u32));
+                    iwl_read_targ_mem(priv, base + i + 2 * sizeof(u32));
                 blink2 =
-                    iwl3945_read_targ_mem(priv, base + i + 3 * sizeof(u32));
+                    iwl_read_targ_mem(priv, base + i + 3 * sizeof(u32));
                 ilink1 =
-                    iwl3945_read_targ_mem(priv, base + i + 4 * sizeof(u32));
+                    iwl_read_targ_mem(priv, base + i + 4 * sizeof(u32));
                 ilink2 =
-                    iwl3945_read_targ_mem(priv, base + i + 5 * sizeof(u32));
+                    iwl_read_targ_mem(priv, base + i + 5 * sizeof(u32));
                 data1 =
-                    iwl3945_read_targ_mem(priv, base + i + 6 * sizeof(u32));
+                    iwl_read_targ_mem(priv, base + i + 6 * sizeof(u32));
 
                 IWL_ERROR
                     ("%-13s (#%d) %010u 0x%05X 0x%05X 0x%05X 0x%05X %u\n\n",
@@ -3997,7 +3997,7 @@ static void iwl3945_dump_nic_error_log(struct iwl_priv *priv)
                      ilink1, ilink2, data1);
         }
 
-        iwl3945_release_nic_access(priv);
+        iwl_release_nic_access(priv);
 
 }
 
@@ -4006,7 +4006,7 @@ static void iwl3945_dump_nic_error_log(struct iwl_priv *priv)
 /**
  * iwl3945_print_event_log - Dump error event log to syslog
  *
- * NOTE: Must be called with iwl3945_grab_nic_access() already obtained!
+ * NOTE: Must be called with iwl_grab_nic_access() already obtained!
  */
 static void iwl3945_print_event_log(struct iwl_priv *priv, u32 start_idx,
                                 u32 num_events, u32 mode)
@@ -4032,14 +4032,14 @@ static void iwl3945_print_event_log(struct iwl_priv *priv, u32 start_idx,
         /* "time" is actually "data" for mode 0 (no timestamp).
          * place event id # at far right for easier visual parsing. */
         for (i = 0; i < num_events; i++) {
-                ev = iwl3945_read_targ_mem(priv, ptr);
+                ev = iwl_read_targ_mem(priv, ptr);
                 ptr += sizeof(u32);
-                time = iwl3945_read_targ_mem(priv, ptr);
+                time = iwl_read_targ_mem(priv, ptr);
                 ptr += sizeof(u32);
                 if (mode == 0)
                         IWL_ERROR("0x%08x\t%04u\n", time, ev); /* data, ev */
                 else {
-                        data = iwl3945_read_targ_mem(priv, ptr);
+                        data = iwl_read_targ_mem(priv, ptr);
                         ptr += sizeof(u32);
                         IWL_ERROR("%010u\t0x%08x\t%04u\n", time, data, ev);
                 }
@@ -4062,24 +4062,24 @@ static void iwl3945_dump_nic_event_log(struct iwl_priv *priv)
                 return;
         }
 
-        rc = iwl3945_grab_nic_access(priv);
+        rc = iwl_grab_nic_access(priv);
         if (rc) {
                 IWL_WARNING("Can not read from adapter at this time.\n");
                 return;
         }
 
         /* event log header */
-        capacity = iwl3945_read_targ_mem(priv, base);
-        mode = iwl3945_read_targ_mem(priv, base + (1 * sizeof(u32)));
-        num_wraps = iwl3945_read_targ_mem(priv, base + (2 * sizeof(u32)));
-        next_entry = iwl3945_read_targ_mem(priv, base + (3 * sizeof(u32)));
+        capacity = iwl_read_targ_mem(priv, base);
+        mode = iwl_read_targ_mem(priv, base + (1 * sizeof(u32)));
+        num_wraps = iwl_read_targ_mem(priv, base + (2 * sizeof(u32)));
+        next_entry = iwl_read_targ_mem(priv, base + (3 * sizeof(u32)));
 
         size = num_wraps ? capacity : next_entry;
 
         /* bail out if nothing in log */
         if (size == 0) {
                 IWL_ERROR("Start IWL Event Log Dump: nothing in log\n");
-                iwl3945_release_nic_access(priv);
+                iwl_release_nic_access(priv);
                 return;
         }
 
@@ -4095,7 +4095,7 @@ static void iwl3945_dump_nic_event_log(struct iwl_priv *priv)
         /* (then/else) start at top of log */
         iwl3945_print_event_log(priv, 0, next_entry, mode);
 
-        iwl3945_release_nic_access(priv);
+        iwl_release_nic_access(priv);
 }
 
 /**
@@ -4167,19 +4167,19 @@ static void iwl3945_irq_tasklet(struct iwl_priv *priv)
         /* Ack/clear/reset pending uCode interrupts.
          * Note:  Some bits in CSR_INT are "OR" of bits in CSR_FH_INT_STATUS,
          *  and will clear only when CSR_FH_INT_STATUS gets cleared. */
-        inta = iwl3945_read32(priv, CSR_INT);
-        iwl3945_write32(priv, CSR_INT, inta);
+        inta = iwl_read32(priv, CSR_INT);
+        iwl_write32(priv, CSR_INT, inta);
 
         /* Ack/clear/reset pending flow-handler (DMA) interrupts.
          * Any new interrupts that happen after this, either while we're
          * in this tasklet, or later, will show up in next ISR/tasklet. */
-        inta_fh = iwl3945_read32(priv, CSR_FH_INT_STATUS);
-        iwl3945_write32(priv, CSR_FH_INT_STATUS, inta_fh);
+        inta_fh = iwl_read32(priv, CSR_FH_INT_STATUS);
+        iwl_write32(priv, CSR_FH_INT_STATUS, inta_fh);
 
 #ifdef CONFIG_IWL3945_DEBUG
         if (priv->debug_level & IWL_DL_ISR) {
                 /* just for debug */
-                inta_mask = iwl3945_read32(priv, CSR_INT_MASK);
+                inta_mask = iwl_read32(priv, CSR_INT_MASK);
                 IWL_DEBUG_ISR("inta 0x%08x, enabled 0x%08x, fh 0x%08x\n",
                               inta, inta_mask, inta_fh);
         }
@@ -4258,11 +4258,11 @@ static void iwl3945_irq_tasklet(struct iwl_priv *priv)
         if (inta & CSR_INT_BIT_FH_TX) {
                 IWL_DEBUG_ISR("Tx interrupt\n");
 
-                iwl3945_write32(priv, CSR_FH_INT_STATUS, (1 << 6));
-                if (!iwl3945_grab_nic_access(priv)) {
-                        iwl3945_write_direct32(priv, FH39_TCSR_CREDIT
+                iwl_write32(priv, CSR_FH_INT_STATUS, (1 << 6));
+                if (!iwl_grab_nic_access(priv)) {
+                        iwl_write_direct32(priv, FH39_TCSR_CREDIT
                                              (FH39_SRVC_CHNL), 0x0);
-                        iwl3945_release_nic_access(priv);
+                        iwl_release_nic_access(priv);
                 }
                 handled |= CSR_INT_BIT_FH_TX;
         }
@@ -4283,9 +4283,9 @@ static void iwl3945_irq_tasklet(struct iwl_priv *priv)
 
 #ifdef CONFIG_IWL3945_DEBUG
         if (priv->debug_level & (IWL_DL_ISR)) {
-                inta = iwl3945_read32(priv, CSR_INT);
-                inta_mask = iwl3945_read32(priv, CSR_INT_MASK);
-                inta_fh = iwl3945_read32(priv, CSR_FH_INT_STATUS);
+                inta = iwl_read32(priv, CSR_INT);
+                inta_mask = iwl_read32(priv, CSR_INT_MASK);
+                inta_fh = iwl_read32(priv, CSR_FH_INT_STATUS);
                 IWL_DEBUG_ISR("End inta 0x%08x, enabled 0x%08x, fh 0x%08x, "
                         "flags 0x%08lx\n", inta, inta_mask, inta_fh, flags);
         }
@@ -4307,12 +4307,12 @@ static irqreturn_t iwl3945_isr(int irq, void *data)
          *    back-to-back ISRs and sporadic interrupts from our NIC.
          * If we have something to service, the tasklet will re-enable ints.
          * If we *don't* have something, we'll re-enable before leaving here. */
-        inta_mask = iwl3945_read32(priv, CSR_INT_MASK);  /* just for debug */
-        iwl3945_write32(priv, CSR_INT_MASK, 0x00000000);
+        inta_mask = iwl_read32(priv, CSR_INT_MASK);  /* just for debug */
+        iwl_write32(priv, CSR_INT_MASK, 0x00000000);
 
         /* Discover which interrupts are active/pending */
-        inta = iwl3945_read32(priv, CSR_INT);
-        inta_fh = iwl3945_read32(priv, CSR_FH_INT_STATUS);
+        inta = iwl_read32(priv, CSR_INT);
+        inta_fh = iwl_read32(priv, CSR_FH_INT_STATUS);
 
         /* Ignore interrupt if there's nothing in NIC to service.
          * This may be due to IRQ shared with another device,
@@ -4937,11 +4937,11 @@ static int iwl3945_verify_inst_full(struct iwl_priv *priv, __le32 *image, u32 le
 
         IWL_DEBUG_INFO("ucode inst image size is %u\n", len);
 
-        rc = iwl3945_grab_nic_access(priv);
+        rc = iwl_grab_nic_access(priv);
         if (rc)
                 return rc;
 
-        iwl3945_write_direct32(priv, HBUS_TARG_MEM_RADDR,
+        iwl_write_direct32(priv, HBUS_TARG_MEM_RADDR,
                                IWL39_RTC_INST_LOWER_BOUND);
 
         errcnt = 0;
@@ -4949,7 +4949,7 @@ static int iwl3945_verify_inst_full(struct iwl_priv *priv, __le32 *image, u32 le
                 /* read data comes through single port, auto-incr addr */
                 /* NOTE: Use the debugless read so we don't flood kernel log
                  * if IWL_DL_IO is set */
-                val = _iwl3945_read_direct32(priv, HBUS_TARG_MEM_RDAT);
+                val = _iwl_read_direct32(priv, HBUS_TARG_MEM_RDAT);
                 if (val != le32_to_cpu(*image)) {
                         IWL_ERROR("uCode INST section is invalid at "
                                   "offset 0x%x, is 0x%x, s/b 0x%x\n",
@@ -4961,7 +4961,7 @@ static int iwl3945_verify_inst_full(struct iwl_priv *priv, __le32 *image, u32 le
                 }
         }
 
-        iwl3945_release_nic_access(priv);
+        iwl_release_nic_access(priv);
 
         if (!errcnt)
                 IWL_DEBUG_INFO("ucode image in INSTRUCTION memory is good\n");
@@ -4984,7 +4984,7 @@ static int iwl3945_verify_inst_sparse(struct iwl_priv *priv, __le32 *image, u32
 
         IWL_DEBUG_INFO("ucode inst image size is %u\n", len);
 
-        rc = iwl3945_grab_nic_access(priv);
+        rc = iwl_grab_nic_access(priv);
         if (rc)
                 return rc;
 
@@ -4992,9 +4992,9 @@ static int iwl3945_verify_inst_sparse(struct iwl_priv *priv, __le32 *image, u32
                 /* read data comes through single port, auto-incr addr */
                 /* NOTE: Use the debugless read so we don't flood kernel log
                  * if IWL_DL_IO is set */
-                iwl3945_write_direct32(priv, HBUS_TARG_MEM_RADDR,
+                iwl_write_direct32(priv, HBUS_TARG_MEM_RADDR,
                         i + IWL39_RTC_INST_LOWER_BOUND);
-                val = _iwl3945_read_direct32(priv, HBUS_TARG_MEM_RDAT);
+                val = _iwl_read_direct32(priv, HBUS_TARG_MEM_RDAT);
                 if (val != le32_to_cpu(*image)) {
 #if 0 /* Enable this if you want to see details */
                         IWL_ERROR("uCode INST section is invalid at "
@@ -5008,7 +5008,7 @@ static int iwl3945_verify_inst_sparse(struct iwl_priv *priv, __le32 *image, u32
                 }
         }
 
-        iwl3945_release_nic_access(priv);
+        iwl_release_nic_access(priv);
 
         return rc;
 }
@@ -5075,11 +5075,11 @@ static int iwl3945_verify_bsm(struct iwl_priv *priv)
         IWL_DEBUG_INFO("Begin verify bsm\n");
 
         /* verify BSM SRAM contents */
-        val = iwl3945_read_prph(priv, BSM_WR_DWCOUNT_REG);
+        val = iwl_read_prph(priv, BSM_WR_DWCOUNT_REG);
         for (reg = BSM_SRAM_LOWER_BOUND;
              reg < BSM_SRAM_LOWER_BOUND + len;
              reg += sizeof(u32), image++) {
-                val = iwl3945_read_prph(priv, reg);
+                val = iwl_read_prph(priv, reg);
                 if (val != le32_to_cpu(*image)) {
                         IWL_ERROR("BSM uCode verification failed at "
                                   "addr 0x%08X+%u (of %u), is 0x%x, s/b 0x%x\n",
@@ -5156,42 +5156,42 @@ static int iwl3945_load_bsm(struct iwl_priv *priv)
         inst_len = priv->ucode_init.len;
         data_len = priv->ucode_init_data.len;
 
-        rc = iwl3945_grab_nic_access(priv);
+        rc = iwl_grab_nic_access(priv);
         if (rc)
                 return rc;
 
-        iwl3945_write_prph(priv, BSM_DRAM_INST_PTR_REG, pinst);
-        iwl3945_write_prph(priv, BSM_DRAM_DATA_PTR_REG, pdata);
-        iwl3945_write_prph(priv, BSM_DRAM_INST_BYTECOUNT_REG, inst_len);
-        iwl3945_write_prph(priv, BSM_DRAM_DATA_BYTECOUNT_REG, data_len);
+        iwl_write_prph(priv, BSM_DRAM_INST_PTR_REG, pinst);
+        iwl_write_prph(priv, BSM_DRAM_DATA_PTR_REG, pdata);
+        iwl_write_prph(priv, BSM_DRAM_INST_BYTECOUNT_REG, inst_len);
+        iwl_write_prph(priv, BSM_DRAM_DATA_BYTECOUNT_REG, data_len);
 
         /* Fill BSM memory with bootstrap instructions */
         for (reg_offset = BSM_SRAM_LOWER_BOUND;
              reg_offset < BSM_SRAM_LOWER_BOUND + len;
              reg_offset += sizeof(u32), image++)
-                _iwl3945_write_prph(priv, reg_offset,
+                _iwl_write_prph(priv, reg_offset,
                                           le32_to_cpu(*image));
 
         rc = iwl3945_verify_bsm(priv);
         if (rc) {
-                iwl3945_release_nic_access(priv);
+                iwl_release_nic_access(priv);
                 return rc;
         }
 
         /* Tell BSM to copy from BSM SRAM into instruction SRAM, when asked */
-        iwl3945_write_prph(priv, BSM_WR_MEM_SRC_REG, 0x0);
-        iwl3945_write_prph(priv, BSM_WR_MEM_DST_REG,
+        iwl_write_prph(priv, BSM_WR_MEM_SRC_REG, 0x0);
+        iwl_write_prph(priv, BSM_WR_MEM_DST_REG,
                                  IWL39_RTC_INST_LOWER_BOUND);
-        iwl3945_write_prph(priv, BSM_WR_DWCOUNT_REG, len / sizeof(u32));
+        iwl_write_prph(priv, BSM_WR_DWCOUNT_REG, len / sizeof(u32));
 
         /* Load bootstrap code into instruction SRAM now,
          *   to prepare to load "initialize" uCode */
-        iwl3945_write_prph(priv, BSM_WR_CTRL_REG,
+        iwl_write_prph(priv, BSM_WR_CTRL_REG,
                 BSM_WR_CTRL_REG_BIT_START);
 
         /* Wait for load of bootstrap uCode to finish */
         for (i = 0; i < 100; i++) {
-                done = iwl3945_read_prph(priv, BSM_WR_CTRL_REG);
+                done = iwl_read_prph(priv, BSM_WR_CTRL_REG);
                 if (!(done & BSM_WR_CTRL_REG_BIT_START))
                         break;
                 udelay(10);
@@ -5205,10 +5205,10 @@ static int iwl3945_load_bsm(struct iwl_priv *priv)
 
         /* Enable future boot loads whenever power management unit triggers it
          *   (e.g. when powering back up after power-save shutdown) */
-        iwl3945_write_prph(priv, BSM_WR_CTRL_REG,
+        iwl_write_prph(priv, BSM_WR_CTRL_REG,
                 BSM_WR_CTRL_REG_BIT_START_EN);
 
-        iwl3945_release_nic_access(priv);
+        iwl_release_nic_access(priv);
 
         return 0;
 }
@@ -5216,7 +5216,7 @@ static int iwl3945_load_bsm(struct iwl_priv *priv)
 static void iwl3945_nic_start(struct iwl_priv *priv)
 {
         /* Remove all resets to allow NIC to operate */
-        iwl3945_write32(priv, CSR_RESET, 0);
+        iwl_write32(priv, CSR_RESET, 0);
 }
 
 /**
@@ -5477,24 +5477,24 @@ static int iwl3945_set_ucode_ptrs(struct iwl_priv *priv)
         pdata = priv->ucode_data_backup.p_addr;
 
         spin_lock_irqsave(&priv->lock, flags);
-        rc = iwl3945_grab_nic_access(priv);
+        rc = iwl_grab_nic_access(priv);
         if (rc) {
                 spin_unlock_irqrestore(&priv->lock, flags);
                 return rc;
         }
 
         /* Tell bootstrap uCode where to find image to load */
-        iwl3945_write_prph(priv, BSM_DRAM_INST_PTR_REG, pinst);
-        iwl3945_write_prph(priv, BSM_DRAM_DATA_PTR_REG, pdata);
-        iwl3945_write_prph(priv, BSM_DRAM_DATA_BYTECOUNT_REG,
+        iwl_write_prph(priv, BSM_DRAM_INST_PTR_REG, pinst);
+        iwl_write_prph(priv, BSM_DRAM_DATA_PTR_REG, pdata);
+        iwl_write_prph(priv, BSM_DRAM_DATA_BYTECOUNT_REG,
                                  priv->ucode_data.len);
 
         /* Inst byte count must be last to set up, bit 31 signals uCode
          *   that all new ptr/size info is in place */
-        iwl3945_write_prph(priv, BSM_DRAM_INST_BYTECOUNT_REG,
+        iwl_write_prph(priv, BSM_DRAM_INST_BYTECOUNT_REG,
                                  priv->ucode_code.len | BSM_DRAM_INST_LOAD);
 
-        iwl3945_release_nic_access(priv);
+        iwl_release_nic_access(priv);
 
         spin_unlock_irqrestore(&priv->lock, flags);
 
@@ -5583,15 +5583,15 @@ static void iwl3945_alive_start(struct iwl_priv *priv)
 
         iwl3945_clear_stations_table(priv);
 
-        rc = iwl3945_grab_nic_access(priv);
+        rc = iwl_grab_nic_access(priv);
         if (rc) {
                 IWL_WARNING("Can not read RFKILL status from adapter\n");
                 return;
         }
 
-        rfkill = iwl3945_read_prph(priv, APMG_RFKILL_REG);
+        rfkill = iwl_read_prph(priv, APMG_RFKILL_REG);
         IWL_DEBUG_INFO("RFKILL status: 0x%x\n", rfkill);
-        iwl3945_release_nic_access(priv);
+        iwl_release_nic_access(priv);
 
         if (rfkill & 0x1) {
                 clear_bit(STATUS_RF_KILL_HW, &priv->status);
@@ -5695,7 +5695,7 @@ static void __iwl3945_down(struct iwl_priv *priv)
                 clear_bit(STATUS_EXIT_PENDING, &priv->status);
 
         /* stop and reset the on-board processor */
-        iwl3945_write32(priv, CSR_RESET, CSR_RESET_REG_FLAG_NEVO_RESET);
+        iwl_write32(priv, CSR_RESET, CSR_RESET_REG_FLAG_NEVO_RESET);
 
         /* tell the device to stop sending interrupts */
         spin_lock_irqsave(&priv->lock, flags);
@@ -5738,24 +5738,24 @@ static void __iwl3945_down(struct iwl_priv *priv)
                                 STATUS_EXIT_PENDING;
 
         spin_lock_irqsave(&priv->lock, flags);
-        iwl3945_clear_bit(priv, CSR_GP_CNTRL, CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ);
+        iwl_clear_bit(priv, CSR_GP_CNTRL, CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ);
         spin_unlock_irqrestore(&priv->lock, flags);
 
         iwl3945_hw_txq_ctx_stop(priv);
         iwl3945_hw_rxq_stop(priv);
 
         spin_lock_irqsave(&priv->lock, flags);
-        if (!iwl3945_grab_nic_access(priv)) {
-                iwl3945_write_prph(priv, APMG_CLK_DIS_REG,
+        if (!iwl_grab_nic_access(priv)) {
+                iwl_write_prph(priv, APMG_CLK_DIS_REG,
                                          APMG_CLK_VAL_DMA_CLK_RQT);
-                iwl3945_release_nic_access(priv);
+                iwl_release_nic_access(priv);
         }
         spin_unlock_irqrestore(&priv->lock, flags);
 
         udelay(5);
 
         iwl3945_hw_nic_stop_master(priv);
-        iwl3945_set_bit(priv, CSR_RESET, CSR_RESET_REG_FLAG_SW_RESET);
+        iwl_set_bit(priv, CSR_RESET, CSR_RESET_REG_FLAG_SW_RESET);
         iwl3945_hw_nic_reset(priv);
 
  exit:
@@ -5801,7 +5801,7 @@ static int __iwl3945_up(struct iwl_priv *priv)
         }
 
         /* If platform's RF_KILL switch is NOT set to KILL */
-        if (iwl3945_read32(priv, CSR_GP_CNTRL) &
+        if (iwl_read32(priv, CSR_GP_CNTRL) &
                                 CSR_GP_CNTRL_REG_FLAG_HW_RF_KILL_SW)
                 clear_bit(STATUS_RF_KILL_HW, &priv->status);
         else {
@@ -5812,7 +5812,7 @@ static int __iwl3945_up(struct iwl_priv *priv)
                 }
         }
 
-        iwl3945_write32(priv, CSR_INT, 0xFFFFFFFF);
+        iwl_write32(priv, CSR_INT, 0xFFFFFFFF);
 
         rc = iwl3945_hw_nic_init(priv);
         if (rc) {
@@ -5821,17 +5821,17 @@ static int __iwl3945_up(struct iwl_priv *priv)
         }
 
         /* make sure rfkill handshake bits are cleared */
-        iwl3945_write32(priv, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL);
-        iwl3945_write32(priv, CSR_UCODE_DRV_GP1_CLR,
+        iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL);
+        iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR,
                     CSR_UCODE_DRV_GP1_BIT_CMD_BLOCKED);
 
         /* clear (again), then enable host interrupts */
-        iwl3945_write32(priv, CSR_INT, 0xFFFFFFFF);
+        iwl_write32(priv, CSR_INT, 0xFFFFFFFF);
         iwl3945_enable_interrupts(priv);
 
         /* really make sure rfkill handshake bits are cleared */
-        iwl3945_write32(priv, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL);
-        iwl3945_write32(priv, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL);
+        iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL);
+        iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL);
 
         /* Copy original ucode data image from disk into backup cache.
          * This will be used to initialize the on-board processor's
@@ -7819,11 +7819,11 @@ static int iwl3945_pci_probe(struct pci_dev *pdev, const struct pci_device_id *e
         pci_write_config_byte(pdev, 0x41, 0x00);
 
         /* nic init */
-        iwl3945_set_bit(priv, CSR_GIO_CHICKEN_BITS,
+        iwl_set_bit(priv, CSR_GIO_CHICKEN_BITS,
                         CSR_GIO_CHICKEN_BITS_REG_BIT_DIS_L0S_EXIT_TIMER);
 
-        iwl3945_set_bit(priv, CSR_GP_CNTRL, CSR_GP_CNTRL_REG_FLAG_INIT_DONE);
-        err = iwl3945_poll_direct_bit(priv, CSR_GP_CNTRL,
+        iwl_set_bit(priv, CSR_GP_CNTRL, CSR_GP_CNTRL_REG_FLAG_INIT_DONE);
+        err = iwl_poll_direct_bit(priv, CSR_GP_CNTRL,
                                 CSR_GP_CNTRL_REG_FLAG_MAC_CLOCK_READY, 25000);
         if (err < 0) {
                 IWL_DEBUG_INFO("Failed to init the card\n");