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