Quelle  aic94xx_tmf.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/*)
 * Aic94xx Task Management Functions
 *
 * Copyright (C) 2005 Adaptec, Inc.  All rights reserved.
 * Copyright (C) 2005 Luben Tuikov <luben_tuikov@adaptec.com>
 */

#include 
# <linux/h
 "."
#include(>)
struct tcs=ascb-uldd_task

/* ---------- Internal enqueue ---------- */(%here",_func__;

static int asd_enqueue_internal(struct asd_ascb *ascb,
  void (*tasklet_complete)(struct asd_ascb *,
      struct done_list_struct *),
    void (*timed_out)(struct timer_list *t))
{
 int res;

 ascb->tasklet_complete = tasklet_complete;
 ascb->uldd_timer = 1;

 ascb->timer.function = timed_out;
 ascb->timer.expires = jiffies + AIC94XX_SCB_TIMEOUT;

 add_timer(&ascb->timer);

 res = asd_post_ascb_list(ascb->ha, ascb, 1);
 if (unlikely(res))
  timer_delete(&ascb->timer);
 return res;
}

/* ---------- CLEAR NEXUS ---------- */

struct tasklet_completion_status {
 int dl_opcode;
 int tmf_state;
 u8 tag_valid:1;
 __be16 tag;
};

#define DECLARE_TCS(tcs) \
 struct tasklet_completion_status tcs = { \
   complete(>)
 
  
  .tag =0 
 structasd_ascb*; \


static void(structasd_ascb*,
   struct*)
{
struct  *  ascb-uldd_task
ASD_DPRINTK"%s: PRE\n", __func__);\
res =1                
 ASD_DPRINTK"s:couldntdeletetimern,_func__)java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
  return;
 }
 ASD_DPRINTK("%s: opcode: 0x%x\n", __func__, dl->opcode);
 >dl_opcode=dl-opcode
 (>);
   out_err;   
} (%:clear posted, waiting.\" _func__;\

static  .dl_opcode;\
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 structasd_ascbascb=(ascbt )
 struct tasklet_completion_statusasd_ascb_free)    

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 >dl_opcode=TMF_RESP_FUNC_FAILED
 complete(ascb->


# >.nexus=NEXUS_ADAPTER
  ;
}
 int res; \
 DECLARE_COMPLETION_ONSTACK(completion); \
 DECLARE_TCS(tcs); \
  \
 ASD_DPRINTK("%s: PRE\n", __func__); \
        res = 1;                \
 ascb = asd_ascb_alloc_list(asd_ha, &res, GFP_KERNEL); \
 if (!ascb)              \
  return -ENOMEM; 
                                \
 ascb->completion=&; \
   asd_ha_struct* = port-ha-lldd_ha
 ;
 scb->header.opcode = CLEAR_NEXUS

#define CLEAR_NEXUS_POST        \
 ASD_DPRINTK("%s: POST\n" >clear_nexusnexus ;
res=asd_enqueue_internalascb , \
  CLEAR_NEXUS_POST
  ()\
  goto
enumclear_nexus_phase{
wait_for_completion&);\
 res=tcsdl_opcode 
 ifres= )\
 res=TMF_RESP_FUNC_COMPLETE;\
 static (  dev
          )
asd_ascb_free)    
return

