/** * asd_abort_task -- ABORT TASK TMF * @task: the task to be aborted * * Before calling ABORT TASK the task state flags should be ORed with * SAS_TASK_STATE_ABORTED (unless SAS_TASK_STATE_DONE is set) under * the task_state_lock IRQ spinlock, then ABORT TASK *must* be called. * * Implements the ABORT TASK TMF, I_T_L_Q nexus. * Returns: SAS TMF responses (see sas_task.h), * -ENOMEM, * -SAS_QUEUE_FULL. * * When ABORT TASK returns, the caller of ABORT TASK checks first the * task->task_state_flags, and then the return value of ABORT TASK. * * If the task has task state bit SAS_TASK_STATE_DONE set, then the * task was completed successfully prior to it being aborted. The * caller of ABORT TASK has responsibility to call task->task_done() * xor free the task, depending on their framework. The return code * is TMF_RESP_FUNC_FAILED in this case. * * Else the SAS_TASK_STATE_DONE bit is not set, * If the return code is TMF_RESP_FUNC_COMPLETE, then * the task was aborted successfully. The caller of * ABORT TASK has responsibility to call task->task_done() * to finish the task, xor free the task depending on their * framework. * else * the ABORT TASK returned some kind of error. The task * was _not_ cancelled. Nothing can be assumed. * The caller of ABORT TASK may wish to retry. */ int asd_abort_task(struct sas_task *task) { struct asd_ascb *tascb = task->lldd_task; struct asd_ha_struct *asd_ha = tascb->ha; int res = 1; unsigned long flags; struct asd_ascb *ascb = NULL; struct scb *scb; int leftover; spin_lock_irqsave(&task->task_state_lock, flags); if (task->task_state_flags & SAS_TASK_STATE_DONE) { spin_unlock_irqrestore(&task->task_state_lock, flags); res = TMF_RESP_FUNC_COMPLETE; ASD_DPRINTK("%s: task 0x%p done\n", __FUNCTION__, task); goto out_done; } spin_unlock_irqrestore(&task->task_state_lock, flags); ascb = asd_ascb_alloc_list(asd_ha, &res, GFP_KERNEL); if (!ascb) return -ENOMEM; scb = ascb->scb; scb->header.opcode = ABORT_TASK; switch (task->task_proto) { case SAS_PROTOCOL_SATA: case SAS_PROTOCOL_STP: scb->abort_task.proto_conn_rate = (1 << 5); /* STP */ break; case SAS_PROTOCOL_SSP: scb->abort_task.proto_conn_rate = (1 << 4); /* SSP */ scb->abort_task.proto_conn_rate |= task->dev->linkrate; break; case SAS_PROTOCOL_SMP: break; default: break; } if (task->task_proto == SAS_PROTOCOL_SSP) { scb->abort_task.ssp_frame.frame_type = SSP_TASK; memcpy(scb->abort_task.ssp_frame.hashed_dest_addr, task->dev->hashed_sas_addr, HASHED_SAS_ADDR_SIZE); memcpy(scb->abort_task.ssp_frame.hashed_src_addr, task->dev->port->ha->hashed_sas_addr, HASHED_SAS_ADDR_SIZE); scb->abort_task.ssp_frame.tptt = cpu_to_be16(0xFFFF); memcpy(scb->abort_task.ssp_task.lun, task->ssp_task.LUN, 8); scb->abort_task.ssp_task.tmf = TMF_ABORT_TASK; scb->abort_task.ssp_task.tag = cpu_to_be16(0xFFFF); } scb->abort_task.sister_scb = cpu_to_le16(0xFFFF); scb->abort_task.conn_handle = cpu_to_le16( (u16)(unsigned long)task->dev->lldd_dev); scb->abort_task.retry_count = 1; scb->abort_task.index = cpu_to_le16((u16)tascb->tc_index); scb->abort_task.itnl_to = cpu_to_le16(ITNL_TIMEOUT_CONST); res = asd_enqueue_internal(ascb, asd_tmf_tasklet_complete, asd_tmf_timedout); if (res) goto out; wait_for_completion(&ascb->completion); ASD_DPRINTK("tmf came back\n"); res = (int) (unsigned long) ascb->uldd_task; tascb->tag = ascb->tag; tascb->tag_valid = ascb->tag_valid; spin_lock_irqsave(&task->task_state_lock, flags); if (task->task_state_flags & SAS_TASK_STATE_DONE) { spin_unlock_irqrestore(&task->task_state_lock, flags); res = TMF_RESP_FUNC_COMPLETE; ASD_DPRINTK("%s: task 0x%p done\n", __FUNCTION__, task); goto out_done; } spin_unlock_irqrestore(&task->task_state_lock, flags); switch (res) { /* The task to be aborted has been sent to the device. * We got a Response IU for the ABORT TASK TMF. */ case TC_NO_ERROR + 0xFF00: case TMF_RESP_FUNC_COMPLETE: case TMF_RESP_FUNC_FAILED: res = asd_clear_nexus(task); break; case TMF_RESP_INVALID_FRAME: case TMF_RESP_OVERLAPPED_TAG: case TMF_RESP_FUNC_ESUPP: case TMF_RESP_NO_LUN: goto out_done; break; } /* In the following we assume that the managing layer * will _never_ make a mistake, when issuing ABORT TASK. */ switch (res) { default: res = asd_clear_nexus(task); /* fallthrough */ case TC_NO_ERROR + 0xFF00: case TMF_RESP_FUNC_COMPLETE: break; /* The task hasn't been sent to the device xor we never got * a (sane) Response IU for the ABORT TASK TMF. */ case TF_NAK_RECV + 0xFF00: res = TMF_RESP_INVALID_FRAME; break; case TF_TMF_TASK_DONE + 0xFF00: /* done but not reported yet */ res = TMF_RESP_FUNC_FAILED; leftover = wait_for_completion_timeout(&tascb->completion, AIC94XX_SCB_TIMEOUT); spin_lock_irqsave(&task->task_state_lock, flags); if (leftover < 1) res = TMF_RESP_FUNC_FAILED; if (task->task_state_flags & SAS_TASK_STATE_DONE) res = TMF_RESP_FUNC_COMPLETE; spin_unlock_irqrestore(&task->task_state_lock, flags); goto out_done; case TF_TMF_NO_TAG + 0xFF00: case TF_TMF_TAG_FREE + 0xFF00: /* the tag is in the free list */ case TF_TMF_NO_CONN_HANDLE + 0xFF00: /* no such device */ res = TMF_RESP_FUNC_COMPLETE; goto out_done; case TF_TMF_NO_CTX + 0xFF00: /* not in seq, or proto != SSP */ res = TMF_RESP_FUNC_ESUPP; goto out; } out_done: if (res == TMF_RESP_FUNC_COMPLETE) { task->lldd_task = NULL; mb(); asd_ascb_free(tascb); } out: asd_ascb_free(ascb); ASD_DPRINTK("task 0x%p aborted, res: 0x%x\n", task, res); return res; }
int asd_abort_task(struct sas_task *task) { struct asd_ascb *tascb = task->lldd_task; struct asd_ha_struct *asd_ha = tascb->ha; int res = 1; unsigned long flags; struct asd_ascb *ascb = NULL; struct scb *scb; int leftover; DECLARE_TCS(tcs); DECLARE_COMPLETION_ONSTACK(completion); DECLARE_COMPLETION_ONSTACK(tascb_completion); tascb->completion = &tascb_completion; spin_lock_irqsave(&task->task_state_lock, flags); if (task->task_state_flags & SAS_TASK_STATE_DONE) { spin_unlock_irqrestore(&task->task_state_lock, flags); res = TMF_RESP_FUNC_COMPLETE; ASD_DPRINTK("%s: task 0x%p done\n", __func__, task); goto out_done; } spin_unlock_irqrestore(&task->task_state_lock, flags); ascb = asd_ascb_alloc_list(asd_ha, &res, GFP_KERNEL); if (!ascb) return -ENOMEM; ascb->uldd_task = &tcs; ascb->completion = &completion; scb = ascb->scb; scb->header.opcode = SCB_ABORT_TASK; switch (task->task_proto) { case SAS_PROTOCOL_SATA: case SAS_PROTOCOL_STP: scb->abort_task.proto_conn_rate = (1 << 5); break; case SAS_PROTOCOL_SSP: scb->abort_task.proto_conn_rate = (1 << 4); scb->abort_task.proto_conn_rate |= task->dev->linkrate; break; case SAS_PROTOCOL_SMP: break; default: break; } if (task->task_proto == SAS_PROTOCOL_SSP) { scb->abort_task.ssp_frame.frame_type = SSP_TASK; memcpy(scb->abort_task.ssp_frame.hashed_dest_addr, task->dev->hashed_sas_addr, HASHED_SAS_ADDR_SIZE); memcpy(scb->abort_task.ssp_frame.hashed_src_addr, task->dev->port->ha->hashed_sas_addr, HASHED_SAS_ADDR_SIZE); scb->abort_task.ssp_frame.tptt = cpu_to_be16(0xFFFF); memcpy(scb->abort_task.ssp_task.lun, task->ssp_task.LUN, 8); scb->abort_task.ssp_task.tmf = TMF_ABORT_TASK; scb->abort_task.ssp_task.tag = cpu_to_be16(0xFFFF); } scb->abort_task.sister_scb = cpu_to_le16(0xFFFF); scb->abort_task.conn_handle = cpu_to_le16( (u16)(unsigned long)task->dev->lldd_dev); scb->abort_task.retry_count = 1; scb->abort_task.index = cpu_to_le16((u16)tascb->tc_index); scb->abort_task.itnl_to = cpu_to_le16(ITNL_TIMEOUT_CONST); res = asd_enqueue_internal(ascb, asd_tmf_tasklet_complete, asd_tmf_timedout); if (res) goto out_free; wait_for_completion(&completion); ASD_DPRINTK("tmf came back\n"); tascb->tag = tcs.tag; tascb->tag_valid = tcs.tag_valid; spin_lock_irqsave(&task->task_state_lock, flags); if (task->task_state_flags & SAS_TASK_STATE_DONE) { spin_unlock_irqrestore(&task->task_state_lock, flags); res = TMF_RESP_FUNC_COMPLETE; ASD_DPRINTK("%s: task 0x%p done\n", __func__, task); goto out_done; } spin_unlock_irqrestore(&task->task_state_lock, flags); if (tcs.dl_opcode == TC_SSP_RESP) { if (tcs.tmf_state == TMF_RESP_FUNC_COMPLETE) res = asd_clear_nexus(task); else res = tcs.tmf_state; } else if (tcs.dl_opcode == TC_NO_ERROR && tcs.tmf_state == TMF_RESP_FUNC_FAILED) { res = TMF_RESP_FUNC_FAILED; } else { switch (tcs.dl_opcode) { default: res = asd_clear_nexus(task); case TC_NO_ERROR: break; case TF_NAK_RECV: res = TMF_RESP_INVALID_FRAME; break; case TF_TMF_TASK_DONE: res = TMF_RESP_FUNC_FAILED; leftover = wait_for_completion_timeout(&tascb_completion, AIC94XX_SCB_TIMEOUT); spin_lock_irqsave(&task->task_state_lock, flags); if (leftover < 1) res = TMF_RESP_FUNC_FAILED; if (task->task_state_flags & SAS_TASK_STATE_DONE) res = TMF_RESP_FUNC_COMPLETE; spin_unlock_irqrestore(&task->task_state_lock, flags); break; case TF_TMF_NO_TAG: case TF_TMF_TAG_FREE: case TF_TMF_NO_CONN_HANDLE: res = TMF_RESP_FUNC_COMPLETE; break; case TF_TMF_NO_CTX: res = TMF_RESP_FUNC_ESUPP; break; } } out_done: tascb->completion = NULL; if (res == TMF_RESP_FUNC_COMPLETE) { task->lldd_task = NULL; mb(); asd_ascb_free(tascb); } ASD_DPRINTK("task 0x%p aborted, res: 0x%x\n", task, res); return res; out_free: asd_ascb_free(ascb); ASD_DPRINTK("task 0x%p aborted, res: 0x%x\n", task, res); return res; }