xref: /freebsd-11-stable/sys/dev/pms/RefTisa/tisa/sassata/sas/ini/itdcb.c

/*******************************************************************************
**
*Copyright (c) 2014 PMC-Sierra, Inc.  All rights reserved.
*
*Redistribution and use in source and binary forms, with or without modification, are permitted provided
*that the following conditions are met:
*1. Redistributions of source code must retain the above copyright notice, this list of conditions and the
*following disclaimer.
*2. Redistributions in binary form must reproduce the above copyright notice,
*this list of conditions and the following disclaimer in the documentation and/or other materials provided
*with the distribution.
*
*THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED
*WARRANTIES,INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
*FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
*FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
*NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
*BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
*LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
*SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE
**
********************************************************************************/
/*****************************************************************************/
/** \file
 *
 * This file contains initiator CB functions
 *
 */
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");
#include <dev/pms/config.h>

#include <dev/pms/freebsd/driver/common/osenv.h>
#include <dev/pms/freebsd/driver/common/ostypes.h>
#include <dev/pms/freebsd/driver/common/osdebug.h>

#include <dev/pms/RefTisa/sallsdk/api/sa.h>
#include <dev/pms/RefTisa/sallsdk/api/saapi.h>
#include <dev/pms/RefTisa/sallsdk/api/saosapi.h>

#include <dev/pms/RefTisa/tisa/api/titypes.h>
#include <dev/pms/RefTisa/tisa/api/ostiapi.h>
#include <dev/pms/RefTisa/tisa/api/tiapi.h>
#include <dev/pms/RefTisa/tisa/api/tiglobal.h>

#ifdef FDS_SM
#include <dev/pms/RefTisa/sat/api/sm.h>
#include <dev/pms/RefTisa/sat/api/smapi.h>
#include <dev/pms/RefTisa/sat/api/tdsmapi.h>
#endif

#ifdef FDS_DM
#include <dev/pms/RefTisa/discovery/api/dm.h>
#include <dev/pms/RefTisa/discovery/api/dmapi.h>
#include <dev/pms/RefTisa/discovery/api/tddmapi.h>
#endif

#include <dev/pms/RefTisa/tisa/sassata/sas/common/tdtypes.h>
#include <dev/pms/freebsd/driver/common/osstring.h>
#include <dev/pms/RefTisa/tisa/sassata/common/tdutil.h>

#ifdef INITIATOR_DRIVER
#include <dev/pms/RefTisa/tisa/sassata/sas/ini/itdtypes.h>
#include <dev/pms/RefTisa/tisa/sassata/sas/ini/itddefs.h>
#include <dev/pms/RefTisa/tisa/sassata/sas/ini/itdglobl.h>
#endif

#ifdef TARGET_DRIVER
#include <dev/pms/RefTisa/tisa/sassata/sas/tgt/ttdglobl.h>
#include <dev/pms/RefTisa/tisa/sassata/sas/tgt/ttdxchg.h>
#include <dev/pms/RefTisa/tisa/sassata/sas/tgt/ttdtypes.h>
#endif

#include <dev/pms/RefTisa/tisa/sassata/common/tdsatypes.h>
#include <dev/pms/RefTisa/tisa/sassata/common/tdproto.h>

/*****************************************************************************
*!  \brief  itdssTaskCompleted
*
*  Purpose: This routine is called to complete an task management request
*           previously issued to the LL Layer. All task management completes with
*           this function except query task management.
*
*   \param  agRoot:         Pointer to driver Instance.
*   \param  agIORequest:    Pointer to the I/O Request data structure for
*                           this I/O.
*   \param  agIOStatus:     Status of I/O just completed.
*   \param  agIOInfoLen:    Length of the I/O information associated with this
*                           I/O request
*   \param   agParam        A Handle used to refer to the response frame or handle
*                           of abort request
*   \param  agOtherInfo        Residual count
*   \return:                None
*
*   \note - This is a initiator specific function called by the jump table.
*
*****************************************************************************/
osGLOBAL void
itdssTaskCompleted(
                 agsaRoot_t             *agRoot,
                 agsaIORequest_t        *agIORequest,
                 bit32                  agIOStatus,
                 bit32                  agIOInfoLen,
                 void                   *agParam,
                 bit32                  agOtherInfo
                 )
{
  tdsaRootOsData_t            *osData = (tdsaRootOsData_t *)agRoot->osData;
  tiRoot_t                    *tiRoot = (tiRoot_t *)osData->tiRoot;
  tiIORequest_t               *taskTag = agNULL, *currentTaskTag = agNULL;
  tdIORequestBody_t           *tdIORequestBody = agNULL;
  tdIORequestBody_t           *TMtdIORequestBody = agNULL;
  tdIORequestBody_t           *AborttdIORequestBody = agNULL;
  agsaIORequest_t             *agTaskedIORequest;
  agsaSSPResponseInfoUnit_t   agSSPRespIU;
  bit8                        respData[128];
  bit32                       respLen;
#ifdef  TD_DEBUG_ENABLE
  bit32                       data_status;
#endif
  agsaSASRequestBody_t        *agSASRequestBody = agNULL;
  agsaSSPScsiTaskMgntReq_t    *agSSPTaskMgntRequest = agNULL;
  agsaIORequest_t             *agAbortIORequest;
  tdIORequestBody_t           *tdAbortIORequestBody;
  bit32                       PhysUpper32;
  bit32                       PhysLower32;
  bit32                       memAllocStatus;
  void                        *osMemHandle;
  bit32                       abortOrquery = agTRUE;
  tiDeviceHandle_t            *tiDeviceHandle = agNULL;
  tdsaDeviceData_t            *oneDeviceData = agNULL;
  agsaDevHandle_t             *agDevHandle = agNULL;
  bit32                        status = AGSA_RC_FAILURE;

  TI_DBG2(("itdssTaskCompleted: start\n"));

  tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;

  /* check the agIOStatus */
  currentTaskTag = tdIORequestBody->IOType.InitiatorTMIO.CurrentTaskTag;

  if (currentTaskTag == agNULL)
  {
    TI_DBG1(("itdssTaskCompleted: currentTaskTag is NULL \n"));
	/* as the currentTaskTag is agNULL, shall not call ostiInitiatorEvent */
	#if 0
    ostiInitiatorEvent( tiRoot,
                        NULL,
                        NULL,
                        tiIntrEventTypeTaskManagement,
                        tiTMFailed,
                        currentTaskTag );
    #endif
    /* free up allocated memory */
    ostiFreeMemory(
                   tiRoot,
                   tdIORequestBody->IOType.InitiatorTMIO.osMemHandle,
                   sizeof(tdIORequestBody_t)
                   );
    return;
  }

  if (agIOStatus != OSSA_IO_SUCCESS)
  {
    TI_DBG1(("itdssTaskCompleted: agIOStatus failed and tiTMFailed\n"));
    if (agIOStatus == OSSA_IO_TM_TAG_NOT_FOUND)
    {
      TI_DBG1(("itdssTaskCompleted: agIOStatus OSSA_IO_TM_TAG_NOT_FOUND\n"));
    }
    else
    if (agIOStatus == OSSA_IO_ABORTED)
    {
      TI_DBG1(("itdssTaskCompleted: agIOStatus OSSA_IO_ABORTED\n"));
    }
    else
    {
      TI_DBG1(("itdssTaskCompleted: agIOStatus 0x%x\n", agIOStatus));
    }
    ostiInitiatorEvent( tiRoot,
                        NULL,
                        NULL,
                        tiIntrEventTypeTaskManagement,
                        tiTMFailed,
                        currentTaskTag );
    /* free up allocated memory */
    ostiFreeMemory(
                   tiRoot,
                   tdIORequestBody->IOType.InitiatorTMIO.osMemHandle,
                   sizeof(tdIORequestBody_t)
                   );
    return;
  }

  /* parse the task management response */
  /* reads agsaSSPResponseInfoUnit_t */
  saFrameReadBlock(agRoot, agParam, 0, &agSSPRespIU, sizeof(agsaSSPResponseInfoUnit_t));
#ifdef  TD_DEBUG_ENABLE
  data_status = SA_SSPRESP_GET_DATAPRES(&agSSPRespIU);
#endif
  respLen = SA_SSPRESP_GET_RESPONSEDATALEN(&agSSPRespIU);
  TI_DBG6(("itdssTaskCompleted: dataPres %d. should be 1\n", data_status));
  /* reads response data */
  saFrameReadBlock(agRoot, agParam,
                   sizeof(agsaSSPResponseInfoUnit_t),
                   respData, respLen);
  TI_DBG6(("itdssTaskCompleted: res code %d. should be 0\n", respData[3]));

  taskTag = tdIORequestBody->IOType.InitiatorTMIO.TaskTag;
  if (taskTag == agNULL)
  {
    /* other than Abort Task or Query Task */
    TI_DBG1(("itdssTaskCompleted: taskTag is NULL\n"));

    abortOrquery = agFALSE;
    TMtdIORequestBody = (tdIORequestBody_t *)currentTaskTag->tdData;
  }
  else
  {
    /* Abort Task or Query Task */
    TI_DBG2(("itdssTaskCompleted: taskTag is NOT NULL\n"));
    abortOrquery = agTRUE;
    TMtdIORequestBody = (tdIORequestBody_t *)currentTaskTag->tdData;
  }

  TI_DBG2(("itdssTaskCompleted: TMtdIORequestBody %p\n", TMtdIORequestBody));

  if (TMtdIORequestBody == agNULL)
  {
    TI_DBG1(("itdssTaskCompleted: TMtdIORequestBody is NULL \n"));
    ostiInitiatorEvent( tiRoot,
                        NULL,
                        NULL,
                        tiIntrEventTypeTaskManagement,
                        tiTMFailed,
                        currentTaskTag );
    /* free up allocated memory */
    ostiFreeMemory(
                   tiRoot,
                   tdIORequestBody->IOType.InitiatorTMIO.osMemHandle,
                   sizeof(tdIORequestBody_t)
                   );
    return;
  }

  if (agIOStatus == OSSA_IO_SUCCESS && agIOInfoLen == 0)
  {
    TI_DBG1(("itdssTaskCompleted: agIOInfoLen is zero, wrong\n"));
    ostiInitiatorEvent( tiRoot,
                        NULL,
                        NULL,
                        tiIntrEventTypeTaskManagement,
                        tiTMFailed,
                        currentTaskTag );
    /* free up allocated memory */
    ostiFreeMemory(
                   tiRoot,
                   tdIORequestBody->IOType.InitiatorTMIO.osMemHandle,
                   sizeof(tdIORequestBody_t)
                   );
    return;
  }

  agSASRequestBody = (agsaSASRequestBody_t *)&(TMtdIORequestBody->transport.SAS.agSASRequestBody);
  agSSPTaskMgntRequest = (agsaSSPScsiTaskMgntReq_t *)&(agSASRequestBody->sspTaskMgntReq);
  TI_DBG2(("itdssTaskCompleted: agSSPTaskMgntRequest->taskMgntFunction 0x%x\n", agSSPTaskMgntRequest->taskMgntFunction));

  if ( (agSSPTaskMgntRequest->taskMgntFunction == AGSA_ABORT_TASK ||
        agSSPTaskMgntRequest->taskMgntFunction == AGSA_QUERY_TASK) &&
        abortOrquery == agFALSE
      )
  {
    TI_DBG1(("itdssTaskCompleted: incorrect tasktag, first\n"));
    ostiInitiatorEvent( tiRoot,
                        NULL,
                        NULL,
                        tiIntrEventTypeTaskManagement,
                        tiTMFailed,
                        currentTaskTag );
    /* free up allocated memory */
    ostiFreeMemory(
                   tiRoot,
                   tdIORequestBody->IOType.InitiatorTMIO.osMemHandle,
                   sizeof(tdIORequestBody_t)
                   );
    return;
  }

  if ((agSSPTaskMgntRequest->taskMgntFunction == AGSA_ABORT_TASK_SET ||
       agSSPTaskMgntRequest->taskMgntFunction == AGSA_CLEAR_TASK_SET ||
       agSSPTaskMgntRequest->taskMgntFunction == AGSA_LOGICAL_UNIT_RESET ||
       agSSPTaskMgntRequest->taskMgntFunction == AGSA_CLEAR_ACA ) &&
       abortOrquery == agTRUE
     )
  {
    TI_DBG1(("itdssTaskCompleted: incorrect tasktag, second\n"));
    ostiInitiatorEvent( tiRoot,
                        NULL,
                        NULL,
                        tiIntrEventTypeTaskManagement,
                        tiTMFailed,
                        currentTaskTag );
    /* free up allocated memory */
    ostiFreeMemory(
                   tiRoot,
                   tdIORequestBody->IOType.InitiatorTMIO.osMemHandle,
                   sizeof(tdIORequestBody_t)
                   );
    return;
  }


  if (agSSPTaskMgntRequest->taskMgntFunction == AGSA_ABORT_TASK)
  {
    TI_DBG2(("itdssTaskCompleted: calling saSSPAbort()\n"));
    AborttdIORequestBody = (tdIORequestBody_t *)taskTag->tdData;
    if (AborttdIORequestBody == agNULL)
    {
      TI_DBG1(("itdssTaskCompleted: wrong, AborttdIORequestBody is NULL\n"));
      return;
    }

    tiDeviceHandle = AborttdIORequestBody->tiDevHandle;
    if (tiDeviceHandle == agNULL)
    {
      TI_DBG1(("itdssTaskCompleted: wrong, tiDeviceHandle is NULL\n"));
      return;
    }
    oneDeviceData  = (tdsaDeviceData_t *)tiDeviceHandle->tdData;
    if (oneDeviceData == agNULL)
    {
      TI_DBG1(("itdssTaskCompleted: wrong, oneDeviceData is NULL\n"));
      return;
    }
    agDevHandle = oneDeviceData->agDevHandle;
    if (agDevHandle == agNULL)
    {
      TI_DBG1(("itdssTaskCompleted: wrong, agDevHandle is NULL\n"));
    }

    agTaskedIORequest = (agsaIORequest_t *)&(AborttdIORequestBody->agIORequest);
    if (agTaskedIORequest == agNULL)
    {
      TI_DBG1(("itdssTaskCompleted: agTaskedIORequest is NULL \n"));
      ostiInitiatorEvent( tiRoot,
                          NULL,
                          NULL,
                          tiIntrEventTypeTaskManagement,
                          tiTMFailed,
                          currentTaskTag );
      /* free up allocated memory */
      ostiFreeMemory(
                     tiRoot,
                     tdIORequestBody->IOType.InitiatorTMIO.osMemHandle,
                     sizeof(tdIORequestBody_t)
                     );
      return;
    }


    /* allocating agIORequest for abort itself */
    memAllocStatus = ostiAllocMemory(
                                     tiRoot,
                                     &osMemHandle,
                                     (void **)&tdAbortIORequestBody,
                                     &PhysUpper32,
                                     &PhysLower32,
                                     8,
                                     sizeof(tdIORequestBody_t),
                                     agTRUE
                                     );
    if (memAllocStatus != tiSuccess)
    {
      /* let os process IO */
      TI_DBG1(("itdssTaskCompleted: ostiAllocMemory failed...\n"));
      return;
    }

    if (tdAbortIORequestBody == agNULL)
    {
      /* let os process IO */
      TI_DBG1(("itdssTaskCompleted: ostiAllocMemory returned NULL tdAbortIORequestBody\n"));
      return;
    }

    /* setup task management structure */
    tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle = osMemHandle;
    tdAbortIORequestBody->tiDevHandle = tiDeviceHandle;
    /* setting callback */
    tdAbortIORequestBody->IOCompletionFunc = itdssIOAbortedHandler;

    /* setting to NULL because the local abort is triggered by TD layer */
    tdAbortIORequestBody->tiIOToBeAbortedRequest = agNULL;
    /* initialize agIORequest */
    agAbortIORequest = &(tdAbortIORequestBody->agIORequest);
    agAbortIORequest->osData = (void *) tdAbortIORequestBody;
    agAbortIORequest->sdkData = agNULL; /* LL takes care of this */

    status = saSSPAbort(agRoot, agAbortIORequest, tdsaRotateQnumber(tiRoot, oneDeviceData), agDevHandle, 0, agTaskedIORequest, agNULL);
    if (status != AGSA_RC_SUCCESS)
    {
      TI_DBG1(("itdssTaskCompleted: saSSPAbort failed agIOInfoLen is zero, wrong\n"));
      ostiFreeMemory(
                     tiRoot,
                     tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
                     sizeof(tdIORequestBody_t)
                     );
    }
  }

  /*
    parse the response and based on the parse,
    set the flag
  */
  if (respData[3] == AGSA_TASK_MANAGEMENT_FUNCTION_COMPLETE ||
      respData[3] == AGSA_TASK_MANAGEMENT_FUNCTION_SUCCEEDED)
  {
    TI_DBG2(("itdssTaskCompleted: tiTMOK\n"));
    tiDeviceHandle = TMtdIORequestBody->tiDevHandle;
    if (tiDeviceHandle == agNULL)
    {
      TI_DBG1(("itdssTaskCompleted: wrong, tiDeviceHandle is NULL\n"));
      return;
    }
    oneDeviceData  = (tdsaDeviceData_t *)tiDeviceHandle->tdData;
    if (oneDeviceData == agNULL)
    {
      TI_DBG1(("itdssTaskCompleted: wrong, oneDeviceData is NULL\n"));
      return;
    }
    agDevHandle = oneDeviceData->agDevHandle;
    if (agDevHandle == agNULL)
    {
      TI_DBG1(("itdssTaskCompleted: wrong, agDevHandle is NULL\n"));
    }
    TI_DBG2(("itdssTaskCompleted: setting Device state to SA_DS_OPERATIONAL\n"));

    saSetDeviceState(agRoot, agNULL, tdsaRotateQnumber(tiRoot, oneDeviceData), agDevHandle, SA_DS_OPERATIONAL);

    ostiInitiatorEvent( tiRoot,
                        NULL,
                        NULL,
                        tiIntrEventTypeTaskManagement,
                        tiTMOK,
                        currentTaskTag );
  }
  else
  {
    TI_DBG1(("itdssTaskCompleted: tiTMFailed\n"));
    ostiInitiatorEvent( tiRoot,
                        NULL,
                        NULL,
                        tiIntrEventTypeTaskManagement,
                        tiTMFailed,
                        currentTaskTag );

  }

  /* free up allocated memory */
  ostiFreeMemory(
                 tiRoot,
                 tdIORequestBody->IOType.InitiatorTMIO.osMemHandle,
                 sizeof(tdIORequestBody_t)
                 );
  return;
}

#ifdef INITIATOR_DRIVER

