iwlwifi: op_mode holds its pointer to the transport

Instead of using the shared area that we be killed.

Signed-off-by: Emmanuel Grumbach <emmanuel.grumbach@intel.com>
Signed-off-by: Wey-Yi Guy <wey-yi.w.guy@intel.com>

1 files changed, 16 insertions, 16 deletions

diff --git a/drivers/net/wireless/iwlwifi/iwl-eeprom.c b/drivers/net/wireless/iwlwifi/iwl-eeprom.c
index a004431d1a60..622a8f33d178 100644
--- a/drivers/net/wireless/iwlwifi/iwl-eeprom.c
+++ b/drivers/net/wireless/iwlwifi/iwl-eeprom.c
@@ -189,7 +189,7 @@ static void iwl_eeprom_release_semaphore(struct iwl_trans *trans)
 
 static int iwl_eeprom_verify_signature(struct iwl_priv *priv)
 {
-        u32 gp = iwl_read32(trans(priv), CSR_EEPROM_GP) &
+        u32 gp = iwl_read32(priv->trans, CSR_EEPROM_GP) &
                            CSR_EEPROM_GP_VALID_MSK;
         int ret = 0;
 
@@ -719,14 +719,14 @@ static void iwl_eeprom_enhanced_txpower(struct iwl_priv *priv)
 int iwl_eeprom_init(struct iwl_priv *priv, u32 hw_rev)
 {
         __le16 *e;
-        u32 gp = iwl_read32(trans(priv), CSR_EEPROM_GP);
+        u32 gp = iwl_read32(priv->trans, CSR_EEPROM_GP);
         int sz;
         int ret;
         u16 addr;
         u16 validblockaddr = 0;
         u16 cache_addr = 0;
 
-        priv->nvm_device_type = iwl_get_nvm_type(trans(priv), hw_rev);
+        priv->nvm_device_type = iwl_get_nvm_type(priv->trans, hw_rev);
         if (priv->nvm_device_type == -ENOENT)
                 return -ENOENT;
         /* allocate eeprom */
@@ -747,7 +747,7 @@ int iwl_eeprom_init(struct iwl_priv *priv, u32 hw_rev)
         }
 
         /* Make sure driver (instead of uCode) is allowed to read EEPROM */
-        ret = iwl_eeprom_acquire_semaphore(trans(priv));
+        ret = iwl_eeprom_acquire_semaphore(priv->trans);
         if (ret < 0) {
                 IWL_ERR(priv, "Failed to acquire EEPROM semaphore.\n");
                 ret = -ENOENT;
@@ -756,22 +756,22 @@ int iwl_eeprom_init(struct iwl_priv *priv, u32 hw_rev)
 
         if (priv->nvm_device_type == NVM_DEVICE_TYPE_OTP) {
 
-                ret = iwl_init_otp_access(trans(priv));
+                ret = iwl_init_otp_access(priv->trans);
                 if (ret) {
                         IWL_ERR(priv, "Failed to initialize OTP access.\n");
                         ret = -ENOENT;
                         goto done;
                 }
-                iwl_write32(trans(priv), CSR_EEPROM_GP,
-                            iwl_read32(trans(priv), CSR_EEPROM_GP) &
+                iwl_write32(priv->trans, CSR_EEPROM_GP,
+                            iwl_read32(priv->trans, CSR_EEPROM_GP) &
                             ~CSR_EEPROM_GP_IF_OWNER_MSK);
 
-                iwl_set_bit(trans(priv), CSR_OTP_GP_REG,
+                iwl_set_bit(priv->trans, CSR_OTP_GP_REG,
                              CSR_OTP_GP_REG_ECC_CORR_STATUS_MSK |
                              CSR_OTP_GP_REG_ECC_UNCORR_STATUS_MSK);
                 /* traversing the linked list if no shadow ram supported */
                 if (!cfg(priv)->base_params->shadow_ram_support) {
-                        if (iwl_find_otp_image(trans(priv), &validblockaddr)) {
+                        if (iwl_find_otp_image(priv->trans, &validblockaddr)) {
                                 ret = -ENOENT;
                                 goto done;
                         }
@@ -780,7 +780,7 @@ int iwl_eeprom_init(struct iwl_priv *priv, u32 hw_rev)
                      addr += sizeof(u16)) {
                         __le16 eeprom_data;
 
-                        ret = iwl_read_otp_word(trans(priv), addr,
+                        ret = iwl_read_otp_word(priv->trans, addr,
                                                 &eeprom_data);
                         if (ret)
                                 goto done;
@@ -792,10 +792,10 @@ int iwl_eeprom_init(struct iwl_priv *priv, u32 hw_rev)
                 for (addr = 0; addr < sz; addr += sizeof(u16)) {
                         u32 r;
 
-                        iwl_write32(trans(priv), CSR_EEPROM_REG,
+                        iwl_write32(priv->trans, CSR_EEPROM_REG,
                                     CSR_EEPROM_REG_MSK_ADDR & (addr << 1));
 
-                        ret = iwl_poll_bit(trans(priv), CSR_EEPROM_REG,
+                        ret = iwl_poll_bit(priv->trans, CSR_EEPROM_REG,
                                                   CSR_EEPROM_REG_READ_VALID_MSK,
                                                   CSR_EEPROM_REG_READ_VALID_MSK,
                                                   IWL_EEPROM_ACCESS_TIMEOUT);
@@ -804,7 +804,7 @@ int iwl_eeprom_init(struct iwl_priv *priv, u32 hw_rev)
                                         "Time out reading EEPROM[%d]\n", addr);
                                 goto done;
                         }
-                        r = iwl_read32(trans(priv), CSR_EEPROM_REG);
+                        r = iwl_read32(priv->trans, CSR_EEPROM_REG);
                         e[addr / 2] = cpu_to_le16(r >> 16);
                 }
         }
@@ -816,7 +816,7 @@ int iwl_eeprom_init(struct iwl_priv *priv, u32 hw_rev)
 
         ret = 0;
 done:
-        iwl_eeprom_release_semaphore(trans(priv));
+        iwl_eeprom_release_semaphore(priv->trans);
 
 err:
         if (ret)
@@ -1132,7 +1132,7 @@ void iwl_rf_config(struct iwl_priv *priv)
 
         /* write radio config values to register */
         if (EEPROM_RF_CFG_TYPE_MSK(radio_cfg) <= EEPROM_RF_CONFIG_TYPE_MAX) {
-                iwl_set_bit(trans(priv), CSR_HW_IF_CONFIG_REG,
+                iwl_set_bit(priv->trans, CSR_HW_IF_CONFIG_REG,
                             EEPROM_RF_CFG_TYPE_MSK(radio_cfg) |
                             EEPROM_RF_CFG_STEP_MSK(radio_cfg) |
                             EEPROM_RF_CFG_DASH_MSK(radio_cfg));
@@ -1144,7 +1144,7 @@ void iwl_rf_config(struct iwl_priv *priv)
                 WARN_ON(1);
 
         /* set CSR_HW_CONFIG_REG for uCode use */
-        iwl_set_bit(trans(priv), CSR_HW_IF_CONFIG_REG,
+        iwl_set_bit(priv->trans, CSR_HW_IF_CONFIG_REG,
                     CSR_HW_IF_CONFIG_REG_BIT_RADIO_SI |
                     CSR_HW_IF_CONFIG_REG_BIT_MAC_SI);
 }