return 0;
 }
 
-void iwlagn_stop_device(struct iwl_priv *priv)
-{
-       unsigned long flags;
-
-       /* stop and reset the on-board processor */
-       iwl_write32(priv, CSR_RESET, CSR_RESET_REG_FLAG_NEVO_RESET);
-
-       /* tell the device to stop sending interrupts */
-       spin_lock_irqsave(&priv->lock, flags);
-       iwl_disable_interrupts(priv);
-       spin_unlock_irqrestore(&priv->lock, flags);
-       trans_sync_irq(priv);
-
-       /* device going down, Stop using ICT table */
-       iwl_disable_ict(priv);
-
-       /*
-        * If a HW restart happens during firmware loading,
-        * then the firmware loading might call this function
-        * and later it might be called again due to the
-        * restart. So don't process again if the device is
-        * already dead.
-        */
-       if (test_bit(STATUS_DEVICE_ENABLED, &priv->status)) {
-               trans_tx_stop(priv);
-               trans_rx_stop(priv);
-
-               /* Power-down device's busmaster DMA clocks */
-               iwl_write_prph(priv, APMG_CLK_DIS_REG,
-                              APMG_CLK_VAL_DMA_CLK_RQT);
-               udelay(5);
-       }
-
-       /* Make sure (redundant) we've released our request to stay awake */
-       iwl_clear_bit(priv, CSR_GP_CNTRL, CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ);
-
-       /* Stop the device, and put it in low power state */
-       iwl_apm_stop(priv);
-}
 
        iwlagn_remove_notification(priv, &calib_wait);
  out:
        /* Whatever happened, stop the device */
-       iwlagn_stop_device(priv);
+       trans_stop_device(priv);
        return ret;
 }
 
                       test_bit(STATUS_EXIT_PENDING, &priv->status) <<
                                STATUS_EXIT_PENDING;
 
-       iwlagn_stop_device(priv);
+       trans_stop_device(priv);
 
        dev_kfree_skb(priv->beacon_skb);
        priv->beacon_skb = NULL;
 
 int iwl_prepare_card_hw(struct iwl_priv *priv);
 
 int iwlagn_start_device(struct iwl_priv *priv);
-void iwlagn_stop_device(struct iwl_priv *priv);
 
 /* tx queue */
 void iwlagn_set_wr_ptrs(struct iwl_priv *priv,
 
  * struct iwl_trans_ops - transport specific operations
 
  * @rx_init: inits the rx memory, allocate it if needed
- * @rx_stop: stop the rx
  * @rx_free: frees the rx memory
  * @tx_init:inits the tx memory, allocate if needed
- * @tx_stop: stop the tx
  * @tx_free: frees the tx memory
+ * @stop_device:stops the whole device (embedded CPU put to reset)
  * @send_cmd:send a host command
  * @send_cmd_pdu:send a host command: flags can be CMD_*
  * @get_tx_cmd: returns a pointer to a new Tx cmd for the upper layer use
  */
 struct iwl_trans_ops {
        int (*rx_init)(struct iwl_priv *priv);
-       int (*rx_stop)(struct iwl_priv *priv);
        void (*rx_free)(struct iwl_priv *priv);
 
        int (*tx_init)(struct iwl_priv *priv);
-       int (*tx_stop)(struct iwl_priv *priv);
        void (*tx_free)(struct iwl_priv *priv);
 
+       void (*stop_device)(struct iwl_priv *priv);
+
        int (*send_cmd)(struct iwl_priv *priv, struct iwl_host_cmd *cmd);
 
        int (*send_cmd_pdu)(struct iwl_priv *priv, u8 id, u32 flags, u16 len,
 
 
        case IWL_TM_CMD_APP2DEV_CFG_INIT_CALIB:
                iwl_testmode_cfg_init_calib(priv);
-               iwlagn_stop_device(priv);
+               trans_stop_device(priv);
                break;
 
        case IWL_TM_CMD_APP2DEV_LOAD_RUNTIME_FW:
 
        return 0;
 }
 
+static void iwl_trans_stop_device(struct iwl_priv *priv)
+{
+       unsigned long flags;
+
+       /* stop and reset the on-board processor */
+       iwl_write32(priv, CSR_RESET, CSR_RESET_REG_FLAG_NEVO_RESET);
+
+       /* tell the device to stop sending interrupts */
+       spin_lock_irqsave(&priv->lock, flags);
+       iwl_disable_interrupts(priv);
+       spin_unlock_irqrestore(&priv->lock, flags);
+       trans_sync_irq(priv);
+
+       /* device going down, Stop using ICT table */
+       iwl_disable_ict(priv);
+
+       /*
+        * If a HW restart happens during firmware loading,
+        * then the firmware loading might call this function
+        * and later it might be called again due to the
+        * restart. So don't process again if the device is
+        * already dead.
+        */
+       if (test_bit(STATUS_DEVICE_ENABLED, &priv->status)) {
+               iwl_trans_tx_stop(priv);
+               iwl_trans_rx_stop(priv);
+
+               /* Power-down device's busmaster DMA clocks */
+               iwl_write_prph(priv, APMG_CLK_DIS_REG,
+                              APMG_CLK_VAL_DMA_CLK_RQT);
+               udelay(5);
+       }
+
+       /* Make sure (redundant) we've released our request to stay awake */
+       iwl_clear_bit(priv, CSR_GP_CNTRL, CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ);
+
+       /* Stop the device, and put it in low power state */
+       iwl_apm_stop(priv);
+}
+
 static struct iwl_tx_cmd *iwl_trans_get_tx_cmd(struct iwl_priv *priv,
                                                int txq_id)
 {
 
 static const struct iwl_trans_ops trans_ops = {
        .rx_init = iwl_trans_rx_init,
-       .rx_stop = iwl_trans_rx_stop,
        .rx_free = iwl_trans_rx_free,
 
        .tx_init = iwl_trans_tx_init,
-       .tx_stop = iwl_trans_tx_stop,
        .tx_free = iwl_trans_tx_free,
 
+       .stop_device = iwl_trans_stop_device,
+
        .send_cmd = iwl_send_cmd,
        .send_cmd_pdu = iwl_send_cmd_pdu,
 
 
        return priv->trans.ops->rx_init(priv);
 }
 
-static inline int trans_rx_stop(struct iwl_priv *priv)
-{
-       return priv->trans.ops->rx_stop(priv);
-}
-
 static inline void trans_rx_free(struct iwl_priv *priv)
 {
        priv->trans.ops->rx_free(priv);
        return priv->trans.ops->tx_init(priv);
 }
 
-static inline int trans_tx_stop(struct iwl_priv *priv)
+static inline void trans_tx_free(struct iwl_priv *priv)
 {
-       return priv->trans.ops->tx_stop(priv);
+       priv->trans.ops->tx_free(priv);
 }
 
-static inline void trans_tx_free(struct iwl_priv *priv)
+static inline void trans_stop_device(struct iwl_priv *priv)
 {
-       priv->trans.ops->tx_free(priv);
+       priv->trans.ops->stop_device(priv);
 }
 
 static inline int trans_send_cmd(struct iwl_priv *priv,