/*****************************************************************************
*!  \brief  itdssQueryTaskCompleted
*
*  Purpose: This routine is called to complete an query task management request
*           previously issued to the LL Layer.
*
*   \param  agRoot:         Pointer to driver Instance.
*   \param  agIORequest:    Pointer to the I/O Request data structure for
*                           this I/O.
*   \param  agIOStatus:     Status of I/O just completed.
*   \param  agIOInfoLen:    Length of the I/O information associated with this
*                           I/O request
*   \param   agParam        A Handle used to refer to the response frame or handle
*                           of abort request
*
*   \return:                None
*
*   \note - This is a initiator specific function called by the jump table.
*
*****************************************************************************/
osGLOBAL void
itdssQueryTaskCompleted(
                        agsaRoot_t             *agRoot,
                        agsaIORequest_t        *agIORequest,
                        bit32                  agIOStatus,
                        bit32                  agIOInfoLen,
                        void                   *agParam,
                        bit32                  agOtherInfo
                        )
{
  tdsaRootOsData_t            *osData = (tdsaRootOsData_t *)agRoot->osData;
  tiRoot_t                    *tiRoot = (tiRoot_t *)osData->tiRoot;
  tiIORequest_t               *taskTag = agNULL;
  tdIORequestBody_t           *tdIORequestBody = agNULL;  /* query task */
  tdIORequestBody_t           *TMtdIORequestBody = agNULL; /* IO being query tasked */
  agsaIORequest_t             *agTaskedIORequest = agNULL;
  agsaSSPResponseInfoUnit_t   agSSPRespIU;
  bit8                        respData[128];
  bit32                       respLen;
#ifdef  TD_DEBUG_ENABLE
  bit32                       data_status;
#endif
  agsaSASRequestBody_t        *agSASRequestBody = agNULL;
  agsaSSPScsiTaskMgntReq_t    *agSSPTaskMgntRequest = agNULL;
  bit32                       status;
  agsaIORequest_t             *agAbortIORequest = agNULL;
  tdIORequestBody_t           *tdAbortIORequestBody = agNULL;
  bit32                       PhysUpper32;
  bit32                       PhysLower32;
  bit32                       memAllocStatus;
  void                        *osMemHandle = agNULL;
  tiDeviceHandle_t            *tiDeviceHandle = agNULL;
  tdsaDeviceData_t            *oneDeviceData = agNULL;
  agsaDevHandle_t             *agDevHandle = agNULL;

  TI_DBG2(("itdssQueryTaskComplted: start\n"));

  /* query task management IORequestBody */
  tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;

  /* OS's tiIORequest for this query taks, which is agNULL */
  //currentTaskTag = tdIORequestBody->IOType.InitiatorTMIO.CurrentTaskTag;

  /*
    currentTaskTag is agNULL for query task since it is generated by
    TD layer
  */
  if (agIOStatus != OSSA_IO_SUCCESS)
  {
    /* let os process IO */
    TI_DBG1(("itdssQueryTaskComplted: agIOStatus failed and tiTMFailed\n"));
    /* free up allocated memory */
    ostiFreeMemory(
                   tiRoot,
                   tdIORequestBody->IOType.InitiatorTMIO.osMemHandle,
                   sizeof(tdIORequestBody_t)
                   );
    return;
  }
  /* parse the task management response */
  /* reads agsaSSPResponseInfoUnit_t */
  saFrameReadBlock(agRoot, agParam, 0, &agSSPRespIU, sizeof(agsaSSPResponseInfoUnit_t));
#ifdef  TD_DEBUG_ENABLE
  data_status = SA_SSPRESP_GET_DATAPRES(&agSSPRespIU);
#endif
  respLen = SA_SSPRESP_GET_RESPONSEDATALEN(&agSSPRespIU);

  TI_DBG6(("itdssQueryTaskCompleted: dataPres %d. should be 1\n", data_status));
  /* reads response data */
  saFrameReadBlock(agRoot, agParam,
                   sizeof(agsaSSPResponseInfoUnit_t),
                   respData, respLen);

  TI_DBG6(("itdssQueryTaskCompleted: res code %d. should be 0\n", respData[3]));

  /* IO being query tasked */
  taskTag = tdIORequestBody->IOType.InitiatorTMIO.TaskTag;
  if (taskTag == agNULL)
  {
    TI_DBG1(("itdssQueryTaskComplted: taskTag is NULL \n"));
    /* free up allocated memory */
    ostiFreeMemory(
                   tiRoot,
                   tdIORequestBody->IOType.InitiatorTMIO.osMemHandle,
                   sizeof(tdIORequestBody_t)
                   );
    return;
  }

  /* request body of IO being query tasked  */
  TMtdIORequestBody = (tdIORequestBody_t *)taskTag->tdData;
  if (TMtdIORequestBody == agNULL)
  {
    TI_DBG1(("itdssQueryTaskComplted: TMtdIORequestBody is NULL \n"));
    /* free up allocated memory */
    ostiFreeMemory(
                   tiRoot,
                   tdIORequestBody->IOType.InitiatorTMIO.osMemHandle,
                   sizeof(tdIORequestBody_t)
                   );
    return;
  }

  agTaskedIORequest = &(TMtdIORequestBody->agIORequest);
  if (agTaskedIORequest == agNULL)
  {
    TI_DBG1(("itdssQueryTaskComplted: agTaskedIORequest is NULL \n"));
    /* free up allocated memory */
    ostiFreeMemory(
                   tiRoot,
                   tdIORequestBody->IOType.InitiatorTMIO.osMemHandle,
                   sizeof(tdIORequestBody_t)
                   );
    return;
  }

  if (agIOStatus == OSSA_IO_SUCCESS && agIOInfoLen == 0)
  {
    TI_DBG1(("itdssQueryTaskCompleted: agIOInfoLen is zero, wrong\n"));
    /* free up allocated memory */
    ostiFreeMemory(
                   tiRoot,
                   tdIORequestBody->IOType.InitiatorTMIO.osMemHandle,
                   sizeof(tdIORequestBody_t)
                   );
   return;
  }
  /* this is query task itself */
  agSASRequestBody = &(tdIORequestBody->transport.SAS.agSASRequestBody);
  agSSPTaskMgntRequest = &(agSASRequestBody->sspTaskMgntReq);
  if (agSSPTaskMgntRequest->taskMgntFunction == AGSA_QUERY_TASK)
  {
    /*
      process response for query task
      For query task, response code must be either
      TASK MANAGEMENT FUNCTION COMPLETE or TASK MANAGEMENT FUNCTION SUCCEEDED by
      SAM

      1. If TASK MANAGEMENT FUNCTION SUCCEEDE, do nothing

      2. If TASK MANAGEMENT FUNCTION COMPLETE and IO is not completed,
      retry by saSSPAbort()
    */
    if (respData[3] == AGSA_TASK_MANAGEMENT_FUNCTION_SUCCEEDED)
    {
      /* OK; IO is being process at the target; do nothing */
    }
    else if (respData[3] == AGSA_TASK_MANAGEMENT_FUNCTION_COMPLETE)
    {
      tiDeviceHandle = TMtdIORequestBody->tiDevHandle;
      if (tiDeviceHandle == agNULL)
      {
        TI_DBG1(("itdssQueryTaskCompleted: wrong, tiDeviceHandle is NULL\n"));
        /* free up allocated memory */
        ostiFreeMemory(
                       tiRoot,
                       tdIORequestBody->IOType.InitiatorTMIO.osMemHandle,
                       sizeof(tdIORequestBody_t)
                       );
        return;
      }
      oneDeviceData  = (tdsaDeviceData_t *)tiDeviceHandle->tdData;
      if (oneDeviceData == agNULL)
      {
        TI_DBG1(("itdssQueryTaskCompleted: wrong, oneDeviceData is NULL\n"));
        /* free up allocated memory */
        ostiFreeMemory(
                       tiRoot,
                       tdIORequestBody->IOType.InitiatorTMIO.osMemHandle,
                       sizeof(tdIORequestBody_t)
                       );

        return;
      }
      agDevHandle = oneDeviceData->agDevHandle;
      if (agDevHandle == agNULL)
      {
        TI_DBG1(("itdssQueryTaskCompleted: wrong, agDevHandle is NULL\n"));
      }
      /* if IO is not completed, retry IO by saSSPAbort() */
      if (TMtdIORequestBody->ioCompleted != agTRUE)
      {
        /* allocating agIORequest for abort itself */
        memAllocStatus = ostiAllocMemory(
                                         tiRoot,
                                         &osMemHandle,
                                         (void **)&tdAbortIORequestBody,
                                         &PhysUpper32,
                                         &PhysLower32,
                                         8,
                                         sizeof(tdIORequestBody_t),
                                         agTRUE
                                         );
        if (memAllocStatus != tiSuccess)
        {
          /* let os process IO */
          TI_DBG1(("itdssQueryTaskCompleted: ostiAllocMemory failed...\n"));
          /* free up allocated memory */
          ostiFreeMemory(
                         tiRoot,
                         tdIORequestBody->IOType.InitiatorTMIO.osMemHandle,
                         sizeof(tdIORequestBody_t)
                         );

          return;
        }
        if (tdAbortIORequestBody == agNULL)
        {
          /* let os process IO */
          TI_DBG1(("itdssQueryTaskCompleted: ostiAllocMemory returned NULL tdAbortIORequestBody\n"));
          /* free up allocated memory */
          ostiFreeMemory(
                         tiRoot,
                         tdIORequestBody->IOType.InitiatorTMIO.osMemHandle,
                         sizeof(tdIORequestBody_t)
                         );

          return;
        }

        /* setup task management structure */
        tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle = osMemHandle;
        tdAbortIORequestBody->tiDevHandle = tdIORequestBody->tiDevHandle;
        tdAbortIORequestBody->tiIOToBeAbortedRequest = agNULL;

        /* setting callback */
        tdAbortIORequestBody->IOCompletionFunc = itdssIOAbortedHandler;

        /* initialize agIORequest */
        agAbortIORequest = &(tdAbortIORequestBody->agIORequest);
        agAbortIORequest->osData = (void *) tdAbortIORequestBody;
        agAbortIORequest->sdkData = agNULL; /* LL takes care of this */

        TI_DBG2(("itdssQueryTaskCompleted: issuing saSSPAbort()\n"));
        status = saSSPAbort(agRoot, agAbortIORequest, tdsaRotateQnumber(tiRoot, oneDeviceData), agDevHandle, 0, agTaskedIORequest, agNULL);
        if (status != AGSA_RC_SUCCESS)
        {
          TI_DBG1(("itdssQueryTaskCompleted: saSSPAbort failed agIOInfoLen is zero, wrong\n"));
          ostiFreeMemory(
                         tiRoot,
                         tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
                         sizeof(tdIORequestBody_t)
                         );
        }
      }
    }
    else
    {
      TI_DBG1(("itdssQueryTaskComplted: not expected response 0x%x\n",respData[3]));
    }
  }
  else
  {
    TI_DBG1(("itdssQueryTaskCompleted: not expected task management fn %d\n",agSSPTaskMgntRequest->taskMgntFunction));
  }

  /* free up allocated memory */
  ostiFreeMemory(
                 tiRoot,
                 tdIORequestBody->IOType.InitiatorTMIO.osMemHandle,
                 sizeof(tdIORequestBody_t)
                 );
  return;
}
#endif

/*****************************************************************************
*!  \brief  itssdosIOCompleted
*
*  Purpose: This routine is called to complete an I/O request previously
*           issued to the LL Layer in saSSPStart().
*
*   \param  agRoot:       Pointer to driver Instance.
*   \param  agIORequest:  Pointer to the I/O Request data structure for
*                         this I/O.
*   \param  agIOStatus:   Status of I/O just completed.
*   \param  agIOInfoLen:  Length of the I/O information associated with this
*                         I/O request
*   \param   agParam      A Handle used to refer to the response frame or handle
*                         of abort request
*  \param  agOtherInfo    Residual count
*   \return:              None
*
*   \note - This is a initiator specific function called by the jump table.
*
*****************************************************************************/
FORCEINLINE void
itdssIOCompleted(
                 agsaRoot_t             *agRoot,
                 agsaIORequest_t        *agIORequest,
                 bit32                   agIOStatus,
                 bit32                   agIOInfoLen,
                 void                   *agParam,
                 bit32                   agOtherInfo
                 )
{
  tdsaRootOsData_t          *osData = (tdsaRootOsData_t *)agRoot->osData;
  tiRoot_t                  *tiRoot = (tiRoot_t *)osData->tiRoot;
  itdsaIni_t                *Initiator = (itdsaIni_t *)osData->itdsaIni;
  tdIORequestBody_t         *tdIORequestBody  = agNULL;
  agsaSASRequestBody_t      *agSASRequestBody = agNULL;
  agsaSSPInitiatorRequest_t *agSSPInitiatorRequest = agNULL;
  agsaSSPResponseInfoUnit_t  agSSPRespIU;

  bit32 scsi_status = 0;

  tiDeviceHandle_t          *tiDeviceHandle = agNULL;
  tdsaDeviceData_t          *oneDeviceData  = agNULL;

  TI_DBG6(("itdssIOCompleted: start\n"));
  TI_DBG6(("itdssIOCompleted: agIOInfoLen %d\n", agIOInfoLen));

  tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
  TD_ASSERT((NULL != tdIORequestBody), "itdssIOCompleted:tdIORequestBody NULL");
  if ( NULL == tdIORequestBody )  // handle windows assert case
  {
    return;
  }
  Initiator->NumIOsActive--;

#ifdef DBG
  if (tdIORequestBody->ioCompleted == agTRUE)
  {
#ifdef  TD_DEBUG_ENABLE
    tiDeviceHandle = tdIORequestBody->tiDevHandle;
    oneDeviceData  = (tdsaDeviceData_t *)tiDeviceHandle->tdData;
#endif /*TD_DEBUG_ENABLE*/
    TI_DBG1(("itdssIOCompleted: Error!!!!!! double completion\n"));
#ifdef  TD_DEBUG_ENABLE
    TI_DBG1(("itdssIOCompleted: did %d \n", oneDeviceData->id));
#endif /*TD_DEBUG_ENABLE*/
  }

  if (Initiator->NumIOsActive == 0)
  {
    /* so far, no timer assocaicated here */
    TI_DBG6(("itdssIOCompleted: no acitve IO's. Kill timers\n"));
  }

  if (tdIORequestBody->tiIORequest->osData == agNULL)
  {
    TI_DBG1( ("itdssIOCompleted: pos 1; "
              "tdIORequestBody->tiIORequest->osData is null, wrong\n") );
  }
#endif /*DBG*/

  tdIORequestBody->ioCompleted = agTRUE;
  tdIORequestBody->ioStarted = agFALSE;

  /* Process completion for debugging, printing cbd */
  agSASRequestBody = &(tdIORequestBody->transport.SAS.agSASRequestBody);
  agSSPInitiatorRequest = &(agSASRequestBody->sspInitiatorReq);

  TI_DBG6( ("itdssIOCompleted: CDB 0x%x\n",
            agSSPInitiatorRequest->sspCmdIU.cdb[0]) );

  /* no respsonse or sense data; data has been processed */
  if((agIOStatus == OSSA_IO_SUCCESS) && (agIOInfoLen == 0))
  {
    // if this is a standard Inquiry command, notify Stoport to set the
    // device queue depth to maximize oustanding IO
    if ( (agSSPInitiatorRequest->sspCmdIU.cdb[0] == SCSIOPC_INQUIRY) &&
         ((agSSPInitiatorRequest->sspCmdIU.cdb[1] & 0x01) == 0))
    {
      bit32 qdepth = 32;
      tiDeviceHandle = tdIORequestBody->tiDevHandle;
      if( tiDeviceHandle )
      {
        oneDeviceData = (tdsaDeviceData_t *)tiDeviceHandle->tdData;
        if( oneDeviceData->DeviceType == TD_SAS_DEVICE )
        {
          qdepth = MAX_OUTSTANDING_IO_PER_LUN;
        }
        if( oneDeviceData->DeviceType == TD_SATA_DEVICE )
        {
          qdepth = 63;
        }
      }

      if ( ostiSetDeviceQueueDepth( tiRoot,
                                    tdIORequestBody->tiIORequest,
                                    MAX_OUTSTANDING_IO_PER_LUN ) == agFALSE )
      {
        TI_DBG1( ( "itdssIOCompleted: failed to call "
                   "ostiSetDeviceQueueDepth() Q=%d !!!\n", qdepth ) );
      }
      else
      {
        TI_DBG2(("itdssIOCompleted: set ostiSetDeviceQueueDepth() Q=%d\n",qdepth));
      }
    }
    // SCSI command was completed OK, this is the normal path. Now call the
    // OS Specific module about this completion.
    ostiInitiatorIOCompleted(
                             tiRoot,
                             tdIORequestBody->tiIORequest,
                             tiIOSuccess,
                             SCSI_STAT_GOOD,
                             agNULL,
                             agTRUE /* intContext; is not being used */
                             );
    return;
  }

  else
  {
    TI_DBG6(("itdssIOCompleted: SUCCESS but data returned \n"));
    TI_DBG6( ("itdssIOCompleted: agIOStatus SUCCESS but data returned 0x%x\n",
              agIOStatus) );
    if(tdIORequestBody)
    {
      tiDeviceHandle = tdIORequestBody->tiDevHandle;
      if(tiDeviceHandle)
      {
        oneDeviceData  = (tdsaDeviceData_t *)tiDeviceHandle->tdData;
      }
    }

    osti_memset(&agSSPRespIU, 0, sizeof(agsaSSPResponseInfoUnit_t));

    saFrameReadBlock( agRoot,
                      agParam,
                      0,
                      &agSSPRespIU,
                      sizeof(agsaSSPResponseInfoUnit_t) );
    scsi_status = agSSPRespIU.status;

    switch (scsi_status)
    {
      case SCSI_STAT_GOOD:
        TI_DBG2( ("itdssIOCompleted: SCSI_STAT_GOOD %d\n",
                  Initiator->ScsiStatusCounts.GoodStatus) );
        Initiator->ScsiStatusCounts.GoodStatus++;
        break;
       case SCSI_STAT_CHECK_CONDITION:
        TI_DBG1( ("itdssIOCompleted: SCSI_STAT_CHECK_CONDITION %d\n",
                  Initiator->ScsiStatusCounts.CheckCondition) );
        Initiator->ScsiStatusCounts.CheckCondition++;
        break;
      case SCSI_STAT_BUSY:
        TI_DBG1( ("itdssIOCompleted: SCSI_STAT_BUSY %d\n",
                  Initiator->ScsiStatusCounts.BusyStatus) );
        Initiator->ScsiStatusCounts.BusyStatus++;
        break;
      case SCSI_STAT_RESV_CONFLICT:
        TI_DBG1( ("itdssIOCompleted: SCSI_STAT_RESV_CONFLICT %d\n",
                  Initiator->ScsiStatusCounts.ResvConflict) );
        Initiator->ScsiStatusCounts.ResvConflict++;
        break;
      case SCSI_STAT_TASK_SET_FULL:
        Initiator->ScsiStatusCounts.TaskSetFull++;
        //agIOStatus =  OSSA_IO_FAILED;
        //agOtherInfo = tiDetailBusy;
        TI_DBG1( ("itdssIOCompleted: SCSI_STAT_TASK_SET_FULL %d\n",
                  Initiator->ScsiStatusCounts.TaskSetFull) );
        break;
      case SCSI_STAT_ACA_ACTIVE:
        Initiator->ScsiStatusCounts.AcaActive++;
        TI_DBG1( ("itdssIOCompleted: SCSI_STAT_ACA_ACTIVE %d\n",
                  Initiator->ScsiStatusCounts.AcaActive) );
        break;
      case SCSI_STAT_TASK_ABORTED:
        Initiator->ScsiStatusCounts.TaskAborted++;
        TI_DBG1( ("itdssIOCompleted: SCSI_STAT_TASK_ABORTED %d\n",
                  Initiator->ScsiStatusCounts.TaskAborted) );
        break;
      case SCSI_STAT_CONDITION_MET:
        Initiator->ScsiStatusCounts.ConditionMet++;
        TI_DBG1( ("itdssIOCompleted: SCSI_STAT_CONDITION_MET %d\n",
                  Initiator->ScsiStatusCounts.ConditionMet) );
        break;
      case SCSI_STAT_INTERMEDIATE:
        TI_DBG1( ("itdssIOCompleted: SCSI_STAT_INTERMEDIATE %d\n",
                  Initiator->ScsiStatusCounts.ObsoleteStatus) );
        Initiator->ScsiStatusCounts.ObsoleteStatus++;
        break;
      case SCSI_STAT_INTER_CONDIT_MET:
        TI_DBG1( ("itdssIOCompleted: SCSI_STAT_INTER_CONDIT_MET %d\n",
                  Initiator->ScsiStatusCounts.ObsoleteStatus) );
        Initiator->ScsiStatusCounts.ObsoleteStatus++;
        break;
      case SCSI_STAT_COMMANDTERMINATED:
        TI_DBG1( ("itdssIOCompleted: SCSI_STAT_COMMANDTERMINATED %d\n",
                  Initiator->ScsiStatusCounts.ObsoleteStatus) );
        Initiator->ScsiStatusCounts.ObsoleteStatus++;
        break;
      default:
        Initiator->ScsiStatusCounts.ObsoleteStatus++;
        TI_DBG1( ("itdssIOCompleted: Unknown scsi_status %d 0x%x\n",
                  scsi_status,Initiator->ScsiStatusCounts.ObsoleteStatus) );
    }

    switch (agIOStatus)
    {
    case OSSA_IO_SUCCESS:
      itdssIOSuccessHandler( agRoot,
                             agIORequest,
                             agIOStatus,
                             agIOInfoLen,
                             agParam,
                             agOtherInfo );
      break;
    case OSSA_IO_ABORTED:
      itdssIOAbortedHandler( agRoot,
                             agIORequest,
                             agIOStatus,
                             agIOInfoLen,
                             agParam,
                             agOtherInfo );
      break;
    case OSSA_IO_UNDERFLOW:
      itdssIOUnderFlowHandler( agRoot,
                               agIORequest,
                               agIOStatus,
                               agIOInfoLen,
                               agParam,
                               agOtherInfo );
      break;
    case OSSA_IO_FAILED:
      itdssIOFailedHandler( agRoot,
                            agIORequest,
                            agIOStatus,
                            agIOInfoLen,
                            agParam,
                            agOtherInfo );
      break;
    case OSSA_IO_ABORT_RESET:
      itdssIOAbortResetHandler( agRoot,
                                agIORequest,
                                agIOStatus,
                                agIOInfoLen,
                                agParam,
                                agOtherInfo );
      break;
    case OSSA_IO_NO_DEVICE:
      itdssIONoDeviceHandler( agRoot,
                              agIORequest,
                              agIOStatus,
                              agIOInfoLen,
                              agParam,
                              agOtherInfo );
      break;
    case OSSA_IO_XFER_ERROR_BREAK:
      itdssXferErrorBreakHandler( agRoot,
                                  agIORequest,
                                  agIOStatus,
                                  agIOInfoLen,
                                  agParam,
                                  agOtherInfo );
      break;
    case OSSA_IO_XFER_ERROR_PHY_NOT_READY:
      itdssXferErrorPhyNotReadyHandler( agRoot,
                                        agIORequest,
                                        agIOStatus,
                                        agIOInfoLen,
                                        agParam,
                                        agOtherInfo );
      break;
    case OSSA_IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED:
      itdssOpenCnxErrorProtocolNotSupprotedHandler( agRoot,
                                                    agIORequest,
                                                    agIOStatus,
                                                    agIOInfoLen,
                                                    agParam,
                                                    agOtherInfo );
      break;
    case OSSA_IO_OPEN_CNX_ERROR_ZONE_VIOLATION:
      itdssOpenCnxErrorZoneViolationHandler( agRoot,
                                             agIORequest,
                                             agIOStatus,
                                             agIOInfoLen,
                                             agParam,
                                             agOtherInfo );
      break;
    case OSSA_IO_OPEN_CNX_ERROR_BREAK:
      itdssOpenCnxErrorBreakHandler( agRoot,
                                     agIORequest,
                                     agIOStatus,
                                     agIOInfoLen,
                                     agParam,
                                     agOtherInfo );
      break;
    case OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS:
      itdssOpenCnxErrorITNexusLossHandler( agRoot,
                                           agIORequest,
                                           agIOStatus,
                                           agIOInfoLen,
                                           agParam,
                                           agOtherInfo );
      break;
    case OSSA_IO_OPEN_CNX_ERROR_BAD_DESTINATION:
      itdssOpenCnxErrorBadDestinationHandler( agRoot,
                                              agIORequest,
                                              agIOStatus,
                                              agIOInfoLen,
                                              agParam,
                                              agOtherInfo );
      break;
    case OSSA_IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED:
      itdssOpenCnxErrorConnectionRateNotSupportedHandler( agRoot,
                                                          agIORequest,
                                                          agIOStatus,
                                                          agIOInfoLen,
                                                          agParam,
                                                          agOtherInfo );
      break;
    case OSSA_IO_OPEN_CNX_ERROR_WRONG_DESTINATION:
      itdssOpenCnxErrorWrongDestinationHandler( agRoot,
                                                agIORequest,
                                                agIOStatus,
                                                agIOInfoLen,
                                                agParam,
                                                agOtherInfo );
      break;
    case OSSA_IO_OPEN_CNX_ERROR_UNKNOWN_ERROR:
      itdssOpenCnxErrorUnknownErrorHandler( agRoot,
                                            agIORequest,
                                            agIOStatus,
                                            agIOInfoLen,
                                            agParam,
                                            agOtherInfo );
      break;
    case OSSA_IO_XFER_ERROR_NAK_RECEIVED:
      itdssXferErrorNAKReceivedHandler( agRoot,
                                        agIORequest,
                                        agIOStatus,
                                        agIOInfoLen,
                                        agParam,
                                        agOtherInfo );
      break;
    case OSSA_IO_XFER_ERROR_ACK_NAK_TIMEOUT:
      itdssXferErrorACKNAKTimeoutHandler( agRoot,
                                          agIORequest,
                                          agIOStatus,
                                          agIOInfoLen,
                                          agParam,
                                          agOtherInfo );
      break;
    case OSSA_IO_XFER_ERROR_DMA:
      itdssXferErrorDMAHandler( agRoot,
                                agIORequest,
                                agIOStatus,
                                agIOInfoLen,
                                agParam,
                                agOtherInfo );
      break;
    case OSSA_IO_XFER_ERROR_OFFSET_MISMATCH:
      itdssXferErrorOffsetMismatchHandler( agRoot,
                                           agIORequest,
                                           agIOStatus,
                                           agIOInfoLen,
                                           agParam,
                                           agOtherInfo );
      break;
    case OSSA_IO_XFER_OPEN_RETRY_TIMEOUT:
      itdssXferOpenRetryTimeoutHandler( agRoot,
                                        agIORequest,
                                        agIOStatus,
                                        agIOInfoLen,
                                        agParam,
                                        agOtherInfo );
      break;
    case OSSA_IO_PORT_IN_RESET:
      itdssPortInResetHandler( agRoot,
                               agIORequest,
                               agIOStatus,
                               agIOInfoLen,
                               agParam,
                               agOtherInfo );
      break;
    case OSSA_IO_DS_NON_OPERATIONAL:
      itdssDsNonOperationalHandler( agRoot,
                                    agIORequest,
                                    agIOStatus,
                                    agIOInfoLen,
                                    agParam,
                                    agOtherInfo );
      break;
    case OSSA_IO_DS_IN_RECOVERY:
      itdssDsInRecoveryHandler( agRoot,
                                agIORequest,
                                agIOStatus,
                                agIOInfoLen,
                                agParam,
                                agOtherInfo );
      break;
    case OSSA_IO_TM_TAG_NOT_FOUND:
      itdssTmTagNotFoundHandler( agRoot,
                                 agIORequest,
                                 agIOStatus,
                                 agIOInfoLen,
                                 agParam,
                                 agOtherInfo );
      break;
    case OSSA_IO_SSP_EXT_IU_ZERO_LEN_ERROR:
      itdssSSPExtIUZeroLenHandler( agRoot,
                                   agIORequest,
                                   agIOStatus,
                                   agIOInfoLen,
                                   agParam,
                                   agOtherInfo );
      break;
    case OSSA_IO_XFER_ERROR_UNEXPECTED_PHASE:
      itdssXferErrorUnexpectedPhaseHandler( agRoot,
                                            agIORequest,
                                            agIOStatus,
                                            agIOInfoLen,
                                            agParam,
                                            agOtherInfo );
      break;
//new
    case OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_RETRY_BACKOFF_THRESHOLD_REACHED:
      itdssXferOpenRetryBackoffThresholdReachedHandler( agRoot,
                                                        agIORequest,
                                                        agIOStatus,
                                                        agIOInfoLen,
                                                        agParam,
                                                        agOtherInfo );
      break;
    case OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_TMO:
      itdssOpenCnxErrorItNexusLossOpenTmoHandler( agRoot,
                                                  agIORequest,
                                                  agIOStatus,
                                                  agIOInfoLen,
                                                  agParam,
                                                  agOtherInfo );
      break;
    case OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_NO_DEST:
      itdssOpenCnxErrorItNexusLossNoDestHandler( agRoot,
                                                 agIORequest,
                                                 agIOStatus,
                                                 agIOInfoLen,
                                                 agParam,
                                                 agOtherInfo );
      break;
    case OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_COLLIDE:
      itdssOpenCnxErrorItNexusLossOpenCollideHandler( agRoot,
                                                      agIORequest,
                                                      agIOStatus,
                                                      agIOInfoLen,
                                                      agParam,
                                                      agOtherInfo );
      break;
    case OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_PATHWAY_BLOCKED:
      itdssOpenCnxErrorItNexusLossOpenPathwayBlockedHandler( agRoot,
                                                             agIORequest,
                                                             agIOStatus,
                                                             agIOInfoLen,
                                                             agParam,
                                                             agOtherInfo );
      break;
      // encryption IO error handling
    case OSSA_IO_XFR_ERROR_DEK_KEY_CACHE_MISS:
    case OSSA_IO_XFR_ERROR_DEK_KEY_TAG_MISMATCH:
    case OSSA_IO_XFR_ERROR_CIPHER_MODE_INVALID:
    case OSSA_IO_XFR_ERROR_DEK_IV_MISMATCH:
    case OSSA_IO_XFR_ERROR_DEK_RAM_INTERFACE_ERROR:
    case OSSA_IO_XFR_ERROR_INTERNAL_RAM:
    case OSSA_IO_XFR_ERROR_DEK_INDEX_OUT_OF_BOUNDS:
      itdssEncryptionHandler( agRoot,
                              agIORequest,
                              agIOStatus,
                              agIOInfoLen,
                              agParam,
                              agOtherInfo );
      break;

    /* DIF IO error handling */
    case OSSA_IO_XFR_ERROR_DIF_MISMATCH:
    case OSSA_IO_XFR_ERROR_DIF_APPLICATION_TAG_MISMATCH:
    case OSSA_IO_XFR_ERROR_DIF_REFERENCE_TAG_MISMATCH:
    case OSSA_IO_XFR_ERROR_DIF_CRC_MISMATCH:
      itdssDifHandler( agRoot,
                       agIORequest,
                       agIOStatus,
                       agIOInfoLen,
                       agParam,
                       agOtherInfo );
      break;
    case OSSA_MPI_ERR_IO_RESOURCE_UNAVAILABLE:
      itdssIOResourceUnavailableHandler( agRoot,
                                         agIORequest,
                                         agIOStatus,
                                         agIOInfoLen,
                                         agParam,
                                         agOtherInfo );
      break;
    case OSSA_MPI_IO_RQE_BUSY_FULL:
      itdssIORQEBusyFullHandler( agRoot,
                                 agIORequest,
                                 agIOStatus,
                                 agIOInfoLen,
                                 agParam,
                                 agOtherInfo );
      break;
    case OSSA_IO_XFR_ERROR_INVALID_SSP_RSP_FRAME:
      itdssXferErrorInvalidSSPRspFrameHandler( agRoot,
                                               agIORequest,
                                               agIOStatus,
                                               agIOInfoLen,
                                               agParam,
                                               agOtherInfo );
      break;
    case OSSA_IO_XFER_ERR_EOB_DATA_OVERRUN:
      itdssXferErrorEOBDataOverrunHandler( agRoot,
                                           agIORequest,
                                           agIOStatus,
                                           agIOInfoLen,
                                           agParam,
                                           agOtherInfo );
      break;
    case OSSA_IO_OPEN_CNX_ERROR_OPEN_PREEMPTED:
      itdssOpenCnxErrorOpenPreemptedHandler( agRoot,
                                             agIORequest,
                                             agIOStatus,
                                             agIOInfoLen,
                                             agParam,
                                             agOtherInfo );
      break;
    default:
      TI_DBG1( ("itdssIOCompleted: Unknown agIOStatus 0x%x\n",agIOStatus) );
      itdssIODefaultHandler( agRoot,
                             agIORequest,
                             agIOStatus,
                             agIOInfoLen,
                             agParam,
                             agOtherInfo );
      break;
    }
  }
  return;
}

