sys/dev/pms/RefTisa/tisa/sassata/sas/ini/itdcb.c

   1 /*******************************************************************************
   2 **
   3 *Copyright (c) 2014 PMC-Sierra, Inc.  All rights reserved.
   4 *
   5 *Redistribution and use in source and binary forms, with or without modification, are permitted provided
   6 *that the following conditions are met:
   7 *1. Redistributions of source code must retain the above copyright notice, this list of conditions and the
   8 *following disclaimer.
   9 *2. Redistributions in binary form must reproduce the above copyright notice,
  10 *this list of conditions and the following disclaimer in the documentation and/or other materials provided
  11 *with the distribution.
  12 *
  13 *THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED
  14 *WARRANTIES,INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  15 *FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  16 *FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  17 *NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  18 *BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  19 *LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  20 *SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE
  21 **
  22 ********************************************************************************/
  23 /*****************************************************************************/
  24 /** \file
  25  *
  26  * This file contains initiator CB functions
  27  *
  28  */
  29 #include <sys/cdefs.h>
  30 __FBSDID("$FreeBSD$");
  31 #include <dev/pms/config.h>
  32
  33 #include <dev/pms/freebsd/driver/common/osenv.h>
  34 #include <dev/pms/freebsd/driver/common/ostypes.h>
  35 #include <dev/pms/freebsd/driver/common/osdebug.h>
  36
  37 #include <dev/pms/RefTisa/sallsdk/api/sa.h>
  38 #include <dev/pms/RefTisa/sallsdk/api/saapi.h>
  39 #include <dev/pms/RefTisa/sallsdk/api/saosapi.h>
  40
  41 #include <dev/pms/RefTisa/tisa/api/titypes.h>
  42 #include <dev/pms/RefTisa/tisa/api/ostiapi.h>
  43 #include <dev/pms/RefTisa/tisa/api/tiapi.h>
  44 #include <dev/pms/RefTisa/tisa/api/tiglobal.h>
  45
  46 #ifdef FDS_SM
  47 #include <dev/pms/RefTisa/sat/api/sm.h>
  48 #include <dev/pms/RefTisa/sat/api/smapi.h>
  49 #include <dev/pms/RefTisa/sat/api/tdsmapi.h>
  50 #endif
  51
  52 #ifdef FDS_DM
  53 #include <dev/pms/RefTisa/discovery/api/dm.h>
  54 #include <dev/pms/RefTisa/discovery/api/dmapi.h>
  55 #include <dev/pms/RefTisa/discovery/api/tddmapi.h>
  56 #endif
  57
  58 #include <dev/pms/RefTisa/tisa/sassata/sas/common/tdtypes.h>
  59 #include <dev/pms/freebsd/driver/common/osstring.h>
  60 #include <dev/pms/RefTisa/tisa/sassata/common/tdutil.h>
  61
  62 #ifdef INITIATOR_DRIVER
  63 #include <dev/pms/RefTisa/tisa/sassata/sas/ini/itdtypes.h>
  64 #include <dev/pms/RefTisa/tisa/sassata/sas/ini/itddefs.h>
  65 #include <dev/pms/RefTisa/tisa/sassata/sas/ini/itdglobl.h>
  66 #endif
  67
  68 #ifdef TARGET_DRIVER
  69 #include <dev/pms/RefTisa/tisa/sassata/sas/tgt/ttdglobl.h>
  70 #include <dev/pms/RefTisa/tisa/sassata/sas/tgt/ttdxchg.h>
  71 #include <dev/pms/RefTisa/tisa/sassata/sas/tgt/ttdtypes.h>
  72 #endif
  73
  74 #include <dev/pms/RefTisa/tisa/sassata/common/tdsatypes.h>
  75 #include <dev/pms/RefTisa/tisa/sassata/common/tdproto.h>
  76
  77 /*****************************************************************************
  78 *!  \brief  itdssTaskCompleted
  79 *
  80 *  Purpose: This routine is called to complete an task management request
  81 *           previously issued to the LL Layer. All task management completes with
  82 *           this function except query task management.
  83 *
  84 *   \param  agRoot:         Pointer to driver Instance.
  85 *   \param  agIORequest:    Pointer to the I/O Request data structure for
  86 *                           this I/O.
  87 *   \param  agIOStatus:     Status of I/O just completed.
  88 *   \param  agIOInfoLen:    Length of the I/O information associated with this
  89 *                           I/O request
  90 *   \param   agParam        A Handle used to refer to the response frame or handle
  91 *                           of abort request
  92 *   \param  agOtherInfo        Residual count
  93 *   \return:                None
  94 *
  95 *   \note - This is a initiator specific function called by the jump table.
  96 *
  97 *****************************************************************************/
  98 osGLOBAL void
  99 itdssTaskCompleted(
 100                  agsaRoot_t             *agRoot,
 101                  agsaIORequest_t        *agIORequest,
 102                  bit32                  agIOStatus,
 103                  bit32                  agIOInfoLen,
 104                  void                   *agParam,
 105                  bit32                  agOtherInfo
 106                  )
 107 {
 108   tdsaRootOsData_t            *osData = (tdsaRootOsData_t *)agRoot->osData;
 109   tiRoot_t                    *tiRoot = (tiRoot_t *)osData->tiRoot;
 110   tiIORequest_t               *taskTag = agNULL, *currentTaskTag = agNULL;
 111   tdIORequestBody_t           *tdIORequestBody = agNULL;
 112   tdIORequestBody_t           *TMtdIORequestBody = agNULL;
 113   tdIORequestBody_t           *AborttdIORequestBody = agNULL;
 114   agsaIORequest_t             *agTaskedIORequest;
 115   agsaSSPResponseInfoUnit_t   agSSPRespIU;
 116   bit8                        respData[128];
 117   bit32                       respLen;
 118 #ifdef  TD_DEBUG_ENABLE
 119   bit32                       data_status;
 120 #endif
 121   agsaSASRequestBody_t        *agSASRequestBody = agNULL;
 122   agsaSSPScsiTaskMgntReq_t    *agSSPTaskMgntRequest = agNULL;
 123   agsaIORequest_t             *agAbortIORequest;
 124   tdIORequestBody_t           *tdAbortIORequestBody;
 125   bit32                       PhysUpper32;
 126   bit32                       PhysLower32;
 127   bit32                       memAllocStatus;
 128   void                        *osMemHandle;
 129   bit32                       abortOrquery = agTRUE;
 130   tiDeviceHandle_t            *tiDeviceHandle = agNULL;
 131   tdsaDeviceData_t            *oneDeviceData = agNULL;
 132   agsaDevHandle_t             *agDevHandle = agNULL;
 133   bit32                        status = AGSA_RC_FAILURE;
 134
 135   TI_DBG2(("itdssTaskCompleted: start\n"));
 136
 137   tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
 138
 139   /* check the agIOStatus */
 140   currentTaskTag = tdIORequestBody->IOType.InitiatorTMIO.CurrentTaskTag;
 141
 142   if (currentTaskTag == agNULL)
 143   {
 144     TI_DBG1(("itdssTaskCompleted: currentTaskTag is NULL \n"));
 145         /* as the currentTaskTag is agNULL, shall not call ostiInitiatorEvent */
 146         #if 0
 147     ostiInitiatorEvent( tiRoot,
 148                         NULL,
 149                         NULL,
 150                         tiIntrEventTypeTaskManagement,
 151                         tiTMFailed,
 152                         currentTaskTag );
 153     #endif
 154     /* free up allocated memory */
 155     ostiFreeMemory(
 156                    tiRoot,
 157                    tdIORequestBody->IOType.InitiatorTMIO.osMemHandle,
 158                    sizeof(tdIORequestBody_t)
 159                    );
 160     return;
 161   }
 162
 163   if (agIOStatus != OSSA_IO_SUCCESS)
 164   {
 165     TI_DBG1(("itdssTaskCompleted: agIOStatus failed and tiTMFailed\n"));
 166     if (agIOStatus == OSSA_IO_TM_TAG_NOT_FOUND)
 167     {
 168       TI_DBG1(("itdssTaskCompleted: agIOStatus OSSA_IO_TM_TAG_NOT_FOUND\n"));
 169     }
 170     else
 171     if (agIOStatus == OSSA_IO_ABORTED)
 172     {
 173       TI_DBG1(("itdssTaskCompleted: agIOStatus OSSA_IO_ABORTED\n"));
 174     }
 175     else
 176     {
 177       TI_DBG1(("itdssTaskCompleted: agIOStatus 0x%x\n", agIOStatus));
 178     }
 179     ostiInitiatorEvent( tiRoot,
 180                         NULL,
 181                         NULL,
 182                         tiIntrEventTypeTaskManagement,
 183                         tiTMFailed,
 184                         currentTaskTag );
 185     /* free up allocated memory */
 186     ostiFreeMemory(
 187                    tiRoot,
 188                    tdIORequestBody->IOType.InitiatorTMIO.osMemHandle,
 189                    sizeof(tdIORequestBody_t)
 190                    );
 191     return;
 192   }
 193
 194   /* parse the task management response */
 195   /* reads agsaSSPResponseInfoUnit_t */
 196   saFrameReadBlock(agRoot, agParam, 0, &agSSPRespIU, sizeof(agsaSSPResponseInfoUnit_t));
 197 #ifdef  TD_DEBUG_ENABLE
 198   data_status = SA_SSPRESP_GET_DATAPRES(&agSSPRespIU);
 199 #endif
 200   respLen = SA_SSPRESP_GET_RESPONSEDATALEN(&agSSPRespIU);
 201   TI_DBG6(("itdssTaskCompleted: dataPres %d. should be 1\n", data_status));
 202   /* reads response data */
 203   saFrameReadBlock(agRoot, agParam,
 204                    sizeof(agsaSSPResponseInfoUnit_t),
 205                    respData, respLen);
 206   TI_DBG6(("itdssTaskCompleted: res code %d. should be 0\n", respData[3]));
 207
 208   taskTag = tdIORequestBody->IOType.InitiatorTMIO.TaskTag;
 209   if (taskTag == agNULL)
 210   {
 211     /* other than Abort Task or Query Task */
 212     TI_DBG1(("itdssTaskCompleted: taskTag is NULL\n"));
 213
 214     abortOrquery = agFALSE;
 215     TMtdIORequestBody = (tdIORequestBody_t *)currentTaskTag->tdData;
 216   }
 217   else
 218   {
 219     /* Abort Task or Query Task */
 220     TI_DBG2(("itdssTaskCompleted: taskTag is NOT NULL\n"));
 221     abortOrquery = agTRUE;
 222     TMtdIORequestBody = (tdIORequestBody_t *)currentTaskTag->tdData;
 223   }
 224
 225   TI_DBG2(("itdssTaskCompleted: TMtdIORequestBody %p\n", TMtdIORequestBody));
 226
 227   if (TMtdIORequestBody == agNULL)
 228   {
 229     TI_DBG1(("itdssTaskCompleted: TMtdIORequestBody is NULL \n"));
 230     ostiInitiatorEvent( tiRoot,
 231                         NULL,
 232                         NULL,
 233                         tiIntrEventTypeTaskManagement,
 234                         tiTMFailed,
 235                         currentTaskTag );
 236     /* free up allocated memory */
 237     ostiFreeMemory(
 238                    tiRoot,
 239                    tdIORequestBody->IOType.InitiatorTMIO.osMemHandle,
 240                    sizeof(tdIORequestBody_t)
 241                    );
 242     return;
 243   }
 244
 245   if (agIOStatus == OSSA_IO_SUCCESS && agIOInfoLen == 0)
 246   {
 247     TI_DBG1(("itdssTaskCompleted: agIOInfoLen is zero, wrong\n"));
 248     ostiInitiatorEvent( tiRoot,
 249                         NULL,
 250                         NULL,
 251                         tiIntrEventTypeTaskManagement,
 252                         tiTMFailed,
 253                         currentTaskTag );
 254     /* free up allocated memory */
 255     ostiFreeMemory(
 256                    tiRoot,
 257                    tdIORequestBody->IOType.InitiatorTMIO.osMemHandle,
 258                    sizeof(tdIORequestBody_t)
 259                    );
 260     return;
 261   }
 262
 263   agSASRequestBody = (agsaSASRequestBody_t *)&(TMtdIORequestBody->transport.SAS.agSASRequestBody);
 264   agSSPTaskMgntRequest = (agsaSSPScsiTaskMgntReq_t *)&(agSASRequestBody->sspTaskMgntReq);
 265   TI_DBG2(("itdssTaskCompleted: agSSPTaskMgntRequest->taskMgntFunction 0x%x\n", agSSPTaskMgntRequest->taskMgntFunction));
 266
 267   if ( (agSSPTaskMgntRequest->taskMgntFunction == AGSA_ABORT_TASK ||
 268         agSSPTaskMgntRequest->taskMgntFunction == AGSA_QUERY_TASK) &&
 269         abortOrquery == agFALSE
 270       )
 271   {
 272     TI_DBG1(("itdssTaskCompleted: incorrect tasktag, first\n"));
 273     ostiInitiatorEvent( tiRoot,
 274                         NULL,
 275                         NULL,
 276                         tiIntrEventTypeTaskManagement,
 277                         tiTMFailed,
 278                         currentTaskTag );
 279     /* free up allocated memory */
 280     ostiFreeMemory(
 281                    tiRoot,
 282                    tdIORequestBody->IOType.InitiatorTMIO.osMemHandle,
 283                    sizeof(tdIORequestBody_t)
 284                    );
 285     return;
 286   }
 287
 288   if ((agSSPTaskMgntRequest->taskMgntFunction == AGSA_ABORT_TASK_SET ||
 289        agSSPTaskMgntRequest->taskMgntFunction == AGSA_CLEAR_TASK_SET ||
 290        agSSPTaskMgntRequest->taskMgntFunction == AGSA_LOGICAL_UNIT_RESET ||
 291        agSSPTaskMgntRequest->taskMgntFunction == AGSA_CLEAR_ACA ) &&
 292        abortOrquery == agTRUE
 293      )
 294   {
 295     TI_DBG1(("itdssTaskCompleted: incorrect tasktag, second\n"));
 296     ostiInitiatorEvent( tiRoot,
 297                         NULL,
 298                         NULL,
 299                         tiIntrEventTypeTaskManagement,
 300                         tiTMFailed,
 301                         currentTaskTag );
 302     /* free up allocated memory */
 303     ostiFreeMemory(
 304                    tiRoot,
 305                    tdIORequestBody->IOType.InitiatorTMIO.osMemHandle,
 306                    sizeof(tdIORequestBody_t)
 307                    );
 308     return;
 309   }
 310
 311
 312   if (agSSPTaskMgntRequest->taskMgntFunction == AGSA_ABORT_TASK)
 313   {
 314     TI_DBG2(("itdssTaskCompleted: calling saSSPAbort()\n"));
 315     AborttdIORequestBody = (tdIORequestBody_t *)taskTag->tdData;
 316     if (AborttdIORequestBody == agNULL)
 317     {
 318       TI_DBG1(("itdssTaskCompleted: wrong, AborttdIORequestBody is NULL\n"));
 319       return;
 320     }
 321
 322     tiDeviceHandle = AborttdIORequestBody->tiDevHandle;
 323     if (tiDeviceHandle == agNULL)
 324     {
 325       TI_DBG1(("itdssTaskCompleted: wrong, tiDeviceHandle is NULL\n"));
 326       return;
 327     }
 328     oneDeviceData  = (tdsaDeviceData_t *)tiDeviceHandle->tdData;
 329     if (oneDeviceData == agNULL)
 330     {
 331       TI_DBG1(("itdssTaskCompleted: wrong, oneDeviceData is NULL\n"));
 332       return;
 333     }
 334     agDevHandle = oneDeviceData->agDevHandle;
 335     if (agDevHandle == agNULL)
 336     {
 337       TI_DBG1(("itdssTaskCompleted: wrong, agDevHandle is NULL\n"));
 338     }
 339
 340     agTaskedIORequest = (agsaIORequest_t *)&(AborttdIORequestBody->agIORequest);
 341     if (agTaskedIORequest == agNULL)
 342     {
 343       TI_DBG1(("itdssTaskCompleted: agTaskedIORequest is NULL \n"));
 344       ostiInitiatorEvent( tiRoot,
 345                           NULL,
 346                           NULL,
 347                           tiIntrEventTypeTaskManagement,
 348                           tiTMFailed,
 349                           currentTaskTag );
 350       /* free up allocated memory */
 351       ostiFreeMemory(
 352                      tiRoot,
 353                      tdIORequestBody->IOType.InitiatorTMIO.osMemHandle,
 354                      sizeof(tdIORequestBody_t)
 355                      );
 356       return;
 357     }
 358
 359
 360     /* allocating agIORequest for abort itself */
 361     memAllocStatus = ostiAllocMemory(
 362                                      tiRoot,
 363                                      &osMemHandle,
 364                                      (void **)&tdAbortIORequestBody,
 365                                      &PhysUpper32,
 366                                      &PhysLower32,
 367                                      8,
 368                                      sizeof(tdIORequestBody_t),
 369                                      agTRUE
 370                                      );
 371     if (memAllocStatus != tiSuccess)
 372     {
 373       /* let os process IO */
 374       TI_DBG1(("itdssTaskCompleted: ostiAllocMemory failed...\n"));
 375       return;
 376     }
 377
 378     if (tdAbortIORequestBody == agNULL)
 379     {
 380       /* let os process IO */
 381       TI_DBG1(("itdssTaskCompleted: ostiAllocMemory returned NULL tdAbortIORequestBody\n"));
 382       return;
 383     }
 384
 385     /* setup task management structure */
 386     tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle = osMemHandle;
 387     tdAbortIORequestBody->tiDevHandle = tiDeviceHandle;
 388     /* setting callback */
 389     tdAbortIORequestBody->IOCompletionFunc = itdssIOAbortedHandler;
 390
 391     /* setting to NULL because the local abort is triggered by TD layer */
 392     tdAbortIORequestBody->tiIOToBeAbortedRequest = agNULL;
 393     /* initialize agIORequest */
 394     agAbortIORequest = &(tdAbortIORequestBody->agIORequest);
 395     agAbortIORequest->osData = (void *) tdAbortIORequestBody;
 396     agAbortIORequest->sdkData = agNULL; /* LL takes care of this */
 397
 398     status = saSSPAbort(agRoot, agAbortIORequest, tdsaRotateQnumber(tiRoot, oneDeviceData), agDevHandle, 0, agTaskedIORequest, agNULL);
 399     if (status != AGSA_RC_SUCCESS)
 400     {
 401       TI_DBG1(("itdssTaskCompleted: saSSPAbort failed agIOInfoLen is zero, wrong\n"));
 402       ostiFreeMemory(
 403                      tiRoot,
 404                      tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
 405                      sizeof(tdIORequestBody_t)
 406                      );
 407     }
 408   }
 409
 410   /*
 411     parse the response and based on the parse,
 412     set the flag
 413   */
 414   if (respData[3] == AGSA_TASK_MANAGEMENT_FUNCTION_COMPLETE ||
 415       respData[3] == AGSA_TASK_MANAGEMENT_FUNCTION_SUCCEEDED)
 416   {
 417     TI_DBG2(("itdssTaskCompleted: tiTMOK\n"));
 418     tiDeviceHandle = TMtdIORequestBody->tiDevHandle;
 419     if (tiDeviceHandle == agNULL)
 420     {
 421       TI_DBG1(("itdssTaskCompleted: wrong, tiDeviceHandle is NULL\n"));
 422       return;
 423     }
 424     oneDeviceData  = (tdsaDeviceData_t *)tiDeviceHandle->tdData;
 425     if (oneDeviceData == agNULL)
 426     {
 427       TI_DBG1(("itdssTaskCompleted: wrong, oneDeviceData is NULL\n"));
 428       return;
 429     }
 430     agDevHandle = oneDeviceData->agDevHandle;
 431     if (agDevHandle == agNULL)
 432     {
 433       TI_DBG1(("itdssTaskCompleted: wrong, agDevHandle is NULL\n"));
 434     }
 435     TI_DBG2(("itdssTaskCompleted: setting Device state to SA_DS_OPERATIONAL\n"));
 436
 437     saSetDeviceState(agRoot, agNULL, tdsaRotateQnumber(tiRoot, oneDeviceData), agDevHandle, SA_DS_OPERATIONAL);
 438
 439     ostiInitiatorEvent( tiRoot,
 440                         NULL,
 441                         NULL,
 442                         tiIntrEventTypeTaskManagement,
 443                         tiTMOK,
 444                         currentTaskTag );
 445   }
 446   else
 447   {
 448     TI_DBG1(("itdssTaskCompleted: tiTMFailed\n"));
 449     ostiInitiatorEvent( tiRoot,
 450                         NULL,
 451                         NULL,
 452                         tiIntrEventTypeTaskManagement,
 453                         tiTMFailed,
 454                         currentTaskTag );
 455
 456   }
 457
 458   /* free up allocated memory */
 459   ostiFreeMemory(
 460                  tiRoot,
 461                  tdIORequestBody->IOType.InitiatorTMIO.osMemHandle,
 462                  sizeof(tdIORequestBody_t)
 463                  );
 464   return;
 465 }
 466
 467 #ifdef INITIATOR_DRIVER
 468
 469 /*****************************************************************************
 470 *!  \brief  itdssQueryTaskCompleted
 471 *
 472 *  Purpose: This routine is called to complete an query task management request
 473 *           previously issued to the LL Layer.
 474 *
 475 *   \param  agRoot:         Pointer to driver Instance.
 476 *   \param  agIORequest:    Pointer to the I/O Request data structure for
 477 *                           this I/O.
 478 *   \param  agIOStatus:     Status of I/O just completed.
 479 *   \param  agIOInfoLen:    Length of the I/O information associated with this
 480 *                           I/O request
 481 *   \param   agParam        A Handle used to refer to the response frame or handle
 482 *                           of abort request
 483 *
 484 *   \return:                None
 485 *
 486 *   \note - This is a initiator specific function called by the jump table.
 487 *
 488 *****************************************************************************/
 489 osGLOBAL void
 490 itdssQueryTaskCompleted(
 491                         agsaRoot_t             *agRoot,
 492                         agsaIORequest_t        *agIORequest,
 493                         bit32                  agIOStatus,
 494                         bit32                  agIOInfoLen,
 495                         void                   *agParam,
 496                         bit32                  agOtherInfo
 497                         )
 498 {
 499   tdsaRootOsData_t            *osData = (tdsaRootOsData_t *)agRoot->osData;
 500   tiRoot_t                    *tiRoot = (tiRoot_t *)osData->tiRoot;
 501   tiIORequest_t               *taskTag = agNULL;
 502   tdIORequestBody_t           *tdIORequestBody = agNULL;  /* query task */
 503   tdIORequestBody_t           *TMtdIORequestBody = agNULL; /* IO being query tasked */
 504   agsaIORequest_t             *agTaskedIORequest = agNULL;
 505   agsaSSPResponseInfoUnit_t   agSSPRespIU;
 506   bit8                        respData[128];
 507   bit32                       respLen;
 508 #ifdef  TD_DEBUG_ENABLE
 509   bit32                       data_status;
 510 #endif
 511   agsaSASRequestBody_t        *agSASRequestBody = agNULL;
 512   agsaSSPScsiTaskMgntReq_t    *agSSPTaskMgntRequest = agNULL;
 513   bit32                       status;
 514   agsaIORequest_t             *agAbortIORequest = agNULL;
 515   tdIORequestBody_t           *tdAbortIORequestBody = agNULL;
 516   bit32                       PhysUpper32;
 517   bit32                       PhysLower32;
 518   bit32                       memAllocStatus;
 519   void                        *osMemHandle = agNULL;
 520   tiDeviceHandle_t            *tiDeviceHandle = agNULL;
 521   tdsaDeviceData_t            *oneDeviceData = agNULL;
 522   agsaDevHandle_t             *agDevHandle = agNULL;
 523
 524   TI_DBG2(("itdssQueryTaskComplted: start\n"));
 525
 526   /* query task management IORequestBody */
 527   tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
 528
 529   /* OS's tiIORequest for this query taks, which is agNULL */
 530   //currentTaskTag = tdIORequestBody->IOType.InitiatorTMIO.CurrentTaskTag;
 531
 532   /*
 533     currentTaskTag is agNULL for query task since it is generated by
 534     TD layer
 535   */
 536   if (agIOStatus != OSSA_IO_SUCCESS)
 537   {
 538     /* let os process IO */
 539     TI_DBG1(("itdssQueryTaskComplted: agIOStatus failed and tiTMFailed\n"));
 540     /* free up allocated memory */
 541     ostiFreeMemory(
 542                    tiRoot,
 543                    tdIORequestBody->IOType.InitiatorTMIO.osMemHandle,
 544                    sizeof(tdIORequestBody_t)
 545                    );
 546     return;
 547   }
 548   /* parse the task management response */
 549   /* reads agsaSSPResponseInfoUnit_t */
 550   saFrameReadBlock(agRoot, agParam, 0, &agSSPRespIU, sizeof(agsaSSPResponseInfoUnit_t));
 551 #ifdef  TD_DEBUG_ENABLE
 552   data_status = SA_SSPRESP_GET_DATAPRES(&agSSPRespIU);
 553 #endif
 554   respLen = SA_SSPRESP_GET_RESPONSEDATALEN(&agSSPRespIU);
 555
 556   TI_DBG6(("itdssQueryTaskCompleted: dataPres %d. should be 1\n", data_status));
 557   /* reads response data */
 558   saFrameReadBlock(agRoot, agParam,
 559                    sizeof(agsaSSPResponseInfoUnit_t),
 560                    respData, respLen);
 561
 562   TI_DBG6(("itdssQueryTaskCompleted: res code %d. should be 0\n", respData[3]));
 563
 564   /* IO being query tasked */
 565   taskTag = tdIORequestBody->IOType.InitiatorTMIO.TaskTag;
 566   if (taskTag == agNULL)
 567   {
 568     TI_DBG1(("itdssQueryTaskComplted: taskTag is NULL \n"));
 569     /* free up allocated memory */
 570     ostiFreeMemory(
 571                    tiRoot,
 572                    tdIORequestBody->IOType.InitiatorTMIO.osMemHandle,
 573                    sizeof(tdIORequestBody_t)
 574                    );
 575     return;
 576   }
 577
 578   /* request body of IO being query tasked  */
 579   TMtdIORequestBody = (tdIORequestBody_t *)taskTag->tdData;
 580   if (TMtdIORequestBody == agNULL)
 581   {
 582     TI_DBG1(("itdssQueryTaskComplted: TMtdIORequestBody is NULL \n"));
 583     /* free up allocated memory */
 584     ostiFreeMemory(
 585                    tiRoot,
 586                    tdIORequestBody->IOType.InitiatorTMIO.osMemHandle,
 587                    sizeof(tdIORequestBody_t)
 588                    );
 589     return;
 590   }
 591
 592   agTaskedIORequest = &(TMtdIORequestBody->agIORequest);
 593   if (agTaskedIORequest == agNULL)
 594   {
 595     TI_DBG1(("itdssQueryTaskComplted: agTaskedIORequest is NULL \n"));
 596     /* free up allocated memory */
 597     ostiFreeMemory(
 598                    tiRoot,
 599                    tdIORequestBody->IOType.InitiatorTMIO.osMemHandle,
 600                    sizeof(tdIORequestBody_t)
 601                    );
 602     return;
 603   }
 604
 605   if (agIOStatus == OSSA_IO_SUCCESS && agIOInfoLen == 0)
 606   {
 607     TI_DBG1(("itdssQueryTaskCompleted: agIOInfoLen is zero, wrong\n"));
 608     /* free up allocated memory */
 609     ostiFreeMemory(
 610                    tiRoot,
 611                    tdIORequestBody->IOType.InitiatorTMIO.osMemHandle,
 612                    sizeof(tdIORequestBody_t)
 613                    );
 614    return;
 615   }
 616   /* this is query task itself */
 617   agSASRequestBody = &(tdIORequestBody->transport.SAS.agSASRequestBody);
 618   agSSPTaskMgntRequest = &(agSASRequestBody->sspTaskMgntReq);
 619   if (agSSPTaskMgntRequest->taskMgntFunction == AGSA_QUERY_TASK)
 620   {
 621     /*
 622       process response for query task
 623       For query task, response code must be either
 624       TASK MANAGEMENT FUNCTION COMPLETE or TASK MANAGEMENT FUNCTION SUCCEEDED by
 625       SAM
 626
 627       1. If TASK MANAGEMENT FUNCTION SUCCEEDE, do nothing
 628
 629       2. If TASK MANAGEMENT FUNCTION COMPLETE and IO is not completed,
 630       retry by saSSPAbort()
 631     */
 632     if (respData[3] == AGSA_TASK_MANAGEMENT_FUNCTION_SUCCEEDED)
 633     {
 634       /* OK; IO is being process at the target; do nothing */
 635     }
 636     else if (respData[3] == AGSA_TASK_MANAGEMENT_FUNCTION_COMPLETE)
 637     {
 638       tiDeviceHandle = TMtdIORequestBody->tiDevHandle;
 639       if (tiDeviceHandle == agNULL)
 640       {
 641         TI_DBG1(("itdssQueryTaskCompleted: wrong, tiDeviceHandle is NULL\n"));
 642         /* free up allocated memory */
 643         ostiFreeMemory(
 644                        tiRoot,
 645                        tdIORequestBody->IOType.InitiatorTMIO.osMemHandle,
 646                        sizeof(tdIORequestBody_t)
 647                        );
 648         return;
 649       }
 650       oneDeviceData  = (tdsaDeviceData_t *)tiDeviceHandle->tdData;
 651       if (oneDeviceData == agNULL)
 652       {
 653         TI_DBG1(("itdssQueryTaskCompleted: wrong, oneDeviceData is NULL\n"));
 654         /* free up allocated memory */
 655         ostiFreeMemory(
 656                        tiRoot,
 657                        tdIORequestBody->IOType.InitiatorTMIO.osMemHandle,
 658                        sizeof(tdIORequestBody_t)
 659                        );
 660
 661         return;
 662       }
 663       agDevHandle = oneDeviceData->agDevHandle;
 664       if (agDevHandle == agNULL)
 665       {
 666         TI_DBG1(("itdssQueryTaskCompleted: wrong, agDevHandle is NULL\n"));
 667       }
 668       /* if IO is not completed, retry IO by saSSPAbort() */
 669       if (TMtdIORequestBody->ioCompleted != agTRUE)
 670       {
 671         /* allocating agIORequest for abort itself */
 672         memAllocStatus = ostiAllocMemory(
 673                                          tiRoot,
 674                                          &osMemHandle,
 675                                          (void **)&tdAbortIORequestBody,
 676                                          &PhysUpper32,
 677                                          &PhysLower32,
 678                                          8,
 679                                          sizeof(tdIORequestBody_t),
 680                                          agTRUE
 681                                          );
 682         if (memAllocStatus != tiSuccess)
 683         {
 684           /* let os process IO */
 685           TI_DBG1(("itdssQueryTaskCompleted: ostiAllocMemory failed...\n"));
 686           /* free up allocated memory */
 687           ostiFreeMemory(
 688                          tiRoot,
 689                          tdIORequestBody->IOType.InitiatorTMIO.osMemHandle,
 690                          sizeof(tdIORequestBody_t)
 691                          );
 692
 693           return;
 694         }
 695         if (tdAbortIORequestBody == agNULL)
 696         {
 697           /* let os process IO */
 698           TI_DBG1(("itdssQueryTaskCompleted: ostiAllocMemory returned NULL tdAbortIORequestBody\n"));
 699           /* free up allocated memory */
 700           ostiFreeMemory(
 701                          tiRoot,
 702                          tdIORequestBody->IOType.InitiatorTMIO.osMemHandle,
 703                          sizeof(tdIORequestBody_t)
 704                          );
 705
 706           return;
 707         }
 708
 709         /* setup task management structure */
 710         tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle = osMemHandle;
 711         tdAbortIORequestBody->tiDevHandle = tdIORequestBody->tiDevHandle;
 712         tdAbortIORequestBody->tiIOToBeAbortedRequest = agNULL;
 713
 714         /* setting callback */
 715         tdAbortIORequestBody->IOCompletionFunc = itdssIOAbortedHandler;
 716
 717         /* initialize agIORequest */
 718         agAbortIORequest = &(tdAbortIORequestBody->agIORequest);
 719         agAbortIORequest->osData = (void *) tdAbortIORequestBody;
 720         agAbortIORequest->sdkData = agNULL; /* LL takes care of this */
 721
 722         TI_DBG2(("itdssQueryTaskCompleted: issuing saSSPAbort()\n"));
 723         status = saSSPAbort(agRoot, agAbortIORequest, tdsaRotateQnumber(tiRoot, oneDeviceData), agDevHandle, 0, agTaskedIORequest, agNULL);
 724         if (status != AGSA_RC_SUCCESS)
 725         {
 726           TI_DBG1(("itdssQueryTaskCompleted: saSSPAbort failed agIOInfoLen is zero, wrong\n"));
 727           ostiFreeMemory(
 728                          tiRoot,
 729                          tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
 730                          sizeof(tdIORequestBody_t)
 731                          );
 732         }
 733       }
 734     }
 735     else
 736     {
 737       TI_DBG1(("itdssQueryTaskComplted: not expected response 0x%x\n",respData[3]));
 738     }
 739   }
 740   else
 741   {
 742     TI_DBG1(("itdssQueryTaskCompleted: not expected task management fn %d\n",agSSPTaskMgntRequest->taskMgntFunction));
 743   }
 744
 745   /* free up allocated memory */
 746   ostiFreeMemory(
 747                  tiRoot,
 748                  tdIORequestBody->IOType.InitiatorTMIO.osMemHandle,
 749                  sizeof(tdIORequestBody_t)
 750                  );
 751   return;
 752 }
 753 #endif
 754
 755 /*****************************************************************************
 756 *!  \brief  itssdosIOCompleted
 757 *
 758 *  Purpose: This routine is called to complete an I/O request previously
 759 *           issued to the LL Layer in saSSPStart().
 760 *
 761 *   \param  agRoot:       Pointer to driver Instance.
 762 *   \param  agIORequest:  Pointer to the I/O Request data structure for
 763 *                         this I/O.
 764 *   \param  agIOStatus:   Status of I/O just completed.
 765 *   \param  agIOInfoLen:  Length of the I/O information associated with this
 766 *                         I/O request
 767 *   \param   agParam      A Handle used to refer to the response frame or handle
 768 *                         of abort request
 769 *  \param  agOtherInfo    Residual count
 770 *   \return:              None
 771 *
 772 *   \note - This is a initiator specific function called by the jump table.
 773 *
 774 *****************************************************************************/
 775 FORCEINLINE void
 776 itdssIOCompleted(
 777                  agsaRoot_t             *agRoot,
 778                  agsaIORequest_t        *agIORequest,
 779                  bit32                   agIOStatus,
 780                  bit32                   agIOInfoLen,
 781                  void                   *agParam,
 782                  bit32                   agOtherInfo
 783                  )
 784 {
 785   tdsaRootOsData_t          *osData = (tdsaRootOsData_t *)agRoot->osData;
 786   tiRoot_t                  *tiRoot = (tiRoot_t *)osData->tiRoot;
 787   itdsaIni_t                *Initiator = (itdsaIni_t *)osData->itdsaIni;
 788   tdIORequestBody_t         *tdIORequestBody  = agNULL;
 789   agsaSASRequestBody_t      *agSASRequestBody = agNULL;
 790   agsaSSPInitiatorRequest_t *agSSPInitiatorRequest = agNULL;
 791   agsaSSPResponseInfoUnit_t  agSSPRespIU;
 792
 793   bit32 scsi_status = 0;
 794
 795   tiDeviceHandle_t          *tiDeviceHandle = agNULL;
 796   tdsaDeviceData_t          *oneDeviceData  = agNULL;
 797
 798   TI_DBG6(("itdssIOCompleted: start\n"));
 799   TI_DBG6(("itdssIOCompleted: agIOInfoLen %d\n", agIOInfoLen));
 800
 801   tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
 802   TD_ASSERT((NULL != tdIORequestBody), "itdssIOCompleted:tdIORequestBody NULL");
 803   if ( NULL == tdIORequestBody )  // handle windows assert case
 804   {
 805     return;
 806   }
 807   Initiator->NumIOsActive--;
 808
 809 #ifdef DBG
 810   if (tdIORequestBody->ioCompleted == agTRUE)
 811   {
 812 #ifdef  TD_DEBUG_ENABLE
 813     tiDeviceHandle = tdIORequestBody->tiDevHandle;
 814     oneDeviceData  = (tdsaDeviceData_t *)tiDeviceHandle->tdData;
 815 #endif /*TD_DEBUG_ENABLE*/
 816     TI_DBG1(("itdssIOCompleted: Error!!!!!! double completion\n"));
 817 #ifdef  TD_DEBUG_ENABLE
 818     TI_DBG1(("itdssIOCompleted: did %d \n", oneDeviceData->id));
 819 #endif /*TD_DEBUG_ENABLE*/
 820   }
 821
 822   if (Initiator->NumIOsActive == 0)
 823   {
 824     /* so far, no timer assocaicated here */
 825     TI_DBG6(("itdssIOCompleted: no acitve IO's. Kill timers\n"));
 826   }
 827
 828   if (tdIORequestBody->tiIORequest->osData == agNULL)
 829   {
 830     TI_DBG1( ("itdssIOCompleted: pos 1; "
 831               "tdIORequestBody->tiIORequest->osData is null, wrong\n") );
 832   }
 833 #endif /*DBG*/
 834
 835   tdIORequestBody->ioCompleted = agTRUE;
 836   tdIORequestBody->ioStarted = agFALSE;
 837
 838   /* Process completion for debugging, printing cbd */
 839   agSASRequestBody = &(tdIORequestBody->transport.SAS.agSASRequestBody);
 840   agSSPInitiatorRequest = &(agSASRequestBody->sspInitiatorReq);
 841
 842   TI_DBG6( ("itdssIOCompleted: CDB 0x%x\n",
 843             agSSPInitiatorRequest->sspCmdIU.cdb[0]) );
 844
 845   /* no respsonse or sense data; data has been processed */
 846   if((agIOStatus == OSSA_IO_SUCCESS) && (agIOInfoLen == 0))
 847   {
 848     // if this is a standard Inquiry command, notify Stoport to set the
 849     // device queue depth to maximize oustanding IO
 850     if ( (agSSPInitiatorRequest->sspCmdIU.cdb[0] == SCSIOPC_INQUIRY) &&
 851          ((agSSPInitiatorRequest->sspCmdIU.cdb[1] & 0x01) == 0))
 852     {
 853       bit32 qdepth = 32;
 854       tiDeviceHandle = tdIORequestBody->tiDevHandle;
 855       if( tiDeviceHandle )
 856       {
 857         oneDeviceData = (tdsaDeviceData_t *)tiDeviceHandle->tdData;
 858         if( oneDeviceData->DeviceType == TD_SAS_DEVICE )
 859         {
 860           qdepth = MAX_OUTSTANDING_IO_PER_LUN;
 861         }
 862         if( oneDeviceData->DeviceType == TD_SATA_DEVICE )
 863         {
 864           qdepth = 63;
 865         }
 866       }
 867
 868       if ( ostiSetDeviceQueueDepth( tiRoot,
 869                                     tdIORequestBody->tiIORequest,
 870                                     MAX_OUTSTANDING_IO_PER_LUN ) == agFALSE )
 871       {
 872         TI_DBG1( ( "itdssIOCompleted: failed to call "
 873                    "ostiSetDeviceQueueDepth() Q=%d !!!\n", qdepth ) );
 874       }
 875       else
 876       {
 877         TI_DBG2(("itdssIOCompleted: set ostiSetDeviceQueueDepth() Q=%d\n",qdepth));
 878       }
 879     }
 880     // SCSI command was completed OK, this is the normal path. Now call the
 881     // OS Specific module about this completion.
 882     ostiInitiatorIOCompleted(
 883                              tiRoot,
 884                              tdIORequestBody->tiIORequest,
 885                              tiIOSuccess,
 886                              SCSI_STAT_GOOD,
 887                              agNULL,
 888                              agTRUE /* intContext; is not being used */
 889                              );
 890     return;
 891   }
 892
 893   else
 894   {
 895     TI_DBG6(("itdssIOCompleted: SUCCESS but data returned \n"));
 896     TI_DBG6( ("itdssIOCompleted: agIOStatus SUCCESS but data returned 0x%x\n",
 897               agIOStatus) );
 898     if(tdIORequestBody)
 899     {
 900       tiDeviceHandle = tdIORequestBody->tiDevHandle;
 901       if(tiDeviceHandle)
 902       {
 903         oneDeviceData  = (tdsaDeviceData_t *)tiDeviceHandle->tdData;
 904       }
 905     }
 906
 907     osti_memset(&agSSPRespIU, 0, sizeof(agsaSSPResponseInfoUnit_t));
 908
 909     saFrameReadBlock( agRoot,
 910                       agParam,
 911                       0,
 912                       &agSSPRespIU,
 913                       sizeof(agsaSSPResponseInfoUnit_t) );
 914     scsi_status = agSSPRespIU.status;
 915
 916     switch (scsi_status)
 917     {
 918       case SCSI_STAT_GOOD:
 919         TI_DBG2( ("itdssIOCompleted: SCSI_STAT_GOOD %d\n",
 920                   Initiator->ScsiStatusCounts.GoodStatus) );
 921         Initiator->ScsiStatusCounts.GoodStatus++;
 922         break;
 923        case SCSI_STAT_CHECK_CONDITION:
 924         TI_DBG1( ("itdssIOCompleted: SCSI_STAT_CHECK_CONDITION %d\n",
 925                   Initiator->ScsiStatusCounts.CheckCondition) );
 926         Initiator->ScsiStatusCounts.CheckCondition++;
 927         break;
 928       case SCSI_STAT_BUSY:
 929         TI_DBG1( ("itdssIOCompleted: SCSI_STAT_BUSY %d\n",
 930                   Initiator->ScsiStatusCounts.BusyStatus) );
 931         Initiator->ScsiStatusCounts.BusyStatus++;
 932         break;
 933       case SCSI_STAT_RESV_CONFLICT:
 934         TI_DBG1( ("itdssIOCompleted: SCSI_STAT_RESV_CONFLICT %d\n",
 935                   Initiator->ScsiStatusCounts.ResvConflict) );
 936         Initiator->ScsiStatusCounts.ResvConflict++;
 937         break;
 938       case SCSI_STAT_TASK_SET_FULL:
 939         Initiator->ScsiStatusCounts.TaskSetFull++;
 940         //agIOStatus =  OSSA_IO_FAILED;
 941         //agOtherInfo = tiDetailBusy;
 942         TI_DBG1( ("itdssIOCompleted: SCSI_STAT_TASK_SET_FULL %d\n",
 943                   Initiator->ScsiStatusCounts.TaskSetFull) );
 944         break;
 945       case SCSI_STAT_ACA_ACTIVE:
 946         Initiator->ScsiStatusCounts.AcaActive++;
 947         TI_DBG1( ("itdssIOCompleted: SCSI_STAT_ACA_ACTIVE %d\n",
 948                   Initiator->ScsiStatusCounts.AcaActive) );
 949         break;
 950       case SCSI_STAT_TASK_ABORTED:
 951         Initiator->ScsiStatusCounts.TaskAborted++;
 952         TI_DBG1( ("itdssIOCompleted: SCSI_STAT_TASK_ABORTED %d\n",
 953                   Initiator->ScsiStatusCounts.TaskAborted) );
 954         break;
 955       case SCSI_STAT_CONDITION_MET:
 956         Initiator->ScsiStatusCounts.ConditionMet++;
 957         TI_DBG1( ("itdssIOCompleted: SCSI_STAT_CONDITION_MET %d\n",
 958                   Initiator->ScsiStatusCounts.ConditionMet) );
 959         break;
 960       case SCSI_STAT_INTERMEDIATE:
 961         TI_DBG1( ("itdssIOCompleted: SCSI_STAT_INTERMEDIATE %d\n",
 962                   Initiator->ScsiStatusCounts.ObsoleteStatus) );
 963         Initiator->ScsiStatusCounts.ObsoleteStatus++;
 964         break;
 965       case SCSI_STAT_INTER_CONDIT_MET:
 966         TI_DBG1( ("itdssIOCompleted: SCSI_STAT_INTER_CONDIT_MET %d\n",
 967                   Initiator->ScsiStatusCounts.ObsoleteStatus) );
 968         Initiator->ScsiStatusCounts.ObsoleteStatus++;
 969         break;
 970       case SCSI_STAT_COMMANDTERMINATED:
 971         TI_DBG1( ("itdssIOCompleted: SCSI_STAT_COMMANDTERMINATED %d\n",
 972                   Initiator->ScsiStatusCounts.ObsoleteStatus) );
 973         Initiator->ScsiStatusCounts.ObsoleteStatus++;
 974         break;
 975       default:
 976         Initiator->ScsiStatusCounts.ObsoleteStatus++;
 977         TI_DBG1( ("itdssIOCompleted: Unknown scsi_status %d 0x%x\n",
 978                   scsi_status,Initiator->ScsiStatusCounts.ObsoleteStatus) );
 979     }
 980
 981     switch (agIOStatus)
 982     {
 983     case OSSA_IO_SUCCESS:
 984       itdssIOSuccessHandler( agRoot,
 985                              agIORequest,
 986                              agIOStatus,
 987                              agIOInfoLen,
 988                              agParam,
 989                              agOtherInfo );
 990       break;
 991     case OSSA_IO_ABORTED:
 992       itdssIOAbortedHandler( agRoot,
 993                              agIORequest,
 994                              agIOStatus,
 995                              agIOInfoLen,
 996                              agParam,
 997                              agOtherInfo );
 998       break;
 999     case OSSA_IO_UNDERFLOW:
1000       itdssIOUnderFlowHandler( agRoot,
1001                                agIORequest,
1002                                agIOStatus,
1003                                agIOInfoLen,
1004                                agParam,
1005                                agOtherInfo );
1006       break;
1007     case OSSA_IO_FAILED:
1008       itdssIOFailedHandler( agRoot,
1009                             agIORequest,
1010                             agIOStatus,
1011                             agIOInfoLen,
1012                             agParam,
1013                             agOtherInfo );
1014       break;
1015     case OSSA_IO_ABORT_RESET:
1016       itdssIOAbortResetHandler( agRoot,
1017                                 agIORequest,
1018                                 agIOStatus,
1019                                 agIOInfoLen,
1020                                 agParam,
1021                                 agOtherInfo );
1022       break;
1023     case OSSA_IO_NO_DEVICE:
1024       itdssIONoDeviceHandler( agRoot,
1025                               agIORequest,
1026                               agIOStatus,
1027                               agIOInfoLen,
1028                               agParam,
1029                               agOtherInfo );
1030       break;
1031     case OSSA_IO_XFER_ERROR_BREAK:
1032       itdssXferErrorBreakHandler( agRoot,
1033                                   agIORequest,
1034                                   agIOStatus,
1035                                   agIOInfoLen,
1036                                   agParam,
1037                                   agOtherInfo );
1038       break;
1039     case OSSA_IO_XFER_ERROR_PHY_NOT_READY:
1040       itdssXferErrorPhyNotReadyHandler( agRoot,
1041                                         agIORequest,
1042                                         agIOStatus,
1043                                         agIOInfoLen,
1044                                         agParam,
1045                                         agOtherInfo );
1046       break;
1047     case OSSA_IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED:
1048       itdssOpenCnxErrorProtocolNotSupprotedHandler( agRoot,
1049                                                     agIORequest,
1050                                                     agIOStatus,
1051                                                     agIOInfoLen,
1052                                                     agParam,
1053                                                     agOtherInfo );
1054       break;
1055     case OSSA_IO_OPEN_CNX_ERROR_ZONE_VIOLATION:
1056       itdssOpenCnxErrorZoneViolationHandler( agRoot,
1057                                              agIORequest,
1058                                              agIOStatus,
1059                                              agIOInfoLen,
1060                                              agParam,
1061                                              agOtherInfo );
1062       break;
1063     case OSSA_IO_OPEN_CNX_ERROR_BREAK:
1064       itdssOpenCnxErrorBreakHandler( agRoot,
1065                                      agIORequest,
1066                                      agIOStatus,
1067                                      agIOInfoLen,
1068                                      agParam,
1069                                      agOtherInfo );
1070       break;
1071     case OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS:
1072       itdssOpenCnxErrorITNexusLossHandler( agRoot,
1073                                            agIORequest,
1074                                            agIOStatus,
1075                                            agIOInfoLen,
1076                                            agParam,
1077                                            agOtherInfo );
1078       break;
1079     case OSSA_IO_OPEN_CNX_ERROR_BAD_DESTINATION:
1080       itdssOpenCnxErrorBadDestinationHandler( agRoot,
1081                                               agIORequest,
1082                                               agIOStatus,
1083                                               agIOInfoLen,
1084                                               agParam,
1085                                               agOtherInfo );
1086       break;
1087     case OSSA_IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED:
1088       itdssOpenCnxErrorConnectionRateNotSupportedHandler( agRoot,
1089                                                           agIORequest,
1090                                                           agIOStatus,
1091                                                           agIOInfoLen,
1092                                                           agParam,
1093                                                           agOtherInfo );
1094       break;
1095     case OSSA_IO_OPEN_CNX_ERROR_WRONG_DESTINATION:
1096       itdssOpenCnxErrorWrongDestinationHandler( agRoot,
1097                                                 agIORequest,
1098                                                 agIOStatus,
1099                                                 agIOInfoLen,
1100                                                 agParam,
1101                                                 agOtherInfo );
1102       break;
1103     case OSSA_IO_OPEN_CNX_ERROR_UNKNOWN_ERROR:
1104       itdssOpenCnxErrorUnknownErrorHandler( agRoot,
1105                                             agIORequest,
1106                                             agIOStatus,
1107                                             agIOInfoLen,
1108                                             agParam,
1109                                             agOtherInfo );
1110       break;
1111     case OSSA_IO_XFER_ERROR_NAK_RECEIVED:
1112       itdssXferErrorNAKReceivedHandler( agRoot,
1113                                         agIORequest,
1114                                         agIOStatus,
1115                                         agIOInfoLen,
1116                                         agParam,
1117                                         agOtherInfo );
1118       break;
1119     case OSSA_IO_XFER_ERROR_ACK_NAK_TIMEOUT:
1120       itdssXferErrorACKNAKTimeoutHandler( agRoot,
1121                                           agIORequest,
1122                                           agIOStatus,
1123                                           agIOInfoLen,
1124                                           agParam,
1125                                           agOtherInfo );
1126       break;
1127     case OSSA_IO_XFER_ERROR_DMA:
1128       itdssXferErrorDMAHandler( agRoot,
1129                                 agIORequest,
1130                                 agIOStatus,
1131                                 agIOInfoLen,
1132                                 agParam,
1133                                 agOtherInfo );
1134       break;
1135     case OSSA_IO_XFER_ERROR_OFFSET_MISMATCH:
1136       itdssXferErrorOffsetMismatchHandler( agRoot,
1137                                            agIORequest,
1138                                            agIOStatus,
1139                                            agIOInfoLen,
1140                                            agParam,
1141                                            agOtherInfo );
1142       break;
1143     case OSSA_IO_XFER_OPEN_RETRY_TIMEOUT:
1144       itdssXferOpenRetryTimeoutHandler( agRoot,
1145                                         agIORequest,
1146                                         agIOStatus,
1147                                         agIOInfoLen,
1148                                         agParam,
1149                                         agOtherInfo );
1150       break;
1151     case OSSA_IO_PORT_IN_RESET:
1152       itdssPortInResetHandler( agRoot,
1153                                agIORequest,
1154                                agIOStatus,
1155                                agIOInfoLen,
1156                                agParam,
1157                                agOtherInfo );
1158       break;
1159     case OSSA_IO_DS_NON_OPERATIONAL:
1160       itdssDsNonOperationalHandler( agRoot,
1161                                     agIORequest,
1162                                     agIOStatus,
1163                                     agIOInfoLen,
1164                                     agParam,
1165                                     agOtherInfo );
1166       break;
1167     case OSSA_IO_DS_IN_RECOVERY:
1168       itdssDsInRecoveryHandler( agRoot,
1169                                 agIORequest,
1170                                 agIOStatus,
1171                                 agIOInfoLen,
1172                                 agParam,
1173                                 agOtherInfo );
1174       break;
1175     case OSSA_IO_TM_TAG_NOT_FOUND:
1176       itdssTmTagNotFoundHandler( agRoot,
1177                                  agIORequest,
1178                                  agIOStatus,
1179                                  agIOInfoLen,
1180                                  agParam,
1181                                  agOtherInfo );
1182       break;
1183     case OSSA_IO_SSP_EXT_IU_ZERO_LEN_ERROR:
1184       itdssSSPExtIUZeroLenHandler( agRoot,
1185                                    agIORequest,
1186                                    agIOStatus,
1187                                    agIOInfoLen,
1188                                    agParam,
1189                                    agOtherInfo );
1190       break;
1191     case OSSA_IO_XFER_ERROR_UNEXPECTED_PHASE:
1192       itdssXferErrorUnexpectedPhaseHandler( agRoot,
1193                                             agIORequest,
1194                                             agIOStatus,
1195                                             agIOInfoLen,
1196                                             agParam,
1197                                             agOtherInfo );
1198       break;
1199 //new
1200     case OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_RETRY_BACKOFF_THRESHOLD_REACHED:
1201       itdssXferOpenRetryBackoffThresholdReachedHandler( agRoot,
1202                                                         agIORequest,
1203                                                         agIOStatus,
1204                                                         agIOInfoLen,
1205                                                         agParam,
1206                                                         agOtherInfo );
1207       break;
1208     case OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_TMO:
1209       itdssOpenCnxErrorItNexusLossOpenTmoHandler( agRoot,
1210                                                   agIORequest,
1211                                                   agIOStatus,
1212                                                   agIOInfoLen,
1213                                                   agParam,
1214                                                   agOtherInfo );
1215       break;
1216     case OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_NO_DEST:
1217       itdssOpenCnxErrorItNexusLossNoDestHandler( agRoot,
1218                                                  agIORequest,
1219                                                  agIOStatus,
1220                                                  agIOInfoLen,
1221                                                  agParam,
1222                                                  agOtherInfo );
1223       break;
1224     case OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_COLLIDE:
1225       itdssOpenCnxErrorItNexusLossOpenCollideHandler( agRoot,
1226                                                       agIORequest,
1227                                                       agIOStatus,
1228                                                       agIOInfoLen,
1229                                                       agParam,
1230                                                       agOtherInfo );
1231       break;
1232     case OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_PATHWAY_BLOCKED:
1233       itdssOpenCnxErrorItNexusLossOpenPathwayBlockedHandler( agRoot,
1234                                                              agIORequest,
1235                                                              agIOStatus,
1236                                                              agIOInfoLen,
1237                                                              agParam,
1238                                                              agOtherInfo );
1239       break;
1240       // encryption IO error handling
1241     case OSSA_IO_XFR_ERROR_DEK_KEY_CACHE_MISS:
1242     case OSSA_IO_XFR_ERROR_DEK_KEY_TAG_MISMATCH:
1243     case OSSA_IO_XFR_ERROR_CIPHER_MODE_INVALID:
1244     case OSSA_IO_XFR_ERROR_DEK_IV_MISMATCH:
1245     case OSSA_IO_XFR_ERROR_DEK_RAM_INTERFACE_ERROR:
1246     case OSSA_IO_XFR_ERROR_INTERNAL_RAM:
1247     case OSSA_IO_XFR_ERROR_DEK_INDEX_OUT_OF_BOUNDS:
1248       itdssEncryptionHandler( agRoot,
1249                               agIORequest,
1250                               agIOStatus,
1251                               agIOInfoLen,
1252                               agParam,
1253                               agOtherInfo );
1254       break;
1255
1256     /* DIF IO error handling */
1257     case OSSA_IO_XFR_ERROR_DIF_MISMATCH:
1258     case OSSA_IO_XFR_ERROR_DIF_APPLICATION_TAG_MISMATCH:
1259     case OSSA_IO_XFR_ERROR_DIF_REFERENCE_TAG_MISMATCH:
1260     case OSSA_IO_XFR_ERROR_DIF_CRC_MISMATCH:
1261       itdssDifHandler( agRoot,
1262                        agIORequest,
1263                        agIOStatus,
1264                        agIOInfoLen,
1265                        agParam,
1266                        agOtherInfo );
1267       break;
1268     case OSSA_MPI_ERR_IO_RESOURCE_UNAVAILABLE:
1269       itdssIOResourceUnavailableHandler( agRoot,
1270                                          agIORequest,
1271                                          agIOStatus,
1272                                          agIOInfoLen,
1273                                          agParam,
1274                                          agOtherInfo );
1275       break;
1276     case OSSA_MPI_IO_RQE_BUSY_FULL:
1277       itdssIORQEBusyFullHandler( agRoot,
1278                                  agIORequest,
1279                                  agIOStatus,
1280                                  agIOInfoLen,
1281                                  agParam,
1282                                  agOtherInfo );
1283       break;
1284     case OSSA_IO_XFR_ERROR_INVALID_SSP_RSP_FRAME:
1285       itdssXferErrorInvalidSSPRspFrameHandler( agRoot,
1286                                                agIORequest,
1287                                                agIOStatus,
1288                                                agIOInfoLen,
1289                                                agParam,
1290                                                agOtherInfo );
1291       break;
1292     case OSSA_IO_XFER_ERR_EOB_DATA_OVERRUN:
1293       itdssXferErrorEOBDataOverrunHandler( agRoot,
1294                                            agIORequest,
1295                                            agIOStatus,
1296                                            agIOInfoLen,
1297                                            agParam,
1298                                            agOtherInfo );
1299       break;
1300     case OSSA_IO_OPEN_CNX_ERROR_OPEN_PREEMPTED:
1301       itdssOpenCnxErrorOpenPreemptedHandler( agRoot,
1302                                              agIORequest,
1303                                              agIOStatus,
1304                                              agIOInfoLen,
1305                                              agParam,
1306                                              agOtherInfo );
1307       break;
1308     default:
1309       TI_DBG1( ("itdssIOCompleted: Unknown agIOStatus 0x%x\n",agIOStatus) );
1310       itdssIODefaultHandler( agRoot,
1311                              agIORequest,
1312                              agIOStatus,
1313                              agIOInfoLen,
1314                              agParam,
1315                              agOtherInfo );
1316       break;
1317     }
1318   }
1319   return;
1320 }
1321
1322 #ifdef TD_DISCOVER
1323 /*****************************************************************************
1324 *!  \brief  itdssSMPCompleted
1325 *
1326 *  Purpose: This routine is called to complete an SMP request previously
1327 *           issued to the LL Layer in saSMPStart().
1328 *
1329 *   \param  agRoot:         Pointer to driver Instance.
1330 *   \param  agIORequest:    Pointer to the I/O Request data structure for
1331 *                           this I/O.
1332 *   \param  agIOStatus:     Status of I/O just completed.
1333 *   \param  agIOInfoLen:    Length of the I/O information associated with this
1334 *                           I/O request
1335 *   \param   agFrameHandle  A Handle used to refer to the response frame
1336 *
1337 *   \return:                None
1338 *
1339 *   \note - This is a initiator specific function called by the jump table.
1340 *
1341 *****************************************************************************/
1342 osGLOBAL void
1343 itdssSMPCompleted (
1344                    agsaRoot_t            *agRoot,
1345                    agsaIORequest_t       *agIORequest,
1346                    bit32                 agIOStatus,
1347                    bit32                 agIOInfoLen,
1348                    agsaFrameHandle_t     agFrameHandle
1349                    )
1350 {
1351   tdsaRootOsData_t          *osData = (tdsaRootOsData_t *)agRoot->osData;
1352   tiRoot_t                  *tiRoot = (tiRoot_t *)osData->tiRoot;
1353 #ifdef REMOVED
1354   tdsaRoot_t                *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData;
1355   tdsaContext_t             *tdsaAllShared = (tdsaContext_t *)&(tdsaRoot->tdsaAllShared);
1356 #endif
1357   tdssSMPRequestBody_t      *tdSMPRequestBody;
1358   agsaSASRequestBody_t      *agSASRequestBody;
1359   agsaSMPFrame_t            *agSMPFrame;
1360   tdsaDeviceData_t          *oneDeviceData;
1361   tiIORequest_t             *CurrentTaskTag;
1362   tdsaPortContext_t         *onePortContext;
1363   tdsaPortContext_t         *oldonePortContext;
1364   smpReqPhyControl_t        *smpPhyControlReq;
1365   bit8                      smpHeader[4];
1366   tdssSMPFrameHeader_t      *tdSMPFrameHeader;
1367   bit8                      *tdSMPPayload;
1368   agsaDevHandle_t           *agDevHandle;
1369   bit32                     status;
1370 #ifndef DIRECT_SMP
1371   tdssSMPFrameHeader_t      *tdRequestSMPFrameHeader;
1372   bit8                      smpRequestHeader[4];
1373 #endif
1374   bit8                      SMPRequestFunction;
1375
1376   TI_DBG3(("itdssSMPCompleted: start\n"));
1377
1378
1379   tdSMPRequestBody = (tdssSMPRequestBody_t *)agIORequest->osData;
1380   CurrentTaskTag  = tdSMPRequestBody->CurrentTaskTag;
1381
1382   oneDeviceData = tdSMPRequestBody->tdDevice;
1383   onePortContext = oneDeviceData->tdPortContext;
1384   agDevHandle = oneDeviceData->agDevHandle;
1385
1386
1387   agSASRequestBody = &(tdSMPRequestBody->agSASRequestBody);
1388   agSMPFrame = &(agSASRequestBody->smpFrame);
1389
1390 #ifdef DIRECT_SMP
1391   SMPRequestFunction = tdSMPRequestBody->smpPayload[1];
1392 #else
1393   saFrameReadBlock(agRoot, tdSMPRequestBody->IndirectSMPResp, 0, smpRequestHeader, 4);
1394   tdRequestSMPFrameHeader = (tdssSMPFrameHeader_t *)smpRequestHeader;
1395   SMPRequestFunction = tdRequestSMPFrameHeader->smpFunction;
1396 #endif
1397
1398   TI_DBG3(("itdssSMPCompleted: agIORequest %p\n", agIORequest));
1399   TI_DBG3(("itdssSMPCompleted: SMPRequestbody %p\n", tdSMPRequestBody));
1400
1401   if (onePortContext != agNULL)
1402   {
1403     TI_DBG3(("itdssSMPCompleted: pid %d\n", onePortContext->id));
1404   }
1405   else
1406   {
1407     TI_DBG1(("itdssSMPCompleted: Wrong!!! onePortContext is NULL\n"));
1408     ostiFreeMemory(
1409                  tiRoot,
1410                  tdSMPRequestBody->osMemHandle,
1411                  sizeof(tdssSMPRequestBody_t)
1412                  );
1413 #ifndef DIRECT_SMP
1414     ostiFreeMemory(
1415                  tiRoot,
1416                  tdSMPRequestBody->IndirectSMPReqosMemHandle,
1417                  tdSMPRequestBody->IndirectSMPReqLen
1418                  );
1419     ostiFreeMemory(
1420                  tiRoot,
1421                  tdSMPRequestBody->IndirectSMPResposMemHandle,
1422                  tdSMPRequestBody->IndirectSMPRespLen
1423                  );
1424 #endif
1425     return;
1426   }
1427
1428   oldonePortContext = tdSMPRequestBody->tdPortContext;
1429   if (oldonePortContext != agNULL)
1430   {
1431     TI_DBG3(("itdssSMPCompleted: old pid %d\n", oldonePortContext->id));
1432   }
1433   else
1434   {
1435     TI_DBG1(("itdssSMPCompleted: Wrong!!! oldonePortContext is NULL\n"));
1436     ostiFreeMemory(
1437                  tiRoot,
1438                  tdSMPRequestBody->osMemHandle,
1439                  sizeof(tdssSMPRequestBody_t)
1440                  );
1441 #ifndef DIRECT_SMP
1442     ostiFreeMemory(
1443                  tiRoot,
1444                  tdSMPRequestBody->IndirectSMPReqosMemHandle,
1445                  tdSMPRequestBody->IndirectSMPReqLen
1446                  );
1447     ostiFreeMemory(
1448                  tiRoot,
1449                  tdSMPRequestBody->IndirectSMPResposMemHandle,
1450                  tdSMPRequestBody->IndirectSMPRespLen
1451                  );
1452 #endif
1453     return;
1454   }
1455
1456
1457   /* decrement the number of pending SMP */
1458   onePortContext->discovery.pendingSMP--;
1459
1460   /* for port invalid case;
1461      full discovery -> full discovery; incremental discovery -> full discovery
1462    */
1463   if (onePortContext != oldonePortContext)
1464   {
1465     TI_DBG1(("itdssSMPCompleted: portcontext has changed!!!\n"));
1466     if (SMPRequestFunction == SMP_REPORT_GENERAL || SMPRequestFunction == SMP_DISCOVER ||
1467         SMPRequestFunction == SMP_REPORT_PHY_SATA ||
1468         SMPRequestFunction == SMP_CONFIGURE_ROUTING_INFORMATION )
1469     {
1470       /* stop SMP timer */
1471       if (onePortContext->discovery.DiscoverySMPTimer.timerRunning == agTRUE)
1472       {
1473         tdsaKillTimer(
1474                       tiRoot,
1475                       &(onePortContext->discovery.DiscoverySMPTimer)
1476                      );
1477       }
1478       if (oldonePortContext->discovery.DiscoverySMPTimer.timerRunning == agTRUE)
1479       {
1480         tdsaKillTimer(
1481                       tiRoot,
1482                       &(oldonePortContext->discovery.DiscoverySMPTimer)
1483                      );
1484       }
1485     }
1486
1487     /* clean up expanders data strucures; move to free exp when device is cleaned */
1488     tdsaCleanAllExp(tiRoot, oldonePortContext);
1489     /* remove devices */
1490     tdssInternalRemovals(oldonePortContext->agRoot,
1491                          oldonePortContext
1492                          );
1493
1494     ostiFreeMemory(
1495                  tiRoot,
1496                  tdSMPRequestBody->osMemHandle,
1497                  sizeof(tdssSMPRequestBody_t)
1498                  );
1499 #ifndef DIRECT_SMP
1500     ostiFreeMemory(
1501                  tiRoot,
1502                  tdSMPRequestBody->IndirectSMPReqosMemHandle,
1503                  tdSMPRequestBody->IndirectSMPReqLen
1504                  );
1505     ostiFreeMemory(
1506                  tiRoot,
1507                  tdSMPRequestBody->IndirectSMPResposMemHandle,
1508                  tdSMPRequestBody->IndirectSMPRespLen
1509                  );
1510 #endif
1511     return;
1512   }
1513
1514   if (onePortContext->valid == agFALSE)
1515   {
1516     if (SMPRequestFunction == SMP_REPORT_GENERAL || SMPRequestFunction == SMP_DISCOVER ||
1517         SMPRequestFunction == SMP_REPORT_PHY_SATA ||
1518         SMPRequestFunction == SMP_CONFIGURE_ROUTING_INFORMATION )
1519     {
1520       /* stop SMP timer */
1521       if (onePortContext->discovery.DiscoverySMPTimer.timerRunning == agTRUE)
1522       {
1523         tdsaKillTimer(
1524                       tiRoot,
1525                       &(onePortContext->discovery.DiscoverySMPTimer)
1526                       );
1527       }
1528       if (oldonePortContext->discovery.DiscoverySMPTimer.timerRunning == agTRUE)
1529       {
1530         tdsaKillTimer(
1531                       tiRoot,
1532                       &(oldonePortContext->discovery.DiscoverySMPTimer)
1533                       );
1534       }
1535     }
1536
1537     if (onePortContext->discovery.pendingSMP == 0)
1538     {
1539       TI_DBG1(("itdssSMPCompleted: aborting discovery\n"));
1540       tdsaSASDiscoverAbort(tiRoot, onePortContext);
1541     }
1542     else
1543     {
1544       TI_DBG1(("itdssSMPCompleted: not yet abort; non zero pendingSMP %d\n", onePortContext->discovery.pendingSMP));
1545     }
1546     ostiFreeMemory(
1547                  tiRoot,
1548                  tdSMPRequestBody->osMemHandle,
1549                  sizeof(tdssSMPRequestBody_t)
1550                  );
1551 #ifndef DIRECT_SMP
1552     ostiFreeMemory(
1553                  tiRoot,
1554                  tdSMPRequestBody->IndirectSMPReqosMemHandle,
1555                  tdSMPRequestBody->IndirectSMPReqLen
1556                  );
1557     ostiFreeMemory(
1558                  tiRoot,
1559                  tdSMPRequestBody->IndirectSMPResposMemHandle,
1560                  tdSMPRequestBody->IndirectSMPRespLen
1561                  );
1562 #endif
1563     return;
1564   }
1565
1566
1567   if (SMPRequestFunction == SMP_REPORT_GENERAL || SMPRequestFunction == SMP_DISCOVER ||
1568       SMPRequestFunction == SMP_REPORT_PHY_SATA ||
1569       SMPRequestFunction == SMP_CONFIGURE_ROUTING_INFORMATION )
1570   {
1571     /* stop SMP timer */
1572     if (onePortContext->discovery.DiscoverySMPTimer.timerRunning == agTRUE)
1573     {
1574       tdsaKillTimer(
1575                     tiRoot,
1576                     &(onePortContext->discovery.DiscoverySMPTimer)
1577                     );
1578     }
1579     if (oldonePortContext->discovery.DiscoverySMPTimer.timerRunning == agTRUE)
1580     {
1581       tdsaKillTimer(
1582                     tiRoot,
1583                     &(oldonePortContext->discovery.DiscoverySMPTimer)
1584                     );
1585     }
1586   }
1587
1588   /* the host as of 4/16/08 does not use indirect SMP. So, check only OSSA_IO_SUCCESS status*/
1589   if (agIOStatus == OSSA_IO_SUCCESS)
1590   {
1591     //tdhexdump("itdssSMPCompleted", (bit8*)agFrameHandle, agIOInfoLen);
1592     /* parsing SMP payload */
1593 #ifdef DIRECT_SMP
1594     saFrameReadBlock(agRoot, agFrameHandle, 0, smpHeader, 4);
1595 #else
1596     saFrameReadBlock(agRoot, tdSMPRequestBody->IndirectSMPResp, 0, smpHeader, 4);
1597 #endif
1598     tdSMPFrameHeader = (tdssSMPFrameHeader_t *)smpHeader;
1599
1600     /* SMP function dependent payload */
1601     switch (tdSMPFrameHeader->smpFunction)
1602     {
1603     case SMP_REPORT_GENERAL:
1604       TI_DBG3(("itdssSMPCompleted: report general\n"));
1605       if (agIOInfoLen != sizeof(smpRespReportGeneral_t) + 4 &&
1606           tdSMPFrameHeader->smpFunctionResult == SMP_FUNCTION_ACCEPTED)
1607       {
1608         TI_DBG1(("itdssSMPCompleted: mismatch len agIOInfoLen 0x%x 0x%x\n", agIOInfoLen, (unsigned int)sizeof(smpRespReportGeneral_t) + 4));
1609         tdsaSASDiscoverDone(tiRoot, onePortContext, tiError);
1610         ostiFreeMemory(
1611                        tiRoot,
1612                        tdSMPRequestBody->osMemHandle,
1613                        sizeof(tdssSMPRequestBody_t)
1614                       );
1615 #ifndef DIRECT_SMP
1616         ostiFreeMemory(
1617                        tiRoot,
1618                        tdSMPRequestBody->IndirectSMPReqosMemHandle,
1619                        tdSMPRequestBody->IndirectSMPReqLen
1620                       );
1621         ostiFreeMemory(
1622                        tiRoot,
1623                        tdSMPRequestBody->IndirectSMPResposMemHandle,
1624                        tdSMPRequestBody->IndirectSMPRespLen
1625                       );
1626 #endif
1627         return;
1628       }
1629       tdsaReportGeneralRespRcvd(
1630                                 tiRoot,
1631                                 agRoot,
1632                                 agIORequest,
1633                                 oneDeviceData,
1634                                 tdSMPFrameHeader,
1635                                 agFrameHandle
1636                                 );
1637
1638       break;
1639     case SMP_DISCOVER:
1640       TI_DBG3(("itdssSMPCompleted: discover\n"));
1641       if (agIOInfoLen != sizeof(smpRespDiscover_t) + 4 &&
1642           tdSMPFrameHeader->smpFunctionResult == SMP_FUNCTION_ACCEPTED)
1643       {
1644         TI_DBG1(("itdssSMPCompleted: mismatch len agIOInfoLen 0x%x 0x%x\n", agIOInfoLen, (unsigned int)sizeof(smpRespDiscover_t) + 4));
1645         tdsaSASDiscoverDone(tiRoot, onePortContext, tiError);
1646         ostiFreeMemory(
1647                        tiRoot,
1648                        tdSMPRequestBody->osMemHandle,
1649                        sizeof(tdssSMPRequestBody_t)
1650                       );
1651 #ifndef DIRECT_SMP
1652         ostiFreeMemory(
1653                        tiRoot,
1654                        tdSMPRequestBody->IndirectSMPReqosMemHandle,
1655                        tdSMPRequestBody->IndirectSMPReqLen
1656                       );
1657         ostiFreeMemory(
1658                        tiRoot,
1659                        tdSMPRequestBody->IndirectSMPResposMemHandle,
1660                        tdSMPRequestBody->IndirectSMPRespLen
1661                       );
1662 #endif
1663         return;
1664       }
1665       tdsaDiscoverRespRcvd(
1666                            tiRoot,
1667                            agRoot,
1668                            agIORequest,
1669                            oneDeviceData,
1670                            tdSMPFrameHeader,
1671                            agFrameHandle
1672                            );
1673       break;
1674     case SMP_REPORT_PHY_SATA:
1675       TI_DBG3(("itdssSMPCompleted: report phy sata\n"));
1676       if (agIOInfoLen != sizeof(smpRespReportPhySata_t) + 4 &&
1677           tdSMPFrameHeader->smpFunctionResult == SMP_FUNCTION_ACCEPTED)
1678       {
1679         TI_DBG1(("itdssSMPCompleted: mismatch len agIOInfoLen 0x%x 0x%x\n", agIOInfoLen, (unsigned int)sizeof(smpRespReportPhySata_t) + 4));
1680         tdsaSATADiscoverDone(tiRoot, onePortContext, tiError);
1681         ostiFreeMemory(
1682                        tiRoot,
1683                        tdSMPRequestBody->osMemHandle,
1684                        sizeof(tdssSMPRequestBody_t)
1685                       );
1686 #ifndef DIRECT_SMP
1687         ostiFreeMemory(
1688                        tiRoot,
1689                        tdSMPRequestBody->IndirectSMPReqosMemHandle,
1690                        tdSMPRequestBody->IndirectSMPReqLen
1691                       );
1692         ostiFreeMemory(
1693                        tiRoot,
1694                        tdSMPRequestBody->IndirectSMPResposMemHandle,
1695                        tdSMPRequestBody->IndirectSMPRespLen
1696                       );
1697 #endif
1698         return;
1699       }
1700       tdsaReportPhySataRcvd(
1701                             tiRoot,
1702                             agRoot,
1703                             agIORequest,
1704                             oneDeviceData,
1705                             tdSMPFrameHeader,
1706                             agFrameHandle
1707                             );
1708       break;
1709     case SMP_CONFIGURE_ROUTING_INFORMATION:
1710       TI_DBG1(("itdssSMPCompleted: configure routing information\n"));
1711       if (agIOInfoLen != 4 &&
1712           tdSMPFrameHeader->smpFunctionResult == SMP_FUNCTION_ACCEPTED)
1713       {
1714         TI_DBG1(("itdssSMPCompleted: mismatch len agIOInfoLen 0x%x 0x%x\n", agIOInfoLen, 4));
1715         tdsaSASDiscoverDone(tiRoot, onePortContext, tiError);
1716         ostiFreeMemory(
1717                        tiRoot,
1718                        tdSMPRequestBody->osMemHandle,
1719                        sizeof(tdssSMPRequestBody_t)
1720                       );
1721 #ifndef DIRECT_SMP
1722         ostiFreeMemory(
1723                        tiRoot,
1724                        tdSMPRequestBody->IndirectSMPReqosMemHandle,
1725                        tdSMPRequestBody->IndirectSMPReqLen
1726                       );
1727         ostiFreeMemory(
1728                        tiRoot,
1729                        tdSMPRequestBody->IndirectSMPResposMemHandle,
1730                        tdSMPRequestBody->IndirectSMPRespLen
1731                       );
1732 #endif
1733         return;
1734       }
1735       tdsaConfigRoutingInfoRespRcvd(
1736                                     tiRoot,
1737                                     agRoot,
1738                                     agIORequest,
1739                                     oneDeviceData,
1740                                     tdSMPFrameHeader,
1741                                     agFrameHandle
1742                                     );
1743
1744       break;
1745     case SMP_PHY_CONTROL:
1746       TI_DBG3(("itdssSMPCompleted: phy control\n"));
1747       if (agIOInfoLen != 4 &&
1748           tdSMPFrameHeader->smpFunctionResult == SMP_FUNCTION_ACCEPTED) /*zero length is expected */
1749       {
1750         TI_DBG1(("itdssSMPCompleted: mismatch len agIOInfoLen 0x%x 0x%x\n", agIOInfoLen, 4));
1751         tdsaSASDiscoverDone(tiRoot, onePortContext, tiError);
1752         ostiFreeMemory(
1753                        tiRoot,
1754                        tdSMPRequestBody->osMemHandle,
1755                        sizeof(tdssSMPRequestBody_t)
1756                       );
1757 #ifndef DIRECT_SMP
1758         ostiFreeMemory(
1759                        tiRoot,
1760                        tdSMPRequestBody->IndirectSMPReqosMemHandle,
1761                        tdSMPRequestBody->IndirectSMPReqLen
1762                       );
1763         ostiFreeMemory(
1764                        tiRoot,
1765                        tdSMPRequestBody->IndirectSMPResposMemHandle,
1766                        tdSMPRequestBody->IndirectSMPRespLen
1767                       );
1768 #endif
1769         return;
1770       }
1771       tdsaPhyControlRespRcvd(
1772                              tiRoot,
1773                              agRoot,
1774                              agIORequest,
1775                              oneDeviceData,
1776                              tdSMPFrameHeader,
1777                              agFrameHandle,
1778                              CurrentTaskTag
1779                              );
1780
1781       break;
1782 #ifdef REMOVED
1783 //temp for testing
1784      case SMP_REPORT_MANUFACTURE_INFORMATION:
1785       TI_DBG1(("itdssSMPCompleted: REPORT_MANUFACTURE_INFORMATION\n"));
1786       if (agIOInfoLen != sizeof(smpRespReportManufactureInfo_t) + 4 &&
1787           tdSMPFrameHeader->smpFunctionResult == SMP_FUNCTION_ACCEPTED) /*zero length is expected */
1788       {
1789         TI_DBG1(("itdssSMPCompleted: mismatch len agIOInfoLen 0x%x 0x%x\n", agIOInfoLen, 4));
1790         tdsaSASDiscoverDone(tiRoot, onePortContext, tiError);
1791         ostiFreeMemory(
1792                        tiRoot,
1793                        tdSMPRequestBody->osMemHandle,
1794                        sizeof(tdssSMPRequestBody_t)
1795                       );
1796 #ifndef DIRECT_SMP
1797         ostiFreeMemory(
1798                        tiRoot,
1799                        tdSMPRequestBody->IndirectSMPReqosMemHandle,
1800                        tdSMPRequestBody->IndirectSMPReqLen
1801                       );
1802         ostiFreeMemory(
1803                        tiRoot,
1804                        tdSMPRequestBody->IndirectSMPResposMemHandle,
1805                        tdSMPRequestBody->IndirectSMPRespLen
1806                       );
1807 #endif
1808         return;
1809       }
1810       tdsaReportManInfoRespRcvd(
1811                                 tiRoot,
1812                                 agRoot,
1813                                 oneDeviceData,
1814                                 tdSMPFrameHeader,
1815                                 agFrameHandle
1816                                 );
1817
1818        break;
1819 //end temp for testing
1820 #endif
1821     case SMP_REPORT_ROUTING_INFORMATION:
1822     case SMP_REPORT_PHY_ERROR_LOG:
1823     case SMP_PHY_TEST_FUNCTION:
1824     case SMP_REPORT_MANUFACTURE_INFORMATION:
1825     case SMP_READ_GPIO_REGISTER:
1826     case SMP_WRITE_GPIO_REGISTER:
1827     default:
1828       TI_DBG1(("itdssSMPCompleted: wrong SMP function 0x%x\n", tdSMPFrameHeader->smpFunction));
1829       TI_DBG1(("itdssSMPCompleted: smpFrameType 0x%x\n", tdSMPFrameHeader->smpFrameType));
1830       TI_DBG1(("itdssSMPCompleted: smpFunctionResult 0x%x\n", tdSMPFrameHeader->smpFunctionResult));
1831       TI_DBG1(("itdssSMPCompleted: smpReserved 0x%x\n", tdSMPFrameHeader->smpReserved));
1832       tdhexdump("itdssSMPCompleted: SMP payload", (bit8 *)agFrameHandle, agIOInfoLen);
1833       break;
1834     }
1835   }
1836   else if (agIOStatus == OSSA_IO_ABORTED || agIOStatus == OSSA_IO_INVALID_LENGTH)
1837   {
1838     /* no retry this case */
1839     TI_DBG1(("itdssSMPCompleted: OSSA_IO_ABORTED\n"));
1840   }
1841   else if (agIOStatus == OSSA_IO_ERROR_INTERNAL_SMP_RESOURCE)
1842   {
1843     TI_DBG1(("itdssSMPCompleted: OSSA_IO_ERROR_INTERNAL_SMP_RESOURCE\n"));
1844     saFrameReadBlock(agRoot, agFrameHandle, 0, smpHeader, 4);
1845     tdSMPFrameHeader = (tdssSMPFrameHeader_t *)smpHeader;
1846
1847     status = saSMPStart(
1848                agRoot,
1849                agIORequest,
1850                tdSMPRequestBody->queueNumber, //tdsaAllShared->SMPQNum, //tdsaRotateQnumber(tiRoot, oneDeviceData),
1851                agDevHandle,
1852                AGSA_SMP_INIT_REQ,
1853                agSASRequestBody,
1854                &ossaSMPCompleted
1855                );
1856
1857     if (status == AGSA_RC_SUCCESS)
1858     {
1859       /* increment the number of pending SMP */
1860       onePortContext->discovery.pendingSMP++;
1861       if (SMPRequestFunction == SMP_REPORT_GENERAL || SMPRequestFunction == SMP_DISCOVER ||
1862           SMPRequestFunction == SMP_REPORT_PHY_SATA ||
1863           SMPRequestFunction == SMP_CONFIGURE_ROUTING_INFORMATION )
1864       {
1865         /* start discovery-related SMP timer */
1866         tdsaDiscoverySMPTimer(tiRoot, onePortContext, (bit32)(tdSMPFrameHeader->smpFunction), tdSMPRequestBody);
1867       }
1868       return;
1869     }
1870     else if (status == AGSA_RC_BUSY)
1871     {
1872       if (tdSMPFrameHeader->smpFunction == SMP_REPORT_GENERAL ||
1873           tdSMPFrameHeader->smpFunction == SMP_DISCOVER ||
1874           tdSMPFrameHeader->smpFunction == SMP_REPORT_PHY_SATA ||
1875           tdSMPFrameHeader->smpFunction == SMP_CONFIGURE_ROUTING_INFORMATION )
1876       {
1877         tdsaSMPBusyTimer(tiRoot, onePortContext, oneDeviceData, tdSMPRequestBody);
1878       }
1879       else if (tdSMPFrameHeader->smpFunction == SMP_PHY_CONTROL)
1880       {
1881         /* For taskmanagement SMP, let's fail task management failure */
1882         tdsaPhyControlFailureRespRcvd(
1883                                       tiRoot,
1884                                       agRoot,
1885                                       oneDeviceData,
1886                                       tdSMPFrameHeader,
1887                                       agFrameHandle,
1888                                       CurrentTaskTag
1889                                       );
1890       }
1891       else
1892       {
1893       }
1894     }
1895     else /* AGSA_RC_FAILURE */
1896     {
1897       if (tdSMPFrameHeader->smpFunction == SMP_REPORT_GENERAL ||
1898           tdSMPFrameHeader->smpFunction == SMP_DISCOVER ||
1899           tdSMPFrameHeader->smpFunction == SMP_REPORT_PHY_SATA ||
1900           tdSMPFrameHeader->smpFunction == SMP_CONFIGURE_ROUTING_INFORMATION )
1901       {
1902         tdsaSASDiscoverDone(tiRoot, onePortContext, tiError);
1903       }
1904       else if (tdSMPFrameHeader->smpFunction == SMP_PHY_CONTROL)
1905       {
1906         /* task management failure */
1907         tdsaPhyControlFailureRespRcvd(
1908                                       tiRoot,
1909                                       agRoot,
1910                                       oneDeviceData,
1911                                       tdSMPFrameHeader,
1912                                       agFrameHandle,
1913                                       CurrentTaskTag
1914                                       );
1915       }
1916       else
1917       {
1918       }
1919     }
1920   }
1921   else
1922   {
1923     if (tdSMPRequestBody->retries < SMP_RETRIES) /* 5 */
1924     {
1925       /* retry the SMP again */
1926       TI_DBG1(("itdssSMPCompleted: failed! but retries %d agIOStatus 0x%x %d agIOInfoLen %d\n",
1927                tdSMPRequestBody->retries, agIOStatus, agIOStatus, agIOInfoLen));
1928       if (agIOStatus == OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS ||
1929           agIOStatus == OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_RETRY_BACKOFF_THRESHOLD_REACHED ||
1930           agIOStatus == OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_TMO ||
1931           agIOStatus == OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_NO_DEST ||
1932           agIOStatus == OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_COLLIDE ||
1933           agIOStatus == OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_PATHWAY_BLOCKED ||
1934           agIOStatus == OSSA_IO_DS_NON_OPERATIONAL
1935          )
1936       {
1937         saSetDeviceState(agRoot, agNULL, tdSMPRequestBody->queueNumber, agDevHandle, SA_DS_OPERATIONAL);
1938       }
1939       saSMPStart(
1940                  agRoot,
1941                  agIORequest,
1942                  tdSMPRequestBody->queueNumber, //tdsaAllShared->SMPQNum, //tdsaRotateQnumber(tiRoot, oneDeviceData),
1943                  agDevHandle,
1944                  AGSA_SMP_INIT_REQ,
1945                  agSASRequestBody,
1946                  &ossaSMPCompleted
1947                  );
1948       /* increment the number of pending SMP */
1949       onePortContext->discovery.pendingSMP++;
1950       tdSMPRequestBody->retries++;
1951       return;
1952     }
1953     else
1954     {
1955       tdSMPFrameHeader = (tdssSMPFrameHeader_t *)agSMPFrame->outFrameBuf;
1956       tdSMPPayload = (bit8 *)agSMPFrame->outFrameBuf + 4;
1957       TI_DBG1(("itdssSMPCompleted: failed! no more retry! agIOStatus 0x%x %d\n", agIOStatus, agIOStatus));
1958       if (agIOStatus == OSSA_IO_DS_NON_OPERATIONAL)
1959       {
1960         TI_DBG1(("itdssSMPCompleted: failed! agIOStatus is OSSA_IO_DS_NON_OPERATIONAL\n"));
1961       }
1962
1963       if (agIOStatus == OSSA_IO_DS_IN_RECOVERY)
1964       {
1965         TI_DBG1(("itdssSMPCompleted: failed! agIOStatus is OSSA_IO_DS_IN_RECOVERY\n"));
1966       }
1967
1968       if (tdSMPFrameHeader->smpFunction == SMP_REPORT_GENERAL ||
1969           tdSMPFrameHeader->smpFunction == SMP_DISCOVER ||
1970           tdSMPFrameHeader->smpFunction == SMP_REPORT_PHY_SATA ||
1971           tdSMPFrameHeader->smpFunction == SMP_CONFIGURE_ROUTING_INFORMATION
1972          )
1973       {
1974         /* discovery failure */
1975         TI_DBG1(("itdssSMPCompleted: SMP function 0x%x\n", tdSMPFrameHeader->smpFunction));
1976         TI_DBG1(("itdssSMPCompleted: discover done with error\n"));
1977         tdsaSASDiscoverDone(tiRoot, onePortContext, tiError);
1978       }
1979       else if (tdSMPFrameHeader->smpFunction == SMP_PHY_CONTROL)
1980       {
1981         TI_DBG1(("itdssSMPCompleted: SMP_PHY_CONTROL\n"));
1982         smpPhyControlReq = (smpReqPhyControl_t *)tdSMPPayload;
1983         if (smpPhyControlReq->phyOperation == SMP_PHY_CONTROL_CLEAR_AFFILIATION)
1984         {
1985           TI_DBG1(("itdssSMPCompleted: discover done with error\n"));
1986           tdsaSASDiscoverDone(tiRoot, onePortContext, tiError);
1987         }
1988         else if (smpPhyControlReq->phyOperation == SMP_PHY_CONTROL_HARD_RESET ||
1989                  smpPhyControlReq->phyOperation == SMP_PHY_CONTROL_LINK_RESET )
1990         {
1991           TI_DBG1(("itdssSMPCompleted: device reset failed\n"));
1992           if (CurrentTaskTag != agNULL )
1993           {
1994             TI_DBG1(("itdssSMPCompleted: callback to OS layer with failure\n"));
1995             ostiInitiatorEvent( tiRoot,
1996                                 NULL,
1997                                 NULL,
1998                                 tiIntrEventTypeTaskManagement,
1999                                 tiTMFailed,
2000                                 CurrentTaskTag );
2001           }
2002           else
2003           {
2004             /* hard reset was not done with this device */
2005             oneDeviceData->ResetCnt = 0;
2006           }
2007         }
2008         else
2009         {
2010           TI_DBG1(("itdssSMPCompleted: unknown phy operation 0x%x\n", smpPhyControlReq->phyOperation));
2011         }
2012       } /* SMP_PHY_CONTROL */
2013       else
2014       {
2015         TI_DBG1(("itdssSMPCompleted: SMP function 0x%x\n", tdSMPFrameHeader->smpFunction));
2016       }
2017     } /* else */
2018   } /* outer else */
2019
2020   ostiFreeMemory(
2021                  tiRoot,
2022                  tdSMPRequestBody->osMemHandle,
2023                  sizeof(tdssSMPRequestBody_t)
2024                  );
2025 #ifndef DIRECT_SMP
2026   ostiFreeMemory(
2027                  tiRoot,
2028                  tdSMPRequestBody->IndirectSMPReqosMemHandle,
2029                  tdSMPRequestBody->IndirectSMPReqLen
2030                  );
2031   ostiFreeMemory(
2032                  tiRoot,
2033                  tdSMPRequestBody->IndirectSMPResposMemHandle,
2034                  tdSMPRequestBody->IndirectSMPRespLen
2035                  );
2036 #endif
2037
2038
2039   return;
2040 }
2041
2042 #else
2043
2044 osGLOBAL void
2045 itdssSMPCompleted (
2046                    agsaRoot_t            *agRoot,
2047                    agsaIORequest_t       *agIORequest,
2048                    bit32                 agIOStatus,
2049                    bit32                 agIOInfoLen,
2050                    agsaFrameHandle_t     agFrameHandle
2051                    )
2052 {
2053   /* pass the payload to OS layer */
2054   TI_DBG3(("itdssSMPCompleted: start\n"));
2055 }
2056 #endif
2057
2058
2059 /*****************************************************************************
2060 *! \brief itdIoSuccessHandler
2061 *
2062 *  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
2063 *            layer with agIOStatus = OSSA_IO_SUCCESS
2064 *
2065 *  \param  agRoot:            pointer to port instance
2066 *  \param  agIORequest:       pointer to I/O request
2067 *  \param  agIOStatus:        I/O status given by LL layer
2068 *  \param  agIOInfoLen:       lenth of complete SAS RESP frame
2069 *  \param  agParam            A Handle used to refer to the response frame or handle
2070 *                             of abort request
2071 *  \param  agOtherInfo        Residual count
2072 *  \return: None
2073 *
2074 *
2075 *****************************************************************************/
2076 osGLOBAL void
2077 itdssIOSuccessHandler(
2078                       agsaRoot_t           *agRoot,
2079                       agsaIORequest_t      *agIORequest,
2080                       bit32                agIOStatus,
2081                       bit32                agIOInfoLen,
2082                       void                 *agParam,
2083                       bit32                agOtherInfo
2084                       )
2085 {
2086   tdsaRootOsData_t          *osData = (tdsaRootOsData_t *)agRoot->osData;
2087   tiRoot_t                  *tiRoot = (tiRoot_t *)osData->tiRoot;
2088   itdsaIni_t                *Initiator = (itdsaIni_t *)osData->itdsaIni;
2089   tdIORequestBody_t         *tdIORequestBody;
2090   agsaSSPResponseInfoUnit_t agSSPRespIU;
2091   tiSenseData_t             senseData;
2092   bit8                      senseDataPayload[256];
2093   bit8                      respData[128];
2094   bit32                     scsi_status;
2095   bit32                     senseLen;
2096   bit32                     respLen;
2097   bit32                     data_status;
2098   bit32                     i;
2099   tiDeviceHandle_t          *tiDeviceHandle = agNULL;
2100   tdsaDeviceData_t          *oneDeviceData = agNULL;
2101
2102   TI_DBG2(("itdssIOSuccessHandler: start\n"));
2103   TI_DBG2(("itdssIOSuccessHandler: agIOInfoLen %d\n", agIOInfoLen));
2104
2105   tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
2106
2107   tdIORequestBody->ioCompleted = agTRUE;
2108   tdIORequestBody->ioStarted = agFALSE;
2109
2110   /*
2111     agIOInfoLen must be >= sizeof(agsaSSPResponseInfoUnit_t), which is minimum
2112     date length
2113   */
2114   if (agIOInfoLen < sizeof(agsaSSPResponseInfoUnit_t))
2115   {
2116     TI_DBG1(("itdssIOSuccessHandler: First agIOInfoLen does not match!!!\n"));
2117     TI_DBG1(("itdssIOSuccessHandler: First agIOInfoLen 0x%x IU 0x%x\n", agIOInfoLen, (unsigned int)sizeof(agsaSSPResponseInfoUnit_t)));
2118     ostiInitiatorIOCompleted(
2119                              tiRoot,
2120                              tdIORequestBody->tiIORequest, /* tiIORequest */
2121                              tiIOFailed,
2122                              tiDetailOtherError,
2123                              agNULL,
2124                              agTRUE /* intContext; is not being used */
2125                              );
2126     return;
2127   }
2128   /* reads agsaSSPResponseInfoUnit_t */
2129   saFrameReadBlock(agRoot, agParam, 0, &agSSPRespIU, sizeof(agsaSSPResponseInfoUnit_t));
2130
2131   data_status = SA_SSPRESP_GET_DATAPRES(&agSSPRespIU);
2132   scsi_status = agSSPRespIU.status;
2133   /* endianess is invovled here */
2134   senseLen = SA_SSPRESP_GET_SENSEDATALEN(&agSSPRespIU);
2135   respLen = SA_SSPRESP_GET_RESPONSEDATALEN(&agSSPRespIU);
2136
2137   TI_DBG2(("itdssIOSuccessHandler: dataPres=%x\n", data_status));
2138   TI_DBG2(("itdssIOSuccessHandler: scsi status=0x%x, senselen=0x%x resplen 0x%x\n", scsi_status, senseLen, respLen));
2139
2140   /*
2141     sanity check: do not go beyond of agIOInfoLen. if happens, return error
2142     agIOInfoLen >= sizeof(agsaSSPResponseInfoUnit_t) + senseLen + respLen -> OK
2143     because frame must be divisible by 4, so there can be extra padding
2144     agIOInfoLen < sizeof(agsaSSPResponseInfoUnit_t) + senseLen + respLen -> NOT OK
2145   */
2146   if (agIOInfoLen < sizeof(agsaSSPResponseInfoUnit_t) + senseLen + respLen)
2147   {
2148     TI_DBG1(("itdssIOSuccessHandler: Second agIOInfoLen does not match!!!\n"));
2149     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));
2150
2151     ostiInitiatorIOCompleted(
2152                              tiRoot,
2153                              tdIORequestBody->tiIORequest, /* tiIORequest */
2154                              tiIOFailed,
2155                              tiDetailOtherError,
2156                              agNULL,
2157                              agTRUE /* intContext; is not being used */
2158                              );
2159     return;
2160   }
2161
2162   /* reads response data */
2163   saFrameReadBlock(agRoot, agParam,
2164                    sizeof(agsaSSPResponseInfoUnit_t),
2165                    respData, respLen);
2166   /* reads sense data */
2167   saFrameReadBlock(agRoot, agParam,
2168                    sizeof(agsaSSPResponseInfoUnit_t)
2169                    + respLen,
2170                    senseDataPayload, senseLen);
2171
2172   if (data_status == 0)
2173   {
2174     /* NO_DATA */
2175     TI_DBG1(("itdssIOSuccessHandler: no data scsi_status 0x%x\n",scsi_status));
2176
2177     ostiInitiatorIOCompleted(
2178                              tiRoot,
2179                              tdIORequestBody->tiIORequest, /* tiIORequest */
2180                              tiIOSuccess,
2181                              scsi_status,
2182                              agNULL,
2183                              agTRUE /* intContext; is not being used */
2184                              );
2185
2186     return;
2187   }
2188
2189   if (data_status == 1)
2190   {
2191     /* RESPONSE_DATA */
2192     TI_DBG1(("itdssIOSuccessHandler: response data \n"));
2193
2194     ostiInitiatorIOCompleted(
2195                              tiRoot,
2196                              tdIORequestBody->tiIORequest, /* tiIORequest */
2197                              tiIOSuccess,
2198                              0,
2199                              agNULL,
2200                              agTRUE /* intContext; is not being used */
2201                              );
2202     return;
2203   }
2204
2205   if (data_status == 2)
2206   {
2207     /* SENSE_DATA */
2208     TI_DBG2(("itdssIOSuccessHandler: sense data \n"));
2209
2210     senseData.senseData = &senseDataPayload;
2211     senseData.senseLen = MIN(256, senseLen);
2212     /* debugging */
2213     tdhexdump("ResponseIU I", (bit8 *)&agSSPRespIU, sizeof(agsaSSPResponseInfoUnit_t));
2214
2215     tiDeviceHandle = tdIORequestBody->tiDevHandle;
2216     oneDeviceData = (tdsaDeviceData_t *)tiDeviceHandle->tdData;
2217     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),
2218              oneDeviceData->id));
2219     tdhexdump("sense data I", (bit8 *)senseDataPayload, senseLen);
2220 //    tdhexdump("sense data II", (bit8 *)senseData.senseData, senseData.senseLen);
2221
2222     if (senseDataPayload[2] == SCSI_SENSE_KEY_RECOVERED_ERROR)
2223     {
2224       Initiator->SenseKeyCounter.SoftError ++;
2225     }
2226     else if (senseDataPayload[2] == SCSI_SENSE_KEY_NOT_READY)
2227     {
2228       Initiator->SenseKeyCounter.MediumNotReady++;
2229     }
2230     else if (senseDataPayload[2] == SCSI_SENSE_KEY_MEDIUM_ERROR)
2231     {
2232       Initiator->SenseKeyCounter.MediumError++;
2233     }
2234     else if (senseDataPayload[2] == SCSI_SENSE_KEY_HARDWARE_ERROR)
2235     {
2236       Initiator->SenseKeyCounter.HardwareError++;
2237     }
2238     else if (senseDataPayload[2] == SCSI_SENSE_KEY_ILLEGAL_REQUEST)
2239     {
2240       Initiator->SenseKeyCounter.IllegalRequest++;
2241     }
2242     else if (senseDataPayload[2] == SCSI_SENSE_KEY_UNIT_ATTENTION)
2243     {
2244       Initiator->SenseKeyCounter.UnitAttention++;
2245     }
2246     else if (senseDataPayload[2] == SCSI_SENSE_KEY_ABORTED_COMMAND)
2247     {
2248       Initiator->SenseKeyCounter.AbortCommand++;
2249     }
2250     else
2251     {
2252       Initiator->SenseKeyCounter.OtherKeyType++;
2253     }
2254
2255     /* when ASQ and ASCQ 0x04 0x11, does saLocalPhyControl for notify spinup */
2256     if ((senseDataPayload[12] == 0x04 && senseDataPayload[13] == 0x11))
2257     {
2258       TI_DBG2(("itdssIOSuccessHandler: sending notfify spinup\n"));
2259       tiDeviceHandle = tdIORequestBody->tiDevHandle;
2260       oneDeviceData = (tdsaDeviceData_t *)tiDeviceHandle->tdData;
2261       if (oneDeviceData->directlyAttached == agTRUE)
2262       {
2263         for (i=0;i<TD_MAX_NUM_NOTIFY_SPINUP;i++)
2264         {
2265           saLocalPhyControl(agRoot, agNULL, 0, oneDeviceData->phyID, AGSA_PHY_NOTIFY_ENABLE_SPINUP, agNULL);
2266         }
2267       }
2268     }
2269     ostiInitiatorIOCompleted(
2270                              tiRoot,
2271                              /* tiIORequest */
2272                              tdIORequestBody->tiIORequest,
2273                              tiIOSuccess,
2274                              scsi_status,
2275                              &senseData,
2276                              agTRUE /* intContext; is not being used */
2277                              );
2278     return;
2279   }
2280   if (data_status == 3)
2281   {
2282     /* RESERVED */
2283     TI_DBG1(("itdssIOSuccessHandler: reserved wrong!!!\n"));
2284     ostiInitiatorIOCompleted(
2285                              tiRoot,
2286                              tdIORequestBody->tiIORequest, /* tiIORequest */
2287                              tiIOFailed,
2288                              scsi_status,
2289                              agNULL,
2290                              agTRUE /* intContext; is not being used */
2291                              );
2292     return;
2293   }
2294
2295 }
2296
2297 /*****************************************************************************
2298 *! \brief itdssIOAbortedHandler
2299 *
2300 *  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
2301 *            layer with agIOStatus = OSSA_IO_ABORTED
2302 *
2303 *  \param  agRoot:            pointer to port instance
2304 *  \param  agIORequest:       pointer to I/O request
2305 *  \param  agIOStatus:        I/O status given by LL layer
2306 *  \param  agIOInfoLen:       lenth of complete SAS RESP frame
2307 *  \param  agParam            A Handle used to refer to the response frame or handle
2308 *                             of abort request
2309 *  \param  agOtherInfo        Residual count
2310 *  \return: None
2311 *
2312 *
2313 *****************************************************************************/
2314 /* see itdosIOCompleted() and itdinit.c and  itdIoAbortedHandler in itdio.c*/
2315 osGLOBAL void
2316 itdssIOAbortedHandler (
2317                        agsaRoot_t              *agRoot,
2318                        agsaIORequest_t         *agIORequest,
2319                        bit32                   agIOStatus,
2320                        bit32                   agIOInfoLen,
2321                        void                    *agParam,
2322                        bit32                   agOtherInfo
2323                        )
2324 {
2325   tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
2326   tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
2327   bit32                  intContext = osData->IntContext;
2328   tdIORequestBody_t      *tdIORequestBody;
2329   tiDeviceHandle_t       *tiDeviceHandle = agNULL;
2330   tdsaDeviceData_t       *oneDeviceData = agNULL;
2331
2332   TI_DBG2(("itdssIOAbortedHandler: start\n"));
2333   tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
2334
2335   if (agIOStatus != OSSA_IO_ABORTED)
2336   {
2337     TI_DBG1(("itdssIOAbortedHandler: incorrect agIOStatus 0x%x\n", agIOStatus));
2338   }
2339
2340   if (tdIORequestBody == agNULL)
2341   {
2342     TI_DBG1(("itdssIOAbortedHandler: start\n"));
2343     return;
2344   }
2345
2346   if (tdIORequestBody != agNULL)
2347   {
2348     tiDeviceHandle = tdIORequestBody->tiDevHandle;
2349   }
2350   if (tiDeviceHandle != agNULL)
2351   {
2352     oneDeviceData  = (tdsaDeviceData_t *)tiDeviceHandle->tdData;
2353   }
2354   if (oneDeviceData != agNULL)
2355   {
2356     TI_DBG2(("itdssIOAbortedHandler: did %d \n", oneDeviceData->id));
2357   }
2358   else
2359   {
2360     TI_DBG1(("itdssIOAbortedHandler: oneDeviceData is NULL\n"));
2361   }
2362
2363
2364   ostiInitiatorIOCompleted (
2365                             tiRoot,
2366                             tdIORequestBody->tiIORequest,
2367                             tiIOFailed,
2368                             tiDetailAborted,
2369                             agNULL,
2370                             intContext
2371                             );
2372
2373   return;
2374 }
2375
2376 #ifdef REMOVED
2377 /*****************************************************************************
2378 *! \brief itdssIOOverFlowHandler
2379 *
2380 *  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
2381 *            layer with agIOStatus = OSSA_IO_OVERFLOW
2382 *
2383 *  \param  agRoot:            pointer to port instance
2384 *  \param  agIORequest:       pointer to I/O request
2385 *  \param  agIOStatus:        I/O status given by LL layer
2386 *  \param  agIOInfoLen:       lenth of complete SAS RESP frame
2387 *  \param  agParam            A Handle used to refer to the response frame or handle
2388 *                             of abort request
2389 *  \return: None
2390 *
2391 *
2392 *****************************************************************************/
2393 osGLOBAL void
2394 itdssIOOverFlowHandler(
2395                        agsaRoot_t              *agRoot,
2396                        agsaIORequest_t         *agIORequest,
2397                        bit32                   agIOStatus,
2398                        bit32                   agIOInfoLen,
2399                        void                    *agParam
2400                        )
2401 {
2402   tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
2403   tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
2404   bit32                  intContext = osData->IntContext;
2405   tdIORequestBody_t      *tdIORequestBody;
2406
2407   TI_DBG2(("itdssIOOverFlowHandler: start\n"));
2408   TI_DBG2(("itdssIOOverFlowHandler: not transferred byte 0x%x\n", agIOInfoLen));
2409
2410   tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
2411
2412   ostiInitiatorIOCompleted (
2413                             tiRoot,
2414                             tdIORequestBody->tiIORequest,
2415                             tiIOOverRun,
2416                             agIOInfoLen,
2417                             agNULL,
2418                             intContext
2419                             );
2420
2421   return;
2422 }
2423 #endif
2424
2425
2426 /*****************************************************************************
2427 *! \brief itdssIOUnderFlowHandler
2428 *
2429 *  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
2430 *            layer with agIOStatus = OSSA_IO_UNDERFLOW
2431 *
2432 *  \param  agRoot:            pointer to port instance
2433 *  \param  agIORequest:       pointer to I/O request
2434 *  \param  agIOStatus:        I/O status given by LL layer
2435 *  \param  agIOInfoLen:       lenth of complete SAS RESP frame
2436 *  \param  agParam            A Handle used to refer to the response frame or handle
2437 *                             of abort request
2438 *  \param  agOtherInfo        Residual count
2439 *  \return: None
2440 *
2441 *
2442 *****************************************************************************/
2443 osGLOBAL void
2444 itdssIOUnderFlowHandler(
2445                         agsaRoot_t              *agRoot,
2446                         agsaIORequest_t         *agIORequest,
2447                         bit32                   agIOStatus,
2448                         bit32                   agIOInfoLen,
2449                         void                    *agParam,
2450                         bit32                   agOtherInfo
2451                         )
2452 {
2453   tdsaRootOsData_t          *osData = (tdsaRootOsData_t *)agRoot->osData;
2454   tiRoot_t                  *tiRoot = (tiRoot_t *)osData->tiRoot;
2455   bit32                     intContext = osData->IntContext;
2456   tdIORequestBody_t         *tdIORequestBody;
2457
2458   TI_DBG6(("itdssIOUnderFlowHandler: start\n"));
2459   TI_DBG6(("itdssIOUnderFlowHandler: agIOInfoLen 0x%x\n", agIOInfoLen));
2460
2461   tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
2462
2463   ostiInitiatorIOCompleted (
2464                             tiRoot,
2465                             tdIORequestBody->tiIORequest,
2466                             tiIOUnderRun,
2467                             agIOInfoLen,
2468                             agNULL,
2469                             intContext
2470                             );
2471
2472   return;
2473 }
2474
2475 /*****************************************************************************
2476 *! \brief itdssIOFailedHandler
2477 *
2478 *  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
2479 *            layer with agIOStatus = OSSA_IO_FAILED
2480 *
2481 *  \param  agRoot:            pointer to port instance
2482 *  \param  agIORequest:       pointer to I/O request
2483 *  \param  agIOStatus:        I/O status given by LL layer
2484 *  \param  agIOInfoLen:       lenth of complete SAS RESP frame
2485 *  \param  agParam            A Handle used to refer to the response frame or handle
2486 *                             of abort request
2487 *  \param  agOtherInfo        Residual count
2488 *  \return: None
2489 *
2490 *
2491 *****************************************************************************/
2492 osGLOBAL void
2493 itdssIOFailedHandler(
2494                      agsaRoot_t              *agRoot,
2495                      agsaIORequest_t         *agIORequest,
2496                      bit32                   agIOStatus,
2497                      bit32                   agIOInfoLen,
2498                      void                    *agParam,
2499                      bit32                   agOtherInfo
2500                      )
2501 {
2502   tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
2503   tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
2504   bit32                  intContext = osData->IntContext;
2505   tdIORequestBody_t      *tdIORequestBody;
2506
2507   TI_DBG1(("itdssIOFailedHandler: start\n"));
2508
2509   tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
2510
2511   ostiInitiatorIOCompleted (
2512                             tiRoot,
2513                             tdIORequestBody->tiIORequest,
2514                             tiIOFailed,
2515                             tiDetailOtherError,
2516                             agNULL,
2517                             intContext
2518                             );
2519   return;
2520 }
2521
2522 /*****************************************************************************
2523 *! \brief itdssIOAbortResetHandler
2524 *
2525 *  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
2526 *            layer with agIOStatus = OSSA_IO_ABORT_RESET
2527 *
2528 *  \param  agRoot:            pointer to port instance
2529 *  \param  agIORequest:       pointer to I/O request
2530 *  \param  agIOStatus:        I/O status given by LL layer
2531 *  \param  agIOInfoLen:       lenth of complete SAS RESP frame
2532 *  \param  agParam            A Handle used to refer to the response frame or handle
2533 *                             of abort request
2534 *  \param  agOtherInfo        Residual count
2535 *  \return: None
2536 *
2537 *
2538 *****************************************************************************/
2539 osGLOBAL void
2540 itdssIOAbortResetHandler(
2541                          agsaRoot_t              *agRoot,
2542                          agsaIORequest_t         *agIORequest,
2543                          bit32                   agIOStatus,
2544                          bit32                   agIOInfoLen,
2545                          void                    *agParam,
2546                          bit32                   agOtherInfo
2547                          )
2548 {
2549   tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
2550   tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
2551   bit32                  intContext = osData->IntContext;
2552   tdIORequestBody_t      *tdIORequestBody;
2553   TI_DBG2(("itdssIOAbortResetHandler: start\n"));
2554
2555   tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
2556
2557   ostiInitiatorIOCompleted (
2558                             tiRoot,
2559                             tdIORequestBody->tiIORequest,
2560                             tiIOFailed,
2561                             tiDetailAbortReset,
2562                             agNULL,
2563                             intContext
2564                             );
2565
2566
2567   return;
2568 }
2569
2570 /*****************************************************************************
2571 *! \brief itdssIONotValidHandler
2572 *
2573 *  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
2574 *            layer with agIOStatus = OSSA_IO_NOT_VALID
2575 *
2576 *  \param  agRoot:            pointer to port instance
2577 *  \param  agIORequest:       pointer to I/O request
2578 *  \param  agIOStatus:        I/O status given by LL layer
2579 *  \param  agIOInfoLen:       lenth of complete SAS RESP frame
2580 *  \param  agParam            A Handle used to refer to the response frame or handle
2581 *                             of abort request
2582 *  \param  agOtherInfo        Residual count
2583 *  \return: None
2584 *
2585 *
2586 *****************************************************************************/
2587 osGLOBAL void
2588 itdssIONotValidHandler(
2589                        agsaRoot_t           *agRoot,
2590                        agsaIORequest_t      *agIORequest,
2591                        bit32                agIOStatus,
2592                        bit32                agIOInfoLen,
2593                        void                 *agParam,
2594                        bit32                agOtherInfo
2595                        )
2596 {
2597   tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
2598   tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
2599   bit32                  intContext = osData->IntContext;
2600   tdIORequestBody_t      *tdIORequestBody;
2601   TI_DBG2(("itdssIONotValidHandler: start\n"));
2602
2603   tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
2604
2605   ostiInitiatorIOCompleted (
2606                             tiRoot,
2607                             tdIORequestBody->tiIORequest,
2608                             tiIOFailed,
2609                             tiDetailNotValid,
2610                             agNULL,
2611                             intContext
2612                             );
2613   return;
2614 }
2615
2616 /*****************************************************************************
2617 *! \brief itdssIONoDeviceHandler
2618 *
2619 *  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
2620 *            layer with agIOStatus = OSSA_IO_NO_DEVICE
2621 *
2622 *  \param  agRoot:            pointer to port instance
2623 *  \param  agIORequest:       pointer to I/O request
2624 *  \param  agIOStatus:        I/O status given by LL layer
2625 *  \param  agIOInfoLen:       lenth of complete SAS RESP frame
2626 *  \param  agParam            A Handle used to refer to the response frame or handle
2627 *                             of abort request
2628 *  \param  agOtherInfo        Residual count
2629 *  \return: None
2630 *
2631 *
2632 *****************************************************************************/
2633 osGLOBAL void
2634 itdssIONoDeviceHandler(
2635                        agsaRoot_t           *agRoot,
2636                        agsaIORequest_t      *agIORequest,
2637                        bit32                agIOStatus,
2638                        bit32                agIOInfoLen,
2639                        void                 *agParam,
2640                        bit32                agOtherInfo
2641                        )
2642 {
2643   tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
2644   tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
2645   bit32                  intContext = osData->IntContext;
2646   tdIORequestBody_t      *tdIORequestBody;
2647   TI_DBG2(("itdssIONoDeviceHandler: start\n"));
2648
2649   tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
2650
2651   ostiInitiatorIOCompleted (
2652                             tiRoot,
2653                             tdIORequestBody->tiIORequest,
2654                             tiIOFailed,
2655                             tiDetailNoLogin,
2656                             agNULL,
2657                             intContext
2658                             );
2659   return;
2660 }
2661
2662 #ifdef REMOVED /* to do: removed from spec */
2663 /*****************************************************************************
2664 *! \brief itdssIllegalParameterHandler
2665 *
2666 *  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
2667 *            layer with agIOStatus = OSSA_IO_ILLEGAL_PARAMETER
2668 *
2669 *  \param  agRoot:            pointer to port instance
2670 *  \param  agIORequest:       pointer to I/O request
2671 *  \param  agIOStatus:        I/O status given by LL layer
2672 *  \param  agIOInfoLen:       lenth of complete SAS RESP frame
2673 *  \param  agParam            A Handle used to refer to the response frame or handle
2674 *                             of abort request
2675 *  \return: None
2676 *
2677 *
2678 *****************************************************************************/
2679 osGLOBAL void
2680 itdssIllegalParameterHandler(
2681                        agsaRoot_t           *agRoot,
2682                        agsaIORequest_t      *agIORequest,
2683                        bit32                agIOStatus,
2684                        bit32                agIOInfoLen,
2685                        void                 *agParam
2686                        )
2687 {
2688   tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
2689   tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
2690   bit32                  intContext = osData->IntContext;
2691   tdIORequestBody_t      *tdIORequestBody;
2692   TI_DBG2(("itdssIllegalParameterHandler: start\n"));
2693
2694   tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
2695
2696   ostiInitiatorIOCompleted (
2697                             tiRoot,
2698                             tdIORequestBody->tiIORequest,
2699                             tiIOFailed,
2700                             tiDetailOtherError,
2701                             agNULL,
2702                             intContext
2703                             );
2704
2705   return;
2706 }
2707 #endif
2708
2709 /*****************************************************************************
2710 *! \brief itdssLinkFailureHandler
2711 *
2712 *  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
2713 *            layer with agIOStatus = OSSA_IO_LINK_FAILURE
2714 *
2715 *  \param  agRoot:            pointer to port instance
2716 *  \param  agIORequest:       pointer to I/O request
2717 *  \param  agIOStatus:        I/O status given by LL layer
2718 *  \param  agIOInfoLen:       lenth of complete SAS RESP frame
2719 *  \param  agParam            A Handle used to refer to the response frame or handle
2720 *                             of abort request
2721 *  \param  agOtherInfo        Residual count
2722 *  \return: None
2723 *
2724 *
2725 *****************************************************************************/
2726 osGLOBAL void
2727 itdssLinkFailureHandler(
2728                        agsaRoot_t           *agRoot,
2729                        agsaIORequest_t      *agIORequest,
2730                        bit32                agIOStatus,
2731                        bit32                agIOInfoLen,
2732                        void                 *agParam,
2733                        bit32                agOtherInfo
2734                        )
2735 {
2736   tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
2737   tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
2738   bit32                  intContext = osData->IntContext;
2739   tdIORequestBody_t      *tdIORequestBody;
2740   TI_DBG1(("itdssLinkFailureHandler: start\n"));
2741
2742   tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
2743
2744   ostiInitiatorIOCompleted (
2745                             tiRoot,
2746                             tdIORequestBody->tiIORequest,
2747                             tiIOFailed,
2748                             tiDetailOtherError,
2749                             agNULL,
2750                             intContext
2751                             );
2752
2753   return;
2754 }
2755
2756 /*****************************************************************************
2757 *! \brief itdssProgErrorHandler
2758 *
2759 *  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
2760 *            layer with agIOStatus = OSSA_IO_PROG_ERROR
2761 *
2762 *  \param  agRoot:            pointer to port instance
2763 *  \param  agIORequest:       pointer to I/O request
2764 *  \param  agIOStatus:        I/O status given by LL layer
2765 *  \param  agIOInfoLen:       lenth of complete SAS RESP frame
2766 *  \param  agParam            A Handle used to refer to the response frame or handle
2767 *                             of abort request
2768 *  \param  agOtherInfo        Residual count
2769 *  \return: None
2770 *
2771 *
2772 *****************************************************************************/
2773 osGLOBAL void
2774 itdssProgErrorHandler(
2775                        agsaRoot_t           *agRoot,
2776                        agsaIORequest_t      *agIORequest,
2777                        bit32                agIOStatus,
2778                        bit32                agIOInfoLen,
2779                        void                 *agParam,
2780                        bit32                agOtherInfo
2781                        )
2782 {
2783   tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
2784   tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
2785   bit32                  intContext = osData->IntContext;
2786   tdIORequestBody_t      *tdIORequestBody;
2787   TI_DBG2(("itdssProgErrorHandler: start\n"));
2788
2789   tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
2790
2791   ostiInitiatorIOCompleted (
2792                             tiRoot,
2793                             tdIORequestBody->tiIORequest,
2794                             tiIOFailed,
2795                             tiDetailOtherError,
2796                             agNULL,
2797                             intContext
2798                             );
2799
2800   return;
2801 }
2802
2803 /*****************************************************************************
2804 *! \brief itdssXferErrorBreakHandler
2805 *
2806 *  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
2807 *            layer with agIOStatus = OSSA_IO_XFER_ERROR_BREAK
2808 *
2809 *  \param  agRoot:            pointer to port instance
2810 *  \param  agIORequest:       pointer to I/O request
2811 *  \param  agIOStatus:        I/O status given by LL layer
2812 *  \param  agIOInfoLen:       lenth of complete SAS RESP frame
2813 *  \param  agParam            A Handle used to refer to the response frame or handle
2814 *                             of abort request
2815 *  \param  agOtherInfo        Residual count
2816 *  \return: None
2817 *
2818 *
2819 *****************************************************************************/
2820 osGLOBAL void
2821 itdssXferErrorBreakHandler(
2822                        agsaRoot_t           *agRoot,
2823                        agsaIORequest_t      *agIORequest,
2824                        bit32                agIOStatus,
2825                        bit32                agIOInfoLen,
2826                        void                 *agParam,
2827                        bit32                agOtherInfo
2828                        )
2829 {
2830   tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
2831   tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
2832   bit32                  intContext = osData->IntContext;
2833   tdIORequestBody_t      *tdIORequestBody;
2834   TI_DBG1(("itdssXferErrorBreakHandler: start\n"));
2835
2836   tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
2837
2838   ostiInitiatorIOCompleted (
2839                             tiRoot,
2840                             tdIORequestBody->tiIORequest,
2841                             tiIOFailed,
2842                             tiDetailOtherError,
2843                             agNULL,
2844                             intContext
2845                             );
2846
2847   return;
2848 }
2849
2850 /*****************************************************************************
2851 *! \brief itdssXferErrorPhyNotReadyHandler
2852 *
2853 *  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
2854 *            layer with agIOStatus = OSSA_IO_XFER_ERROR_PHY_NOT_READY
2855 *
2856 *  \param  agRoot:            pointer to port instance
2857 *  \param  agIORequest:       pointer to I/O request
2858 *  \param  agIOStatus:        I/O status given by LL layer
2859 *  \param  agIOInfoLen:       lenth of complete SAS RESP frame
2860 *  \param  agParam            A Handle used to refer to the response frame or handle
2861 *                             of abort request
2862 *  \param  agOtherInfo        Residual count
2863 *  \return: None
2864 *
2865 *
2866 *****************************************************************************/
2867 osGLOBAL void
2868 itdssXferErrorPhyNotReadyHandler(
2869                        agsaRoot_t           *agRoot,
2870                        agsaIORequest_t      *agIORequest,
2871                        bit32                agIOStatus,
2872                        bit32                agIOInfoLen,
2873                        void                 *agParam,
2874                        bit32                agOtherInfo
2875                        )
2876 {
2877   tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
2878   tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
2879   bit32                  intContext = osData->IntContext;
2880   tdIORequestBody_t      *tdIORequestBody;
2881   TI_DBG2(("itdssXferErrorPhyNotReadyHandler: start\n"));
2882
2883   tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
2884
2885   ostiInitiatorIOCompleted (
2886                             tiRoot,
2887                             tdIORequestBody->tiIORequest,
2888                             tiIOFailed,
2889                             tiDetailOtherError,
2890                             agNULL,
2891                             intContext
2892                             );
2893
2894   return;
2895 }
2896
2897 /*****************************************************************************
2898 *! \brief itdssOpenCnxErrorProtocolNotSupprotedHandler
2899 *
2900 *  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
2901 *            layer with agIOStatus = OSSA_IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED
2902 *
2903 *  \param  agRoot:            pointer to port instance
2904 *  \param  agIORequest:       pointer to I/O request
2905 *  \param  agIOStatus:        I/O status given by LL layer
2906 *  \param  agIOInfoLen:       lenth of complete SAS RESP frame
2907 *  \param  agParam            A Handle used to refer to the response frame or handle
2908 *                             of abort request
2909 *  \param  agOtherInfo        Residual count
2910 *  \return: None
2911 *
2912 *
2913 *****************************************************************************/
2914 osGLOBAL void
2915 itdssOpenCnxErrorProtocolNotSupprotedHandler(
2916                        agsaRoot_t           *agRoot,
2917                        agsaIORequest_t      *agIORequest,
2918                        bit32                agIOStatus,
2919                        bit32                agIOInfoLen,
2920                        void                 *agParam,
2921                        bit32                agOtherInfo
2922                        )
2923 {
2924   tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
2925   tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
2926   bit32                  intContext = osData->IntContext;
2927   tdIORequestBody_t      *tdIORequestBody;
2928   TI_DBG2(("itdssOpenCnxErrorProtocolNotSupprotedHandler: start\n"));
2929
2930   tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
2931
2932   ostiInitiatorIOCompleted (
2933                             tiRoot,
2934                             tdIORequestBody->tiIORequest,
2935                             tiIOFailed,
2936                             tiDetailOtherError,
2937                             agNULL,
2938                             intContext
2939                             );
2940
2941   return;
2942 }
2943
2944 /*****************************************************************************
2945 *! \brief itdssOpenCnxErrorZoneViolationHandler
2946 *
2947 *  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
2948 *            layer with agIOStatus = OSSA_IO_OPEN_CNX_ERROR_ZONE_VIOLATION
2949 *
2950 *  \param  agRoot:            pointer to port instance
2951 *  \param  agIORequest:       pointer to I/O request
2952 *  \param  agIOStatus:        I/O status given by LL layer
2953 *  \param  agIOInfoLen:       lenth of complete SAS RESP frame
2954 *  \param  agParam            A Handle used to refer to the response frame or handle
2955 *                             of abort request
2956 *  \param  agOtherInfo        Residual count
2957 *  \return: None
2958 *
2959 *
2960 *****************************************************************************/
2961 osGLOBAL void
2962 itdssOpenCnxErrorZoneViolationHandler(
2963                        agsaRoot_t           *agRoot,
2964                        agsaIORequest_t      *agIORequest,
2965                        bit32                agIOStatus,
2966                        bit32                agIOInfoLen,
2967                        void                 *agParam,
2968                        bit32                agOtherInfo
2969                        )
2970 {
2971   tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
2972   tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
2973   bit32                  intContext = osData->IntContext;
2974   tdIORequestBody_t      *tdIORequestBody;
2975   TI_DBG2(("itdssOpenCnxErrorZoneViolationHandler: start\n"));
2976
2977   tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
2978
2979   ostiInitiatorIOCompleted (
2980                             tiRoot,
2981                             tdIORequestBody->tiIORequest,
2982                             tiIOFailed,
2983                             tiDetailOtherError,
2984                             agNULL,
2985                             intContext
2986                             );
2987
2988   return;
2989 }
2990
2991 /*****************************************************************************
2992 *! \brief itdssOpenCnxErrorBreakHandler
2993 *
2994 *  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
2995 *            layer with agIOStatus = OSSA_IO_OPEN_CNX_ERROR_BREAK
2996 *
2997 *  \param  agRoot:            pointer to port instance
2998 *  \param  agIORequest:       pointer to I/O request
2999 *  \param  agIOStatus:        I/O status given by LL layer
3000 *  \param  agIOInfoLen:       lenth of complete SAS RESP frame
3001 *  \param  agParam            A Handle used to refer to the response frame or handle
3002 *                             of abort request
3003 *  \param  agOtherInfo        Residual count
3004 *  \return: None
3005 *
3006 *
3007 *****************************************************************************/
3008 osGLOBAL void
3009 itdssOpenCnxErrorBreakHandler(
3010                        agsaRoot_t           *agRoot,
3011                        agsaIORequest_t      *agIORequest,
3012                        bit32                agIOStatus,
3013                        bit32                agIOInfoLen,
3014                        void                 *agParam,
3015                        bit32                agOtherInfo
3016                        )
3017 {
3018   tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
3019   tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
3020   bit32                  intContext = osData->IntContext;
3021   tdIORequestBody_t      *tdIORequestBody;
3022   TI_DBG1(("itdssOpenCnxErrorBreakHandler: start\n"));
3023
3024   tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
3025
3026   ostiInitiatorIOCompleted (
3027                             tiRoot,
3028                             tdIORequestBody->tiIORequest,
3029                             tiIOFailed,
3030                             tiDetailOtherError,
3031                             agNULL,
3032                             intContext
3033                             );
3034
3035   return;
3036 }
3037
3038 /*****************************************************************************
3039 *! \brief itdssOpenCnxErrorITNexusLossHandler
3040 *
3041 *  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
3042 *            layer with agIOStatus = OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS
3043 *
3044 *  \param  agRoot:            pointer to port instance
3045 *  \param  agIORequest:       pointer to I/O request
3046 *  \param  agIOStatus:        I/O status given by LL layer
3047 *  \param  agIOInfoLen:       lenth of complete SAS RESP frame
3048 *  \param  agParam            A Handle used to refer to the response frame or handle
3049 *                             of abort request
3050 *  \param  agOtherInfo        Residual count
3051 *  \return: None
3052 *
3053 *
3054 *****************************************************************************/
3055 osGLOBAL void
3056 itdssOpenCnxErrorITNexusLossHandler(
3057                        agsaRoot_t           *agRoot,
3058                        agsaIORequest_t      *agIORequest,
3059                        bit32                agIOStatus,
3060                        bit32                agIOInfoLen,
3061                        void                 *agParam,
3062                        bit32                agOtherInfo
3063                        )
3064 {
3065   tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
3066   tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
3067   bit32                  intContext = osData->IntContext;
3068   tdIORequestBody_t      *tdIORequestBody;
3069   TI_DBG1(("itdssOpenCnxErrorITNexusLossHandler: start\n"));
3070
3071   tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
3072
3073   ostiInitiatorIOCompleted (
3074                             tiRoot,
3075                             tdIORequestBody->tiIORequest,
3076                             tiIOFailed,
3077                             tiDetailOtherError,
3078                             agNULL,
3079                             intContext
3080                             );
3081
3082   return;
3083 }
3084
3085 /*****************************************************************************
3086 *! \brief itdssOpenCnxErrorBadDestinationHandler
3087 *
3088 *  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
3089 *            layer with agIOStatus = OSSA_IO_OPEN_CNX_ERROR_BAD_DESTINATION
3090 *
3091 *  \param  agRoot:            pointer to port instance
3092 *  \param  agIORequest:       pointer to I/O request
3093 *  \param  agIOStatus:        I/O status given by LL layer
3094 *  \param  agIOInfoLen:       lenth of complete SAS RESP frame
3095 *  \param  agParam            A Handle used to refer to the response frame or handle
3096 *                             of abort request
3097 *  \param  agOtherInfo        Residual count
3098 *  \return: None
3099 *
3100 *
3101 *****************************************************************************/
3102 osGLOBAL void
3103 itdssOpenCnxErrorBadDestinationHandler(
3104                        agsaRoot_t           *agRoot,
3105                        agsaIORequest_t      *agIORequest,
3106                        bit32                agIOStatus,
3107                        bit32                agIOInfoLen,
3108                        void                 *agParam,
3109                        bit32                agOtherInfo
3110                        )
3111 {
3112   tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
3113   tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
3114   bit32                  intContext = osData->IntContext;
3115   tdIORequestBody_t      *tdIORequestBody;
3116   TI_DBG1(("itdssOpenCnxErrorBadDestinationHandler: start\n"));
3117
3118   tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
3119
3120   ostiInitiatorIOCompleted (
3121                             tiRoot,
3122                             tdIORequestBody->tiIORequest,
3123                             tiIOFailed,
3124                             tiDetailOtherError,
3125                             agNULL,
3126                             intContext
3127                             );
3128
3129   return;
3130 }
3131
3132 /*****************************************************************************
3133 *! \brief itdssOpenCnxErrorConnectionRateNotSupportedHandler
3134 *
3135 *  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
3136 *            layer with agIOStatus = OSSA_IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED
3137 *
3138 *  \param  agRoot:            pointer to port instance
3139 *  \param  agIORequest:       pointer to I/O request
3140 *  \param  agIOStatus:        I/O status given by LL layer
3141 *  \param  agIOInfoLen:       lenth of complete SAS RESP frame
3142 *  \param  agParam            A Handle used to refer to the response frame or handle
3143 *                             of abort request
3144 *  \param  agOtherInfo        Residual count
3145 *  \return: None
3146 *
3147 *
3148 *****************************************************************************/
3149 osGLOBAL void
3150 itdssOpenCnxErrorConnectionRateNotSupportedHandler(
3151                        agsaRoot_t           *agRoot,
3152                        agsaIORequest_t      *agIORequest,
3153                        bit32                agIOStatus,
3154                        bit32                agIOInfoLen,
3155                        void                 *agParam,
3156                        bit32                agOtherInfo
3157                        )
3158 {
3159   tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
3160   tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
3161   tdsaRoot_t             *tdsaRoot      = (tdsaRoot_t *) tiRoot->tdData;
3162   tdsaContext_t          *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
3163   bit32                  intContext = osData->IntContext;
3164   tdIORequestBody_t      *tdIORequestBody;
3165   agsaDevHandle_t        *agDevHandle = agNULL;
3166   tiDeviceHandle_t       *tiDeviceHandle = agNULL;
3167   tdsaDeviceData_t       *oneDeviceData = agNULL;
3168   bit32                  ConnRate = SAS_CONNECTION_RATE_12_0G;
3169   agsaContext_t          *agContext = agNULL;
3170   TI_DBG1(("itdssOpenCnxErrorConnectionRateNotSupportedHandler: start\n"));
3171
3172   /* we retry by lowering link rate
3173      retry should be in ossaSetDeviceInfoCB()
3174   */
3175   tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
3176   tiDeviceHandle = tdIORequestBody->tiDevHandle;
3177   oneDeviceData  = (tdsaDeviceData_t *)tiDeviceHandle->tdData;
3178   agDevHandle = oneDeviceData->agDevHandle;
3179
3180   if (tdsaAllShared->RateAdjust)
3181   {
3182     if (oneDeviceData->valid == agTRUE && oneDeviceData->registered == agTRUE &&
3183         oneDeviceData->tdPortContext != agNULL )
3184     {
3185       ConnRate = DEVINFO_GET_LINKRATE(&oneDeviceData->agDeviceInfo);
3186       if (ConnRate == SAS_CONNECTION_RATE_1_5G)
3187       {
3188         /* no retry; completes IO */
3189         ostiInitiatorIOCompleted(
3190                                  tiRoot,
3191                                  tdIORequestBody->tiIORequest,
3192                                  tiIOFailed,
3193                                  tiDetailOtherError,
3194                                  agNULL,
3195                                  intContext
3196                                  );
3197       }
3198       else
3199       {
3200         ConnRate = ConnRate - 1;
3201       }
3202       agContext = &(tdIORequestBody->agContext);
3203       agContext->osData = agIORequest;
3204       saSetDeviceInfo(agRoot, agContext, tdsaRotateQnumber(tiRoot, oneDeviceData), agDevHandle, 32, ConnRate << 28, ossaIniSetDeviceInfoCB);
3205     }
3206   }
3207   else
3208   {
3209     ostiInitiatorIOCompleted(
3210                              tiRoot,
3211                              tdIORequestBody->tiIORequest,
3212                              tiIOFailed,
3213                              tiDetailOtherError,
3214                              agNULL,
3215                              intContext
3216                              );
3217   }
3218
3219   return;
3220 }
3221
3222 /*****************************************************************************
3223 *! \brief itdssOpenCnxErrorSTPResourceBusyHandler
3224 *
3225 *  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
3226 *            layer with agIOStatus = OSSA_IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY
3227 *
3228 *  \param  agRoot:            pointer to port instance
3229 *  \param  agIORequest:       pointer to I/O request
3230 *  \param  agIOStatus:        I/O status given by LL layer
3231 *  \param  agIOInfoLen:       lenth of complete SAS RESP frame
3232 *  \param  agParam            A Handle used to refer to the response frame or handle
3233 *                             of abort request
3234 *  \param  agOtherInfo        Residual count
3235 *  \return: None
3236 *
3237 *
3238 *****************************************************************************/
3239 osGLOBAL void
3240 itdssOpenCnxErrorSTPResourceBusyHandler(
3241                        agsaRoot_t           *agRoot,
3242                        agsaIORequest_t      *agIORequest,
3243                        bit32                agIOStatus,
3244                        bit32                agIOInfoLen,
3245                        void                 *agParam,
3246                        bit32                agOtherInfo
3247                        )
3248 {
3249   tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
3250   tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
3251   bit32                  intContext = osData->IntContext;
3252   tdIORequestBody_t      *tdIORequestBody;
3253   TI_DBG2(("itdssOpenCnxErrorSTPResourceBusyHandler: start\n"));
3254
3255   tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
3256
3257   ostiInitiatorIOCompleted (
3258                             tiRoot,
3259                             tdIORequestBody->tiIORequest,
3260                             tiIOFailed,
3261                             tiDetailOtherError,
3262                             agNULL,
3263                             intContext
3264                             );
3265
3266   return;
3267 }
3268
3269 /*****************************************************************************
3270 *! \brief itdssOpenCnxErrorWrongDestinationHandler
3271 *
3272 *  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
3273 *            layer with agIOStatus = OSSA_IO_OPEN_CNX_ERROR_WRONG_DESTINATION
3274 *
3275 *  \param  agRoot:            pointer to port instance
3276 *  \param  agIORequest:       pointer to I/O request
3277 *  \param  agIOStatus:        I/O status given by LL layer
3278 *  \param  agIOInfoLen:       lenth of complete SAS RESP frame
3279 *  \param  agParam            A Handle used to refer to the response frame or handle
3280 *                             of abort request
3281 *  \param  agOtherInfo        Residual count
3282 *  \return: None
3283 *
3284 *
3285 *****************************************************************************/
3286 osGLOBAL void
3287 itdssOpenCnxErrorWrongDestinationHandler(
3288                        agsaRoot_t           *agRoot,
3289                        agsaIORequest_t      *agIORequest,
3290                        bit32                agIOStatus,
3291                        bit32                agIOInfoLen,
3292                        void                 *agParam,
3293                        bit32                agOtherInfo
3294                        )
3295 {
3296   tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
3297   tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
3298   bit32                  intContext = osData->IntContext;
3299   tdIORequestBody_t      *tdIORequestBody;
3300   TI_DBG1(("itdssOpenCnxErrorWrongDestinationHandler: start\n"));
3301
3302   tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
3303
3304   ostiInitiatorIOCompleted (
3305                             tiRoot,
3306                             tdIORequestBody->tiIORequest,
3307                             tiIOFailed,
3308                             tiDetailOtherError,
3309                             agNULL,
3310                             intContext
3311                             );
3312
3313   return;
3314 }
3315
3316 /*****************************************************************************
3317 *! \brief itdssOpenCnxErrorUnknownErrorHandler
3318 *
3319 *  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
3320 *            layer with agIOStatus = OSSA_IO_OPEN_CNX_ERROR_UNKNOWN_ERROR
3321 *
3322 *  \param  agRoot:            pointer to port instance
3323 *  \param  agIORequest:       pointer to I/O request
3324 *  \param  agIOStatus:        I/O status given by LL layer
3325 *  \param  agIOInfoLen:       lenth of complete SAS RESP frame
3326 *  \param  agParam            A Handle used to refer to the response frame or handle
3327 *                             of abort request
3328 *  \param  agOtherInfo        Residual count
3329 *  \return: None
3330 *
3331 *
3332 *****************************************************************************/
3333 osGLOBAL void
3334 itdssOpenCnxErrorUnknownErrorHandler(
3335                        agsaRoot_t           *agRoot,
3336                        agsaIORequest_t      *agIORequest,
3337                        bit32                agIOStatus,
3338                        bit32                agIOInfoLen,
3339                        void                 *agParam,
3340                        bit32                agOtherInfo
3341                        )
3342 {
3343   tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
3344   tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
3345   bit32                  intContext = osData->IntContext;
3346   tdIORequestBody_t      *tdIORequestBody;
3347   TI_DBG1(("itdssOpenCnxErrorUnknownErrorHandler: start\n"));
3348
3349   tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
3350
3351   ostiInitiatorIOCompleted (
3352                             tiRoot,
3353                             tdIORequestBody->tiIORequest,
3354                             tiIOFailed,
3355                             tiDetailOtherError,
3356                             agNULL,
3357                             intContext
3358                             );
3359
3360   return;
3361 }
3362
3363 /*****************************************************************************
3364 *! \brief itdssXferErrorNAKReceivedHandler
3365 *
3366 *  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
3367 *            layer with agIOStatus = OSSA_IO_XFER_ERROR_NAK_RECEIVED
3368 *
3369 *  \param  agRoot:            pointer to port instance
3370 *  \param  agIORequest:       pointer to I/O request
3371 *  \param  agIOStatus:        I/O status given by LL layer
3372 *  \param  agIOInfoLen:       lenth of complete SAS RESP frame
3373 *  \param  agParam            A Handle used to refer to the response frame or handle
3374 *                             of abort request
3375 *  \param  agOtherInfo        Residual count
3376 *  \return: None
3377 *
3378 *
3379 *****************************************************************************/
3380 osGLOBAL void
3381 itdssXferErrorNAKReceivedHandler(
3382                        agsaRoot_t           *agRoot,
3383                        agsaIORequest_t      *agIORequest,
3384                        bit32                agIOStatus,
3385                        bit32                agIOInfoLen,
3386                        void                 *agParam,
3387                        bit32                agOtherInfo
3388                        )
3389 {
3390   tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
3391   tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
3392   bit32                  intContext = osData->IntContext;
3393   tdIORequestBody_t      *tdIORequestBody;
3394   TI_DBG1(("itdssXferErrorNAKReceivedHandler: start\n"));
3395
3396   tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
3397
3398   ostiInitiatorIOCompleted (
3399                             tiRoot,
3400                             tdIORequestBody->tiIORequest,
3401                             tiIOFailed,
3402                             tiDetailOtherError,
3403                             agNULL,
3404                             intContext
3405                             );
3406
3407   return;
3408 }
3409
3410 /*****************************************************************************
3411 *! \brief itdssXferErrorACKNAKTimeoutHandler
3412 *
3413 *  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
3414 *            layer with agIOStatus = OSSA_IO_XFER_ERROR_ACK_NAK_TIMEOUT
3415 *
3416 *  \param  agRoot:            pointer to port instance
3417 *  \param  agIORequest:       pointer to I/O request
3418 *  \param  agIOStatus:        I/O status given by LL layer
3419 *  \param  agIOInfoLen:       lenth of complete SAS RESP frame
3420 *  \param  agParam            A Handle used to refer to the response frame or handle
3421 *                             of abort request
3422 *  \param  agOtherInfo        Residual count
3423 *  \return: None
3424 *
3425 *
3426 *****************************************************************************/
3427 osGLOBAL void
3428 itdssXferErrorACKNAKTimeoutHandler(
3429                        agsaRoot_t           *agRoot,
3430                        agsaIORequest_t      *agIORequest,
3431                        bit32                agIOStatus,
3432                        bit32                agIOInfoLen,
3433                        void                 *agParam,
3434                        bit32                agOtherInfo
3435                        )
3436 {
3437   tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
3438   tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
3439   bit32                  intContext = osData->IntContext;
3440   tdIORequestBody_t      *tdIORequestBody;
3441   TI_DBG1(("itdssXferErrorACKNAKTimeoutHandler: start\n"));
3442
3443   tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
3444
3445   ostiInitiatorIOCompleted (
3446                             tiRoot,
3447                             tdIORequestBody->tiIORequest,
3448                             tiIOFailed,
3449                             tiDetailOtherError,
3450                             agNULL,
3451                             intContext
3452                             );
3453
3454   return;
3455 }
3456
3457 /*****************************************************************************
3458 *! \brief itdssXferErrorPeerAbortedHandler
3459 *
3460 *  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
3461 *            layer with agIOStatus = OSSA_IO_XFER_ERROR_PEER_ABORTED
3462 *
3463 *  \param  agRoot:            pointer to port instance
3464 *  \param  agIORequest:       pointer to I/O request
3465 *  \param  agIOStatus:        I/O status given by LL layer
3466 *  \param  agIOInfoLen:       lenth of complete SAS RESP frame
3467 *  \param  agParam            A Handle used to refer to the response frame or handle
3468 *                             of abort request
3469 *  \param  agOtherInfo        Residual count
3470 *  \return: None
3471 *
3472 *
3473 *****************************************************************************/
3474 osGLOBAL void
3475 itdssXferErrorPeerAbortedHandler(
3476                        agsaRoot_t           *agRoot,
3477                        agsaIORequest_t      *agIORequest,
3478                        bit32                agIOStatus,
3479                        bit32                agIOInfoLen,
3480                        void                 *agParam,
3481                        bit32                agOtherInfo
3482                        )
3483 {
3484   tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
3485   tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
3486   bit32                  intContext = osData->IntContext;
3487   tdIORequestBody_t      *tdIORequestBody;
3488   TI_DBG2(("itdssXferErrorPeerAbortedHandler: start\n"));
3489
3490   tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
3491
3492   ostiInitiatorIOCompleted (
3493                             tiRoot,
3494                             tdIORequestBody->tiIORequest,
3495                             tiIOFailed,
3496                             tiDetailOtherError,
3497                             agNULL,
3498                             intContext
3499                             );
3500
3501   return;
3502 }
3503
3504 /*****************************************************************************
3505 *! \brief itdssXferErrorRxFrameHandler
3506 *
3507 *  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
3508 *            layer with agIOStatus = OSSA_IO_XFER_ERROR_RX_FRAME
3509 *
3510 *  \param  agRoot:            pointer to port instance
3511 *  \param  agIORequest:       pointer to I/O request
3512 *  \param  agIOStatus:        I/O status given by LL layer
3513 *  \param  agIOInfoLen:       lenth of complete SAS RESP frame
3514 *  \param  agParam            A Handle used to refer to the response frame or handle
3515 *                             of abort request
3516 *  \param  agOtherInfo        Residual count
3517 *  \return: None
3518 *
3519 *
3520 *****************************************************************************/
3521 osGLOBAL void
3522 itdssXferErrorRxFrameHandler(
3523                        agsaRoot_t           *agRoot,
3524                        agsaIORequest_t      *agIORequest,
3525                        bit32                agIOStatus,
3526                        bit32                agIOInfoLen,
3527                        void                 *agParam,
3528                        bit32                agOtherInfo
3529                        )
3530 {
3531   tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
3532   tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
3533   bit32                  intContext = osData->IntContext;
3534   tdIORequestBody_t      *tdIORequestBody;
3535   TI_DBG1(("itdssXferErrorRxFrameHandler: start\n"));
3536
3537   tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
3538
3539   ostiInitiatorIOCompleted (
3540                             tiRoot,
3541                             tdIORequestBody->tiIORequest,
3542                             tiIOFailed,
3543                             tiDetailOtherError,
3544                             agNULL,
3545                             intContext
3546                             );
3547
3548   return;
3549 }
3550
3551 /*****************************************************************************
3552 *! \brief itdssXferErrorDMAHandler
3553 *
3554 *  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
3555 *            layer with agIOStatus = OSSA_IO_XFER_ERROR_DMA
3556 *
3557 *  \param  agRoot:            pointer to port instance
3558 *  \param  agIORequest:       pointer to I/O request
3559 *  \param  agIOStatus:        I/O status given by LL layer
3560 *  \param  agIOInfoLen:       lenth of complete SAS RESP frame
3561 *  \param  agParam            A Handle used to refer to the response frame or handle
3562 *                             of abort request
3563 *  \param  agOtherInfo        Residual count
3564 *  \return: None
3565 *
3566 *
3567 *****************************************************************************/
3568 osGLOBAL void
3569 itdssXferErrorDMAHandler(
3570                        agsaRoot_t           *agRoot,
3571                        agsaIORequest_t      *agIORequest,
3572                        bit32                agIOStatus,
3573                        bit32                agIOInfoLen,
3574                        void                 *agParam,
3575                        bit32                agOtherInfo
3576                        )
3577 {
3578   tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
3579   tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
3580   bit32                  intContext = osData->IntContext;
3581   tdIORequestBody_t      *tdIORequestBody;
3582   TI_DBG1(("itdssXferErrorDMAHandler: start\n"));
3583
3584   tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
3585
3586   ostiInitiatorIOCompleted (
3587                             tiRoot,
3588                             tdIORequestBody->tiIORequest,
3589                             tiIOFailed,
3590                             tiDetailOtherErrorNoRetry,
3591                             agNULL,
3592                             intContext
3593                             );
3594
3595   return;
3596 }
3597
3598 /*****************************************************************************
3599 *! \brief itdssXferErrorCreditTimeoutHandler
3600 *
3601 *  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
3602 *            layer with agIOStatus = OSSA_IO_XFER_ERROR_CREDIT_TIMEOUT
3603 *
3604 *  \param  agRoot:            pointer to port instance
3605 *  \param  agIORequest:       pointer to I/O request
3606 *  \param  agIOStatus:        I/O status given by LL layer
3607 *  \param  agIOInfoLen:       lenth of complete SAS RESP frame
3608 *  \param  agParam            A Handle used to refer to the response frame or handle
3609 *                             of abort request
3610 *  \param  agOtherInfo        Residual count
3611 *  \return: None
3612 *
3613 *
3614 *****************************************************************************/
3615 osGLOBAL void
3616 itdssXferErrorCreditTimeoutHandler(
3617                        agsaRoot_t           *agRoot,
3618                        agsaIORequest_t      *agIORequest,
3619                        bit32                agIOStatus,
3620                        bit32                agIOInfoLen,
3621                        void                 *agParam,
3622                        bit32                agOtherInfo
3623                        )
3624 {
3625   tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
3626   tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
3627   bit32                  intContext = osData->IntContext;
3628   tdIORequestBody_t      *tdIORequestBody;
3629   TI_DBG1(("itdssXferErrorCreditTimeoutHandler: start\n"));
3630
3631   tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
3632
3633   ostiInitiatorIOCompleted (
3634                             tiRoot,
3635                             tdIORequestBody->tiIORequest,
3636                             tiIOFailed,
3637                             tiDetailOtherError,
3638                             agNULL,
3639                             intContext
3640                             );
3641
3642   return;
3643 }
3644
3645 /*****************************************************************************
3646 *! \brief itdssXferErrorCMDIssueACKNAKTimeoutHandler
3647 *
3648 *  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
3649 *            layer with agIOStatus = OSSA_IO_XFER_ERROR_CMD_ISSUE_ACK_NAK_TIMEOUT
3650 *
3651 *  \param  agRoot:            pointer to port instance
3652 *  \param  agIORequest:       pointer to I/O request
3653 *  \param  agIOStatus:        I/O status given by LL layer
3654 *  \param  agIOInfoLen:       lenth of complete SAS RESP frame
3655 *  \param  agParam            A Handle used to refer to the response frame or handle
3656 *                             of abort request
3657 *  \param  agOtherInfo        Residual count
3658 *  \return: None
3659 *
3660 *
3661 *****************************************************************************/
3662 osGLOBAL void
3663 itdssXferErrorCMDIssueACKNAKTimeoutHandler(
3664                        agsaRoot_t           *agRoot,
3665                        agsaIORequest_t      *agIORequest,
3666                        bit32                agIOStatus,
3667                        bit32                agIOInfoLen,
3668                        void                 *agParam,
3669                        bit32                agOtherInfo
3670                        )
3671 {
3672   tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
3673   tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
3674   bit32                  intContext = osData->IntContext;
3675   tdIORequestBody_t      *tdIORequestBody;
3676   TI_DBG1(("itdssXferErrorCMDIssueACKNAKTimeoutHandler: start\n"));
3677
3678   tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
3679
3680   ostiInitiatorIOCompleted (
3681                             tiRoot,
3682                             tdIORequestBody->tiIORequest,
3683                             tiIOFailed,
3684                             tiDetailOtherError,
3685                             agNULL,
3686                             intContext
3687                             );
3688
3689   return;
3690 }
3691
3692 /*****************************************************************************
3693 *! \brief itdssXferErrorCMDIssueBreakBeforeACKNAKHandler
3694 *
3695 *  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
3696 *            layer with agIOStatus = OSSA_IO_XFER_ERROR_CMD_ISSUE_BREAK_BEFORE_ACK_NAK
3697 *
3698 *  \param  agRoot:            pointer to port instance
3699 *  \param  agIORequest:       pointer to I/O request
3700 *  \param  agIOStatus:        I/O status given by LL layer
3701 *  \param  agIOInfoLen:       lenth of complete SAS RESP frame
3702 *  \param  agParam            A Handle used to refer to the response frame or handle
3703 *                             of abort request
3704 *  \param  agOtherInfo        Residual count
3705 *  \return: None
3706 *
3707 *
3708 *****************************************************************************/
3709 osGLOBAL void
3710 itdssXferErrorCMDIssueBreakBeforeACKNAKHandler(
3711                        agsaRoot_t           *agRoot,
3712                        agsaIORequest_t      *agIORequest,
3713                        bit32                agIOStatus,
3714                        bit32                agIOInfoLen,
3715                        void                 *agParam,
3716                        bit32                agOtherInfo
3717                        )
3718 {
3719   tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
3720   tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
3721   bit32                  intContext = osData->IntContext;
3722   tdIORequestBody_t      *tdIORequestBody;
3723   TI_DBG1(("itdssXferErrorCMDIssueBreakBeforeACKNAKHandler: start\n"));
3724
3725   tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
3726
3727   ostiInitiatorIOCompleted (
3728                             tiRoot,
3729                             tdIORequestBody->tiIORequest,
3730                             tiIOFailed,
3731                             tiDetailOtherError,
3732                             agNULL,
3733                             intContext
3734                             );
3735
3736   return;
3737 }
3738
3739 /*****************************************************************************
3740 *! \brief itdssXferErrorCMDIssuePhyDownBeforeACKNAKHandler
3741 *
3742 *  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
3743 *            layer with agIOStatus = OSSA_IO_XFER_ERROR_CMD_ISSUE_PHY_DOWN_BEFORE_ACK_NAK
3744 *
3745 *  \param  agRoot:            pointer to port instance
3746 *  \param  agIORequest:       pointer to I/O request
3747 *  \param  agIOStatus:        I/O status given by LL layer
3748 *  \param  agIOInfoLen:       lenth of complete SAS RESP frame
3749 *  \param  agParam            A Handle used to refer to the response frame or handle
3750 *                             of abort request
3751 *  \param  agOtherInfo        Residual count
3752 *  \return: None
3753 *
3754 *
3755 *****************************************************************************/
3756 osGLOBAL void
3757 itdssXferErrorCMDIssuePhyDownBeforeACKNAKHandler(
3758                        agsaRoot_t           *agRoot,
3759                        agsaIORequest_t      *agIORequest,
3760                        bit32                agIOStatus,
3761                        bit32                agIOInfoLen,
3762                        void                 *agParam,
3763                        bit32                agOtherInfo
3764                        )
3765 {
3766   tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
3767   tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
3768   bit32                  intContext = osData->IntContext;
3769   tdIORequestBody_t      *tdIORequestBody;
3770   TI_DBG1(("itdssXferErrorCMDIssuePhyDownBeforeACKNAKHandler: start\n"));
3771
3772   tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
3773
3774   ostiInitiatorIOCompleted (
3775                             tiRoot,
3776                             tdIORequestBody->tiIORequest,
3777                             tiIOFailed,
3778                             tiDetailOtherError,
3779                             agNULL,
3780                             intContext
3781                             );
3782
3783   return;
3784 }
3785
3786 /*****************************************************************************
3787 *! \brief itdssXferErrorDisruptedPhyDownHandler
3788 *
3789 *  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
3790 *            layer with agIOStatus = OSSA_IO_XFER_ERROR_DISRUPTED_PHY_DOWN
3791 *
3792 *  \param  agRoot:            pointer to port instance
3793 *  \param  agIORequest:       pointer to I/O request
3794 *  \param  agIOStatus:        I/O status given by LL layer
3795 *  \param  agIOInfoLen:       lenth of complete SAS RESP frame
3796 *  \param  agParam            A Handle used to refer to the response frame or handle
3797 *                             of abort request
3798 *  \param  agOtherInfo        Residual count
3799 *  \return: None
3800 *
3801 *
3802 *****************************************************************************/
3803 osGLOBAL void
3804 itdssXferErrorDisruptedPhyDownHandler(
3805                        agsaRoot_t           *agRoot,
3806                        agsaIORequest_t      *agIORequest,
3807                        bit32                agIOStatus,
3808                        bit32                agIOInfoLen,
3809                        void                 *agParam,
3810                        bit32                agOtherInfo
3811                        )
3812 {
3813   tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
3814   tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
3815   bit32                  intContext = osData->IntContext;
3816   tdIORequestBody_t      *tdIORequestBody;
3817   TI_DBG2(("itdssXferErrorDisruptedPhyDownHandler: start\n"));
3818
3819   tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
3820
3821   ostiInitiatorIOCompleted (
3822                             tiRoot,
3823                             tdIORequestBody->tiIORequest,
3824                             tiIOFailed,
3825                             tiDetailOtherError,
3826                             agNULL,
3827                             intContext
3828                             );
3829
3830   return;
3831 }
3832
3833 /*****************************************************************************
3834 *! \brief itdssXferErrorOffsetMismatchHandler
3835 *
3836 *  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
3837 *            layer with agIOStatus = OSSA_IO_XFER_ERROR_OFFSET_MISMATCH
3838 *
3839 *  \param  agRoot:            pointer to port instance
3840 *  \param  agIORequest:       pointer to I/O request
3841 *  \param  agIOStatus:        I/O status given by LL layer
3842 *  \param  agIOInfoLen:       lenth of complete SAS RESP frame
3843 *  \param  agParam            A Handle used to refer to the response frame or handle
3844 *                             of abort request
3845 *  \param  agOtherInfo        Residual count
3846 *  \return: None
3847 *
3848 *
3849 *****************************************************************************/
3850 osGLOBAL void
3851 itdssXferErrorOffsetMismatchHandler(
3852                        agsaRoot_t           *agRoot,
3853                        agsaIORequest_t      *agIORequest,
3854                        bit32                agIOStatus,
3855                        bit32                agIOInfoLen,
3856                        void                 *agParam,
3857                        bit32                agOtherInfo
3858                        )
3859 {
3860   tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
3861   tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
3862   bit32                  intContext = osData->IntContext;
3863   tdIORequestBody_t      *tdIORequestBody;
3864   TI_DBG1(("itdssXferErrorOffsetMismatchHandler: start\n"));
3865
3866   tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
3867
3868   ostiInitiatorIOCompleted (
3869                             tiRoot,
3870                             tdIORequestBody->tiIORequest,
3871                             tiIOFailed,
3872                             tiDetailOtherError,
3873                             agNULL,
3874                             intContext
3875                             );
3876
3877   return;
3878 }
3879
3880 /*****************************************************************************
3881 *! \brief itdssXferErrorXferZeroDataLenHandler
3882 *
3883 *  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
3884 *            layer with agIOStatus = OSSA_IO_XFER_ERROR_XFER_ZERO_DATA_LEN
3885 *
3886 *  \param  agRoot:            pointer to port instance
3887 *  \param  agIORequest:       pointer to I/O request
3888 *  \param  agIOStatus:        I/O status given by LL layer
3889 *  \param  agIOInfoLen:       lenth of complete SAS RESP frame
3890 *  \param  agParam            A Handle used to refer to the response frame or handle
3891 *                             of abort request
3892 *  \param  agOtherInfo        Residual count
3893 *  \return: None
3894 *
3895 *
3896 *****************************************************************************/
3897 osGLOBAL void
3898 itdssXferErrorXferZeroDataLenHandler(
3899                        agsaRoot_t           *agRoot,
3900                        agsaIORequest_t      *agIORequest,
3901                        bit32                agIOStatus,
3902                        bit32                agIOInfoLen,
3903                        void                 *agParam,
3904                        bit32                agOtherInfo
3905                        )
3906 {
3907   tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
3908   tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
3909   bit32                  intContext = osData->IntContext;
3910   tdIORequestBody_t      *tdIORequestBody;
3911   TI_DBG2(("itdssXferErrorXferZeroDataLenHandler: start\n"));
3912
3913   tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
3914
3915   ostiInitiatorIOCompleted (
3916                             tiRoot,
3917                             tdIORequestBody->tiIORequest,
3918                             tiIOFailed,
3919                             tiDetailOtherError,
3920                             agNULL,
3921                             intContext
3922                             );
3923
3924   return;
3925 }
3926
3927 /*****************************************************************************
3928 *! \brief itdssXferOpenRetryTimeoutHandler
3929 *
3930 *  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
3931 *            layer with agIOStatus = OSSA_IO_XFER_OPEN_RETRY_TIMEOUT
3932 *
3933 *  \param  agRoot:            pointer to port instance
3934 *  \param  agIORequest:       pointer to I/O request
3935 *  \param  agIOStatus:        I/O status given by LL layer
3936 *  \param  agIOInfoLen:       lenth of complete SAS RESP frame
3937 *  \param  agParam            A Handle used to refer to the response frame or handle
3938 *                             of abort request
3939 *  \param  agOtherInfo        Residual count
3940 *  \return: None
3941 *
3942 *
3943 *****************************************************************************/
3944 osGLOBAL void
3945 itdssXferOpenRetryTimeoutHandler(
3946                        agsaRoot_t           *agRoot,
3947                        agsaIORequest_t      *agIORequest,
3948                        bit32                agIOStatus,
3949                        bit32                agIOInfoLen,
3950                        void                 *agParam,
3951                        bit32                agOtherInfo
3952                        )
3953 {
3954   tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
3955   tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
3956   tdsaRoot_t             *tdsaRoot      = (tdsaRoot_t *) tiRoot->tdData;
3957   tdsaContext_t          *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
3958   itdsaIni_t             *Initiator = (itdsaIni_t *)tdsaAllShared->itdsaIni;
3959   bit32                  intContext = osData->IntContext;
3960   tdIORequestBody_t      *tdIORequestBody;
3961   agsaDevHandle_t        *agDevHandle = agNULL;
3962   tiDeviceHandle_t       *tiDeviceHandle = agNULL;
3963   tdsaDeviceData_t       *oneDeviceData = agNULL;
3964   bit32                  saStatus = AGSA_RC_FAILURE;
3965
3966   TI_DBG2(("itdssXferOpenRetryTimeoutHandler: start\n"));
3967
3968   tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
3969   tiDeviceHandle = tdIORequestBody->tiDevHandle;
3970   oneDeviceData  = (tdsaDeviceData_t *)tiDeviceHandle->tdData;
3971   agDevHandle = oneDeviceData->agDevHandle;
3972
3973   if (oneDeviceData->valid == agTRUE && oneDeviceData->registered == agTRUE &&
3974       oneDeviceData->tdPortContext != agNULL )
3975   {
3976     if (tdIORequestBody->reTries < OPEN_RETRY_RETRIES) /* 10 */
3977     {
3978       saStatus = saSSPStart(agRoot,
3979                             agIORequest,
3980                             tdsaRotateQnumber(tiRoot, oneDeviceData),
3981                             agDevHandle,
3982                             tdIORequestBody->agRequestType,
3983                             &(tdIORequestBody->transport.SAS.agSASRequestBody),
3984                             agNULL,
3985                             &ossaSSPCompleted);
3986
3987       if (saStatus == AGSA_RC_SUCCESS)
3988       {
3989         TI_DBG2(("itdssXferOpenRetryTimeoutHandler: retried\n"));
3990         Initiator->NumIOsActive++;
3991         tdIORequestBody->ioStarted = agTRUE;
3992         tdIORequestBody->ioCompleted = agFALSE;
3993         tdIORequestBody->reTries++;
3994         return;
3995       }
3996       else
3997       {
3998         TI_DBG1(("itdssXferOpenRetryTimeoutHandler: retry failed\n"));
3999         tdIORequestBody->ioStarted = agFALSE;
4000         tdIORequestBody->ioCompleted = agTRUE;
4001         tdIORequestBody->reTries = 0;
4002       }
4003     }
4004     else
4005     {
4006       TI_DBG1(("itdssXferOpenRetryTimeoutHandler: retry is over and fail\n"));
4007       tdIORequestBody->reTries = 0;
4008     }
4009   }
4010   else
4011   {
4012     TI_DBG1(("itdssXferOpenRetryTimeoutHandler: not valid deivce no retry\n"));
4013     tdIORequestBody->reTries = 0;
4014   }
4015   ostiInitiatorIOCompleted(
4016                            tiRoot,
4017                            tdIORequestBody->tiIORequest,
4018                            tiIOFailed,
4019                            tiDetailOtherError,
4020                            agNULL,
4021                            intContext
4022                            );
4023   return;
4024 }
4025
4026 /*****************************************************************************
4027 *! \brief itdssPortInResetHandler
4028 *
4029 *  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
4030 *            layer with agIOStatus = OSSA_IO_PORT_IN_RESET
4031 *
4032 *  \param  agRoot:            pointer to port instance
4033 *  \param  agIORequest:       pointer to I/O request
4034 *  \param  agIOStatus:        I/O status given by LL layer
4035 *  \param  agIOInfoLen:       lenth of complete SAS RESP frame
4036 *  \param  agParam            A Handle used to refer to the response frame or handle
4037 *                             of abort request
4038 *  \param  agOtherInfo        Residual count
4039 *  \return: None
4040 *
4041 *
4042 *****************************************************************************/
4043 osGLOBAL void
4044 itdssPortInResetHandler(
4045                        agsaRoot_t           *agRoot,
4046                        agsaIORequest_t      *agIORequest,
4047                        bit32                agIOStatus,
4048                        bit32                agIOInfoLen,
4049                        void                 *agParam,
4050                        bit32                agOtherInfo
4051                        )
4052 {
4053   tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
4054   tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
4055   bit32                  intContext = osData->IntContext;
4056   tdIORequestBody_t      *tdIORequestBody;
4057   TI_DBG2(("itdssPortInResetHandler: start\n"));
4058
4059   tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
4060
4061   ostiInitiatorIOCompleted (
4062                             tiRoot,
4063                             tdIORequestBody->tiIORequest,
4064                             tiIOFailed,
4065                             tiDetailOtherError,
4066                             agNULL,
4067                             intContext
4068                             );
4069
4070   return;
4071 }
4072
4073 /*****************************************************************************
4074 *! \brief itdssDsNonOperationalHandler
4075 *
4076 *  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
4077 *            layer with agIOStatus = OSSA_IO_DS_NON_OPERATIONAL
4078 *
4079 *  \param  agRoot:            pointer to port instance
4080 *  \param  agIORequest:       pointer to I/O request
4081 *  \param  agIOStatus:        I/O status given by LL layer
4082 *  \param  agIOInfoLen:       lenth of complete SAS RESP frame
4083 *  \param  agParam            A Handle used to refer to the response frame or handle
4084 *                             of abort request
4085 *  \param  agOtherInfo        Residual count
4086 *  \return: None
4087 *
4088 *
4089 *****************************************************************************/
4090 osGLOBAL void
4091 itdssDsNonOperationalHandler(
4092                        agsaRoot_t           *agRoot,
4093                        agsaIORequest_t      *agIORequest,
4094                        bit32                agIOStatus,
4095                        bit32                agIOInfoLen,
4096                        void                 *agParam,
4097                        bit32                agOtherInfo
4098                        )
4099 {
4100   tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
4101   tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
4102   bit32                  intContext = osData->IntContext;
4103   tdIORequestBody_t      *tdIORequestBody;
4104   agsaDevHandle_t        *agDevHandle = agNULL;
4105   tiDeviceHandle_t       *tiDeviceHandle = agNULL;
4106   tdsaDeviceData_t       *oneDeviceData = agNULL;
4107
4108
4109   TI_DBG2(("itdssDsNonOperationalHandler: start\n"));
4110
4111
4112   tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
4113
4114 #if 1 /* TBD */
4115   /* let's do it only once ????? */
4116   tiDeviceHandle = tdIORequestBody->tiDevHandle;
4117   oneDeviceData  = (tdsaDeviceData_t *)tiDeviceHandle->tdData;
4118   agDevHandle = oneDeviceData->agDevHandle;
4119   if (oneDeviceData->valid == agTRUE && oneDeviceData->registered == agTRUE &&
4120       oneDeviceData->tdPortContext != agNULL )
4121   {
4122     saSetDeviceState(agRoot, agNULL, tdsaRotateQnumber(tiRoot, oneDeviceData), agDevHandle, SA_DS_OPERATIONAL);
4123   }
4124 #endif
4125
4126   ostiInitiatorIOCompleted (
4127                             tiRoot,
4128                             tdIORequestBody->tiIORequest,
4129                             tiIOFailed,
4130                             tiDetailOtherError,
4131                             agNULL,
4132                             intContext
4133                             );
4134
4135   return;
4136 }
4137
4138 /*****************************************************************************
4139 *! \brief itdssDsInRecoveryHandler
4140 *
4141 *  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
4142 *            layer with agIOStatus = OSSA_IO_DS_IN_RECOVERY
4143 *
4144 *  \param  agRoot:            pointer to port instance
4145 *  \param  agIORequest:       pointer to I/O request
4146 *  \param  agIOStatus:        I/O status given by LL layer
4147 *  \param  agIOInfoLen:       lenth of complete SAS RESP frame
4148 *  \param  agParam            A Handle used to refer to the response frame or handle
4149 *                             of abort request
4150 *  \param  agOtherInfo        Residual count
4151 *  \return: None
4152 *
4153 *
4154 *****************************************************************************/
4155 osGLOBAL void
4156 itdssDsInRecoveryHandler(
4157                        agsaRoot_t           *agRoot,
4158                        agsaIORequest_t      *agIORequest,
4159                        bit32                agIOStatus,
4160                        bit32                agIOInfoLen,
4161                        void                 *agParam,
4162                        bit32                agOtherInfo
4163                        )
4164 {
4165   tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
4166   tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
4167   bit32                  intContext = osData->IntContext;
4168   tdIORequestBody_t      *tdIORequestBody;
4169   TI_DBG2(("itdssDsInRecoveryHandler: start\n"));
4170
4171   tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
4172
4173   ostiInitiatorIOCompleted (
4174                             tiRoot,
4175                             tdIORequestBody->tiIORequest,
4176                             tiIOFailed,
4177                             tiDetailOtherError,
4178                             agNULL,
4179                             intContext
4180                             );
4181
4182   return;
4183 }
4184
4185 /*****************************************************************************
4186 *! \brief itdssTmTagNotFoundHandler
4187 *
4188 *  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
4189 *            layer with agIOStatus = OSSA_IO_TM_TAG_NOT_FOUND
4190 *
4191 *  \param  agRoot:            pointer to port instance
4192 *  \param  agIORequest:       pointer to I/O request
4193 *  \param  agIOStatus:        I/O status given by LL layer
4194 *  \param  agIOInfoLen:       lenth of complete SAS RESP frame
4195 *  \param  agParam            A Handle used to refer to the response frame or handle
4196 *                             of abort request
4197 *  \param  agOtherInfo        Residual count
4198 *  \return: None
4199 *
4200 *
4201 *****************************************************************************/
4202 osGLOBAL void
4203 itdssTmTagNotFoundHandler(
4204                        agsaRoot_t           *agRoot,
4205                        agsaIORequest_t      *agIORequest,
4206                        bit32                agIOStatus,
4207                        bit32                agIOInfoLen,
4208                        void                 *agParam,
4209                        bit32                agOtherInfo
4210                        )
4211 {
4212   tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
4213   tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
4214   bit32                  intContext = osData->IntContext;
4215   tdIORequestBody_t      *tdIORequestBody;
4216   TI_DBG2(("itdssTmTagNotFoundHandler: start\n"));
4217
4218   tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
4219
4220   ostiInitiatorIOCompleted (
4221                             tiRoot,
4222                             tdIORequestBody->tiIORequest,
4223                             tiIOFailed,
4224                             tiDetailOtherError,
4225                             agNULL,
4226                             intContext
4227                             );
4228
4229   return;
4230 }
4231
4232 /*****************************************************************************
4233 *! \brief itdssSSPExtIUZeroLenHandler
4234 *
4235 *  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
4236 *            layer with agIOStatus = OSSA_IO_SSP_EXT_IU_ZERO_LEN_ERROR
4237 *
4238 *  \param  agRoot:            pointer to port instance
4239 *  \param  agIORequest:       pointer to I/O request
4240 *  \param  agIOStatus:        I/O status given by LL layer
4241 *  \param  agIOInfoLen:       lenth of complete SAS RESP frame
4242 *  \param  agParam            A Handle used to refer to the response frame or handle
4243 *                             of abort request
4244 *  \param  agOtherInfo        Residual count
4245 *  \return: None
4246 *
4247 *
4248 *****************************************************************************/
4249 osGLOBAL void
4250 itdssSSPExtIUZeroLenHandler(
4251                        agsaRoot_t           *agRoot,
4252                        agsaIORequest_t      *agIORequest,
4253                        bit32                agIOStatus,
4254                        bit32                agIOInfoLen,
4255                        void                 *agParam,
4256                        bit32                agOtherInfo
4257                        )
4258 {
4259   tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
4260   tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
4261   bit32                  intContext = osData->IntContext;
4262   tdIORequestBody_t      *tdIORequestBody;
4263   TI_DBG2(("itdssSSPExtIUZeroLenHandler: start\n"));
4264
4265   tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
4266
4267   ostiInitiatorIOCompleted (
4268                             tiRoot,
4269                             tdIORequestBody->tiIORequest,
4270                             tiIOFailed,
4271                             tiDetailOtherError,
4272                             agNULL,
4273                             intContext
4274                             );
4275
4276   return;
4277 }
4278
4279 /*****************************************************************************
4280 *! \brief itdssXferErrorUnexpectedPhaseHandler
4281 *
4282 *  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
4283 *            layer with agIOStatus = OSSA_IO_XFER_ERROR_UNEXPECTED_PHASE
4284 *
4285 *  \param  agRoot:            pointer to port instance
4286 *  \param  agIORequest:       pointer to I/O request
4287 *  \param  agIOStatus:        I/O status given by LL layer
4288 *  \param  agIOInfoLen:       lenth of complete SAS RESP frame
4289 *  \param  agParam            A Handle used to refer to the response frame or handle
4290 *                             of abort request
4291 *  \param  agOtherInfo        Residual count
4292 *  \return: None
4293 *
4294 *
4295 *****************************************************************************/
4296 osGLOBAL void
4297 itdssXferErrorUnexpectedPhaseHandler(
4298                        agsaRoot_t           *agRoot,
4299                        agsaIORequest_t      *agIORequest,
4300                        bit32                agIOStatus,
4301                        bit32                agIOInfoLen,
4302                        void                 *agParam,
4303                        bit32                agOtherInfo
4304                        )
4305 {
4306   tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
4307   tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
4308   bit32                  intContext = osData->IntContext;
4309   tdIORequestBody_t      *tdIORequestBody;
4310   TI_DBG2(("itdssXferErrorUnexpectedPhaseHandler: start\n"));
4311
4312   tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
4313
4314   ostiInitiatorIOCompleted (
4315                             tiRoot,
4316                             tdIORequestBody->tiIORequest,
4317                             tiIOFailed,
4318                             tiDetailOtherError,
4319                             agNULL,
4320                             intContext
4321                             );
4322
4323   return;
4324 }
4325
4326 #ifdef REMOVED
4327 /*****************************************************************************
4328 *! \brief itdssIOUnderFlowWithChkConditionHandler
4329 *
4330 *  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
4331 *            layer with agIOStatus = OSSA_IO_UNDERFLOW_WITH_CHK_COND
4332 *
4333 *  \param  agRoot:            pointer to port instance
4334 *  \param  agIORequest:       pointer to I/O request
4335 *  \param  agIOStatus:        I/O status given by LL layer
4336 *  \param  agIOInfoLen:       lenth of complete SAS RESP frame
4337 *  \param  agParam            A Handle used to refer to the response frame or handle
4338 *                             of abort request
4339 *  \return: None
4340 *
4341 *
4342 *****************************************************************************/
4343 /*
4344   How to report SCSI_STAT_CHECK_CONDITION and tiIOUnderRun simultaneoulsy???
4345   ostiInitiatorIOCompleted(
4346                              tiRoot,
4347                              tdIORequestBody->tiIORequest,
4348                              tiIOSuccess,
4349                              SCSI_STAT_CHECK_CONDITION,
4350                              &senseData,
4351                              agTRUE
4352                              );
4353
4354                  vs
4355
4356   ostiInitiatorIOCompleted (
4357                             tiRoot,
4358                             tdIORequestBody->tiIORequest,
4359                             tiIOUnderRun,
4360                             agIOInfoLen,
4361                             agNULL,
4362                             intContext
4363                             );
4364
4365   For now, SCSI_STAT_CHECK_CONDITION is reported until TISA changes (as of 1/6/09)
4366   In other words, this handler is the practically same as itdssIOSuccessHandler()
4367 */
4368 osGLOBAL void
4369 itdssIOUnderFlowWithChkConditionHandler(
4370                         agsaRoot_t              *agRoot,
4371                         agsaIORequest_t         *agIORequest,
4372                         bit32                   agIOStatus,
4373                         bit32                   agIOInfoLen,
4374                         void                    *agParam
4375                         )
4376 {
4377   tdsaRootOsData_t          *osData = (tdsaRootOsData_t *)agRoot->osData;
4378   tiRoot_t                  *tiRoot = (tiRoot_t *)osData->tiRoot;
4379   tdIORequestBody_t         *tdIORequestBody;
4380   agsaSSPResponseInfoUnit_t agSSPRespIU;
4381   tiSenseData_t             senseData;
4382   bit8                      senseDataPayload[256];
4383   bit8                      respData[128];
4384   bit32                     scsi_status;
4385   bit32                     senseLen;
4386   bit32                     respLen;
4387   bit32                     data_status;
4388   bit32                     i;
4389   tiDeviceHandle_t          *tiDeviceHandle = agNULL;
4390   tdsaDeviceData_t          *oneDeviceData = agNULL;
4391
4392   TI_DBG2(("itdssIOUnderFlowWithChkConditionHandler: start\n"));
4393   TI_DBG2(("itdssIOUnderFlowWithChkConditionHandler: agIOInfoLen 0x%x\n", agIOInfoLen));
4394
4395   tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
4396
4397   tdIORequestBody->ioCompleted = agTRUE;
4398   tdIORequestBody->ioStarted = agFALSE;
4399
4400   /*
4401     agIOInfoLen must be >= sizeof(agsaSSPResponseInfoUnit_t), which is minimum
4402     date length
4403   */
4404   if (agIOInfoLen < sizeof(agsaSSPResponseInfoUnit_t))
4405   {
4406     TI_DBG1(("itdssIOUnderFlowWithChkConditionHandler: First agIOInfoLen does not match!!!\n"));
4407     TI_DBG1(("itdssIOUnderFlowWithChkConditionHandler: First agIOInfoLen 0x%x IU 0x%x\n", agIOInfoLen, (unsigned int)sizeof(agsaSSPResponseInfoUnit_t)));
4408     ostiInitiatorIOCompleted(
4409                              tiRoot,
4410                              tdIORequestBody->tiIORequest, /* tiIORequest */
4411                              tiIOFailed,
4412                              tiDetailOtherError,
4413                              agNULL,
4414                              agTRUE /* intContext; is not being used */
4415                              );
4416     return;
4417   }
4418   /* reads agsaSSPResponseInfoUnit_t */
4419   saFrameReadBlock(agRoot, agParam, 0, &agSSPRespIU, sizeof(agsaSSPResponseInfoUnit_t));
4420
4421   data_status = SA_SSPRESP_GET_DATAPRES(&agSSPRespIU);
4422   scsi_status = agSSPRespIU.status;
4423   /* endianess is invovled here */
4424   senseLen = SA_SSPRESP_GET_SENSEDATALEN(&agSSPRespIU);
4425   respLen = SA_SSPRESP_GET_RESPONSEDATALEN(&agSSPRespIU);
4426
4427   TI_DBG2(("itdssIOUnderFlowWithChkConditionHandler: dataPres=%x\n", data_status));
4428   TI_DBG2(("itdssIOUnderFlowWithChkConditionHandler: scsi status=0x%x, senselen=0x%x resplen 0x%x\n", scsi_status, senseLen, respLen));
4429
4430   /*
4431     sanity check: do not go beyond of agIOInfoLen. if happens, return error
4432     agIOInfoLen >= sizeof(agsaSSPResponseInfoUnit_t) + senseLen + respLen -> OK
4433     because frame must be divisible by 4, so there can be extra padding
4434     agIOInfoLen < sizeof(agsaSSPResponseInfoUnit_t) + senseLen + respLen -> NOT OK
4435   */
4436   if (agIOInfoLen < sizeof(agsaSSPResponseInfoUnit_t) + senseLen + respLen)
4437   {
4438     TI_DBG1(("itdssIOUnderFlowWithChkConditionHandler: Second agIOInfoLen does not match!!!\n"));
4439     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));
4440
4441     ostiInitiatorIOCompleted(
4442                              tiRoot,
4443                              tdIORequestBody->tiIORequest, /* tiIORequest */
4444                              tiIOFailed,
4445                              tiDetailOtherError,
4446                              agNULL,
4447                              agTRUE /* intContext; is not being used */
4448                              );
4449     return;
4450   }
4451
4452   /* reads response data */
4453   saFrameReadBlock(agRoot, agParam,
4454                    sizeof(agsaSSPResponseInfoUnit_t),
4455                    respData, respLen);
4456   /* reads sense data */
4457   saFrameReadBlock(agRoot, agParam,
4458                    sizeof(agsaSSPResponseInfoUnit_t)
4459                    + respLen,
4460                    senseDataPayload, senseLen);
4461
4462   if (data_status == 0)
4463   {
4464     /* NO_DATA */
4465     TI_DBG2(("itdssIOUnderFlowWithChkConditionHandler: no data\n"));
4466
4467     ostiInitiatorIOCompleted(
4468                              tiRoot,
4469                              tdIORequestBody->tiIORequest, /* tiIORequest */
4470                              tiIOSuccess,
4471                              scsi_status,
4472                              agNULL,
4473                              agTRUE /* intContext; is not being used */
4474                              );
4475
4476     return;
4477   }
4478
4479   if (data_status == 1)
4480   {
4481     /* RESPONSE_DATA */
4482     TI_DBG2(("itdssIOUnderFlowWithChkConditionHandler: response data \n"));
4483
4484     ostiInitiatorIOCompleted(
4485                              tiRoot,
4486                              tdIORequestBody->tiIORequest, /* tiIORequest */
4487                              tiIOSuccess,
4488                              0,
4489                              agNULL,
4490                              agTRUE /* intContext; is not being used */
4491                              );
4492     return;
4493   }
4494
4495   if (data_status == 2)
4496   {
4497     /* SENSE_DATA */
4498     TI_DBG2(("itdssIOUnderFlowWithChkConditionHandler: sense data \n"));
4499
4500     senseData.senseData = &senseDataPayload;
4501     senseData.senseLen = MIN(256, senseLen);
4502     /* debugging */
4503     tdhexdump("ResponseIU I", (bit8 *)&agSSPRespIU, sizeof(agsaSSPResponseInfoUnit_t));
4504
4505     tdhexdump("sense data I", (bit8 *)senseDataPayload, senseLen);
4506     tdhexdump("sense data II", (bit8 *)senseData.senseData, senseData.senseLen);
4507
4508     if (senseDataPayload[2] == SCSI_SENSE_KEY_RECOVERED_ERROR)
4509     {
4510       Initiator->SenseKeyCounter.SoftError ++;
4511     }
4512     else if (senseDataPayload[2] == SCSI_SENSE_KEY_NOT_READY)
4513     {
4514       Initiator->SenseKeyCounter.MediumNotReady++;
4515     }
4516     else if (senseDataPayload[2] == SCSI_SENSE_KEY_MEDIUM_ERROR)
4517     {
4518       Initiator->SenseKeyCounter.MediumError++;
4519     }
4520     else if (senseDataPayload[2] == SCSI_SENSE_KEY_HARDWARE_ERROR)
4521     {
4522       Initiator->SenseKeyCounter.HardwareError++;
4523     }
4524     else if (senseDataPayload[2] == SCSI_SENSE_KEY_ILLEGAL_REQUEST)
4525     {
4526       Initiator->SenseKeyCounter.IllegalRequest++;
4527     }
4528     else if (senseDataPayload[2] == SCSI_SENSE_KEY_UNIT_ATTENTION)
4529     {
4530       Initiator->SenseKeyCounter.UnitAttention++;
4531     }
4532     else if (senseDataPayload[2] == SCSI_SENSE_KEY_ABORTED_COMMAND)
4533     {
4534       Initiator->SenseKeyCounter.AbortCommand++;
4535     }
4536     else
4537     {
4538       Initiator->SenseKeyCounter.OtherKeyType++;
4539     }
4540
4541     /* when ASQ and ASCQ 0x04 0x11, does saLocalPhyControl for notify spinup */
4542     if ((senseDataPayload[12] == 0x04 && senseDataPayload[13] == 0x11))
4543     {
4544       TI_DBG2(("itdssIOUnderFlowWithChkConditionHandler: sending notfify spinup\n"));
4545       tiDeviceHandle = tdIORequestBody->tiDevHandle;
4546       oneDeviceData = (tdsaDeviceData_t *)tiDeviceHandle->tdData;
4547       if (oneDeviceData->directlyAttached == agTRUE)
4548       {
4549         for (i=0;i<TD_MAX_NUM_NOTIFY_SPINUP;i++)
4550         {
4551           saLocalPhyControl(agRoot, agNULL, 0, oneDeviceData->phyID, AGSA_PHY_NOTIFY_ENABLE_SPINUP, agNULL);
4552         }
4553       }
4554     }
4555     ostiInitiatorIOCompleted(
4556                              tiRoot,
4557                              /* tiIORequest */
4558                              tdIORequestBody->tiIORequest,
4559                              tiIOSuccess,
4560                              scsi_status,
4561                              &senseData,
4562                              agTRUE /* intContext; is not being used */
4563                              );
4564     return;
4565   }
4566   if (data_status == 3)
4567   {
4568     /* RESERVED */
4569     TI_DBG1(("itdssIOUnderFlowWithChkConditionHandler: reserved wrong!!!\n"));
4570     ostiInitiatorIOCompleted(
4571                              tiRoot,
4572                              tdIORequestBody->tiIORequest, /* tiIORequest */
4573                              tiIOFailed,
4574                              scsi_status,
4575                              agNULL,
4576                              agTRUE /* intContext; is not being used */
4577                              );
4578     return;
4579   }
4580
4581
4582   return;
4583 }
4584 #endif
4585
4586 /*****************************************************************************
4587 *! \brief itdssXferOpenRetryBackoffThresholdReachedHandler
4588 *
4589 *  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
4590 *            layer with agIOStatus =
4591 *            OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_RETRY_BACKOFF_THRESHOLD_REACHED
4592 *
4593 *  \param  agRoot:            pointer to port instance
4594 *  \param  agIORequest:       pointer to I/O request
4595 *  \param  agIOStatus:        I/O status given by LL layer
4596 *  \param  agIOInfoLen:       lenth of complete SAS RESP frame
4597 *  \param  agParam            A Handle used to refer to the response frame or handle
4598 *                             of abort request
4599 *  \param  agOtherInfo        Residual count
4600 *  \return: None
4601 *
4602 *
4603 *****************************************************************************/
4604 osGLOBAL void
4605 itdssXferOpenRetryBackoffThresholdReachedHandler(
4606                                                  agsaRoot_t           *agRoot,
4607                                                  agsaIORequest_t      *agIORequest,
4608                                                  bit32                agIOStatus,
4609                                                  bit32                agIOInfoLen,
4610                                                  void                 *agParam,
4611                                                  bit32                agOtherInfo
4612                                                 )
4613 {
4614   tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
4615   tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
4616   bit32                  intContext = osData->IntContext;
4617   tdIORequestBody_t      *tdIORequestBody;
4618   TI_DBG2(("itdssXferOpenRetryBackoffThresholdReachedHandler: start\n"));
4619
4620   tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
4621
4622   ostiInitiatorIOCompleted (
4623                             tiRoot,
4624                             tdIORequestBody->tiIORequest,
4625                             tiIOFailed,
4626                             tiDetailOtherError,
4627                             agNULL,
4628                             intContext
4629                             );
4630
4631   return;
4632 }
4633
4634 /*****************************************************************************
4635 *! \brief itdssOpenCnxErrorItNexusLossOpenTmoHandler
4636 *
4637 *  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
4638 *            layer with agIOStatus = OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_TMO
4639 *
4640 *  \param  agRoot:            pointer to port instance
4641 *  \param  agIORequest:       pointer to I/O request
4642 *  \param  agIOStatus:        I/O status given by LL layer
4643 *  \param  agIOInfoLen:       lenth of complete SAS RESP frame
4644 *  \param  agParam            A Handle used to refer to the response frame or handle
4645 *                             of abort request
4646 *  \param  agOtherInfo        Residual count
4647 *  \return: None
4648 *
4649 *
4650 *****************************************************************************/
4651 osGLOBAL void
4652 itdssOpenCnxErrorItNexusLossOpenTmoHandler(
4653                                            agsaRoot_t           *agRoot,
4654                                            agsaIORequest_t      *agIORequest,
4655                                            bit32                agIOStatus,
4656                                            bit32                agIOInfoLen,
4657                                            void                 *agParam,
4658                                            bit32                agOtherInfo
4659                                           )
4660 {
4661   tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
4662   tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
4663   bit32                  intContext = osData->IntContext;
4664   tdIORequestBody_t      *tdIORequestBody;
4665   TI_DBG2(("itdssOpenCnxErrorItNexusLossOpenTmoHandler: start\n"));
4666
4667   tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
4668
4669   ostiInitiatorIOCompleted (
4670                             tiRoot,
4671                             tdIORequestBody->tiIORequest,
4672                             tiIOFailed,
4673                             tiDetailOtherError,
4674                             agNULL,
4675                             intContext
4676                             );
4677
4678   return;
4679 }
4680
4681 /*****************************************************************************
4682 *! \brief itdssOpenCnxErrorItNexusLossNoDestHandler
4683 *
4684 *  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
4685 *            layer with agIOStatus = OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_NO_DEST
4686 *
4687 *  \param  agRoot:            pointer to port instance
4688 *  \param  agIORequest:       pointer to I/O request
4689 *  \param  agIOStatus:        I/O status given by LL layer
4690 *  \param  agIOInfoLen:       lenth of complete SAS RESP frame
4691 *  \param  agParam            A Handle used to refer to the response frame or handle
4692 *                             of abort request
4693 *  \param  agOtherInfo        Residual count
4694 *  \return: None
4695 *
4696 *
4697 *****************************************************************************/
4698 osGLOBAL void
4699 itdssOpenCnxErrorItNexusLossNoDestHandler(
4700                                           agsaRoot_t           *agRoot,
4701                                           agsaIORequest_t      *agIORequest,
4702                                           bit32                agIOStatus,
4703                                           bit32                agIOInfoLen,
4704                                           void                 *agParam,
4705                                           bit32                agOtherInfo
4706                                          )
4707 {
4708   tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
4709   tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
4710   bit32                  intContext = osData->IntContext;
4711   tdIORequestBody_t      *tdIORequestBody;
4712   TI_DBG2(("itdssOpenCnxErrorItNexusLossNoDestHandler: start\n"));
4713
4714   tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
4715
4716   ostiInitiatorIOCompleted (
4717                             tiRoot,
4718                             tdIORequestBody->tiIORequest,
4719                             tiIOFailed,
4720                             tiDetailOtherError,
4721                             agNULL,
4722                             intContext
4723                             );
4724
4725   return;
4726 }
4727
4728 /*****************************************************************************
4729 *! \brief itdssOpenCnxErrorItNexusLossOpenCollideHandler
4730 *
4731 *  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
4732 *            layer with agIOStatus = OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_COLLIDE
4733 *
4734 *  \param  agRoot:            pointer to port instance
4735 *  \param  agIORequest:       pointer to I/O request
4736 *  \param  agIOStatus:        I/O status given by LL layer
4737 *  \param  agIOInfoLen:       lenth of complete SAS RESP frame
4738 *  \param  agParam            A Handle used to refer to the response frame or handle
4739 *                             of abort request
4740 *  \param  agOtherInfo        Residual count
4741 *  \return: None
4742 *
4743 *
4744 *****************************************************************************/
4745 osGLOBAL void
4746 itdssOpenCnxErrorItNexusLossOpenCollideHandler(
4747                                                agsaRoot_t           *agRoot,
4748                                                agsaIORequest_t      *agIORequest,
4749                                                bit32                agIOStatus,
4750                                                bit32                agIOInfoLen,
4751                                                void                 *agParam,
4752                                                bit32                agOtherInfo
4753                                               )
4754 {
4755   tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
4756   tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
4757   bit32                  intContext = osData->IntContext;
4758   tdIORequestBody_t      *tdIORequestBody;
4759   TI_DBG2(("itdssOpenCnxErrorItNexusLossOpenCollideHandler: start\n"));
4760
4761   tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
4762
4763   ostiInitiatorIOCompleted (
4764                             tiRoot,
4765                             tdIORequestBody->tiIORequest,
4766                             tiIOFailed,
4767                             tiDetailOtherError,
4768                             agNULL,
4769                             intContext
4770                             );
4771
4772   return;
4773 }
4774
4775 /*****************************************************************************
4776 *! \brief itdssOpenCnxErrorItNexusLossOpenPathwayBlockedHandler
4777 *
4778 *  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
4779 *            layer with agIOStatus = OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_PATHWAY_BLOCKED
4780 *
4781 *  \param  agRoot:            pointer to port instance
4782 *  \param  agIORequest:       pointer to I/O request
4783 *  \param  agIOStatus:        I/O status given by LL layer
4784 *  \param  agIOInfoLen:       lenth of complete SAS RESP frame
4785 *  \param  agParam            A Handle used to refer to the response frame or handle
4786 *                             of abort request
4787 *  \param  agOtherInfo        Residual count
4788 *  \return: None
4789 *
4790 *
4791 *****************************************************************************/
4792 osGLOBAL void
4793 itdssOpenCnxErrorItNexusLossOpenPathwayBlockedHandler(
4794                                                       agsaRoot_t           *agRoot,
4795                                                       agsaIORequest_t      *agIORequest,
4796                                                       bit32                agIOStatus,
4797                                                       bit32                agIOInfoLen,
4798                                                       void                 *agParam,
4799                                                       bit32                agOtherInfo
4800                                                      )
4801 {
4802   tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
4803   tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
4804   bit32                  intContext = osData->IntContext;
4805   tdIORequestBody_t      *tdIORequestBody;
4806   TI_DBG2(("itdssOpenCnxErrorItNexusLossOpenPathwayBlockedHandler: start\n"));
4807
4808   tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
4809
4810   ostiInitiatorIOCompleted (
4811                             tiRoot,
4812                             tdIORequestBody->tiIORequest,
4813                             tiIOFailed,
4814                             tiDetailOtherError,
4815                             agNULL,
4816                             intContext
4817                             );
4818
4819   return;
4820 }
4821
4822 /*****************************************************************************
4823 *! \brief itdssEncryptionHandler
4824 *
4825 *  Purpose:  This function processes I/Os completed and returned by SAS lower
4826 *            layer with any encryption specific agIOStatus.
4827 *
4828 *  \param  agRoot:            pointer to port instance
4829 *  \param  agIORequest:       pointer to I/O request
4830 *  \param  agIOStatus:        I/O status given by LL layer
4831 *  \param  agIOInfoLen:       lenth of complete SAS RESP frame
4832 *  \param  agParam            A Handle used to refer to the response frame or handle
4833 *                             of abort request
4834 *  \return: None
4835 *
4836 *
4837 *****************************************************************************/
4838 osGLOBAL void
4839 itdssEncryptionHandler (
4840                        agsaRoot_t              *agRoot,
4841                        agsaIORequest_t         *agIORequest,
4842                        bit32                   agIOStatus,
4843                        bit32                   agIOInfoLen,
4844                        void                    *agParam,
4845                        bit32                   agOtherInfo
4846                        )
4847 {
4848   tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
4849   tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
4850   bit32                  intContext = osData->IntContext;
4851   bit32                  errorDetail = tiDetailOtherError;
4852   tdIORequestBody_t      *tdIORequestBody;
4853   TI_DBG1(("itdssEncryptionHandler: start\n"));
4854   TI_DBG1(("itdssEncryptionHandler: agIOStatus 0x%x\n", agIOStatus));
4855
4856   tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
4857
4858   switch (agIOStatus)
4859   {
4860   case OSSA_IO_XFR_ERROR_DEK_KEY_CACHE_MISS:
4861       TI_DBG1(("itdssEncryptionHandler: OSSA_IO_XFR_ERROR_DEK_KEY_CACHE_MISS\n"));
4862       errorDetail = tiDetailDekKeyCacheMiss;
4863       break;
4864   case OSSA_IO_XFR_ERROR_CIPHER_MODE_INVALID:
4865       TI_DBG1(("itdssEncryptionHandler: OSSA_IO_XFR_ERROR_CIPHER_MODE_INVALID\n"));
4866       errorDetail = tiDetailCipherModeInvalid;
4867       break;
4868   case OSSA_IO_XFR_ERROR_DEK_IV_MISMATCH:
4869       TI_DBG1(("itdssEncryptionHandler: OSSA_IO_XFR_ERROR_DEK_IV_MISMATCH\n"));
4870       errorDetail = tiDetailDekIVMismatch;
4871       break;
4872   case OSSA_IO_XFR_ERROR_DEK_RAM_INTERFACE_ERROR:
4873       TI_DBG1(("itdssEncryptionHandler: OSSA_IO_XFR_ERROR_DEK_RAM_INTERFACE_ERROR\n"));
4874       errorDetail = tiDetailDekRamInterfaceError;
4875       break;
4876   case OSSA_IO_XFR_ERROR_DEK_INDEX_OUT_OF_BOUNDS:
4877       TI_DBG1(("itdssEncryptionHandler: OSSA_IO_XFR_ERROR_DEK_INDEX_OUT_OF_BOUNDS\n"));
4878       errorDetail = tiDetailDekIndexOutofBounds;
4879       break;
4880   case OSSA_IO_XFR_ERROR_DEK_ILLEGAL_TABLE:
4881       TI_DBG1(("itdssEncryptionHandler: OSSA_IO_XFR_ERROR_DEK_ILLEGAL_TABLE\n"));
4882       errorDetail = tiDetailOtherError;
4883       break;
4884   default:
4885       TI_DBG1(("itdssEncryptionHandler: other error!!! 0x%x\n", agIOStatus));
4886       errorDetail = tiDetailOtherError;
4887       break;
4888   }
4889
4890   ostiInitiatorIOCompleted (
4891                             tiRoot,
4892                             tdIORequestBody->tiIORequest,
4893                             tiIOEncryptError,
4894                             errorDetail,
4895                             agNULL,
4896                             intContext
4897                             );
4898   return;
4899 }
4900
4901 /*****************************************************************************
4902 *! \brief itdssDifHandler
4903 *
4904 *  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
4905 *            layer with any DIF specific agIOStatus
4906 *
4907 *  \param  agRoot:            pointer to port instance
4908 *  \param  agIORequest:       pointer to I/O request
4909 *  \param  agIOStatus:        I/O status given by LL layer
4910 *  \param  agIOInfoLen:       lenth of complete SAS RESP frame
4911 *  \param  agParam            A Handle used to refer to the response frame or handle
4912 *                             of abort request
4913 *  \param  agOtherInfo        Residual count
4914 *  \return: None
4915 *
4916 *
4917 *****************************************************************************/
4918 osGLOBAL void
4919 itdssDifHandler(
4920                 agsaRoot_t           *agRoot,
4921                 agsaIORequest_t      *agIORequest,
4922                 bit32                agIOStatus,
4923                 bit32                agIOInfoLen,
4924                 void                 *agParam,
4925                 bit32                agOtherInfo
4926                )
4927 {
4928   tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
4929   tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
4930   bit32                  intContext = osData->IntContext;
4931   bit32                  errorDetail = tiDetailOtherError;
4932   tdIORequestBody_t      *tdIORequestBody;
4933 #ifdef  TD_DEBUG_ENABLE
4934   agsaDifDetails_t       *DifDetail;
4935 #endif
4936
4937   TI_DBG1(("itdssDifHandler: start\n"));
4938   TI_DBG1(("itdssDifHandler: agIOStatus 0x%x\n", agIOStatus));
4939   tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
4940 #ifdef  TD_DEBUG_ENABLE
4941   DifDetail = (agsaDifDetails_t *)agParam;
4942 #endif
4943   switch (agIOStatus)
4944   {
4945   case OSSA_IO_XFR_ERROR_DIF_MISMATCH:
4946       errorDetail = tiDetailDifMismatch;
4947       TI_DBG1(("itdssDifHandler: OSSA_IO_XFR_ERROR_DIF_MISMATCH\n"));
4948       break;
4949   case OSSA_IO_XFR_ERROR_DIF_APPLICATION_TAG_MISMATCH:
4950       errorDetail = tiDetailDifAppTagMismatch;
4951       TI_DBG1(("itdssDifHandler: OSSA_IO_XFR_ERROR_DIF_APPLICATION_TAG_MISMATCH\n"));
4952       break;
4953   case OSSA_IO_XFR_ERROR_DIF_REFERENCE_TAG_MISMATCH:
4954       errorDetail = tiDetailDifRefTagMismatch;
4955       TI_DBG1(("itdssDifHandler: OSSA_IO_XFR_ERROR_DIF_REFERENCE_TAG_MISMATCH\n"));
4956       break;
4957   case OSSA_IO_XFR_ERROR_DIF_CRC_MISMATCH:
4958       errorDetail = tiDetailDifCrcMismatch;
4959       TI_DBG1(("itdssDifHandler: OSSA_IO_XFR_ERROR_DIF_CRC_MISMATCH\n"));
4960       break;
4961   default:
4962       errorDetail = tiDetailOtherError;
4963       TI_DBG1(("itdssDifHandler: other error!!! 0x%x\n", agIOStatus));
4964       break;
4965   }
4966   TI_DBG1(("itdssDifHandler: DIF detail UpperLBA 0x%08x LowerLBA 0x%08x\n", DifDetail->UpperLBA, DifDetail->LowerLBA));
4967   ostiInitiatorIOCompleted (
4968                             tiRoot,
4969                             tdIORequestBody->tiIORequest,
4970                             tiIODifError,
4971                             errorDetail,
4972                             agNULL,
4973                             intContext
4974                             );
4975   return;
4976 }
4977
4978 /*****************************************************************************
4979 *! \brief itdssIOResourceUnavailableHandler
4980 *
4981 *  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
4982 *            layer with agIOStatus = OSSA_MPI_ERR_IO_RESOURCE_UNAVAILABLE
4983 *
4984 *  \param  agRoot:            pointer to port instance
4985 *  \param  agIORequest:       pointer to I/O request
4986 *  \param  agIOStatus:        I/O status given by LL layer
4987 *  \param  agIOInfoLen:       lenth of complete SAS RESP frame
4988 *  \param  agParam            A Handle used to refer to the response frame or handle
4989 *                             of abort request
4990 *  \param  agOtherInfo        Residual count
4991 *  \return: None
4992 *
4993 *
4994 *****************************************************************************/
4995 osGLOBAL void
4996 itdssIOResourceUnavailableHandler(
4997                                   agsaRoot_t              *agRoot,
4998                                   agsaIORequest_t         *agIORequest,
4999                                   bit32                   agIOStatus,
5000                                   bit32                   agIOInfoLen,
5001                                   void                    *agParam,
5002                                   bit32                   agOtherInfo
5003                                  )
5004 {
5005   tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
5006   tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
5007   bit32                  intContext = osData->IntContext;
5008   tdIORequestBody_t      *tdIORequestBody;
5009   TI_DBG2(("itdssIOResourceUnavailableHandler: start\n"));
5010   TI_DBG2(("itdssIOResourceUnavailableHandler: agIOStatus 0x%x\n", agIOStatus));
5011
5012   tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
5013
5014   ostiInitiatorIOCompleted (
5015                             tiRoot,
5016                             tdIORequestBody->tiIORequest,
5017                             tiIOFailed,
5018                             tiDetailBusy,
5019                             agNULL,
5020                             intContext
5021                             );
5022   return;
5023 }
5024 /*****************************************************************************
5025 *! \brief itdssIORQEBusyFullHandler
5026 *
5027 *  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
5028 *            layer with agIOStatus = OSSA_MPI_IO_RQE_BUSY_FULL
5029 *
5030 *  \param  agRoot:            pointer to port instance
5031 *  \param  agIORequest:       pointer to I/O request
5032 *  \param  agIOStatus:        I/O status given by LL layer
5033 *  \param  agIOInfoLen:       lenth of complete SAS RESP frame
5034 *  \param  agParam            A Handle used to refer to the response frame or handle
5035 *                             of abort request
5036 *  \param  agOtherInfo        Residual count
5037 *  \return: None
5038 *
5039 *
5040 *****************************************************************************/
5041 osGLOBAL void
5042 itdssIORQEBusyFullHandler(
5043                                   agsaRoot_t              *agRoot,
5044                                   agsaIORequest_t         *agIORequest,
5045                                   bit32                   agIOStatus,
5046                                   bit32                   agIOInfoLen,
5047                                   void                    *agParam,
5048                                   bit32                   agOtherInfo
5049                                  )
5050 {
5051   tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
5052   tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
5053   bit32                  intContext = osData->IntContext;
5054   tdIORequestBody_t      *tdIORequestBody;
5055   TI_DBG2(("itdssIORQEBusyFullHandler: start\n"));
5056   TI_DBG2(("itdssIORQEBusyFullHandler: agIOStatus 0x%x\n", agIOStatus));
5057
5058   tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
5059
5060   ostiInitiatorIOCompleted (
5061                             tiRoot,
5062                             tdIORequestBody->tiIORequest,
5063                             tiIOFailed,
5064                             tiDetailBusy,
5065                             agNULL,
5066                             intContext
5067                             );
5068   return;
5069 }
5070
5071 /*****************************************************************************
5072 *! \brief itdssXferErrorInvalidSSPRspFrameHandler
5073 *
5074 *  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
5075 *            layer with agIOStatus = OSSA_IO_XFR_ERROR_INVALID_SSP_RSP_FRAME
5076 *
5077 *  \param  agRoot:            pointer to port instance
5078 *  \param  agIORequest:       pointer to I/O request
5079 *  \param  agIOStatus:        I/O status given by LL layer
5080 *  \param  agIOInfoLen:       lenth of complete SAS RESP frame
5081 *  \param  agParam            A Handle used to refer to the response frame or handle
5082 *                             of abort request
5083 *  \param  agOtherInfo        Residual count
5084 *  \return: None
5085 *
5086 *
5087 *****************************************************************************/
5088 osGLOBAL void
5089 itdssXferErrorInvalidSSPRspFrameHandler(
5090                                   agsaRoot_t              *agRoot,
5091                                   agsaIORequest_t         *agIORequest,
5092                                   bit32                   agIOStatus,
5093                                   bit32                   agIOInfoLen,
5094                                   void                    *agParam,
5095                                   bit32                   agOtherInfo
5096                                  )
5097 {
5098   tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
5099   tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
5100   bit32                  intContext = osData->IntContext;
5101   tdIORequestBody_t      *tdIORequestBody;
5102   TI_DBG2(("itdssXferErrorInvalidSSPRspFrameHandler: start\n"));
5103   TI_DBG2(("itdssXferErrorInvalidSSPRspFrameHandler: agIOStatus 0x%x\n", agIOStatus));
5104
5105   tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
5106
5107   ostiInitiatorIOCompleted (
5108                             tiRoot,
5109                             tdIORequestBody->tiIORequest,
5110                             tiIOFailed,
5111                             tiDetailOtherError,
5112                             agNULL,
5113                             intContext
5114                             );
5115   return;
5116 }
5117
5118 /*****************************************************************************
5119 *! \brief itdssXferErrorEOBDataOverrunHandler
5120 *
5121 *  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
5122 *            layer with agIOStatus = OSSA_IO_XFER_ERR_EOB_DATA_OVERRUN
5123 *
5124 *  \param  agRoot:            pointer to port instance
5125 *  \param  agIORequest:       pointer to I/O request
5126 *  \param  agIOStatus:        I/O status given by LL layer
5127 *  \param  agIOInfoLen:       lenth of complete SAS RESP frame
5128 *  \param  agParam            A Handle used to refer to the response frame or handle
5129 *                             of abort request
5130 *  \param  agOtherInfo        Residual count
5131 *  \return: None
5132 *
5133 *
5134 *****************************************************************************/
5135 osGLOBAL void
5136 itdssXferErrorEOBDataOverrunHandler(
5137                                   agsaRoot_t              *agRoot,
5138                                   agsaIORequest_t         *agIORequest,
5139                                   bit32                   agIOStatus,
5140                                   bit32                   agIOInfoLen,
5141                                   void                    *agParam,
5142                                   bit32                   agOtherInfo
5143                                  )
5144 {
5145   tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
5146   tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
5147   bit32                  intContext = osData->IntContext;
5148   tdIORequestBody_t      *tdIORequestBody;
5149   TI_DBG2(("itdssXferErrorEOBDataOverrunHandler: start\n"));
5150   TI_DBG2(("itdssXferErrorEOBDataOverrunHandler: agIOStatus 0x%x\n", agIOStatus));
5151
5152   tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
5153
5154   ostiInitiatorIOCompleted (
5155                             tiRoot,
5156                             tdIORequestBody->tiIORequest,
5157                             tiIOFailed,
5158                             tiDetailOtherError,
5159                             agNULL,
5160                             intContext
5161                             );
5162   return;
5163 }
5164
5165 /*****************************************************************************
5166 *! \brief itdssOpenCnxErrorOpenPreemptedHandler
5167 *
5168 *  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
5169 *            layer with agIOStatus = OSSA_IO_OPEN_CNX_ERROR_OPEN_PREEMPTED
5170 *
5171 *  \param  agRoot:            pointer to port instance
5172 *  \param  agIORequest:       pointer to I/O request
5173 *  \param  agIOStatus:        I/O status given by LL layer
5174 *  \param  agIOInfoLen:       lenth of complete SAS RESP frame
5175 *  \param  agParam            A Handle used to refer to the response frame or handle
5176 *                             of abort request
5177 *  \param  agOtherInfo        Residual count
5178 *  \return: None
5179 *
5180 *
5181 *****************************************************************************/
5182 osGLOBAL void
5183 itdssOpenCnxErrorOpenPreemptedHandler(
5184                                   agsaRoot_t              *agRoot,
5185                                   agsaIORequest_t         *agIORequest,
5186                                   bit32                   agIOStatus,
5187                                   bit32                   agIOInfoLen,
5188                                   void                    *agParam,
5189                                   bit32                   agOtherInfo
5190                                  )
5191 {
5192   tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
5193   tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
5194   bit32                  intContext = osData->IntContext;
5195   tdIORequestBody_t      *tdIORequestBody;
5196   TI_DBG2(("itdssOpenCnxErrorOpenPreemptedHandler: start\n"));
5197   TI_DBG2(("itdssOpenCnxErrorOpenPreemptedHandler: agIOStatus 0x%x\n", agIOStatus));
5198
5199   tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
5200
5201   ostiInitiatorIOCompleted (
5202                             tiRoot,
5203                             tdIORequestBody->tiIORequest,
5204                             tiIOFailed,
5205                             tiDetailOtherError,
5206                             agNULL,
5207                             intContext
5208                             );
5209   return;
5210 }
5211
5212 /* default */
5213 /*****************************************************************************
5214 *! \brief itdssIODefaultHandler
5215 *
5216 *  Purpose:  This function processes I/Os completed and returned by SAS/SATA lower
5217 *            layer with agIOStatus = unspecified
5218 *
5219 *  \param  agRoot:            pointer to port instance
5220 *  \param  agIORequest:       pointer to I/O request
5221 *  \param  agIOStatus:        I/O status given by LL layer
5222 *  \param  agIOInfoLen:       lenth of complete SAS RESP frame
5223 *  \param  agParam            A Handle used to refer to the response frame or handle
5224 *                             of abort request
5225 *  \param  agOtherInfo        Residual count
5226 *  \return: None
5227 *
5228 *
5229 *****************************************************************************/
5230 osGLOBAL void
5231 itdssIODefaultHandler (
5232                        agsaRoot_t              *agRoot,
5233                        agsaIORequest_t         *agIORequest,
5234                        bit32                   agIOStatus,
5235                        bit32                   agIOInfoLen,
5236                        void                    *agParam,
5237                        bit32                   agOtherInfo
5238                        )
5239 {
5240   tdsaRootOsData_t       *osData = (tdsaRootOsData_t *)agRoot->osData;
5241   tiRoot_t               *tiRoot = (tiRoot_t *)osData->tiRoot;
5242   bit32                  intContext = osData->IntContext;
5243   tdIORequestBody_t      *tdIORequestBody;
5244   TI_DBG2(("itdssIODefaultHandler: start\n"));
5245   TI_DBG2(("itdssIODefaultHandler: agIOStatus 0x%x\n", agIOStatus));
5246
5247   tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
5248
5249   ostiInitiatorIOCompleted (
5250                             tiRoot,
5251                             tdIORequestBody->tiIORequest,
5252                             tiIOFailed,
5253                             tiDetailOtherError,
5254                             agNULL,
5255                             intContext
5256                             );
5257   return;
5258 }
5259
5260 /*****************************************************************************
5261 *! \brief itdssIOForDebugging1Completed
5262 *
5263 *  Purpose:  This function is only for debugging. This function should NOT be
5264 *            called.
5265 *
5266 *  \param  agRoot:            pointer to port instance
5267 *  \param  agIORequest:       pointer to I/O request
5268 *  \param  agIOStatus:        I/O status given by LL layer
5269 *  \param  agIOInfoLen:       lenth of complete SAS RESP frame
5270 *  \param  agParam            A Handle used to refer to the response frame or handle
5271 *                             of abort request
5272 *  \param  agOtherInfo        Residual count
5273 *  \return: None
5274 *
5275 *
5276 *****************************************************************************/
5277 osGLOBAL void
5278 itdssIOForDebugging1Completed(
5279                  agsaRoot_t             *agRoot,
5280                  agsaIORequest_t        *agIORequest,
5281                  bit32                  agIOStatus,
5282                  bit32                  agIOInfoLen,
5283                  void                   *agParam,
5284                  bit32                  agOtherInfo
5285                  )
5286 {
5287   TI_DBG1(("itdssIOForDebugging1Completed: start, error!!! can't be called. \n"));
5288 }
5289
5290 /*****************************************************************************
5291 *! \brief itdssIOForDebugging2Completed
5292 *
5293 *  Purpose:  This function is only for debugging. This function should NOT be
5294 *            called.
5295 *
5296 *  \param  agRoot:            pointer to port instance
5297 *  \param  agIORequest:       pointer to I/O request
5298 *  \param  agIOStatus:        I/O status given by LL layer
5299 *  \param  agIOInfoLen:       lenth of complete SAS RESP frame
5300 *  \param  agParam            A Handle used to refer to the response frame or handle
5301 *                             of abort request
5302 *  \param  agOtherInfo        Residual count
5303 *  \return: None
5304 *
5305 *
5306 *****************************************************************************/
5307 osGLOBAL void
5308 itdssIOForDebugging2Completed(
5309                  agsaRoot_t             *agRoot,
5310                  agsaIORequest_t        *agIORequest,
5311                  bit32                  agIOStatus,
5312                  bit32                  agIOInfoLen,
5313                  void                   *agParam,
5314                  bit32                  agOtherInfo
5315                  )
5316 {
5317   TI_DBG1(("itdssIOForDebugging2Completed: start, error!!! can't be called.  \n"));
5318 }
5319
5320 /*****************************************************************************
5321 *! \brief itdssIOForDebugging3Completed
5322 *
5323 *  Purpose:  This function is only for debugging. This function should NOT be
5324 *            called.
5325 *
5326 *  \param  agRoot:            pointer to port instance
5327 *  \param  agIORequest:       pointer to I/O request
5328 *  \param  agIOStatus:        I/O status given by LL layer
5329 *  \param  agIOInfoLen:       lenth of complete SAS RESP frame
5330 *  \param  agParam            A Handle used to refer to the response frame or handle
5331 *                             of abort request
5332 *  \param  agOtherInfo        Residual count
5333 *  \return: None
5334 *
5335 *
5336 *****************************************************************************/
5337 osGLOBAL void
5338 itdssIOForDebugging3Completed(
5339                  agsaRoot_t             *agRoot,
5340                  agsaIORequest_t        *agIORequest,
5341                  bit32                  agIOStatus,
5342                  bit32                  agIOInfoLen,
5343                  void                   *agParam,
5344                  bit32                  agOtherInfo
5345                  )
5346 {
5347   TI_DBG1(("itdssIOForDebugging3Completed: start, error!!! can't be called.  \n"));
5348 }
5349
5350