/** * asd_initiate_ssp_tmf -- send a TMF to an I_T_L or I_T_L_Q nexus * @dev: pointer to struct domain_device of interest * @lun: pointer to u8[8] which is the LUN * @tmf: the TMF to be performed (see sas_task.h or the SAS spec) * @index: the transaction context of the task to be queried if QT TMF * * This function is used to send ABORT TASK SET, CLEAR ACA, * CLEAR TASK SET, LU RESET and QUERY TASK TMFs. * * No SCBs should be queued to the I_T_L nexus when this SCB is * pending. * * Returns: TMF response code (see sas_task.h or the SAS spec) */ static int asd_initiate_ssp_tmf(struct domain_device *dev, u8 *lun, int tmf, int index) { struct asd_ha_struct *asd_ha = dev->port->ha->lldd_ha; struct asd_ascb *ascb; int res = 1; struct scb *scb; if (!(dev->tproto & SAS_PROTOCOL_SSP)) return TMF_RESP_FUNC_ESUPP; ascb = asd_ascb_alloc_list(asd_ha, &res, GFP_KERNEL); if (!ascb) return -ENOMEM; scb = ascb->scb; if (tmf == TMF_QUERY_TASK) scb->header.opcode = QUERY_SSP_TASK; else scb->header.opcode = INITIATE_SSP_TMF; scb->ssp_tmf.proto_conn_rate = (1 << 4); /* SSP */ scb->ssp_tmf.proto_conn_rate |= dev->linkrate; /* SSP frame header */ scb->ssp_tmf.ssp_frame.frame_type = SSP_TASK; memcpy(scb->ssp_tmf.ssp_frame.hashed_dest_addr, dev->hashed_sas_addr, HASHED_SAS_ADDR_SIZE); memcpy(scb->ssp_tmf.ssp_frame.hashed_src_addr, dev->port->ha->hashed_sas_addr, HASHED_SAS_ADDR_SIZE); scb->ssp_tmf.ssp_frame.tptt = cpu_to_be16(0xFFFF); /* SSP Task IU */ memcpy(scb->ssp_tmf.ssp_task.lun, lun, 8); scb->ssp_tmf.ssp_task.tmf = tmf; scb->ssp_tmf.sister_scb = cpu_to_le16(0xFFFF); scb->ssp_tmf.conn_handle= cpu_to_le16((u16)(unsigned long) dev->lldd_dev); scb->ssp_tmf.retry_count = 1; scb->ssp_tmf.itnl_to = cpu_to_le16(ITNL_TIMEOUT_CONST); if (tmf == TMF_QUERY_TASK) scb->ssp_tmf.index = cpu_to_le16(index); res = asd_enqueue_internal(ascb, asd_tmf_tasklet_complete, asd_tmf_timedout); if (res) goto out_err; wait_for_completion(&ascb->completion); res = (int) (unsigned long) ascb->uldd_task; switch (res) { case TC_NO_ERROR + 0xFF00: res = TMF_RESP_FUNC_COMPLETE; break; case TF_NAK_RECV + 0xFF00: res = TMF_RESP_INVALID_FRAME; break; case TF_TMF_TASK_DONE + 0xFF00: res = TMF_RESP_FUNC_FAILED; break; 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; break; case TF_TMF_NO_CTX + 0xFF00: /* not in seq, or proto != SSP */ res = TMF_RESP_FUNC_ESUPP; break; default: /* Allow TMF response codes to propagate upwards */ break; } out_err: asd_ascb_free(ascb); return res; }
static int asd_initiate_ssp_tmf(struct domain_device *dev, u8 *lun, int tmf, int index) { struct asd_ha_struct *asd_ha = dev->port->ha->lldd_ha; struct asd_ascb *ascb; int res = 1; struct scb *scb; DECLARE_COMPLETION_ONSTACK(completion); DECLARE_TCS(tcs); if (!(dev->tproto & SAS_PROTOCOL_SSP)) return TMF_RESP_FUNC_ESUPP; ascb = asd_ascb_alloc_list(asd_ha, &res, GFP_KERNEL); if (!ascb) return -ENOMEM; ascb->completion = &completion; ascb->uldd_task = &tcs; scb = ascb->scb; if (tmf == TMF_QUERY_TASK) scb->header.opcode = QUERY_SSP_TASK; else scb->header.opcode = INITIATE_SSP_TMF; scb->ssp_tmf.proto_conn_rate = (1 << 4); scb->ssp_tmf.proto_conn_rate |= dev->linkrate; scb->ssp_tmf.ssp_frame.frame_type = SSP_TASK; memcpy(scb->ssp_tmf.ssp_frame.hashed_dest_addr, dev->hashed_sas_addr, HASHED_SAS_ADDR_SIZE); memcpy(scb->ssp_tmf.ssp_frame.hashed_src_addr, dev->port->ha->hashed_sas_addr, HASHED_SAS_ADDR_SIZE); scb->ssp_tmf.ssp_frame.tptt = cpu_to_be16(0xFFFF); memcpy(scb->ssp_tmf.ssp_task.lun, lun, 8); scb->ssp_tmf.ssp_task.tmf = tmf; scb->ssp_tmf.sister_scb = cpu_to_le16(0xFFFF); scb->ssp_tmf.conn_handle= cpu_to_le16((u16)(unsigned long) dev->lldd_dev); scb->ssp_tmf.retry_count = 1; scb->ssp_tmf.itnl_to = cpu_to_le16(ITNL_TIMEOUT_CONST); if (tmf == TMF_QUERY_TASK) scb->ssp_tmf.index = cpu_to_le16(index); res = asd_enqueue_internal(ascb, asd_tmf_tasklet_complete, asd_tmf_timedout); if (res) goto out_err; wait_for_completion(&completion); switch (tcs.dl_opcode) { case TC_NO_ERROR: res = TMF_RESP_FUNC_COMPLETE; break; case TF_NAK_RECV: res = TMF_RESP_INVALID_FRAME; break; case TF_TMF_TASK_DONE: res = TMF_RESP_FUNC_FAILED; 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; default: res = tcs.dl_opcode; break; } return res; out_err: asd_ascb_free(ascb); return res; }
/** * 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; }