#ifdef TD_DISCOVER
/*****************************************************************************
*!  \brief  itdssSMPCompleted
*
*  Purpose: This routine is called to complete an SMP request previously
*           issued to the LL Layer in saSMPStart().
*
*   \param  agRoot:         Pointer to driver Instance.
*   \param  agIORequest:    Pointer to the I/O Request data structure for
*                           this I/O.
*   \param  agIOStatus:     Status of I/O just completed.
*   \param  agIOInfoLen:    Length of the I/O information associated with this
*                           I/O request
*   \param   agFrameHandle  A Handle used to refer to the response frame
*
*   \return:                None
*
*   \note - This is a initiator specific function called by the jump table.
*
*****************************************************************************/
osGLOBAL void
itdssSMPCompleted (
                   agsaRoot_t            *agRoot,
                   agsaIORequest_t       *agIORequest,
                   bit32                 agIOStatus,
                   bit32                 agIOInfoLen,
                   agsaFrameHandle_t     agFrameHandle
                   )
{
  tdsaRootOsData_t          *osData = (tdsaRootOsData_t *)agRoot->osData;
  tiRoot_t                  *tiRoot = (tiRoot_t *)osData->tiRoot;
#ifdef REMOVED
  tdsaRoot_t                *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData;
  tdsaContext_t             *tdsaAllShared = (tdsaContext_t *)&(tdsaRoot->tdsaAllShared);
#endif
  tdssSMPRequestBody_t      *tdSMPRequestBody;
  agsaSASRequestBody_t      *agSASRequestBody;
  agsaSMPFrame_t            *agSMPFrame;
  tdsaDeviceData_t          *oneDeviceData;
  tiIORequest_t             *CurrentTaskTag;
  tdsaPortContext_t         *onePortContext;
  tdsaPortContext_t         *oldonePortContext;
  smpReqPhyControl_t        *smpPhyControlReq;
  bit8                      smpHeader[4];
  tdssSMPFrameHeader_t      *tdSMPFrameHeader;
  bit8                      *tdSMPPayload;
  agsaDevHandle_t           *agDevHandle;
  bit32                     status;
#ifndef DIRECT_SMP
  tdssSMPFrameHeader_t      *tdRequestSMPFrameHeader;
  bit8                      smpRequestHeader[4];
#endif
  bit8                      SMPRequestFunction;

  TI_DBG3(("itdssSMPCompleted: start\n"));


  tdSMPRequestBody = (tdssSMPRequestBody_t *)agIORequest->osData;
  CurrentTaskTag  = tdSMPRequestBody->CurrentTaskTag;

  oneDeviceData = tdSMPRequestBody->tdDevice;
  onePortContext = oneDeviceData->tdPortContext;
  agDevHandle = oneDeviceData->agDevHandle;


  agSASRequestBody = &(tdSMPRequestBody->agSASRequestBody);
  agSMPFrame = &(agSASRequestBody->smpFrame);

#ifdef DIRECT_SMP
  SMPRequestFunction = tdSMPRequestBody->smpPayload[1];
#else
  saFrameReadBlock(agRoot, tdSMPRequestBody->IndirectSMPResp, 0, smpRequestHeader, 4);
  tdRequestSMPFrameHeader = (tdssSMPFrameHeader_t *)smpRequestHeader;
  SMPRequestFunction = tdRequestSMPFrameHeader->smpFunction;
#endif

  TI_DBG3(("itdssSMPCompleted: agIORequest %p\n", agIORequest));
  TI_DBG3(("itdssSMPCompleted: SMPRequestbody %p\n", tdSMPRequestBody));

  if (onePortContext != agNULL)
  {
    TI_DBG3(("itdssSMPCompleted: pid %d\n", onePortContext->id));
  }
  else
  {
    TI_DBG1(("itdssSMPCompleted: Wrong!!! onePortContext is NULL\n"));
    ostiFreeMemory(
                 tiRoot,
                 tdSMPRequestBody->osMemHandle,
                 sizeof(tdssSMPRequestBody_t)
                 );
#ifndef DIRECT_SMP
    ostiFreeMemory(
                 tiRoot,
                 tdSMPRequestBody->IndirectSMPReqosMemHandle,
                 tdSMPRequestBody->IndirectSMPReqLen
                 );
    ostiFreeMemory(
                 tiRoot,
                 tdSMPRequestBody->IndirectSMPResposMemHandle,
                 tdSMPRequestBody->IndirectSMPRespLen
                 );
#endif
    return;
  }

  oldonePortContext = tdSMPRequestBody->tdPortContext;
  if (oldonePortContext != agNULL)
  {
    TI_DBG3(("itdssSMPCompleted: old pid %d\n", oldonePortContext->id));
  }
  else
  {
    TI_DBG1(("itdssSMPCompleted: Wrong!!! oldonePortContext is NULL\n"));
    ostiFreeMemory(
                 tiRoot,
                 tdSMPRequestBody->osMemHandle,
                 sizeof(tdssSMPRequestBody_t)
                 );
#ifndef DIRECT_SMP
    ostiFreeMemory(
                 tiRoot,
                 tdSMPRequestBody->IndirectSMPReqosMemHandle,
                 tdSMPRequestBody->IndirectSMPReqLen
                 );
    ostiFreeMemory(
                 tiRoot,
                 tdSMPRequestBody->IndirectSMPResposMemHandle,
                 tdSMPRequestBody->IndirectSMPRespLen
                 );
#endif
    return;
  }


  /* decrement the number of pending SMP */
  onePortContext->discovery.pendingSMP--;

  /* for port invalid case;
     full discovery -> full discovery; incremental discovery -> full discovery
   */
  if (onePortContext != oldonePortContext)
  {
    TI_DBG1(("itdssSMPCompleted: portcontext has changed!!!\n"));
    if (SMPRequestFunction == SMP_REPORT_GENERAL || SMPRequestFunction == SMP_DISCOVER ||
        SMPRequestFunction == SMP_REPORT_PHY_SATA ||
        SMPRequestFunction == SMP_CONFIGURE_ROUTING_INFORMATION )
    {
      /* stop SMP timer */
      if (onePortContext->discovery.DiscoverySMPTimer.timerRunning == agTRUE)
      {
        tdsaKillTimer(
                      tiRoot,
                      &(onePortContext->discovery.DiscoverySMPTimer)
                     );
      }
      if (oldonePortContext->discovery.DiscoverySMPTimer.timerRunning == agTRUE)
      {
        tdsaKillTimer(
                      tiRoot,
                      &(oldonePortContext->discovery.DiscoverySMPTimer)
                     );
      }
    }

    /* clean up expanders data strucures; move to free exp when device is cleaned */
    tdsaCleanAllExp(tiRoot, oldonePortContext);
    /* remove devices */
    tdssInternalRemovals(oldonePortContext->agRoot,
                         oldonePortContext
                         );

    ostiFreeMemory(
                 tiRoot,
                 tdSMPRequestBody->osMemHandle,
                 sizeof(tdssSMPRequestBody_t)
                 );
#ifndef DIRECT_SMP
    ostiFreeMemory(
                 tiRoot,
                 tdSMPRequestBody->IndirectSMPReqosMemHandle,
                 tdSMPRequestBody->IndirectSMPReqLen
                 );
    ostiFreeMemory(
                 tiRoot,
                 tdSMPRequestBody->IndirectSMPResposMemHandle,
                 tdSMPRequestBody->IndirectSMPRespLen
                 );
#endif
    return;
  }

  if (onePortContext->valid == agFALSE)
  {
    if (SMPRequestFunction == SMP_REPORT_GENERAL || SMPRequestFunction == SMP_DISCOVER ||
        SMPRequestFunction == SMP_REPORT_PHY_SATA ||
        SMPRequestFunction == SMP_CONFIGURE_ROUTING_INFORMATION )
    {
      /* stop SMP timer */
      if (onePortContext->discovery.DiscoverySMPTimer.timerRunning == agTRUE)
      {
        tdsaKillTimer(
                      tiRoot,
                      &(onePortContext->discovery.DiscoverySMPTimer)
                      );
      }
      if (oldonePortContext->discovery.DiscoverySMPTimer.timerRunning == agTRUE)
      {
        tdsaKillTimer(
                      tiRoot,
                      &(oldonePortContext->discovery.DiscoverySMPTimer)
                      );
      }
    }

    if (onePortContext->discovery.pendingSMP == 0)
    {
      TI_DBG1(("itdssSMPCompleted: aborting discovery\n"));
      tdsaSASDiscoverAbort(tiRoot, onePortContext);
    }
    else
    {
      TI_DBG1(("itdssSMPCompleted: not yet abort; non zero pendingSMP %d\n", onePortContext->discovery.pendingSMP));
    }
    ostiFreeMemory(
                 tiRoot,
                 tdSMPRequestBody->osMemHandle,
                 sizeof(tdssSMPRequestBody_t)
                 );
#ifndef DIRECT_SMP
    ostiFreeMemory(
                 tiRoot,
                 tdSMPRequestBody->IndirectSMPReqosMemHandle,
                 tdSMPRequestBody->IndirectSMPReqLen
                 );
    ostiFreeMemory(
                 tiRoot,
                 tdSMPRequestBody->IndirectSMPResposMemHandle,
                 tdSMPRequestBody->IndirectSMPRespLen
                 );
#endif
    return;
  }


  if (SMPRequestFunction == SMP_REPORT_GENERAL || SMPRequestFunction == SMP_DISCOVER ||
      SMPRequestFunction == SMP_REPORT_PHY_SATA ||
      SMPRequestFunction == SMP_CONFIGURE_ROUTING_INFORMATION )
  {
    /* stop SMP timer */
    if (onePortContext->discovery.DiscoverySMPTimer.timerRunning == agTRUE)
    {
      tdsaKillTimer(
                    tiRoot,
                    &(onePortContext->discovery.DiscoverySMPTimer)
                    );
    }
    if (oldonePortContext->discovery.DiscoverySMPTimer.timerRunning == agTRUE)
    {
      tdsaKillTimer(
                    tiRoot,
                    &(oldonePortContext->discovery.DiscoverySMPTimer)
                    );
    }
  }

  /* the host as of 4/16/08 does not use indirect SMP. So, check only OSSA_IO_SUCCESS status*/
  if (agIOStatus == OSSA_IO_SUCCESS)
  {
    //tdhexdump("itdssSMPCompleted", (bit8*)agFrameHandle, agIOInfoLen);
    /* parsing SMP payload */
#ifdef DIRECT_SMP
    saFrameReadBlock(agRoot, agFrameHandle, 0, smpHeader, 4);
#else
    saFrameReadBlock(agRoot, tdSMPRequestBody->IndirectSMPResp, 0, smpHeader, 4);
#endif
    tdSMPFrameHeader = (tdssSMPFrameHeader_t *)smpHeader;

    /* SMP function dependent payload */
    switch (tdSMPFrameHeader->smpFunction)
    {
    case SMP_REPORT_GENERAL:
      TI_DBG3(("itdssSMPCompleted: report general\n"));
      if (agIOInfoLen != sizeof(smpRespReportGeneral_t) + 4 &&
          tdSMPFrameHeader->smpFunctionResult == SMP_FUNCTION_ACCEPTED)
      {
        TI_DBG1(("itdssSMPCompleted: mismatch len agIOInfoLen 0x%x 0x%x\n", agIOInfoLen, (unsigned int)sizeof(smpRespReportGeneral_t) + 4));
        tdsaSASDiscoverDone(tiRoot, onePortContext, tiError);
        ostiFreeMemory(
                       tiRoot,
                       tdSMPRequestBody->osMemHandle,
                       sizeof(tdssSMPRequestBody_t)
                      );
#ifndef DIRECT_SMP
        ostiFreeMemory(
                       tiRoot,
                       tdSMPRequestBody->IndirectSMPReqosMemHandle,
                       tdSMPRequestBody->IndirectSMPReqLen
                      );
        ostiFreeMemory(
                       tiRoot,
                       tdSMPRequestBody->IndirectSMPResposMemHandle,
                       tdSMPRequestBody->IndirectSMPRespLen
                      );
#endif
        return;
      }
      tdsaReportGeneralRespRcvd(
                                tiRoot,
                                agRoot,
                                agIORequest,
                                oneDeviceData,
                                tdSMPFrameHeader,
                                agFrameHandle
                                );

      break;
    case SMP_DISCOVER:
      TI_DBG3(("itdssSMPCompleted: discover\n"));
      if (agIOInfoLen != sizeof(smpRespDiscover_t) + 4 &&
          tdSMPFrameHeader->smpFunctionResult == SMP_FUNCTION_ACCEPTED)
      {
        TI_DBG1(("itdssSMPCompleted: mismatch len agIOInfoLen 0x%x 0x%x\n", agIOInfoLen, (unsigned int)sizeof(smpRespDiscover_t) + 4));
        tdsaSASDiscoverDone(tiRoot, onePortContext, tiError);
        ostiFreeMemory(
                       tiRoot,
                       tdSMPRequestBody->osMemHandle,
                       sizeof(tdssSMPRequestBody_t)
                      );
#ifndef DIRECT_SMP
        ostiFreeMemory(
                       tiRoot,
                       tdSMPRequestBody->IndirectSMPReqosMemHandle,
                       tdSMPRequestBody->IndirectSMPReqLen
                      );
        ostiFreeMemory(
                       tiRoot,
                       tdSMPRequestBody->IndirectSMPResposMemHandle,
                       tdSMPRequestBody->IndirectSMPRespLen
                      );
#endif
        return;
      }
      tdsaDiscoverRespRcvd(
                           tiRoot,
                           agRoot,
                           agIORequest,
                           oneDeviceData,
                           tdSMPFrameHeader,
                           agFrameHandle
                           );
      break;
    case SMP_REPORT_PHY_SATA:
      TI_DBG3(("itdssSMPCompleted: report phy sata\n"));
      if (agIOInfoLen != sizeof(smpRespReportPhySata_t) + 4 &&
          tdSMPFrameHeader->smpFunctionResult == SMP_FUNCTION_ACCEPTED)
      {
        TI_DBG1(("itdssSMPCompleted: mismatch len agIOInfoLen 0x%x 0x%x\n", agIOInfoLen, (unsigned int)sizeof(smpRespReportPhySata_t) + 4));
        tdsaSATADiscoverDone(tiRoot, onePortContext, tiError);
        ostiFreeMemory(
                       tiRoot,
                       tdSMPRequestBody->osMemHandle,
                       sizeof(tdssSMPRequestBody_t)
                      );
#ifndef DIRECT_SMP
        ostiFreeMemory(
                       tiRoot,
                       tdSMPRequestBody->IndirectSMPReqosMemHandle,
                       tdSMPRequestBody->IndirectSMPReqLen
                      );
        ostiFreeMemory(
                       tiRoot,
                       tdSMPRequestBody->IndirectSMPResposMemHandle,
                       tdSMPRequestBody->IndirectSMPRespLen
                      );
#endif
        return;
      }
      tdsaReportPhySataRcvd(
                            tiRoot,
                            agRoot,
                            agIORequest,
                            oneDeviceData,
                            tdSMPFrameHeader,
                            agFrameHandle
                            );
      break;
    case SMP_CONFIGURE_ROUTING_INFORMATION:
      TI_DBG1(("itdssSMPCompleted: configure routing information\n"));
      if (agIOInfoLen != 4 &&
          tdSMPFrameHeader->smpFunctionResult == SMP_FUNCTION_ACCEPTED)
      {
        TI_DBG1(("itdssSMPCompleted: mismatch len agIOInfoLen 0x%x 0x%x\n", agIOInfoLen, 4));
        tdsaSASDiscoverDone(tiRoot, onePortContext, tiError);
        ostiFreeMemory(
                       tiRoot,
                       tdSMPRequestBody->osMemHandle,
                       sizeof(tdssSMPRequestBody_t)
                      );
#ifndef DIRECT_SMP
        ostiFreeMemory(
                       tiRoot,
                       tdSMPRequestBody->IndirectSMPReqosMemHandle,
                       tdSMPRequestBody->IndirectSMPReqLen
                      );
        ostiFreeMemory(
                       tiRoot,
                       tdSMPRequestBody->IndirectSMPResposMemHandle,
                       tdSMPRequestBody->IndirectSMPRespLen
                      );
#endif
        return;
      }
      tdsaConfigRoutingInfoRespRcvd(
                                    tiRoot,
                                    agRoot,
                                    agIORequest,
                                    oneDeviceData,
                                    tdSMPFrameHeader,
                                    agFrameHandle
                                    );

      break;
    case SMP_PHY_CONTROL:
      TI_DBG3(("itdssSMPCompleted: phy control\n"));
      if (agIOInfoLen != 4 &&
          tdSMPFrameHeader->smpFunctionResult == SMP_FUNCTION_ACCEPTED) /*zero length is expected */
      {
        TI_DBG1(("itdssSMPCompleted: mismatch len agIOInfoLen 0x%x 0x%x\n", agIOInfoLen, 4));
        tdsaSASDiscoverDone(tiRoot, onePortContext, tiError);
        ostiFreeMemory(
                       tiRoot,
                       tdSMPRequestBody->osMemHandle,
                       sizeof(tdssSMPRequestBody_t)
                      );
#ifndef DIRECT_SMP
        ostiFreeMemory(
                       tiRoot,
                       tdSMPRequestBody->IndirectSMPReqosMemHandle,
                       tdSMPRequestBody->IndirectSMPReqLen
                      );
        ostiFreeMemory(
                       tiRoot,
                       tdSMPRequestBody->IndirectSMPResposMemHandle,
                       tdSMPRequestBody->IndirectSMPRespLen
                      );
#endif
        return;
      }
      tdsaPhyControlRespRcvd(
                             tiRoot,
                             agRoot,
                             agIORequest,
                             oneDeviceData,
                             tdSMPFrameHeader,
                             agFrameHandle,
                             CurrentTaskTag
                             );

      break;
#ifdef REMOVED
//temp for testing
     case SMP_REPORT_MANUFACTURE_INFORMATION:
      TI_DBG1(("itdssSMPCompleted: REPORT_MANUFACTURE_INFORMATION\n"));
      if (agIOInfoLen != sizeof(smpRespReportManufactureInfo_t) + 4 &&
          tdSMPFrameHeader->smpFunctionResult == SMP_FUNCTION_ACCEPTED) /*zero length is expected */
      {
        TI_DBG1(("itdssSMPCompleted: mismatch len agIOInfoLen 0x%x 0x%x\n", agIOInfoLen, 4));
        tdsaSASDiscoverDone(tiRoot, onePortContext, tiError);
        ostiFreeMemory(
                       tiRoot,
                       tdSMPRequestBody->osMemHandle,
                       sizeof(tdssSMPRequestBody_t)
                      );
#ifndef DIRECT_SMP
        ostiFreeMemory(
                       tiRoot,
                       tdSMPRequestBody->IndirectSMPReqosMemHandle,
                       tdSMPRequestBody->IndirectSMPReqLen
                      );
        ostiFreeMemory(
                       tiRoot,
                       tdSMPRequestBody->IndirectSMPResposMemHandle,
                       tdSMPRequestBody->IndirectSMPRespLen
                      );
#endif
        return;
      }
      tdsaReportManInfoRespRcvd(
                                tiRoot,
                                agRoot,
                                oneDeviceData,
                                tdSMPFrameHeader,
                                agFrameHandle
                                );

       break;
//end temp for testing
#endif
    case SMP_REPORT_ROUTING_INFORMATION:
    case SMP_REPORT_PHY_ERROR_LOG:
    case SMP_PHY_TEST_FUNCTION:
    case SMP_REPORT_MANUFACTURE_INFORMATION:
    case SMP_READ_GPIO_REGISTER:
    case SMP_WRITE_GPIO_REGISTER:
    default:
      TI_DBG1(("itdssSMPCompleted: wrong SMP function 0x%x\n", tdSMPFrameHeader->smpFunction));
      TI_DBG1(("itdssSMPCompleted: smpFrameType 0x%x\n", tdSMPFrameHeader->smpFrameType));
      TI_DBG1(("itdssSMPCompleted: smpFunctionResult 0x%x\n", tdSMPFrameHeader->smpFunctionResult));
      TI_DBG1(("itdssSMPCompleted: smpReserved 0x%x\n", tdSMPFrameHeader->smpReserved));
      tdhexdump("itdssSMPCompleted: SMP payload", (bit8 *)agFrameHandle, agIOInfoLen);
      break;
    }
  }
  else if (agIOStatus == OSSA_IO_ABORTED || agIOStatus == OSSA_IO_INVALID_LENGTH)
  {
    /* no retry this case */
    TI_DBG1(("itdssSMPCompleted: OSSA_IO_ABORTED\n"));
  }
  else if (agIOStatus == OSSA_IO_ERROR_INTERNAL_SMP_RESOURCE)
  {
    TI_DBG1(("itdssSMPCompleted: OSSA_IO_ERROR_INTERNAL_SMP_RESOURCE\n"));
    saFrameReadBlock(agRoot, agFrameHandle, 0, smpHeader, 4);
    tdSMPFrameHeader = (tdssSMPFrameHeader_t *)smpHeader;

    status = saSMPStart(
               agRoot,
               agIORequest,
               tdSMPRequestBody->queueNumber, //tdsaAllShared->SMPQNum, //tdsaRotateQnumber(tiRoot, oneDeviceData),
               agDevHandle,
               AGSA_SMP_INIT_REQ,
               agSASRequestBody,
               &ossaSMPCompleted
               );

    if (status == AGSA_RC_SUCCESS)
    {
      /* increment the number of pending SMP */
      onePortContext->discovery.pendingSMP++;
      if (SMPRequestFunction == SMP_REPORT_GENERAL || SMPRequestFunction == SMP_DISCOVER ||
          SMPRequestFunction == SMP_REPORT_PHY_SATA ||
          SMPRequestFunction == SMP_CONFIGURE_ROUTING_INFORMATION )
      {
        /* start discovery-related SMP timer */
        tdsaDiscoverySMPTimer(tiRoot, onePortContext, (bit32)(tdSMPFrameHeader->smpFunction), tdSMPRequestBody);
      }
      return;
    }
    else if (status == AGSA_RC_BUSY)
    {
      if (tdSMPFrameHeader->smpFunction == SMP_REPORT_GENERAL ||
          tdSMPFrameHeader->smpFunction == SMP_DISCOVER ||
          tdSMPFrameHeader->smpFunction == SMP_REPORT_PHY_SATA ||
          tdSMPFrameHeader->smpFunction == SMP_CONFIGURE_ROUTING_INFORMATION )
      {
        tdsaSMPBusyTimer(tiRoot, onePortContext, oneDeviceData, tdSMPRequestBody);
      }
      else if (tdSMPFrameHeader->smpFunction == SMP_PHY_CONTROL)
      {
        /* For taskmanagement SMP, let's fail task management failure */
        tdsaPhyControlFailureRespRcvd(
                                      tiRoot,
                                      agRoot,
                                      oneDeviceData,
                                      tdSMPFrameHeader,
                                      agFrameHandle,
                                      CurrentTaskTag
                                      );
      }
      else
      {
      }
    }
    else /* AGSA_RC_FAILURE */
    {
      if (tdSMPFrameHeader->smpFunction == SMP_REPORT_GENERAL ||
          tdSMPFrameHeader->smpFunction == SMP_DISCOVER ||
          tdSMPFrameHeader->smpFunction == SMP_REPORT_PHY_SATA ||
          tdSMPFrameHeader->smpFunction == SMP_CONFIGURE_ROUTING_INFORMATION )
      {
        tdsaSASDiscoverDone(tiRoot, onePortContext, tiError);
      }
      else if (tdSMPFrameHeader->smpFunction == SMP_PHY_CONTROL)
      {
        /* task management failure */
        tdsaPhyControlFailureRespRcvd(
                                      tiRoot,
                                      agRoot,
                                      oneDeviceData,
                                      tdSMPFrameHeader,
                                      agFrameHandle,
                                      CurrentTaskTag
                                      );
      }
      else
      {
      }
    }
  }
  else
  {
    if (tdSMPRequestBody->retries < SMP_RETRIES) /* 5 */
    {
      /* retry the SMP again */
      TI_DBG1(("itdssSMPCompleted: failed! but retries %d agIOStatus 0x%x %d agIOInfoLen %d\n",
               tdSMPRequestBody->retries, agIOStatus, agIOStatus, agIOInfoLen));
      if (agIOStatus == OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS ||
          agIOStatus == OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_RETRY_BACKOFF_THRESHOLD_REACHED ||
          agIOStatus == OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_TMO ||
          agIOStatus == OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_NO_DEST ||
          agIOStatus == OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_COLLIDE ||
          agIOStatus == OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_PATHWAY_BLOCKED ||
          agIOStatus == OSSA_IO_DS_NON_OPERATIONAL
         )
      {
        saSetDeviceState(agRoot, agNULL, tdSMPRequestBody->queueNumber, agDevHandle, SA_DS_OPERATIONAL);
      }
      saSMPStart(
                 agRoot,
                 agIORequest,
                 tdSMPRequestBody->queueNumber, //tdsaAllShared->SMPQNum, //tdsaRotateQnumber(tiRoot, oneDeviceData),
                 agDevHandle,
                 AGSA_SMP_INIT_REQ,
                 agSASRequestBody,
                 &ossaSMPCompleted
                 );
      /* increment the number of pending SMP */
      onePortContext->discovery.pendingSMP++;
      tdSMPRequestBody->retries++;
      return;
    }
    else
    {
      tdSMPFrameHeader = (tdssSMPFrameHeader_t *)agSMPFrame->outFrameBuf;
      tdSMPPayload = (bit8 *)agSMPFrame->outFrameBuf + 4;
      TI_DBG1(("itdssSMPCompleted: failed! no more retry! agIOStatus 0x%x %d\n", agIOStatus, agIOStatus));
      if (agIOStatus == OSSA_IO_DS_NON_OPERATIONAL)
      {
        TI_DBG1(("itdssSMPCompleted: failed! agIOStatus is OSSA_IO_DS_NON_OPERATIONAL\n"));
      }

      if (agIOStatus == OSSA_IO_DS_IN_RECOVERY)
      {
        TI_DBG1(("itdssSMPCompleted: failed! agIOStatus is OSSA_IO_DS_IN_RECOVERY\n"));
      }

      if (tdSMPFrameHeader->smpFunction == SMP_REPORT_GENERAL ||
          tdSMPFrameHeader->smpFunction == SMP_DISCOVER ||
          tdSMPFrameHeader->smpFunction == SMP_REPORT_PHY_SATA ||
          tdSMPFrameHeader->smpFunction == SMP_CONFIGURE_ROUTING_INFORMATION
         )
      {
        /* discovery failure */
        TI_DBG1(("itdssSMPCompleted: SMP function 0x%x\n", tdSMPFrameHeader->smpFunction));
        TI_DBG1(("itdssSMPCompleted: discover done with error\n"));
        tdsaSASDiscoverDone(tiRoot, onePortContext, tiError);
      }
      else if (tdSMPFrameHeader->smpFunction == SMP_PHY_CONTROL)
      {
        TI_DBG1(("itdssSMPCompleted: SMP_PHY_CONTROL\n"));
        smpPhyControlReq = (smpReqPhyControl_t *)tdSMPPayload;
        if (smpPhyControlReq->phyOperation == SMP_PHY_CONTROL_CLEAR_AFFILIATION)
        {
          TI_DBG1(("itdssSMPCompleted: discover done with error\n"));
          tdsaSASDiscoverDone(tiRoot, onePortContext, tiError);
        }
        else if (smpPhyControlReq->phyOperation == SMP_PHY_CONTROL_HARD_RESET ||
                 smpPhyControlReq->phyOperation == SMP_PHY_CONTROL_LINK_RESET )
        {
          TI_DBG1(("itdssSMPCompleted: device reset failed\n"));
          if (CurrentTaskTag != agNULL )
          {
            TI_DBG1(("itdssSMPCompleted: callback to OS layer with failure\n"));
            ostiInitiatorEvent( tiRoot,
                                NULL,
                                NULL,
                                tiIntrEventTypeTaskManagement,
                                tiTMFailed,
                                CurrentTaskTag );
          }
          else
          {
            /* hard reset was not done with this device */
            oneDeviceData->ResetCnt = 0;
          }
        }
        else
        {
          TI_DBG1(("itdssSMPCompleted: unknown phy operation 0x%x\n", smpPhyControlReq->phyOperation));
        }
      } /* SMP_PHY_CONTROL */
      else
      {
        TI_DBG1(("itdssSMPCompleted: SMP function 0x%x\n", tdSMPFrameHeader->smpFunction));
      }
    } /* else */
  } /* outer else */

  ostiFreeMemory(
                 tiRoot,
                 tdSMPRequestBody->osMemHandle,
                 sizeof(tdssSMPRequestBody_t)
                 );
#ifndef DIRECT_SMP
  ostiFreeMemory(
                 tiRoot,
                 tdSMPRequestBody->IndirectSMPReqosMemHandle,
                 tdSMPRequestBody->IndirectSMPReqLen
                 );
  ostiFreeMemory(
                 tiRoot,
                 tdSMPRequestBody->IndirectSMPResposMemHandle,
                 tdSMPRequestBody->IndirectSMPRespLen
                 );
#endif


  return;
}

