FreeBSD kernel pms device code
itdcb.c
Go to the documentation of this file.
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/*****************************************************************************/
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*****************************************************************************/
98osGLOBAL void
99itdssTaskCompleted(
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*****************************************************************************/
489osGLOBAL void
490itdssQueryTaskCompleted(
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*****************************************************************************/
775FORCEINLINE void
776itdssIOCompleted(
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*****************************************************************************/
1342osGLOBAL void
1343itdssSMPCompleted (
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
2044osGLOBAL void
2045itdssSMPCompleted (
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*****************************************************************************/
2076osGLOBAL void
2077itdssIOSuccessHandler(
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*/
2315osGLOBAL void
2316itdssIOAbortedHandler (
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*****************************************************************************/
2393osGLOBAL void
2394itdssIOOverFlowHandler(
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*****************************************************************************/
2443osGLOBAL void
2444itdssIOUnderFlowHandler(
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*****************************************************************************/
2492osGLOBAL void
2493itdssIOFailedHandler(
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*****************************************************************************/
2539osGLOBAL void
2540itdssIOAbortResetHandler(
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*****************************************************************************/
2587osGLOBAL void
2588itdssIONotValidHandler(
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*****************************************************************************/
2633osGLOBAL void
2634itdssIONoDeviceHandler(
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*****************************************************************************/
2679osGLOBAL void
2680itdssIllegalParameterHandler(
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*****************************************************************************/
2726osGLOBAL void
2727itdssLinkFailureHandler(
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*****************************************************************************/
2773osGLOBAL void
2774itdssProgErrorHandler(
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*****************************************************************************/
2820osGLOBAL void
2821itdssXferErrorBreakHandler(
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*****************************************************************************/
2867osGLOBAL void
2868itdssXferErrorPhyNotReadyHandler(
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*****************************************************************************/
2914osGLOBAL void
2915itdssOpenCnxErrorProtocolNotSupprotedHandler(
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*****************************************************************************/
2961osGLOBAL void
2962itdssOpenCnxErrorZoneViolationHandler(
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*****************************************************************************/
3008osGLOBAL void
3009itdssOpenCnxErrorBreakHandler(
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*****************************************************************************/
3055osGLOBAL void
3056itdssOpenCnxErrorITNexusLossHandler(
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*****************************************************************************/
3102osGLOBAL void
3103itdssOpenCnxErrorBadDestinationHandler(
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*****************************************************************************/
3149osGLOBAL void
3150itdssOpenCnxErrorConnectionRateNotSupportedHandler(
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*****************************************************************************/
3239osGLOBAL void
3240itdssOpenCnxErrorSTPResourceBusyHandler(
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*****************************************************************************/
3286osGLOBAL void
3287itdssOpenCnxErrorWrongDestinationHandler(
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*****************************************************************************/
3333osGLOBAL void
3334itdssOpenCnxErrorUnknownErrorHandler(
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*****************************************************************************/
3380osGLOBAL void
3381itdssXferErrorNAKReceivedHandler(
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*****************************************************************************/
3427osGLOBAL void
3428itdssXferErrorACKNAKTimeoutHandler(
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*****************************************************************************/
3474osGLOBAL void
3475itdssXferErrorPeerAbortedHandler(
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*****************************************************************************/
3521osGLOBAL void
3522itdssXferErrorRxFrameHandler(
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*****************************************************************************/
3568osGLOBAL void
3569itdssXferErrorDMAHandler(
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*****************************************************************************/
3615osGLOBAL void
3616itdssXferErrorCreditTimeoutHandler(
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*****************************************************************************/
3662osGLOBAL void
3663itdssXferErrorCMDIssueACKNAKTimeoutHandler(
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*****************************************************************************/
3709osGLOBAL void
3710itdssXferErrorCMDIssueBreakBeforeACKNAKHandler(
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*****************************************************************************/
3756osGLOBAL void
3757itdssXferErrorCMDIssuePhyDownBeforeACKNAKHandler(
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*****************************************************************************/
3803osGLOBAL void
3804itdssXferErrorDisruptedPhyDownHandler(
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*****************************************************************************/
3850osGLOBAL void
3851itdssXferErrorOffsetMismatchHandler(
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*****************************************************************************/
3897osGLOBAL void
3898itdssXferErrorXferZeroDataLenHandler(
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*****************************************************************************/
3944osGLOBAL void
3945itdssXferOpenRetryTimeoutHandler(
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*****************************************************************************/
4043osGLOBAL void
4044itdssPortInResetHandler(
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*****************************************************************************/
4090osGLOBAL void
4091itdssDsNonOperationalHandler(
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*****************************************************************************/
4155osGLOBAL void
4156itdssDsInRecoveryHandler(
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*****************************************************************************/
4202osGLOBAL void
4203itdssTmTagNotFoundHandler(
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*****************************************************************************/
4249osGLOBAL void
4250itdssSSPExtIUZeroLenHandler(
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*****************************************************************************/
4296osGLOBAL void
4297itdssXferErrorUnexpectedPhaseHandler(
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*/
4368osGLOBAL void
4369itdssIOUnderFlowWithChkConditionHandler(
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*****************************************************************************/
4604osGLOBAL void
4605itdssXferOpenRetryBackoffThresholdReachedHandler(
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*****************************************************************************/
4651osGLOBAL void
4652itdssOpenCnxErrorItNexusLossOpenTmoHandler(
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*****************************************************************************/
4698osGLOBAL void
4699itdssOpenCnxErrorItNexusLossNoDestHandler(
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*****************************************************************************/
4745osGLOBAL void
4746itdssOpenCnxErrorItNexusLossOpenCollideHandler(
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*****************************************************************************/
4792osGLOBAL void
4793itdssOpenCnxErrorItNexusLossOpenPathwayBlockedHandler(
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*****************************************************************************/
4838osGLOBAL void
4839itdssEncryptionHandler (
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*****************************************************************************/
4918osGLOBAL void
4919itdssDifHandler(
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*****************************************************************************/
4995osGLOBAL void
4996itdssIOResourceUnavailableHandler(
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*****************************************************************************/
5041osGLOBAL void
5042itdssIORQEBusyFullHandler(
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*****************************************************************************/
5088osGLOBAL void
5089itdssXferErrorInvalidSSPRspFrameHandler(
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*****************************************************************************/
5135osGLOBAL void
5136itdssXferErrorEOBDataOverrunHandler(
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*****************************************************************************/
5182osGLOBAL void
5183itdssOpenCnxErrorOpenPreemptedHandler(
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*****************************************************************************/
5230osGLOBAL void
5231itdssIODefaultHandler (
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*****************************************************************************/
5277osGLOBAL void
5278itdssIOForDebugging1Completed(
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*****************************************************************************/
5307osGLOBAL void
5308itdssIOForDebugging2Completed(
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*****************************************************************************/
5337osGLOBAL void
5338itdssIOForDebugging3Completed(
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
SMP_WRITE_GPIO_REGISTER
#define SMP_WRITE_GPIO_REGISTER
Definition: dmdefs.h:158
SMP_REPORT_PHY_SATA
#define SMP_REPORT_PHY_SATA
Definition: dmdefs.h:156
SMP_PHY_CONTROL_CLEAR_AFFILIATION
#define SMP_PHY_CONTROL_CLEAR_AFFILIATION
Definition: dmdefs.h:202
SMP_PHY_TEST_FUNCTION
#define SMP_PHY_TEST_FUNCTION
Definition: dmdefs.h:161
MIN
#define MIN(a, b)
MIN macro.
Definition: dmdefs.h:88
SAS_CONNECTION_RATE_1_5G
#define SAS_CONNECTION_RATE_1_5G
Definition: dmdefs.h:1120
SMP_REPORT_MANUFACTURE_INFORMATION
#define SMP_REPORT_MANUFACTURE_INFORMATION
Definition: dmdefs.h:152
SMP_PHY_CONTROL_HARD_RESET
#define SMP_PHY_CONTROL_HARD_RESET
Definition: dmdefs.h:199
SMP_PHY_CONTROL
#define SMP_PHY_CONTROL
Definition: dmdefs.h:160
SMP_CONFIGURE_ROUTING_INFORMATION
#define SMP_CONFIGURE_ROUTING_INFORMATION
Definition: dmdefs.h:159
DEVINFO_GET_LINKRATE
#define DEVINFO_GET_LINKRATE(devInfo)
Definition: dmdefs.h:1186
SAS_CONNECTION_RATE_12_0G
#define SAS_CONNECTION_RATE_12_0G
Definition: dmdefs.h:1123
SMP_READ_GPIO_REGISTER
#define SMP_READ_GPIO_REGISTER
Definition: dmdefs.h:153
SMP_DISCOVER
#define SMP_DISCOVER
Definition: dmdefs.h:154
SMP_RETRIES
#define SMP_RETRIES
Definition: dmdefs.h:1086
SMP_FUNCTION_ACCEPTED
#define SMP_FUNCTION_ACCEPTED
Definition: dmdefs.h:167
SMP_REPORT_GENERAL
#define SMP_REPORT_GENERAL
Definition: dmdefs.h:151
SMP_REPORT_PHY_ERROR_LOG
#define SMP_REPORT_PHY_ERROR_LOG
Definition: dmdefs.h:155
SMP_PHY_CONTROL_LINK_RESET
#define SMP_PHY_CONTROL_LINK_RESET
Definition: dmdefs.h:198
SMP_REPORT_ROUTING_INFORMATION
#define SMP_REPORT_ROUTING_INFORMATION
Definition: dmdefs.h:157
status
bit32 status
Definition: encrypt_ioctl.h:12
itdssTmTagNotFoundHandler
osGLOBAL void itdssTmTagNotFoundHandler(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, bit32 agIOInfoLen, void *agParam, bit32 agOtherInfo)
Definition: itdcb.c:4203
itdssIOCompleted
FORCEINLINE void itdssIOCompleted(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, bit32 agIOInfoLen, void *agParam, bit32 agOtherInfo)
Definition: itdcb.c:776
itdssOpenCnxErrorBreakHandler
osGLOBAL void itdssOpenCnxErrorBreakHandler(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, bit32 agIOInfoLen, void *agParam, bit32 agOtherInfo)
Definition: itdcb.c:3009
itdssOpenCnxErrorITNexusLossHandler
osGLOBAL void itdssOpenCnxErrorITNexusLossHandler(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, bit32 agIOInfoLen, void *agParam, bit32 agOtherInfo)
Definition: itdcb.c:3056
itdssPortInResetHandler
osGLOBAL void itdssPortInResetHandler(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, bit32 agIOInfoLen, void *agParam, bit32 agOtherInfo)
Definition: itdcb.c:4044
itdssXferErrorInvalidSSPRspFrameHandler
osGLOBAL void itdssXferErrorInvalidSSPRspFrameHandler(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, bit32 agIOInfoLen, void *agParam, bit32 agOtherInfo)
Definition: itdcb.c:5089
itdssIOResourceUnavailableHandler
osGLOBAL void itdssIOResourceUnavailableHandler(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, bit32 agIOInfoLen, void *agParam, bit32 agOtherInfo)
Definition: itdcb.c:4996
itdssIOForDebugging1Completed
osGLOBAL void itdssIOForDebugging1Completed(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, bit32 agIOInfoLen, void *agParam, bit32 agOtherInfo)
Definition: itdcb.c:5278
itdssOpenCnxErrorItNexusLossOpenTmoHandler
osGLOBAL void itdssOpenCnxErrorItNexusLossOpenTmoHandler(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, bit32 agIOInfoLen, void *agParam, bit32 agOtherInfo)
Definition: itdcb.c:4652
itdssOpenCnxErrorWrongDestinationHandler
osGLOBAL void itdssOpenCnxErrorWrongDestinationHandler(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, bit32 agIOInfoLen, void *agParam, bit32 agOtherInfo)
Definition: itdcb.c:3287
itdssOpenCnxErrorUnknownErrorHandler
osGLOBAL void itdssOpenCnxErrorUnknownErrorHandler(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, bit32 agIOInfoLen, void *agParam, bit32 agOtherInfo)
Definition: itdcb.c:3334
itdssIOForDebugging3Completed
osGLOBAL void itdssIOForDebugging3Completed(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, bit32 agIOInfoLen, void *agParam, bit32 agOtherInfo)
Definition: itdcb.c:5338
itdssIONoDeviceHandler
osGLOBAL void itdssIONoDeviceHandler(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, bit32 agIOInfoLen, void *agParam, bit32 agOtherInfo)
Definition: itdcb.c:2634
itdssXferErrorCMDIssueACKNAKTimeoutHandler
osGLOBAL void itdssXferErrorCMDIssueACKNAKTimeoutHandler(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, bit32 agIOInfoLen, void *agParam, bit32 agOtherInfo)
Definition: itdcb.c:3663
itdssEncryptionHandler
osGLOBAL void itdssEncryptionHandler(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, bit32 agIOInfoLen, void *agParam, bit32 agOtherInfo)
Definition: itdcb.c:4839
itdssIOSuccessHandler
osGLOBAL void itdssIOSuccessHandler(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, bit32 agIOInfoLen, void *agParam, bit32 agOtherInfo)
Definition: itdcb.c:2077
itdssIOAbortedHandler
osGLOBAL void itdssIOAbortedHandler(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, bit32 agIOInfoLen, void *agParam, bit32 agOtherInfo)
Definition: itdcb.c:2316
itdssXferErrorBreakHandler
osGLOBAL void itdssXferErrorBreakHandler(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, bit32 agIOInfoLen, void *agParam, bit32 agOtherInfo)
Definition: itdcb.c:2821
itdssXferErrorEOBDataOverrunHandler
osGLOBAL void itdssXferErrorEOBDataOverrunHandler(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, bit32 agIOInfoLen, void *agParam, bit32 agOtherInfo)
Definition: itdcb.c:5136
itdssXferErrorPeerAbortedHandler
osGLOBAL void itdssXferErrorPeerAbortedHandler(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, bit32 agIOInfoLen, void *agParam, bit32 agOtherInfo)
Definition: itdcb.c:3475
itdssIOForDebugging2Completed
osGLOBAL void itdssIOForDebugging2Completed(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, bit32 agIOInfoLen, void *agParam, bit32 agOtherInfo)
Definition: itdcb.c:5308
itdssOpenCnxErrorItNexusLossOpenCollideHandler
osGLOBAL void itdssOpenCnxErrorItNexusLossOpenCollideHandler(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, bit32 agIOInfoLen, void *agParam, bit32 agOtherInfo)
Definition: itdcb.c:4746
itdssXferErrorACKNAKTimeoutHandler
osGLOBAL void itdssXferErrorACKNAKTimeoutHandler(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, bit32 agIOInfoLen, void *agParam, bit32 agOtherInfo)
Definition: itdcb.c:3428
itdssTaskCompleted
osGLOBAL void itdssTaskCompleted(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, bit32 agIOInfoLen, void *agParam, bit32 agOtherInfo)
Definition: itdcb.c:99
itdssSMPCompleted
osGLOBAL void itdssSMPCompleted(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, bit32 agIOInfoLen, agsaFrameHandle_t agFrameHandle)
Definition: itdcb.c:2045
itdssSSPExtIUZeroLenHandler
osGLOBAL void itdssSSPExtIUZeroLenHandler(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, bit32 agIOInfoLen, void *agParam, bit32 agOtherInfo)
Definition: itdcb.c:4250
itdssIODefaultHandler
osGLOBAL void itdssIODefaultHandler(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, bit32 agIOInfoLen, void *agParam, bit32 agOtherInfo)
Definition: itdcb.c:5231
itdssXferErrorPhyNotReadyHandler
osGLOBAL void itdssXferErrorPhyNotReadyHandler(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, bit32 agIOInfoLen, void *agParam, bit32 agOtherInfo)
Definition: itdcb.c:2868
itdssXferErrorCMDIssuePhyDownBeforeACKNAKHandler
osGLOBAL void itdssXferErrorCMDIssuePhyDownBeforeACKNAKHandler(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, bit32 agIOInfoLen, void *agParam, bit32 agOtherInfo)
Definition: itdcb.c:3757
itdssXferErrorDMAHandler
osGLOBAL void itdssXferErrorDMAHandler(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, bit32 agIOInfoLen, void *agParam, bit32 agOtherInfo)
Definition: itdcb.c:3569
itdssIONotValidHandler
osGLOBAL void itdssIONotValidHandler(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, bit32 agIOInfoLen, void *agParam, bit32 agOtherInfo)
Definition: itdcb.c:2588
itdssIORQEBusyFullHandler
osGLOBAL void itdssIORQEBusyFullHandler(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, bit32 agIOInfoLen, void *agParam, bit32 agOtherInfo)
Definition: itdcb.c:5042
itdssIOFailedHandler
osGLOBAL void itdssIOFailedHandler(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, bit32 agIOInfoLen, void *agParam, bit32 agOtherInfo)
Definition: itdcb.c:2493
itdssXferOpenRetryBackoffThresholdReachedHandler
osGLOBAL void itdssXferOpenRetryBackoffThresholdReachedHandler(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, bit32 agIOInfoLen, void *agParam, bit32 agOtherInfo)
Definition: itdcb.c:4605
__FBSDID
__FBSDID("$FreeBSD$")
itdssXferErrorUnexpectedPhaseHandler
osGLOBAL void itdssXferErrorUnexpectedPhaseHandler(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, bit32 agIOInfoLen, void *agParam, bit32 agOtherInfo)
Definition: itdcb.c:4297
itdssIOUnderFlowHandler
osGLOBAL void itdssIOUnderFlowHandler(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, bit32 agIOInfoLen, void *agParam, bit32 agOtherInfo)
Definition: itdcb.c:2444
itdssDifHandler
osGLOBAL void itdssDifHandler(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, bit32 agIOInfoLen, void *agParam, bit32 agOtherInfo)
Definition: itdcb.c:4919
itdssProgErrorHandler
osGLOBAL void itdssProgErrorHandler(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, bit32 agIOInfoLen, void *agParam, bit32 agOtherInfo)
Definition: itdcb.c:2774
itdssIOAbortResetHandler
osGLOBAL void itdssIOAbortResetHandler(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, bit32 agIOInfoLen, void *agParam, bit32 agOtherInfo)
Definition: itdcb.c:2540
itdssDsInRecoveryHandler
osGLOBAL void itdssDsInRecoveryHandler(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, bit32 agIOInfoLen, void *agParam, bit32 agOtherInfo)
Definition: itdcb.c:4156
itdssLinkFailureHandler
osGLOBAL void itdssLinkFailureHandler(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, bit32 agIOInfoLen, void *agParam, bit32 agOtherInfo)
Definition: itdcb.c:2727
itdssOpenCnxErrorSTPResourceBusyHandler
osGLOBAL void itdssOpenCnxErrorSTPResourceBusyHandler(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, bit32 agIOInfoLen, void *agParam, bit32 agOtherInfo)
Definition: itdcb.c:3240
itdssOpenCnxErrorBadDestinationHandler
osGLOBAL void itdssOpenCnxErrorBadDestinationHandler(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, bit32 agIOInfoLen, void *agParam, bit32 agOtherInfo)
Definition: itdcb.c:3103
itdssXferErrorOffsetMismatchHandler
osGLOBAL void itdssXferErrorOffsetMismatchHandler(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, bit32 agIOInfoLen, void *agParam, bit32 agOtherInfo)
Definition: itdcb.c:3851
itdssDsNonOperationalHandler
osGLOBAL void itdssDsNonOperationalHandler(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, bit32 agIOInfoLen, void *agParam, bit32 agOtherInfo)
Definition: itdcb.c:4091
itdssXferErrorNAKReceivedHandler
osGLOBAL void itdssXferErrorNAKReceivedHandler(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, bit32 agIOInfoLen, void *agParam, bit32 agOtherInfo)
Definition: itdcb.c:3381
itdssOpenCnxErrorZoneViolationHandler
osGLOBAL void itdssOpenCnxErrorZoneViolationHandler(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, bit32 agIOInfoLen, void *agParam, bit32 agOtherInfo)
Definition: itdcb.c:2962
itdssOpenCnxErrorOpenPreemptedHandler
osGLOBAL void itdssOpenCnxErrorOpenPreemptedHandler(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, bit32 agIOInfoLen, void *agParam, bit32 agOtherInfo)
Definition: itdcb.c:5183
itdssXferOpenRetryTimeoutHandler
osGLOBAL void itdssXferOpenRetryTimeoutHandler(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, bit32 agIOInfoLen, void *agParam, bit32 agOtherInfo)
Definition: itdcb.c:3945
itdssXferErrorRxFrameHandler
osGLOBAL void itdssXferErrorRxFrameHandler(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, bit32 agIOInfoLen, void *agParam, bit32 agOtherInfo)
Definition: itdcb.c:3522
itdssOpenCnxErrorProtocolNotSupprotedHandler
osGLOBAL void itdssOpenCnxErrorProtocolNotSupprotedHandler(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, bit32 agIOInfoLen, void *agParam, bit32 agOtherInfo)
Definition: itdcb.c:2915
itdssOpenCnxErrorItNexusLossOpenPathwayBlockedHandler
osGLOBAL void itdssOpenCnxErrorItNexusLossOpenPathwayBlockedHandler(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, bit32 agIOInfoLen, void *agParam, bit32 agOtherInfo)
Definition: itdcb.c:4793
itdssOpenCnxErrorItNexusLossNoDestHandler
osGLOBAL void itdssOpenCnxErrorItNexusLossNoDestHandler(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, bit32 agIOInfoLen, void *agParam, bit32 agOtherInfo)
Definition: itdcb.c:4699
itdssXferErrorXferZeroDataLenHandler
osGLOBAL void itdssXferErrorXferZeroDataLenHandler(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, bit32 agIOInfoLen, void *agParam, bit32 agOtherInfo)
Definition: itdcb.c:3898
itdssXferErrorCreditTimeoutHandler
osGLOBAL void itdssXferErrorCreditTimeoutHandler(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, bit32 agIOInfoLen, void *agParam, bit32 agOtherInfo)
Definition: itdcb.c:3616
itdssXferErrorCMDIssueBreakBeforeACKNAKHandler
osGLOBAL void itdssXferErrorCMDIssueBreakBeforeACKNAKHandler(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, bit32 agIOInfoLen, void *agParam, bit32 agOtherInfo)
Definition: itdcb.c:3710
itdssOpenCnxErrorConnectionRateNotSupportedHandler
osGLOBAL void itdssOpenCnxErrorConnectionRateNotSupportedHandler(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, bit32 agIOInfoLen, void *agParam, bit32 agOtherInfo)
Definition: itdcb.c:3150
itdssXferErrorDisruptedPhyDownHandler
osGLOBAL void itdssXferErrorDisruptedPhyDownHandler(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, bit32 agIOInfoLen, void *agParam, bit32 agOtherInfo)
Definition: itdcb.c:3804
ostiFreeMemory
osGLOBAL U32 ostiFreeMemory(tiRoot_t *ptiRoot, void *osMemHandle, U32 allocLength)
Definition: lxosapi.c:320
ostiAllocMemory
osGLOBAL U32 ostiAllocMemory(tiRoot_t *ptiRoot, void **osMemHandle, void **agVirtAddr, U32 *agPhysUpper32, U32 *agPhysLower32, U32 alignment, U32 allocLength, agBOOLEAN isCacheable)
Definition: lxosapi.c:51
ostiInitiatorEvent
void ostiInitiatorEvent(tiRoot_t *ptiRoot, tiPortalContext_t *ptiPortalContext, tiDeviceHandle_t *ptiDevHandle, tiIntrEventType_t eventType, U32 eventStatus, void *parm)
Definition: osapi.c:49
ostiSetDeviceQueueDepth
osGLOBAL bit32 ostiSetDeviceQueueDepth(tiRoot_t *tiRoot, tiIORequest_t *tiIORequest, bit32 QueueDepth)
Definition: osapi.c:761
ostiInitiatorIOCompleted
void ostiInitiatorIOCompleted(tiRoot_t *ptiRoot, tiIORequest_t *ptiIORequest, tiIOStatus_t IOStatus, U32 statusDetail, tiSenseData_t *pSenseData, U32 context)
Definition: osapi.c:270
osti_memset
#define osti_memset(s, c, n)
Definition: osstring.h:65
NULL
#define NULL
Definition: ostypes.h:142
osGLOBAL
#define osGLOBAL
Definition: ostypes.h:147
agNULL
#define agNULL
Definition: ostypes.h:151
bit32
unsigned int bit32
Definition: ostypes.h:99
agFALSE
#define agFALSE
Definition: ostypes.h:150
FORCEINLINE
#define FORCEINLINE
Definition: ostypes.h:86
agTRUE
#define agTRUE
Definition: ostypes.h:149
bit8
unsigned char bit8
Definition: ostypes.h:97
sa.h
The file defines the constants, data structure, and functions defined by LL API.
AGSA_RC_BUSY
#define AGSA_RC_BUSY
Definition: sa.h:782
agsaFrameHandle_t
void * agsaFrameHandle_t
handle to access frame
Definition: sa.h:1719
SA_DS_OPERATIONAL
#define SA_DS_OPERATIONAL
Definition: sa.h:1179
AGSA_CLEAR_ACA
#define AGSA_CLEAR_ACA
Definition: sa.h:1109
AGSA_ABORT_TASK
#define AGSA_ABORT_TASK
Definition: sa.h:1104
AGSA_CLEAR_TASK_SET
#define AGSA_CLEAR_TASK_SET
Definition: sa.h:1106
AGSA_SMP_INIT_REQ
#define AGSA_SMP_INIT_REQ
Definition: sa.h:994
AGSA_LOGICAL_UNIT_RESET
#define AGSA_LOGICAL_UNIT_RESET
Definition: sa.h:1107
AGSA_TASK_MANAGEMENT_FUNCTION_COMPLETE
#define AGSA_TASK_MANAGEMENT_FUNCTION_COMPLETE
Definition: sa.h:1117
AGSA_QUERY_TASK
#define AGSA_QUERY_TASK
Definition: sa.h:1110
AGSA_ABORT_TASK_SET
#define AGSA_ABORT_TASK_SET
Definition: sa.h:1105
AGSA_PHY_NOTIFY_ENABLE_SPINUP
#define AGSA_PHY_NOTIFY_ENABLE_SPINUP
Definition: sa.h:839
AGSA_RC_FAILURE
#define AGSA_RC_FAILURE
Definition: sa.h:781
AGSA_TASK_MANAGEMENT_FUNCTION_SUCCEEDED
#define AGSA_TASK_MANAGEMENT_FUNCTION_SUCCEEDED
Definition: sa.h:1121
AGSA_RC_SUCCESS
#define AGSA_RC_SUCCESS
Definition: sa.h:780
OSSA_IO_XFER_ERROR_DMA
#define OSSA_IO_XFER_ERROR_DMA
Definition: sa_err.h:77
OSSA_IO_OPEN_CNX_ERROR_WRONG_DESTINATION
#define OSSA_IO_OPEN_CNX_ERROR_WRONG_DESTINATION
Definition: sa_err.h:70
OSSA_IO_XFR_ERROR_CIPHER_MODE_INVALID
#define OSSA_IO_XFR_ERROR_CIPHER_MODE_INVALID
Definition: sa_err.h:166
OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_COLLIDE
#define OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_COLLIDE
Definition: sa_err.h:117
OSSA_MPI_ERR_IO_RESOURCE_UNAVAILABLE
#define OSSA_MPI_ERR_IO_RESOURCE_UNAVAILABLE
Definition: sa_err.h:131
OSSA_IO_ABORTED
#define OSSA_IO_ABORTED
Definition: sa_err.h:46
OSSA_IO_XFR_ERROR_DEK_INDEX_OUT_OF_BOUNDS
#define OSSA_IO_XFR_ERROR_DEK_INDEX_OUT_OF_BOUNDS
Definition: sa_err.h:180
OSSA_IO_TM_TAG_NOT_FOUND
#define OSSA_IO_TM_TAG_NOT_FOUND
Definition: sa_err.h:105
OSSA_IO_DS_IN_RECOVERY
#define OSSA_IO_DS_IN_RECOVERY
Definition: sa_err.h:104
OSSA_IO_OPEN_CNX_ERROR_OPEN_PREEMPTED
#define OSSA_IO_OPEN_CNX_ERROR_OPEN_PREEMPTED
Definition: sa_err.h:129
OSSA_IO_DS_NON_OPERATIONAL
#define OSSA_IO_DS_NON_OPERATIONAL
Definition: sa_err.h:103
OSSA_IO_XFR_ERROR_INVALID_SSP_RSP_FRAME
#define OSSA_IO_XFR_ERROR_INVALID_SSP_RSP_FRAME
Definition: sa_err.h:128
OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_TMO
#define OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_TMO
Definition: sa_err.h:115
OSSA_IO_SSP_EXT_IU_ZERO_LEN_ERROR
#define OSSA_IO_SSP_EXT_IU_ZERO_LEN_ERROR
Definition: sa_err.h:107
OSSA_IO_FAILED
#define OSSA_IO_FAILED
Definition: sa_err.h:49
OSSA_IO_XFER_ERROR_PHY_NOT_READY
#define OSSA_IO_XFER_ERROR_PHY_NOT_READY
Definition: sa_err.h:62
OSSA_IO_XFR_ERROR_DEK_KEY_TAG_MISMATCH
#define OSSA_IO_XFR_ERROR_DEK_KEY_TAG_MISMATCH
Definition: sa_err.h:165
OSSA_IO_XFR_ERROR_DIF_CRC_MISMATCH
#define OSSA_IO_XFR_ERROR_DIF_CRC_MISMATCH
Definition: sa_err.h:194
OSSA_IO_XFR_ERROR_DEK_RAM_INTERFACE_ERROR
#define OSSA_IO_XFR_ERROR_DEK_RAM_INTERFACE_ERROR
Definition: sa_err.h:173
OSSA_IO_XFER_ERROR_UNEXPECTED_PHASE
#define OSSA_IO_XFER_ERROR_UNEXPECTED_PHASE
Definition: sa_err.h:89
OSSA_IO_OPEN_CNX_ERROR_BREAK
#define OSSA_IO_OPEN_CNX_ERROR_BREAK
Definition: sa_err.h:65
OSSA_IO_XFER_ERROR_OFFSET_MISMATCH
#define OSSA_IO_XFER_ERROR_OFFSET_MISMATCH
Definition: sa_err.h:98
OSSA_IO_UNDERFLOW
#define OSSA_IO_UNDERFLOW
Definition: sa_err.h:48
OSSA_IO_SUCCESS
#define OSSA_IO_SUCCESS
Definition: sa_err.h:45
OSSA_IO_ERROR_INTERNAL_SMP_RESOURCE
#define OSSA_IO_ERROR_INTERNAL_SMP_RESOURCE
Definition: sa_err.h:101
OSSA_IO_PORT_IN_RESET
#define OSSA_IO_PORT_IN_RESET
Definition: sa_err.h:102
OSSA_IO_XFER_ERROR_NAK_RECEIVED
#define OSSA_IO_XFER_ERROR_NAK_RECEIVED
Definition: sa_err.h:73
OSSA_IO_XFER_ERROR_BREAK
#define OSSA_IO_XFER_ERROR_BREAK
Definition: sa_err.h:61
OSSA_IO_XFR_ERROR_DIF_MISMATCH
#define OSSA_IO_XFR_ERROR_DIF_MISMATCH
Definition: sa_err.h:191
OSSA_IO_XFR_ERROR_DEK_ILLEGAL_TABLE
#define OSSA_IO_XFR_ERROR_DEK_ILLEGAL_TABLE
Definition: sa_err.h:181
OSSA_IO_XFER_ERROR_ACK_NAK_TIMEOUT
#define OSSA_IO_XFER_ERROR_ACK_NAK_TIMEOUT
Definition: sa_err.h:74
OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_PATHWAY_BLOCKED
#define OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_PATHWAY_BLOCKED
Definition: sa_err.h:118
OSSA_IO_XFR_ERROR_DEK_KEY_CACHE_MISS
#define OSSA_IO_XFR_ERROR_DEK_KEY_CACHE_MISS
Definition: sa_err.h:160
OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS
#define OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS
Definition: sa_err.h:66
OSSA_IO_INVALID_LENGTH
#define OSSA_IO_INVALID_LENGTH
Definition: sa_err.h:112
OSSA_IO_ABORT_RESET
#define OSSA_IO_ABORT_RESET
Definition: sa_err.h:50
OSSA_IO_XFR_ERROR_DIF_APPLICATION_TAG_MISMATCH
#define OSSA_IO_XFR_ERROR_DIF_APPLICATION_TAG_MISMATCH
Definition: sa_err.h:192
OSSA_IO_XFER_OPEN_RETRY_TIMEOUT
#define OSSA_IO_XFER_OPEN_RETRY_TIMEOUT
Definition: sa_err.h:86
OSSA_IO_XFER_ERR_EOB_DATA_OVERRUN
#define OSSA_IO_XFER_ERR_EOB_DATA_OVERRUN
Definition: sa_err.h:127
OSSA_IO_XFR_ERROR_DEK_IV_MISMATCH
#define OSSA_IO_XFR_ERROR_DEK_IV_MISMATCH
Definition: sa_err.h:171
OSSA_IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED
#define OSSA_IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED
Definition: sa_err.h:63
OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_RETRY_BACKOFF_THRESHOLD_REACHED
#define OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_RETRY_BACKOFF_THRESHOLD_REACHED
Definition: sa_err.h:114
OSSA_IO_OPEN_CNX_ERROR_ZONE_VIOLATION
#define OSSA_IO_OPEN_CNX_ERROR_ZONE_VIOLATION
Definition: sa_err.h:64
OSSA_MPI_IO_RQE_BUSY_FULL
#define OSSA_MPI_IO_RQE_BUSY_FULL
Definition: sa_err.h:126
OSSA_IO_XFR_ERROR_INTERNAL_RAM
#define OSSA_IO_XFR_ERROR_INTERNAL_RAM
Definition: sa_err.h:175
OSSA_IO_NO_DEVICE
#define OSSA_IO_NO_DEVICE
Definition: sa_err.h:52
OSSA_IO_OPEN_CNX_ERROR_BAD_DESTINATION
#define OSSA_IO_OPEN_CNX_ERROR_BAD_DESTINATION
Definition: sa_err.h:67
OSSA_IO_OPEN_CNX_ERROR_UNKNOWN_ERROR
#define OSSA_IO_OPEN_CNX_ERROR_UNKNOWN_ERROR
Definition: sa_err.h:72
OSSA_IO_XFR_ERROR_DIF_REFERENCE_TAG_MISMATCH
#define OSSA_IO_XFR_ERROR_DIF_REFERENCE_TAG_MISMATCH
Definition: sa_err.h:193
OSSA_IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED
#define OSSA_IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED
Definition: sa_err.h:68
OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_NO_DEST
#define OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_NO_DEST
Definition: sa_err.h:116
SA_SSPRESP_GET_RESPONSEDATALEN
#define SA_SSPRESP_GET_RESPONSEDATALEN(pSSPResp)
Definition: sa_spec.h:881
SA_SSPRESP_GET_DATAPRES
#define SA_SSPRESP_GET_DATAPRES(pSSPResp)
Definition: sa_spec.h:884
SA_SSPRESP_GET_SENSEDATALEN
#define SA_SSPRESP_GET_SENSEDATALEN(pSSPResp)
Definition: sa_spec.h:878
saapi.h
The file defines the declaration of tSDK APIs.
saFrameReadBlock
GLOBAL void saFrameReadBlock(agsaRoot_t *agRoot, agsaFrameHandle_t agFrame, bit32 frameOffset, void *frameBuffer, bit32 frameBufLen)
Read a block from a frame.
Definition: saframe.c:96
saSetDeviceInfo
GLOBAL bit32 saSetDeviceInfo(agsaRoot_t *agRoot, agsaContext_t *agContext, bit32 queueNum, agsaDevHandle_t *agDevHandle, bit32 option, bit32 param, ossaSetDeviceInfoCB_t agCB)
Set Device Information.
Definition: sadisc.c:672
saLocalPhyControl
GLOBAL bit32 saLocalPhyControl(agsaRoot_t *agRoot, agsaContext_t *agContext, bit32 queueNum, bit32 phyId, bit32 phyOperation, ossaLocalPhyControlCB_t agCB)
Initiate a Local PHY control command.
Definition: saphy.c:420
saSMPStart
GLOBAL bit32 saSMPStart(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 queueNum, agsaDevHandle_t *agDevHandle, bit32 agRequestType, agsaSASRequestBody_t *agRequestBody, ossaSMPCompletedCB_t agCB)
Start SMP request.
Definition: sasmp.c:62
saSSPAbort
GLOBAL bit32 saSSPAbort(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 queueNum, agsaDevHandle_t *agDevHandle, bit32 flag, void *abortParam, ossaGenericAbortCB_t agCB)
Abort SSP request.
Definition: sassp.c:1678
saSetDeviceState
GLOBAL bit32 saSetDeviceState(agsaRoot_t *agRoot, agsaContext_t *agContext, bit32 queueNum, agsaDevHandle_t *agDevHandle, bit32 newDeviceState)
Set Device State.
Definition: sadisc.c:801
saSSPStart
GLOBAL bit32 saSSPStart(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 queueNum, agsaDevHandle_t *agDevHandle, bit32 agRequestType, agsaSASRequestBody_t *agRequestBody, agsaIORequest_t *agTMRequest, ossaSSPCompletedCB_t agCB)
Start SSP request.
Definition: sassp.c:580
saosapi.h
The file defines the declaration of OS APIs.
ossaSMPCompleted
GLOBAL void ossaSMPCompleted(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, bit32 agIOInfoLen, agsaFrameHandle_t agFrameHandle)
ossaSMPCompleted
Definition: ossacmnapi.c:3961
ossaSSPCompleted
GLOBAL FORCEINLINE void ossaSSPCompleted(agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, bit32 agIOStatus, bit32 agIOInfoLen, void *agParam, bit16 sspTag, bit32 agOtherInfo)
ossaSSPCompleted
Definition: ossacmnapi.c:4321
OPEN_RETRY_RETRIES
#define OPEN_RETRY_RETRIES
Definition: smdefs.h:571
SCSIOPC_INQUIRY
#define SCSIOPC_INQUIRY
Definition: smdefs.h:444
agsaContext_s
data structure stores OS specific and LL specific context
Definition: sa.h:1658
agsaContext_s::osData
void * osData
Definition: sa.h:1659
agsaContext_s::sdkData
void * sdkData
Definition: sa.h:1660
agsaDifDetails_s
Definition: sa.h:3356
agsaDifDetails_s::LowerLBA
bit32 LowerLBA
Definition: sa.h:3358
agsaDifDetails_s::UpperLBA
bit32 UpperLBA
Definition: sa.h:3357
agsaSMPFrame_s
data structure describes a SMP request or response frame to be sent on the SAS port
Definition: sa.h:3057
agsaSMPFrame_s::outFrameBuf
void * outFrameBuf
Definition: sa.h:3058
agsaSSPInitiatorRequest_s
data structure describes a SAS SSP command request to be sent to the target device
Definition: sa.h:2892
agsaSSPResponseInfoUnit_s
structure describes an SSP Response INFORMATION UNIT
Definition: sa_spec.h:818
agsaSSPResponseInfoUnit_s::status
bit8 status
Definition: sa_spec.h:824
agsaSSPScsiTaskMgntReq_s
structure describes a SAS SSP Task Management command request
Definition: sa_spec.h:898
agsaSSPScsiTaskMgntReq_s::taskMgntFunction
bit8 taskMgntFunction
Definition: sa_spec.h:901
smpReqPhyControl_s
Definition: dmdefs.h:504
smpReqPhyControl_s::phyOperation
bit8 phyOperation
Definition: dmdefs.h:508
smpRespDiscover_s
Definition: dmdefs.h:308
smpRespReportGeneral_s
Definition: dmdefs.h:253
smpRespReportManufactureInfo_s
Definition: dmdefs.h:284
smpRespReportPhySata_s
Definition: dmdefs.h:481
tdIORequestBody_s
data structure for SAS SSP IO reuqest body This structure contains IO related fields....
Definition: tdtypes.h:587
tdIORequestBody_s::tiDevHandle
tiDeviceHandle_t * tiDevHandle
Definition: tdtypes.h:589
tdIORequestBody_s::ioCompleted
bit32 ioCompleted
Definition: tdtypes.h:620
tdIORequestBody_s::SAS
struct tdIORequestBody_s::@15::@17 SAS
tdIORequestBody_s::osMemHandle
void * osMemHandle
Definition: tdtypes.h:633
tdIORequestBody_s::CurrentTaskTag
tiIORequest_t * CurrentTaskTag
Definition: tdtypes.h:634
tdIORequestBody_s::reTries
bit32 reTries
Definition: tdtypes.h:621
tdIORequestBody_s::InitiatorTMIO
struct tdIORequestBody_s::@16::@20 InitiatorTMIO
tdIORequestBody_s::TaskTag
tiIORequest_t * TaskTag
Definition: tdtypes.h:635
tdIORequestBody_s::ioStarted
bit32 ioStarted
Definition: tdtypes.h:619
tdIORequestBody_s::transport
union tdIORequestBody_s::@15 transport
tdIORequestBody_s::IOType
union tdIORequestBody_s::@16 IOType
tdIORequestBody_s::agRequestType
bit32 agRequestType
Definition: tdtypes.h:624
tdIORequestBody_s::agIORequest
agsaIORequest_t agIORequest
Definition: tdtypes.h:591
tdIORequestBody_s::tiIORequest
tiIORequest_t * tiIORequest
Definition: tdtypes.h:590
tdIORequestBody_s::agSASRequestBody
agsaSASRequestBody_t agSASRequestBody
Definition: tdtypes.h:607
tdIORequestBody_s::agContext
agsaContext_t agContext
Definition: tdtypes.h:593
tdsaContext_s
data structure for SAS/SATA context at TD layer
Definition: tdsatypes.h:199
tdsaContext_s::itdsaIni
struct itdsaIni_s * itdsaIni
Definition: tdsatypes.h:240
tdsaDeviceData_s
data structure for SAS device list This structure maintains the device as a list and information abou...
Definition: tdtypes.h:322
tdsaDeviceData_s::DeviceType
bit8 DeviceType
Definition: tdtypes.h:333
tdsaDeviceData_s::valid
bit8 valid
Definition: tdtypes.h:351
tdsaDeviceData_s::ResetCnt
bit32 ResetCnt
Definition: tdtypes.h:374
tdsaDeviceData_s::agDevHandle
agsaDevHandle_t * agDevHandle
Definition: tdtypes.h:336
tdsaDeviceData_s::directlyAttached
bit8 directlyAttached
Definition: tdtypes.h:367
tdsaDeviceData_s::tdPortContext
struct tdsaPortContext_s * tdPortContext
Definition: tdtypes.h:349
tdsaDeviceData_s::phyID
bit8 phyID
Definition: tdtypes.h:363
tdsaDeviceData_s::agDeviceInfo
agsaDeviceInfo_t agDeviceInfo
Definition: tdtypes.h:357
tdsaDeviceData_s::registered
bit8 registered
Definition: tdtypes.h:366
tdsaDeviceData_s::id
bit32 id
Definition: tdtypes.h:330
tdsaDiscovery_s::pendingSMP
bit32 pendingSMP
Definition: tdtypes.h:257
tdsaDiscovery_s::DiscoverySMPTimer
tdsaTimerRequest_t DiscoverySMPTimer
Definition: tdtypes.h:263
tdsaPortContext_s
data structure for TD port context This structure maintains information about the port such as ID add...
Definition: tdtypes.h:412
tdsaPortContext_s::discovery
tdsaDiscovery_t discovery
Definition: tdtypes.h:453
tdsaPortContext_s::id
bit32 id
Definition: tdtypes.h:428
tdsaPortContext_s::valid
bit32 valid
Definition: tdtypes.h:454
tdsaPortContext_s::agRoot
agsaRoot_t * agRoot
Definition: tdtypes.h:445
tdsaRootOsData_s
data structure OS root from the view of lower layer. TD Layer interrupt/non-interrupt context support...
Definition: tdtypes.h:151
tdsaRootOsData_s::IntContext
agBOOLEAN IntContext
Definition: tdtypes.h:159
tdsaRootOsData_s::itdsaIni
void * itdsaIni
Definition: tdtypes.h:154
tdsaRootOsData_s::tiRoot
tiRoot_t * tiRoot
Definition: tdtypes.h:152
tdsaRoot_s
the root data structure for TD layer
Definition: tdsatypes.h:362
tdsaRoot_s::tdsaAllShared
tdsaContext_t tdsaAllShared
Definition: tdsatypes.h:364
tdsaTimerRequest_s::timerRunning
bit32 timerRunning
Definition: tdtypes.h:130
tdssSMPFrameHeader_s
Definition: tddefs.h:458
tdssSMPFrameHeader_s::smpFunction
bit8 smpFunction
Definition: tddefs.h:460
tdssSMPFrameHeader_s::smpFrameType
bit8 smpFrameType
Definition: tddefs.h:459
tdssSMPFrameHeader_s::smpReserved
bit8 smpReserved
Definition: tddefs.h:462
tdssSMPFrameHeader_s::smpFunctionResult
bit8 smpFunctionResult
Definition: tddefs.h:461
tdssSMPRequestBody_s
data structure for SAS SMP reuqest body This structure contains IO related fields....
Definition: tdtypes.h:668
tdssSMPRequestBody_s::agSASRequestBody
agsaSASRequestBody_t agSASRequestBody
Definition: tdtypes.h:674
tdssSMPRequestBody_s::IndirectSMPReqosMemHandle
void * IndirectSMPReqosMemHandle
Definition: tdtypes.h:685
tdssSMPRequestBody_s::retries
bit32 retries
Definition: tdtypes.h:682
tdssSMPRequestBody_s::tdPortContext
tdsaPortContext_t * tdPortContext
Definition: tdtypes.h:679
tdssSMPRequestBody_s::osMemHandle
void * osMemHandle
Definition: tdtypes.h:676
tdssSMPRequestBody_s::IndirectSMPRespLen
bit32 IndirectSMPRespLen
Definition: tdtypes.h:690
tdssSMPRequestBody_s::IndirectSMPResposMemHandle
void * IndirectSMPResposMemHandle
Definition: tdtypes.h:688
tdssSMPRequestBody_s::queueNumber
bit32 queueNumber
Definition: tdtypes.h:683
tdssSMPRequestBody_s::IndirectSMPReqLen
bit32 IndirectSMPReqLen
Definition: tdtypes.h:687
tdssSMPRequestBody_s::IndirectSMPResp
void * IndirectSMPResp
Definition: tdtypes.h:689
tdssSMPRequestBody_s::smpPayload
bit8 smpPayload[SMP_DIRECT_PAYLOAD_LIMIT]
Definition: tdtypes.h:680
tdssSMPRequestBody_s::tdDevice
tdsaDeviceData_t * tdDevice
Definition: tdtypes.h:677
tdssSMPRequestBody_s::CurrentTaskTag
tiIORequest_t * CurrentTaskTag
Definition: tdtypes.h:678
tiDeviceHandle::tdData
void * tdData
Definition: titypes.h:57
tiIORequest::osData
void * osData
Definition: titypes.h:117
tiIORequest::tdData
void * tdData
Definition: titypes.h:118
tiRoot
Definition: titypes.h:61
tiRoot::tdData
void * tdData
Definition: titypes.h:63
tiSenseData::senseData
void * senseData
Definition: titypes.h:131
tiSenseData::senseLen
bit8 senseLen
Definition: titypes.h:132
TD_MAX_NUM_NOTIFY_SPINUP
#define TD_MAX_NUM_NOTIFY_SPINUP
Definition: tddefs.h:1105
MAX_OUTSTANDING_IO_PER_LUN
#define MAX_OUTSTANDING_IO_PER_LUN
Definition: tddefs.h:127
TD_ASSERT
#define TD_ASSERT
Definition: tddefs.h:1055
tdhexdump
void tdhexdump(const char *ptitle, bit8 *pbuf, int len)
Definition: tdmisc.c:2836
tdsaPhyControlRespRcvd
osGLOBAL void tdsaPhyControlRespRcvd(tiRoot_t *tiRoot, agsaRoot_t *agRoot, agsaIORequest_t *agIORequest, tdsaDeviceData_t *oneDeviceData, tdssSMPFrameHeader_t *frameHeader, agsaFrameHandle_t frameHandle, tiIORequest_t *CurrentTaskTag)
Definition: tdmisc.c:2390
tdsaPhyControlFailureRespRcvd
osGLOBAL void tdsaPhyControlFailureRespRcvd(tiRoot_t *tiRoot, agsaRoot_t *agRoot, tdsaDeviceData_t *oneDeviceData, tdssSMPFrameHeader_t *frameHeader, agsaFrameHandle_t frameHandle, tiIORequest_t *CurrentTaskTag)
Definition: tdmisc.c:2302
tdsaRotateQnumber
FORCEINLINE bit32 tdsaRotateQnumber(tiRoot_t *tiRoot, tdsaDeviceData_t *oneDeviceData)
Definition: tdport.c:7956
tdsaKillTimer
osGLOBAL void tdsaKillTimer(tiRoot_t *tiRoot, tdsaTimerRequest_t *timerRequest)
Definition: tdtimers.c:228
TD_SATA_DEVICE
#define TD_SATA_DEVICE
Definition: tdsatypes.h:42
TD_SAS_DEVICE
#define TD_SAS_DEVICE
Definition: tdsatypes.h:41
SCSI_STAT_CHECK_CONDITION
#define SCSI_STAT_CHECK_CONDITION
Definition: tidefs.h:364
SCSI_STAT_CONDITION_MET
#define SCSI_STAT_CONDITION_MET
Definition: tidefs.h:365
SCSI_STAT_TASK_ABORTED
#define SCSI_STAT_TASK_ABORTED
Definition: tidefs.h:373
SCSI_STAT_BUSY
#define SCSI_STAT_BUSY
Definition: tidefs.h:366
tiDetailCipherModeInvalid
@ tiDetailCipherModeInvalid
Definition: tidefs.h:210
tiDetailDekRamInterfaceError
@ tiDetailDekRamInterfaceError
Definition: tidefs.h:212
tiDetailBusy
@ tiDetailBusy
Definition: tidefs.h:199
tiDetailNoLogin
@ tiDetailNoLogin
Definition: tidefs.h:201
tiDetailDifAppTagMismatch
@ tiDetailDifAppTagMismatch
Definition: tidefs.h:206
tiDetailDekKeyCacheMiss
@ tiDetailDekKeyCacheMiss
Definition: tidefs.h:209
tiDetailAbortReset
@ tiDetailAbortReset
Definition: tidefs.h:203
tiDetailOtherError
@ tiDetailOtherError
Definition: tidefs.h:214
tiDetailAborted
@ tiDetailAborted
Definition: tidefs.h:204
tiDetailDifCrcMismatch
@ tiDetailDifCrcMismatch
Definition: tidefs.h:208
tiDetailNotValid
@ tiDetailNotValid
Definition: tidefs.h:200
tiDetailDifRefTagMismatch
@ tiDetailDifRefTagMismatch
Definition: tidefs.h:207
tiDetailDekIndexOutofBounds
@ tiDetailDekIndexOutofBounds
Definition: tidefs.h:213
tiDetailDekIVMismatch
@ tiDetailDekIVMismatch
Definition: tidefs.h:211
tiDetailOtherErrorNoRetry
@ tiDetailOtherErrorNoRetry
Definition: tidefs.h:215
tiDetailDifMismatch
@ tiDetailDifMismatch
Definition: tidefs.h:205
SCSI_SENSE_KEY_RECOVERED_ERROR
#define SCSI_SENSE_KEY_RECOVERED_ERROR
Definition: tidefs.h:385
SCSI_STAT_INTERMEDIATE
#define SCSI_STAT_INTERMEDIATE
Definition: tidefs.h:367
tiSuccess
@ tiSuccess
Definition: tidefs.h:67
tiError
@ tiError
Definition: tidefs.h:68
SCSI_SENSE_KEY_ABORTED_COMMAND
#define SCSI_SENSE_KEY_ABORTED_COMMAND
Definition: tidefs.h:395
SCSI_SENSE_KEY_UNIT_ATTENTION
#define SCSI_SENSE_KEY_UNIT_ATTENTION
Definition: tidefs.h:390
tiIOOverRun
@ tiIOOverRun
Definition: tidefs.h:180
tiIOUnderRun
@ tiIOUnderRun
Definition: tidefs.h:181
tiIOFailed
@ tiIOFailed
Definition: tidefs.h:182
tiIOEncryptError
@ tiIOEncryptError
Definition: tidefs.h:184
tiIOSuccess
@ tiIOSuccess
Definition: tidefs.h:179
tiIODifError
@ tiIODifError
Definition: tidefs.h:183
tiTMFailed
@ tiTMFailed
Definition: tidefs.h:499
tiTMOK
@ tiTMOK
Definition: tidefs.h:498
SCSI_SENSE_KEY_NOT_READY
#define SCSI_SENSE_KEY_NOT_READY
Definition: tidefs.h:386
SCSI_STAT_RESV_CONFLICT
#define SCSI_STAT_RESV_CONFLICT
Definition: tidefs.h:369
SCSI_SENSE_KEY_HARDWARE_ERROR
#define SCSI_SENSE_KEY_HARDWARE_ERROR
Definition: tidefs.h:388
SCSI_STAT_GOOD
#define SCSI_STAT_GOOD
Definition: tidefs.h:363
SCSI_SENSE_KEY_ILLEGAL_REQUEST
#define SCSI_SENSE_KEY_ILLEGAL_REQUEST
Definition: tidefs.h:389
SCSI_STAT_INTER_CONDIT_MET
#define SCSI_STAT_INTER_CONDIT_MET
Definition: tidefs.h:368
SCSI_STAT_COMMANDTERMINATED
#define SCSI_STAT_COMMANDTERMINATED
Definition: tidefs.h:370
tiIntrEventTypeTaskManagement
@ tiIntrEventTypeTaskManagement
Definition: tidefs.h:460
SCSI_STAT_TASK_SET_FULL
#define SCSI_STAT_TASK_SET_FULL
Definition: tidefs.h:371
SCSI_SENSE_KEY_MEDIUM_ERROR
#define SCSI_SENSE_KEY_MEDIUM_ERROR
Definition: tidefs.h:387
SCSI_STAT_ACA_ACTIVE
#define SCSI_STAT_ACA_ACTIVE
Definition: tidefs.h:372
TI_DBG3
#define TI_DBG3(a)
Definition: tiglobal.h:50
TI_DBG6
#define TI_DBG6(a)
Definition: tiglobal.h:53
TI_DBG1
#define TI_DBG1(a)
Definition: tiglobal.h:48
TI_DBG2
#define TI_DBG2(a)
Definition: tiglobal.h:49
agsaSASRequestBody_u
union data structure specifies a request
Definition: sa.h:3104
agsaSASRequestBody_u::sspInitiatorReq
agsaSSPInitiatorRequest_t sspInitiatorReq
Definition: sa.h:3105
agsaSASRequestBody_u::smpFrame
agsaSMPFrame_t smpFrame
Definition: sa.h:3111
agsaSASRequestBody_u::sspTaskMgntReq
agsaSSPScsiTaskMgntReq_t sspTaskMgntReq
Definition: sa.h:3109