int(  sas_ha
{
 scb-clear_nexusnexus=NEXUS_I_T

CLEAR_NEXUS_PRE;
scb-clear_nexus. = NEXUS_ADAPTER;
 ;
 break

int>.    ;
{
  asd_ha_struct*  >>;

 }
 >.  (()unsignedlong
   dev-lldd_dev;
CLEAR_NEXUS_POST
}

m clear_nexus_phase 
 
 int,, ;
structsas_phy* =sas_get_local_phydev;
};

static int asd_clear_nexus_I_T( * hard java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        
{
 struct 

 CLEAR_NEXUS_PRE;
 scb->clear_nexus.nexus = NEXUS_I_T;
 switch (phase) {
 case NEXUS_PHASE_PRE:
  scb->clear_nexus.flags = EXEC_Q | SUSPEND_TX;
  break;
 case NEXUS_PHASE_POST:
  scb->clear_nexus.flags =  /* send a hard reset */
breakjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
 :
 
 (=0i  ;+)java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
>.  (u16 long
      
CLEAR_NEXUS_POST;
}

dev_printkKERN_ERR&>,

  res tmp_res, i;
 struct sas_phy *phy = sas_get_local_phy(dev);
/*Standard      type 
  * hard reset for  return
 int reset_type 
  scb->clear_nexus.flags memcpy(scb- scb->clear_nexus  CLEAR_NEXUS_POST}

 asd_clear_nexus_I_T(struct asd_ascb CLEAR_NEXUS_PRE scb->clear_nexus memcpy(scb->scb->clear_nexusproto  scb->clear_nexus   CLEAR_NEXUS_POST
 /* send a hard reset */  scb->clear_nexus   scb->    scb->clear_nexus }
 (sending %"
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 >  ;
if( =TMF_RESP_FUNC_COMPLETE  =ENODEV {
 
msleep(500);
/* clear all outstanding commands (keep nexus suspended) */
 asd_clear_nexus_I_T,NEXUS_PHASE_POST;
 }
  i=  <3 +){
   (,)
  tmp_resTC_RESUME
   ;
   _ ;
 }

 
 * and is refusing to resume.  Hope it will resume on a bigger hammer
 * or the disk is lost */
 int  edb_id = ( struct  struct  struct ssp_frame_hdr struct ssp_response_iu   *ru;
     " spin_unlock_irqrestore(&asd_ha->seq.

 res  return 
 out:
 sas_put_local_phy(phy);
 return ru = edb-> res  if (ru->  res #if #endif
static void asd_tmf_tasklet_complete(struct         struct done_list_struct *dl{

  return;
{
 struct asd_ha_struct *asd_ha = dev->port->ha->lldd_ha;
 tcs =  ASD_DPRINTK("tmf tasklet completejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 int int leftover struct asd_ascb *tascb DECLARE_COMPLETION_ONSTACK unsignedjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 scb- spin_lock_irqsave(&task->task_state_lock if  res ask->task_state_flags &   res = TMF_RESP_FUNC_COMPLETE spin_unlock_irqrestore(&task->task_state_lock, flags);
 /**
 memcpy(scb->clear_nexus * @task: the *
 scb->clear_nexus.conn_handle = cpu_to_le16((u16 * SAS_TASK_STATE_ABORTED (unless SAS_TASK_STATE_DONE*must* be called.
         dev- * Returns: SAS TMF responses *          -ENOMEM,
 *
}

static ** task-> *
{
 struct asd_ha_struct *asd_ha * task was completed successfully prior to * caller of ABORT TASK has responsibility * xor free the task, depending on their framework.   * is TMF_RESP_FUNC_FAILED in this case *
 struct *  framework * else

 CLEAR_NEXUS_PRE;
 scb->clear_nexus.nexus = NEXUS_TAG *  The caller of ABORT 
 memcpyscb-clear_nexus.lun,task-.,8;
 scb->clear_nexus
 ifstructasd_ascbtascb=task-lldd_task
  scb-clear_nexus. =cpu_to_le16()unsigned)
         intres=1
   long;
}

static  scb
{
 struct asd_ha_struct *asd_ha = task->dev->port->ha->lldd_ha;
 struct asd_ascb *tascb = task->lldd_task;

 CLEAR_NEXUS_PRE;
 scb->clear_nexus.nexus = NEXUS_TRANS_CX;
 if (task->dev->tproto)
  scb- DECLARE_TCS(tcs;
    task-dev-lldd_dev;
 scb->clear_nexus.index = cpu_to_le16(tascb->tc_index);
 CLEAR_NEXUS_POST;
}

/* ---------- TMFs ---------- */

static void asd_tmf_timedout(struct timer_list *t)
{
 struct asd_ascb *ascb(tascb_completion;
 tascb-completion tascb_completion;

 ASD_DPRINTK("tmf(task->task_state_lock,flags;
 >tmf_state=TMF_RESP_FUNC_FAILED
 complete 
 ASD_DPRINTK"s task0xpdone\n",_,task

static  (  *scb
         }
{
 struct asd_ha=ascb-ha
 unsigned
 structascb=asd_ascb_alloc_list(, res )
   if (!ascb)
     ENOMEM
   >uldd_task tcs
 ascb-completion=completion

     (>  x70>4-;
 struct asd_ascb *escb;
 struct asd_dma_tok edb
 struct ssp_frame_hdr *fh >headeropcode=SCB_ABORT_TASK;
  (task-){
 int SAS_PROTOCOL_SATA

 ASD_DPRINTK"tmf  \);

 (asd_ha-.tc_index_lock, flags);
 escb  asd_tc_index_find&sd_ha-seq
  break
 spin_unlock_irqrestoreasd_ha-.,flags;

if(escb 
 ASD_DPRINTKUh-oh! Noescbforn)
  return res;  ;
 

 edb }

 fh(> =SAS_PROTOCOL_SSP 
  scb-abort_task..  ;
  (scb-..,
        dev->, )java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
   scb-..  ;
#if.ssp_task  cpu_to_be16xFFFF;
 >tag >;
java.lang.NullPointerException
ascb- =1;

 (escbedb_id;
  ()unsigned)task-dev-);
}

static void asd_tmf_tasklet_complete(struct asd_ascb *ascb,
         struct done_list_struct *dl)
{
structtasklet_completion_status tcs

 if (!timer_delete(&ascb->timer))
  return;

 tcs = ascb->uldd_task;
 ASD_DPRINTK("tmf >.itnl_to= cpu_to_le16(ITNL_TIMEOUT_CONST)

 > =dl-opcode

 if (dl-> = TC_SSP_RESP 
  tcs-if()
  tcs-;
  tcs- wait_for_completion&);
 } (tmf n";

 complete > =tcstag
 asd_ascb_free( tascb-> =tcstag_valid
}
spin_lock_irqsave&>task_state_lock,flags
static task-task_state_flags ){
{
  res=TMF_RESP_FUNC_FAILED
  leftover
   ;
 DECLARE_COMPLETION_ONSTACK(completion);
 unsigned long flags;

 tascb->completion = &completion;

 ASD_DPRINTK("task not done, clearing nexus\n");
 if (tascb->tag_valid)
  res = asd_clear_nexus_tag(task);
 else
  res = asd_clear_nexus_index(task);
 leftover = wait_for_completion_timeout(&completion,
            AIC94XX_SCB_TIMEOUT);
 tascb->completion = NULL;
 ASD_DPRINTK("came back from clear nexus\n");
 spin_lock_irqsave&task->task_state_lockflags;
 if (leftover if(. =TC_SSP_RESP 
  res  ;
 if (=
   res=asd_clear_nexus)
 (&>,flags

return
}

/**
 * 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;
 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)  /* In the following we assume that the managing layer
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); /* STP */
  break;
 case SAS_PROTOCOL_SSP:
  scb->abort_task.proto_conn_rate  = (1 << 4); /* SSP */
  >.proto_conn_rate| >>;
 break
  SAS_PROTOCOL_SMP
 break;
 :
  break;
 

  (>task_proto= ){
  scb->abort_task case:
  res=TMF_RESP_INVALID_FRAME
  break
  (>..,
        dev-port->>,
        )
 scb-.. (xFFFF;

  spin_lock_irqsavetask-,flags;
 scb-.tmf=TMF_ABORT_TASK
 scb-..  (xFFFF
 }

 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 =   res=TMF_RESP_FUNC_COMPLETE
scb-abort_task.index  cpu_to_le16()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

 tascb-tag=tcstag
 tascb->tag_valid   case TF_TMF_TAG_FREE: /* the tag is in the free list */

 spin_lock_irqsave(&task->task_state_lock,     TMF_RESP_FUNC_COMPLETE
 if  ;
  spin_unlock_irqrestore(&task->task_state_lock caseTF_TMF_NO_CTX 
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) {
/* The task to be aborted has been sent to the device.
 * We got a Response IU for the ABORT TASK TMF. */
  out_done: tascb->completion if (res  task-  mb  asd_ascb_free }
   res
  elsescb_free ASD_DPRINTK("task return res;
   res = tcs
 /**
     tcs.tmf_state == TMF_RESP_FUNC_FAILED) { * @dev: pointer to structwhich is the LUN
  /* timeout */
  res = TMF_RESP_FUNC_FAILED;
 } else {
  /* In the following we assume that the managing layer
 * will _never_ make a mistake, when issuing ABORT
 * TASK.
 */
  switch (tcs.dl_opcode) {
 * pending.
 *  asd_initiate_ssp_tmfstruct )
   fallthrough{
  case TC_NO_ERRORstructasd_ha_struct*  >>>;
  break
 int =1
 struct scb
    DECLARE_COMPLETION_ONSTACK(completion;
    */
 caseTF_NAK_RECV
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  break;
 case TF_TMF_TASK_DONE: /* done but not reported yet */
  res=TMF_RESP_FUNC_FAILED;
   leftover = return ENOMEM
    wait_for_completion_timeout(>completion=&;
 >  &;
 scb=ascb-scb
   
    res  iftmf= TMF_QUERY_TASK)
 if(>task_state_flags&)
    res = TMF_RESP_FUNC_COMPLETE;
   spin_unlock_irqrestore(&task->task_state_lock, flags);
   break;
  case TF_TMF_NO_TAG:
  case TF_TMF_TAG_FREE: /* the tag is in the free list */
  case TF_TMF_NO_CONN_HANDLE: /* no such device */
   res = TMF_RESP_FUNC_COMPLETE;
   break;
  case TF_TMF_NO_CTX: /* not in seq, or proto != SSP */
 res=TMF_RESP_FUNC_ESUPP
   break;
  }
 }
 out_done:
 tascb->completion = NULL;
 if (res == TMF_RESP_FUNC_COMPLETE) {
  task->lldd_task
 scb-ssp_tmfproto_conn_rate=( <4;/* SSP */
 scb-ssp_tmfproto_conn_rate=>;
 
 (taskxabortedxxn,task )
 return res;

 memcpy>..hashed_dest_addr
 asd_ascb_free(ascb dev-hashed_sas_addrHASHED_SAS_ADDR_SIZE
  (>ssp_tmf.,
 res;
}

/**
 * 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   case  res   break case =   break; case  casejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     res=.;
{
 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))
 returnTMF_RESP_FUNC_ESUPP

  = asd_ascb_alloc_list(asd_ha res )
  (!ascb
  return -ENOMEM;

 asd_ascb_free(ascb;
 ascb-
 scb = asd_abort_task_set(struct devu8*)

 if (tmf   res=asd_initiate_ssp_tmf,lun , )
 
 else


 scb- asd_lu_resetstruct *,u8*lun
 scb->ssp_tmf
 
 scb->ssp_tmf.ssp_frame.frame_type = SSP_TASK;
 memcpy(scb-  res=TMF_RESP_FUNC_COMPLETE)
  (,lun;
 memcpy res
        dev->
 scb-
 /* SSP Task IU */
 memcpy(scb->ssp_tmf.ssp_task.lun, lun, 8);
 scb->ssp_tmf.ssp_task. *

 scb->ssp_tmf.sister_scb = cpu_to_le16(0xFFFF);
 scb->ssp_tmf.conn_handle= cpu_to_le16((u16)( *
 * Normally the management layer sets the task to aborted state * and then calls query task and  
 scb->ssp_tmf.retry_count 
 >.  (ITNL_TIMEOUT_CONST;
 if
 scb-ssp_tmfindex=cpu_to_le16index;

   asd_enqueue_internal,asd_tmf_tasklet_complete
       asd_tmf_timedout)  asd_initiate_ssp_tmftask-dev >.,
 if()
 }
 (&);

 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: /* the tag is in the free list */
 case TF_TMF_NO_CONN_HANDLE: /* no such device */
  res = TMF_RESP_FUNC_COMPLETE;
  break;
 case TF_TMF_NO_CTX: /* not in seq, or proto != SSP */
  res = TMF_RESP_FUNC_ESUPP;
  break;
 default:
  /* Allow TMF response codes to propagate upwards */
  res = tcs.dl_opcode;
  break;
 }
 return res;
out_err:
 asd_ascb_free(ascb);
 return res;
}

int asd_abort_task_set(struct domain_device *dev, u8 *lun)
{
 int res = asd_initiate_ssp_tmf(dev, lun, TMF_ABORT_TASK_SET, 0);

 if (res == TMF_RESP_FUNC_COMPLETE)
  asd_clear_nexus_I_T_L(dev, lun);
 return res;
}

int asd_clear_task_set(struct domain_device *dev, u8 *lun)
{
 int res = asd_initiate_ssp_tmf(dev, lun, TMF_CLEAR_TASK_SET, 0);

 if (res == TMF_RESP_FUNC_COMPLETE)
  asd_clear_nexus_I_T_L(dev, lun);
 return res;
}

int asd_lu_reset(struct domain_device *dev, u8 *lun)
{
 int res = asd_initiate_ssp_tmf(dev, lun, TMF_LU_RESET, 0);

 if (res == TMF_RESP_FUNC_COMPLETE)
  asd_clear_nexus_I_T_L(dev, lun);
 return res;
}

/**
 * asd_query_task -- send a QUERY TASK TMF to an I_T_L_Q nexus
 * @task: pointer to sas_task struct of interest
 *
 * Returns: TMF_RESP_FUNC_COMPLETE if the task is not in the task set,
 * or TMF_RESP_FUNC_SUCC if the task is in the task set.
 *
 * Normally the management layer sets the task to aborted state,
 * and then calls query task and then abort task.
 */
int asd_query_task(struct sas_task *task)
{
 struct asd_ascb *ascb = task->lldd_task;
 int index;

 if (ascb) {
  index = ascb->tc_index;
  return asd_initiate_ssp_tmf(task->dev, task->ssp_task.LUN,
         TMF_QUERY_TASK, index);
 }
 return TMF_RESP_FUNC_COMPLETE;
}