#else

osGLOBAL void
itdssSMPCompleted (
                   agsaRoot_t            *agRoot,
                   agsaIORequest_t       *agIORequest,
                   bit32                 agIOStatus,
                   bit32                 agIOInfoLen,
                   agsaFrameHandle_t     agFrameHandle
                   )
{
  /* pass the payload to OS layer */
  TI_DBG3(("itdssSMPCompleted: start\n"));
}
#endif


/*****************************************************************************
*! \brief itdIoSuccessHandler
*
*  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
*            layer with agIOStatus = OSSA_IO_SUCCESS
*
*  \param  agRoot:            pointer to port instance
*  \param  agIORequest:       pointer to I/O request
*  \param  agIOStatus:        I/O status given by LL layer
*  \param  agIOInfoLen:       lenth of complete SAS RESP frame
*  \param  agParam            A Handle used to refer to the response frame or handle
*                             of abort request
*  \param  agOtherInfo        Residual count
*  \return: None
*
*
*****************************************************************************/
osGLOBAL void
itdssIOSuccessHandler(
                      agsaRoot_t           *agRoot,
                      agsaIORequest_t      *agIORequest,
                      bit32                agIOStatus,
                      bit32                agIOInfoLen,
                      void                 *agParam,
                      bit32                agOtherInfo
                      )
{
  tdsaRootOsData_t          *osData = (tdsaRootOsData_t *)agRoot->osData;
  tiRoot_t                  *tiRoot = (tiRoot_t *)osData->tiRoot;
  itdsaIni_t                *Initiator = (itdsaIni_t *)osData->itdsaIni;
  tdIORequestBody_t         *tdIORequestBody;
  agsaSSPResponseInfoUnit_t agSSPRespIU;
  tiSenseData_t             senseData;
  bit8                      senseDataPayload[256];
  bit8                      respData[128];
  bit32                     scsi_status;
  bit32                     senseLen;
  bit32                     respLen;
  bit32                     data_status;
  bit32                     i;
  tiDeviceHandle_t          *tiDeviceHandle = agNULL;
  tdsaDeviceData_t          *oneDeviceData = agNULL;

  TI_DBG2(("itdssIOSuccessHandler: start\n"));
  TI_DBG2(("itdssIOSuccessHandler: agIOInfoLen %d\n", agIOInfoLen));

  tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;

  tdIORequestBody->ioCompleted = agTRUE;
  tdIORequestBody->ioStarted = agFALSE;

  /*
    agIOInfoLen must be >= sizeof(agsaSSPResponseInfoUnit_t), which is minimum
    date length
  */
  if (agIOInfoLen < sizeof(agsaSSPResponseInfoUnit_t))
  {
    TI_DBG1(("itdssIOSuccessHandler: First agIOInfoLen does not match!!!\n"));
    TI_DBG1(("itdssIOSuccessHandler: First agIOInfoLen 0x%x IU 0x%x\n", agIOInfoLen, (unsigned int)sizeof(agsaSSPResponseInfoUnit_t)));
    ostiInitiatorIOCompleted(
                             tiRoot,
                             tdIORequestBody->tiIORequest, /* tiIORequest */
                             tiIOFailed,
                             tiDetailOtherError,
                             agNULL,
                             agTRUE /* intContext; is not being used */
                             );
    return;
  }
  /* reads agsaSSPResponseInfoUnit_t */
  saFrameReadBlock(agRoot, agParam, 0, &agSSPRespIU, sizeof(agsaSSPResponseInfoUnit_t));

  data_status = SA_SSPRESP_GET_DATAPRES(&agSSPRespIU);
  scsi_status = agSSPRespIU.status;
  /* endianess is invovled here */
  senseLen = SA_SSPRESP_GET_SENSEDATALEN(&agSSPRespIU);
  respLen = SA_SSPRESP_GET_RESPONSEDATALEN(&agSSPRespIU);

  TI_DBG2(("itdssIOSuccessHandler: dataPres=%x\n", data_status));
  TI_DBG2(("itdssIOSuccessHandler: scsi status=0x%x, senselen=0x%x resplen 0x%x\n", scsi_status, senseLen, respLen));

  /*
    sanity check: do not go beyond of agIOInfoLen. if happens, return error
    agIOInfoLen >= sizeof(agsaSSPResponseInfoUnit_t) + senseLen + respLen -> OK
    because frame must be divisible by 4, so there can be extra padding
    agIOInfoLen < sizeof(agsaSSPResponseInfoUnit_t) + senseLen + respLen -> NOT OK
  */
  if (agIOInfoLen < sizeof(agsaSSPResponseInfoUnit_t) + senseLen + respLen)
  {
    TI_DBG1(("itdssIOSuccessHandler: Second agIOInfoLen does not match!!!\n"));
    TI_DBG1(("itdssIOSuccessHandler: Second agIOInfoLen 0x%x IU 0x%x senselen 0x%x resplen 0x%x\n", agIOInfoLen, (unsigned int)sizeof(agsaSSPResponseInfoUnit_t), senseLen, respLen));

    ostiInitiatorIOCompleted(
                             tiRoot,
                             tdIORequestBody->tiIORequest, /* tiIORequest */
                             tiIOFailed,
                             tiDetailOtherError,
                             agNULL,
                             agTRUE /* intContext; is not being used */
                             );
    return;
  }

  /* reads response data */
  saFrameReadBlock(agRoot, agParam,
                   sizeof(agsaSSPResponseInfoUnit_t),
                   respData, respLen);
  /* reads sense data */
  saFrameReadBlock(agRoot, agParam,
                   sizeof(agsaSSPResponseInfoUnit_t)
                   + respLen,
                   senseDataPayload, senseLen);

  if (data_status == 0)
  {
    /* NO_DATA */
    TI_DBG1(("itdssIOSuccessHandler: no data scsi_status 0x%x\n",scsi_status));

    ostiInitiatorIOCompleted(
                             tiRoot,
                             tdIORequestBody->tiIORequest, /* tiIORequest */
                             tiIOSuccess,
                             scsi_status,
                             agNULL,
                             agTRUE /* intContext; is not being used */
                             );

    return;
  }

  if (data_status == 1)
  {
    /* RESPONSE_DATA */
    TI_DBG1(("itdssIOSuccessHandler: response data \n"));

    ostiInitiatorIOCompleted(
                             tiRoot,
                             tdIORequestBody->tiIORequest, /* tiIORequest */
                             tiIOSuccess,
                             0,
                             agNULL,
                             agTRUE /* intContext; is not being used */
                             );
    return;
  }

  if (data_status == 2)
  {
    /* SENSE_DATA */
    TI_DBG2(("itdssIOSuccessHandler: sense data \n"));

    senseData.senseData = &senseDataPayload;
    senseData.senseLen = MIN(256, senseLen);
    /* debugging */
    tdhexdump("ResponseIU I", (bit8 *)&agSSPRespIU, sizeof(agsaSSPResponseInfoUnit_t));

    tiDeviceHandle = tdIORequestBody->tiDevHandle;
    oneDeviceData = (tdsaDeviceData_t *)tiDeviceHandle->tdData;
    TI_DBG1(("sense data Sense Key 0x%2X ASC(Code) 0x%2X ASCQ(Qualifier) 0x%2X, did 0x%x\n",*(senseDataPayload+ 2),*(senseDataPayload + 12),*(senseDataPayload + 13),
             oneDeviceData->id));
    tdhexdump("sense data I", (bit8 *)senseDataPayload, senseLen);
//    tdhexdump("sense data II", (bit8 *)senseData.senseData, senseData.senseLen);

    if (senseDataPayload[2] == SCSI_SENSE_KEY_RECOVERED_ERROR)
    {
      Initiator->SenseKeyCounter.SoftError ++;
    }
    else if (senseDataPayload[2] == SCSI_SENSE_KEY_NOT_READY)
    {
      Initiator->SenseKeyCounter.MediumNotReady++;
    }
    else if (senseDataPayload[2] == SCSI_SENSE_KEY_MEDIUM_ERROR)
    {
      Initiator->SenseKeyCounter.MediumError++;
    }
    else if (senseDataPayload[2] == SCSI_SENSE_KEY_HARDWARE_ERROR)
    {
      Initiator->SenseKeyCounter.HardwareError++;
    }
    else if (senseDataPayload[2] == SCSI_SENSE_KEY_ILLEGAL_REQUEST)
    {
      Initiator->SenseKeyCounter.IllegalRequest++;
    }
    else if (senseDataPayload[2] == SCSI_SENSE_KEY_UNIT_ATTENTION)
    {
      Initiator->SenseKeyCounter.UnitAttention++;
    }
    else if (senseDataPayload[2] == SCSI_SENSE_KEY_ABORTED_COMMAND)
    {
      Initiator->SenseKeyCounter.AbortCommand++;
    }
    else
    {
      Initiator->SenseKeyCounter.OtherKeyType++;
    }

    /* when ASQ and ASCQ 0x04 0x11, does saLocalPhyControl for notify spinup */
    if ((senseDataPayload[12] == 0x04 && senseDataPayload[13] == 0x11))
    {
      TI_DBG2(("itdssIOSuccessHandler: sending notfify spinup\n"));
      tiDeviceHandle = tdIORequestBody->tiDevHandle;
      oneDeviceData = (tdsaDeviceData_t *)tiDeviceHandle->tdData;
      if (oneDeviceData->directlyAttached == agTRUE)
      {
        for (i=0;i<TD_MAX_NUM_NOTIFY_SPINUP;i++)
        {
          saLocalPhyControl(agRoot, agNULL, 0, oneDeviceData->phyID, AGSA_PHY_NOTIFY_ENABLE_SPINUP, agNULL);
        }
      }
    }
    ostiInitiatorIOCompleted(
                             tiRoot,
                             /* tiIORequest */
                             tdIORequestBody->tiIORequest,
                             tiIOSuccess,
                             scsi_status,
                             &senseData,
                             agTRUE /* intContext; is not being used */
                             );
    return;
  }
  if (data_status == 3)
  {
    /* RESERVED */
    TI_DBG1(("itdssIOSuccessHandler: reserved wrong!!!\n"));
    ostiInitiatorIOCompleted(
                             tiRoot,
                             tdIORequestBody->tiIORequest, /* tiIORequest */
                             tiIOFailed,
                             scsi_status,
                             agNULL,
                             agTRUE /* intContext; is not being used */
                             );
    return;
  }

}

/*****************************************************************************
*! \brief itdssIOAbortedHandler
*
*  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
*            layer with agIOStatus = OSSA_IO_ABORTED
*
*  \param  agRoot:            pointer to port instance
*  \param  agIORequest:       pointer to I/O request
*  \param  agIOStatus:        I/O status given by LL layer
*  \param  agIOInfoLen:       lenth of complete SAS RESP frame
*  \param  agParam            A Handle used to refer to the response frame or handle
*                             of abort request
*  \param  agOtherInfo        Residual count
*  \return: None
*
*
*****************************************************************************/
/* see itdosIOCompleted() and itdinit.c and  itdIoAbortedHandler in itdio.c*/
osGLOBAL void
itdssIOAbortedHandler (
                       agsaRoot_t              *agRoot,
                       agsaIORequest_t         *agIORequest,
                       bit32                   agIOStatus,
                       bit32                   agIOInfoLen,
                       void                    *agParam,
                       bit32                   agOtherInfo
                       )
{
  tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
  tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
  bit32                  intContext = osData->IntContext;
  tdIORequestBody_t      *tdIORequestBody;
  tiDeviceHandle_t       *tiDeviceHandle = agNULL;
  tdsaDeviceData_t       *oneDeviceData = agNULL;

  TI_DBG2(("itdssIOAbortedHandler: start\n"));
  tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;

  if (agIOStatus != OSSA_IO_ABORTED)
  {
    TI_DBG1(("itdssIOAbortedHandler: incorrect agIOStatus 0x%x\n", agIOStatus));
  }

  if (tdIORequestBody == agNULL)
  {
    TI_DBG1(("itdssIOAbortedHandler: start\n"));
    return;
  }

  if (tdIORequestBody != agNULL)
  {
    tiDeviceHandle = tdIORequestBody->tiDevHandle;
  }
  if (tiDeviceHandle != agNULL)
  {
    oneDeviceData  = (tdsaDeviceData_t *)tiDeviceHandle->tdData;
  }
  if (oneDeviceData != agNULL)
  {
    TI_DBG2(("itdssIOAbortedHandler: did %d \n", oneDeviceData->id));
  }
  else
  {
    TI_DBG1(("itdssIOAbortedHandler: oneDeviceData is NULL\n"));
  }


  ostiInitiatorIOCompleted (
                            tiRoot,
                            tdIORequestBody->tiIORequest,
                            tiIOFailed,
                            tiDetailAborted,
                            agNULL,
                            intContext
                            );

  return;
}

