iwl_write32(trans, CSR_RESET, 0);
 }
 
-static int iwl_trans_pcie_request_irq(struct iwl_trans *trans)
+static int iwl_trans_pcie_start_hw(struct iwl_trans *trans)
 {
        struct iwl_trans_pcie *trans_pcie =
                IWL_TRANS_GET_PCIE_TRANS(trans);
 
        trans_pcie->inta_mask = CSR_INI_SET_MASK;
 
-       tasklet_init(&trans_pcie->irq_tasklet, (void (*)(unsigned long))
-               iwl_irq_tasklet, (unsigned long)trans);
+       if (!trans_pcie->irq_requested) {
+               tasklet_init(&trans_pcie->irq_tasklet, (void (*)(unsigned long))
+                       iwl_irq_tasklet, (unsigned long)trans);
 
-       iwl_alloc_isr_ict(trans);
+               iwl_alloc_isr_ict(trans);
 
-       err = request_irq(trans->irq, iwl_isr_ict, IRQF_SHARED,
-               DRV_NAME, trans);
-       if (err) {
-               IWL_ERR(trans, "Error allocating IRQ %d\n", trans->irq);
-               iwl_free_isr_ict(trans);
-               return err;
+               err = request_irq(trans->irq, iwl_isr_ict, IRQF_SHARED,
+                       DRV_NAME, trans);
+               if (err) {
+                       IWL_ERR(trans, "Error allocating IRQ %d\n",
+                               trans->irq);
+                       iwl_free_isr_ict(trans);
+                       tasklet_kill(&trans_pcie->irq_tasklet);
+                       return err;
+               }
+
+               INIT_WORK(&trans_pcie->rx_replenish, iwl_bg_rx_replenish);
+               trans_pcie->irq_requested = true;
        }
 
-       INIT_WORK(&trans_pcie->rx_replenish, iwl_bg_rx_replenish);
        return 0;
 }
 
 #ifndef CONFIG_IWLWIFI_IDI
        iwl_trans_pcie_rx_free(trans);
 #endif
-       free_irq(trans->irq, trans);
-       iwl_free_isr_ict(trans);
+       if (trans_pcie->irq_requested == true) {
+               free_irq(trans->irq, trans);
+               iwl_free_isr_ict(trans);
+       }
 
        pci_disable_msi(trans_pcie->pci_dev);
        pci_iounmap(trans_pcie->pci_dev, trans_pcie->hw_base);
 #endif /*CONFIG_IWLWIFI_DEBUGFS */
 
 const struct iwl_trans_ops trans_ops_pcie = {
-       .request_irq = iwl_trans_pcie_request_irq,
+       .start_hw = iwl_trans_pcie_start_hw,
        .fw_alive = iwl_trans_pcie_fw_alive,
        .start_device = iwl_trans_pcie_start_device,
        .prepare_card_hw = iwl_trans_pcie_prepare_card_hw,
 
 
 /**
  * struct iwl_trans_ops - transport specific operations
- * @request_irq: requests IRQ - will be called before the FW load in probe flow
+ * @start_hw: starts the HW- from that point on, the HW can send interrupts
  * @start_device: allocates and inits all the resources for the transport
  *                layer.
  * @prepare_card_hw: claim the ownership on the HW. Will be called during
  */
 struct iwl_trans_ops {
 
-       int (*request_irq)(struct iwl_trans *iwl_trans);
+       int (*start_hw)(struct iwl_trans *iwl_trans);
        int (*start_device)(struct iwl_trans *trans);
        void (*fw_alive)(struct iwl_trans *trans);
        int (*prepare_card_hw)(struct iwl_trans *trans);
        char trans_specific[0] __attribute__((__aligned__(sizeof(void *))));
 };
 
-static inline int iwl_trans_request_irq(struct iwl_trans *trans)
+static inline int iwl_trans_start_hw(struct iwl_trans *trans)
 {
-       return trans->ops->request_irq(trans);
+       return trans->ops->start_hw(trans);
 }
 
 static inline void iwl_trans_fw_alive(struct iwl_trans *trans)