megaraid_sas: Make adprecovery variable atomic

Make instance->adprecovery variable atomic and removes hba_lock spinlock
while accessing instance->adprecovery.

Signed-off-by: Sumit Saxena <sumit.saxena@avagotech.com>
Signed-off-by: Kashyap Desai <kashyap.desai@avagotech.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>

diff --git a/drivers/scsi/megaraid/megaraid_sas.h b/drivers/scsi/megaraid/megaraid_sas.h
index c8d25a739d38b5f05c18c540487edaff15f6d852..3e92f20b3d6284678fd71c8f674902a9be990d75 100644 (file)
--- a/drivers/scsi/megaraid/megaraid_sas.h
+++ b/drivers/scsi/megaraid/megaraid_sas.h
@@ -2101,7 +2101,7 @@ struct megasas_instance {
        u16 drv_supported_vd_count;
        u16 drv_supported_pd_count;
 
-       u8 adprecovery;
+       atomic_t adprecovery;
        unsigned long last_time;
        u32 mfiStatus;
        u32 last_seq_num;

diff --git a/drivers/scsi/megaraid/megaraid_sas_base.c b/drivers/scsi/megaraid/megaraid_sas_base.c
index 961c024d11ca6d216a8a955698b2c83817cf9414..1bd5da49b897adf0f39d68e2e478624e18cd24c3 100644 (file)
--- a/drivers/scsi/megaraid/megaraid_sas_base.c
+++ b/drivers/scsi/megaraid/megaraid_sas_base.c
@@ -483,7 +483,7 @@ static int
 megasas_check_reset_xscale(struct megasas_instance *instance,
                struct megasas_register_set __iomem *regs)
 {
-       if ((instance->adprecovery != MEGASAS_HBA_OPERATIONAL) &&
+       if ((atomic_read(&instance->adprecovery) != MEGASAS_HBA_OPERATIONAL) &&
            (le32_to_cpu(*instance->consumer) ==
                MEGASAS_ADPRESET_INPROG_SIGN))
                return 1;
@@ -619,7 +619,7 @@ static int
 megasas_check_reset_ppc(struct megasas_instance *instance,
                        struct megasas_register_set __iomem *regs)
 {
-       if (instance->adprecovery != MEGASAS_HBA_OPERATIONAL)
+       if (atomic_read(&instance->adprecovery) != MEGASAS_HBA_OPERATIONAL)
                return 1;
 
        return 0;
@@ -756,7 +756,7 @@ static int
 megasas_check_reset_skinny(struct megasas_instance *instance,
                                struct megasas_register_set __iomem *regs)
 {
-       if (instance->adprecovery != MEGASAS_HBA_OPERATIONAL)
+       if (atomic_read(&instance->adprecovery) != MEGASAS_HBA_OPERATIONAL)
                return 1;
 
        return 0;
@@ -950,9 +950,8 @@ static int
 megasas_check_reset_gen2(struct megasas_instance *instance,
                struct megasas_register_set __iomem *regs)
 {
-       if (instance->adprecovery != MEGASAS_HBA_OPERATIONAL) {
+       if (atomic_read(&instance->adprecovery) != MEGASAS_HBA_OPERATIONAL)
                return 1;
-       }
 
        return 0;
 }
@@ -998,7 +997,7 @@ megasas_issue_polled(struct megasas_instance *instance, struct megasas_cmd *cmd)
        frame_hdr->cmd_status = MFI_STAT_INVALID_STATUS;
        frame_hdr->flags |= cpu_to_le16(MFI_FRAME_DONT_POST_IN_REPLY_QUEUE);
 
-       if ((instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR) ||
+       if ((atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR) ||
                (instance->instancet->issue_dcmd(instance, cmd))) {
                dev_err(&instance->pdev->dev, "Failed from %s %d\n",
                        __func__, __LINE__);
@@ -1026,7 +1025,7 @@ megasas_issue_blocked_cmd(struct megasas_instance *instance,
        int ret = 0;
        cmd->cmd_status_drv = MFI_STAT_INVALID_STATUS;
 
-       if ((instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR) ||
+       if ((atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR) ||
                (instance->instancet->issue_dcmd(instance, cmd))) {
                dev_err(&instance->pdev->dev, "Failed from %s %d\n",
                        __func__, __LINE__);
@@ -1090,7 +1089,7 @@ megasas_issue_blocked_abort_cmd(struct megasas_instance *instance,
        cmd->sync_cmd = 1;
        cmd->cmd_status_drv = MFI_STAT_INVALID_STATUS;
 
-       if ((instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR) ||
+       if ((atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR) ||
                (instance->instancet->issue_dcmd(instance, cmd))) {
                dev_err(&instance->pdev->dev, "Failed from %s %d\n",
                        __func__, __LINE__);
@@ -1653,7 +1652,6 @@ static int
 megasas_queue_command(struct Scsi_Host *shost, struct scsi_cmnd *scmd)
 {
        struct megasas_instance *instance;
-       unsigned long flags;
        struct MR_PRIV_DEVICE *mr_device_priv_data;
 
        instance = (struct megasas_instance *)
@@ -1668,24 +1666,20 @@ megasas_queue_command(struct Scsi_Host *shost, struct scsi_cmnd *scmd)
        if (instance->issuepend_done == 0)
                return SCSI_MLQUEUE_HOST_BUSY;
 
-       spin_lock_irqsave(&instance->hba_lock, flags);
 
        /* Check for an mpio path and adjust behavior */
-       if (instance->adprecovery == MEGASAS_ADPRESET_SM_INFAULT) {
+       if (atomic_read(&instance->adprecovery) == MEGASAS_ADPRESET_SM_INFAULT) {
                if (megasas_check_mpio_paths(instance, scmd) ==
                    (DID_RESET << 16)) {
-                       spin_unlock_irqrestore(&instance->hba_lock, flags);
                        return SCSI_MLQUEUE_HOST_BUSY;
                } else {
-                       spin_unlock_irqrestore(&instance->hba_lock, flags);
                        scmd->result = DID_NO_CONNECT << 16;
                        scmd->scsi_done(scmd);
                        return 0;
                }
        }
 
-       if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR) {
-               spin_unlock_irqrestore(&instance->hba_lock, flags);
+       if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR) {
                scmd->result = DID_NO_CONNECT << 16;
                scmd->scsi_done(scmd);
                return 0;
@@ -1693,23 +1687,17 @@ megasas_queue_command(struct Scsi_Host *shost, struct scsi_cmnd *scmd)
 
        mr_device_priv_data = scmd->device->hostdata;
        if (!mr_device_priv_data) {
-               spin_unlock_irqrestore(&instance->hba_lock, flags);
                scmd->result = DID_NO_CONNECT << 16;
                scmd->scsi_done(scmd);
                return 0;
        }
 
-       if (instance->adprecovery != MEGASAS_HBA_OPERATIONAL) {
-               spin_unlock_irqrestore(&instance->hba_lock, flags);
+       if (atomic_read(&instance->adprecovery) != MEGASAS_HBA_OPERATIONAL)
                return SCSI_MLQUEUE_HOST_BUSY;
-       }
 
-       if (mr_device_priv_data->tm_busy) {
-               spin_unlock_irqrestore(&instance->hba_lock, flags);
+       if (mr_device_priv_data->tm_busy)
                return SCSI_MLQUEUE_DEVICE_BUSY;
-       }
 
-       spin_unlock_irqrestore(&instance->hba_lock, flags);
 
        scmd->result = 0;
 
@@ -1942,7 +1930,7 @@ static void megasas_complete_outstanding_ioctls(struct megasas_instance *instanc
 void megaraid_sas_kill_hba(struct megasas_instance *instance)
 {
        /* Set critical error to block I/O & ioctls in case caller didn't */
-       instance->adprecovery = MEGASAS_HW_CRITICAL_ERROR;
+       atomic_set(&instance->adprecovery, MEGASAS_HW_CRITICAL_ERROR);
        /* Wait 1 second to ensure IO or ioctls in build have posted */
        msleep(1000);
        if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
@@ -2002,7 +1990,7 @@ static void megasas_complete_cmd_dpc(unsigned long instance_addr)
        unsigned long flags;
 
        /* If we have already declared adapter dead, donot complete cmds */
-       if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR)
+       if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR)
                return;
 
        spin_lock_irqsave(&instance->completion_lock, flags);
@@ -2071,7 +2059,7 @@ void megasas_do_ocr(struct megasas_instance *instance)
                *instance->consumer = cpu_to_le32(MEGASAS_ADPRESET_INPROG_SIGN);
        }
        instance->instancet->disable_intr(instance);
-       instance->adprecovery   = MEGASAS_ADPRESET_SM_INFAULT;
+       atomic_set(&instance->adprecovery, MEGASAS_ADPRESET_SM_INFAULT);
        instance->issuepend_done = 0;
 
        atomic_set(&instance->fw_outstanding, 0);
@@ -2470,18 +2458,14 @@ static int megasas_wait_for_outstanding(struct megasas_instance *instance)
        int i;
        u32 reset_index;
        u32 wait_time = MEGASAS_RESET_WAIT_TIME;
-       u8 adprecovery;
        unsigned long flags;
        struct list_head clist_local;
        struct megasas_cmd *reset_cmd;
        u32 fw_state;
        u8 kill_adapter_flag;
 
-       spin_lock_irqsave(&instance->hba_lock, flags);
-       adprecovery = instance->adprecovery;
-       spin_unlock_irqrestore(&instance->hba_lock, flags);
 
-       if (adprecovery != MEGASAS_HBA_OPERATIONAL) {
+       if (atomic_read(&instance->adprecovery) != MEGASAS_HBA_OPERATIONAL) {
 
                INIT_LIST_HEAD(&clist_local);
                spin_lock_irqsave(&instance->hba_lock, flags);
@@ -2492,18 +2476,13 @@ static int megasas_wait_for_outstanding(struct megasas_instance *instance)
                dev_notice(&instance->pdev->dev, "HBA reset wait ...\n");
                for (i = 0; i < wait_time; i++) {
                        msleep(1000);
-                       spin_lock_irqsave(&instance->hba_lock, flags);
-                       adprecovery = instance->adprecovery;
-                       spin_unlock_irqrestore(&instance->hba_lock, flags);
-                       if (adprecovery == MEGASAS_HBA_OPERATIONAL)
+                       if (atomic_read(&instance->adprecovery) == MEGASAS_HBA_OPERATIONAL)
                                break;
                }
 
-               if (adprecovery != MEGASAS_HBA_OPERATIONAL) {
+               if (atomic_read(&instance->adprecovery) != MEGASAS_HBA_OPERATIONAL) {
                        dev_notice(&instance->pdev->dev, "reset: Stopping HBA.\n");
-                       spin_lock_irqsave(&instance->hba_lock, flags);
-                       instance->adprecovery = MEGASAS_HW_CRITICAL_ERROR;
-                       spin_unlock_irqrestore(&instance->hba_lock, flags);
+                       atomic_set(&instance->adprecovery, MEGASAS_HW_CRITICAL_ERROR);
                        return FAILED;
                }
 
@@ -2612,9 +2591,7 @@ static int megasas_wait_for_outstanding(struct megasas_instance *instance)
                                &instance->reg_set->inbound_doorbell);
                }
                megasas_dump_pending_frames(instance);
-               spin_lock_irqsave(&instance->hba_lock, flags);
-               instance->adprecovery = MEGASAS_HW_CRITICAL_ERROR;
-               spin_unlock_irqrestore(&instance->hba_lock, flags);
+               atomic_set(&instance->adprecovery, MEGASAS_HW_CRITICAL_ERROR);
                return FAILED;
        }
 
@@ -2641,7 +2618,7 @@ static int megasas_generic_reset(struct scsi_cmnd *scmd)
        scmd_printk(KERN_NOTICE, scmd, "megasas: RESET cmd=%x retries=%x\n",
                 scmd->cmnd[0], scmd->retries);
 
-       if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR) {
+       if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR) {
                dev_err(&instance->pdev->dev, "cannot recover from previous reset failures\n");
                return FAILED;
        }
@@ -3385,13 +3362,13 @@ process_fw_state_change_wq(struct work_struct *work)
        u32 wait;
        unsigned long flags;
 
-       if (instance->adprecovery != MEGASAS_ADPRESET_SM_INFAULT) {
+    if (atomic_read(&instance->adprecovery) != MEGASAS_ADPRESET_SM_INFAULT) {
                dev_notice(&instance->pdev->dev, "error, recovery st %x\n",
-                               instance->adprecovery);
+                               atomic_read(&instance->adprecovery));
                return ;
        }
 
-       if (instance->adprecovery == MEGASAS_ADPRESET_SM_INFAULT) {
+       if (atomic_read(&instance->adprecovery) == MEGASAS_ADPRESET_SM_INFAULT) {
                dev_notice(&instance->pdev->dev, "FW detected to be in fault"
                                        "state, restarting it...\n");
 
@@ -3434,7 +3411,7 @@ process_fw_state_change_wq(struct work_struct *work)
                megasas_issue_init_mfi(instance);
 
                spin_lock_irqsave(&instance->hba_lock, flags);
-               instance->adprecovery   = MEGASAS_HBA_OPERATIONAL;
+               atomic_set(&instance->adprecovery, MEGASAS_HBA_OPERATIONAL);
                spin_unlock_irqrestore(&instance->hba_lock, flags);
                instance->instancet->enable_intr(instance);
 
@@ -3499,14 +3476,14 @@ megasas_deplete_reply_queue(struct megasas_instance *instance,
 
 
                        instance->instancet->disable_intr(instance);
-                       instance->adprecovery   = MEGASAS_ADPRESET_SM_INFAULT;
+                       atomic_set(&instance->adprecovery, MEGASAS_ADPRESET_SM_INFAULT);
                        instance->issuepend_done = 0;
 
                        atomic_set(&instance->fw_outstanding, 0);
                        megasas_internal_reset_defer_cmds(instance);
 
                        dev_notice(&instance->pdev->dev, "fwState=%x, stage:%d\n",
-                                       fw_state, instance->adprecovery);
+                                       fw_state, atomic_read(&instance->adprecovery));
 
                        schedule_work(&instance->work_init);
                        return IRQ_HANDLED;
@@ -5795,7 +5772,7 @@ static int megasas_probe_one(struct pci_dev *pdev,
        instance->flag_ieee = 0;
        instance->ev = NULL;
        instance->issuepend_done = 1;
-       instance->adprecovery = MEGASAS_HBA_OPERATIONAL;
+       atomic_set(&instance->adprecovery, MEGASAS_HBA_OPERATIONAL);
        instance->is_imr = 0;
 
        instance->evt_detail = pci_alloc_consistent(pdev,
@@ -5974,7 +5951,7 @@ static void megasas_flush_cache(struct megasas_instance *instance)
        struct megasas_cmd *cmd;
        struct megasas_dcmd_frame *dcmd;
 
-       if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR)
+       if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR)
                return;
 
        cmd = megasas_get_cmd(instance);
@@ -6017,7 +5994,7 @@ static void megasas_shutdown_controller(struct megasas_instance *instance,
        struct megasas_cmd *cmd;
        struct megasas_dcmd_frame *dcmd;
 
-       if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR)
+       if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR)
                return;
 
        cmd = megasas_get_cmd(instance);
@@ -6462,7 +6439,7 @@ static int megasas_set_crash_dump_params_ioctl(struct megasas_cmd *cmd)
        for (i = 0; i < megasas_mgmt_info.max_index; i++) {
                local_instance = megasas_mgmt_info.instance[i];
                if (local_instance && local_instance->crash_dump_drv_support) {
-                       if ((local_instance->adprecovery ==
+                       if ((atomic_read(&local_instance->adprecovery) ==
                                MEGASAS_HBA_OPERATIONAL) &&
                                !megasas_set_crash_dump_params(local_instance,
                                        crash_support)) {
@@ -6710,7 +6687,7 @@ static int megasas_mgmt_ioctl_fw(struct file *file, unsigned long arg)
                goto out_kfree_ioc;
        }
 
-       if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR) {
+       if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR) {
                dev_err(&instance->pdev->dev, "Controller in crit error\n");
                error = -ENODEV;
                goto out_kfree_ioc;
@@ -6729,7 +6706,7 @@ static int megasas_mgmt_ioctl_fw(struct file *file, unsigned long arg)
        for (i = 0; i < wait_time; i++) {
 
                spin_lock_irqsave(&instance->hba_lock, flags);
-               if (instance->adprecovery == MEGASAS_HBA_OPERATIONAL) {
+               if (atomic_read(&instance->adprecovery) == MEGASAS_HBA_OPERATIONAL) {
                        spin_unlock_irqrestore(&instance->hba_lock, flags);
                        break;
                }
@@ -6744,7 +6721,7 @@ static int megasas_mgmt_ioctl_fw(struct file *file, unsigned long arg)
        }
 
        spin_lock_irqsave(&instance->hba_lock, flags);
-       if (instance->adprecovery != MEGASAS_HBA_OPERATIONAL) {
+       if (atomic_read(&instance->adprecovery) != MEGASAS_HBA_OPERATIONAL) {
                spin_unlock_irqrestore(&instance->hba_lock, flags);
 
                dev_err(&instance->pdev->dev, "timed out while"
@@ -6786,7 +6763,7 @@ static int megasas_mgmt_ioctl_aen(struct file *file, unsigned long arg)
        if (!instance)
                return -ENODEV;
 
-       if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR) {
+       if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR) {
                return -ENODEV;
        }
 
@@ -6797,7 +6774,7 @@ static int megasas_mgmt_ioctl_aen(struct file *file, unsigned long arg)
        for (i = 0; i < wait_time; i++) {
 
                spin_lock_irqsave(&instance->hba_lock, flags);
-               if (instance->adprecovery == MEGASAS_HBA_OPERATIONAL) {
+               if (atomic_read(&instance->adprecovery) == MEGASAS_HBA_OPERATIONAL) {
                        spin_unlock_irqrestore(&instance->hba_lock,
                                                flags);
                        break;
@@ -6814,7 +6791,7 @@ static int megasas_mgmt_ioctl_aen(struct file *file, unsigned long arg)
        }
 
        spin_lock_irqsave(&instance->hba_lock, flags);
-       if (instance->adprecovery != MEGASAS_HBA_OPERATIONAL) {
+       if (atomic_read(&instance->adprecovery) != MEGASAS_HBA_OPERATIONAL) {
                spin_unlock_irqrestore(&instance->hba_lock, flags);
                dev_err(&instance->pdev->dev, "timed out while waiting"
                                "for HBA to recover\n");

diff --git a/drivers/scsi/megaraid/megaraid_sas_fusion.c b/drivers/scsi/megaraid/megaraid_sas_fusion.c
index 2c4912f68225b45de534e5344ff60f30947ba320..64926f7ef119d42a61a3652f2a0579371f3cb292 100644 (file)
--- a/drivers/scsi/megaraid/megaraid_sas_fusion.c
+++ b/drivers/scsi/megaraid/megaraid_sas_fusion.c
@@ -2246,7 +2246,7 @@ complete_cmd_fusion(struct megasas_instance *instance, u32 MSIxIndex)
 
        fusion = instance->ctrl_context;
 
-       if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR)
+       if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR)
                return IRQ_HANDLED;
 
        desc = fusion->reply_frames_desc[MSIxIndex] +
@@ -2413,7 +2413,7 @@ megasas_complete_cmd_dpc_fusion(unsigned long instance_addr)
 
        /* If we have already declared adapter dead, donot complete cmds */
        spin_lock_irqsave(&instance->hba_lock, flags);
-       if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR) {
+       if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR) {
                spin_unlock_irqrestore(&instance->hba_lock, flags);
                return;
        }
@@ -3197,7 +3197,7 @@ int megasas_task_abort_fusion(struct scsi_cmnd *scmd)
        instance = (struct megasas_instance *)scmd->device->host->hostdata;
        fusion = instance->ctrl_context;
 
-       if (instance->adprecovery != MEGASAS_HBA_OPERATIONAL) {
+       if (atomic_read(&instance->adprecovery) != MEGASAS_HBA_OPERATIONAL) {
                dev_err(&instance->pdev->dev, "Controller is not OPERATIONAL,"
                "SCSI host:%d\n", instance->host->host_no);
                ret = FAILED;
@@ -3277,7 +3277,7 @@ int megasas_reset_target_fusion(struct scsi_cmnd *scmd)
        instance = (struct megasas_instance *)scmd->device->host->hostdata;
        fusion = instance->ctrl_context;
 
-       if (instance->adprecovery != MEGASAS_HBA_OPERATIONAL) {
+       if (atomic_read(&instance->adprecovery) != MEGASAS_HBA_OPERATIONAL) {
                dev_err(&instance->pdev->dev, "Controller is not OPERATIONAL,"
                "SCSI host:%d\n", instance->host->host_no);
                ret = FAILED;
@@ -3366,7 +3366,7 @@ int megasas_reset_fusion(struct Scsi_Host *shost, int reason)
 
        mutex_lock(&instance->reset_mutex);
 
-       if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR) {
+       if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR) {
                dev_warn(&instance->pdev->dev, "Hardware critical error, "
                       "returning FAILED for scsi%d.\n",
                        instance->host->host_no);
@@ -3381,7 +3381,7 @@ int megasas_reset_fusion(struct Scsi_Host *shost, int reason)
                instance->crash_dump_app_support && reason) {
                dev_info(&instance->pdev->dev, "IO/DCMD timeout is detected, "
                        "forcibly FAULT Firmware\n");
-               instance->adprecovery = MEGASAS_ADPRESET_SM_INFAULT;
+               atomic_set(&instance->adprecovery, MEGASAS_ADPRESET_SM_INFAULT);
                status_reg = readl(&instance->reg_set->doorbell);
                writel(status_reg | MFI_STATE_FORCE_OCR,
                        &instance->reg_set->doorbell);
@@ -3393,10 +3393,10 @@ int megasas_reset_fusion(struct Scsi_Host *shost, int reason)
                        dev_dbg(&instance->pdev->dev, "waiting for [%d] "
                                "seconds for crash dump collection and OCR "
                                "to be done\n", (io_timeout_in_crash_mode * 3));
-               } while ((instance->adprecovery != MEGASAS_HBA_OPERATIONAL) &&
+               } while ((atomic_read(&instance->adprecovery) != MEGASAS_HBA_OPERATIONAL) &&
                        (io_timeout_in_crash_mode < 80));
 
-               if (instance->adprecovery == MEGASAS_HBA_OPERATIONAL) {
+               if (atomic_read(&instance->adprecovery) == MEGASAS_HBA_OPERATIONAL) {
                        dev_info(&instance->pdev->dev, "OCR done for IO "
                                "timeout case\n");
                        retval = SUCCESS;
@@ -3413,14 +3413,14 @@ int megasas_reset_fusion(struct Scsi_Host *shost, int reason)
        if (instance->requestorId && !instance->skip_heartbeat_timer_del)
                del_timer_sync(&instance->sriov_heartbeat_timer);
        set_bit(MEGASAS_FUSION_IN_RESET, &instance->reset_flags);
-       instance->adprecovery = MEGASAS_ADPRESET_SM_POLLING;
+       atomic_set(&instance->adprecovery, MEGASAS_ADPRESET_SM_POLLING);
        instance->instancet->disable_intr(instance);
        msleep(1000);
 
        /* First try waiting for commands to complete */
        if (megasas_wait_for_outstanding_fusion(instance, reason,
                                                &convert)) {
-               instance->adprecovery = MEGASAS_ADPRESET_SM_INFAULT;
+               atomic_set(&instance->adprecovery, MEGASAS_ADPRESET_SM_INFAULT);
                dev_warn(&instance->pdev->dev, "resetting fusion "
                       "adapter scsi%d.\n", instance->host->host_no);
                if (convert)
@@ -3503,8 +3503,7 @@ int megasas_reset_fusion(struct Scsi_Host *shost, int reason)
                                               status_reg);
                                        megaraid_sas_kill_hba(instance);
                                        instance->skip_heartbeat_timer_del = 1;
-                                       instance->adprecovery =
-                                               MEGASAS_HW_CRITICAL_ERROR;
+                                       atomic_set(&instance->adprecovery, MEGASAS_HW_CRITICAL_ERROR);
                                        retval = FAILED;
                                        goto out;
                                }
@@ -3563,7 +3562,7 @@ int megasas_reset_fusion(struct Scsi_Host *shost, int reason)
                        clear_bit(MEGASAS_FUSION_IN_RESET,
                                  &instance->reset_flags);
                        instance->instancet->enable_intr(instance);
-                       instance->adprecovery = MEGASAS_HBA_OPERATIONAL;
+                       atomic_set(&instance->adprecovery, MEGASAS_HBA_OPERATIONAL);
 
                        /* Restart SR-IOV heartbeat */
                        if (instance->requestorId) {
@@ -3608,7 +3607,7 @@ int megasas_reset_fusion(struct Scsi_Host *shost, int reason)
                }
                clear_bit(MEGASAS_FUSION_IN_RESET, &instance->reset_flags);
                instance->instancet->enable_intr(instance);
-               instance->adprecovery = MEGASAS_HBA_OPERATIONAL;
+               atomic_set(&instance->adprecovery, MEGASAS_HBA_OPERATIONAL);
        }
 out:
        clear_bit(MEGASAS_FUSION_IN_RESET, &instance->reset_flags);