#ifdef REMOVED
/*****************************************************************************
*! \brief itdssIOOverFlowHandler
*
*  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
*            layer with agIOStatus = OSSA_IO_OVERFLOW
*
*  \param  agRoot:            pointer to port instance
*  \param  agIORequest:       pointer to I/O request
*  \param  agIOStatus:        I/O status given by LL layer
*  \param  agIOInfoLen:       lenth of complete SAS RESP frame
*  \param  agParam            A Handle used to refer to the response frame or handle
*                             of abort request
*  \return: None
*
*
*****************************************************************************/
osGLOBAL void
itdssIOOverFlowHandler(
                       agsaRoot_t              *agRoot,
                       agsaIORequest_t         *agIORequest,
                       bit32                   agIOStatus,
                       bit32                   agIOInfoLen,
                       void                    *agParam
                       )
{
  tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
  tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
  bit32                  intContext = osData->IntContext;
  tdIORequestBody_t      *tdIORequestBody;

  TI_DBG2(("itdssIOOverFlowHandler: start\n"));
  TI_DBG2(("itdssIOOverFlowHandler: not transferred byte 0x%x\n", agIOInfoLen));

  tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;

  ostiInitiatorIOCompleted (
                            tiRoot,
                            tdIORequestBody->tiIORequest,
                            tiIOOverRun,
                            agIOInfoLen,
                            agNULL,
                            intContext
                            );

  return;
}
#endif


/*****************************************************************************
*! \brief itdssIOUnderFlowHandler
*
*  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
*            layer with agIOStatus = OSSA_IO_UNDERFLOW
*
*  \param  agRoot:            pointer to port instance
*  \param  agIORequest:       pointer to I/O request
*  \param  agIOStatus:        I/O status given by LL layer
*  \param  agIOInfoLen:       lenth of complete SAS RESP frame
*  \param  agParam            A Handle used to refer to the response frame or handle
*                             of abort request
*  \param  agOtherInfo        Residual count
*  \return: None
*
*
*****************************************************************************/
osGLOBAL void
itdssIOUnderFlowHandler(
                        agsaRoot_t              *agRoot,
                        agsaIORequest_t         *agIORequest,
                        bit32                   agIOStatus,
                        bit32                   agIOInfoLen,
                        void                    *agParam,
                        bit32                   agOtherInfo
                        )
{
  tdsaRootOsData_t          *osData = (tdsaRootOsData_t *)agRoot->osData;
  tiRoot_t                  *tiRoot = (tiRoot_t *)osData->tiRoot;
  bit32                     intContext = osData->IntContext;
  tdIORequestBody_t         *tdIORequestBody;

  TI_DBG6(("itdssIOUnderFlowHandler: start\n"));
  TI_DBG6(("itdssIOUnderFlowHandler: agIOInfoLen 0x%x\n", agIOInfoLen));

  tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;

  ostiInitiatorIOCompleted (
                            tiRoot,
                            tdIORequestBody->tiIORequest,
                            tiIOUnderRun,
                            agIOInfoLen,
                            agNULL,
                            intContext
                            );

  return;
}

/*****************************************************************************
*! \brief itdssIOFailedHandler
*
*  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
*            layer with agIOStatus = OSSA_IO_FAILED
*
*  \param  agRoot:            pointer to port instance
*  \param  agIORequest:       pointer to I/O request
*  \param  agIOStatus:        I/O status given by LL layer
*  \param  agIOInfoLen:       lenth of complete SAS RESP frame
*  \param  agParam            A Handle used to refer to the response frame or handle
*                             of abort request
*  \param  agOtherInfo        Residual count
*  \return: None
*
*
*****************************************************************************/
osGLOBAL void
itdssIOFailedHandler(
                     agsaRoot_t              *agRoot,
                     agsaIORequest_t         *agIORequest,
                     bit32                   agIOStatus,
                     bit32                   agIOInfoLen,
                     void                    *agParam,
                     bit32                   agOtherInfo
                     )
{
  tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
  tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
  bit32                  intContext = osData->IntContext;
  tdIORequestBody_t      *tdIORequestBody;

  TI_DBG1(("itdssIOFailedHandler: start\n"));

  tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;

  ostiInitiatorIOCompleted (
                            tiRoot,
                            tdIORequestBody->tiIORequest,
                            tiIOFailed,
                            tiDetailOtherError,
                            agNULL,
                            intContext
                            );
  return;
}

/*****************************************************************************
*! \brief itdssIOAbortResetHandler
*
*  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
*            layer with agIOStatus = OSSA_IO_ABORT_RESET
*
*  \param  agRoot:            pointer to port instance
*  \param  agIORequest:       pointer to I/O request
*  \param  agIOStatus:        I/O status given by LL layer
*  \param  agIOInfoLen:       lenth of complete SAS RESP frame
*  \param  agParam            A Handle used to refer to the response frame or handle
*                             of abort request
*  \param  agOtherInfo        Residual count
*  \return: None
*
*
*****************************************************************************/
osGLOBAL void
itdssIOAbortResetHandler(
                         agsaRoot_t              *agRoot,
                         agsaIORequest_t         *agIORequest,
                         bit32                   agIOStatus,
                         bit32                   agIOInfoLen,
                         void                    *agParam,
                         bit32                   agOtherInfo
                         )
{
  tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
  tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
  bit32                  intContext = osData->IntContext;
  tdIORequestBody_t      *tdIORequestBody;
  TI_DBG2(("itdssIOAbortResetHandler: start\n"));

  tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;

  ostiInitiatorIOCompleted (
                            tiRoot,
                            tdIORequestBody->tiIORequest,
                            tiIOFailed,
                            tiDetailAbortReset,
                            agNULL,
                            intContext
                            );


  return;
}

/*****************************************************************************
*! \brief itdssIONotValidHandler
*
*  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
*            layer with agIOStatus = OSSA_IO_NOT_VALID
*
*  \param  agRoot:            pointer to port instance
*  \param  agIORequest:       pointer to I/O request
*  \param  agIOStatus:        I/O status given by LL layer
*  \param  agIOInfoLen:       lenth of complete SAS RESP frame
*  \param  agParam            A Handle used to refer to the response frame or handle
*                             of abort request
*  \param  agOtherInfo        Residual count
*  \return: None
*
*
*****************************************************************************/
osGLOBAL void
itdssIONotValidHandler(
                       agsaRoot_t           *agRoot,
                       agsaIORequest_t      *agIORequest,
                       bit32                agIOStatus,
                       bit32                agIOInfoLen,
                       void                 *agParam,
                       bit32                agOtherInfo
                       )
{
  tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
  tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
  bit32                  intContext = osData->IntContext;
  tdIORequestBody_t      *tdIORequestBody;
  TI_DBG2(("itdssIONotValidHandler: start\n"));

  tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;

  ostiInitiatorIOCompleted (
                            tiRoot,
                            tdIORequestBody->tiIORequest,
                            tiIOFailed,
                            tiDetailNotValid,
                            agNULL,
                            intContext
                            );
  return;
}

/*****************************************************************************
*! \brief itdssIONoDeviceHandler
*
*  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
*            layer with agIOStatus = OSSA_IO_NO_DEVICE
*
*  \param  agRoot:            pointer to port instance
*  \param  agIORequest:       pointer to I/O request
*  \param  agIOStatus:        I/O status given by LL layer
*  \param  agIOInfoLen:       lenth of complete SAS RESP frame
*  \param  agParam            A Handle used to refer to the response frame or handle
*                             of abort request
*  \param  agOtherInfo        Residual count
*  \return: None
*
*
*****************************************************************************/
osGLOBAL void
itdssIONoDeviceHandler(
                       agsaRoot_t           *agRoot,
                       agsaIORequest_t      *agIORequest,
                       bit32                agIOStatus,
                       bit32                agIOInfoLen,
                       void                 *agParam,
                       bit32                agOtherInfo
                       )
{
  tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
  tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
  bit32                  intContext = osData->IntContext;
  tdIORequestBody_t      *tdIORequestBody;
  TI_DBG2(("itdssIONoDeviceHandler: start\n"));

  tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;

  ostiInitiatorIOCompleted (
                            tiRoot,
                            tdIORequestBody->tiIORequest,
                            tiIOFailed,
                            tiDetailNoLogin,
                            agNULL,
                            intContext
                            );
  return;
}

#ifdef REMOVED /* to do: removed from spec */
/*****************************************************************************
*! \brief itdssIllegalParameterHandler
*
*  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
*            layer with agIOStatus = OSSA_IO_ILLEGAL_PARAMETER
*
*  \param  agRoot:            pointer to port instance
*  \param  agIORequest:       pointer to I/O request
*  \param  agIOStatus:        I/O status given by LL layer
*  \param  agIOInfoLen:       lenth of complete SAS RESP frame
*  \param  agParam            A Handle used to refer to the response frame or handle
*                             of abort request
*  \return: None
*
*
*****************************************************************************/
osGLOBAL void
itdssIllegalParameterHandler(
                       agsaRoot_t           *agRoot,
                       agsaIORequest_t      *agIORequest,
                       bit32                agIOStatus,
                       bit32                agIOInfoLen,
                       void                 *agParam
                       )
{
  tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
  tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
  bit32                  intContext = osData->IntContext;
  tdIORequestBody_t      *tdIORequestBody;
  TI_DBG2(("itdssIllegalParameterHandler: start\n"));

  tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;

  ostiInitiatorIOCompleted (
                            tiRoot,
                            tdIORequestBody->tiIORequest,
                            tiIOFailed,
                            tiDetailOtherError,
                            agNULL,
                            intContext
                            );

  return;
}
#endif

/*****************************************************************************
*! \brief itdssLinkFailureHandler
*
*  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
*            layer with agIOStatus = OSSA_IO_LINK_FAILURE
*
*  \param  agRoot:            pointer to port instance
*  \param  agIORequest:       pointer to I/O request
*  \param  agIOStatus:        I/O status given by LL layer
*  \param  agIOInfoLen:       lenth of complete SAS RESP frame
*  \param  agParam            A Handle used to refer to the response frame or handle
*                             of abort request
*  \param  agOtherInfo        Residual count
*  \return: None
*
*
*****************************************************************************/
osGLOBAL void
itdssLinkFailureHandler(
                       agsaRoot_t           *agRoot,
                       agsaIORequest_t      *agIORequest,
                       bit32                agIOStatus,
                       bit32                agIOInfoLen,
                       void                 *agParam,
                       bit32                agOtherInfo
                       )
{
  tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
  tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
  bit32                  intContext = osData->IntContext;
  tdIORequestBody_t      *tdIORequestBody;
  TI_DBG1(("itdssLinkFailureHandler: start\n"));

  tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;

  ostiInitiatorIOCompleted (
                            tiRoot,
                            tdIORequestBody->tiIORequest,
                            tiIOFailed,
                            tiDetailOtherError,
                            agNULL,
                            intContext
                            );

  return;
}

/*****************************************************************************
*! \brief itdssProgErrorHandler
*
*  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
*            layer with agIOStatus = OSSA_IO_PROG_ERROR
*
*  \param  agRoot:            pointer to port instance
*  \param  agIORequest:       pointer to I/O request
*  \param  agIOStatus:        I/O status given by LL layer
*  \param  agIOInfoLen:       lenth of complete SAS RESP frame
*  \param  agParam            A Handle used to refer to the response frame or handle
*                             of abort request
*  \param  agOtherInfo        Residual count
*  \return: None
*
*
*****************************************************************************/
osGLOBAL void
itdssProgErrorHandler(
                       agsaRoot_t           *agRoot,
                       agsaIORequest_t      *agIORequest,
                       bit32                agIOStatus,
                       bit32                agIOInfoLen,
                       void                 *agParam,
                       bit32                agOtherInfo
                       )
{
  tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
  tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
  bit32                  intContext = osData->IntContext;
  tdIORequestBody_t      *tdIORequestBody;
  TI_DBG2(("itdssProgErrorHandler: start\n"));

  tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;

  ostiInitiatorIOCompleted (
                            tiRoot,
                            tdIORequestBody->tiIORequest,
                            tiIOFailed,
                            tiDetailOtherError,
                            agNULL,
                            intContext
                            );

  return;
}

/*****************************************************************************
*! \brief itdssXferErrorBreakHandler
*
*  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
*            layer with agIOStatus = OSSA_IO_XFER_ERROR_BREAK
*
*  \param  agRoot:            pointer to port instance
*  \param  agIORequest:       pointer to I/O request
*  \param  agIOStatus:        I/O status given by LL layer
*  \param  agIOInfoLen:       lenth of complete SAS RESP frame
*  \param  agParam            A Handle used to refer to the response frame or handle
*                             of abort request
*  \param  agOtherInfo        Residual count
*  \return: None
*
*
*****************************************************************************/
osGLOBAL void
itdssXferErrorBreakHandler(
                       agsaRoot_t           *agRoot,
                       agsaIORequest_t      *agIORequest,
                       bit32                agIOStatus,
                       bit32                agIOInfoLen,
                       void                 *agParam,
                       bit32                agOtherInfo
                       )
{
  tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
  tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
  bit32                  intContext = osData->IntContext;
  tdIORequestBody_t      *tdIORequestBody;
  TI_DBG1(("itdssXferErrorBreakHandler: start\n"));

  tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;

  ostiInitiatorIOCompleted (
                            tiRoot,
                            tdIORequestBody->tiIORequest,
                            tiIOFailed,
                            tiDetailOtherError,
                            agNULL,
                            intContext
                            );

  return;
}

/*****************************************************************************
*! \brief itdssXferErrorPhyNotReadyHandler
*
*  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
*            layer with agIOStatus = OSSA_IO_XFER_ERROR_PHY_NOT_READY
*
*  \param  agRoot:            pointer to port instance
*  \param  agIORequest:       pointer to I/O request
*  \param  agIOStatus:        I/O status given by LL layer
*  \param  agIOInfoLen:       lenth of complete SAS RESP frame
*  \param  agParam            A Handle used to refer to the response frame or handle
*                             of abort request
*  \param  agOtherInfo        Residual count
*  \return: None
*
*
*****************************************************************************/
osGLOBAL void
itdssXferErrorPhyNotReadyHandler(
                       agsaRoot_t           *agRoot,
                       agsaIORequest_t      *agIORequest,
                       bit32                agIOStatus,
                       bit32                agIOInfoLen,
                       void                 *agParam,
                       bit32                agOtherInfo
                       )
{
  tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
  tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
  bit32                  intContext = osData->IntContext;
  tdIORequestBody_t      *tdIORequestBody;
  TI_DBG2(("itdssXferErrorPhyNotReadyHandler: start\n"));

  tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;

  ostiInitiatorIOCompleted (
                            tiRoot,
                            tdIORequestBody->tiIORequest,
                            tiIOFailed,
                            tiDetailOtherError,
                            agNULL,
                            intContext
                            );

  return;
}

/*****************************************************************************
*! \brief itdssOpenCnxErrorProtocolNotSupprotedHandler
*
*  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
*            layer with agIOStatus = OSSA_IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED
*
*  \param  agRoot:            pointer to port instance
*  \param  agIORequest:       pointer to I/O request
*  \param  agIOStatus:        I/O status given by LL layer
*  \param  agIOInfoLen:       lenth of complete SAS RESP frame
*  \param  agParam            A Handle used to refer to the response frame or handle
*                             of abort request
*  \param  agOtherInfo        Residual count
*  \return: None
*
*
*****************************************************************************/
osGLOBAL void
itdssOpenCnxErrorProtocolNotSupprotedHandler(
                       agsaRoot_t           *agRoot,
                       agsaIORequest_t      *agIORequest,
                       bit32                agIOStatus,
                       bit32                agIOInfoLen,
                       void                 *agParam,
                       bit32                agOtherInfo
                       )
{
  tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
  tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
  bit32                  intContext = osData->IntContext;
  tdIORequestBody_t      *tdIORequestBody;
  TI_DBG2(("itdssOpenCnxErrorProtocolNotSupprotedHandler: start\n"));

  tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;

  ostiInitiatorIOCompleted (
                            tiRoot,
                            tdIORequestBody->tiIORequest,
                            tiIOFailed,
                            tiDetailOtherError,
                            agNULL,
                            intContext
                            );

  return;
}

/*****************************************************************************
*! \brief itdssOpenCnxErrorZoneViolationHandler
*
*  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
*            layer with agIOStatus = OSSA_IO_OPEN_CNX_ERROR_ZONE_VIOLATION
*
*  \param  agRoot:            pointer to port instance
*  \param  agIORequest:       pointer to I/O request
*  \param  agIOStatus:        I/O status given by LL layer
*  \param  agIOInfoLen:       lenth of complete SAS RESP frame
*  \param  agParam            A Handle used to refer to the response frame or handle
*                             of abort request
*  \param  agOtherInfo        Residual count
*  \return: None
*
*
*****************************************************************************/
osGLOBAL void
itdssOpenCnxErrorZoneViolationHandler(
                       agsaRoot_t           *agRoot,
                       agsaIORequest_t      *agIORequest,
                       bit32                agIOStatus,
                       bit32                agIOInfoLen,
                       void                 *agParam,
                       bit32                agOtherInfo
                       )
{
  tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
  tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
  bit32                  intContext = osData->IntContext;
  tdIORequestBody_t      *tdIORequestBody;
  TI_DBG2(("itdssOpenCnxErrorZoneViolationHandler: start\n"));

  tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;

  ostiInitiatorIOCompleted (
                            tiRoot,
                            tdIORequestBody->tiIORequest,
                            tiIOFailed,
                            tiDetailOtherError,
                            agNULL,
                            intContext
                            );

  return;
}

/*****************************************************************************
*! \brief itdssOpenCnxErrorBreakHandler
*
*  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
*            layer with agIOStatus = OSSA_IO_OPEN_CNX_ERROR_BREAK
*
*  \param  agRoot:            pointer to port instance
*  \param  agIORequest:       pointer to I/O request
*  \param  agIOStatus:        I/O status given by LL layer
*  \param  agIOInfoLen:       lenth of complete SAS RESP frame
*  \param  agParam            A Handle used to refer to the response frame or handle
*                             of abort request
*  \param  agOtherInfo        Residual count
*  \return: None
*
*
*****************************************************************************/
osGLOBAL void
itdssOpenCnxErrorBreakHandler(
                       agsaRoot_t           *agRoot,
                       agsaIORequest_t      *agIORequest,
                       bit32                agIOStatus,
                       bit32                agIOInfoLen,
                       void                 *agParam,
                       bit32                agOtherInfo
                       )
{
  tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
  tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
  bit32                  intContext = osData->IntContext;
  tdIORequestBody_t      *tdIORequestBody;
  TI_DBG1(("itdssOpenCnxErrorBreakHandler: start\n"));

  tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;

  ostiInitiatorIOCompleted (
                            tiRoot,
                            tdIORequestBody->tiIORequest,
                            tiIOFailed,
                            tiDetailOtherError,
                            agNULL,
                            intContext
                            );

  return;
}

/*****************************************************************************
*! \brief itdssOpenCnxErrorITNexusLossHandler
*
*  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
*            layer with agIOStatus = OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS
*
*  \param  agRoot:            pointer to port instance
*  \param  agIORequest:       pointer to I/O request
*  \param  agIOStatus:        I/O status given by LL layer
*  \param  agIOInfoLen:       lenth of complete SAS RESP frame
*  \param  agParam            A Handle used to refer to the response frame or handle
*                             of abort request
*  \param  agOtherInfo        Residual count
*  \return: None
*
*
*****************************************************************************/
osGLOBAL void
itdssOpenCnxErrorITNexusLossHandler(
                       agsaRoot_t           *agRoot,
                       agsaIORequest_t      *agIORequest,
                       bit32                agIOStatus,
                       bit32                agIOInfoLen,
                       void                 *agParam,
                       bit32                agOtherInfo
                       )
{
  tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
  tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
  bit32                  intContext = osData->IntContext;
  tdIORequestBody_t      *tdIORequestBody;
  TI_DBG1(("itdssOpenCnxErrorITNexusLossHandler: start\n"));

  tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;

  ostiInitiatorIOCompleted (
                            tiRoot,
                            tdIORequestBody->tiIORequest,
                            tiIOFailed,
                            tiDetailOtherError,
                            agNULL,
                            intContext
                            );

  return;
}

/*****************************************************************************
*! \brief itdssOpenCnxErrorBadDestinationHandler
*
*  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
*            layer with agIOStatus = OSSA_IO_OPEN_CNX_ERROR_BAD_DESTINATION
*
*  \param  agRoot:            pointer to port instance
*  \param  agIORequest:       pointer to I/O request
*  \param  agIOStatus:        I/O status given by LL layer
*  \param  agIOInfoLen:       lenth of complete SAS RESP frame
*  \param  agParam            A Handle used to refer to the response frame or handle
*                             of abort request
*  \param  agOtherInfo        Residual count
*  \return: None
*
*
*****************************************************************************/
osGLOBAL void
itdssOpenCnxErrorBadDestinationHandler(
                       agsaRoot_t           *agRoot,
                       agsaIORequest_t      *agIORequest,
                       bit32                agIOStatus,
                       bit32                agIOInfoLen,
                       void                 *agParam,
                       bit32                agOtherInfo
                       )
{
  tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
  tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
  bit32                  intContext = osData->IntContext;
  tdIORequestBody_t      *tdIORequestBody;
  TI_DBG1(("itdssOpenCnxErrorBadDestinationHandler: start\n"));

  tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;

  ostiInitiatorIOCompleted (
                            tiRoot,
                            tdIORequestBody->tiIORequest,
                            tiIOFailed,
                            tiDetailOtherError,
                            agNULL,
                            intContext
                            );

  return;
}

/*****************************************************************************
*! \brief itdssOpenCnxErrorConnectionRateNotSupportedHandler
*
*  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
*            layer with agIOStatus = OSSA_IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED
*
*  \param  agRoot:            pointer to port instance
*  \param  agIORequest:       pointer to I/O request
*  \param  agIOStatus:        I/O status given by LL layer
*  \param  agIOInfoLen:       lenth of complete SAS RESP frame
*  \param  agParam            A Handle used to refer to the response frame or handle
*                             of abort request
*  \param  agOtherInfo        Residual count
*  \return: None
*
*
*****************************************************************************/
osGLOBAL void
itdssOpenCnxErrorConnectionRateNotSupportedHandler(
                       agsaRoot_t           *agRoot,
                       agsaIORequest_t      *agIORequest,
                       bit32                agIOStatus,
                       bit32                agIOInfoLen,
                       void                 *agParam,
                       bit32                agOtherInfo
                       )
{
  tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
  tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
  tdsaRoot_t             *tdsaRoot      = (tdsaRoot_t *) tiRoot->tdData;
  tdsaContext_t          *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
  bit32                  intContext = osData->IntContext;
  tdIORequestBody_t      *tdIORequestBody;
  agsaDevHandle_t        *agDevHandle = agNULL;
  tiDeviceHandle_t       *tiDeviceHandle = agNULL;
  tdsaDeviceData_t       *oneDeviceData = agNULL;
  bit32                  ConnRate = SAS_CONNECTION_RATE_12_0G;
  agsaContext_t          *agContext = agNULL;
  TI_DBG1(("itdssOpenCnxErrorConnectionRateNotSupportedHandler: start\n"));

  /* we retry by lowering link rate
     retry should be in ossaSetDeviceInfoCB()
  */
  tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
  tiDeviceHandle = tdIORequestBody->tiDevHandle;
  oneDeviceData  = (tdsaDeviceData_t *)tiDeviceHandle->tdData;
  agDevHandle = oneDeviceData->agDevHandle;

  if (tdsaAllShared->RateAdjust)
  {
    if (oneDeviceData->valid == agTRUE && oneDeviceData->registered == agTRUE &&
        oneDeviceData->tdPortContext != agNULL )
    {
      ConnRate = DEVINFO_GET_LINKRATE(&oneDeviceData->agDeviceInfo);
      if (ConnRate == SAS_CONNECTION_RATE_1_5G)
      {
        /* no retry; completes IO */
        ostiInitiatorIOCompleted(
                                 tiRoot,
                                 tdIORequestBody->tiIORequest,
                                 tiIOFailed,
                                 tiDetailOtherError,
                                 agNULL,
                                 intContext
                                 );
      }
      else
      {
        ConnRate = ConnRate - 1;
      }
      agContext = &(tdIORequestBody->agContext);
      agContext->osData = agIORequest;
      saSetDeviceInfo(agRoot, agContext, tdsaRotateQnumber(tiRoot, oneDeviceData), agDevHandle, 32, ConnRate << 28, ossaIniSetDeviceInfoCB);
    }
  }
  else
  {
    ostiInitiatorIOCompleted(
                             tiRoot,
                             tdIORequestBody->tiIORequest,
                             tiIOFailed,
                             tiDetailOtherError,
                             agNULL,
                             intContext
                             );
  }

  return;
}

