}
 
-static int slot_complete_v1_hw(struct hisi_hba *hisi_hba,
-                              struct hisi_sas_slot *slot)
+static void slot_complete_v1_hw(struct hisi_hba *hisi_hba,
+                               struct hisi_sas_slot *slot)
 {
        struct sas_task *task = slot->task;
        struct hisi_sas_device *sas_dev;
        struct device *dev = hisi_hba->dev;
        struct task_status_struct *ts;
        struct domain_device *device;
-       enum exec_status sts;
        struct hisi_sas_complete_v1_hdr *complete_queue =
                        hisi_hba->complete_hdr[slot->cmplt_queue];
        struct hisi_sas_complete_v1_hdr *complete_hdr;
        cmplt_hdr_data = le32_to_cpu(complete_hdr->data);
 
        if (unlikely(!task || !task->lldd_task || !task->dev))
-               return -EINVAL;
+               return;
 
        ts = &task->task_status;
        device = task->dev;
 
                slot_err_v1_hw(hisi_hba, task, slot);
                if (unlikely(slot->abort))
-                       return ts->stat;
+                       return;
                goto out;
        }
 
 
 out:
        hisi_sas_slot_task_free(hisi_hba, task, slot);
-       sts = ts->stat;
 
        if (task->task_done)
                task->task_done(task);
-
-       return sts;
 }
 
 /* Interrupts */
 
        }
 }
 
-static int
-slot_complete_v2_hw(struct hisi_hba *hisi_hba, struct hisi_sas_slot *slot)
+static void slot_complete_v2_hw(struct hisi_hba *hisi_hba,
+                               struct hisi_sas_slot *slot)
 {
        struct sas_task *task = slot->task;
        struct hisi_sas_device *sas_dev;
        struct task_status_struct *ts;
        struct domain_device *device;
        struct sas_ha_struct *ha;
-       enum exec_status sts;
        struct hisi_sas_complete_v2_hdr *complete_queue =
                        hisi_hba->complete_hdr[slot->cmplt_queue];
        struct hisi_sas_complete_v2_hdr *complete_hdr =
        u32 dw0;
 
        if (unlikely(!task || !task->lldd_task || !task->dev))
-               return -EINVAL;
+               return;
 
        ts = &task->task_status;
        device = task->dev;
                                 error_info[2], error_info[3]);
 
                if (unlikely(slot->abort))
-                       return ts->stat;
+                       return;
                goto out;
        }
 
        }
 
 out:
-       sts = ts->stat;
        spin_lock_irqsave(&task->task_state_lock, flags);
        if (task->task_state_flags & SAS_TASK_STATE_ABORTED) {
                spin_unlock_irqrestore(&task->task_state_lock, flags);
                dev_info(dev, "slot complete: task(%pK) aborted\n", task);
-               return SAS_ABORTED_TASK;
+               return;
        }
        task->task_state_flags |= SAS_TASK_STATE_DONE;
        spin_unlock_irqrestore(&task->task_state_lock, flags);
                        spin_unlock_irqrestore(&device->done_lock, flags);
                        dev_info(dev, "slot complete: task(%pK) ignored\n",
                                 task);
-                       return sts;
+                       return;
                }
                spin_unlock_irqrestore(&device->done_lock, flags);
        }
 
        if (task->task_done)
                task->task_done(task);
-
-       return sts;
 }
 
 static void prep_ata_v2_hw(struct hisi_hba *hisi_hba,
 
        }
 }
 
-static int
-slot_complete_v3_hw(struct hisi_hba *hisi_hba, struct hisi_sas_slot *slot)
+static void slot_complete_v3_hw(struct hisi_hba *hisi_hba,
+                               struct hisi_sas_slot *slot)
 {
        struct sas_task *task = slot->task;
        struct hisi_sas_device *sas_dev;
        struct task_status_struct *ts;
        struct domain_device *device;
        struct sas_ha_struct *ha;
-       enum exec_status sts;
        struct hisi_sas_complete_v3_hdr *complete_queue =
                        hisi_hba->complete_hdr[slot->cmplt_queue];
        struct hisi_sas_complete_v3_hdr *complete_hdr =
        u32 dw0, dw1, dw3;
 
        if (unlikely(!task || !task->lldd_task || !task->dev))
-               return -EINVAL;
+               return;
 
        ts = &task->task_status;
        device = task->dev;
                                 error_info[0], error_info[1],
                                 error_info[2], error_info[3]);
                if (unlikely(slot->abort))
-                       return ts->stat;
+                       return;
                goto out;
        }
 
        }
 
 out:
-       sts = ts->stat;
        spin_lock_irqsave(&task->task_state_lock, flags);
        if (task->task_state_flags & SAS_TASK_STATE_ABORTED) {
                spin_unlock_irqrestore(&task->task_state_lock, flags);
                dev_info(dev, "slot complete: task(%pK) aborted\n", task);
-               return SAS_ABORTED_TASK;
+               return;
        }
        task->task_state_flags |= SAS_TASK_STATE_DONE;
        spin_unlock_irqrestore(&task->task_state_lock, flags);
                        spin_unlock_irqrestore(&device->done_lock, flags);
                        dev_info(dev, "slot complete: task(%pK) ignored\n ",
                                 task);
-                       return sts;
+                       return;
                }
                spin_unlock_irqrestore(&device->done_lock, flags);
        }
 
        if (task->task_done)
                task->task_done(task);
-
-       return sts;
 }
 
 static irqreturn_t  cq_thread_v3_hw(int irq_no, void *p)