/*****************************************************************************
*! \brief itdssOpenCnxErrorSTPResourceBusyHandler
*
*  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
*            layer with agIOStatus = OSSA_IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY
*
*  \param  agRoot:            pointer to port instance
*  \param  agIORequest:       pointer to I/O request
*  \param  agIOStatus:        I/O status given by LL layer
*  \param  agIOInfoLen:       lenth of complete SAS RESP frame
*  \param  agParam            A Handle used to refer to the response frame or handle
*                             of abort request
*  \param  agOtherInfo        Residual count
*  \return: None
*
*
*****************************************************************************/
osGLOBAL void
itdssOpenCnxErrorSTPResourceBusyHandler(
                       agsaRoot_t           *agRoot,
                       agsaIORequest_t      *agIORequest,
                       bit32                agIOStatus,
                       bit32                agIOInfoLen,
                       void                 *agParam,
                       bit32                agOtherInfo
                       )
{
  tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
  tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
  bit32                  intContext = osData->IntContext;
  tdIORequestBody_t      *tdIORequestBody;
  TI_DBG2(("itdssOpenCnxErrorSTPResourceBusyHandler: start\n"));

  tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;

  ostiInitiatorIOCompleted (
                            tiRoot,
                            tdIORequestBody->tiIORequest,
                            tiIOFailed,
                            tiDetailOtherError,
                            agNULL,
                            intContext
                            );

  return;
}

/*****************************************************************************
*! \brief itdssOpenCnxErrorWrongDestinationHandler
*
*  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
*            layer with agIOStatus = OSSA_IO_OPEN_CNX_ERROR_WRONG_DESTINATION
*
*  \param  agRoot:            pointer to port instance
*  \param  agIORequest:       pointer to I/O request
*  \param  agIOStatus:        I/O status given by LL layer
*  \param  agIOInfoLen:       lenth of complete SAS RESP frame
*  \param  agParam            A Handle used to refer to the response frame or handle
*                             of abort request
*  \param  agOtherInfo        Residual count
*  \return: None
*
*
*****************************************************************************/
osGLOBAL void
itdssOpenCnxErrorWrongDestinationHandler(
                       agsaRoot_t           *agRoot,
                       agsaIORequest_t      *agIORequest,
                       bit32                agIOStatus,
                       bit32                agIOInfoLen,
                       void                 *agParam,
                       bit32                agOtherInfo
                       )
{
  tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
  tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
  bit32                  intContext = osData->IntContext;
  tdIORequestBody_t      *tdIORequestBody;
  TI_DBG1(("itdssOpenCnxErrorWrongDestinationHandler: start\n"));

  tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;

  ostiInitiatorIOCompleted (
                            tiRoot,
                            tdIORequestBody->tiIORequest,
                            tiIOFailed,
                            tiDetailOtherError,
                            agNULL,
                            intContext
                            );

  return;
}

/*****************************************************************************
*! \brief itdssOpenCnxErrorUnknownErrorHandler
*
*  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
*            layer with agIOStatus = OSSA_IO_OPEN_CNX_ERROR_UNKNOWN_ERROR
*
*  \param  agRoot:            pointer to port instance
*  \param  agIORequest:       pointer to I/O request
*  \param  agIOStatus:        I/O status given by LL layer
*  \param  agIOInfoLen:       lenth of complete SAS RESP frame
*  \param  agParam            A Handle used to refer to the response frame or handle
*                             of abort request
*  \param  agOtherInfo        Residual count
*  \return: None
*
*
*****************************************************************************/
osGLOBAL void
itdssOpenCnxErrorUnknownErrorHandler(
                       agsaRoot_t           *agRoot,
                       agsaIORequest_t      *agIORequest,
                       bit32                agIOStatus,
                       bit32                agIOInfoLen,
                       void                 *agParam,
                       bit32                agOtherInfo
                       )
{
  tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
  tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
  bit32                  intContext = osData->IntContext;
  tdIORequestBody_t      *tdIORequestBody;
  TI_DBG1(("itdssOpenCnxErrorUnknownErrorHandler: start\n"));

  tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;

  ostiInitiatorIOCompleted (
                            tiRoot,
                            tdIORequestBody->tiIORequest,
                            tiIOFailed,
                            tiDetailOtherError,
                            agNULL,
                            intContext
                            );

  return;
}

/*****************************************************************************
*! \brief itdssXferErrorNAKReceivedHandler
*
*  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
*            layer with agIOStatus = OSSA_IO_XFER_ERROR_NAK_RECEIVED
*
*  \param  agRoot:            pointer to port instance
*  \param  agIORequest:       pointer to I/O request
*  \param  agIOStatus:        I/O status given by LL layer
*  \param  agIOInfoLen:       lenth of complete SAS RESP frame
*  \param  agParam            A Handle used to refer to the response frame or handle
*                             of abort request
*  \param  agOtherInfo        Residual count
*  \return: None
*
*
*****************************************************************************/
osGLOBAL void
itdssXferErrorNAKReceivedHandler(
                       agsaRoot_t           *agRoot,
                       agsaIORequest_t      *agIORequest,
                       bit32                agIOStatus,
                       bit32                agIOInfoLen,
                       void                 *agParam,
                       bit32                agOtherInfo
                       )
{
  tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
  tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
  bit32                  intContext = osData->IntContext;
  tdIORequestBody_t      *tdIORequestBody;
  TI_DBG1(("itdssXferErrorNAKReceivedHandler: start\n"));

  tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;

  ostiInitiatorIOCompleted (
                            tiRoot,
                            tdIORequestBody->tiIORequest,
                            tiIOFailed,
                            tiDetailOtherError,
                            agNULL,
                            intContext
                            );

  return;
}

/*****************************************************************************
*! \brief itdssXferErrorACKNAKTimeoutHandler
*
*  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
*            layer with agIOStatus = OSSA_IO_XFER_ERROR_ACK_NAK_TIMEOUT
*
*  \param  agRoot:            pointer to port instance
*  \param  agIORequest:       pointer to I/O request
*  \param  agIOStatus:        I/O status given by LL layer
*  \param  agIOInfoLen:       lenth of complete SAS RESP frame
*  \param  agParam            A Handle used to refer to the response frame or handle
*                             of abort request
*  \param  agOtherInfo        Residual count
*  \return: None
*
*
*****************************************************************************/
osGLOBAL void
itdssXferErrorACKNAKTimeoutHandler(
                       agsaRoot_t           *agRoot,
                       agsaIORequest_t      *agIORequest,
                       bit32                agIOStatus,
                       bit32                agIOInfoLen,
                       void                 *agParam,
                       bit32                agOtherInfo
                       )
{
  tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
  tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
  bit32                  intContext = osData->IntContext;
  tdIORequestBody_t      *tdIORequestBody;
  TI_DBG1(("itdssXferErrorACKNAKTimeoutHandler: start\n"));

  tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;

  ostiInitiatorIOCompleted (
                            tiRoot,
                            tdIORequestBody->tiIORequest,
                            tiIOFailed,
                            tiDetailOtherError,
                            agNULL,
                            intContext
                            );

  return;
}

/*****************************************************************************
*! \brief itdssXferErrorPeerAbortedHandler
*
*  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
*            layer with agIOStatus = OSSA_IO_XFER_ERROR_PEER_ABORTED
*
*  \param  agRoot:            pointer to port instance
*  \param  agIORequest:       pointer to I/O request
*  \param  agIOStatus:        I/O status given by LL layer
*  \param  agIOInfoLen:       lenth of complete SAS RESP frame
*  \param  agParam            A Handle used to refer to the response frame or handle
*                             of abort request
*  \param  agOtherInfo        Residual count
*  \return: None
*
*
*****************************************************************************/
osGLOBAL void
itdssXferErrorPeerAbortedHandler(
                       agsaRoot_t           *agRoot,
                       agsaIORequest_t      *agIORequest,
                       bit32                agIOStatus,
                       bit32                agIOInfoLen,
                       void                 *agParam,
                       bit32                agOtherInfo
                       )
{
  tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
  tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
  bit32                  intContext = osData->IntContext;
  tdIORequestBody_t      *tdIORequestBody;
  TI_DBG2(("itdssXferErrorPeerAbortedHandler: start\n"));

  tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;

  ostiInitiatorIOCompleted (
                            tiRoot,
                            tdIORequestBody->tiIORequest,
                            tiIOFailed,
                            tiDetailOtherError,
                            agNULL,
                            intContext
                            );

  return;
}

/*****************************************************************************
*! \brief itdssXferErrorRxFrameHandler
*
*  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
*            layer with agIOStatus = OSSA_IO_XFER_ERROR_RX_FRAME
*
*  \param  agRoot:            pointer to port instance
*  \param  agIORequest:       pointer to I/O request
*  \param  agIOStatus:        I/O status given by LL layer
*  \param  agIOInfoLen:       lenth of complete SAS RESP frame
*  \param  agParam            A Handle used to refer to the response frame or handle
*                             of abort request
*  \param  agOtherInfo        Residual count
*  \return: None
*
*
*****************************************************************************/
osGLOBAL void
itdssXferErrorRxFrameHandler(
                       agsaRoot_t           *agRoot,
                       agsaIORequest_t      *agIORequest,
                       bit32                agIOStatus,
                       bit32                agIOInfoLen,
                       void                 *agParam,
                       bit32                agOtherInfo
                       )
{
  tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
  tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
  bit32                  intContext = osData->IntContext;
  tdIORequestBody_t      *tdIORequestBody;
  TI_DBG1(("itdssXferErrorRxFrameHandler: start\n"));

  tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;

  ostiInitiatorIOCompleted (
                            tiRoot,
                            tdIORequestBody->tiIORequest,
                            tiIOFailed,
                            tiDetailOtherError,
                            agNULL,
                            intContext
                            );

  return;
}

/*****************************************************************************
*! \brief itdssXferErrorDMAHandler
*
*  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
*            layer with agIOStatus = OSSA_IO_XFER_ERROR_DMA
*
*  \param  agRoot:            pointer to port instance
*  \param  agIORequest:       pointer to I/O request
*  \param  agIOStatus:        I/O status given by LL layer
*  \param  agIOInfoLen:       lenth of complete SAS RESP frame
*  \param  agParam            A Handle used to refer to the response frame or handle
*                             of abort request
*  \param  agOtherInfo        Residual count
*  \return: None
*
*
*****************************************************************************/
osGLOBAL void
itdssXferErrorDMAHandler(
                       agsaRoot_t           *agRoot,
                       agsaIORequest_t      *agIORequest,
                       bit32                agIOStatus,
                       bit32                agIOInfoLen,
                       void                 *agParam,
                       bit32                agOtherInfo
                       )
{
  tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
  tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
  bit32                  intContext = osData->IntContext;
  tdIORequestBody_t      *tdIORequestBody;
  TI_DBG1(("itdssXferErrorDMAHandler: start\n"));

  tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;

  ostiInitiatorIOCompleted (
                            tiRoot,
                            tdIORequestBody->tiIORequest,
                            tiIOFailed,
                            tiDetailOtherErrorNoRetry,
                            agNULL,
                            intContext
                            );

  return;
}

/*****************************************************************************
*! \brief itdssXferErrorCreditTimeoutHandler
*
*  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
*            layer with agIOStatus = OSSA_IO_XFER_ERROR_CREDIT_TIMEOUT
*
*  \param  agRoot:            pointer to port instance
*  \param  agIORequest:       pointer to I/O request
*  \param  agIOStatus:        I/O status given by LL layer
*  \param  agIOInfoLen:       lenth of complete SAS RESP frame
*  \param  agParam            A Handle used to refer to the response frame or handle
*                             of abort request
*  \param  agOtherInfo        Residual count
*  \return: None
*
*
*****************************************************************************/
osGLOBAL void
itdssXferErrorCreditTimeoutHandler(
                       agsaRoot_t           *agRoot,
                       agsaIORequest_t      *agIORequest,
                       bit32                agIOStatus,
                       bit32                agIOInfoLen,
                       void                 *agParam,
                       bit32                agOtherInfo
                       )
{
  tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
  tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
  bit32                  intContext = osData->IntContext;
  tdIORequestBody_t      *tdIORequestBody;
  TI_DBG1(("itdssXferErrorCreditTimeoutHandler: start\n"));

  tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;

  ostiInitiatorIOCompleted (
                            tiRoot,
                            tdIORequestBody->tiIORequest,
                            tiIOFailed,
                            tiDetailOtherError,
                            agNULL,
                            intContext
                            );

  return;
}

/*****************************************************************************
*! \brief itdssXferErrorCMDIssueACKNAKTimeoutHandler
*
*  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
*            layer with agIOStatus = OSSA_IO_XFER_ERROR_CMD_ISSUE_ACK_NAK_TIMEOUT
*
*  \param  agRoot:            pointer to port instance
*  \param  agIORequest:       pointer to I/O request
*  \param  agIOStatus:        I/O status given by LL layer
*  \param  agIOInfoLen:       lenth of complete SAS RESP frame
*  \param  agParam            A Handle used to refer to the response frame or handle
*                             of abort request
*  \param  agOtherInfo        Residual count
*  \return: None
*
*
*****************************************************************************/
osGLOBAL void
itdssXferErrorCMDIssueACKNAKTimeoutHandler(
                       agsaRoot_t           *agRoot,
                       agsaIORequest_t      *agIORequest,
                       bit32                agIOStatus,
                       bit32                agIOInfoLen,
                       void                 *agParam,
                       bit32                agOtherInfo
                       )
{
  tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
  tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
  bit32                  intContext = osData->IntContext;
  tdIORequestBody_t      *tdIORequestBody;
  TI_DBG1(("itdssXferErrorCMDIssueACKNAKTimeoutHandler: start\n"));

  tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;

  ostiInitiatorIOCompleted (
                            tiRoot,
                            tdIORequestBody->tiIORequest,
                            tiIOFailed,
                            tiDetailOtherError,
                            agNULL,
                            intContext
                            );

  return;
}

/*****************************************************************************
*! \brief itdssXferErrorCMDIssueBreakBeforeACKNAKHandler
*
*  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
*            layer with agIOStatus = OSSA_IO_XFER_ERROR_CMD_ISSUE_BREAK_BEFORE_ACK_NAK
*
*  \param  agRoot:            pointer to port instance
*  \param  agIORequest:       pointer to I/O request
*  \param  agIOStatus:        I/O status given by LL layer
*  \param  agIOInfoLen:       lenth of complete SAS RESP frame
*  \param  agParam            A Handle used to refer to the response frame or handle
*                             of abort request
*  \param  agOtherInfo        Residual count
*  \return: None
*
*
*****************************************************************************/
osGLOBAL void
itdssXferErrorCMDIssueBreakBeforeACKNAKHandler(
                       agsaRoot_t           *agRoot,
                       agsaIORequest_t      *agIORequest,
                       bit32                agIOStatus,
                       bit32                agIOInfoLen,
                       void                 *agParam,
                       bit32                agOtherInfo
                       )
{
  tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
  tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
  bit32                  intContext = osData->IntContext;
  tdIORequestBody_t      *tdIORequestBody;
  TI_DBG1(("itdssXferErrorCMDIssueBreakBeforeACKNAKHandler: start\n"));

  tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;

  ostiInitiatorIOCompleted (
                            tiRoot,
                            tdIORequestBody->tiIORequest,
                            tiIOFailed,
                            tiDetailOtherError,
                            agNULL,
                            intContext
                            );

  return;
}

/*****************************************************************************
*! \brief itdssXferErrorCMDIssuePhyDownBeforeACKNAKHandler
*
*  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
*            layer with agIOStatus = OSSA_IO_XFER_ERROR_CMD_ISSUE_PHY_DOWN_BEFORE_ACK_NAK
*
*  \param  agRoot:            pointer to port instance
*  \param  agIORequest:       pointer to I/O request
*  \param  agIOStatus:        I/O status given by LL layer
*  \param  agIOInfoLen:       lenth of complete SAS RESP frame
*  \param  agParam            A Handle used to refer to the response frame or handle
*                             of abort request
*  \param  agOtherInfo        Residual count
*  \return: None
*
*
*****************************************************************************/
osGLOBAL void
itdssXferErrorCMDIssuePhyDownBeforeACKNAKHandler(
                       agsaRoot_t           *agRoot,
                       agsaIORequest_t      *agIORequest,
                       bit32                agIOStatus,
                       bit32                agIOInfoLen,
                       void                 *agParam,
                       bit32                agOtherInfo
                       )
{
  tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
  tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
  bit32                  intContext = osData->IntContext;
  tdIORequestBody_t      *tdIORequestBody;
  TI_DBG1(("itdssXferErrorCMDIssuePhyDownBeforeACKNAKHandler: start\n"));

  tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;

  ostiInitiatorIOCompleted (
                            tiRoot,
                            tdIORequestBody->tiIORequest,
                            tiIOFailed,
                            tiDetailOtherError,
                            agNULL,
                            intContext
                            );

  return;
}

/*****************************************************************************
*! \brief itdssXferErrorDisruptedPhyDownHandler
*
*  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
*            layer with agIOStatus = OSSA_IO_XFER_ERROR_DISRUPTED_PHY_DOWN
*
*  \param  agRoot:            pointer to port instance
*  \param  agIORequest:       pointer to I/O request
*  \param  agIOStatus:        I/O status given by LL layer
*  \param  agIOInfoLen:       lenth of complete SAS RESP frame
*  \param  agParam            A Handle used to refer to the response frame or handle
*                             of abort request
*  \param  agOtherInfo        Residual count
*  \return: None
*
*
*****************************************************************************/
osGLOBAL void
itdssXferErrorDisruptedPhyDownHandler(
                       agsaRoot_t           *agRoot,
                       agsaIORequest_t      *agIORequest,
                       bit32                agIOStatus,
                       bit32                agIOInfoLen,
                       void                 *agParam,
                       bit32                agOtherInfo
                       )
{
  tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
  tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
  bit32                  intContext = osData->IntContext;
  tdIORequestBody_t      *tdIORequestBody;
  TI_DBG2(("itdssXferErrorDisruptedPhyDownHandler: start\n"));

  tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;

  ostiInitiatorIOCompleted (
                            tiRoot,
                            tdIORequestBody->tiIORequest,
                            tiIOFailed,
                            tiDetailOtherError,
                            agNULL,
                            intContext
                            );

  return;
}

/*****************************************************************************
*! \brief itdssXferErrorOffsetMismatchHandler
*
*  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
*            layer with agIOStatus = OSSA_IO_XFER_ERROR_OFFSET_MISMATCH
*
*  \param  agRoot:            pointer to port instance
*  \param  agIORequest:       pointer to I/O request
*  \param  agIOStatus:        I/O status given by LL layer
*  \param  agIOInfoLen:       lenth of complete SAS RESP frame
*  \param  agParam            A Handle used to refer to the response frame or handle
*                             of abort request
*  \param  agOtherInfo        Residual count
*  \return: None
*
*
*****************************************************************************/
osGLOBAL void
itdssXferErrorOffsetMismatchHandler(
                       agsaRoot_t           *agRoot,
                       agsaIORequest_t      *agIORequest,
                       bit32                agIOStatus,
                       bit32                agIOInfoLen,
                       void                 *agParam,
                       bit32                agOtherInfo
                       )
{
  tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
  tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
  bit32                  intContext = osData->IntContext;
  tdIORequestBody_t      *tdIORequestBody;
  TI_DBG1(("itdssXferErrorOffsetMismatchHandler: start\n"));

  tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;

  ostiInitiatorIOCompleted (
                            tiRoot,
                            tdIORequestBody->tiIORequest,
                            tiIOFailed,
                            tiDetailOtherError,
                            agNULL,
                            intContext
                            );

  return;
}

/*****************************************************************************
*! \brief itdssXferErrorXferZeroDataLenHandler
*
*  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
*            layer with agIOStatus = OSSA_IO_XFER_ERROR_XFER_ZERO_DATA_LEN
*
*  \param  agRoot:            pointer to port instance
*  \param  agIORequest:       pointer to I/O request
*  \param  agIOStatus:        I/O status given by LL layer
*  \param  agIOInfoLen:       lenth of complete SAS RESP frame
*  \param  agParam            A Handle used to refer to the response frame or handle
*                             of abort request
*  \param  agOtherInfo        Residual count
*  \return: None
*
*
*****************************************************************************/
osGLOBAL void
itdssXferErrorXferZeroDataLenHandler(
                       agsaRoot_t           *agRoot,
                       agsaIORequest_t      *agIORequest,
                       bit32                agIOStatus,
                       bit32                agIOInfoLen,
                       void                 *agParam,
                       bit32                agOtherInfo
                       )
{
  tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
  tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
  bit32                  intContext = osData->IntContext;
  tdIORequestBody_t      *tdIORequestBody;
  TI_DBG2(("itdssXferErrorXferZeroDataLenHandler: start\n"));

  tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;

  ostiInitiatorIOCompleted (
                            tiRoot,
                            tdIORequestBody->tiIORequest,
                            tiIOFailed,
                            tiDetailOtherError,
                            agNULL,
                            intContext
                            );

  return;
}

/*****************************************************************************
*! \brief itdssXferOpenRetryTimeoutHandler
*
*  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
*            layer with agIOStatus = OSSA_IO_XFER_OPEN_RETRY_TIMEOUT
*
*  \param  agRoot:            pointer to port instance
*  \param  agIORequest:       pointer to I/O request
*  \param  agIOStatus:        I/O status given by LL layer
*  \param  agIOInfoLen:       lenth of complete SAS RESP frame
*  \param  agParam            A Handle used to refer to the response frame or handle
*                             of abort request
*  \param  agOtherInfo        Residual count
*  \return: None
*
*
*****************************************************************************/
osGLOBAL void
itdssXferOpenRetryTimeoutHandler(
                       agsaRoot_t           *agRoot,
                       agsaIORequest_t      *agIORequest,
                       bit32                agIOStatus,
                       bit32                agIOInfoLen,
                       void                 *agParam,
                       bit32                agOtherInfo
                       )
{
  tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
  tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
  tdsaRoot_t             *tdsaRoot      = (tdsaRoot_t *) tiRoot->tdData;
  tdsaContext_t          *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
  itdsaIni_t             *Initiator = (itdsaIni_t *)tdsaAllShared->itdsaIni;
  bit32                  intContext = osData->IntContext;
  tdIORequestBody_t      *tdIORequestBody;
  agsaDevHandle_t        *agDevHandle = agNULL;
  tiDeviceHandle_t       *tiDeviceHandle = agNULL;
  tdsaDeviceData_t       *oneDeviceData = agNULL;
  bit32                  saStatus = AGSA_RC_FAILURE;

  TI_DBG2(("itdssXferOpenRetryTimeoutHandler: start\n"));

  tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
  tiDeviceHandle = tdIORequestBody->tiDevHandle;
  oneDeviceData  = (tdsaDeviceData_t *)tiDeviceHandle->tdData;
  agDevHandle = oneDeviceData->agDevHandle;

  if (oneDeviceData->valid == agTRUE && oneDeviceData->registered == agTRUE &&
      oneDeviceData->tdPortContext != agNULL )
  {
    if (tdIORequestBody->reTries < OPEN_RETRY_RETRIES) /* 10 */
    {
      saStatus = saSSPStart(agRoot,
                            agIORequest,
                            tdsaRotateQnumber(tiRoot, oneDeviceData),
                            agDevHandle,
                            tdIORequestBody->agRequestType,
                            &(tdIORequestBody->transport.SAS.agSASRequestBody),
                            agNULL,
                            &ossaSSPCompleted);

      if (saStatus == AGSA_RC_SUCCESS)
      {
        TI_DBG2(("itdssXferOpenRetryTimeoutHandler: retried\n"));
        Initiator->NumIOsActive++;
        tdIORequestBody->ioStarted = agTRUE;
        tdIORequestBody->ioCompleted = agFALSE;
        tdIORequestBody->reTries++;
        return;
      }
      else
      {
        TI_DBG1(("itdssXferOpenRetryTimeoutHandler: retry failed\n"));
        tdIORequestBody->ioStarted = agFALSE;
        tdIORequestBody->ioCompleted = agTRUE;
        tdIORequestBody->reTries = 0;
      }
    }
    else
    {
      TI_DBG1(("itdssXferOpenRetryTimeoutHandler: retry is over and fail\n"));
      tdIORequestBody->reTries = 0;
    }
  }
  else
  {
    TI_DBG1(("itdssXferOpenRetryTimeoutHandler: not valid deivce no retry\n"));
    tdIORequestBody->reTries = 0;
  }
  ostiInitiatorIOCompleted(
                           tiRoot,
                           tdIORequestBody->tiIORequest,
                           tiIOFailed,
                           tiDetailOtherError,
                           agNULL,
                           intContext
                           );
  return;
}

/*****************************************************************************
*! \brief itdssPortInResetHandler
*
*  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
*            layer with agIOStatus = OSSA_IO_PORT_IN_RESET
*
*  \param  agRoot:            pointer to port instance
*  \param  agIORequest:       pointer to I/O request
*  \param  agIOStatus:        I/O status given by LL layer
*  \param  agIOInfoLen:       lenth of complete SAS RESP frame
*  \param  agParam            A Handle used to refer to the response frame or handle
*                             of abort request
*  \param  agOtherInfo        Residual count
*  \return: None
*
*
*****************************************************************************/
osGLOBAL void
itdssPortInResetHandler(
                       agsaRoot_t           *agRoot,
                       agsaIORequest_t      *agIORequest,
                       bit32                agIOStatus,
                       bit32                agIOInfoLen,
                       void                 *agParam,
                       bit32                agOtherInfo
                       )
{
  tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
  tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
  bit32                  intContext = osData->IntContext;
  tdIORequestBody_t      *tdIORequestBody;
  TI_DBG2(("itdssPortInResetHandler: start\n"));

  tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;

  ostiInitiatorIOCompleted (
                            tiRoot,
                            tdIORequestBody->tiIORequest,
                            tiIOFailed,
                            tiDetailOtherError,
                            agNULL,
                            intContext
                            );

  return;
}

/*****************************************************************************
*! \brief itdssDsNonOperationalHandler
*
*  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
*            layer with agIOStatus = OSSA_IO_DS_NON_OPERATIONAL
*
*  \param  agRoot:            pointer to port instance
*  \param  agIORequest:       pointer to I/O request
*  \param  agIOStatus:        I/O status given by LL layer
*  \param  agIOInfoLen:       lenth of complete SAS RESP frame
*  \param  agParam            A Handle used to refer to the response frame or handle
*                             of abort request
*  \param  agOtherInfo        Residual count
*  \return: None
*
*
*****************************************************************************/
osGLOBAL void
itdssDsNonOperationalHandler(
                       agsaRoot_t           *agRoot,
                       agsaIORequest_t      *agIORequest,
                       bit32                agIOStatus,
                       bit32                agIOInfoLen,
                       void                 *agParam,
                       bit32                agOtherInfo
                       )
{
  tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
  tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
  bit32                  intContext = osData->IntContext;
  tdIORequestBody_t      *tdIORequestBody;
  agsaDevHandle_t        *agDevHandle = agNULL;
  tiDeviceHandle_t       *tiDeviceHandle = agNULL;
  tdsaDeviceData_t       *oneDeviceData = agNULL;


  TI_DBG2(("itdssDsNonOperationalHandler: start\n"));


  tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;

#if 1 /* TBD */
  /* let's do it only once ????? */
  tiDeviceHandle = tdIORequestBody->tiDevHandle;
  oneDeviceData  = (tdsaDeviceData_t *)tiDeviceHandle->tdData;
  agDevHandle = oneDeviceData->agDevHandle;
  if (oneDeviceData->valid == agTRUE && oneDeviceData->registered == agTRUE &&
      oneDeviceData->tdPortContext != agNULL )
  {
    saSetDeviceState(agRoot, agNULL, tdsaRotateQnumber(tiRoot, oneDeviceData), agDevHandle, SA_DS_OPERATIONAL);
  }
#endif

  ostiInitiatorIOCompleted (
                            tiRoot,
                            tdIORequestBody->tiIORequest,
                            tiIOFailed,
                            tiDetailOtherError,
                            agNULL,
                            intContext
                            );

  return;
}

/*****************************************************************************
*! \brief itdssDsInRecoveryHandler
*
*  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
*            layer with agIOStatus = OSSA_IO_DS_IN_RECOVERY
*
*  \param  agRoot:            pointer to port instance
*  \param  agIORequest:       pointer to I/O request
*  \param  agIOStatus:        I/O status given by LL layer
*  \param  agIOInfoLen:       lenth of complete SAS RESP frame
*  \param  agParam            A Handle used to refer to the response frame or handle
*                             of abort request
*  \param  agOtherInfo        Residual count
*  \return: None
*
*
*****************************************************************************/
osGLOBAL void
itdssDsInRecoveryHandler(
                       agsaRoot_t           *agRoot,
                       agsaIORequest_t      *agIORequest,
                       bit32                agIOStatus,
                       bit32                agIOInfoLen,
                       void                 *agParam,
                       bit32                agOtherInfo
                       )
{
  tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
  tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
  bit32                  intContext = osData->IntContext;
  tdIORequestBody_t      *tdIORequestBody;
  TI_DBG2(("itdssDsInRecoveryHandler: start\n"));

  tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;

  ostiInitiatorIOCompleted (
                            tiRoot,
                            tdIORequestBody->tiIORequest,
                            tiIOFailed,
                            tiDetailOtherError,
                            agNULL,
                            intContext
                            );

  return;
}

/*****************************************************************************
*! \brief itdssTmTagNotFoundHandler
*
*  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
*            layer with agIOStatus = OSSA_IO_TM_TAG_NOT_FOUND
*
*  \param  agRoot:            pointer to port instance
*  \param  agIORequest:       pointer to I/O request
*  \param  agIOStatus:        I/O status given by LL layer
*  \param  agIOInfoLen:       lenth of complete SAS RESP frame
*  \param  agParam            A Handle used to refer to the response frame or handle
*                             of abort request
*  \param  agOtherInfo        Residual count
*  \return: None
*
*
*****************************************************************************/
osGLOBAL void
itdssTmTagNotFoundHandler(
                       agsaRoot_t           *agRoot,
                       agsaIORequest_t      *agIORequest,
                       bit32                agIOStatus,
                       bit32                agIOInfoLen,
                       void                 *agParam,
                       bit32                agOtherInfo
                       )
{
  tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
  tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
  bit32                  intContext = osData->IntContext;
  tdIORequestBody_t      *tdIORequestBody;
  TI_DBG2(("itdssTmTagNotFoundHandler: start\n"));

  tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;

  ostiInitiatorIOCompleted (
                            tiRoot,
                            tdIORequestBody->tiIORequest,
                            tiIOFailed,
                            tiDetailOtherError,
                            agNULL,
                            intContext
                            );

  return;
}

/*****************************************************************************
*! \brief itdssSSPExtIUZeroLenHandler
*
*  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
*            layer with agIOStatus = OSSA_IO_SSP_EXT_IU_ZERO_LEN_ERROR
*
*  \param  agRoot:            pointer to port instance
*  \param  agIORequest:       pointer to I/O request
*  \param  agIOStatus:        I/O status given by LL layer
*  \param  agIOInfoLen:       lenth of complete SAS RESP frame
*  \param  agParam            A Handle used to refer to the response frame or handle
*                             of abort request
*  \param  agOtherInfo        Residual count
*  \return: None
*
*
*****************************************************************************/
osGLOBAL void
itdssSSPExtIUZeroLenHandler(
                       agsaRoot_t           *agRoot,
                       agsaIORequest_t      *agIORequest,
                       bit32                agIOStatus,
                       bit32                agIOInfoLen,
                       void                 *agParam,
                       bit32                agOtherInfo
                       )
{
  tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
  tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
  bit32                  intContext = osData->IntContext;
  tdIORequestBody_t      *tdIORequestBody;
  TI_DBG2(("itdssSSPExtIUZeroLenHandler: start\n"));

  tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;

  ostiInitiatorIOCompleted (
                            tiRoot,
                            tdIORequestBody->tiIORequest,
                            tiIOFailed,
                            tiDetailOtherError,
                            agNULL,
                            intContext
                            );

  return;
}

/*****************************************************************************
*! \brief itdssXferErrorUnexpectedPhaseHandler
*
*  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
*            layer with agIOStatus = OSSA_IO_XFER_ERROR_UNEXPECTED_PHASE
*
*  \param  agRoot:            pointer to port instance
*  \param  agIORequest:       pointer to I/O request
*  \param  agIOStatus:        I/O status given by LL layer
*  \param  agIOInfoLen:       lenth of complete SAS RESP frame
*  \param  agParam            A Handle used to refer to the response frame or handle
*                             of abort request
*  \param  agOtherInfo        Residual count
*  \return: None
*
*
*****************************************************************************/
osGLOBAL void
itdssXferErrorUnexpectedPhaseHandler(
                       agsaRoot_t           *agRoot,
                       agsaIORequest_t      *agIORequest,
                       bit32                agIOStatus,
                       bit32                agIOInfoLen,
                       void                 *agParam,
                       bit32                agOtherInfo
                       )
{
  tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
  tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
  bit32                  intContext = osData->IntContext;
  tdIORequestBody_t      *tdIORequestBody;
  TI_DBG2(("itdssXferErrorUnexpectedPhaseHandler: start\n"));

  tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;

  ostiInitiatorIOCompleted (
                            tiRoot,
                            tdIORequestBody->tiIORequest,
                            tiIOFailed,
                            tiDetailOtherError,
                            agNULL,
                            intContext
                            );

  return;
}

#ifdef REMOVED
/*****************************************************************************
*! \brief itdssIOUnderFlowWithChkConditionHandler
*
*  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
*            layer with agIOStatus = OSSA_IO_UNDERFLOW_WITH_CHK_COND
*
*  \param  agRoot:            pointer to port instance
*  \param  agIORequest:       pointer to I/O request
*  \param  agIOStatus:        I/O status given by LL layer
*  \param  agIOInfoLen:       lenth of complete SAS RESP frame
*  \param  agParam            A Handle used to refer to the response frame or handle
*                             of abort request
*  \return: None
*
*
*****************************************************************************/
/*
  How to report SCSI_STAT_CHECK_CONDITION and tiIOUnderRun simultaneoulsy???
  ostiInitiatorIOCompleted(
                             tiRoot,
                             tdIORequestBody->tiIORequest,
                             tiIOSuccess,
                             SCSI_STAT_CHECK_CONDITION,
                             &senseData,
                             agTRUE
                             );

                 vs

  ostiInitiatorIOCompleted (
                            tiRoot,
                            tdIORequestBody->tiIORequest,
                            tiIOUnderRun,
                            agIOInfoLen,
                            agNULL,
                            intContext
                            );

  For now, SCSI_STAT_CHECK_CONDITION is reported until TISA changes (as of 1/6/09)
  In other words, this handler is the practically same as itdssIOSuccessHandler()
*/
osGLOBAL void
itdssIOUnderFlowWithChkConditionHandler(
                        agsaRoot_t              *agRoot,
                        agsaIORequest_t         *agIORequest,
                        bit32                   agIOStatus,
                        bit32                   agIOInfoLen,
                        void                    *agParam
                        )
{
  tdsaRootOsData_t          *osData = (tdsaRootOsData_t *)agRoot->osData;
  tiRoot_t                  *tiRoot = (tiRoot_t *)osData->tiRoot;
  tdIORequestBody_t         *tdIORequestBody;
  agsaSSPResponseInfoUnit_t agSSPRespIU;
  tiSenseData_t             senseData;
  bit8                      senseDataPayload[256];
  bit8                      respData[128];
  bit32                     scsi_status;
  bit32                     senseLen;
  bit32                     respLen;
  bit32                     data_status;
  bit32                     i;
  tiDeviceHandle_t          *tiDeviceHandle = agNULL;
  tdsaDeviceData_t          *oneDeviceData = agNULL;

  TI_DBG2(("itdssIOUnderFlowWithChkConditionHandler: start\n"));
  TI_DBG2(("itdssIOUnderFlowWithChkConditionHandler: agIOInfoLen 0x%x\n", agIOInfoLen));

  tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;

  tdIORequestBody->ioCompleted = agTRUE;
  tdIORequestBody->ioStarted = agFALSE;

  /*
    agIOInfoLen must be >= sizeof(agsaSSPResponseInfoUnit_t), which is minimum
    date length
  */
  if (agIOInfoLen < sizeof(agsaSSPResponseInfoUnit_t))
  {
    TI_DBG1(("itdssIOUnderFlowWithChkConditionHandler: First agIOInfoLen does not match!!!\n"));
    TI_DBG1(("itdssIOUnderFlowWithChkConditionHandler: First agIOInfoLen 0x%x IU 0x%x\n", agIOInfoLen, (unsigned int)sizeof(agsaSSPResponseInfoUnit_t)));
    ostiInitiatorIOCompleted(
                             tiRoot,
                             tdIORequestBody->tiIORequest, /* tiIORequest */
                             tiIOFailed,
                             tiDetailOtherError,
                             agNULL,
                             agTRUE /* intContext; is not being used */
                             );
    return;
  }
  /* reads agsaSSPResponseInfoUnit_t */
  saFrameReadBlock(agRoot, agParam, 0, &agSSPRespIU, sizeof(agsaSSPResponseInfoUnit_t));

  data_status = SA_SSPRESP_GET_DATAPRES(&agSSPRespIU);
  scsi_status = agSSPRespIU.status;
  /* endianess is invovled here */
  senseLen = SA_SSPRESP_GET_SENSEDATALEN(&agSSPRespIU);
  respLen = SA_SSPRESP_GET_RESPONSEDATALEN(&agSSPRespIU);

  TI_DBG2(("itdssIOUnderFlowWithChkConditionHandler: dataPres=%x\n", data_status));
  TI_DBG2(("itdssIOUnderFlowWithChkConditionHandler: scsi status=0x%x, senselen=0x%x resplen 0x%x\n", scsi_status, senseLen, respLen));

  /*
    sanity check: do not go beyond of agIOInfoLen. if happens, return error
    agIOInfoLen >= sizeof(agsaSSPResponseInfoUnit_t) + senseLen + respLen -> OK
    because frame must be divisible by 4, so there can be extra padding
    agIOInfoLen < sizeof(agsaSSPResponseInfoUnit_t) + senseLen + respLen -> NOT OK
  */
  if (agIOInfoLen < sizeof(agsaSSPResponseInfoUnit_t) + senseLen + respLen)
  {
    TI_DBG1(("itdssIOUnderFlowWithChkConditionHandler: Second agIOInfoLen does not match!!!\n"));
    TI_DBG1(("itdssIOUnderFlowWithChkConditionHandler: Second agIOInfoLen 0x%x IU 0x%x senselen 0x%x resplen 0x%x\n", agIOInfoLen, (unsigned int)sizeof(agsaSSPResponseInfoUnit_t), senseLen, respLen));

    ostiInitiatorIOCompleted(
                             tiRoot,
                             tdIORequestBody->tiIORequest, /* tiIORequest */
                             tiIOFailed,
                             tiDetailOtherError,
                             agNULL,
                             agTRUE /* intContext; is not being used */
                             );
    return;
  }

  /* reads response data */
  saFrameReadBlock(agRoot, agParam,
                   sizeof(agsaSSPResponseInfoUnit_t),
                   respData, respLen);
  /* reads sense data */
  saFrameReadBlock(agRoot, agParam,
                   sizeof(agsaSSPResponseInfoUnit_t)
                   + respLen,
                   senseDataPayload, senseLen);

  if (data_status == 0)
  {
    /* NO_DATA */
    TI_DBG2(("itdssIOUnderFlowWithChkConditionHandler: no data\n"));

    ostiInitiatorIOCompleted(
                             tiRoot,
                             tdIORequestBody->tiIORequest, /* tiIORequest */
                             tiIOSuccess,
                             scsi_status,
                             agNULL,
                             agTRUE /* intContext; is not being used */
                             );

    return;
  }

  if (data_status == 1)
  {
    /* RESPONSE_DATA */
    TI_DBG2(("itdssIOUnderFlowWithChkConditionHandler: response data \n"));

    ostiInitiatorIOCompleted(
                             tiRoot,
                             tdIORequestBody->tiIORequest, /* tiIORequest */
                             tiIOSuccess,
                             0,
                             agNULL,
                             agTRUE /* intContext; is not being used */
                             );
    return;
  }

  if (data_status == 2)
  {
    /* SENSE_DATA */
    TI_DBG2(("itdssIOUnderFlowWithChkConditionHandler: sense data \n"));

    senseData.senseData = &senseDataPayload;
    senseData.senseLen = MIN(256, senseLen);
    /* debugging */
    tdhexdump("ResponseIU I", (bit8 *)&agSSPRespIU, sizeof(agsaSSPResponseInfoUnit_t));

    tdhexdump("sense data I", (bit8 *)senseDataPayload, senseLen);
    tdhexdump("sense data II", (bit8 *)senseData.senseData, senseData.senseLen);

    if (senseDataPayload[2] == SCSI_SENSE_KEY_RECOVERED_ERROR)
    {
      Initiator->SenseKeyCounter.SoftError ++;
    }
    else if (senseDataPayload[2] == SCSI_SENSE_KEY_NOT_READY)
    {
      Initiator->SenseKeyCounter.MediumNotReady++;
    }
    else if (senseDataPayload[2] == SCSI_SENSE_KEY_MEDIUM_ERROR)
    {
      Initiator->SenseKeyCounter.MediumError++;
    }
    else if (senseDataPayload[2] == SCSI_SENSE_KEY_HARDWARE_ERROR)
    {
      Initiator->SenseKeyCounter.HardwareError++;
    }
    else if (senseDataPayload[2] == SCSI_SENSE_KEY_ILLEGAL_REQUEST)
    {
      Initiator->SenseKeyCounter.IllegalRequest++;
    }
    else if (senseDataPayload[2] == SCSI_SENSE_KEY_UNIT_ATTENTION)
    {
      Initiator->SenseKeyCounter.UnitAttention++;
    }
    else if (senseDataPayload[2] == SCSI_SENSE_KEY_ABORTED_COMMAND)
    {
      Initiator->SenseKeyCounter.AbortCommand++;
    }
    else
    {
      Initiator->SenseKeyCounter.OtherKeyType++;
    }

    /* when ASQ and ASCQ 0x04 0x11, does saLocalPhyControl for notify spinup */
    if ((senseDataPayload[12] == 0x04 && senseDataPayload[13] == 0x11))
    {
      TI_DBG2(("itdssIOUnderFlowWithChkConditionHandler: sending notfify spinup\n"));
      tiDeviceHandle = tdIORequestBody->tiDevHandle;
      oneDeviceData = (tdsaDeviceData_t *)tiDeviceHandle->tdData;
      if (oneDeviceData->directlyAttached == agTRUE)
      {
        for (i=0;i<TD_MAX_NUM_NOTIFY_SPINUP;i++)
        {
          saLocalPhyControl(agRoot, agNULL, 0, oneDeviceData->phyID, AGSA_PHY_NOTIFY_ENABLE_SPINUP, agNULL);
        }
      }
    }
    ostiInitiatorIOCompleted(
                             tiRoot,
                             /* tiIORequest */
                             tdIORequestBody->tiIORequest,
                             tiIOSuccess,
                             scsi_status,
                             &senseData,
                             agTRUE /* intContext; is not being used */
                             );
    return;
  }
  if (data_status == 3)
  {
    /* RESERVED */
    TI_DBG1(("itdssIOUnderFlowWithChkConditionHandler: reserved wrong!!!\n"));
    ostiInitiatorIOCompleted(
                             tiRoot,
                             tdIORequestBody->tiIORequest, /* tiIORequest */
                             tiIOFailed,
                             scsi_status,
                             agNULL,
                             agTRUE /* intContext; is not being used */
                             );
    return;
  }


  return;
}
#endif

/*****************************************************************************
*! \brief itdssXferOpenRetryBackoffThresholdReachedHandler
*
*  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
*            layer with agIOStatus =
*            OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_RETRY_BACKOFF_THRESHOLD_REACHED
*
*  \param  agRoot:            pointer to port instance
*  \param  agIORequest:       pointer to I/O request
*  \param  agIOStatus:        I/O status given by LL layer
*  \param  agIOInfoLen:       lenth of complete SAS RESP frame
*  \param  agParam            A Handle used to refer to the response frame or handle
*                             of abort request
*  \param  agOtherInfo        Residual count
*  \return: None
*
*
*****************************************************************************/
osGLOBAL void
itdssXferOpenRetryBackoffThresholdReachedHandler(
                                                 agsaRoot_t           *agRoot,
                                                 agsaIORequest_t      *agIORequest,
                                                 bit32                agIOStatus,
                                                 bit32                agIOInfoLen,
                                                 void                 *agParam,
                                                 bit32                agOtherInfo
                                                )
{
  tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
  tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
  bit32                  intContext = osData->IntContext;
  tdIORequestBody_t      *tdIORequestBody;
  TI_DBG2(("itdssXferOpenRetryBackoffThresholdReachedHandler: start\n"));

  tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;

  ostiInitiatorIOCompleted (
                            tiRoot,
                            tdIORequestBody->tiIORequest,
                            tiIOFailed,
                            tiDetailOtherError,
                            agNULL,
                            intContext
                            );

  return;
}

/*****************************************************************************
*! \brief itdssOpenCnxErrorItNexusLossOpenTmoHandler
*
*  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
*            layer with agIOStatus = OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_TMO
*
*  \param  agRoot:            pointer to port instance
*  \param  agIORequest:       pointer to I/O request
*  \param  agIOStatus:        I/O status given by LL layer
*  \param  agIOInfoLen:       lenth of complete SAS RESP frame
*  \param  agParam            A Handle used to refer to the response frame or handle
*                             of abort request
*  \param  agOtherInfo        Residual count
*  \return: None
*
*
*****************************************************************************/
osGLOBAL void
itdssOpenCnxErrorItNexusLossOpenTmoHandler(
                                           agsaRoot_t           *agRoot,
                                           agsaIORequest_t      *agIORequest,
                                           bit32                agIOStatus,
                                           bit32                agIOInfoLen,
                                           void                 *agParam,
                                           bit32                agOtherInfo
                                          )
{
  tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
  tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
  bit32                  intContext = osData->IntContext;
  tdIORequestBody_t      *tdIORequestBody;
  TI_DBG2(("itdssOpenCnxErrorItNexusLossOpenTmoHandler: start\n"));

  tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;

  ostiInitiatorIOCompleted (
                            tiRoot,
                            tdIORequestBody->tiIORequest,
                            tiIOFailed,
                            tiDetailOtherError,
                            agNULL,
                            intContext
                            );

  return;
}

/*****************************************************************************
*! \brief itdssOpenCnxErrorItNexusLossNoDestHandler
*
*  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
*            layer with agIOStatus = OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_NO_DEST
*
*  \param  agRoot:            pointer to port instance
*  \param  agIORequest:       pointer to I/O request
*  \param  agIOStatus:        I/O status given by LL layer
*  \param  agIOInfoLen:       lenth of complete SAS RESP frame
*  \param  agParam            A Handle used to refer to the response frame or handle
*                             of abort request
*  \param  agOtherInfo        Residual count
*  \return: None
*
*
*****************************************************************************/
osGLOBAL void
itdssOpenCnxErrorItNexusLossNoDestHandler(
                                          agsaRoot_t           *agRoot,
                                          agsaIORequest_t      *agIORequest,
                                          bit32                agIOStatus,
                                          bit32                agIOInfoLen,
                                          void                 *agParam,
                                          bit32                agOtherInfo
                                         )
{
  tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
  tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
  bit32                  intContext = osData->IntContext;
  tdIORequestBody_t      *tdIORequestBody;
  TI_DBG2(("itdssOpenCnxErrorItNexusLossNoDestHandler: start\n"));

  tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;

  ostiInitiatorIOCompleted (
                            tiRoot,
                            tdIORequestBody->tiIORequest,
                            tiIOFailed,
                            tiDetailOtherError,
                            agNULL,
                            intContext
                            );

  return;
}

/*****************************************************************************
*! \brief itdssOpenCnxErrorItNexusLossOpenCollideHandler
*
*  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
*            layer with agIOStatus = OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_COLLIDE
*
*  \param  agRoot:            pointer to port instance
*  \param  agIORequest:       pointer to I/O request
*  \param  agIOStatus:        I/O status given by LL layer
*  \param  agIOInfoLen:       lenth of complete SAS RESP frame
*  \param  agParam            A Handle used to refer to the response frame or handle
*                             of abort request
*  \param  agOtherInfo        Residual count
*  \return: None
*
*
*****************************************************************************/
osGLOBAL void
itdssOpenCnxErrorItNexusLossOpenCollideHandler(
                                               agsaRoot_t           *agRoot,
                                               agsaIORequest_t      *agIORequest,
                                               bit32                agIOStatus,
                                               bit32                agIOInfoLen,
                                               void                 *agParam,
                                               bit32                agOtherInfo
                                              )
{
  tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
  tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
  bit32                  intContext = osData->IntContext;
  tdIORequestBody_t      *tdIORequestBody;
  TI_DBG2(("itdssOpenCnxErrorItNexusLossOpenCollideHandler: start\n"));

  tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;

  ostiInitiatorIOCompleted (
                            tiRoot,
                            tdIORequestBody->tiIORequest,
                            tiIOFailed,
                            tiDetailOtherError,
                            agNULL,
                            intContext
                            );

  return;
}

/*****************************************************************************
*! \brief itdssOpenCnxErrorItNexusLossOpenPathwayBlockedHandler
*
*  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
*            layer with agIOStatus = OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_PATHWAY_BLOCKED
*
*  \param  agRoot:            pointer to port instance
*  \param  agIORequest:       pointer to I/O request
*  \param  agIOStatus:        I/O status given by LL layer
*  \param  agIOInfoLen:       lenth of complete SAS RESP frame
*  \param  agParam            A Handle used to refer to the response frame or handle
*                             of abort request
*  \param  agOtherInfo        Residual count
*  \return: None
*
*
*****************************************************************************/
osGLOBAL void
itdssOpenCnxErrorItNexusLossOpenPathwayBlockedHandler(
                                                      agsaRoot_t           *agRoot,
                                                      agsaIORequest_t      *agIORequest,
                                                      bit32                agIOStatus,
                                                      bit32                agIOInfoLen,
                                                      void                 *agParam,
                                                      bit32                agOtherInfo
                                                     )
{
  tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
  tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
  bit32                  intContext = osData->IntContext;
  tdIORequestBody_t      *tdIORequestBody;
  TI_DBG2(("itdssOpenCnxErrorItNexusLossOpenPathwayBlockedHandler: start\n"));

  tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;

  ostiInitiatorIOCompleted (
                            tiRoot,
                            tdIORequestBody->tiIORequest,
                            tiIOFailed,
                            tiDetailOtherError,
                            agNULL,
                            intContext
                            );

  return;
}

/*****************************************************************************
*! \brief itdssEncryptionHandler
*
*  Purpose:  This function processes I/Os completed and returned by SAS lower
*            layer with any encryption specific agIOStatus.
*
*  \param  agRoot:            pointer to port instance
*  \param  agIORequest:       pointer to I/O request
*  \param  agIOStatus:        I/O status given by LL layer
*  \param  agIOInfoLen:       lenth of complete SAS RESP frame
*  \param  agParam            A Handle used to refer to the response frame or handle
*                             of abort request
*  \return: None
*
*
*****************************************************************************/
osGLOBAL void
itdssEncryptionHandler (
                       agsaRoot_t              *agRoot,
                       agsaIORequest_t         *agIORequest,
                       bit32                   agIOStatus,
                       bit32                   agIOInfoLen,
                       void                    *agParam,
                       bit32                   agOtherInfo
                       )
{
  tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
  tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
  bit32                  intContext = osData->IntContext;
  bit32                  errorDetail = tiDetailOtherError;
  tdIORequestBody_t      *tdIORequestBody;
  TI_DBG1(("itdssEncryptionHandler: start\n"));
  TI_DBG1(("itdssEncryptionHandler: agIOStatus 0x%x\n", agIOStatus));

  tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;

  switch (agIOStatus)
  {
  case OSSA_IO_XFR_ERROR_DEK_KEY_CACHE_MISS:
      TI_DBG1(("itdssEncryptionHandler: OSSA_IO_XFR_ERROR_DEK_KEY_CACHE_MISS\n"));
      errorDetail = tiDetailDekKeyCacheMiss;
      break;
  case OSSA_IO_XFR_ERROR_CIPHER_MODE_INVALID:
      TI_DBG1(("itdssEncryptionHandler: OSSA_IO_XFR_ERROR_CIPHER_MODE_INVALID\n"));
      errorDetail = tiDetailCipherModeInvalid;
      break;
  case OSSA_IO_XFR_ERROR_DEK_IV_MISMATCH:
      TI_DBG1(("itdssEncryptionHandler: OSSA_IO_XFR_ERROR_DEK_IV_MISMATCH\n"));
      errorDetail = tiDetailDekIVMismatch;
      break;
  case OSSA_IO_XFR_ERROR_DEK_RAM_INTERFACE_ERROR:
      TI_DBG1(("itdssEncryptionHandler: OSSA_IO_XFR_ERROR_DEK_RAM_INTERFACE_ERROR\n"));
      errorDetail = tiDetailDekRamInterfaceError;
      break;
  case OSSA_IO_XFR_ERROR_DEK_INDEX_OUT_OF_BOUNDS:
      TI_DBG1(("itdssEncryptionHandler: OSSA_IO_XFR_ERROR_DEK_INDEX_OUT_OF_BOUNDS\n"));
      errorDetail = tiDetailDekIndexOutofBounds;
      break;
  case OSSA_IO_XFR_ERROR_DEK_ILLEGAL_TABLE:
      TI_DBG1(("itdssEncryptionHandler: OSSA_IO_XFR_ERROR_DEK_ILLEGAL_TABLE\n"));
      errorDetail = tiDetailOtherError;
      break;
  default:
      TI_DBG1(("itdssEncryptionHandler: other error!!! 0x%x\n", agIOStatus));
      errorDetail = tiDetailOtherError;
      break;
  }

  ostiInitiatorIOCompleted (
                            tiRoot,
                            tdIORequestBody->tiIORequest,
                            tiIOEncryptError,
                            errorDetail,
                            agNULL,
                            intContext
                            );
  return;
}

/*****************************************************************************
*! \brief itdssDifHandler
*
*  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
*            layer with any DIF specific agIOStatus
*
*  \param  agRoot:            pointer to port instance
*  \param  agIORequest:       pointer to I/O request
*  \param  agIOStatus:        I/O status given by LL layer
*  \param  agIOInfoLen:       lenth of complete SAS RESP frame
*  \param  agParam            A Handle used to refer to the response frame or handle
*                             of abort request
*  \param  agOtherInfo        Residual count
*  \return: None
*
*
*****************************************************************************/
osGLOBAL void
itdssDifHandler(
                agsaRoot_t           *agRoot,
                agsaIORequest_t      *agIORequest,
                bit32                agIOStatus,
                bit32                agIOInfoLen,
                void                 *agParam,
                bit32                agOtherInfo
               )
{
  tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
  tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
  bit32                  intContext = osData->IntContext;
  bit32                  errorDetail = tiDetailOtherError;
  tdIORequestBody_t      *tdIORequestBody;
#ifdef  TD_DEBUG_ENABLE
  agsaDifDetails_t       *DifDetail;
#endif

  TI_DBG1(("itdssDifHandler: start\n"));
  TI_DBG1(("itdssDifHandler: agIOStatus 0x%x\n", agIOStatus));
  tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
#ifdef  TD_DEBUG_ENABLE
  DifDetail = (agsaDifDetails_t *)agParam;
#endif
  switch (agIOStatus)
  {
  case OSSA_IO_XFR_ERROR_DIF_MISMATCH:
      errorDetail = tiDetailDifMismatch;
      TI_DBG1(("itdssDifHandler: OSSA_IO_XFR_ERROR_DIF_MISMATCH\n"));
      break;
  case OSSA_IO_XFR_ERROR_DIF_APPLICATION_TAG_MISMATCH:
      errorDetail = tiDetailDifAppTagMismatch;
      TI_DBG1(("itdssDifHandler: OSSA_IO_XFR_ERROR_DIF_APPLICATION_TAG_MISMATCH\n"));
      break;
  case OSSA_IO_XFR_ERROR_DIF_REFERENCE_TAG_MISMATCH:
      errorDetail = tiDetailDifRefTagMismatch;
      TI_DBG1(("itdssDifHandler: OSSA_IO_XFR_ERROR_DIF_REFERENCE_TAG_MISMATCH\n"));
      break;
  case OSSA_IO_XFR_ERROR_DIF_CRC_MISMATCH:
      errorDetail = tiDetailDifCrcMismatch;
      TI_DBG1(("itdssDifHandler: OSSA_IO_XFR_ERROR_DIF_CRC_MISMATCH\n"));
      break;
  default:
      errorDetail = tiDetailOtherError;
      TI_DBG1(("itdssDifHandler: other error!!! 0x%x\n", agIOStatus));
      break;
  }
  TI_DBG1(("itdssDifHandler: DIF detail UpperLBA 0x%08x LowerLBA 0x%08x\n", DifDetail->UpperLBA, DifDetail->LowerLBA));
  ostiInitiatorIOCompleted (
                            tiRoot,
                            tdIORequestBody->tiIORequest,
                            tiIODifError,
                            errorDetail,
                            agNULL,
                            intContext
                            );
  return;
}

/*****************************************************************************
*! \brief itdssIOResourceUnavailableHandler
*
*  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
*            layer with agIOStatus = OSSA_MPI_ERR_IO_RESOURCE_UNAVAILABLE
*
*  \param  agRoot:            pointer to port instance
*  \param  agIORequest:       pointer to I/O request
*  \param  agIOStatus:        I/O status given by LL layer
*  \param  agIOInfoLen:       lenth of complete SAS RESP frame
*  \param  agParam            A Handle used to refer to the response frame or handle
*                             of abort request
*  \param  agOtherInfo        Residual count
*  \return: None
*
*
*****************************************************************************/
osGLOBAL void
itdssIOResourceUnavailableHandler(
                                  agsaRoot_t              *agRoot,
                                  agsaIORequest_t         *agIORequest,
                                  bit32                   agIOStatus,
                                  bit32                   agIOInfoLen,
                                  void                    *agParam,
                                  bit32                   agOtherInfo
                                 )
{
  tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
  tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
  bit32                  intContext = osData->IntContext;
  tdIORequestBody_t      *tdIORequestBody;
  TI_DBG2(("itdssIOResourceUnavailableHandler: start\n"));
  TI_DBG2(("itdssIOResourceUnavailableHandler: agIOStatus 0x%x\n", agIOStatus));

  tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;

  ostiInitiatorIOCompleted (
                            tiRoot,
                            tdIORequestBody->tiIORequest,
                            tiIOFailed,
                            tiDetailBusy,
                            agNULL,
                            intContext
                            );
  return;
}
/*****************************************************************************
*! \brief itdssIORQEBusyFullHandler
*
*  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
*            layer with agIOStatus = OSSA_MPI_IO_RQE_BUSY_FULL
*
*  \param  agRoot:            pointer to port instance
*  \param  agIORequest:       pointer to I/O request
*  \param  agIOStatus:        I/O status given by LL layer
*  \param  agIOInfoLen:       lenth of complete SAS RESP frame
*  \param  agParam            A Handle used to refer to the response frame or handle
*                             of abort request
*  \param  agOtherInfo        Residual count
*  \return: None
*
*
*****************************************************************************/
osGLOBAL void
itdssIORQEBusyFullHandler(
                                  agsaRoot_t              *agRoot,
                                  agsaIORequest_t         *agIORequest,
                                  bit32                   agIOStatus,
                                  bit32                   agIOInfoLen,
                                  void                    *agParam,
                                  bit32                   agOtherInfo
                                 )
{
  tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
  tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
  bit32                  intContext = osData->IntContext;
  tdIORequestBody_t      *tdIORequestBody;
  TI_DBG2(("itdssIORQEBusyFullHandler: start\n"));
  TI_DBG2(("itdssIORQEBusyFullHandler: agIOStatus 0x%x\n", agIOStatus));

  tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;

  ostiInitiatorIOCompleted (
                            tiRoot,
                            tdIORequestBody->tiIORequest,
                            tiIOFailed,
                            tiDetailBusy,
                            agNULL,
                            intContext
                            );
  return;
}

/*****************************************************************************
*! \brief itdssXferErrorInvalidSSPRspFrameHandler
*
*  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
*            layer with agIOStatus = OSSA_IO_XFR_ERROR_INVALID_SSP_RSP_FRAME
*
*  \param  agRoot:            pointer to port instance
*  \param  agIORequest:       pointer to I/O request
*  \param  agIOStatus:        I/O status given by LL layer
*  \param  agIOInfoLen:       lenth of complete SAS RESP frame
*  \param  agParam            A Handle used to refer to the response frame or handle
*                             of abort request
*  \param  agOtherInfo        Residual count
*  \return: None
*
*
*****************************************************************************/
osGLOBAL void
itdssXferErrorInvalidSSPRspFrameHandler(
                                  agsaRoot_t              *agRoot,
                                  agsaIORequest_t         *agIORequest,
                                  bit32                   agIOStatus,
                                  bit32                   agIOInfoLen,
                                  void                    *agParam,
                                  bit32                   agOtherInfo
                                 )
{
  tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
  tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
  bit32                  intContext = osData->IntContext;
  tdIORequestBody_t      *tdIORequestBody;
  TI_DBG2(("itdssXferErrorInvalidSSPRspFrameHandler: start\n"));
  TI_DBG2(("itdssXferErrorInvalidSSPRspFrameHandler: agIOStatus 0x%x\n", agIOStatus));

  tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;

  ostiInitiatorIOCompleted (
                            tiRoot,
                            tdIORequestBody->tiIORequest,
                            tiIOFailed,
                            tiDetailOtherError,
                            agNULL,
                            intContext
                            );
  return;
}

/*****************************************************************************
*! \brief itdssXferErrorEOBDataOverrunHandler
*
*  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
*            layer with agIOStatus = OSSA_IO_XFER_ERR_EOB_DATA_OVERRUN
*
*  \param  agRoot:            pointer to port instance
*  \param  agIORequest:       pointer to I/O request
*  \param  agIOStatus:        I/O status given by LL layer
*  \param  agIOInfoLen:       lenth of complete SAS RESP frame
*  \param  agParam            A Handle used to refer to the response frame or handle
*                             of abort request
*  \param  agOtherInfo        Residual count
*  \return: None
*
*
*****************************************************************************/
osGLOBAL void
itdssXferErrorEOBDataOverrunHandler(
                                  agsaRoot_t              *agRoot,
                                  agsaIORequest_t         *agIORequest,
                                  bit32                   agIOStatus,
                                  bit32                   agIOInfoLen,
                                  void                    *agParam,
                                  bit32                   agOtherInfo
                                 )
{
  tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
  tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
  bit32                  intContext = osData->IntContext;
  tdIORequestBody_t      *tdIORequestBody;
  TI_DBG2(("itdssXferErrorEOBDataOverrunHandler: start\n"));
  TI_DBG2(("itdssXferErrorEOBDataOverrunHandler: agIOStatus 0x%x\n", agIOStatus));

  tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;

  ostiInitiatorIOCompleted (
                            tiRoot,
                            tdIORequestBody->tiIORequest,
                            tiIOFailed,
                            tiDetailOtherError,
                            agNULL,
                            intContext
                            );
  return;
}

/*****************************************************************************
*! \brief itdssOpenCnxErrorOpenPreemptedHandler
*
*  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
*            layer with agIOStatus = OSSA_IO_OPEN_CNX_ERROR_OPEN_PREEMPTED
*
*  \param  agRoot:            pointer to port instance
*  \param  agIORequest:       pointer to I/O request
*  \param  agIOStatus:        I/O status given by LL layer
*  \param  agIOInfoLen:       lenth of complete SAS RESP frame
*  \param  agParam            A Handle used to refer to the response frame or handle
*                             of abort request
*  \param  agOtherInfo        Residual count
*  \return: None
*
*
*****************************************************************************/
osGLOBAL void
itdssOpenCnxErrorOpenPreemptedHandler(
                                  agsaRoot_t              *agRoot,
                                  agsaIORequest_t         *agIORequest,
                                  bit32                   agIOStatus,
                                  bit32                   agIOInfoLen,
                                  void                    *agParam,
                                  bit32                   agOtherInfo
                                 )
{
  tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
  tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
  bit32                  intContext = osData->IntContext;
  tdIORequestBody_t      *tdIORequestBody;
  TI_DBG2(("itdssOpenCnxErrorOpenPreemptedHandler: start\n"));
  TI_DBG2(("itdssOpenCnxErrorOpenPreemptedHandler: agIOStatus 0x%x\n", agIOStatus));

  tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;

  ostiInitiatorIOCompleted (
                            tiRoot,
                            tdIORequestBody->tiIORequest,
                            tiIOFailed,
                            tiDetailOtherError,
                            agNULL,
                            intContext
                            );
  return;
}

/* default */
/*****************************************************************************
*! \brief itdssIODefaultHandler
*
*  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
*            layer with agIOStatus = unspecified
*
*  \param  agRoot:            pointer to port instance
*  \param  agIORequest:       pointer to I/O request
*  \param  agIOStatus:        I/O status given by LL layer
*  \param  agIOInfoLen:       lenth of complete SAS RESP frame
*  \param  agParam            A Handle used to refer to the response frame or handle
*                             of abort request
*  \param  agOtherInfo        Residual count
*  \return: None
*
*
*****************************************************************************/
osGLOBAL void
itdssIODefaultHandler (
                       agsaRoot_t              *agRoot,
                       agsaIORequest_t         *agIORequest,
                       bit32                   agIOStatus,
                       bit32                   agIOInfoLen,
                       void                    *agParam,
                       bit32                   agOtherInfo
                       )
{
  tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
  tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
  bit32                  intContext = osData->IntContext;
  tdIORequestBody_t      *tdIORequestBody;
  TI_DBG2(("itdssIODefaultHandler: start\n"));
  TI_DBG2(("itdssIODefaultHandler: agIOStatus 0x%x\n", agIOStatus));

  tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;

  ostiInitiatorIOCompleted (
                            tiRoot,
                            tdIORequestBody->tiIORequest,
                            tiIOFailed,
                            tiDetailOtherError,
                            agNULL,
                            intContext
                            );
  return;
}

/*****************************************************************************
*! \brief itdssIOForDebugging1Completed
*
*  Purpose:  This function is only for debugging. This function should NOT be
*            called.
*
*  \param  agRoot:            pointer to port instance
*  \param  agIORequest:       pointer to I/O request
*  \param  agIOStatus:        I/O status given by LL layer
*  \param  agIOInfoLen:       lenth of complete SAS RESP frame
*  \param  agParam            A Handle used to refer to the response frame or handle
*                             of abort request
*  \param  agOtherInfo        Residual count
*  \return: None
*
*
*****************************************************************************/
osGLOBAL void
itdssIOForDebugging1Completed(
                 agsaRoot_t             *agRoot,
                 agsaIORequest_t        *agIORequest,
                 bit32                  agIOStatus,
                 bit32                  agIOInfoLen,
                 void                   *agParam,
                 bit32                  agOtherInfo
                 )
{
  TI_DBG1(("itdssIOForDebugging1Completed: start, error!!! can't be called. \n"));
}

/*****************************************************************************
*! \brief itdssIOForDebugging2Completed
*
*  Purpose:  This function is only for debugging. This function should NOT be
*            called.
*
*  \param  agRoot:            pointer to port instance
*  \param  agIORequest:       pointer to I/O request
*  \param  agIOStatus:        I/O status given by LL layer
*  \param  agIOInfoLen:       lenth of complete SAS RESP frame
*  \param  agParam            A Handle used to refer to the response frame or handle
*                             of abort request
*  \param  agOtherInfo        Residual count
*  \return: None
*
*
*****************************************************************************/
osGLOBAL void
itdssIOForDebugging2Completed(
                 agsaRoot_t             *agRoot,
                 agsaIORequest_t        *agIORequest,
                 bit32                  agIOStatus,
                 bit32                  agIOInfoLen,
                 void                   *agParam,
                 bit32                  agOtherInfo
                 )
{
  TI_DBG1(("itdssIOForDebugging2Completed: start, error!!! can't be called.  \n"));
}

/*****************************************************************************
*! \brief itdssIOForDebugging3Completed
*
*  Purpose:  This function is only for debugging. This function should NOT be
*            called.
*
*  \param  agRoot:            pointer to port instance
*  \param  agIORequest:       pointer to I/O request
*  \param  agIOStatus:        I/O status given by LL layer
*  \param  agIOInfoLen:       lenth of complete SAS RESP frame
*  \param  agParam            A Handle used to refer to the response frame or handle
*                             of abort request
*  \param  agOtherInfo        Residual count
*  \return: None
*
*
*****************************************************************************/
osGLOBAL void
itdssIOForDebugging3Completed(
                 agsaRoot_t             *agRoot,
                 agsaIORequest_t        *agIORequest,
                 bit32                  agIOStatus,
                 bit32                  agIOInfoLen,
                 void                   *agParam,
                 bit32                  agOtherInfo
                 )
{
  TI_DBG1(("itdssIOForDebugging3Completed: start, error!!! can't be called.  \n"));
}