1 /*******************************************************************************
2 *Copyright (c) 2014 PMC-Sierra, Inc. All rights reserved.
3 *
4 *Redistribution and use in source and binary forms, with or without modification, are permitted provided
5 *that the following conditions are met:
6 *1. Redistributions of source code must retain the above copyright notice, this list of conditions and the
7 *following disclaimer.
8 *2. Redistributions in binary form must reproduce the above copyright notice,
9 *this list of conditions and the following disclaimer in the documentation and/or other materials provided
10 *with the distribution.
11 *
12 *THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED
13 *WARRANTIES,INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
14 *FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
15 *FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
16 *NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
17 *BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
18 *LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
19 *SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE
20
21 ********************************************************************************/
22 /*******************************************************************************/
23 /** \file
24 *
25 *
26 *
27 * This file contains CB functions used by lower layer in SAS/SATA TD layer
28 *
29 */
30 #include <sys/cdefs.h>
31 #include <dev/pms/config.h>
32
33 #include <dev/pms/freebsd/driver/common/osenv.h>
34 #include <dev/pms/freebsd/driver/common/ostypes.h>
35 #include <dev/pms/freebsd/driver/common/osdebug.h>
36
37 #include <dev/pms/RefTisa/sallsdk/api/sa.h>
38 #include <dev/pms/RefTisa/sallsdk/api/saapi.h>
39 #include <dev/pms/RefTisa/sallsdk/api/saosapi.h>
40
41 #include <dev/pms/RefTisa/tisa/api/titypes.h>
42 #include <dev/pms/RefTisa/tisa/api/ostiapi.h>
43 #include <dev/pms/RefTisa/tisa/api/tiapi.h>
44 #include <dev/pms/RefTisa/tisa/api/tiglobal.h>
45
46 #ifdef FDS_SM
47 #include <dev/pms/RefTisa/sat/api/sm.h>
48 #include <dev/pms/RefTisa/sat/api/smapi.h>
49 #include <dev/pms/RefTisa/sat/api/tdsmapi.h>
50 #endif
51
52 #ifdef FDS_DM
53 #include <dev/pms/RefTisa/discovery/api/dm.h>
54 #include <dev/pms/RefTisa/discovery/api/dmapi.h>
55 #include <dev/pms/RefTisa/discovery/api/tddmapi.h>
56 #endif
57
58 #include <dev/pms/RefTisa/tisa/sassata/sas/common/tdtypes.h>
59 #include <dev/pms/freebsd/driver/common/osstring.h>
60 #include <dev/pms/RefTisa/tisa/sassata/common/tdutil.h>
61
62 #ifdef INITIATOR_DRIVER
63 #include <dev/pms/RefTisa/tisa/sassata/sas/ini/itdtypes.h>
64 #include <dev/pms/RefTisa/tisa/sassata/sas/ini/itddefs.h>
65 #include <dev/pms/RefTisa/tisa/sassata/sas/ini/itdglobl.h>
66 #endif
67
68 #ifdef TARGET_DRIVER
69 #include <dev/pms/RefTisa/tisa/sassata/sas/tgt/ttdglobl.h>
70 #include <dev/pms/RefTisa/tisa/sassata/sas/tgt/ttdxchg.h>
71 #include <dev/pms/RefTisa/tisa/sassata/sas/tgt/ttdtypes.h>
72 #endif
73
74 #include <dev/pms/RefTisa/tisa/sassata/common/tdsatypes.h>
75 #include <dev/pms/RefTisa/tisa/sassata/common/tdproto.h>
76
77 #ifdef ECHO_TESTING
78 /* temporary to test saEchoCommand() */
79 extern bit8 gEcho;
80 #endif
81
82 #if defined(SALLSDK_DEBUG)
83 extern bit32 gLLDebugLevel;
84 #endif
85
86
87 #include <dev/pms/RefTisa/sallsdk/spc/mpidebug.h>
88
89 #ifdef SA_ENABLE_TRACE_FUNCTIONS
90
91 #ifdef siTraceFileID
92 #undef siTraceFileID
93 #endif
94 #define siTraceFileID 'R'
95 #endif
96 /*
97 functions that are common to SAS and SATA
98 */
99
100 FORCEINLINE
ossaCacheInvalidate(agsaRoot_t * agRoot,void * osMemHandle,void * virtPtr,bit32 length)101 void ossaCacheInvalidate(
102 agsaRoot_t *agRoot,
103 void *osMemHandle,
104 void *virtPtr,
105 bit32 length
106 )
107 {
108 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
109 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
110
111 TI_DBG6(("ossaCacheInvalidate: start\n"));
112 ostiCacheInvalidate(tiRoot, osMemHandle, virtPtr, length);
113 return;
114 }
115
116 FORCEINLINE
ossaCacheFlush(agsaRoot_t * agRoot,void * osMemHandle,void * virtPtr,bit32 length)117 void ossaCacheFlush(
118 agsaRoot_t *agRoot,
119 void *osMemHandle,
120 void *virtPtr,
121 bit32 length
122 )
123 {
124 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
125 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
126
127 TI_DBG6(("ossaCacheFlush: start\n"));
128 ostiCacheFlush(tiRoot, osMemHandle, virtPtr, length);
129 return;
130 }
131
132 FORCEINLINE
ossaCachePreFlush(agsaRoot_t * agRoot,void * osMemHandle,void * virtPtr,bit32 length)133 void ossaCachePreFlush(
134 agsaRoot_t *agRoot,
135 void *osMemHandle,
136 void *virtPtr,
137 bit32 length
138 )
139
140 {
141 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
142 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
143
144 TI_DBG6(("ossaCachePreFlush: start\n"));
145 ostiCachePreFlush(tiRoot, osMemHandle, virtPtr, length);
146 return;
147 }
148
149 /*****************************************************************************
150 *! \brief ossaDeviceHandleAccept
151 *
152 * Purpose: This function is called by lower layer to inform TD layer of
153 * a new SAS device arrival. Used only at the target
154 *
155 *
156 * \param agRoot Pointer to chip/driver Instance.
157 * \param agDevHandle Pointer to the device handle of the device
158 * \param agDevInfo Pointer to the device info structure
159 * \param agPortContext Pointer to a port context
160 *
161 * \return:
162 * OSSA_RC_REJECT A device is accpeted
163 * OSSA_RC_ACCEPT A device is rejected
164 *
165 * \note - For details, refer to SAS/SATA Low-Level API Specification
166 *
167 *****************************************************************************/
ossaDeviceHandleAccept(agsaRoot_t * agRoot,agsaDevHandle_t * agDevHandle,agsaSASDeviceInfo_t * agDevInfo,agsaPortContext_t * agPortContext,bit32 * hostAssignedDeviceId)168 osGLOBAL bit32 ossaDeviceHandleAccept(
169 agsaRoot_t *agRoot,
170 agsaDevHandle_t *agDevHandle,
171 agsaSASDeviceInfo_t *agDevInfo,
172 agsaPortContext_t *agPortContext,
173 bit32 *hostAssignedDeviceId
174 )
175 {
176 #ifdef TARGET_DRIVER
177 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
178 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
179 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData;
180 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
181
182 tdsaPortContext_t *onePortContext = agNULL;
183 tiPortalContext_t *tiPortalContext = agNULL;
184 tdsaDeviceData_t *oneDeviceData = agNULL;
185 tiDeviceHandle_t *tiDeviceHandle = agNULL;
186 tdsaSASSubID_t agSASSubID;
187 bit32 option;
188 bit32 param;
189 /*
190 at target only
191 by default TD layer accpets all devices
192 */
193 /*
194 at this point,
195 by LINK_UP event tdsaPortContext should have been created
196 */
197 smTraceFuncEnter(hpDBG_VERY_LOUD, "Y0");
198 TI_DBG1(("ossaDeviceHandleAccept: start hostAssignedDeviceId 0x%X\n",*hostAssignedDeviceId));
199
200
201 if (agPortContext == agNULL)
202 {
203 TI_DBG1(("ossaDeviceHandleAccept: NULL agsaPortContext; wrong\n"));
204 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Y0");
205 return OSSA_RC_REJECT;
206 }
207
208
209 onePortContext = (tdsaPortContext_t *)agPortContext->osData;
210
211 if (onePortContext == agNULL)
212 {
213 TI_DBG1(("ossaDeviceHandleAccept: NULL oneportcontext; wrong\n"));
214 smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "Y0");
215 return OSSA_RC_REJECT;
216 }
217
218 tiPortalContext = (tiPortalContext_t *)onePortContext->tiPortalContext;
219
220 if (tiPortalContext == agNULL)
221 {
222 TI_DBG1(("ossaDeviceHandleAccept: NULL tiPortalContext; wrong\n"));
223 smTraceFuncExit(hpDBG_VERY_LOUD, 'c', "Y0");
224 return OSSA_RC_REJECT;
225 }
226
227 /*
228 add the device to device list
229 cf) OSSA_DISCOVER_FOUND_DEVICE
230 */
231 TI_DBG4(("ossaDeviceHandleAccept: sasAddressHi 0x%08x\n", SA_DEVINFO_GET_SAS_ADDRESSHI(&agDevInfo->commonDevInfo)));
232 TI_DBG4(("ossaDeviceHandleAccept: sasAddressLo 0x%08x\n", SA_DEVINFO_GET_SAS_ADDRESSLO(&agDevInfo->commonDevInfo)));
233 TI_DBG4(("ossaDeviceHandleAccept: device type 0x%x\n", DEVINFO_GET_DEVICETTYPE(&agDevInfo->commonDevInfo)));
234 TI_DBG4(("ossaDeviceHandleAccept: phys %d\n", agDevInfo->numOfPhys));
235 TI_DBG4(("ossaDeviceHandleAccept: pid %d\n", onePortContext->id));
236
237 if (DEVINFO_GET_DEVICETTYPE(&agDevInfo->commonDevInfo) == SAS_END_DEVICE)
238 {
239 TI_DBG4(("ossaDeviceHandleAccept: SAS_END_DEVICE\n"));
240 }
241 else if (DEVINFO_GET_DEVICETTYPE(&agDevInfo->commonDevInfo) == SAS_EDGE_EXPANDER_DEVICE)
242 {
243 TI_DBG4(("ossaDeviceHandleAccept: SAS_EDGE_EXPANDER_DEVICE\n"));
244 }
245 else /* SAS_FANOUT_EXPANDER_DEVICE */
246 {
247 TI_DBG4(("ossaDeviceHandleAccept: SAS_FANOUT_EXPANDER_DEVICE\n"));
248 }
249 agSASSubID.sasAddressHi = SA_DEVINFO_GET_SAS_ADDRESSHI(&agDevInfo->commonDevInfo);
250 agSASSubID.sasAddressLo = SA_DEVINFO_GET_SAS_ADDRESSLO(&agDevInfo->commonDevInfo);
251 agSASSubID.initiator_ssp_stp_smp = agDevInfo->initiator_ssp_stp_smp;
252 agSASSubID.target_ssp_stp_smp = agDevInfo->target_ssp_stp_smp;
253
254
255 tdssAddSASToSharedcontext(
256 onePortContext,
257 agRoot,
258 agDevHandle,
259 &agSASSubID,
260 agTRUE,
261 0xFF,
262 TD_OPERATION_TARGET
263 );
264
265 /* at this point devicedata for new device exists */
266 oneDeviceData = (tdsaDeviceData_t *)agDevHandle->osData;
267
268 if (oneDeviceData == agNULL)
269 {
270 TI_DBG1(("ossaDeviceHandleAccept: NULL oneDeviceData; wrong\n"));
271 return OSSA_RC_REJECT;
272 }
273
274 oneDeviceData->registered = agTRUE;
275
276 tiDeviceHandle = &(oneDeviceData->tiDeviceHandle);
277
278 if (tiDeviceHandle == agNULL)
279 {
280 TI_DBG1(("ossaDeviceHandleAccept: NULL tiDeviceHandle; wrong\n"));
281 smTraceFuncExit(hpDBG_VERY_LOUD, 'd', "Y0");
282 return OSSA_RC_REJECT;
283 }
284
285 /* setting MCN in agsaDeviceInfo_t*/
286 agDevInfo->commonDevInfo.flag = agDevInfo->commonDevInfo.flag | (tdsaAllShared->MCN << 16);
287 /* increment RegisteredDevNums */
288 onePortContext->RegisteredDevNums++;
289
290 *hostAssignedDeviceId |= 0xBEEF0000;
291
292 TI_DBG1(("ossaDeviceHandleAccept: Now hostAssignedDeviceId 0x%X\n", *hostAssignedDeviceId));
293
294
295 /* no login in SAS */
296 /*
297 osGLOBAL bit32 ostiTargetEvent (
298 tiRoot_t *tiRoot,
299 tiPortalContext_t *portalContext,
300 tiDeviceHandle_t *tiDeviceHandle,
301 tiTgtEventType_t eventType,
302 bit32 eventStatus,
303 void *parm
304 );
305 */
306
307 ostiTargetEvent(
308 tiRoot,
309 tiPortalContext,
310 tiDeviceHandle,
311 tiTgtEventTypeDeviceChange,
312 tiDeviceArrival,
313 agNULL
314 );
315 /* set MCN and initiator role bit using saSetDeviceInfo */
316 option = 24; /* setting MCN and initiator role 1 1000b*/
317 param = (1 << 18) | (tdsaAllShared->MCN << 24);
318 TI_DBG1(("ossaDeviceHandleAccept: option 0x%x param 0x%x MCN 0x%x\n", option, param, tdsaAllShared->MCN));
319 saSetDeviceInfo(agRoot, agNULL, 0, agDevHandle, option, param, ossaSetDeviceInfoCB);
320 smTraceFuncExit(hpDBG_VERY_LOUD, 'e', "Y0");
321 return OSSA_RC_ACCEPT;
322 #endif
323
324 #ifdef INITIATOR_DRIVER
325 /* this function is not used in case of Initiator */
326 return OSSA_RC_ACCEPT;
327 #endif
328 }
329
330 #ifdef INITIATOR_DRIVER
331 /*****************************************************************************
332 *! \brief ossaDiscoverSasCB
333 *
334 * Purpose: This function is called by lower layer to inform TD layer of
335 * SAS discovery results
336 *
337 *
338 * \param agRoot Pointer to chip/driver Instance.
339 * \param agPortContext Pointer to the port context of TD and Lower layer
340 * \param event event type
341 * \param pParm1 Pointer to data associated with event
342 * \param pParm2 Pointer to data associated with event
343 *
344 * \return: none
345 *
346 * \note - For details, refer to SAS/SATA Low-Level API Specification
347 *
348 *****************************************************************************/
ossaDiscoverSasCB(agsaRoot_t * agRoot,agsaPortContext_t * agPortContext,bit32 event,void * pParm1,void * pParm2)349 osGLOBAL void ossaDiscoverSasCB(agsaRoot_t *agRoot,
350 agsaPortContext_t *agPortContext,
351 bit32 event,
352 void *pParm1,
353 void *pParm2
354 )
355 {
356 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
357 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
358 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)osData->tdsaAllShared;
359
360 tdsaPortContext_t *onePortContext = agNULL;
361 tdsaDeviceData_t *oneDeviceData = agNULL;
362
363 agsaDevHandle_t *agDevHandle = agNULL;
364 agsaSASDeviceInfo_t *agDeviceInfo = agNULL;
365 tiPortalContext_t *tiPortalContext = agNULL;
366 tdList_t *DeviceListList;
367 tdsaSASSubID_t agSASSubID;
368
369 smTraceFuncEnter(hpDBG_VERY_LOUD,"Y1");
370 TI_DBG2(("ossaDiscoverSasCB: start\n"));
371
372 if (agPortContext == agNULL)
373 {
374 TI_DBG1(("ossaDiscoverSasCB: NULL agsaPortContext; wrong\n"));
375 return;
376 }
377
378 onePortContext = (tdsaPortContext_t *)agPortContext->osData;
379 tiPortalContext = (tiPortalContext_t *)onePortContext->tiPortalContext;
380
381 switch ( event )
382 {
383 case OSSA_DISCOVER_STARTED:
384 {
385 TI_DBG3(("ossaDiscoverSasCB: STARTED pid %d\n", onePortContext->id));
386 /*
387 invalidate all devices in current device list
388 */
389 DeviceListList = tdsaAllShared->MainDeviceList.flink;
390 while (DeviceListList != &(tdsaAllShared->MainDeviceList))
391 {
392 oneDeviceData = TDLIST_OBJECT_BASE(tdsaDeviceData_t, MainLink, DeviceListList);
393 TI_DBG3(("ossaDiscoverSasCB: loop did %d\n", oneDeviceData->id));
394 TI_DBG3(("ossaDiscoverSasCB: loop sasAddressHi 0x%08x\n", oneDeviceData->SASAddressID.sasAddressHi));
395 TI_DBG6(("ossaDiscoverSasCB: loop sasAddressLo 0x%08x\n", oneDeviceData->SASAddressID.sasAddressLo));
396 if (oneDeviceData->tdPortContext == onePortContext)
397 {
398 TI_DBG3(("ossaDiscoverSasCB: did %d is invalidated \n", oneDeviceData->id));
399 /* temporary solution: only for sata direct attached */
400 }
401 DeviceListList = DeviceListList->flink;
402 }
403 onePortContext->DiscoveryState = ITD_DSTATE_STARTED;
404 break;
405 }
406
407 case OSSA_DISCOVER_FOUND_DEVICE:
408 {
409 TI_DBG4(("ossaDiscoverSasCB: $$$$$ FOUND_DEVICE pid %d\n", onePortContext->id));
410 agDevHandle = (agsaDevHandle_t *)pParm1;
411 agDeviceInfo = (agsaSASDeviceInfo_t *)pParm2;
412 TI_DBG5(("ossaDiscoverSasCB: sasAddressHi 0x%08x\n", SA_DEVINFO_GET_SAS_ADDRESSHI(&agDeviceInfo->commonDevInfo)));
413 TI_DBG5(("ossaDiscoverSasCB: sasAddressLo 0x%08x\n", SA_DEVINFO_GET_SAS_ADDRESSLO(&agDeviceInfo->commonDevInfo)));
414 TI_DBG5(("ossaDiscoverSasCB: device type 0x%x\n", DEVINFO_GET_DEVICETTYPE(&agDeviceInfo->commonDevInfo)));
415
416 TI_DBG6(("ossaDiscoverSasCB: phys %d\n", agDeviceInfo->numOfPhys));
417 TI_DBG4(("ossaDiscoverSasCB: pid %d\n", onePortContext->id));
418
419
420 /* Add only target devices; do not add expander device */
421 if (DEVINFO_GET_DEVICETTYPE(&agDeviceInfo->commonDevInfo) == SAS_END_DEVICE)
422 {
423 agSASSubID.sasAddressHi = SA_DEVINFO_GET_SAS_ADDRESSHI(&agDeviceInfo->commonDevInfo);
424 agSASSubID.sasAddressLo = SA_DEVINFO_GET_SAS_ADDRESSLO(&agDeviceInfo->commonDevInfo);
425 agSASSubID.initiator_ssp_stp_smp = agDeviceInfo->initiator_ssp_stp_smp;
426 agSASSubID.target_ssp_stp_smp = agDeviceInfo->target_ssp_stp_smp;
427
428 TI_DBG2(("ossaDiscoverSasCB: adding ....\n"));
429
430 tdssAddSASToSharedcontext(
431 onePortContext,
432 agRoot,
433 agDevHandle,
434 &agSASSubID,
435 agTRUE,
436 agDeviceInfo->phyIdentifier,
437 TD_OPERATION_INITIATOR
438 );
439 ostiInitiatorEvent(
440 tiRoot,
441 tiPortalContext,
442 agNULL,
443 tiIntrEventTypeDeviceChange,
444 tiDeviceArrival,
445 agNULL
446 );
447 }
448 else
449 {
450 TI_DBG5(("ossaDiscoverSasCB: $$$$$ not end device. not adding....\n"));
451 }
452
453
454 break;
455 }
456
457 case OSSA_DISCOVER_REMOVED_DEVICE:
458 {
459 TI_DBG3(("ossaDiscoverSasCB: REMOVED_DEVICE\n"));
460 agDevHandle = (agsaDevHandle_t *)pParm1;
461 agDeviceInfo = (agsaSASDeviceInfo_t *)pParm2;
462 oneDeviceData = (tdsaDeviceData_t *) agDevHandle->osData;
463
464 TI_DBG6(("ossaDiscoverSasCB: sasAddressHi 0x%08x\n",
465 SA_DEVINFO_GET_SAS_ADDRESSHI(&agDeviceInfo->commonDevInfo)));
466 TI_DBG6(("ossaDiscoverSasCB: sasAddressLo 0x%08x\n",
467 SA_DEVINFO_GET_SAS_ADDRESSLO(&agDeviceInfo->commonDevInfo)));
468 TI_DBG6(("ossaDiscoverSasCB: phys %d\n", agDeviceInfo->numOfPhys));
469 TI_DBG6(("ossaDiscoverSasCB: onePortContext->id %d\n", onePortContext->id));
470
471 if (oneDeviceData == agNULL)
472 {
473 TI_DBG1(("ossaDiscoverSasCB: Wrong. DevHandle->osData is NULL but is being removed\n"));
474 }
475 else
476 {
477 tdssRemoveSASFromSharedcontext(onePortContext,
478 oneDeviceData,
479 agRoot);
480 agDevHandle->osData = agNULL;
481 ostiInitiatorEvent(
482 tiRoot,
483 tiPortalContext,
484 agNULL,
485 tiIntrEventTypeDeviceChange,
486 tiDeviceRemoval,
487 agNULL
488 );
489 }
490
491 break;
492 }
493 case OSSA_DISCOVER_COMPLETE:
494 {
495 TI_DBG2(("ossaDiscoverSasCB: SAS COMPLETE pid %d\n", onePortContext->id));
496 /*
497 note:
498 SAS discovery must be called before SATA discovery
499 "onePortContext->DiscoveryState = ITD_DSTATE_COMPLETED" is
500 in ossaDiscoverSataCB not in ossaDiscoverSasCB when SATA_ENABLE
501 */
502 #ifndef SATA_ENABLE
503 onePortContext->DiscoveryState = ITD_DSTATE_COMPLETED;
504 TI_DBG6(("ossaDiscoverSasCB: COMPLETE pid %d\n", onePortContext->id));
505 #endif
506
507 #ifdef SATA_ENABLE
508 TI_DBG2(("ossaDiscoverSasCB: calling SATA discovery\n"));
509
510 /* Continue with SATA discovery */
511 saDiscover(agRoot, agPortContext, AG_SA_DISCOVERY_TYPE_SATA,
512 onePortContext->discoveryOptions);
513
514 #else /* SATA not enable */
515
516 #ifdef TD_INTERNAL_DEBUG /* for debugging */
517 /* dump device list */
518 DeviceListList = tdsaAllShared->MainPortContextList.flink;
519
520 while (DeviceListList != &(tdsaAllShared->MainPortContextList))
521 {
522 oneDeviceData = TDLIST_OBJECT_BASE(tdsaDeviceData_t, MainLink, DeviceListList);
523 TI_DBG2(("ossaDiscoverSasCB: did %d valid %d\n", oneDeviceData->id, oneDeviceData->valid));
524 TI_DBG2(("ossaDiscoverSasCB: device AddrHi 0x%08x\n", oneDeviceData->SASAddressID.sasAddressHi));
525 TI_DBG2(("ossaDiscoverSasCB: device AddrLo 0x%08x\n", oneDeviceData->SASAddressID.sasAddressLo));
526 DeviceListList = DeviceListList->flink;
527 }
528 #endif
529
530 /* letting OS layer know discovery has been successfully complete */
531 ostiInitiatorEvent(
532 tiRoot,
533 tiPortalContext,
534 agNULL,
535 tiIntrEventTypeDiscovery,
536 tiDiscOK,
537 agNULL
538 );
539 #endif /* SATA_ENABLE */
540
541 break;
542 }
543 case OSSA_DISCOVER_ABORT:
544 {
545 TI_DBG3(("ossaDiscoverSasCB: ABORT\n"));
546 /* letting OS layer know discovery has not been successfully complete */
547 ostiInitiatorEvent(
548 tiRoot,
549 tiPortalContext,
550 agNULL,
551 tiIntrEventTypeDiscovery,
552 tiDiscFailed,
553 agNULL
554 );
555 break;
556 }
557 case OSSA_DISCOVER_ABORT_ERROR_1:
558 {
559 TI_DBG3(("ossaDiscoverSasCB: ERROR 1\n"));
560 /* letting OS layer know discovery has not been successfully complete */
561 ostiInitiatorEvent(
562 tiRoot,
563 tiPortalContext,
564 agNULL,
565 tiIntrEventTypeDiscovery,
566 tiDiscFailed,
567 agNULL
568 );
569 break;
570 }
571
572 case OSSA_DISCOVER_ABORT_ERROR_2:
573 {
574 TI_DBG3(("ossaDiscoverSasCB: ERROR 2\n"));
575 /* letting OS layer know discovery has not been successfully complete */
576 ostiInitiatorEvent(
577 tiRoot,
578 tiPortalContext,
579 agNULL,
580 tiIntrEventTypeDiscovery,
581 tiDiscFailed,
582 agNULL
583 );
584 break;
585 }
586
587 case OSSA_DISCOVER_ABORT_ERROR_3:
588 {
589 TI_DBG3(("ossaDiscoverSasCB: ERROR 3\n"));
590 /* letting OS layer know discovery has not been successfully complete */
591 ostiInitiatorEvent(
592 tiRoot,
593 tiPortalContext,
594 agNULL,
595 tiIntrEventTypeDiscovery,
596 tiDiscFailed,
597 agNULL
598 );
599 break;
600 }
601 case OSSA_DISCOVER_ABORT_ERROR_4:
602 {
603 TI_DBG3(("ossaDiscoverSasCB: ERROR 4\n"));
604 /* letting OS layer know discovery has not been successfully complete */
605 ostiInitiatorEvent(
606 tiRoot,
607 tiPortalContext,
608 agNULL,
609 tiIntrEventTypeDiscovery,
610 tiDiscFailed,
611 agNULL
612 );
613 break;
614 }
615 case OSSA_DISCOVER_ABORT_ERROR_5:
616 {
617 TI_DBG3(("ossaDiscoverSasCB: ERROR 5\n"));
618 /* letting OS layer know discovery has not been successfully complete */
619 ostiInitiatorEvent(
620 tiRoot,
621 tiPortalContext,
622 agNULL,
623 tiIntrEventTypeDiscovery,
624 tiDiscFailed,
625 agNULL
626 );
627 break;
628 }
629 case OSSA_DISCOVER_ABORT_ERROR_6:
630 {
631 TI_DBG3(("ossaDiscoverSasCB: ERROR 6\n"));
632 /* letting OS layer know discovery has not been successfully complete */
633 ostiInitiatorEvent(
634 tiRoot,
635 tiPortalContext,
636 agNULL,
637 tiIntrEventTypeDiscovery,
638 tiDiscFailed,
639 agNULL
640 );
641 break;
642 }
643 case OSSA_DISCOVER_ABORT_ERROR_7:
644 {
645 TI_DBG3(("ossaDiscoverSasCB: ERROR 7\n"));
646 /* letting OS layer know discovery has not been successfully complete */
647 ostiInitiatorEvent(
648 tiRoot,
649 tiPortalContext,
650 agNULL,
651 tiIntrEventTypeDiscovery,
652 tiDiscFailed,
653 agNULL
654 );
655 break;
656 }
657 case OSSA_DISCOVER_ABORT_ERROR_8:
658 {
659 TI_DBG3(("ossaDiscoverSasCB: ERROR 8\n"));
660 /* letting OS layer know discovery has not been successfully complete */
661 ostiInitiatorEvent(
662 tiRoot,
663 tiPortalContext,
664 agNULL,
665 tiIntrEventTypeDiscovery,
666 tiDiscFailed,
667 agNULL
668 );
669 break;
670 }
671 case OSSA_DISCOVER_ABORT_ERROR_9:
672 {
673 TI_DBG3(("ossaDiscoverSasCB: ERROR 9\n"));
674 /* letting OS layer know discovery has not been successfully complete */
675 ostiInitiatorEvent(
676 tiRoot,
677 tiPortalContext,
678 agNULL,
679 tiIntrEventTypeDiscovery,
680 tiDiscFailed,
681 agNULL
682 );
683 break;
684 }
685 default:
686 TI_DBG3(("ossaDiscoverSasCB: ERROR default event 0x%x\n", event));
687 /* letting OS layer know discovery has not been successfully complete */
688 ostiInitiatorEvent(
689 tiRoot,
690 tiPortalContext,
691 agNULL,
692 tiIntrEventTypeDiscovery,
693 tiDiscFailed,
694 agNULL
695 );
696 break;
697 } /* end of switch */
698 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Y1");
699 return;
700 }
701 #endif // #ifdef INITIATOR_DRIVER
702
ossaLogTrace0(agsaRoot_t * agRoot,bit32 traceCode)703 osGLOBAL void ossaLogTrace0(
704 agsaRoot_t *agRoot,
705 bit32 traceCode
706 )
707 {
708 return;
709 }
710
ossaLogTrace1(agsaRoot_t * agRoot,bit32 traceCode,bit32 value1)711 osGLOBAL void ossaLogTrace1(
712 agsaRoot_t *agRoot,
713 bit32 traceCode,
714 bit32 value1
715 )
716 {
717 return;
718 }
719
ossaLogTrace2(agsaRoot_t * agRoot,bit32 traceCode,bit32 value1,bit32 value2)720 osGLOBAL void ossaLogTrace2(
721 agsaRoot_t *agRoot,
722 bit32 traceCode,
723 bit32 value1,
724 bit32 value2
725 )
726 {
727 return;
728 }
729
ossaLogTrace3(agsaRoot_t * agRoot,bit32 traceCode,bit32 value1,bit32 value2,bit32 value3)730 osGLOBAL void ossaLogTrace3(
731 agsaRoot_t *agRoot,
732 bit32 traceCode,
733 bit32 value1,
734 bit32 value2,
735 bit32 value3
736 )
737 {
738 return;
739 }
740
741
742 osGLOBAL void
ossaLogTrace4(agsaRoot_t * agRoot,bit32 traceCode,bit32 value1,bit32 value2,bit32 value3,bit32 value4)743 ossaLogTrace4(
744 agsaRoot_t *agRoot,
745 bit32 traceCode,
746 bit32 value1,
747 bit32 value2,
748 bit32 value3,
749 bit32 value4
750 )
751 {
752 return;
753 }
754
755
756 /*****************************************************************************
757 *! \brief ossaHwCB
758 *
759 * Purpose: This function is called by lower layer to inform TD layer of
760 * HW related results
761 *
762 * \param agRoot Pointer to chip/driver Instance.
763 * \param agPortContext Pointer to the port context of TD and Lower layer
764 * \param event event type
765 * \param eventParm1 event-specific parameter
766 * \param eventParm2 event-specific parameter
767 * \param eventParm3 event-specific parameter of pointer type
768 *
769 * \return: none
770 *
771 * \note - For details, refer to SAS/SATA Low-Level API Specification
772 *
773 *****************************************************************************/
ossaHwCB(agsaRoot_t * agRoot,agsaPortContext_t * agPortContext,bit32 event,bit32 eventParm1,void * eventParm2,void * eventParm3)774 osGLOBAL void ossaHwCB(
775 agsaRoot_t *agRoot,
776 agsaPortContext_t *agPortContext,
777 bit32 event,
778 bit32 eventParm1,
779 void *eventParm2,
780 void *eventParm3
781 )
782 {
783 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
784 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
785 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)osData->tdsaAllShared;
786 tdList_t *PortContextList = agNULL;
787 tdsaPortContext_t *onePortContext = agNULL;
788 agsaDevHandle_t *agDevHandle = agNULL;
789 agsaSASIdentify_t *IDframe = agNULL;
790 int i = 0;
791 #ifdef INITIATOR_DRIVER
792 tdsaSASSubID_t agSASSubID;
793 #endif
794 bit32 PhyID;
795 bit32 PhyStatus;
796 bit32 LinkRate;
797 bit32 PortState;
798 bit32 HwAckSatus = AGSA_RC_SUCCESS;
799
800 // #ifdef INITIATOR_DRIVER
801 #ifdef INITIATOR_DRIVER
802 agsaFisRegDeviceToHost_t *RegD2H = agNULL;
803 tdsaDeviceData_t *oneDeviceData = agNULL;
804 tdList_t *DeviceListList;
805 #endif
806 #ifdef REMOVED
807 bit32 found = agFALSE;
808 #endif
809 agsaHWEventEncrypt_t *pEncryptCBData;
810 agsaEncryptInfo_t *pEncryptInfo;
811 agsaHWEventMode_t *pModeEvent;
812 tiEncryptPort_t encryptEventData;
813 tiEncryptInfo_t encryptInfo;
814 bit32 *pModePage;
815 bit32 securityMode;
816 bit32 cipherMode;
817 bit32 encryptStatus;
818 bit32 securitySetModeStatus;
819 bit32 securityModeStatus;
820
821 // #endif /* INITIATOR_DRIVER */
822 agsaPhyErrCountersPage_t *agPhyErrCountersPage;
823 agsaEventSource_t eventSource;
824
825 #ifdef FDS_DM
826 dmRoot_t *dmRoot = &(tdsaAllShared->dmRoot);
827 dmPortContext_t *dmPortContext = agNULL;
828 bit32 status = DM_RC_FAILURE;
829 dmPortInfo_t dmPortInfo;
830 // bit32 discStatus = dmDiscInProgress;
831 #endif
832
833 smTraceFuncEnter(hpDBG_VERY_LOUD,"Y2");
834
835 TI_DBG2(("ossaHwCB: agPortContext %p event 0x%x eventParm1 0x%x eventParm2 %p eventParm3 %p\n",
836 agPortContext,event,eventParm1,eventParm2,eventParm3 ));
837
838 switch ( event )
839 {
840 case OSSA_HW_EVENT_SAS_PHY_UP:
841 {
842 PhyID = TD_GET_PHY_ID(eventParm1);
843 LinkRate = TD_GET_LINK_RATE(eventParm1);
844 PortState = TD_GET_PORT_STATE(eventParm1);
845 agDevHandle = agNULL;
846 IDframe = (agsaSASIdentify_t *)eventParm3;
847
848
849 TI_DBG2(("ossaHwCB: Phy%d SAS link Up\n", PhyID));
850
851 if (agPortContext == agNULL)
852 {
853 TI_DBG1(("ossaHwCB: agPortContext null, wrong\n"));
854 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Y2");
855 return;
856 }
857 if (agDevHandle == agNULL)
858 {
859 TI_DBG3(("ossaHwCB: agDevHandle null by design change\n"));
860 }
861
862 if (IDframe == agNULL)
863 {
864 TI_DBG1(("ossaHwCB: IDframe null, wrong\n"));
865 smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "Y2");
866 return;
867 }
868 /* debugging only */
869 if (LinkRate == 0x01)
870 {
871 TI_DBG1(("ossaHwCB: SAS Link Rate is 1.5 Gbps PhyID %d\n",PhyID));
872 }
873 if (LinkRate == 0x02)
874 {
875 TI_DBG1(("ossaHwCB: SAS Link Rate is 3.0 Gbps PhyID %d\n",PhyID));
876 }
877 if (LinkRate == 0x04)
878 {
879 TI_DBG1(("ossaHwCB: SAS Link Rate is 6.0 Gbps PhyID %d\n",PhyID));
880 }
881 if (LinkRate == 0x08)
882 {
883 TI_DBG1(("ossaHwCB: SAS Link Rate is 12.0 Gbps PhyID %d\n",PhyID));
884 }
885
886 if (PortState == OSSA_PORT_INVALID)
887 {
888 TI_DBG1(("ossaHwCB: Wrong port state with SAS link up\n"));
889 smTraceFuncExit(hpDBG_VERY_LOUD, 'c', "Y2");
890 return;
891 }
892
893 if ( agPortContext->osData == agNULL)
894 {/* if */
895 TI_DBG6 (("ossaHwCB: PhyID %d tdsaAllShared %p\n", PhyID, tdsaAllShared));
896 if (tdsaAllShared->Ports[PhyID].tiPortalContext == agNULL)
897 {
898 TI_DBG6(("ossaHwCB: NULL portalcontext\n"));
899 }
900 else
901 {
902 TI_DBG6(("ossaHwCB: NOT NULL portalcontext\n"));
903 }
904
905 if (IDframe == agNULL)
906 {
907 TI_DBG1(("ossaHwCB: IDFrame is NULL; SATA !!!!\n"));
908 }
909 else
910 {
911 TI_DBG3(("ossaHwCB: IDframe->sasAddressHi 0x%08x \n",
912 SA_IDFRM_GET_SAS_ADDRESSHI(IDframe)));
913 TI_DBG3(("ossaHwCB: IDframe->sasAddressLo 0x%08x \n",
914 SA_IDFRM_GET_SAS_ADDRESSLO(IDframe)));
915
916 }
917 /*
918 setting tdsaPortContext fields
919 take the head from the FreeLink of tdsaPortContext_t
920 then modify it
921 then put it in MainLink of tdsaPortContext_t
922 */
923 tdsaSingleThreadedEnter(tiRoot, TD_PORT_LOCK);
924 if (TDLIST_NOT_EMPTY(&(tdsaAllShared->FreePortContextList)))
925 {
926 TDLIST_DEQUEUE_FROM_HEAD(&PortContextList, &(tdsaAllShared->FreePortContextList));
927 tdsaSingleThreadedLeave(tiRoot, TD_PORT_LOCK);
928 onePortContext = TDLIST_OBJECT_BASE(tdsaPortContext_t, FreeLink, PortContextList);
929 TI_DBG2(("ossaHwCB: pid %d\n", onePortContext->id));
930 TI_DBG6(("ossaHwCB: onePortContext %p\n", onePortContext));
931 if (onePortContext == agNULL)
932 {
933 TI_DBG1(("ossaHwCB: onePortContext is NULL in allocation, wrong!\n"));
934 return;
935 }
936
937 /* sets fields of tdsaportcontext */
938 #ifdef INITIATOR_DRIVER
939 onePortContext->DiscoveryState = ITD_DSTATE_NOT_STARTED;
940 onePortContext->discoveryOptions = AG_SA_DISCOVERY_OPTION_FULL_START;
941 #endif
942 onePortContext->PhyIDList[PhyID] = agTRUE;
943 if (IDframe == agNULL)
944 {
945 onePortContext->sasRemoteAddressHi = 0xFFFFFFFF;
946 onePortContext->sasRemoteAddressLo = 0xFFFFFFFF;
947 onePortContext->directAttatchedSAS = agTRUE;
948 }
949 else
950 {
951 onePortContext->sasRemoteAddressHi = SA_IDFRM_GET_SAS_ADDRESSHI(IDframe);
952 onePortContext->sasRemoteAddressLo = SA_IDFRM_GET_SAS_ADDRESSLO(IDframe);
953 /* Create ID frame and storing ID frame */
954 osti_memcpy(&onePortContext->sasIDframe, IDframe, sizeof(agsaSASIdentify_t));
955 tdhexdump("ossaHWCB: sasIDframe", (bit8 *)(&onePortContext->sasIDframe), sizeof(agsaSASIdentify_t));
956 if (SA_IDFRM_GET_DEVICETTYPE(IDframe) == SAS_END_DEVICE)
957 {
958 onePortContext->directAttatchedSAS = agTRUE;
959 }
960 #ifdef FDS_DM
961 if (SA_IDFRM_GET_DEVICETTYPE(IDframe) == SAS_EDGE_EXPANDER_DEVICE ||
962 SA_IDFRM_GET_DEVICETTYPE(IDframe) == SAS_FANOUT_EXPANDER_DEVICE
963 )
964 {
965 onePortContext->UseDM = agTRUE;
966 }
967 #endif
968 }
969
970 onePortContext->sasLocalAddressHi = SA_IDFRM_GET_SAS_ADDRESSHI(&tdsaAllShared->Ports[PhyID].SASID);
971 onePortContext->sasLocalAddressLo = SA_IDFRM_GET_SAS_ADDRESSLO(&tdsaAllShared->Ports[PhyID].SASID);
972 onePortContext->tiPortalContext = tdsaAllShared->Ports[PhyID].tiPortalContext;
973 onePortContext->agRoot = agRoot;
974 onePortContext->agPortContext = agPortContext;
975 tdsaAllShared->Ports[PhyID].portContext = onePortContext;
976 agPortContext->osData = onePortContext;
977 onePortContext->valid = agTRUE;
978 if (LinkRate == 0x01)
979 {
980 onePortContext->LinkRate = SAS_CONNECTION_RATE_1_5G;
981 }
982 else if (LinkRate == 0x02)
983 {
984 onePortContext->LinkRate = SAS_CONNECTION_RATE_3_0G;
985 }
986 else if (LinkRate == 0x04)
987 {
988 onePortContext->LinkRate = SAS_CONNECTION_RATE_6_0G;
989 }
990 else /* (LinkRate == 0x08) */
991 {
992 onePortContext->LinkRate = SAS_CONNECTION_RATE_12_0G;
993 }
994
995 tdsaSingleThreadedEnter(tiRoot, TD_PORT_LOCK);
996 TDLIST_ENQUEUE_AT_TAIL(&(onePortContext->MainLink), &(tdsaAllShared->MainPortContextList));
997 tdsaSingleThreadedLeave(tiRoot, TD_PORT_LOCK);
998 #ifdef FDS_DM
999 dmPortContext = &(onePortContext->dmPortContext);
1000 dmPortContext->tdData = onePortContext;
1001 /* set up dmPortInfo_t */
1002 PORTINFO_PUT_SAS_REMOTE_ADDRESSLO(&dmPortInfo, onePortContext->sasRemoteAddressLo);
1003 PORTINFO_PUT_SAS_REMOTE_ADDRESSHI(&dmPortInfo, onePortContext->sasRemoteAddressHi);
1004 PORTINFO_PUT_SAS_LOCAL_ADDRESSLO(&dmPortInfo, onePortContext->sasLocalAddressLo);
1005 PORTINFO_PUT_SAS_LOCAL_ADDRESSHI(&dmPortInfo, onePortContext->sasLocalAddressHi);
1006
1007 TI_DBG2(("ossaHwCB: phy %d hi 0x%x lo 0x%x\n", PhyID,
1008 SA_IDFRM_GET_SAS_ADDRESSHI(&(tdsaAllShared->Ports[PhyID].SASID)),
1009 SA_IDFRM_GET_SAS_ADDRESSLO(&(tdsaAllShared->Ports[PhyID].SASID))));
1010 TI_DBG2(("ossaHwCB: LocalAddrHi 0x%08x LocaAddrLo 0x%08x\n", onePortContext->sasLocalAddressHi, onePortContext->sasLocalAddressLo));
1011
1012 dmPortInfo.flag = onePortContext->LinkRate;
1013
1014 if (onePortContext->UseDM == agTRUE)
1015 {
1016 TI_DBG1(("ossaHwCB: calling dmCreatePort\n"));
1017 status = dmCreatePort(dmRoot, dmPortContext, &dmPortInfo);
1018 if (status != DM_RC_SUCCESS)
1019 {
1020 TI_DBG1(("ossaHwCB: dmCreatePort failed!!! 0x%x\n", status));
1021 }
1022 }
1023 #endif
1024
1025 }
1026 else
1027 {
1028 tdsaSingleThreadedLeave(tiRoot, TD_PORT_LOCK);
1029 TI_DBG1(("\nossaHwCB: Attention!!! no more free PortContext.\n"));
1030 }
1031 #ifdef TD_INTERNAL_DEBUG /* for debugging only */
1032
1033 print_tdlist_flink(&(tdsaPortContext->FreeLink), 1, 1);
1034 print_tdlist_flink(&(tdsaPortContext->MainLink), 1, 2);
1035 print_tdlist_flink(&(tdsaDeviceData->FreeLink), 2, 1);
1036 print_tdlist_flink(&(tdsaDeviceData->MainLink), 2, 2);
1037 #endif
1038
1039 #ifdef TD_INTERNAL_DEBUG /* for debugging */
1040 PortContextList = tdsaPortContext->MainLink.flink;
1041 while (PortContextList != &(tdsaPortContext->MainLink))
1042 {
1043 twoPortContext = TDLIST_OBJECT_BASE(tdsaPortContext_t, MainLink, PortContextList);
1044 TI_DBG6(("ossaHwCB: in while portContext ID %d\n", twoPortContext->id));
1045 TI_DBG6(("ossaHwCB: in while PortContext %p\n", twoPortContext));
1046 PortContextList = PortContextList->flink;
1047 }
1048 #endif
1049 /* add agDevHandle */
1050 if (SA_IDFRM_GET_DEVICETTYPE(IDframe) != SAS_NO_DEVICE)
1051 {
1052 #ifdef INITIATOR_DRIVER
1053 agSASSubID.sasAddressHi = SA_IDFRM_GET_SAS_ADDRESSHI(IDframe);
1054 agSASSubID.sasAddressLo = SA_IDFRM_GET_SAS_ADDRESSLO(IDframe);
1055 agSASSubID.initiator_ssp_stp_smp = IDframe->initiator_ssp_stp_smp;
1056 agSASSubID.target_ssp_stp_smp = IDframe->target_ssp_stp_smp;
1057 #endif
1058
1059 TI_DBG2(("ossaHwCB: adding ....\n"));
1060 /* uses only SASIDframe not agsaSASDeviceInfo_t */
1061 #ifdef INITIATOR_DRIVER
1062 tdssAddSASToSharedcontext(
1063 onePortContext,
1064 agRoot,
1065 agDevHandle, /* agNULL */
1066 &agSASSubID,
1067 agTRUE,
1068 (bit8)PhyID,
1069 TD_OPERATION_INITIATOR
1070 );
1071 #endif
1072
1073 #ifdef FDS_DM
1074 if (SA_IDFRM_GET_DEVICETTYPE(IDframe) == SAS_END_DEVICE &&
1075 SA_IDFRM_IS_SSP_TARGET(IDframe) )
1076 {
1077 TI_DBG2(("ossaHwCB: NOTIFY_ENABLE_SPINUP PhyID %d \n", PhyID));
1078
1079 for (i=0;i<TD_MAX_NUM_NOTIFY_SPINUP;i++)
1080 {
1081 saLocalPhyControl(agRoot, agNULL, 0, PhyID, AGSA_PHY_NOTIFY_ENABLE_SPINUP, agNULL);
1082 }
1083 }
1084
1085 /* update MCN */
1086 tdsaUpdateMCN(dmRoot, onePortContext);
1087 #endif
1088
1089 #ifdef TARGET_DRIVER
1090 TI_DBG1(("ossaHwCB: target, link up PhyID 0x%x\n",PhyID));
1091
1092 /* notifying link up */
1093 ostiPortEvent (
1094 tiRoot,
1095 tiPortLinkUp,
1096 tiSuccess,
1097 (void *)tdsaAllShared->Ports[PhyID].tiPortalContext
1098 );
1099 #endif
1100 }
1101 else
1102 {
1103 TI_DBG5(("ossaHwCB: $$$$$ not end device. not adding....\n"));
1104 }
1105
1106 saPortControl(agRoot, /* AGSA_PORT_SET_PORT_RECOVERY_TIME */
1107 agNULL,
1108 0,
1109 agPortContext,
1110 AGSA_PORT_SET_PORT_RECOVERY_TIME,
1111 tdsaAllShared->portTMO, //PORT_RECOVERY_TIMEOUT
1112 0
1113 );
1114 /* setting SAS PORT RESET TMO and SATA PORT RESET TMO*/
1115 if (tIsSPCV12G(agRoot))
1116 {
1117 saPortControl(agRoot, /* AGSA_PORT_SET_PORT_RESET_TIME */
1118 agNULL,
1119 0,
1120 agPortContext,
1121 AGSA_PORT_SET_PORT_RESET_TIME,
1122 SAS_12G_PORT_RESET_TMO, // 800 ms
1123 0
1124 );
1125 }
1126 else
1127 {
1128 saPortControl(agRoot, /* AGSA_PORT_SET_PORT_RESET_TIME */
1129 agNULL,
1130 0,
1131 agPortContext,
1132 AGSA_PORT_SET_PORT_RESET_TIME,
1133 SAS_PORT_RESET_TMO, // 300 ms
1134 0
1135 );
1136 }
1137 }
1138 else
1139 {
1140 /*
1141 an existing portcontext
1142 to be tested
1143 */
1144
1145 TI_DBG2(("ossaHwCB: SAS existing portcontext returned\n"));
1146
1147 onePortContext = (tdsaPortContext_t *)agPortContext->osData;
1148 if (onePortContext == agNULL)
1149 {
1150 TI_DBG1(("ossaHwCB: onePortContext is NULL, wrong!\n"));
1151 return;
1152 }
1153 if (onePortContext->valid == agFALSE)
1154 {
1155 /* port has been invalidated; needs to be allocated */
1156 TI_DBG2(("ossaHwCB: SAS allocating port context\n"));
1157
1158 tdsaSingleThreadedEnter(tiRoot, TD_PORT_LOCK);
1159 if (TDLIST_NOT_EMPTY(&(tdsaAllShared->FreePortContextList)))
1160 {
1161 TDLIST_DEQUEUE_FROM_HEAD(&PortContextList, &(tdsaAllShared->FreePortContextList));
1162 tdsaSingleThreadedLeave(tiRoot, TD_PORT_LOCK);
1163 onePortContext = TDLIST_OBJECT_BASE(tdsaPortContext_t, FreeLink, PortContextList);
1164 TI_DBG2(("ossaHwCB: allocating pid %d\n", onePortContext->id));
1165 TI_DBG6(("ossaHwCB: allocating onePortContext %p\n", onePortContext));
1166 if (onePortContext == agNULL)
1167 {
1168 TI_DBG1(("ossaHwCB: onePortContext is NULL in allocation, wrong!\n"));
1169 return;
1170 }
1171 /* sets fields of tdsaportcontext */
1172 #ifdef INITIATOR_DRIVER
1173 onePortContext->DiscoveryState = ITD_DSTATE_NOT_STARTED;
1174 onePortContext->discoveryOptions = AG_SA_DISCOVERY_OPTION_FULL_START;
1175 #endif
1176 onePortContext->PhyIDList[PhyID] = agTRUE;
1177 if (IDframe == agNULL)
1178 {
1179 onePortContext->sasRemoteAddressHi = 0xFFFFFFFF;
1180 onePortContext->sasRemoteAddressLo = 0xFFFFFFFF;
1181 onePortContext->directAttatchedSAS = agTRUE;
1182 }
1183 else
1184 {
1185 onePortContext->sasRemoteAddressHi = SA_IDFRM_GET_SAS_ADDRESSHI(IDframe);
1186 onePortContext->sasRemoteAddressLo = SA_IDFRM_GET_SAS_ADDRESSLO(IDframe);
1187 /* Create ID frame and storing ID frame */
1188 osti_memcpy(&onePortContext->sasIDframe, IDframe, sizeof(agsaSASIdentify_t));
1189 tdhexdump("ossaHWCB: sasIDframe", (bit8 *)(&onePortContext->sasIDframe), sizeof(agsaSASIdentify_t));
1190 if (SA_IDFRM_GET_DEVICETTYPE(IDframe) == SAS_END_DEVICE)
1191 {
1192 onePortContext->directAttatchedSAS = agTRUE;
1193 }
1194 }
1195
1196 onePortContext->sasLocalAddressHi = SA_IDFRM_GET_SAS_ADDRESSHI(&tdsaAllShared->Ports[PhyID].SASID);
1197 onePortContext->sasLocalAddressLo = SA_IDFRM_GET_SAS_ADDRESSLO(&tdsaAllShared->Ports[PhyID].SASID);
1198 onePortContext->tiPortalContext = tdsaAllShared->Ports[PhyID].tiPortalContext;
1199 onePortContext->agRoot = agRoot;
1200 onePortContext->agPortContext = agPortContext;
1201 tdsaAllShared->Ports[PhyID].portContext = onePortContext;
1202 agPortContext->osData = onePortContext;
1203 onePortContext->valid = agTRUE;
1204 if (LinkRate == 0x01)
1205 {
1206 onePortContext->LinkRate = SAS_CONNECTION_RATE_1_5G;
1207 }
1208 else if (LinkRate == 0x02)
1209 {
1210 onePortContext->LinkRate = SAS_CONNECTION_RATE_3_0G;
1211 }
1212 else if (LinkRate == 0x04)
1213 {
1214 onePortContext->LinkRate = SAS_CONNECTION_RATE_6_0G;
1215 }
1216 else /* (LinkRate == 0x08) */
1217 {
1218 onePortContext->LinkRate = SAS_CONNECTION_RATE_12_0G;
1219 }
1220 tdsaSingleThreadedEnter(tiRoot, TD_PORT_LOCK);
1221 TDLIST_ENQUEUE_AT_TAIL(&(onePortContext->MainLink), &(tdsaAllShared->MainPortContextList));
1222 tdsaSingleThreadedLeave(tiRoot, TD_PORT_LOCK);
1223 }
1224 else
1225 {
1226 tdsaSingleThreadedLeave(tiRoot, TD_PORT_LOCK);
1227 TI_DBG1(("\nossaHwCB: Attention!!! no more free PortContext.\n"));
1228 smTraceFuncExit(hpDBG_VERY_LOUD, 'd', "Y2");
1229 return;
1230 }
1231 } /* invalidated port */
1232 else
1233 {
1234 /* already alloacated */
1235 TI_DBG2(("ossaHwCB: SAS already allocated port context\n"));
1236 if (TDLIST_EMPTY(&(tdsaAllShared->MainPortContextList)))
1237 {
1238 TI_DBG1(("ossaHwCB: wrong!!! null tdsaPortContext list\n"));
1239 smTraceFuncExit(hpDBG_VERY_LOUD, 'e', "Y2");
1240 return;
1241 }
1242 if (onePortContext == agNULL)
1243 {
1244 TI_DBG1(("ossaHwCB: wrong !!! No corressponding tdsaPortContext\n"));
1245 smTraceFuncExit(hpDBG_VERY_LOUD, 'f', "Y2");
1246 return;
1247 }
1248
1249 TI_DBG2(("ossaHwCB: existing pid %d\n", onePortContext->id));
1250 if (tdsaAllShared->Ports[PhyID].portContext == agNULL)
1251 {
1252 TI_DBG1(("ossaHwCB: existing allshared pid is NULL\n"));
1253 }
1254 else
1255 {
1256 TI_DBG2(("ossaHwCB: existing allshared pid %d\n", tdsaAllShared->Ports[PhyID].portContext->id));
1257 }
1258 /* updates PhyID belong to a port */
1259 onePortContext->PhyIDList[PhyID] = agTRUE;
1260 #ifdef FDS_DM
1261 if (SA_IDFRM_GET_DEVICETTYPE(IDframe) == SAS_END_DEVICE &&
1262 SA_IDFRM_IS_SSP_TARGET(IDframe) )
1263 {
1264 TI_DBG2(("ossaHwCB: NOTIFY_ENABLE_SPINUP PhyID %d \n", PhyID));
1265
1266 for (i=0;i<TD_MAX_NUM_NOTIFY_SPINUP;i++)
1267 {
1268 saLocalPhyControl(agRoot, agNULL, 0, PhyID, AGSA_PHY_NOTIFY_ENABLE_SPINUP, agNULL);
1269 }
1270 }
1271
1272 /* update MCN */
1273 tdsaUpdateMCN(dmRoot, onePortContext);
1274 #endif
1275 }
1276 onePortContext->SeenLinkUp = agTRUE;
1277 } /* else, old portcontext */
1278
1279 break;
1280 }
1281 #ifdef INITIATOR_DRIVER
1282 case OSSA_HW_EVENT_SATA_PHY_UP:
1283 {
1284 PhyID = TD_GET_PHY_ID(eventParm1);
1285 LinkRate = TD_GET_LINK_RATE(eventParm1);
1286 PortState = TD_GET_PORT_STATE(eventParm1);
1287 agDevHandle = agNULL;
1288 RegD2H = ( agsaFisRegDeviceToHost_t *)eventParm3;
1289
1290 TI_DBG2(("ossaHwCB: Phy%d SATA link Up\n", PhyID));
1291
1292 if (agDevHandle == agNULL)
1293 {
1294 TI_DBG3(("ossaHwCB: agDevHandle null by design change\n"));
1295 }
1296
1297 if (RegD2H == agNULL)
1298 {
1299 TI_DBG1(("ossaHwCB: RegD2H null, wrong\n"));
1300 smTraceFuncExit(hpDBG_VERY_LOUD, 'g', "Y2");
1301 return;
1302 }
1303
1304
1305 TI_DBG2(("ossaHwCB: agDevHandle %p\n", agDevHandle));
1306 tdhexdump("ossaHWCB RegD2H", (bit8 *)RegD2H, sizeof(agsaFisRegDeviceToHost_t));
1307 TI_DBG2(("ossaHwCB: Sector Count %d\n", RegD2H->d.sectorCount));
1308 TI_DBG2(("ossaHwCB: LBA LOW %d\n", RegD2H->d.lbaLow));
1309 TI_DBG2(("ossaHwCB: LBA MID %d\n", RegD2H->d.lbaMid));
1310 TI_DBG2(("ossaHwCB: LBA HIGH %d\n", RegD2H->d.lbaHigh));
1311 TI_DBG2(("ossaHwCB: DEVICE %d\n", RegD2H->d.device));
1312
1313 /* debugging only */
1314 if (LinkRate == 0x01)
1315 {
1316 TI_DBG1(("ossaHwCB: SATA Link Rate is 1.5 Gbps PhyID %d\n",PhyID));
1317 }
1318 if (LinkRate == 0x02)
1319 {
1320 TI_DBG1(("ossaHwCB: SATA Link Rate is 3.0 Gbps PhyID %d\n",PhyID));
1321 }
1322 if (LinkRate == 0x04)
1323 {
1324 TI_DBG1(("ossaHwCB: SATA Link Rate is 6.0 Gbps PhyID %d\n",PhyID));
1325 }
1326 if (LinkRate == 0x08)
1327 {
1328 TI_DBG1(("ossaHwCB: SATA Link Rate is 12.0 Gbps PhyID %d\n",PhyID));
1329 }
1330
1331 if (PortState == OSSA_PORT_INVALID)
1332 {
1333 TI_DBG1(("ossaHwCB: Wrong port state with SATA link up\n"));
1334 smTraceFuncExit(hpDBG_VERY_LOUD, 'h', "Y2");
1335 return;
1336 }
1337
1338 if ( agPortContext->osData == agNULL)
1339 {/* if */
1340 TI_DBG6 (("ossaHwCB: PhyID %d tdsaAllShared %p\n", PhyID, tdsaAllShared));
1341 tdsaSingleThreadedEnter(tiRoot, TD_PORT_LOCK);
1342 if (TDLIST_NOT_EMPTY(&(tdsaAllShared->FreePortContextList)))
1343 {
1344 TDLIST_DEQUEUE_FROM_HEAD(&PortContextList, &(tdsaAllShared->FreePortContextList));
1345 tdsaSingleThreadedLeave(tiRoot, TD_PORT_LOCK);
1346 onePortContext = TDLIST_OBJECT_BASE(tdsaPortContext_t, FreeLink, PortContextList);
1347 TI_DBG2(("ossaHwCB: pid %d\n", onePortContext->id));
1348 TI_DBG6(("ossaHwCB: onePortContext %p\n", onePortContext));
1349 if (onePortContext == agNULL)
1350 {
1351 TI_DBG1(("ossaHwCB: onePortContext is NULL in allocation, wrong!\n"));
1352 return;
1353 }
1354
1355 /* sets fields of tdsaportcontext */
1356 onePortContext->DiscoveryState = ITD_DSTATE_NOT_STARTED;
1357 onePortContext->discoveryOptions = AG_SA_DISCOVERY_OPTION_FULL_START;
1358 onePortContext->PhyIDList[PhyID] = agTRUE;
1359 /* NO sas address for SATA */
1360 onePortContext->sasRemoteAddressHi = 0xFFFFFFFF;
1361 onePortContext->sasRemoteAddressLo = 0xFFFFFFFF;
1362 /* copying the signature */
1363 onePortContext->remoteSignature[0] = RegD2H->d.sectorCount;
1364 onePortContext->remoteSignature[1] = RegD2H->d.lbaLow;
1365 onePortContext->remoteSignature[2] = RegD2H->d.lbaMid;
1366 onePortContext->remoteSignature[3] = RegD2H->d.lbaHigh;
1367 onePortContext->remoteSignature[4] = RegD2H->d.device;
1368
1369 onePortContext->sasLocalAddressHi = SA_IDFRM_GET_SAS_ADDRESSHI(&tdsaAllShared->Ports[PhyID].SASID);
1370 onePortContext->sasLocalAddressLo = SA_IDFRM_GET_SAS_ADDRESSLO(&tdsaAllShared->Ports[PhyID].SASID);
1371 onePortContext->tiPortalContext = tdsaAllShared->Ports[PhyID].tiPortalContext;
1372 onePortContext->agRoot = agRoot;
1373 onePortContext->agPortContext = agPortContext;
1374 tdsaAllShared->Ports[PhyID].portContext = onePortContext;
1375 agPortContext->osData = onePortContext;
1376 onePortContext->nativeSATAMode = agTRUE;
1377 onePortContext->valid = agTRUE;
1378 if (LinkRate == 0x01)
1379 {
1380 onePortContext->LinkRate = SAS_CONNECTION_RATE_1_5G;
1381 }
1382 else if (LinkRate == 0x02)
1383 {
1384 onePortContext->LinkRate = SAS_CONNECTION_RATE_3_0G;
1385 }
1386 else if (LinkRate == 0x04)
1387 {
1388 onePortContext->LinkRate = SAS_CONNECTION_RATE_6_0G;
1389 }
1390 else /* (LinkRate == 0x08) */
1391 {
1392 onePortContext->LinkRate = SAS_CONNECTION_RATE_12_0G;
1393 }
1394
1395 tdsaSingleThreadedEnter(tiRoot, TD_PORT_LOCK);
1396 TDLIST_ENQUEUE_AT_TAIL(&(onePortContext->MainLink), &(tdsaAllShared->MainPortContextList));
1397 tdsaSingleThreadedLeave(tiRoot, TD_PORT_LOCK);
1398 }
1399 else
1400 {
1401 tdsaSingleThreadedLeave(tiRoot, TD_PORT_LOCK);
1402 TI_DBG1(("\nossaHwCB: Attention!!! no more free PortContext.\n"));
1403 smTraceFuncExit(hpDBG_VERY_LOUD, 'i', "Y2");
1404 return;
1405 }
1406 #ifdef SATA_ENABLE
1407 /* tdssAddSATAToSharedcontext() sends identify device data to find out the uniqueness of
1408 target. In identify device data CB fn (satAddSATAIDDevCB()),
1409 tiPortLinkUp and tiPortDiscoveryReady happen
1410 */
1411 tdssAddSATAToSharedcontext(
1412 onePortContext,
1413 agRoot,
1414 agDevHandle, /* agNULL */
1415 agNULL,
1416 agTRUE,
1417 (bit8)PhyID
1418 );
1419 #endif
1420 /* setting SAS PORT RESET TMO and SATA PORT RESET TMO*/
1421 saPortControl(agRoot, /* AGSA_PORT_SET_PORT_RESET_TIME */
1422 agNULL,
1423 0,
1424 agPortContext,
1425 AGSA_PORT_SET_PORT_RESET_TIME,
1426 0,
1427 SATA_PORT_RESET_TMO // 8000 ms
1428 );
1429
1430 }
1431 else
1432 {
1433 /*
1434 an existing portcontext
1435 to be tested
1436 */
1437
1438 TI_DBG1(("ossaHwCB: SATA existing portcontext returned. need testing\n"));
1439 onePortContext = (tdsaPortContext_t *)agPortContext->osData;
1440 /* for debugging only */
1441 if (onePortContext->valid == agFALSE)
1442 {
1443 /* port has been invalidated; needs to be allocated */
1444 TI_DBG2(("ossaHwCB: SATA allocating port context\n"));
1445 }
1446 else
1447 {
1448 /* already alloacated */
1449 TI_DBG1(("ossaHwCB: Wrong!!! SATA already allocated port context\n"));
1450 smTraceFuncExit(hpDBG_VERY_LOUD, 'j', "Y2");
1451 return;
1452 }
1453
1454 tdsaSingleThreadedEnter(tiRoot, TD_PORT_LOCK);
1455 if (TDLIST_NOT_EMPTY(&(tdsaAllShared->FreePortContextList)))
1456 {
1457 TDLIST_DEQUEUE_FROM_HEAD(&PortContextList, &(tdsaAllShared->FreePortContextList));
1458 tdsaSingleThreadedLeave(tiRoot, TD_PORT_LOCK);
1459 onePortContext = TDLIST_OBJECT_BASE(tdsaPortContext_t, FreeLink, PortContextList);
1460 TI_DBG2(("ossaHwCB: pid %d\n", onePortContext->id));
1461 TI_DBG6(("ossaHwCB: onePortContext %p\n", onePortContext));
1462 if (onePortContext == agNULL)
1463 {
1464 TI_DBG1(("ossaHwCB: onePortContext is NULL in allocation, wrong!\n"));
1465 return;
1466 }
1467
1468 /* sets fields of tdsaportcontext */
1469 onePortContext->DiscoveryState = ITD_DSTATE_NOT_STARTED;
1470 onePortContext->discoveryOptions = AG_SA_DISCOVERY_OPTION_FULL_START;
1471 onePortContext->PhyIDList[PhyID] = agTRUE;
1472 /* NO sas address for SATA */
1473 onePortContext->sasRemoteAddressHi = 0xFFFFFFFF;
1474 onePortContext->sasRemoteAddressLo = 0xFFFFFFFF;
1475 /* copying the signature */
1476 onePortContext->remoteSignature[0] = RegD2H->d.sectorCount;
1477 onePortContext->remoteSignature[1] = RegD2H->d.lbaLow;
1478 onePortContext->remoteSignature[2] = RegD2H->d.lbaMid;
1479 onePortContext->remoteSignature[3] = RegD2H->d.lbaHigh;
1480 onePortContext->remoteSignature[4] = RegD2H->d.device;
1481
1482 onePortContext->sasLocalAddressHi = SA_IDFRM_GET_SAS_ADDRESSHI(&tdsaAllShared->Ports[PhyID].SASID);
1483 onePortContext->sasLocalAddressLo = SA_IDFRM_GET_SAS_ADDRESSLO(&tdsaAllShared->Ports[PhyID].SASID);
1484 onePortContext->tiPortalContext = tdsaAllShared->Ports[PhyID].tiPortalContext;
1485 onePortContext->agRoot = agRoot;
1486 onePortContext->agPortContext = agPortContext;
1487 tdsaAllShared->Ports[PhyID].portContext = onePortContext;
1488 agPortContext->osData = onePortContext;
1489 onePortContext->nativeSATAMode = agTRUE;
1490 onePortContext->valid = agTRUE;
1491 if (LinkRate == 0x01)
1492 {
1493 onePortContext->LinkRate = SAS_CONNECTION_RATE_1_5G;
1494 }
1495 else if (LinkRate == 0x02)
1496 {
1497 onePortContext->LinkRate = SAS_CONNECTION_RATE_3_0G;
1498 }
1499 else if (LinkRate == 0x04)
1500 {
1501 onePortContext->LinkRate = SAS_CONNECTION_RATE_6_0G;
1502 }
1503 else /* (LinkRate == 0x08) */
1504 {
1505 onePortContext->LinkRate = SAS_CONNECTION_RATE_12_0G;
1506 }
1507
1508 tdsaSingleThreadedEnter(tiRoot, TD_PORT_LOCK);
1509 TDLIST_ENQUEUE_AT_TAIL(&(onePortContext->MainLink), &(tdsaAllShared->MainPortContextList));
1510 tdsaSingleThreadedLeave(tiRoot, TD_PORT_LOCK);
1511 }
1512 else
1513 {
1514 tdsaSingleThreadedLeave(tiRoot, TD_PORT_LOCK);
1515 TI_DBG1(("\nossaHwCB: Attention!!! no more free PortContext.\n"));
1516 smTraceFuncExit(hpDBG_VERY_LOUD, 'k', "Y2");
1517 return;
1518 }
1519
1520
1521 /*hotplug */
1522 #ifdef SATA_ENABLE
1523 tdssAddSATAToSharedcontext(
1524 onePortContext,
1525 agRoot,
1526 agDevHandle, /* agNULL */
1527 agNULL,
1528 agTRUE,
1529 (bit8)PhyID
1530 );
1531 #endif
1532 /* end hotplug */
1533 }
1534
1535 break;
1536 }
1537 #endif
1538 case OSSA_HW_EVENT_SATA_SPINUP_HOLD:
1539 {
1540 PhyID = TD_GET_PHY_ID(eventParm1);
1541
1542 TI_DBG2(("ossaHwCB: spinup hold PhyID %d\n", PhyID));
1543 break;
1544 }
1545
1546 case OSSA_HW_EVENT_PHY_DOWN:
1547 {
1548 bit32 AllPhyDown = agTRUE;
1549
1550 /* 4/15/08 spec */
1551 PhyID = TD_GET_PHY_ID(eventParm1);
1552 LinkRate = TD_GET_LINK_RATE(eventParm1);
1553 PortState = TD_GET_PORT_STATE(eventParm1);
1554
1555
1556 TI_DBG2(("ossaHwCB: Phy%d link Down\n", PhyID));
1557
1558 if (agPortContext == agNULL)
1559 {
1560 TI_DBG1(("ossaHwCB: agPortContext null, wrong\n"));
1561 smTraceFuncExit(hpDBG_VERY_LOUD, 'l', "Y2");
1562 return;
1563 }
1564
1565 if ( agPortContext->osData == agNULL)
1566 { /* if */
1567 /* PortContext must exit at this point */
1568 TI_DBG1(("ossaHwCB: NULL portalcontext. Error. Can't be NULL\n"));
1569 }
1570 else
1571 {
1572 TI_DBG3(("ossaHwCB: NOT NULL portalcontext\n"));
1573 onePortContext = (tdsaPortContext_t *)agPortContext->osData;
1574 if (onePortContext == agNULL)
1575 {
1576 TI_DBG1(("ossaHwCB: wrong !!! No corressponding tdsaPortContext\n"));
1577 smTraceFuncExit(hpDBG_VERY_LOUD, 'm', "Y2");
1578 return;
1579 }
1580 onePortContext->PhyIDList[PhyID] = agFALSE;
1581 for(i=0;i<TD_MAX_NUM_PHYS;i++)
1582 {
1583 if (onePortContext->PhyIDList[i] == agTRUE)
1584 {
1585 TI_DBG3(("ossaHwCB: Phy %d is still up\n", i));
1586 AllPhyDown = agFALSE;
1587 break;
1588 }
1589 }
1590
1591 /* last phy belong to the portcontext */
1592 if (AllPhyDown == agTRUE)
1593 {
1594 #ifdef NOT_YET
1595 TI_DBG1(("ossaHwCB: calling tiPortLinkDown\n"));
1596 ostiPortEvent (
1597 tiRoot,
1598 tiPortLinkDown,
1599 tiSuccess,
1600 (void *)onePortContext->tiPortalContext
1601 );
1602 #endif
1603 }
1604
1605 if (PortState == OSSA_PORT_VALID)
1606 {
1607 /* do nothing */
1608 /* no ack for every phy down */
1609 #ifdef FDS_DM
1610 /* update MCN for all devices belong to this port */
1611 tdsaUpdateMCN(dmRoot, onePortContext);
1612 #endif
1613 }
1614 else if (PortState == OSSA_PORT_LOSTCOMM)
1615 {
1616 /*
1617 1. Mark the port as invalid and stop the io for that port and its device
1618 No ack here. Otherwise, port will be released by FW.
1619 */
1620 TI_DBG2(("ossaHwCB: phy Down and OSSA_PORT_LOSTCOMM\n"));
1621 /* save eventSource related information in tdsaAllShared */
1622 tdsaAllShared->eventSource[PhyID].EventValid = agTRUE;
1623 tdsaAllShared->eventSource[PhyID].Source.agPortContext = agPortContext;
1624 tdsaAllShared->eventSource[PhyID].Source.event = OSSA_HW_EVENT_PHY_DOWN;
1625 /* phy ID */
1626 tdsaAllShared->eventSource[PhyID].Source.param = PhyID;
1627 /* phy ID */
1628 onePortContext->eventPhyID = PhyID;
1629 /* to stop IO's */
1630 onePortContext->valid = agFALSE;
1631 break;
1632 }
1633 else if (PortState == OSSA_PORT_IN_RESET)
1634 {
1635 TI_DBG2(("ossaHwCB: phy Down and OSSA_PORT_IN_RESET\n"));
1636 /* save eventSource related information in tdsaAllShared */
1637 tdsaAllShared->eventSource[PhyID].EventValid = agTRUE;
1638 tdsaAllShared->eventSource[PhyID].Source.agPortContext = agPortContext;
1639 tdsaAllShared->eventSource[PhyID].Source.event = OSSA_HW_EVENT_PHY_DOWN;
1640 /* phy ID */
1641 tdsaAllShared->eventSource[PhyID].Source.param = PhyID;
1642 /* phy ID */
1643 onePortContext->eventPhyID = PhyID;
1644 /* to stop IO's */
1645 onePortContext->valid = agFALSE;
1646 break;
1647 }
1648 else if (PortState == OSSA_PORT_INVALID)
1649 {
1650 TI_DBG1(("ossaHwCB: Last phy Down and port invalid OSSA_PORT_INVALID\n"));
1651 /*
1652 invalidate port
1653 then, saHwEventAck() in ossaDeregisterDeviceHandleCB()
1654 */
1655
1656 /* save eventSource related information in tdsaAllShared */
1657 tdsaAllShared->eventSource[PhyID].EventValid = agTRUE;
1658 tdsaAllShared->eventSource[PhyID].Source.agPortContext = agPortContext;
1659 tdsaAllShared->eventSource[PhyID].Source.event = OSSA_HW_EVENT_PHY_DOWN;
1660 /* phy ID */
1661 tdsaAllShared->eventSource[PhyID].Source.param = PhyID;
1662 /* phy ID */
1663 onePortContext->eventPhyID = PhyID;
1664
1665 onePortContext->valid = agFALSE;
1666
1667 TI_DBG2(("ossaHwCB: pid %d\n", onePortContext->id));
1668 #ifdef INITIATOR_DRIVER
1669 /* notifying link down (all links belonging to a port are down) */
1670 ostiPortEvent(
1671 tiRoot,
1672 tiPortStopped,
1673 tiSuccess,
1674 (void *)onePortContext->tiPortalContext
1675 );
1676 #endif
1677
1678 #ifdef TARGET_DRIVER
1679 ostiPortEvent(
1680 tiRoot,
1681 tiPortLinkDown,
1682 tiSuccess,
1683 (void *)onePortContext->tiPortalContext
1684 );
1685
1686 #endif
1687
1688 #ifdef INITIATOR_DRIVER
1689 tdssReportRemovals(agRoot,
1690 onePortContext,
1691 agFALSE
1692 );
1693 #endif
1694 #ifdef TARGET_DRIVER
1695 ttdssReportRemovals(agRoot,
1696 onePortContext,
1697 agFALSE
1698 );
1699
1700 #endif
1701
1702 /* find a PhyID and reset for portContext in tdssSASShared */
1703 for(i=0;i<TD_MAX_NUM_PHYS;i++)
1704 {
1705 if (onePortContext->PhyIDList[i] == agTRUE)
1706 {
1707 tdsaAllShared->Ports[i].portContext = agNULL;
1708 }
1709 }
1710 /* portcontext is removed from MainLink to FreeLink in tdssReportRemovals or
1711 ossaDeregisterDeviceHandleCB
1712 */
1713 }/* OSSA_PORT_INVALID */
1714 else
1715 {
1716 /* other newly defined port state */
1717 /* do nothing */
1718 TI_DBG2(("ossaHwCB: portstate 0x%x\n", PortState));
1719 }
1720 } /* big else */
1721 break;
1722 }
1723 case OSSA_HW_EVENT_PHY_START_STATUS:
1724 {
1725 PhyID = TD_GET_PHY_ID(eventParm1);
1726 PhyStatus = TD_GET_PHY_STATUS(eventParm1);
1727
1728 TI_DBG6(("ossaHwCB: OSSA_HW_EVENT_PHY_START_STATUS\n"));
1729 if (PhyStatus == 0x00)
1730 {
1731 TI_DBG6(("ossaHwCB: OSSA_HW_EVENT_PHY_START_STATUS, SUCCESS\n"));
1732 }
1733 else if (PhyStatus == 0x01)
1734 {
1735 TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_START_STATUS, INVALID_PHY\n"));
1736 }
1737 else if (PhyStatus == 0x02)
1738 {
1739 TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_START_STATUS, PHY_NOT_DISABLED\n"));
1740 }
1741 else
1742 {
1743 TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_START_STATUS, OTHER_FAILURE %d\n", PhyStatus));
1744 }
1745 break;
1746 }
1747 case OSSA_HW_EVENT_PHY_STOP_STATUS:
1748 {
1749 agsaContext_t *agContext;
1750 PhyID = TD_GET_PHY_ID(eventParm1);
1751 PhyStatus = TD_GET_PHY_STATUS(eventParm1);
1752 PortState = TD_GET_PORT_STATE(eventParm1);
1753
1754 TI_DBG2(("ossaHwCB: OSSA_HW_EVENT_PHY_STOP_STATUS\n"));
1755 if (PhyStatus == 0x00)
1756 {
1757 TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_STOP_STATUS, SUCCESS\n"));
1758 agContext = (agsaContext_t *)eventParm2;
1759 onePortContext = (tdsaPortContext_t *)agContext->osData;
1760 if (onePortContext == agNULL)
1761 {
1762 TI_DBG1(("ossaHwCB: onePortContext is null, wrong!!!\n"));
1763 return;
1764 }
1765 onePortContext->PhyIDList[PhyID] = agFALSE;
1766 if (PortState == OSSA_PORT_INVALID) /* invalid port */
1767 {
1768 TI_DBG1(("ossaHwCB: OSSA_PORT_INVALID\n"));
1769 tdsaAllShared->eventSource[PhyID].EventValid = NO_ACK;
1770 onePortContext->eventPhyID = PhyID;
1771 onePortContext->valid = agFALSE;
1772
1773 TI_DBG2(("ossaHwCB: pid %d\n", onePortContext->id));
1774 #ifdef INITIATOR_DRIVER
1775 /* notifying link down (all links belonging to a port are down) */
1776 ostiPortEvent(
1777 tiRoot,
1778 tiPortStopped,
1779 tiSuccess,
1780 (void *)onePortContext->tiPortalContext
1781 );
1782 #endif
1783
1784 #ifdef TARGET_DRIVER
1785 ostiPortEvent(
1786 tiRoot,
1787 tiPortLinkDown,
1788 tiSuccess,
1789 (void *)onePortContext->tiPortalContext
1790 );
1791
1792 #endif
1793
1794 #ifdef INITIATOR_DRIVER
1795 tdssReportRemovals(agRoot,
1796 onePortContext,
1797 agFALSE
1798 );
1799 #endif
1800 #ifdef TARGET_DRIVER
1801 ttdssReportRemovals(agRoot,
1802 onePortContext,
1803 agFALSE
1804 );
1805
1806 #endif
1807
1808 /* find a PhyID and reset for portContext in tdssSASShared */
1809 for(i=0;i<TD_MAX_NUM_PHYS;i++)
1810 {
1811 if (onePortContext->PhyIDList[i] == agTRUE)
1812 {
1813 tdsaAllShared->Ports[i].portContext = agNULL;
1814 }
1815 }
1816 /* portcontext is removed from MainLink to FreeLink in tdssReportRemovals or
1817 ossaDeregisterDeviceHandleCB
1818 */
1819 } /* invalid port */
1820 }
1821 else if (PhyStatus == 0x01)
1822 {
1823 TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_STOP_STATUS, INVALID_PHY\n"));
1824 }
1825 else if (PhyStatus == 0x02)
1826 {
1827 TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_STOP_STATUS, DEVICES_ATTACHED\n"));
1828 }
1829 else if (PhyStatus == 0x03)
1830 {
1831 TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_STOP_STATUS, OTHER_FAILURE\n"));
1832 }
1833 else if (PhyStatus == 0x04)
1834 {
1835 TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_STOP_STATUS, PHY_NOT_DISABLED\n"));
1836 }
1837 else
1838 {
1839 TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_STOP_STATUS, Unknown %d\n", PhyStatus));
1840 }
1841 break;
1842 }
1843
1844 case OSSA_HW_EVENT_RESET_START:
1845 {
1846 bit32 new_status = TD_GET_RESET_STATUS(eventParm1);
1847 TI_DBG2(("ossaHwCB: RESET_START, status %d\n", new_status));
1848 if (new_status == OSSA_SUCCESS)
1849 {
1850 tdsaAllShared->flags.resetInProgress = agTRUE;
1851 TI_DBG2(("ossaHwCB: RESET_START, SUCCESS\n"));
1852 }
1853 else if (new_status == OSSA_FAILURE)
1854 {
1855 TI_DBG1(("ossaHwCB: RESET_START, FAILURE\n"));
1856 }
1857 else
1858 {
1859 TI_DBG1(("ossaHwCB: RESET_START, PENDING\n"));
1860 }
1861 break;
1862 }
1863
1864 case OSSA_HW_EVENT_RESET_COMPLETE:
1865 {
1866 bit32 new_status = TD_GET_RESET_STATUS(eventParm1);
1867 #ifdef SOFT_RESET_TEST
1868 DbgPrint("Reset Complete\n");
1869 #endif
1870 TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_RESET_COMPLETE, status %d\n", new_status));
1871 if (new_status == OSSA_SUCCESS)
1872 {
1873 /* remove all portcontext and devices */
1874 #ifdef INITIATOR_DRIVER
1875 tdssRemoveSASSATAFromSharedcontextByReset(agRoot);
1876 #endif
1877 tdsaAllShared->flags.resetInProgress = agFALSE;
1878 /*
1879 a callback notifying reset completion
1880 */
1881 ostiPortEvent(
1882 tiRoot,
1883 tiPortResetComplete,
1884 tiSuccess,
1885 agNULL
1886 );
1887 }
1888 else
1889 {
1890 /*
1891 a callback notifying reset completion
1892 */
1893 tdsaAllShared->flags.resetInProgress = agFALSE;
1894 ostiPortEvent(
1895 tiRoot,
1896 tiPortResetComplete,
1897 tiError,
1898 agNULL
1899 );
1900
1901 }
1902 break;
1903 }
1904
1905 case OSSA_HW_EVENT_PHY_ERR_INBOUND_CRC:
1906 {
1907 PhyID = TD_GET_PHY_ID(eventParm1);
1908 PortState = TD_GET_PORT_STATE(eventParm1);
1909 agPhyErrCountersPage = (agsaPhyErrCountersPage_t *)eventParm2;
1910
1911 TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_ERR_INBOUND_CRC from PhyID %d; to be tested\n", PhyID));
1912
1913 if (PortState == OSSA_PORT_INVALID)
1914 {
1915 TI_DBG1(("ossaHwCB: Wrong port state with OSSA_HW_EVENT_PHY_ERR_INBOUND_CRC\n"));
1916 smTraceFuncExit(hpDBG_VERY_LOUD, 'n', "Y2");
1917 return;
1918 }
1919
1920 if (agPhyErrCountersPage != agNULL)
1921 {
1922 TI_DBG2(("ossaHwCB: OSSA_HW_EVENT_PHY_ERR_INBOUND_CRC from PhyID %d\n", PhyID));
1923 TI_DBG1(("ossaHwCB: iDw %d rDE %d cV %d lS %d rP %d iCRC %d\n",
1924 agPhyErrCountersPage->invalidDword,
1925 agPhyErrCountersPage->runningDisparityError,
1926 agPhyErrCountersPage->codeViolation,
1927 agPhyErrCountersPage->lossOfDwordSynch,
1928 agPhyErrCountersPage->phyResetProblem,
1929 agPhyErrCountersPage->inboundCRCError ));
1930 }
1931 else
1932 {
1933 TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_ERR_INBOUND_CRC: Error!!! eventParm2 is NULL\n"));
1934 }
1935
1936 /* saHwEventAck() */
1937 eventSource.agPortContext = agPortContext;
1938 eventSource.event = OSSA_HW_EVENT_PHY_ERR_INBOUND_CRC;
1939 /* phy ID */
1940 eventSource.param = PhyID;
1941 HwAckSatus = saHwEventAck(
1942 agRoot,
1943 agNULL, /* agContext */
1944 0,
1945 &eventSource, /* agsaEventSource_t */
1946 0,
1947 0
1948 );
1949 if ( HwAckSatus != AGSA_RC_SUCCESS)
1950 {
1951 TI_DBG1(("ossaHwCB: failing in saHwEventAck; status %d\n", HwAckSatus));
1952 smTraceFuncExit(hpDBG_VERY_LOUD, 'o', "Y2");
1953 return;
1954 }
1955 break;
1956 }
1957 #ifdef REMOVED
1958 case OSSA_HW_EVENT_PORT_INVALID:
1959 {
1960 TI_DBG1(("ossaHwCB: PORT_INVALID\n"));
1961
1962 if ( agPortContext == agNULL)
1963 {
1964 TI_DBG1(("ossaHwCB: agPortContext is NULL, wrong.\n"));
1965 smTraceFuncExit(hpDBG_VERY_LOUD, 'p', "Y2");
1966 return;
1967 }
1968 if ( agPortContext->osData != agNULL)
1969 {
1970 TI_DBG1(("ossaHwCB: NOT NULL osDATA\n"));
1971 /*
1972 put the old portcontext back to free list
1973 */
1974 onePortContext = (tdsaPortContext_t *)agPortContext->osData;
1975 TI_DBG1(("ossaHwCB: pid %d\n", onePortContext->id));
1976
1977 #ifdef INITIATOR_DRIVER
1978 /* notifying link down (all links belonging to a port are down) */
1979 ostiPortEvent (
1980 tiRoot,
1981 tiPortStopped,
1982 tiSuccess,
1983 (void *)onePortContext->tiPortalContext
1984
1985 );
1986 #endif /* INITIATOR_DRIVER */
1987 #ifdef TARGET_DRIVER
1988 ostiPortEvent(
1989 tiRoot,
1990 tiPortLinkDown,
1991 tiSuccess,
1992 (void *)onePortContext->tiPortalContext
1993 );
1994
1995 #endif /*TARGET_DRIVER */
1996
1997 /* find the device belonging to the port and remove it from the device list */
1998 //tdssRemoveSASSATAFromSharedcontext(agRoot, tdsaDeviceData, onePortContext);
1999
2000
2001 #ifdef INITIATOR_DRIVER
2002 /* reset the fields of portcontext */
2003 onePortContext->DiscoveryState = ITD_DSTATE_NOT_STARTED;
2004 tdssReportRemovals(agRoot,
2005 onePortContext,
2006 agFALSE
2007 );
2008
2009 onePortContext->discoveryOptions = AG_SA_DISCOVERY_OPTION_FULL_START;
2010 onePortContext->DiscoveryRdyGiven = agFALSE;
2011 onePortContext->SeenLinkUp = agFALSE;
2012
2013 #endif /* INITIATOR_DRIVER */
2014
2015
2016
2017 /* for hotplug */
2018
2019 /* find a PhyID and reset for portContext in tdssSASShared */
2020 for(i=0;i<TD_MAX_NUM_PHYS;i++)
2021 {
2022 if (onePortContext->PhyIDList[i] == agTRUE)
2023 {
2024 tdsaAllShared->Ports[i].portContext = agNULL;
2025 }
2026 }
2027
2028 /* reset PhyIDList in portcontext */
2029 for(i=0;i<TD_MAX_NUM_PHYS;i++)
2030 {
2031 onePortContext->PhyIDList[i] = agFALSE;
2032 }
2033
2034 // onePortContext->tiPortalContext = agNULL;
2035 // onePortContext->agRoot = agNULL;
2036 onePortContext->agPortContext = agNULL;
2037 onePortContext->valid = agFALSE;
2038
2039 TI_DBG4(("ossaHwCB: pid %d count %d\n", onePortContext->id, onePortContext->Count));
2040
2041 /* resets the number of devices in onePortContext */
2042 onePortContext->Count = 0;
2043 onePortContext->discovery.pendingSMP = 0;
2044 onePortContext->discovery.SeenBC = agFALSE;
2045
2046
2047 /*
2048 put all devices belonging to the onePortContext
2049 back to the free link
2050 */
2051
2052 tdsaSingleThreadedEnter(tiRoot, TD_PORT_LOCK);
2053 TDLIST_DEQUEUE_THIS(&(onePortContext->MainLink));
2054 TDLIST_ENQUEUE_AT_TAIL(&(onePortContext->FreeLink), &(tdsaPortContext->FreeLink));
2055 tdsaSingleThreadedLeave(tiRoot, TD_PORT_LOCK);
2056 }
2057 else
2058 {
2059 TI_DBG1(("ossaHwCB: NULL osDATA: wrong\n"));
2060 }
2061 TI_DBG6(("ossaHwCB: PORT_INVALID end\n"));
2062 break;
2063 }
2064 #endif /* REMOVED */
2065
2066 case OSSA_HW_EVENT_BROADCAST_CHANGE:
2067 {
2068 PhyID = TD_GET_PHY_ID(eventParm1);
2069 PortState = TD_GET_PORT_STATE(eventParm1);
2070 TI_DBG1(("ossaHwCB: BROADCAST_CHANGE from PhyID %d\n", PhyID));
2071
2072 if (PortState == OSSA_PORT_INVALID)
2073 {
2074 TI_DBG1(("ossaHwCB: Wrong port state with BROADCAST_CHANGE\n"));
2075 smTraceFuncExit(hpDBG_VERY_LOUD, 'q', "Y2");
2076 return;
2077 }
2078 /* saHwEventAck() */
2079 eventSource.agPortContext = agPortContext;
2080 eventSource.event = OSSA_HW_EVENT_BROADCAST_CHANGE;
2081 /* phy ID */
2082 eventSource.param = PhyID;
2083 HwAckSatus = saHwEventAck(
2084 agRoot,
2085 agNULL, /* agContext */
2086 0,
2087 &eventSource, /* agsaEventSource_t */
2088 0,
2089 0
2090 );
2091 TI_DBG4(("ossaHwCB: calling saHwEventAck\n"));
2092
2093 if ( HwAckSatus != AGSA_RC_SUCCESS)
2094 {
2095 TI_DBG1(("ossaHwCB: failing in saHwEventAck; status %d\n", HwAckSatus));
2096 smTraceFuncExit(hpDBG_VERY_LOUD, 'r', "Y2");
2097 return;
2098 }
2099 if (tIsSPC12SATA(agRoot))
2100 {
2101 TI_DBG1(("ossaHwCB: BROADCAST_CHANGE received for SATA Controller\n"));
2102 break;
2103 }
2104 /*
2105 * incremental discovery is to be tested and debugged further
2106 */
2107
2108 /* just for testing discovery abort */
2109 #ifdef FDS_DM_NO
2110 if (agPortContext == agNULL)
2111 {
2112 /* this case happens when broadcase is received first before the link up */
2113 TI_DBG2(("ossaHwCB: agPortContext is NULL. Do nothing.\n"));
2114 }
2115 else if ( agPortContext->osData != agNULL)
2116 {
2117 dmRoot = &(tdsaAllShared->dmRoot);
2118 onePortContext = (tdsaPortContext_t *)agPortContext->osData;
2119 dmPortContext = &(onePortContext->dmPortContext);
2120
2121 dmQueryDiscovery(dmRoot, dmPortContext);
2122 // dmDiscover(dmRoot, dmPortContext, DM_DISCOVERY_OPTION_ABORT);
2123
2124 #if 1
2125 if (onePortContext->DMDiscoveryState == dmDiscInProgress)
2126 {
2127 dmDiscover(dmRoot, dmPortContext, DM_DISCOVERY_OPTION_ABORT);
2128 }
2129 #endif /* 1 */
2130
2131 TI_DBG2(("ossaHwCB: portcontext pid %d\n", onePortContext->id));
2132 if (onePortContext->DMDiscoveryState == dmDiscCompleted ||
2133 onePortContext->DMDiscoveryState == dmDiscAborted ||
2134 onePortContext->DMDiscoveryState == dmDiscAbortInvalid )
2135 {
2136 TI_DBG1(("ossaHwCB: BROADCAST_CHANGE; calling dmNotifyBC and does incremental discovery\n"));
2137 dmNotifyBC(dmRoot, dmPortContext, OSSA_HW_EVENT_BROADCAST_CHANGE);
2138 dmDiscover(dmRoot, dmPortContext, DM_DISCOVERY_OPTION_INCREMENTAL_START);
2139
2140 }
2141 else
2142 {
2143 TI_DBG2(("ossaHwCB: pid %d BROADCAST_CHANGE; updating SeenBC. calling dmNotifyBC\n", onePortContext->id));
2144 dmNotifyBC(dmRoot, dmPortContext, OSSA_HW_EVENT_BROADCAST_CHANGE);
2145 }
2146 }
2147 else
2148 {
2149 TI_DBG1(("ossaHwCB: BROADCAST_CHANGE NULL osDATA wrong !!! \n"));
2150 }
2151
2152
2153 #endif /* FDS_DM_NO */
2154
2155 #ifdef FDS_DM
2156 if (agPortContext == agNULL)
2157 {
2158 /* this case happens when broadcase is received first before the link up */
2159 TI_DBG2(("ossaHwCB: agPortContext is NULL. Do nothing.\n"));
2160 }
2161 else if ( agPortContext->osData != agNULL)
2162 {
2163 dmRoot = &(tdsaAllShared->dmRoot);
2164 onePortContext = (tdsaPortContext_t *)agPortContext->osData;
2165 dmPortContext = &(onePortContext->dmPortContext);
2166
2167 dmQueryDiscovery(dmRoot, dmPortContext);
2168
2169 TI_DBG2(("ossaHwCB: portcontext pid %d\n", onePortContext->id));
2170 if (onePortContext->DMDiscoveryState == dmDiscCompleted ||
2171 onePortContext->DMDiscoveryState == dmDiscAborted ||
2172 onePortContext->DMDiscoveryState == dmDiscAbortInvalid )
2173 {
2174 TI_DBG1(("ossaHwCB: BROADCAST_CHANGE; calling dmNotifyBC and does incremental discovery, pid %d\n", onePortContext->id));
2175 onePortContext->DiscoveryState = ITD_DSTATE_STARTED;
2176 dmNotifyBC(dmRoot, dmPortContext, OSSA_HW_EVENT_BROADCAST_CHANGE);
2177 dmDiscover(dmRoot, dmPortContext, DM_DISCOVERY_OPTION_INCREMENTAL_START);
2178
2179 }
2180 else if (onePortContext->DMDiscoveryState == dmDiscFailed )
2181 {
2182 TI_DBG1(("ossaHwCB: dmDiscFailed; pid %d BROADCAST_CHANGE; updating SeenBC. calling dmNotifyBC\n", onePortContext->id));
2183 onePortContext->DiscFailNSeenBC = agTRUE;
2184 dmNotifyBC(dmRoot, dmPortContext, OSSA_HW_EVENT_BROADCAST_CHANGE);
2185 }
2186 else
2187 {
2188 TI_DBG2(("ossaHwCB: pid %d BROADCAST_CHANGE; updating SeenBC. calling dmNotifyBC\n", onePortContext->id));
2189 dmNotifyBC(dmRoot, dmPortContext, OSSA_HW_EVENT_BROADCAST_CHANGE);
2190 }
2191 }
2192 else
2193 {
2194 TI_DBG1(("ossaHwCB: BROADCAST_CHANGE NULL osDATA wrong !!! \n"));
2195 }
2196 #endif /* FDS_DM */
2197
2198 #ifdef FDS_DM_WORKED
2199 if (agPortContext == agNULL)
2200 {
2201 /* this case happens when broadcase is received first before the link up */
2202 TI_DBG2(("ossaHwCB: agPortContext is NULL. Do nothing.\n"));
2203 }
2204 else if ( agPortContext->osData != agNULL)
2205 {
2206 onePortContext = (tdsaPortContext_t *)agPortContext->osData;
2207 TI_DBG2(("ossaHwCB: calling dmNotifyBC\n"));
2208 dmRoot = &(tdsaAllShared->dmRoot);
2209 dmPortContext = &(onePortContext->dmPortContext);
2210 dmNotifyBC(dmRoot, dmPortContext, OSSA_HW_EVENT_BROADCAST_CHANGE);
2211 }
2212 #endif /* FDS_DM_WORKED */
2213
2214 #ifndef FDS_DM
2215 #ifdef INITIATOR_DRIVER
2216 if (agPortContext == agNULL)
2217 {
2218 /* this case happens when broadcase is received first before the link up */
2219 TI_DBG2(("ossaHwCB: agPortContext is NULL. Do nothing.\n"));
2220 }
2221 else if ( agPortContext->osData != agNULL)
2222 {
2223 onePortContext = (tdsaPortContext_t *)agPortContext->osData;
2224 TI_DBG2(("ossaHwCB: portcontext pid %d\n", onePortContext->id));
2225 if (onePortContext->DiscoveryState == ITD_DSTATE_COMPLETED)
2226 {
2227 TI_DBG1(("ossaHwCB: BROADCAST_CHANGE; does incremental discovery\n"));
2228 onePortContext->DiscoveryState = ITD_DSTATE_NOT_STARTED;
2229 onePortContext->discoveryOptions = AG_SA_DISCOVERY_OPTION_INCREMENTAL_START;
2230 /* processed broadcast change */
2231 onePortContext->discovery.SeenBC = agFALSE;
2232 #ifdef TD_DISCOVER
2233 if (tdsaAllShared->ResetInDiscovery != 0 &&
2234 onePortContext->discovery.ResetTriggerred == agTRUE)
2235 {
2236 TI_DBG2(("ossaHwCB: tdsaBCTimer\n"));
2237 tdsaBCTimer(tiRoot, onePortContext);
2238 }
2239 else
2240 {
2241 tdsaDiscover(
2242 tiRoot,
2243 onePortContext,
2244 TDSA_DISCOVERY_TYPE_SAS,
2245 TDSA_DISCOVERY_OPTION_INCREMENTAL_START
2246 );
2247 }
2248 #else
2249 saDiscover(agRoot,
2250 agPortContext,
2251 AG_SA_DISCOVERY_TYPE_SAS,
2252 onePortContext->discoveryOptions);
2253 #endif
2254 }
2255 else
2256 {
2257 TI_DBG2(("ossaHwCB: pid %d BROADCAST_CHANGE; updating SeenBC. Do nothing.\n", onePortContext->id));
2258 onePortContext->discovery.SeenBC = agTRUE;
2259 }
2260 }
2261 else
2262 {
2263 TI_DBG1(("ossaHwCB: BROADCAST_CHANGE NULL osDATA wrong !!! \n"));
2264 }
2265 #endif
2266 #endif /* ifndef FDS_DM */
2267
2268 break;
2269 }
2270
2271 case OSSA_HW_EVENT_PORT_RECOVERY_TIMER_TMO:
2272 {
2273 PhyID = TD_GET_PHY_ID(eventParm1);
2274 PortState = TD_GET_PORT_STATE(eventParm1);
2275
2276 /*
2277 1. tear town the portcontext just like link down last phy down
2278 2. ack
2279 port state must be invalid
2280 */
2281
2282 TI_DBG2(("ossaHwCB: OSSA_HW_EVENT_PORT_RECOVERY_TIMER_TMO\n"));
2283
2284 if (PortState == OSSA_PORT_VALID)
2285 {
2286 TI_DBG1(("ossaHwCB: Wrong port state\n"));
2287 smTraceFuncExit(hpDBG_VERY_LOUD, 's', "Y2");
2288 return;
2289 }
2290
2291 TD_ASSERT(agPortContext, "agPortContext");
2292 if ( agPortContext->osData == agNULL)
2293 { /* if */
2294 /* PortContext must exit at this point */
2295 TI_DBG1(("ossaHwCB: NULL portalcontext. Error. Can't be NULL\n"));
2296 }
2297 else
2298 {
2299 onePortContext = (tdsaPortContext_t *)agPortContext->osData;
2300 onePortContext->valid = agFALSE;
2301
2302 TI_DBG1(("ossaHwCB: tiPortStopped pid %d\n", onePortContext->id));
2303 #ifdef INITIATOR_DRIVER
2304 /* notifying link down (all links belonging to a port are down) */
2305 ostiPortEvent(
2306 tiRoot,
2307 tiPortStopped,
2308 tiSuccess,
2309 (void *)onePortContext->tiPortalContext
2310 );
2311 #endif
2312
2313 #ifdef TARGET_DRIVER
2314 ostiPortEvent(
2315 tiRoot,
2316 tiPortLinkDown,
2317 tiSuccess,
2318 (void *)onePortContext->tiPortalContext
2319 );
2320
2321 #endif
2322
2323 #ifdef INITIATOR_DRIVER
2324 tdssReportRemovals(agRoot,
2325 onePortContext,
2326 agFALSE
2327 );
2328 #endif
2329 #ifdef TARGET_DRIVER
2330 ttdssReportRemovals(agRoot,
2331 onePortContext,
2332 agFALSE
2333 );
2334
2335 #endif
2336 /* find a PhyID and reset for portContext in tdssSASShared */
2337 for(i=0;i<TD_MAX_NUM_PHYS;i++)
2338 {
2339 if (onePortContext->PhyIDList[i] == agTRUE)
2340 {
2341 tdsaAllShared->Ports[i].portContext = agNULL;
2342 }
2343 }
2344 /* portcontext is removed from MainLink to FreeLink in tdssReportRemovals or
2345 ossaDeregisterDeviceHandleCB
2346 */
2347 }
2348
2349 break;
2350 }
2351
2352 case OSSA_HW_EVENT_PORT_RESET_TIMER_TMO:
2353 {
2354 /*
2355 clean up
2356 */
2357 PhyID = TD_GET_PHY_ID(eventParm1);
2358 PortState = TD_GET_PORT_STATE(eventParm1);
2359
2360 TI_DBG2(("ossaHwCB: OSSA_HW_EVENT_PORT_RESET_TIMER_TMO\n"));
2361
2362 if (PortState == OSSA_PORT_VALID)
2363 {
2364 TI_DBG1(("ossaHwCB: Wrong port state\n"));
2365 smTraceFuncExit(hpDBG_VERY_LOUD, 't', "Y2");
2366 return;
2367 }
2368
2369 if (agPortContext == agNULL)
2370 {
2371 TI_DBG1(("ossaHwCB: agPortContext is NULL, error\n"));
2372 smTraceFuncExit(hpDBG_VERY_LOUD, 'u', "Y2");
2373 return;
2374 }
2375
2376 if ( agPortContext->osData == agNULL)
2377 { /* if */
2378 /* PortContext must exit at this point */
2379 TI_DBG1(("ossaHwCB: NULL portalcontext. Error. Can't be NULL\n"));
2380 }
2381 else
2382 {
2383 onePortContext = (tdsaPortContext_t *)agPortContext->osData;
2384 onePortContext->valid = agFALSE;
2385
2386 TI_DBG1(("ossaHwCB: pid %d tiPortStopped\n", onePortContext->id));
2387
2388 #ifdef INITIATOR_DRIVER
2389 /* notifying link down (all links belonging to a port are down) */
2390 ostiPortEvent(
2391 tiRoot,
2392 tiPortStopped,
2393 tiSuccess,
2394 (void *)onePortContext->tiPortalContext
2395 );
2396 #endif
2397
2398 #ifdef TARGET_DRIVER
2399 ostiPortEvent(
2400 tiRoot,
2401 tiPortLinkDown,
2402 tiSuccess,
2403 (void *)onePortContext->tiPortalContext
2404 );
2405
2406 #endif
2407
2408 #ifdef INITIATOR_DRIVER
2409 tdssReportRemovals(agRoot,
2410 onePortContext,
2411 agFALSE
2412 );
2413 #endif
2414 #ifdef TARGET_DRIVER
2415 ttdssReportRemovals(agRoot,
2416 onePortContext,
2417 agFALSE
2418 );
2419
2420 #endif
2421 /* find a PhyID and reset for portContext in tdssSASShared */
2422 for(i=0;i<TD_MAX_NUM_PHYS;i++)
2423 {
2424 if (onePortContext->PhyIDList[i] == agTRUE)
2425 {
2426 tdsaAllShared->Ports[i].portContext = agNULL;
2427 }
2428 }
2429 /* portcontext is removed from MainLink to FreeLink in tdssReportRemovals or
2430 ossaDeregisterDeviceHandleCB
2431 */
2432 }
2433
2434 break;
2435 }
2436
2437 case OSSA_HW_EVENT_PORT_RESET_COMPLETE:
2438 {
2439 #ifdef INITIATOR_DRIVER
2440 tiIORequest_t *currentTaskTag = agNULL;
2441 #endif
2442
2443 #ifdef REMOVED
2444 smRoot_t *smRoot = &(tdsaAllShared->smRoot);
2445 #endif
2446
2447 PhyID = TD_GET_PHY_ID(eventParm1);
2448 PortState = TD_GET_PORT_STATE(eventParm1);
2449 IDframe = (agsaSASIdentify_t *)eventParm3;
2450
2451 /* completes for Lun Reset and Target reset for directly attached SATA */
2452 /* completes for Target reset for directly attached SAS */
2453
2454 TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PORT_RESET_COMPLETE, phyID %d\n", PhyID));
2455
2456 /* error check */
2457 if (PortState == OSSA_PORT_INVALID)
2458 {
2459 TI_DBG1(("ossaHwCB: Wrong port state\n"));
2460 smTraceFuncExit(hpDBG_VERY_LOUD, 'v', "Y2");
2461 return;
2462 }
2463
2464 if (agPortContext == agNULL)
2465 {
2466 TI_DBG1(("ossaHwCB: agPortContext null, wrong\n"));
2467 smTraceFuncExit(hpDBG_VERY_LOUD, 'w', "Y2");
2468 return;
2469 }
2470 if ( agPortContext->osData == agNULL)
2471 {
2472 TI_DBG1(("ossaHwCB: agPortContext->osData null, wrong\n"));
2473 smTraceFuncExit(hpDBG_VERY_LOUD, 'x', "Y2");
2474 return;
2475 }
2476
2477 /* find a corresponding portcontext */
2478 onePortContext = (tdsaPortContext_t *)agPortContext->osData;
2479
2480 if (onePortContext == agNULL)
2481 {
2482 TI_DBG1(("ossaHwCB: oneportContext is NULL; wrong??????\n"));
2483 }
2484 else
2485 {
2486 TI_DBG1(("ossaHwCB: oneportContext %p pid %d\n", onePortContext, onePortContext->id));
2487 onePortContext->valid = agTRUE;
2488 #ifdef INITIATOR_DRIVER
2489 #ifdef REMOVED
2490 if (tdsaAllShared->ResetInDiscovery != 0)
2491 {
2492 DeviceListList = tdsaAllShared->MainDeviceList.flink;
2493 while (DeviceListList != &(tdsaAllShared->MainDeviceList))
2494 {
2495 oneDeviceData = TDLIST_OBJECT_BASE(tdsaDeviceData_t, MainLink, DeviceListList);
2496 if (oneDeviceData->tdPortContext != onePortContext)
2497 {
2498 DeviceListList = DeviceListList->flink;
2499 }
2500 else
2501 {
2502 found = agTRUE;
2503 break;
2504 }
2505 } /* while */
2506 if (found == agTRUE)
2507 {
2508 /* applied to only SATA devices */
2509 if (DEVICE_IS_SATA_DEVICE(oneDeviceData) || DEVICE_IS_STP_TARGET(oneDeviceData))
2510 {
2511 #ifdef FDS_SM
2512 tdIDStart(tiRoot, agRoot, smRoot, oneDeviceData, onePortContext);
2513 #else
2514 tdssRetrySATAID(tiRoot, oneDeviceData);
2515 #endif
2516 }
2517 }
2518 else
2519 {
2520 TI_DBG1(("ossaHwCB: no onedevicedata found!\n"));
2521 }
2522 }
2523 #endif
2524 /* completed TM */
2525 DeviceListList = tdsaAllShared->MainDeviceList.flink;
2526 while (DeviceListList != &(tdsaAllShared->MainDeviceList))
2527 {
2528 oneDeviceData = TDLIST_OBJECT_BASE(tdsaDeviceData_t, MainLink, DeviceListList);
2529 if ( oneDeviceData == agNULL)
2530 {
2531 TI_DBG1(("ossaHwCB: oneDeviceData is NULL!!!\n"));
2532 return;
2533 }
2534
2535 if ( (oneDeviceData->tdPortContext == onePortContext) &&
2536 (oneDeviceData->directlyAttached == agTRUE) &&
2537 (oneDeviceData->phyID == PhyID) )
2538 {
2539 TI_DBG1(("ossaHwCB: found the onePortContext and oneDeviceData!!\n"));
2540
2541 currentTaskTag = (tiIORequest_t *)oneDeviceData->agDeviceResetContext.osData;
2542 if (currentTaskTag != agNULL )
2543 {
2544 /* applied to only SATA devices */
2545 if (DEVICE_IS_SATA_DEVICE(oneDeviceData))
2546 {
2547 tdIORequestBody_t *SMTMtdIORequestBody = agNULL;
2548 SMTMtdIORequestBody = (tdIORequestBody_t *)currentTaskTag->tdData;
2549 if (SMTMtdIORequestBody != agNULL)
2550 {
2551 /* free the SMTMtdIORequestBody memory allocated in tiINITaskManagement function */
2552 ostiFreeMemory(
2553 tiRoot,
2554 SMTMtdIORequestBody->IOType.InitiatorTMIO.osMemHandle,
2555 sizeof(tdIORequestBody_t)
2556 );
2557 }
2558 else
2559 {
2560 TI_DBG1(("ossaHwCB: SATA device but SMTMtdIORequestBody is NULL!!!\n"));
2561 }
2562 }
2563 /* set device state to DS_OPERATIONAL */
2564 saSetDeviceState(agRoot,
2565 agNULL,
2566 tdsaRotateQnumber(tiRoot, oneDeviceData),
2567 oneDeviceData->agDevHandle,
2568 SA_DS_OPERATIONAL
2569 );
2570 /* notify OS layer to complete the TMF IO */
2571 ostiInitiatorEvent(tiRoot,
2572 agNULL,
2573 agNULL,
2574 tiIntrEventTypeTaskManagement,
2575 tiTMOK,
2576 currentTaskTag
2577 );
2578
2579 }
2580 else
2581 {
2582 TI_DBG1(("ossaHwCB: currentTaskTag is NULL!!!\n"));
2583 }
2584
2585 break;
2586 }
2587 else
2588 {
2589 DeviceListList = DeviceListList->flink;
2590 }
2591 }
2592 #endif
2593 }
2594 break;
2595 }
2596 case OSSA_HW_EVENT_BROADCAST_ASYNCH_EVENT:
2597 {
2598 PhyID = TD_GET_PHY_ID(eventParm1);
2599 PortState = TD_GET_PORT_STATE(eventParm1);
2600
2601 TI_DBG2(("ossaHwCB: OSSA_HW_EVENT_BROADCAST_ASYNCH_EVENT\n"));
2602 if (tIsSPC12SATA(agRoot))
2603 {
2604 TI_DBG1(("ossaHwCB: BROADCAST_ASYNCH_EVENT received for SATA Controller\n"));
2605 break;
2606 }
2607 if (agPortContext == agNULL)
2608 {
2609 TI_DBG1(("ossaHwCB: Error!!! agPortContext is NULL %d\n", PhyID));
2610 smTraceFuncExit(hpDBG_VERY_LOUD, 'y', "Y2");
2611 return;
2612 }
2613 onePortContext = (tdsaPortContext_t *)agPortContext->osData;
2614 if (onePortContext == agNULL)
2615 {
2616 TI_DBG1(("ossaHwCB: Error!!! onePortContext is NULL %d\n", PhyID));
2617 smTraceFuncExit(hpDBG_VERY_LOUD, 'z', "Y2");
2618 return;
2619 }
2620
2621 if (onePortContext->tiPortalContext != agNULL)
2622 {
2623 #if 0
2624 ostiInitiatorEvent(
2625 tiRoot,
2626 onePortContext->tiPortalContext,
2627 agNULL,
2628 tiIntrEventTypeDeviceChange,
2629 OSSA_HW_EVENT_BROADCAST_ASYNCH_EVENT,
2630 agNULL
2631 );
2632 #endif
2633 }
2634 else
2635 {
2636 TI_DBG1(("ossaHwCB: Error!!! onePortContext->tiPortalContext is NULL\n"));
2637 smTraceFuncExit(hpDBG_VERY_LOUD, 'A', "Y2");
2638 return;
2639 }
2640
2641 break;
2642 }
2643
2644 case OSSA_HW_EVENT_PORT_RECOVER:
2645 {
2646
2647 PhyID = TD_GET_PHY_ID(eventParm1);
2648 if (agPortContext == agNULL)
2649 {
2650 TI_DBG1(("ossaHwCB: Error!!! agPortContext is NULL %d\n", PhyID));
2651 smTraceFuncExit(hpDBG_VERY_LOUD, 'B', "Y2");
2652 return;
2653 }
2654
2655 LinkRate = TD_GET_LINK_RATE(eventParm1);
2656 PortState = TD_GET_PORT_STATE(eventParm1);
2657 agDevHandle = agNULL;
2658 IDframe = (agsaSASIdentify_t *)eventParm3;
2659
2660 /*
2661 1. this is like link up
2662 2. handle the phyID
2663 3. no trigger discovery (broadcast change will do this later)
2664 port state must be valid
2665 */
2666
2667 TI_DBG2(("ossaHwCB: OSSA_HW_EVENT_PORT_RECOVER, phyID %d\n", PhyID));
2668
2669 if (PortState == OSSA_PORT_INVALID)
2670 {
2671 TI_DBG1(("ossaHwCB: Wrong port state\n"));
2672 smTraceFuncExit(hpDBG_VERY_LOUD, 'C', "Y2");
2673 return;
2674 }
2675 if ( agPortContext->osData == agNULL)
2676 { /* if */
2677 /* PortContext must exit at this point */
2678 TI_DBG1(("ossaHwCB: NULL portalcontext. Error. Can't be NULL\n"));
2679 }
2680 else
2681 {
2682 onePortContext = (tdsaPortContext_t *)agPortContext->osData;
2683 TI_DBG2(("ossaHwCB: pid %d\n", onePortContext->id));
2684 onePortContext->PhyIDList[PhyID] = agTRUE;
2685 onePortContext->valid = agTRUE;
2686 tdsaAllShared->Ports[PhyID].portContext = onePortContext;
2687 onePortContext->tiPortalContext = tdsaAllShared->Ports[PhyID].tiPortalContext;
2688 onePortContext->PortRecoverPhyID = PhyID;
2689 if (LinkRate == 0x01)
2690 {
2691 onePortContext->LinkRate = SAS_CONNECTION_RATE_1_5G;
2692 }
2693 else if (LinkRate == 0x02)
2694 {
2695 onePortContext->LinkRate = SAS_CONNECTION_RATE_3_0G;
2696 }
2697 else if (LinkRate == 0x04)
2698 {
2699 onePortContext->LinkRate = SAS_CONNECTION_RATE_6_0G;
2700 }
2701 else /* (LinkRate == 0x08) */
2702 {
2703 onePortContext->LinkRate = SAS_CONNECTION_RATE_12_0G;
2704 }
2705
2706 if (SA_IDFRM_GET_DEVICETTYPE(&onePortContext->sasIDframe) == SAS_END_DEVICE &&
2707 SA_IDFRM_IS_SSP_TARGET(&onePortContext->sasIDframe) )
2708 {
2709 TI_DBG2(("ossaHwCB: OSSA_HW_EVENT_PORT_RECOVER, sending spinup on phyID %d\n", PhyID));
2710 for (i=0;i<TD_MAX_NUM_NOTIFY_SPINUP;i++)
2711 {
2712 saLocalPhyControl(agRoot, agNULL, 0, PhyID, AGSA_PHY_NOTIFY_ENABLE_SPINUP, agNULL);
2713 }
2714 }
2715
2716 /* transient period between link up and link down/port recovery */
2717 if (onePortContext->Transient == agTRUE && onePortContext->RegisteredDevNums == 0)
2718 {
2719 TI_DBG2(("ossaHwCB: OSSA_HW_EVENT_PORT_RECOVER transient period"));
2720 if (SA_IDFRM_GET_DEVICETTYPE(IDframe) != SAS_NO_DEVICE)
2721 {
2722 #ifdef INITIATOR_DRIVER
2723 agSASSubID.sasAddressHi = SA_IDFRM_GET_SAS_ADDRESSHI(IDframe);
2724 agSASSubID.sasAddressLo = SA_IDFRM_GET_SAS_ADDRESSLO(IDframe);
2725 agSASSubID.initiator_ssp_stp_smp = IDframe->initiator_ssp_stp_smp;
2726 agSASSubID.target_ssp_stp_smp = IDframe->target_ssp_stp_smp;
2727 tdssAddSASToSharedcontext(
2728 onePortContext,
2729 agRoot,
2730 agDevHandle, /* agNULL */
2731 &agSASSubID,
2732 agTRUE,
2733 (bit8)PhyID,
2734 TD_OPERATION_INITIATOR
2735 );
2736 #endif
2737 }
2738 onePortContext->Transient = agFALSE;
2739 }
2740
2741
2742
2743
2744 }
2745 break;
2746 }
2747
2748 case OSSA_HW_EVENT_BROADCAST_SES:
2749 {
2750 PhyID = TD_GET_PHY_ID(eventParm1);
2751 PortState = TD_GET_PORT_STATE(eventParm1);
2752
2753 TI_DBG2(("ossaHwCB: BROADCAST_SES from PhyID %d; to be tested\n", PhyID));
2754 if (tIsSPC12SATA(agRoot))
2755 {
2756 TI_DBG1(("ossaHwCB: BROADCAST_SES received for SATA Controller\n"));
2757 break;
2758 }
2759 if (PortState == OSSA_PORT_INVALID)
2760 {
2761 TI_DBG1(("ossaHwCB: Wrong port state with BROADCAST_SES\n"));
2762 smTraceFuncExit(hpDBG_VERY_LOUD, 'D', "Y2");
2763 return;
2764 }
2765
2766 /*
2767 let os layer read payload
2768 */
2769 break;
2770 }
2771 case OSSA_HW_EVENT_BROADCAST_EXP:
2772 {
2773 PhyID = TD_GET_PHY_ID(eventParm1);
2774 PortState = TD_GET_PORT_STATE(eventParm1);
2775
2776 TI_DBG2(("ossaHwCB: BROADCAST_EXP from PhyID %d; to be tested\n", PhyID));
2777 if (tIsSPC12SATA(agRoot))
2778 {
2779 TI_DBG1(("ossaHwCB: BROADCAST_EXP received for SATA Controller\n"));
2780 break;
2781 }
2782
2783 if (PortState == OSSA_PORT_INVALID)
2784 {
2785 TI_DBG1(("ossaHwCB: Wrong port state with BROADCAST_EXP\n"));
2786 smTraceFuncExit(hpDBG_VERY_LOUD, 'E', "Y2");
2787 return;
2788 }
2789 /* to-do:
2790 let os layer read payload
2791 */
2792 break;
2793 }
2794
2795 case OSSA_HW_EVENT_HARD_RESET_RECEIVED:
2796 {
2797 PhyID = TD_GET_PHY_ID(eventParm1);
2798 PortState = TD_GET_PORT_STATE(eventParm1);
2799
2800 TI_DBG2(("ossaHwCB: HARD_RESET_RECEIVED from PhyID %d\n", PhyID));
2801
2802 if (PortState == OSSA_PORT_VALID && tiIS_SPC(agRoot))
2803 {
2804 TI_DBG1(("ossaHwCB: calling saPortControl and OSSA_PORT_VALID\n"));
2805 saPortControl(agRoot, agNULL, 0, agPortContext, AGSA_PORT_HARD_RESET, 0,0);
2806 }
2807 else if (PortState == OSSA_PORT_3RDPARTY_RESET && (tIsSPCV12or6G(agRoot)) )
2808 {
2809 TI_DBG1(("ossaHwCB: calling saPortControl and OSSA_PORT_3RDPARTY_RESET\n"));
2810 saPortControl(agRoot, agNULL, 0, agPortContext, AGSA_PORT_HARD_RESET, 0,0);
2811 }
2812 else /* PortState == OSSA_PORT_INVALID */
2813 {
2814 TI_DBG1(("ossaHwCB: Error. Port state is invalid\n"));
2815 #ifdef REMOVED
2816 TI_DBG1(("ossaHwCB: calling saLocalPhyControl on phyID %d\n", PhyID));
2817 saLocalPhyControl(agRoot, agNULL, 0, PhyID, AGSA_PHY_LINK_RESET, agNULL);
2818 #endif
2819 }
2820
2821 break;
2822 }
2823
2824 case OSSA_HW_EVENT_MALFUNCTION:
2825 {
2826 #ifdef TD_DEBUG_ENABLE
2827 agsaFatalErrorInfo_t *FatalError = (agsaFatalErrorInfo_t *)eventParm2;
2828 #endif
2829 TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_MALFUNCTION \n"));
2830 TI_DBG1(("ossaHwCB: errorInfo0 %8X errorInfo1 %8X\n", FatalError->errorInfo0, FatalError->errorInfo1));
2831 TI_DBG1(("ossaHwCB: errorInfo2 %8X errorInfo3 %8X\n", FatalError->errorInfo2, FatalError->errorInfo3));
2832 TI_DBG1(("ossaHwCB: regDumpBusBaseNum0 %8X regDumpOffset0 %8X regDumpLen0 %8X\n", FatalError->regDumpBusBaseNum0, FatalError->regDumpOffset0, FatalError->regDumpLen0));
2833 TI_DBG1(("ossaHwCB: regDumpBusBaseNum1 %8X regDumpOffset1 %8X regDumpLen1 %8X\n", FatalError->regDumpBusBaseNum1, FatalError->regDumpOffset1, FatalError->regDumpLen1));
2834
2835
2836 if (eventParm1 == agTRUE)
2837 {
2838 TI_DBG1(("ossaHwCB: fatal error\n"));
2839 /* port panic */
2840 ostiPortEvent (
2841 tiRoot,
2842 tiPortPanic,
2843 0,
2844 agNULL
2845 );
2846 }
2847 else
2848 {
2849 TI_DBG1(("ossaHwCB: non-fatal error \n"));
2850 }
2851 break;
2852 }
2853
2854 case OSSA_HW_EVENT_ID_FRAME_TIMEOUT:
2855 {
2856 PhyID = TD_GET_PHY_ID(eventParm1);
2857 PortState = TD_GET_PORT_STATE(eventParm1);
2858
2859 TI_DBG2(("ossaHwCB: OSSA_HW_EVENT_ID_FRAME_TIMEOUT from PhyID %d\n", PhyID));
2860
2861 if (PortState == OSSA_PORT_INVALID)
2862 {
2863 TI_DBG1(("ossaHwCB: Wrong port state with OSSA_HW_EVENT_ID_FRAME_TIMEOUT\n"));
2864 smTraceFuncExit(hpDBG_VERY_LOUD, 'F', "Y2");
2865 return;
2866 }
2867 break;
2868 }
2869
2870 case OSSA_HW_EVENT_PHY_ERR_INVALID_DWORD:
2871 {
2872 PhyID = TD_GET_PHY_ID(eventParm1);
2873 PortState = TD_GET_PORT_STATE(eventParm1);
2874 agPhyErrCountersPage = (agsaPhyErrCountersPage_t *)eventParm2;
2875 TI_DBG2(("ossaHwCB: OSSA_HW_EVENT_PHY_ERR_INVALID_DWORD\n"));
2876
2877 if (PortState == OSSA_PORT_INVALID)
2878 {
2879 TI_DBG1(("ossaHwCB: Wrong port state with OSSA_HW_EVENT_PHY_ERR_INVALID_DWORD\n"));
2880 smTraceFuncExit(hpDBG_VERY_LOUD, 'G', "Y2");
2881 return;
2882 }
2883
2884 if (agPhyErrCountersPage != agNULL)
2885 {
2886 TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_ERR_INVALID_DWORD from PhyID %d\n", PhyID));
2887 TI_DBG1(("ossaHwCB: invalidDword %d\n", agPhyErrCountersPage->invalidDword));
2888 }
2889 else
2890 {
2891 TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_ERR_INVALID_DWORD: Error!!! eventParm2 is NULL\n"));
2892 }
2893
2894 /* saHwEventAck() */
2895 eventSource.agPortContext = agPortContext;
2896 eventSource.event = OSSA_HW_EVENT_PHY_ERR_INVALID_DWORD;
2897 /* phy ID */
2898 eventSource.param = PhyID;
2899 HwAckSatus = saHwEventAck(
2900 agRoot,
2901 agNULL, /* agContext */
2902 0,
2903 &eventSource, /* agsaEventSource_t */
2904 0,
2905 0
2906 );
2907 if ( HwAckSatus != AGSA_RC_SUCCESS)
2908 {
2909 TI_DBG1(("ossaHwCB: failing in saHwEventAck; status %d\n", HwAckSatus));
2910 smTraceFuncExit(hpDBG_VERY_LOUD, 'H', "Y2");
2911 return;
2912 }
2913
2914 break;
2915 }
2916
2917 case OSSA_HW_EVENT_PHY_ERR_DISPARITY_ERROR:
2918 {
2919 PhyID = TD_GET_PHY_ID(eventParm1);
2920 PortState = TD_GET_PORT_STATE(eventParm1);
2921 agPhyErrCountersPage = (agsaPhyErrCountersPage_t *)eventParm2;
2922 TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_ERR_DISPARITY_ERROR\n"));
2923
2924 if (PortState == OSSA_PORT_INVALID)
2925 {
2926 TI_DBG1(("ossaHwCB: Wrong port state with OSSA_HW_EVENT_PHY_ERR_DISPARITY_ERROR\n"));
2927 smTraceFuncExit(hpDBG_VERY_LOUD, 'I', "Y2");
2928 return;
2929 }
2930
2931 if (agPhyErrCountersPage != agNULL)
2932 {
2933 TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_ERR_DISPARITY_ERROR from PhyID %d\n", PhyID));
2934 TI_DBG1(("ossaHwCB: runningDisparityError %d\n", agPhyErrCountersPage->runningDisparityError));
2935 }
2936 else
2937 {
2938 TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_ERR_DISPARITY_ERROR: Error!!! eventParm2 is NULL\n"));
2939 }
2940
2941 /* saHwEventAck() */
2942 eventSource.agPortContext = agPortContext;
2943 eventSource.event = OSSA_HW_EVENT_PHY_ERR_DISPARITY_ERROR;
2944 /* phy ID */
2945 eventSource.param = PhyID;
2946 HwAckSatus = saHwEventAck(
2947 agRoot,
2948 agNULL, /* agContext */
2949 0,
2950 &eventSource, /* agsaEventSource_t */
2951 0,
2952 0
2953 );
2954 if ( HwAckSatus != AGSA_RC_SUCCESS)
2955 {
2956 TI_DBG1(("ossaHwCB: failing in saHwEventAck; status %d\n", HwAckSatus));
2957 smTraceFuncExit(hpDBG_VERY_LOUD, 'J', "Y2");
2958 return;
2959 }
2960
2961 break;
2962 }
2963
2964 case OSSA_HW_EVENT_PHY_ERR_CODE_VIOLATION:
2965 {
2966 PhyID = TD_GET_PHY_ID(eventParm1);
2967 PortState = TD_GET_PORT_STATE(eventParm1);
2968 agPhyErrCountersPage = (agsaPhyErrCountersPage_t *)eventParm2;
2969 TI_DBG2(("ossaHwCB: OSSA_HW_EVENT_PHY_ERR_CODE_VIOLATION\n"));
2970
2971 if (PortState == OSSA_PORT_INVALID)
2972 {
2973 TI_DBG1(("ossaHwCB: Wrong port state with OSSA_HW_EVENT_PHY_ERR_CODE_VIOLATION\n"));
2974 smTraceFuncExit(hpDBG_VERY_LOUD, 'K', "Y2");
2975 return;
2976 }
2977
2978 if (agPhyErrCountersPage != agNULL)
2979 {
2980 TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_ERR_CODE_VIOLATION from PhyID %d\n", PhyID));
2981 TI_DBG1(("ossaHwCB: codeViolation %d\n", agPhyErrCountersPage->codeViolation));
2982 }
2983 else
2984 {
2985 TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_ERR_CODE_VIOLATION: Error!!! eventParm2 is NULL\n"));
2986 }
2987
2988 /* saHwEventAck() */
2989 eventSource.agPortContext = agPortContext;
2990 eventSource.event = OSSA_HW_EVENT_PHY_ERR_CODE_VIOLATION;
2991 /* phy ID */
2992 eventSource.param = PhyID;
2993 HwAckSatus = saHwEventAck(
2994 agRoot,
2995 agNULL, /* agContext */
2996 0,
2997 &eventSource, /* agsaEventSource_t */
2998 0,
2999 0
3000 );
3001 if ( HwAckSatus != AGSA_RC_SUCCESS)
3002 {
3003 TI_DBG1(("ossaHwCB: failing in saHwEventAck; status %d\n", HwAckSatus));
3004 smTraceFuncExit(hpDBG_VERY_LOUD, 'L', "Y2");
3005 return;
3006 }
3007
3008 break;
3009 }
3010
3011 #ifdef REMOVED
3012 case OSSA_HW_EVENT_LINK_ERR_CODE_VIOLATION1:
3013 {
3014 PhyID = eventParm1 & 0xFF;
3015 agPhyErrCountersPage = (agsaPhyErrCountersPage_t *)eventParm2;
3016
3017 if (agPhyErrCountersPage != agNULL)
3018 {
3019 TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_LINK_ERR_CODE_VIOLATION1 from PhyID %d\n", PhyID));
3020 TI_DBG1(("ossaHwCB: invalidDword %d\n", agPhyErrCountersPage->invalidDword));
3021 TI_DBG1(("ossaHwCB: runningDisparityError %d\n", agPhyErrCountersPage->runningDisparityError));
3022 TI_DBG1(("ossaHwCB: codeViolation %d\n", agPhyErrCountersPage->codeViolation));
3023 TI_DBG1(("ossaHwCB: lostOfDwordSynch %d\n", agPhyErrCountersPage->lossOfDwordSynch));
3024 TI_DBG1(("ossaHwCB: phyResetProblem %d\n", agPhyErrCountersPage->phyResetProblem));
3025 TI_DBG1(("ossaHwCB: inboundCRCError %d\n", agPhyErrCountersPage->inboundCRCError));
3026 }
3027 else
3028 {
3029 TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_LINK_ERR_CODE_VIOLATION1: Error!!! eventParm2 is NULL\n"));
3030 }
3031 break;
3032 }
3033 #endif /* REMOVED */
3034
3035 case OSSA_HW_EVENT_PHY_ERR_LOSS_OF_DWORD_SYNCH:
3036 {
3037 PhyID = TD_GET_PHY_ID(eventParm1);
3038 PortState = TD_GET_PORT_STATE(eventParm1);
3039 agPhyErrCountersPage = (agsaPhyErrCountersPage_t *)eventParm2;
3040 TI_DBG2(("ossaHwCB: OSSA_HW_EVENT_PHY_ERR_LOSS_OF_DWORD_SYNCH\n"));
3041
3042 if (PortState == OSSA_PORT_INVALID)
3043 {
3044 TI_DBG1(("ossaHwCB: Wrong port state with OSSA_HW_EVENT_PHY_ERR_LOSS_OF_DWORD_SYNCH\n"));
3045 smTraceFuncExit(hpDBG_VERY_LOUD, 'M', "Y2");
3046 return;
3047 }
3048
3049 if (agPhyErrCountersPage != agNULL)
3050 {
3051 TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_ERR_LOSS_OF_DWORD_SYNCH from PhyID %d\n", PhyID));
3052 TI_DBG1(("ossaHwCB: lostOfDwordSynch %d\n", agPhyErrCountersPage->lossOfDwordSynch));
3053 }
3054 else
3055 {
3056 TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_ERR_LOSS_OF_DWORD_SYNCH: Error!!! eventParm2 is NULL\n"));
3057 }
3058
3059 /* saHwEventAck() */
3060 eventSource.agPortContext = agPortContext;
3061 eventSource.event = OSSA_HW_EVENT_PHY_ERR_LOSS_OF_DWORD_SYNCH;
3062 /* phy ID */
3063 eventSource.param = PhyID;
3064 HwAckSatus = saHwEventAck(
3065 agRoot,
3066 agNULL, /* agContext */
3067 0,
3068 &eventSource, /* agsaEventSource_t */
3069 0,
3070 0
3071 );
3072 if ( HwAckSatus != AGSA_RC_SUCCESS)
3073 {
3074 TI_DBG1(("ossaHwCB: failing in saHwEventAck; status %d\n", HwAckSatus));
3075 smTraceFuncExit(hpDBG_VERY_LOUD, 'N', "Y2");
3076 return;
3077 }
3078
3079 break;
3080 }
3081
3082 case OSSA_HW_EVENT_PHY_ERR_PHY_RESET_FAILED:
3083 {
3084 PhyID = TD_GET_PHY_ID(eventParm1);
3085 PortState = TD_GET_PORT_STATE(eventParm1);
3086 agPhyErrCountersPage = (agsaPhyErrCountersPage_t *)eventParm2;
3087
3088 TI_DBG2(("ossaHwCB: OSSA_HW_EVENT_PHY_ERR_PHY_RESET_FAILED\n"));
3089
3090 if (PortState == OSSA_PORT_INVALID)
3091 {
3092 TI_DBG1(("ossaHwCB: Wrong port state with OSSA_HW_EVENT_PHY_ERR_PHY_RESET_FAILED\n"));
3093 smTraceFuncExit(hpDBG_VERY_LOUD, 'O', "Y2");
3094 return;
3095 }
3096
3097 if (agPhyErrCountersPage != agNULL)
3098 {
3099 TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_ERR_PHY_RESET_FAILED from PhyID %d\n", PhyID));
3100 TI_DBG1(("ossaHwCB: phyResetProblem %d\n", agPhyErrCountersPage->phyResetProblem));
3101 }
3102 else
3103 {
3104 TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_ERR_PHY_RESET_FAILED: Error!!! eventParm2 is NULL\n"));
3105 }
3106
3107 /* saHwEventAck() */
3108 eventSource.agPortContext = agPortContext;
3109 eventSource.event = OSSA_HW_EVENT_PHY_ERR_PHY_RESET_FAILED;
3110 /* phy ID */
3111 eventSource.param = PhyID;
3112 HwAckSatus = saHwEventAck(
3113 agRoot,
3114 agNULL, /* agContext */
3115 0,
3116 &eventSource, /* agsaEventSource_t */
3117 0,
3118 0
3119 );
3120 if ( HwAckSatus != AGSA_RC_SUCCESS)
3121 {
3122 TI_DBG1(("ossaHwCB: failing in saHwEventAck; status %d\n", HwAckSatus));
3123 smTraceFuncExit(hpDBG_VERY_LOUD, 'P', "Y2");
3124 return;
3125 }
3126
3127 break;
3128 }
3129
3130 // #ifdef INITIATOR_DRIVER
3131 case OSSA_HW_EVENT_ENCRYPTION:
3132 {
3133 pEncryptCBData = (agsaHWEventEncrypt_t *) eventParm2;
3134 TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_ENCRYPTION: encryptOperation 0x%x\n",pEncryptCBData->encryptOperation));
3135 TI_DBG1(("ossaHwCB: event 0x%x eventParm1 0x%x eventParm2 %p eventParm3 %p\n",event,eventParm1,eventParm2,eventParm3));
3136
3137 /*
3138 * All events and status need to be translated from
3139 * SAS specific values to TISA specific values. This
3140 * is effectively a NOP, but the OS layer won't want to
3141 * look for SAS values.
3142 */
3143 if (pEncryptCBData->encryptOperation == OSSA_HW_ENCRYPT_KEK_UPDATE_AND_STORE)
3144 {
3145 TI_DBG1(("ossaHwCB: OSSA_HW_ENCRYPT_KEK_UPDATE_AND_STORE\n"));
3146 encryptEventData.encryptEvent = tiEncryptKekStore;
3147 }
3148 else if (pEncryptCBData->encryptOperation == OSSA_HW_ENCRYPT_KEK_UPDATE)
3149 {
3150 TI_DBG1(("ossaHwCB:OSSA_HW_ENCRYPT_KEK_UPDATE \n"));
3151 encryptEventData.encryptEvent = tiEncryptKekAdd;
3152 }
3153 else if (pEncryptCBData->encryptOperation == OSSA_HW_ENCRYPT_KEK_INVALIDTE)
3154 {
3155 TI_DBG1(("ossaHwCB:OSSA_HW_ENCRYPT_KEK_INVALIDTE \n"));
3156 /* none */
3157 }
3158 else if (pEncryptCBData->encryptOperation == OSSA_HW_ENCRYPT_DEK_UPDATE)
3159 {
3160 TI_DBG1(("ossaHwCB: OSSA_HW_ENCRYPT_DEK_UPDATE\n"));
3161 encryptEventData.encryptEvent = tiEncryptDekAdd;
3162 }
3163 else if (pEncryptCBData->encryptOperation == OSSA_HW_ENCRYPT_DEK_INVALIDTE)
3164 {
3165 TI_DBG1(("ossaHwCB: OSSA_HW_ENCRYPT_DEK_INVALIDTE\n"));
3166 encryptEventData.encryptEvent = tiEncryptDekInvalidate;
3167 }
3168 else if (pEncryptCBData->encryptOperation == OSSA_HW_ENCRYPT_OPERATOR_MANAGEMENT)
3169 {
3170 TI_DBG1(("ossaHwCB: OSSA_HW_ENCRYPT_OPERATOR_MANAGEMENT\n"));
3171 encryptEventData.encryptEvent = tiEncryptOperatorManagement;
3172 }
3173 else if (pEncryptCBData->encryptOperation == OSSA_HW_ENCRYPT_TEST_EXECUTE)
3174 {
3175 TI_DBG1(("ossaHwCB: OSSA_HW_ENCRYPT_TEST_EXECUTE\n"));
3176 encryptEventData.encryptEvent = tiEncryptSelfTest;
3177 encryptEventData.subEvent = pEncryptCBData->eq;
3178 }
3179 else
3180 {
3181 TI_DBG1(("ossaHwCB: unknown encryptOperation 0x%x\n",pEncryptCBData->encryptOperation));
3182 }
3183
3184 if (pEncryptCBData->status != OSSA_SUCCESS)
3185 {
3186 encryptStatus = tiError;
3187
3188 /* prints out status and error qualifier */
3189 TI_DBG1(("ossaHwCB: encrypt response status 0x%x error qualifier 0x%x\n", pEncryptCBData->status, pEncryptCBData->eq));
3190 }
3191 else
3192 {
3193 encryptStatus = tiSuccess;
3194 }
3195
3196 if (pEncryptCBData->encryptOperation == OSSA_HW_ENCRYPT_KEK_UPDATE_AND_STORE ||
3197 pEncryptCBData->encryptOperation == OSSA_HW_ENCRYPT_KEK_UPDATE )
3198 {
3199 /* returning new KEK index */
3200 encryptEventData.pData = pEncryptCBData->handle;
3201 }
3202 else
3203 {
3204 /* returning current KEK index or DEK index */
3205 encryptEventData.pData = pEncryptCBData->param;
3206 }
3207
3208 ostiPortEvent(tiRoot,
3209 tiEncryptOperation,
3210 encryptStatus,
3211 &encryptEventData);
3212 break;
3213 }
3214 case OSSA_HW_EVENT_SECURITY_MODE:
3215 {
3216 securitySetModeStatus = eventParm1;
3217 pEncryptInfo = (agsaEncryptInfo_t *) eventParm2;
3218
3219 TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_SECURITY_MODE\n"));
3220 if (securitySetModeStatus == OSSA_SUCCESS)
3221 {
3222 securityModeStatus = tiSuccess;
3223 }
3224 else
3225 {
3226 securityModeStatus = tiError;
3227 }
3228
3229 encryptEventData.encryptEvent = tiEncryptSetMode;
3230 /* process status to fill in subevent */
3231 /* See PM 4.26.12.6 */
3232 TI_DBG1(("ossaHwCB: pEncryptInfo->status 0x%x\n", pEncryptInfo->status));
3233 if ( pEncryptInfo->status == OSSA_SUCCESS)
3234 {
3235 encryptEventData.subEvent = tiNVRAMSuccess;
3236 }
3237 else if (pEncryptInfo->status == 0x24)
3238 {
3239 encryptEventData.subEvent = tiNVRAMNotFound;
3240 }
3241 else if (pEncryptInfo->status == 0x05 || pEncryptInfo->status == 0x20 || pEncryptInfo->status == 0x21)
3242 {
3243 encryptEventData.subEvent = tiNVRAMAccessTimeout;
3244 }
3245 else
3246 {
3247 encryptEventData.subEvent = tiNVRAMWriteFail;
3248 }
3249
3250 encryptEventData.pData = agNULL;
3251 ostiPortEvent(tiRoot,
3252 tiEncryptOperation,
3253 securityModeStatus,
3254 &encryptEventData);
3255
3256 break;
3257 }
3258 case OSSA_HW_EVENT_MODE:
3259 {
3260 pModeEvent = (agsaHWEventMode_t *) eventParm2;
3261 pModePage = (bit32 *) pModeEvent->modePage;
3262
3263 TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_MODE modePageOperation 0x%x status 0x%x modePageLen 0x%x\n",
3264 pModeEvent->modePageOperation, pModeEvent->status, pModeEvent->modePageLen));
3265
3266 if (pModeEvent->modePageOperation == agsaModePageSet)
3267 {
3268 TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_MODE page code 0x%x error qualifier 0x%x\n", (eventParm1 & 0xFF), (eventParm1 >> 16)));
3269 ostiPortEvent(tiRoot,
3270 tiModePageOperation,
3271 pModeEvent->status,
3272 eventParm2);
3273 }
3274 else if (pModeEvent->modePageOperation == agsaModePageGet)
3275 {
3276 TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_MODE error qualifier 0x%x\n", eventParm1));
3277 switch ((*pModePage) & 0xFF)
3278 {
3279 case AGSA_ENCRYPTION_GENERAL_CONFIG_PAGE:
3280 TI_DBG1(("ossaHwCB: AGSA_ENCRYPTION_GENERAL_CONFIG_PAGE 0x%x %p\n", pModeEvent->status,eventParm2));
3281 TI_DBG1(("ossaHwCB:modePageOperation 0x%x status 0x%x modePageLen 0x%x modePage %p context %p\n",
3282 pModeEvent->modePageOperation,
3283 pModeEvent->status,
3284 pModeEvent->modePageLen,
3285 pModeEvent->modePage,
3286 pModeEvent->context));
3287 ostiPortEvent(tiRoot,
3288 tiModePageOperation,
3289 pModeEvent->status,
3290 eventParm2);
3291 break;
3292 case AGSA_ENCRYPTION_DEK_CONFIG_PAGE:
3293 TI_DBG1(("ossaHwCB: AGSA_ENCRYPTION_DEK_CONFIG_PAGE 0x%x %p\n", pModeEvent->status,eventParm2));
3294 ostiPortEvent(tiRoot,
3295 tiModePageOperation,
3296 pModeEvent->status,
3297 eventParm2);
3298 break;
3299 case AGSA_ENCRYPTION_HMAC_CONFIG_PAGE:
3300 TI_DBG1(("ossaHwCB: AGSA_ENCRYPTION_HMAC_CONFIG_PAGE 0x%x %p\n", pModeEvent->status,eventParm2));
3301 ostiPortEvent(tiRoot,
3302 tiModePageOperation,
3303 pModeEvent->status,
3304 eventParm2);
3305 break;
3306 case AGSA_ENCRYPTION_CONTROL_PARM_PAGE:
3307 TI_DBG1(("ossaHwCB: AGSA_ENCRYPTION_CONTROL_PARM_PAGE 0x%x %p\n", pModeEvent->status,eventParm2));
3308 /*
3309 * This page is directly related to tiCOMEncryptGetInfo() and
3310 * will be translated into a tiEncrytOperation for the OS layer.
3311 */
3312
3313 /* Fill out tiEncryptInfo_t */
3314 securityMode = *pModePage & 0x0F00 >> 8;
3315 cipherMode = *pModePage & 0xF000 >> 12;
3316
3317 if (securityMode == agsaEncryptSMA)
3318 {
3319 encryptInfo.securityCipherMode = TI_ENCRYPT_SEC_MODE_A;
3320 }
3321 else if (securityMode == agsaEncryptSMB)
3322 {
3323 encryptInfo.securityCipherMode = TI_ENCRYPT_SEC_MODE_B;
3324 }
3325 else
3326 {
3327 encryptInfo.securityCipherMode = TI_ENCRYPT_SEC_MODE_FACT_INIT;
3328 }
3329
3330 if (cipherMode == agsaEncryptCipherModeECB)
3331 {
3332 encryptInfo.securityCipherMode |= TI_ENCRYPT_ATTRIB_CIPHER_ECB;
3333 }
3334
3335 if (cipherMode == agsaEncryptCipherModeXTS)
3336 {
3337 encryptInfo.securityCipherMode |= TI_ENCRYPT_ATTRIB_CIPHER_XTS;
3338 }
3339
3340 /* How will subEvents be tracked? */
3341 encryptInfo.status = 0;
3342
3343 encryptInfo.sectorSize[0] = 512; /* DIF is allowed on 512 BPS SATA drives */
3344 encryptInfo.sectorSize[1] = 520;
3345 encryptInfo.sectorSize[2] = 528;
3346 encryptInfo.sectorSize[3] = 4104;
3347 encryptInfo.sectorSize[4] = 4168;
3348 encryptInfo.sectorSize[5] = 4232;
3349
3350 encryptEventData.encryptEvent = tiEncryptGetInfo;
3351 encryptEventData.subEvent = 0;
3352 encryptEventData.pData = &encryptInfo;
3353
3354 ostiPortEvent(tiRoot,
3355 tiEncryptOperation,
3356 pModeEvent->status,
3357 &encryptEventData);
3358 break;
3359 case AGSA_SAS_PROTOCOL_TIMER_CONFIG_PAGE:
3360 TI_DBG1(("ossaHwCB: AGSA_SAS_PROTOCOL_TIMER_CONFIG_PAGE 0x%x %p\n", pModeEvent->status,eventParm2));
3361
3362 #ifdef IOCTL_INTERRUPT_TIME_CONFIG
3363 ostiPortEvent(tiRoot,
3364 tiModePageOperation,
3365 pModeEvent->status,
3366 eventParm2
3367 );
3368 #endif /* IOCTL_INTERRUPT_TIME_CONFIG */
3369
3370 /*ostiPortEvent(tiRoot,
3371 tiModePageOperation,
3372 pModeEvent->status,
3373 &encryptEventData);*/
3374 break;
3375 case AGSA_INTERRUPT_CONFIGURATION_PAGE:
3376 TI_DBG1(("ossaHwCB: AGSA_INTERRUPT_CONFIGURATION_PAGE 0x%x %p\n", pModeEvent->status,eventParm2));
3377
3378 #ifdef IOCTL_INTERRUPT_TIME_CONFIG
3379 ostiPortEvent(tiRoot,
3380 tiModePageOperation,
3381 pModeEvent->status,
3382 eventParm2
3383 );
3384 #endif /* IOCTL_INTERRUPT_TIME_CONFIG */
3385
3386 break;
3387 default:
3388 TI_DBG1(("ossaHwCB: Unknown Mode Event %x\n", *pModePage));
3389 break;
3390 }
3391
3392 }
3393 else
3394 {
3395 TI_DBG1(("ossaHwCB: Unknown modePageOperation %x\n", pModeEvent->modePageOperation));
3396 }
3397 break;
3398 }
3399
3400 // #endif /* INITIATOR_DRIVER */
3401
3402 #ifdef REMOVED
3403 case OSSA_HW_EVENT_PHY_UNRECOVERABLE_ERROR:
3404 {
3405 PhyID = TD_GET_PHY_ID(eventParm1);
3406 PortState = TD_GET_PORT_STATE(eventParm1);
3407
3408 TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_UNRECOVERABLE_ERROR\n"));
3409
3410 if (PortState == OSSA_PORT_INVALID)
3411 {
3412 TI_DBG1(("ossaHwCB: INVALID port state\n"));
3413 }
3414 else
3415 {
3416 TI_DBG1(("ossaHwCB: VALID port state\n"));
3417 }
3418 break;
3419 }
3420 #endif /* REMOVED */
3421 case OSSA_HW_EVENT_OPEN_RETRY_BACKOFF_THR_ADJUSTED:
3422 {
3423 TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_OPEN_RETRY_BACKOFF_THR_ADJUSTED\n"));
3424 break;
3425 }
3426
3427 default:
3428 {
3429 TI_DBG1(("ossaHwCB: default error (0x%X)!!!!!\n",event));
3430 break;
3431 }
3432 }
3433
3434 smTraceFuncExit(hpDBG_VERY_LOUD, 'R', "Y2");
3435 return;
3436 }
3437
ossaPortControlCB(agsaRoot_t * agRoot,agsaContext_t * agContext,agsaPortContext_t * agPortContext,bit32 portOperation,bit32 status)3438 osGLOBAL void ossaPortControlCB(
3439 agsaRoot_t *agRoot,
3440 agsaContext_t *agContext,
3441 agsaPortContext_t *agPortContext,
3442 bit32 portOperation,
3443 bit32 status)
3444 {
3445 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
3446 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
3447 tdsaPortContext_t *onePortContext = agNULL;
3448
3449 TI_DBG6(("ossaPortControlCB: start\n"));
3450
3451 smTraceFuncEnter(hpDBG_VERY_LOUD,"Y3");
3452 if (portOperation == AGSA_PORT_SET_SMP_PHY_WIDTH)
3453 {
3454 TI_DBG1(("ossaPortControlCB: portOperation AGSA_PORT_SET_SMP_PHY_WIDTH\n"));
3455 }
3456 else if (portOperation == AGSA_PORT_SET_PORT_RECOVERY_TIME)
3457 {
3458 TI_DBG1(("ossaPortControlCB: portOperation AGSA_PORT_SET_PORT_RECOVERY_TIME\n"));
3459 }
3460 else if (portOperation == AGSA_PORT_IO_ABORT)
3461 {
3462 TI_DBG1(("ossaPortControlCB: portOperation AGSA_PORT_IO_ABORT\n"));
3463 /* code is here because disocvery failed
3464 deregister all targets. Then, later call discovery if broacast is seen in ossaDeregisterDeviceHandleCB.
3465 */
3466 onePortContext = (tdsaPortContext_t *)agPortContext->osData;
3467 if (onePortContext == agNULL)
3468 {
3469 TI_DBG1(("ossaPortControlCB: onePortContext is NULL\n"));
3470 return;
3471 }
3472 /* qqqqq deregister all devices */
3473 tdsaDeregisterDevicesInPort(tiRoot, onePortContext);
3474
3475 }
3476 else if (portOperation == AGSA_PORT_SET_PORT_RESET_TIME)
3477 {
3478 TI_DBG1(("ossaPortControlCB: portOperation AGSA_PORT_SET_PORT_RESET_TIME\n"));
3479 }
3480 else if (portOperation == AGSA_PORT_HARD_RESET)
3481 {
3482 TI_DBG1(("ossaPortControlCB: portOperation AGSA_PORT_HARD_RESET\n"));
3483 }
3484 else if (portOperation == AGSA_PORT_CLEAN_UP)
3485 {
3486 TI_DBG1(("ossaPortControlCB: portOperation AGSA_PORT_CLEAN_UP\n"));
3487 }
3488 else if (portOperation == AGSA_STOP_PORT_RECOVERY_TIMER)
3489 {
3490 TI_DBG1(("ossaPortControlCB: portOperation AGSA_STOP_PORT_RECOVERY_TIMER\n"));
3491 }
3492 else
3493 {
3494 TI_DBG1(("ossaPortControlCB: undefined portOperation %d\n", portOperation));
3495 }
3496
3497 TI_DBG1(("ossaPortControlCB: status %d\n", status));
3498
3499 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Y3");
3500 return;
3501 }
3502
3503 /*****************************************************************************
3504 *! \brief ossaHwRegRead
3505 *
3506 * Purpose: This routine is called to read a 32-bit value from the PCI
3507 * registers of the controller
3508 *
3509 * \param agRoot: Pointer to chip/driver Instance.
3510 * \param regOffset: Byte offset to chip register from which to read a 32-bit
3511 * value.
3512 *
3513 * \return: 32-bit value.
3514 *
3515 * \note - The scope is shared target and initiator.
3516 *
3517 *****************************************************************************/
3518 FORCEINLINE
3519 bit32
ossaHwRegRead(agsaRoot_t * agRoot,bit32 regOffset)3520 ossaHwRegRead(agsaRoot_t *agRoot,
3521 bit32 regOffset
3522 )
3523 {
3524 tdsaRootOsData_t *osData = (tdsaRootOsData_t *) (agRoot->osData);
3525 bit32 return_value;
3526
3527
3528 return_value = ostiChipReadBit32 (
3529 osData->tiRoot,
3530 regOffset
3531 );
3532 if( agNULL != agRoot->sdkData )
3533 {
3534 smTrace(hpDBG_REGISTERS,"RR",regOffset);
3535 /* TP:RR regOffset */
3536 smTrace(hpDBG_REGISTERS,"RV",return_value);
3537 /* TP:RV value read */
3538 }
3539
3540 return(return_value);
3541
3542 }
3543
3544 /*****************************************************************************
3545 *! \brief ossaHwRegWrite
3546 *
3547 * Purpose: This routine is called to write a 32-bit value to the PCI
3548 * registers of the controller.
3549 *
3550 * \param agRoot: Pointer to chip/driver Instance.
3551 * \param regOffset: Byte offset to chip register to which chipIOValue is
3552 * written.
3553 * \param regValue: 32-bit value to write at chipIOOffset in host byte order.
3554 *
3555 * \return: None.
3556 *
3557 * \note - The scope is shared target and initiator.
3558 *
3559 *****************************************************************************/
3560 FORCEINLINE
3561 void
ossaHwRegWrite(agsaRoot_t * agRoot,bit32 regOffset,bit32 regValue)3562 ossaHwRegWrite(agsaRoot_t *agRoot,
3563 bit32 regOffset,
3564 bit32 regValue
3565 )
3566 {
3567
3568 tdsaRootOsData_t *osData = (tdsaRootOsData_t *) (agRoot->osData);
3569 if( agNULL != agRoot->sdkData )
3570 {
3571 smTrace(hpDBG_REGISTERS,"RW",regOffset);
3572 /* TP:RW regOffset */
3573 smTrace(hpDBG_REGISTERS,"VW",regValue);
3574 /* TP:VW value written */
3575 }
3576
3577 ostiChipWriteBit32 (
3578 osData->tiRoot,
3579 regOffset,
3580 regValue
3581 );
3582 return;
3583 }
3584
3585 /*****************************************************************************
3586 *! \brief ossaHwRegReadExt
3587 *
3588 * Purpose: This routine is called to read a 32-bit value from a bus-specific
3589 * mapped registers of the controller
3590 *
3591 * \param agRoot: Pointer to chip/driver Instance.
3592 * \param regOffset: Byte offset to chip register from which to read a 32-bit
3593 * value.
3594 *
3595 * \return: 32-bit value.
3596 *
3597 * \note - The scope is shared target and initiator.
3598 *
3599 *****************************************************************************/
3600 FORCEINLINE
3601 bit32
ossaHwRegReadExt(agsaRoot_t * agRoot,bit32 busBaseNumber,bit32 regOffset)3602 ossaHwRegReadExt(
3603 agsaRoot_t *agRoot,
3604 bit32 busBaseNumber,
3605 bit32 regOffset
3606 )
3607 {
3608 tdsaRootOsData_t *osData = (tdsaRootOsData_t *) (agRoot->osData);
3609
3610 bit32 return_value;
3611
3612 return_value = ostiChipReadBit32Ext(
3613 osData->tiRoot,
3614 busBaseNumber,
3615 regOffset
3616 );
3617
3618 /* TI_DBG4(("#_R: 0x%x:0x%x=0x%x\n",busBaseNumber,regOffset,return_value)); */
3619
3620 if( agNULL != agRoot->sdkData )
3621 {
3622 smTrace(hpDBG_REGISTERS,"EB",busBaseNumber);
3623 /* TP:EB EX read busBaseNumber */
3624 smTrace(hpDBG_REGISTERS,"EO",regOffset);
3625 /* TP:EO regOffset */
3626 smTrace(hpDBG_REGISTERS,"ER",return_value);
3627 /* TP:ER value read */
3628 }
3629 return(return_value);
3630 }
3631
ossaPCI_TRIGGER(agsaRoot_t * agRoot)3632 void ossaPCI_TRIGGER(agsaRoot_t *agRoot )
3633 {
3634 tdsaRootOsData_t *osData = (tdsaRootOsData_t *) (agRoot->osData);
3635 ostiPCI_TRIGGER(osData->tiRoot);
3636
3637 }
3638
3639
3640
3641 /*****************************************************************************
3642 *! \brief ossaHwRegWriteExt
3643 *
3644 * Purpose: This routine is called to write a 32-bit value to a bus specific
3645 * mapped registers of the controller.
3646 *
3647 * \param agRoot: Pointer to chip/driver Instance.
3648 * \param regOffset: Byte offset to chip register to which chipIOValue is
3649 * written.
3650 * \param regValue: 32-bit value to write at chipIOOffset in host byte order.
3651 *
3652 * \return: None.
3653 *
3654 * \note - The scope is shared target and initiator.
3655 *
3656 *****************************************************************************/
3657 FORCEINLINE
3658 void
ossaHwRegWriteExt(agsaRoot_t * agRoot,bit32 busBaseNumber,bit32 regOffset,bit32 regValue)3659 ossaHwRegWriteExt(
3660 agsaRoot_t *agRoot,
3661 bit32 busBaseNumber,
3662 bit32 regOffset,
3663 bit32 regValue
3664 )
3665 {
3666 tdsaRootOsData_t *osData = (tdsaRootOsData_t *) (agRoot->osData);
3667 ostiChipWriteBit32Ext(
3668 osData->tiRoot,
3669 busBaseNumber,
3670 regOffset,
3671 regValue
3672 );
3673
3674 /* TI_DBG4(("#_W: 0x%x:0x%x=0x%x\n",busBaseNumber,regOffset,regValue)); */
3675
3676 if( agNULL != agRoot->sdkData )
3677 {
3678 smTrace(hpDBG_REGISTERS,"Eb",busBaseNumber);
3679 /* TP:Eb Ex Write busBaseNumber */
3680 smTrace(hpDBG_REGISTERS,"Eo",regOffset);
3681 /* TP:Eo regOffset */
3682 smTrace(hpDBG_REGISTERS,"Ew",regValue);
3683 /* TP:Ew value written regValue*/
3684 }
3685 return;
3686 }
3687
3688
ossaHwRegReadConfig32(agsaRoot_t * agRoot,bit32 regOffset)3689 osGLOBAL bit32 ossaHwRegReadConfig32(
3690 agsaRoot_t *agRoot,
3691 bit32 regOffset
3692 )
3693 {
3694 tdsaRootOsData_t *osData = (tdsaRootOsData_t *) (agRoot->osData);
3695 bit32 to_ret;
3696 to_ret= ostiChipConfigReadBit32( osData->tiRoot, regOffset);
3697 TI_DBG4(("ossaHwRegReadConfig32: regOffset 0x%x returns 0x%x\n",regOffset,to_ret));
3698 return(to_ret);
3699 }
3700
3701
3702
3703
3704 #ifdef TD_INT_COALESCE
3705 void
ossaIntCoalesceInitCB(agsaRoot_t * agRoot,agsaIntCoalesceContext_t * agIntCoContext,bit32 status)3706 ossaIntCoalesceInitCB(
3707 agsaRoot_t *agRoot,
3708 agsaIntCoalesceContext_t *agIntCoContext,
3709 bit32 status
3710 )
3711 {
3712 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
3713 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
3714 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)osData->tdsaAllShared;
3715 tiIntCoalesceContext_t *tiIntCoalesceCxt;
3716 tdsaIntCoalesceContext_t *tdsaIntCoalCxt;
3717 tdsaIntCoalesceContext_t *tdsaIntCoalCxtHead
3718 = (tdsaIntCoalesceContext_t *)tdsaAllShared->IntCoalesce;
3719 bit32 tiStatus;
3720
3721 TI_DBG2(("ossaIntCoalesceInitCB: start\n"));
3722
3723 tdsaIntCoalCxt = (tdsaIntCoalesceContext_t *)agIntCoContext->osData;
3724 tiIntCoalesceCxt = tdsaIntCoalCxt->tiIntCoalesceCxt;
3725 switch (status)
3726 {
3727 case AGSA_RC_SUCCESS:
3728 tiStatus = tiSuccess;
3729 break;
3730 case AGSA_RC_BUSY:
3731 tiStatus = tiBusy;
3732 break;
3733 case AGSA_RC_FAILURE:
3734 tiStatus = tiError;
3735 break;
3736 default:
3737 TI_DBG1(("ossaIntCoalesceInitCB: unknown status %d\n", status));
3738 tiStatus = tiError;
3739 break;
3740 }
3741
3742 TI_DBG2(("ossaIntCoalesceInitCB: status %d\n", tiStatus));
3743
3744 /* enqueue tdsaIntCoalCxt to freelink */
3745 tdsaIntCoalCxt->tiIntCoalesceCxt = agNULL;
3746 TI_DBG2(("ossaIntCoalesceInitCB: id %d\n", tdsaIntCoalCxt->id));
3747
3748 tdsaSingleThreadedEnter(tiRoot, TD_INTCOAL_LOCK);
3749 TDLIST_DEQUEUE_THIS(&(tdsaIntCoalCxt->MainLink));
3750 TDLIST_ENQUEUE_AT_TAIL(&(tdsaIntCoalCxt->FreeLink), &(tdsaIntCoalCxtHead->FreeLink));
3751 tdsaSingleThreadedLeave(tiRoot, TD_INTCOAL_LOCK);
3752
3753 #ifdef OS_INT_COALESCE
3754 ostiInitiatorIntCoalesceInitCB(tiRoot,
3755 tiIntCoalesceCxt,
3756 tiStatus);
3757 #endif
3758
3759 TI_DBG2(("ossaIntCoalesceInitCB: return end\n"));
3760
3761 return;
3762 }
3763 #endif /* TD_INT_COALESCE */
3764
3765 /*****************************************************************************/
3766 /*! \brief ossaSingleThreadedEnter
3767 *
3768 *
3769 * Purpose: This routine is called to ensure that only a single thread of
3770 * the given port instance executes code in the region protected by
3771 * this function.
3772 *
3773 *
3774 * \param agRoot: Pointer to chip/driver Instance.
3775 * \param syncLockId to be explained.
3776 *
3777 *
3778 * \return None.
3779 *
3780 * \note - The scope is shared target and initiator.
3781 *
3782 */
3783 /*****************************************************************************/
3784 FORCEINLINE
ossaSingleThreadedEnter(agsaRoot_t * agRoot,bit32 syncLockId)3785 void ossaSingleThreadedEnter(
3786 agsaRoot_t *agRoot,
3787 bit32 syncLockId
3788 )
3789 {
3790 tdsaRootOsData_t *pOsData = agNULL;
3791 tiRoot_t *ptiRoot = agNULL;
3792 tdsaContext_t *tdsaAllShared = agNULL;
3793
3794 TD_ASSERT(agRoot, "agRoot");
3795 pOsData = (tdsaRootOsData_t *) (agRoot->osData);
3796 TD_ASSERT(pOsData, "pOsData");
3797 ptiRoot = pOsData->tiRoot;
3798 TD_ASSERT(ptiRoot, "ptiRoot");
3799
3800 tdsaAllShared = (tdsaContext_t *)pOsData->tdsaAllShared;
3801 TD_ASSERT(tdsaAllShared, "tdsaAllShared");
3802
3803 ostiSingleThreadedEnter(ptiRoot, syncLockId + tdsaAllShared->MaxNumOSLocks);
3804 return;
3805 }
3806
3807 /*****************************************************************************/
3808 /*! \brief ossaSingleThreadedLeave
3809 *
3810 *
3811 * Purpose: This routine is called to leave a critical region of code
3812 * previously protected by a call to osSingleThreadedEnter()
3813 *
3814 *
3815 * \param agRoot: Pointer to chip/driver Instance.
3816 * \param syncLockId to be explained.
3817 *
3818 *
3819 * \return None.
3820 *
3821 * \note - The scope is shared target and initiator.
3822 *
3823 */
3824 /*****************************************************************************/
3825 FORCEINLINE
ossaSingleThreadedLeave(agsaRoot_t * agRoot,bit32 syncLockId)3826 void ossaSingleThreadedLeave(
3827 agsaRoot_t *agRoot,
3828 bit32 syncLockId
3829 )
3830 {
3831 tdsaRootOsData_t *pOsData = agNULL;
3832 tiRoot_t *ptiRoot = agNULL;
3833 tdsaContext_t *tdsaAllShared = agNULL;
3834
3835 TD_ASSERT(agRoot, "agRoot");
3836 pOsData = (tdsaRootOsData_t *) (agRoot->osData);
3837 TD_ASSERT(pOsData, "pOsData");
3838 ptiRoot = pOsData->tiRoot;
3839 TD_ASSERT(ptiRoot, "ptiRoot");
3840
3841 tdsaAllShared = (tdsaContext_t *)pOsData->tdsaAllShared;
3842 TD_ASSERT(tdsaAllShared, "tdsaAllShared");
3843
3844 ostiSingleThreadedLeave(ptiRoot, syncLockId + tdsaAllShared->MaxNumOSLocks);
3845 return;
3846 }
3847
3848 #ifdef PERF_COUNT
ossaEnter(agsaRoot_t * agRoot,int io)3849 osGLOBAL void ossaEnter(agsaRoot_t *agRoot, int io)
3850 {
3851 ostiEnter(((tdsaRootOsData_t*)(agRoot->osData))->tiRoot, 0, io);
3852 return;
3853 }
3854
ossaLeave(agsaRoot_t * agRoot,int io)3855 osGLOBAL void ossaLeave(agsaRoot_t *agRoot, int io)
3856 {
3857 ostiLeave(((tdsaRootOsData_t*)(agRoot->osData))->tiRoot, 0, io);
3858 return;
3859 }
3860 #endif
3861
3862
3863 osGLOBAL void
ossaSSPIoctlCompleted(agsaRoot_t * agRoot,agsaIORequest_t * agIORequest,bit32 agIOStatus,bit32 agIOInfoLen,void * agParam,bit16 sspTag,bit32 agOtherInfo)3864 ossaSSPIoctlCompleted(
3865 agsaRoot_t *agRoot,
3866 agsaIORequest_t *agIORequest,
3867 bit32 agIOStatus,
3868 bit32 agIOInfoLen,
3869 void *agParam,
3870 bit16 sspTag,
3871 bit32 agOtherInfo
3872 )
3873 {
3874 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
3875 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
3876 tdIORequestBody_t *tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
3877 agsaSASRequestBody_t *agSASRequestBody = agNULL;
3878 agsaSSPInitiatorRequest_t *agSSPFrame = agNULL;
3879 bit8 scsiOpcode = 0;
3880
3881 agSASRequestBody = &(tdIORequestBody->transport.SAS.agSASRequestBody);
3882 agSSPFrame = &(agSASRequestBody->sspInitiatorReq);
3883 scsiOpcode = agSSPFrame->sspCmdIU.cdb[0];
3884
3885 TI_DBG2(("ossaSSPIoctlCompleted: start\n"));
3886
3887 if (agIOStatus == OSSA_SUCCESS)
3888 {
3889 TI_DBG2(("ossaSSPIoctlCompleted: Success status\n"));
3890 }
3891 else
3892 {
3893 TI_DBG1(("ossaSSPIoctlCompleted: Status 0x%x\n", agIOStatus));
3894 }
3895 switch(scsiOpcode)
3896 {
3897 case REPORT_LUN_OPCODE:
3898 ostiNumOfLUNIOCTLRsp(tiRoot, agIOStatus);
3899 break;
3900
3901 default:
3902 TI_DBG1(("ossaSSPIoctlCompleted: Unsupported SCSI command Response 0x%x\n",scsiOpcode));
3903 break;
3904 }
3905 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Yi");
3906 return;
3907
3908 }
3909
3910 osGLOBAL void
ossaSMPIoctlCompleted(agsaRoot_t * agRoot,agsaIORequest_t * agIORequest,bit32 agIOStatus,bit32 agIOInfoLen,agsaFrameHandle_t agFrameHandle)3911 ossaSMPIoctlCompleted(
3912 agsaRoot_t *agRoot,
3913 agsaIORequest_t *agIORequest,
3914 bit32 agIOStatus,
3915 bit32 agIOInfoLen,
3916 agsaFrameHandle_t agFrameHandle
3917 )
3918 {
3919 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
3920 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
3921 TI_DBG2(("ossaSMPIoctlCompleted: start\n"));
3922
3923 if (agIOStatus == OSSA_SUCCESS)
3924 {
3925 TI_DBG2(("ossaSMPIoctlCompleted: Success status\n"));
3926 }
3927 else
3928 {
3929 TI_DBG1(("ossaSMPIoctlCompleted: Status 0x%x\n", agIOStatus));
3930 }
3931
3932 ostiSendSMPIOCTLRsp(tiRoot, agIOStatus);
3933 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Yi");
3934 return;
3935
3936 }
3937
3938
3939 /*****************************************************************************/
3940 /*! \brief ossaSMPCompleted
3941 *
3942 *
3943 * Purpose: This routine is called by lower layer to indicate the completion of
3944 * SMP request
3945 *
3946 * \param agRoot: Pointer to chip/driver Instance.
3947 * \param agIORequest Pointer to SMP request handle
3948 * \param agIOStatus Status
3949 * \param agFrameHeader:Pointer to SMP frame header.
3950 * \param agIOInfoLen IO information length assoicated with the IO
3951 * \param agFrameHandle A Handle used to refer to the response frame
3952 *
3953 *
3954 * \return None.
3955 *
3956 * \note - The scope is shared target and initiator.
3957 * For details, refer to SAS/SATA Low-Level API Specification
3958 */
3959 /*****************************************************************************/
ossaSMPCompleted(agsaRoot_t * agRoot,agsaIORequest_t * agIORequest,bit32 agIOStatus,bit32 agIOInfoLen,agsaFrameHandle_t agFrameHandle)3960 osGLOBAL void ossaSMPCompleted(
3961 agsaRoot_t *agRoot,
3962 agsaIORequest_t *agIORequest,
3963 bit32 agIOStatus,
3964 bit32 agIOInfoLen,
3965 agsaFrameHandle_t agFrameHandle
3966 )
3967 {
3968 #ifdef PASSTHROUGH
3969 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
3970 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
3971 tdPassthroughCmndBody_t *tdPTCmndBody = (tdPassthroughCmndBody_t *)agIORequest->osData;
3972 bit32 tiStatus = tiPassthroughError;
3973 bit8 SMPframe[agIOInfoLen + sizeof(agsaSMPFrameHeader_t)];
3974 bit8 SMPpayload[agIOInfoLen];
3975
3976 TI_DBG2(("ossaSMPCompleted: start and passthrough\n"));
3977 #else /* not PASSTHROUGH */
3978
3979 tdssSMPRequestBody_t *pSMPRequestBody = (tdssSMPRequestBody_t *) agIORequest->osData;
3980 TI_DBG4(("ossaSMPCompleted: start\n"));
3981 #endif /* end not PASSTHROUGH */
3982
3983 TDSA_OUT_ENTER((tiRoot_t *)((tdsaRootOsData_t *)agRoot->osData)->tiRoot);
3984 smTraceFuncEnter(hpDBG_VERY_LOUD,"Y4");
3985
3986 #ifdef PASSTHROUGH
3987 if (tdPTCmndBody == agNULL)
3988 {
3989 TI_DBG1(("ossaSMPCompleted: tdPTCmndBody is NULL \n"));
3990 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Y4");
3991 goto ext;
3992 }
3993
3994 if (tdPTCmndBody->EventCB == agNULL)
3995 {
3996 TI_DBG1(("ossaSMPCompleted: tdPTCmndBody->EventCB is NULL \n"));
3997 smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "Y4");
3998 goto ext;
3999 }
4000
4001 if (agIOStatus == OSSA_IO_SUCCESS)
4002 {
4003 tiStatus = tiPassthroughSuccess;
4004 }
4005 else if (agIOStatus == OSSA_IO_ABORTED)
4006 {
4007 tiStatus = tiPassthroughAborted;
4008 }
4009 else
4010 {
4011 tiStatus = tiPassthroughError;
4012 }
4013
4014 osti_memset(SMPpayload, 0, agIOInfoLen);
4015 osti_memset(SMPframe, 0, agIOInfoLen + sizeof(agsaSMPFrameHeader_t));
4016
4017 /* combine the header and payload */
4018 saFrameReadBlock(agRoot, agFrameHandle, 0, &SMPpayload, agIOInfoLen);
4019 osti_memcpy(SMPframe, agFrameHeader, sizeof(agsaSMPFrameHeader_t));
4020 osti_memcpy(SMPframe+sizeof(agsaSMPFrameHeader_t), SMPpayload, agIOInfoLen);
4021
4022 tdPTCmndBody->EventCB(tiRoot,
4023 tdPTCmndBody->tiPassthroughRequest,
4024 tiStatus,
4025 SMPframe,
4026 agIOInfoLen + sizeof(agsaSMPFrameHeader_t)
4027 );
4028
4029
4030 #else /* not PASSTHROUGH */
4031
4032 /*
4033 At initiator, passing SMP to TD layer, itdssSMPCompleted(), which does nothing.
4034 At target, passing SMP to TD layer, ttdsaSMPCompleted()
4035 */
4036 /*
4037 how to use agFrameHandle, when saFrameReadBlock() is used
4038 */
4039
4040 /* SPC can't be SMP target */
4041
4042 TI_DBG4(("ossaSMPCompleted: start\n"));
4043
4044 if (pSMPRequestBody == agNULL)
4045 {
4046 TI_DBG1(("ossaSMPCompleted: pSMPRequestBody is NULL \n"));
4047 smTraceFuncExit(hpDBG_VERY_LOUD, 'c', "Y4");
4048 goto ext;
4049 }
4050
4051 if (pSMPRequestBody->SMPCompletionFunc == agNULL)
4052 {
4053 TI_DBG1(("ossaSMPCompleted: pSMPRequestBody->SMPCompletionFunc is NULL \n"));
4054 smTraceFuncExit(hpDBG_VERY_LOUD, 'd', "Y4");
4055 goto ext;
4056 }
4057 #ifdef TD_INTERNAL_DEBUG /* debugging */
4058 TI_DBG4(("ossaSMPCompleted: agIOrequest %p\n", agIORequest->osData));
4059 TI_DBG4(("ossaSMPCompleted: sizeof(tdIORequestBody_t) %d 0x%x\n", sizeof(tdIORequestBody_t),
4060 sizeof(tdIORequestBody_t)));
4061 TI_DBG4(("ossaSMPCompleted: SMPRequestbody %p\n", pSMPRequestBody));
4062 TI_DBG4(("ossaSMPCompleted: calling callback fn\n"));
4063 TI_DBG4(("ossaSMPCompleted: callback fn %p\n",pSMPRequestBody->SMPCompletionFunc));
4064 #endif /* TD_INTERNAL_DEBUG */
4065 /*
4066 if initiator, calling itdssSMPCompleted() in itdcb.c
4067 if target, calling ttdsaSMPCompleted() in ttdsmp.c
4068 */
4069 pSMPRequestBody->SMPCompletionFunc(
4070 agRoot,
4071 agIORequest,
4072 agIOStatus,
4073 agIOInfoLen,
4074 agFrameHandle
4075 );
4076
4077 #endif /* Not PASSTHROUGH */
4078
4079 smTraceFuncExit(hpDBG_VERY_LOUD, 'e', "Y4");
4080 ext:
4081 TDSA_OUT_LEAVE((tiRoot_t *)((tdsaRootOsData_t *)agRoot->osData)->tiRoot);
4082 return;
4083 }
4084
4085 osGLOBAL void
ossaSMPReqReceived(agsaRoot_t * agRoot,agsaDevHandle_t * agDevHandle,agsaFrameHandle_t agFrameHandle,bit32 agIOInfoLen,bit32 phyId)4086 ossaSMPReqReceived(
4087 agsaRoot_t *agRoot,
4088 agsaDevHandle_t *agDevHandle,
4089 agsaFrameHandle_t agFrameHandle,
4090 bit32 agIOInfoLen,
4091 bit32 phyId
4092 )
4093 {
4094 smTraceFuncEnter(hpDBG_VERY_LOUD,"Y5");
4095 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Y5");
4096 return;
4097 }
4098
4099 /*****************************************************************************/
4100 /*! \brief ossaSMPCAMCompleted
4101 *
4102 *
4103 * Purpose: This routine is called by lower layer to indicate the completion of
4104 * SMP request
4105 *
4106 * \param agRoot: Pointer to chip/driver Instance.
4107 * \param agIORequest Pointer to SMP request handle
4108 * \param agIOStatus Status
4109 * \param agIOInfoLen IO information length assoicated with the IO
4110 * \param agFrameHandle A Handle used to refer to the response frame
4111 *
4112 *
4113 * \return None.
4114 *
4115 * \note - The scope is shared target and initiator.
4116 * For details, refer to SAS/SATA Low-Level API Specification
4117 */
4118 /*****************************************************************************/
ossaSMPCAMCompleted(agsaRoot_t * agRoot,agsaIORequest_t * agIORequest,bit32 agIOStatus,bit32 agIOInfoLen,agsaFrameHandle_t agFrameHandle)4119 osGLOBAL void ossaSMPCAMCompleted(
4120 agsaRoot_t *agRoot,
4121 agsaIORequest_t *agIORequest,
4122 bit32 agIOStatus,
4123 bit32 agIOInfoLen,
4124 agsaFrameHandle_t agFrameHandle
4125 )
4126 {
4127 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
4128 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
4129 tdIORequestBody_t *tdSMPRequestBody = agNULL;
4130 bit32 context = osData->IntContext;
4131 tiSMPStatus_t status;
4132 bit32 PhysUpper32;
4133 bit32 PhysLower32;
4134 bit32 memAllocStatus;
4135 void *osMemHandle;
4136 bit32 *SMPpayload;
4137 TI_DBG2(("ossaSMPCAMCompleted: start\n"));
4138 TI_DBG2(("ossaSMPCAMCompleted: agIOInfoLen %d\n", agIOInfoLen));
4139 if (!agIORequest->osData)
4140 {
4141 TD_ASSERT((0), "ossaSMPCAMCompleted agIORequest->osData");
4142 goto ext;
4143 }
4144 tdSMPRequestBody = (tdIORequestBody_t *)agIORequest->osData;
4145 if (tdSMPRequestBody->tiIORequest->osData == agNULL)
4146 {
4147 TI_DBG1(("ossaSMPCAMCompleted: tdIORequestBody->tiIORequest->osData is null, wrong\n"));
4148 goto ext;
4149 }
4150 /* allocating agIORequest for SMP Payload itself */
4151 memAllocStatus = ostiAllocMemory(
4152 tiRoot,
4153 &osMemHandle,
4154 (void **)&SMPpayload,
4155 &PhysUpper32,
4156 &PhysLower32,
4157 8,
4158 agIOInfoLen,
4159 agTRUE
4160 );
4161 if (memAllocStatus != tiSuccess)
4162 {
4163 /* let os process IO */
4164 TI_DBG1(("ossaSMPCAMCompleted: ostiAllocMemory failed...\n"));
4165 goto ext;
4166 }
4167 if (SMPpayload == agNULL)
4168 {
4169 TI_DBG1(("ossaSMPCAMCompleted: ostiAllocMemory returned NULL SMPpayload\n"));
4170 goto ext;
4171 }
4172 if (agIOStatus == OSSA_IO_SUCCESS)
4173 {
4174 TI_DBG1(("ossaSMPCAMCompleted: Success status\n"));
4175 osti_memset(SMPpayload, 0, agIOInfoLen);
4176 TI_DBG1(("ossaSMPCAMCompleted: after memset\n"));
4177 saFrameReadBlock(agRoot, agFrameHandle, 0, SMPpayload, agIOInfoLen);
4178 TI_DBG1(("ossaSMPCAMCompleted: after read \n"));
4179 status = tiSMPSuccess;
4180 }
4181 else if (agIOStatus == OSSA_IO_ABORTED)
4182 {
4183 TI_DBG1(("ossaSMPCAMCompleted: SMP Aborted status\n"));
4184 status = tiSMPAborted;
4185 TI_DBG1(("ossaSMPCAMCompleted: failed status=%d\n", status));
4186 //failed to send smp command, we need to free the memory
4187 ostiFreeMemory(
4188 tiRoot,
4189 osMemHandle,
4190 agIOInfoLen
4191 );
4192 }
4193 else
4194 {
4195 TI_DBG1(("ossaSMPCAMCompleted: SMP failed status\n"));
4196 status = tiSMPFailed;
4197 TI_DBG1(("ossaSMPCAMCompleted: failed status=%d\n", status));
4198 //failed to send smp command, we need to free the memory
4199 ostiFreeMemory(
4200 tiRoot,
4201 osMemHandle,
4202 agIOInfoLen
4203 );
4204 }
4205 ostiInitiatorSMPCompleted(tiRoot,
4206 tdSMPRequestBody->tiIORequest,
4207 status,
4208 agIOInfoLen,
4209 SMPpayload,
4210 context
4211 );
4212 ext:
4213 TDSA_OUT_LEAVE((tiRoot_t*)((tdsaRootOsData_t*)agRoot->osData)->tiRoot);
4214 return;
4215 }
4216 #ifdef REMOVED
4217 #ifdef TARGET_DRIVER
4218 /*****************************************************************************/
4219 /*! \brief ossaSMPReqReceived
4220 *
4221 *
4222 * Purpose: This routine is called by lower layer to indicate the reception of
4223 * SMP request
4224 *
4225 * \param agRoot: Pointer to chip/driver Instance.
4226 * \param agDevHandle Pointer to the device handle of the device
4227 * \param agFrameHandle A Handle used to refer to the response frame
4228 *
4229 *
4230 * \return None.
4231 *
4232 * \note - The scope is target only
4233 * For details, refer to SAS/SATA Low-Level API Specification
4234 */
4235 /*****************************************************************************/
ossaSMPReqReceived(agsaRoot_t * agRoot,agsaDevHandle_t * agDevHandle,agsaFrameHandle_t agFrameHandle,bit32 agFrameLength,bit32 phyId)4236 osGLOBAL void ossaSMPReqReceived(
4237 agsaRoot_t *agRoot,
4238 agsaDevHandle_t *agDevHandle,
4239 agsaFrameHandle_t agFrameHandle,
4240 bit32 agFrameLength,
4241 bit32 phyId
4242 )
4243 {
4244 bit8 smpHeader[4];
4245 agsaSMPFrameHeader_t *agFrameHeader;
4246 #ifdef PASSTHROUGH
4247 /* call the registered function(parameter in tiTGTPassthroughCmndRegister() by target */
4248 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
4249 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
4250 ttdsaTgt_t *Target = (ttdsaTgt_t *)osData->ttdsaTgt;
4251
4252 bit8 SMPframe[agIOInfoLen + sizeof(agsaSMPFrameHeader_t)];
4253 bit8 SMPpayload[agIOInfoLen];
4254
4255 TI_DBG2(("ossaSMPReqReceived: start and passthrough\n"));
4256 osti_memset(SMPpayload, 0, agIOInfoLen);
4257 osti_memset(SMPframe, 0, agIOInfoLen + sizeof(agsaSMPFrameHeader_t));
4258 /* combine smp header and payload */
4259 saFrameReadBlock(agRoot, agFrameHandle, 0, &SMPpayload, agIOInfoLen);
4260 osti_memcpy(SMPframe, agFrameHeader, sizeof(agsaSMPFrameHeader_t));
4261 osti_memcpy(SMPframe+sizeof(agsaSMPFrameHeader_t), SMPpayload, agIOInfoLen);
4262
4263 Target->PasthroughCB(
4264 tiRoot,
4265 tiSASATA,
4266 tiSMP,
4267 tiSMPResponse,
4268 SMPframe,
4269 agIOInfoLen + sizeof(agsaSMPFrameHeader_t),
4270 phyId
4271 );
4272
4273 #else
4274
4275 /*
4276 agDevHandle_t->osData points to tdssDeviceData_t
4277 */
4278 tdsaDeviceData_t *pDeviceData = (tdsaDeviceData_t *) agDevHandle->osData;
4279
4280 saFrameReadBlock(agRoot, agFrameHandle, 0, smpHeader, 4);
4281 agFrameHeader = (agsaSMPFrameHeader_t *)smpHeader;
4282 TI_DBG4(("ossaSMPReqReceived: start\n"));
4283
4284 /* tdtypes.h, calling ttdsaSMPReqReceived in ttdsmp.c */
4285 pDeviceData->pJumpTable->pSMPReqReceived (
4286 agRoot,
4287 agDevHandle,
4288 agFrameHeader,
4289 agFrameHandle,
4290 agFrameLength,
4291 phyId
4292 );
4293 #endif
4294 return;
4295 }
4296 #endif
4297 #endif
4298
4299 /*****************************************************************************/
4300 /*! \brief ossaSSPCompleted
4301 *
4302 *
4303 * Purpose: This routine is called by lower layer to indicate the completion of
4304 * SSP request
4305 *
4306 * \param agRoot: Pointer to chip/driver Instance.
4307 * \param agIORequest Pointer to SMP request handle
4308 * \param agIOStatus Status
4309 * \param agIOInfoLen IO information length assoicated with the IO
4310 * \param agFrameHandle A Handle used to refer to the response frame
4311 *
4312 *
4313 * \return None.
4314 *
4315 * \note - The scope is shared target and initiator.
4316 * For details, refer to SAS/SATA Low-Level API Specification
4317 */
4318 /*****************************************************************************/
4319 FORCEINLINE
ossaSSPCompleted(agsaRoot_t * agRoot,agsaIORequest_t * agIORequest,bit32 agIOStatus,bit32 agIOInfoLen,void * agParam,bit16 sspTag,bit32 agOtherInfo)4320 void ossaSSPCompleted(
4321 agsaRoot_t *agRoot,
4322 agsaIORequest_t *agIORequest,
4323 bit32 agIOStatus,
4324 bit32 agIOInfoLen,
4325 void *agParam,
4326 bit16 sspTag,
4327 bit32 agOtherInfo
4328 )
4329 {
4330 tdIORequestBody_t *pIORequestBody;
4331 #ifdef TD_DEBUG_ENABLE
4332 tiDeviceHandle_t *tiDeviceHandle = agNULL;
4333 tdsaDeviceData_t *oneDeviceData = agNULL;
4334 #endif
4335
4336 TDSA_OUT_ENTER((tiRoot_t*)((tdsaRootOsData_t*)agRoot->osData)->tiRoot);
4337 smTraceFuncEnter(hpDBG_VERY_LOUD,"2L");
4338
4339 if(!agIORequest->osData)
4340 {
4341 TD_ASSERT((0), "ossaSSPCompleted agIORequest->osData");
4342 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "2L");
4343 goto ext;
4344 }
4345 pIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
4346
4347
4348 TI_DBG4(("ossaSSPCompleted: start\n"));
4349
4350 if (pIORequestBody == agNULL)
4351 {
4352 TI_DBG1(("ossaSSPCompleted: pIORequestBody is NULL \n"));
4353 smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "2L");
4354 goto ext;
4355 }
4356 if (pIORequestBody->IOCompletionFunc == agNULL)
4357 {
4358 #ifdef TD_DEBUG_ENABLE
4359 tiDeviceHandle = pIORequestBody->tiDevHandle;
4360 oneDeviceData = (tdsaDeviceData_t *)tiDeviceHandle->tdData;
4361 #endif
4362 TI_DBG1(("ossaSSPCompleted: IOCompletionFunc is NULL \n"));
4363 TI_DBG1(("ossaSSPCompleted: did %d \n", oneDeviceData->id));
4364 smTraceFuncExit(hpDBG_VERY_LOUD, 'c', "2L");
4365 goto ext;
4366 }
4367
4368 /*
4369 if initiator, calling itdssIOCompleted() in itdcb.c
4370 if initiator, calling itdssTaskCompleted in itdcb.c
4371 if target, calling ttdsaIOCompleted() in ttdio.c
4372 */
4373 pIORequestBody->IOCompletionFunc(
4374 agRoot,
4375 agIORequest,
4376 agIOStatus,
4377 agIOInfoLen,
4378 agParam,
4379 agOtherInfo
4380 );
4381 smTraceFuncExit(hpDBG_VERY_LOUD, 'd', "2L");
4382 ext:
4383 TDSA_OUT_LEAVE((tiRoot_t*)((tdsaRootOsData_t*)agRoot->osData)->tiRoot);
4384 return;
4385 }
4386
4387 #ifdef FAST_IO_TEST
ossaFastSSPCompleted(agsaRoot_t * agRoot,agsaIORequest_t * cbArg,bit32 agIOStatus,bit32 agIOInfoLen,void * agParam,bit16 sspTag,bit32 agOtherInfo)4388 GLOBAL void ossaFastSSPCompleted(
4389 agsaRoot_t *agRoot,
4390 agsaIORequest_t *cbArg,
4391 bit32 agIOStatus,
4392 bit32 agIOInfoLen,
4393 void *agParam,
4394 bit16 sspTag,
4395 bit32 agOtherInfo
4396 )
4397 {
4398 agsaFastCBBuf_t *safb = (agsaFastCBBuf_t*)cbArg;
4399 tdsaRootOsData_t *osData = (tdsaRootOsData_t*)agRoot->osData;
4400 tiRoot_t *tiRoot = (tiRoot_t*)osData->tiRoot;
4401 bit32 scsi_status;
4402 bit32 data_status;
4403 bit32 respLen;
4404 bit8 respData[128];
4405 bit32 senseLen;
4406 agsaSSPResponseInfoUnit_t agSSPRespIU;
4407
4408 TDSA_OUT_ENTER((tiRoot_t*)((tdsaRootOsData_t*)agRoot->osData)->tiRoot);
4409 smTraceFuncEnter(hpDBG_VERY_LOUD,"Y6");
4410
4411 TI_DBG4(("ossaSSPCompleted: start\n"));
4412
4413 if (safb->cb == agNULL || safb->cbArg == agNULL)
4414 {
4415 TI_DBG1(("ossaFastSSPCompleted: pIORequestBody is NULL \n"));
4416 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Y6");
4417 TD_ASSERT((0), "");
4418 goto ext;
4419 }
4420
4421 switch (agIOStatus)
4422 {
4423 case OSSA_IO_SUCCESS:
4424
4425 /* ~ itdssIOSuccessHandler */
4426 if ((agIOInfoLen < sizeof(agsaSSPResponseInfoUnit_t)))
4427 {
4428 ((ostiFastSSPCb_t)safb->cb)(tiRoot, safb->cbArg, OSSA_IO_SUCCESS, 0);
4429 break;
4430 }
4431
4432 /* reads agsaSSPResponseInfoUnit_t */
4433 saFrameReadBlock(agRoot, agParam, 0, &agSSPRespIU,
4434 sizeof(agsaSSPResponseInfoUnit_t));
4435
4436 data_status = SA_SSPRESP_GET_DATAPRES(&agSSPRespIU);
4437 scsi_status = agSSPRespIU.status;
4438
4439 TI_DBG1(("itdssIOSuccessHandler: scsi_status %d\n", scsi_status));
4440
4441 /* endianess is invovled here */
4442 senseLen = SA_SSPRESP_GET_SENSEDATALEN(&agSSPRespIU);
4443 respLen = SA_SSPRESP_GET_RESPONSEDATALEN(&agSSPRespIU);
4444 TI_DBG2(("itdssIOSuccessHandler: scsi status=0x%x, senselen=0x%x resplen "
4445 "0x%x\n", scsi_status, senseLen, respLen));
4446
4447 if (agIOInfoLen < sizeof(agsaSSPResponseInfoUnit_t) + senseLen + respLen)
4448 {
4449 ((ostiFastSSPCb_t)safb->cb)(tiRoot, safb->cbArg, tiIOFailed,
4450 tiDetailOtherError);
4451 break;
4452 }
4453
4454 /* reads response data */
4455 saFrameReadBlock(agRoot, agParam, sizeof(agsaSSPResponseInfoUnit_t),
4456 respData, respLen);
4457 /* reads sense data */
4458 saFrameReadBlock(agRoot, agParam, sizeof(agsaSSPResponseInfoUnit_t)
4459 + respLen, safb->pSenseData, senseLen);
4460
4461 if (data_status == 0)
4462 {
4463 /* NO_DATA */
4464 TI_DBG2(("ossaFastSSPCompleted: no data\n"));
4465 ((ostiFastSSPCb_t)safb->cb)(tiRoot, safb->cbArg, tiIOSuccess,
4466 scsi_status);
4467 break;
4468 }
4469
4470 if (data_status == 1)
4471 {
4472 /* RESPONSE_DATA */
4473 TI_DBG1(("ossaFastSSPCompleted: response data \n"));
4474 ((ostiFastSSPCb_t)safb->cb)(tiRoot, safb->cbArg, tiIOSuccess, 0);
4475 break;
4476 }
4477
4478 if (data_status == 2)
4479 {
4480 tiSenseData_t senseData;
4481
4482 /* SENSE_DATA */
4483 TI_DBG2(("itdssIOSuccessHandler: sense data \n"));
4484
4485 senseData.senseData = safb->pSenseData;
4486 senseData.senseLen = MIN(*(safb->senseLen), senseLen);
4487
4488 /* when ASC = 0x04 - Log Unit Not Ready,
4489 and ASCQ = 0x11 - Enable Spinup Required:
4490 call saLocalPhyControl to notify spinup */
4491 if (((char*)safb->pSenseData)[12] == 0x04 &&
4492 ((char*)safb->pSenseData)[13] == 0x11)
4493 {
4494 int i;
4495
4496 TI_DBG2(("ossaFastSSPCompleted: sending notfify spinup\n"));
4497
4498 if (((tdsaDeviceData_t*)safb->oneDeviceData)->directlyAttached ==
4499 agTRUE)
4500 {
4501 for (i = 0; i < TD_MAX_NUM_NOTIFY_SPINUP; i++)
4502 {
4503 saLocalPhyControl(agRoot, agNULL, 0,
4504 ((tdsaDeviceData_t*)safb->oneDeviceData)->phyID,
4505 AGSA_PHY_NOTIFY_ENABLE_SPINUP,
4506 agNULL);
4507 }
4508 }
4509 }
4510
4511 if (*(safb->senseLen) > senseData.senseLen)
4512 *(safb->senseLen) = senseData.senseLen;
4513 // memcpy((void *)safb->pSenseData, senseData.senseData, safb->senseLen);
4514
4515 ((ostiFastSSPCb_t)safb->cb)(tiRoot, safb->cbArg, tiIOSuccess,
4516 scsi_status);
4517 break;
4518 }
4519
4520 if (data_status == 3)
4521 {
4522 /* RESERVED */
4523 TI_DBG1(("ossaFastSSPCompleted: reserved wrong!!!\n"));
4524
4525 ((ostiFastSSPCb_t)safb->cb)(tiRoot, safb->cbArg, tiIOFailed,
4526 scsi_status);
4527 break;
4528 }
4529 break;
4530 #ifdef REMOVED
4531 case OSSA_IO_OVERFLOW:
4532 ((ostiFastSSPCb_t)safb->cb)(tiRoot, safb->cbArg, tiIOOverRun,
4533 agIOInfoLen);
4534 break;
4535 #endif /* REMOVED */
4536 case OSSA_IO_UNDERFLOW:
4537 ((ostiFastSSPCb_t)safb->cb)(tiRoot, safb->cbArg, tiIOUnderRun,
4538 agIOInfoLen);
4539 break;
4540
4541 case OSSA_IO_ABORTED:
4542 ((ostiFastSSPCb_t)safb->cb)(tiRoot, safb->cbArg, tiIOFailed,
4543 tiDetailAborted);
4544 break;
4545 case OSSA_IO_ABORT_RESET:
4546 ((ostiFastSSPCb_t)safb->cb)(tiRoot, safb->cbArg, tiIOFailed,
4547 tiDetailAbortReset);
4548 break;
4549 case OSSA_IO_NO_DEVICE:
4550 ((ostiFastSSPCb_t)safb->cb)(tiRoot, safb->cbArg, tiIOFailed,
4551 tiDetailNoLogin);
4552 break;
4553 case OSSA_IO_DS_NON_OPERATIONAL:
4554 {
4555
4556 tdsaDeviceData_t *oneDeviceData;
4557
4558 oneDeviceData = (tdsaDeviceData_t*)safb->oneDeviceData;
4559 if (oneDeviceData->valid == agTRUE &&
4560 oneDeviceData->registered == agTRUE &&
4561 oneDeviceData->tdPortContext != agNULL)
4562 {
4563 saSetDeviceState(oneDeviceData->agRoot, agNULL, tdsaRotateQnumber(tiRoot, oneDeviceData),
4564 oneDeviceData->agDevHandle, SA_DS_OPERATIONAL);
4565 }
4566 /* fall through */
4567 }
4568
4569 default:
4570 ((ostiFastSSPCb_t)safb->cb)(tiRoot, safb->cbArg, tiIOFailed,
4571 tiDetailOtherError);
4572 break;
4573 }
4574
4575 smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "Y6");
4576
4577 ext:
4578 TDSA_OUT_LEAVE((tiRoot_t*)((tdsaRootOsData_t*)agRoot->osData)->tiRoot);
4579 return;
4580 } /* ossaFastSSPCompleted */
4581 #endif
4582
4583 /*****************************************************************************/
4584 /*! \brief ossaSSPReqReceived
4585 *
4586 *
4587 * Purpose: This routine is called by lower layer to indicate the reception of
4588 * SMP request
4589 *
4590 * \param agRoot: Pointer to chip/driver Instance.
4591 * \param agDevHandle Pointer to the device handle of the device
4592 * \param agFrameHandle A Handle used to refer to the response frame
4593 * \param agInitiatorTag the initiator tag
4594 * \param agFrameType SSP frame type
4595 *
4596 * \return none.
4597 *
4598 * \note - The scope is target only
4599 * For details, refer to SAS/SATA Low-Level API Specification
4600 */
4601 /*****************************************************************************/
ossaSSPReqReceived(agsaRoot_t * agRoot,agsaDevHandle_t * agDevHandle,agsaFrameHandle_t agFrameHandle,bit16 agInitiatorTag,bit32 parameter,bit32 agFrameLen)4602 osGLOBAL void ossaSSPReqReceived(
4603 agsaRoot_t *agRoot,
4604 agsaDevHandle_t *agDevHandle,
4605 agsaFrameHandle_t agFrameHandle,
4606 bit16 agInitiatorTag,
4607 bit32 parameter,
4608 bit32 agFrameLen
4609 )
4610 {
4611 /*
4612 at target only
4613 uses jumptable, not callback
4614 */
4615 /*
4616 agDevHandle_t->osData points to tdssDeviceData_t
4617 */
4618 tdsaDeviceData_t *pDeviceData = (tdsaDeviceData_t *) agDevHandle->osData;
4619 smTraceFuncEnter(hpDBG_VERY_LOUD,"Y7");
4620
4621 /* tdtypes.h, calling ttdsaSSPReqReceived() in ttdio.c */
4622 pDeviceData->pJumpTable->pSSPReqReceived (
4623 agRoot,
4624 agDevHandle,
4625 agFrameHandle,
4626 agInitiatorTag,
4627 parameter,
4628 agFrameLen
4629 );
4630 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Y7");
4631 return;
4632 }
4633 /*****************************************************************************/
4634 /*! \brief ossaStallThread
4635 *
4636 *
4637 * Purpose: This routine is called to stall this thread for a number of
4638 * microseconds.
4639 *
4640 *
4641 * \param agRoot: Pointer to chip/driver Instance.
4642 * \param microseconds: Micro second to stall.
4643 *
4644 *
4645 * \return None.
4646 *
4647 * \note - The scope is shared target and initiator.
4648 *
4649 */
4650 /*****************************************************************************/
ossaStallThread(agsaRoot_t * agRoot,bit32 microseconds)4651 osGLOBAL void ossaStallThread(agsaRoot_t *agRoot,
4652 bit32 microseconds
4653 )
4654 {
4655 tdsaRootOsData_t *pOsData = (tdsaRootOsData_t *) (agRoot->osData);
4656
4657 ostiStallThread (
4658 pOsData->tiRoot,
4659 microseconds
4660 );
4661 return;
4662 }
4663
4664
4665 /*****************************************************************************
4666 *! \brief ossaSSPEvent
4667 *
4668 * This routine is called to notify the OS Layer of an event associated with
4669 * SAS port or SAS device
4670 *
4671 * \param agRoot: Handles for this instance of SAS/SATA hardware
4672 * \param agIORequest Pointer to IO request
4673 * \param event: event type
4674 * \param agIOInfoLen: not in use
4675 * \param agFrameHandle: not in use
4676 *
4677 * \return: none
4678 *
4679 *****************************************************************************/
4680 /* in case of CMD ACK_NAK timeout, send query task */
ossaSSPEvent(agsaRoot_t * agRoot,agsaIORequest_t * agIORequest,agsaPortContext_t * agPortContext,agsaDevHandle_t * agDevHandle,bit32 event,bit16 sspTag,bit32 agIOInfoLen,void * agParam)4681 osGLOBAL void ossaSSPEvent(
4682 agsaRoot_t *agRoot,
4683 agsaIORequest_t *agIORequest,
4684 agsaPortContext_t *agPortContext,
4685 agsaDevHandle_t *agDevHandle,
4686 bit32 event,
4687 bit16 sspTag,
4688 bit32 agIOInfoLen,
4689 void *agParam
4690 )
4691 {
4692 #ifdef INITIATOR_DRIVER
4693 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
4694 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
4695 /* bit32 intContext = osData->IntContext; */
4696 void *osMemHandle;
4697 tdIORequestBody_t *TMtdIORequestBody;
4698 bit32 PhysUpper32;
4699 bit32 PhysLower32;
4700 bit32 memAllocStatus;
4701 bit32 agRequestType;
4702 agsaIORequest_t *agTMIORequest = agNULL; /* task management itself */
4703 agsaSASRequestBody_t *agSASRequestBody = agNULL;
4704 agsaSSPScsiTaskMgntReq_t *agSSPTaskMgntRequest;
4705 bit32 saStatus;
4706 bit32 agIORequestType; /* type of IO recevied */
4707 tiIORequest_t *taskTag; /* being task managed one */
4708 tdIORequestBody_t *tdIORequestBody;
4709 #endif
4710
4711 #ifdef REMOVED
4712 tiDeviceHandle_t *tiDeviceHandle;
4713 tdsaDeviceData_t *oneDeviceData = agNULL;
4714 tdIORequestBody_t *tdAbortIORequestBody;
4715 #endif
4716 agsaDifDetails_t agDifDetails;
4717 bit8 framePayload[256];
4718 #ifdef REMOVED
4719 bit16 frameOffset = 0;
4720 #endif
4721 bit16 frameLen = 0;
4722
4723 TI_DBG6(("ossaSSPEvent: start\n"));
4724 smTraceFuncEnter(hpDBG_VERY_LOUD,"Y9");
4725
4726
4727
4728 if (event == OSSA_IO_XFER_ERROR_CMD_ISSUE_ACK_NAK_TIMEOUT ||
4729 event == OSSA_IO_XFER_ERROR_BREAK ||
4730 event == OSSA_IO_XFER_ERROR_PHY_NOT_READY
4731 )
4732 {
4733
4734 /* IO being task managed(the original IO) depending on event */
4735 #ifdef INITIATOR_DRIVER
4736 tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
4737 taskTag = tdIORequestBody->tiIORequest;
4738 #endif
4739 #ifdef REMOVED
4740 tiDeviceHandle = tdIORequestBody->tiDevHandle;
4741 oneDeviceData = (tdsaDeviceData_t *)tiDeviceHandle->tdData;
4742 #endif
4743
4744 #ifdef INITIATOR_DRIVER
4745 agIORequestType = tdIORequestBody->agRequestType;
4746
4747 /* error checking; only command is expected here */
4748 if (agIORequestType == AGSA_REQ_TYPE_UNKNOWN)
4749 {
4750 TI_DBG1(("ossaSSPEvent: incorrect frame 0x%x. Should be command\n", agIORequestType));
4751 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Y9");
4752 return;
4753 }
4754
4755 /* Allocate memory for query task management */
4756 memAllocStatus = ostiAllocMemory(
4757 tiRoot,
4758 &osMemHandle,
4759 (void **)&TMtdIORequestBody,
4760 &PhysUpper32,
4761 &PhysLower32,
4762 8,
4763 sizeof(tdIORequestBody_t),
4764 agTRUE
4765 );
4766
4767 if (memAllocStatus != tiSuccess)
4768 {
4769 /* let os process IO */
4770 TI_DBG1(("ossaSSPEvent: ostiAllocMemory failed...\n"));
4771 smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "Y9");
4772 return;
4773 }
4774
4775 if (TMtdIORequestBody == agNULL)
4776 {
4777 /* let os process IO */
4778 TI_DBG1(("ossaSSPEvent: ostiAllocMemory returned NULL TMIORequestBody\n"));
4779 smTraceFuncExit(hpDBG_VERY_LOUD, 'c', "Y9");
4780 return;
4781 }
4782
4783 /* setup task management structure */
4784 TMtdIORequestBody->IOType.InitiatorTMIO.osMemHandle = osMemHandle;
4785 /* TD generates Query Task not OS layer */
4786 TMtdIORequestBody->IOType.InitiatorTMIO.CurrentTaskTag = agNULL;
4787 TMtdIORequestBody->IOType.InitiatorTMIO.TaskTag = taskTag;
4788
4789 /* initialize callback function */
4790 TMtdIORequestBody->IOCompletionFunc = itdssQueryTaskCompleted;
4791
4792 /* initialize tiDevhandle */
4793 TMtdIORequestBody->tiDevHandle = tdIORequestBody->tiDevHandle;
4794
4795
4796 /* initialize agIORequest */
4797 agTMIORequest = &(TMtdIORequestBody->agIORequest);
4798 agTMIORequest->osData = (void *) TMtdIORequestBody;
4799 agTMIORequest->sdkData = agNULL; /* LL takes care of this */
4800
4801 /* request type */
4802 agRequestType = AGSA_SSP_TASK_MGNT_REQ;
4803 TMtdIORequestBody->agRequestType = AGSA_SSP_TASK_MGNT_REQ;
4804
4805 /*
4806 initialize
4807 tdIORequestBody_t tdIORequestBody -> agSASRequestBody
4808 */
4809 agSASRequestBody = &(TMtdIORequestBody->transport.SAS.agSASRequestBody);
4810 agSSPTaskMgntRequest = &(agSASRequestBody->sspTaskMgntReq);
4811
4812 /* fill up LUN field */
4813 osti_memset(agSSPTaskMgntRequest->lun, 0, 8);
4814
4815 /* sets taskMgntFunction field */
4816 agSSPTaskMgntRequest->taskMgntFunction = AGSA_QUERY_TASK;
4817 /* debugging */
4818 if (TMtdIORequestBody->IOCompletionFunc == agNULL)
4819 {
4820 TI_DBG1(("ossaSSPEvent: Error !!! IOCompletionFunc is NULL\n"));
4821 }
4822 /* send query task management */
4823 saStatus = saSSPStart(agRoot,
4824 agTMIORequest,
4825 0,
4826 agDevHandle,
4827 agRequestType,
4828 agSASRequestBody,
4829 agIORequest,
4830 &ossaSSPCompleted);
4831
4832 if (saStatus != AGSA_RC_SUCCESS)
4833 {
4834 /* free up allocated memory */
4835 ostiFreeMemory(
4836 tiRoot,
4837 TMtdIORequestBody->IOType.InitiatorTMIO.osMemHandle,
4838 sizeof(tdIORequestBody_t)
4839 );
4840 TI_DBG1(("ossaSSPEvent: saSSPStart failed\n"));
4841 return;
4842 }
4843 #endif
4844 }
4845 #ifdef REMOVED
4846 else if (event == OSSA_IO_ABORTED)
4847 {
4848 TI_DBG2(("ossaSSPEvent: OSSA_IO_ABORTED\n"));
4849 /* clean up TD layer's IORequestBody */
4850 tdAbortIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
4851 ostiFreeMemory(
4852 tiRoot,
4853 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
4854 sizeof(tdIORequestBody_t)
4855 );
4856
4857 }
4858 else if (event == OSSA_IO_NOT_VALID)
4859 {
4860 TI_DBG1(("ossaSSPEvent: OSSA_IO_NOT_VALID\n"));
4861 tdAbortIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
4862 ostiFreeMemory(
4863 tiRoot,
4864 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
4865 sizeof(tdIORequestBody_t)
4866 );
4867
4868
4869 }
4870 #endif
4871 else if (event == OSSA_IO_XFER_CMD_FRAME_ISSUED)
4872 {
4873 TI_DBG2(("ossaSSPEvent: OSSA_IO_XFER_CMD_FRAME_ISSUED\n"));
4874 }
4875 else if (event == OSSA_IO_XFER_ERROR_OFFSET_MISMATCH)
4876 {
4877 TI_DBG1(("ossaSSPEvent: OSSA_IO_XFER_ERROR_OFFSET_MISMATCH\n"));
4878 }
4879 else if (event == OSSA_IO_OVERFLOW)
4880 {
4881 TI_DBG1(("ossaSSPEvent: OSSA_IO_OVERFLOW\n"));
4882 /*
4883 ??? can't call; missing agIOInfoLen
4884 ostiInitiatorIOCompleted (
4885 tiRoot,
4886 tdIORequestBody->tiIORequest,
4887 tiIOOverRun,
4888 agIOInfoLen,
4889 agNULL,
4890 intContext
4891 );
4892
4893 */
4894
4895 }
4896 else if (event == OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_RETRY_BACKOFF_THRESHOLD_REACHED)
4897 {
4898 TI_DBG1(("ossaSSPEvent: OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_RETRY_BACKOFF_THRESHOLD_REACHED\n"));
4899 }
4900 else if (event == OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_TMO)
4901 {
4902 TI_DBG1(("ossaSSPEvent: OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_TMO\n"));
4903 }
4904 else if (event == OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_NO_DEST)
4905 {
4906 TI_DBG1(("ossaSSPEvent: OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_NO_DEST\n"));
4907 }
4908 else if (event == OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_COLLIDE)
4909 {
4910 TI_DBG1(("ossaSSPEvent: OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_COLLIDE\n"));
4911 }
4912 else if (event == OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_PATHWAY_BLOCKED)
4913 {
4914 TI_DBG1(("ossaSSPEvent: OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_PATHWAY_BLOCKED\n"));
4915 }
4916 else if (event == OSSA_IO_XFR_ERROR_DEK_KEY_TAG_MISMATCH)
4917 {
4918 TI_DBG1(("ossaSSPEvent: OSSA_IO_XFR_ERROR_DEK_KEY_TAG_MISMATCH\n"));
4919 }
4920 else if (event == OSSA_IO_XFER_ERROR_XFER_RDY_OVERRUN)
4921 {
4922 TI_DBG1(("ossaSSPEvent: OSSA_IO_XFER_ERROR_XFER_RDY_OVERRUN\n"));
4923 }
4924 else if (event == OSSA_IO_XFR_ERROR_DIF_MISMATCH ||
4925 event == OSSA_IO_XFR_ERROR_DIF_APPLICATION_TAG_MISMATCH ||
4926 event == OSSA_IO_XFR_ERROR_DIF_REFERENCE_TAG_MISMATCH ||
4927 event == OSSA_IO_XFR_ERROR_DIF_CRC_MISMATCH )
4928 {
4929 TI_DBG1(("ossaSSPEvent: DIF related, event 0x%x\n", event));
4930 /* process DIF detail information */
4931 TI_DBG2(("ossaSSPEvent: agIOInfoLen %d\n", agIOInfoLen));
4932 if (agParam == agNULL)
4933 {
4934 TI_DBG2(("ossaSSPEvent: agParam is NULL!!!\n"));
4935 return;
4936 }
4937 if (agIOInfoLen < sizeof(agsaDifDetails_t))
4938 {
4939 TI_DBG2(("ossaSSPEvent: wrong agIOInfoLen!!! agIOInfoLen %d sizeof(agsaDifDetails_t) %d\n", agIOInfoLen, (int)sizeof(agsaDifDetails_t)));
4940 return;
4941 }
4942 /* reads agsaDifDetails_t */
4943 saFrameReadBlock(agRoot, agParam, 0, &agDifDetails, sizeof(agsaDifDetails_t));
4944 #ifdef REMOVED
4945 frameOffset = (agDifDetails.ErrBoffsetEDataLen & 0xFFFF);
4946 #endif
4947 frameLen = (bit16)((agDifDetails.ErrBoffsetEDataLen & 0xFFFF0000) >> 16);
4948
4949 TI_DBG2(("ossaSSPEvent: UpperLBA 0x%08x LowerLBA 0x%08x\n", agDifDetails.UpperLBA, agDifDetails.LowerLBA));
4950 TI_DBG2(("ossaSSPEvent: SASAddrHI 0x%08x SASAddrLO 0x%08x\n",
4951 TD_GET_SAS_ADDRESSHI(agDifDetails.sasAddressHi), TD_GET_SAS_ADDRESSLO(agDifDetails.sasAddressLo)));
4952 TI_DBG2(("ossaSSPEvent: DIF error mask 0x%x Device ID 0x%x\n",
4953 (agDifDetails.DIFErrDevID) & 0xFF, (agDifDetails.DIFErrDevID & 0xFFFF0000) >> 16));
4954 if (frameLen != 0 && frameLen <= 256)
4955 {
4956 saFrameReadBlock(agRoot, agParam, sizeof(agsaDifDetails_t), framePayload, frameLen);
4957 tdhexdump("ossaSSPEvent frame", framePayload, frameLen);
4958 }
4959 }
4960 else
4961 {
4962 TI_DBG1(("ossaSSPEvent: other event 0x%x\n", event));
4963 }
4964
4965 smTraceFuncExit(hpDBG_VERY_LOUD, 'd', "Y9");
4966 return;
4967 }
4968
4969 #ifdef FDS_SM
ossaSATAIDAbortCB(agsaRoot_t * agRoot,agsaIORequest_t * agIORequest,bit32 flag,bit32 status)4970 osGLOBAL void ossaSATAIDAbortCB(
4971 agsaRoot_t *agRoot,
4972 agsaIORequest_t *agIORequest,
4973 bit32 flag,
4974 bit32 status)
4975 {
4976 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
4977 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
4978 tdIORequestBody_t *tdAbortIORequestBody;
4979
4980 TI_DBG1(("ossaSATAIDAbortCB: start flag %d status %d\n", flag, status));
4981
4982 tdAbortIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
4983
4984 /*
4985 triggered by tdIDStartTimerCB
4986 */
4987 ostiFreeMemory(
4988 tiRoot,
4989 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
4990 sizeof(tdIORequestBody_t)
4991 );
4992 return;
4993 }
4994 #endif
4995
4996 #ifdef INITIATOR_DRIVER
ossaSSPAbortCB(agsaRoot_t * agRoot,agsaIORequest_t * agIORequest,bit32 flag,bit32 status)4997 osGLOBAL void ossaSSPAbortCB(
4998 agsaRoot_t *agRoot,
4999 agsaIORequest_t *agIORequest,
5000 bit32 flag,
5001 bit32 status)
5002 {
5003 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
5004 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
5005 tdIORequestBody_t *tdAbortIORequestBody = agNULL;
5006 tdsaDeviceData_t *oneDeviceData = agNULL;
5007 tiDeviceHandle_t *tiDeviceHandle = agNULL;
5008 tiIORequest_t *taskTag = agNULL;
5009
5010 TI_DBG2(("ossaSSPAbortCB: start\n"));
5011 smTraceFuncEnter(hpDBG_VERY_LOUD,"Ya");
5012
5013 tdAbortIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
5014 if (tdAbortIORequestBody == agNULL)
5015 {
5016 TI_DBG1(("ossaSSPAbortCB: tdAbortIORequestBody is NULL warning!!!!\n"));
5017 return;
5018 }
5019
5020 if (flag == 2)
5021 {
5022 /* abort per port */
5023 TI_DBG1(("ossaSSPAbortCB: abort per port\n"));
5024 }
5025 else if (flag == 1)
5026 {
5027 TI_DBG2(("ossaSSPAbortCB: abort all\n"));
5028
5029 tiDeviceHandle = (tiDeviceHandle_t *)tdAbortIORequestBody->tiDevHandle;
5030 if (tiDeviceHandle == agNULL)
5031 {
5032 TI_DBG1(("ossaSSPAbortCB: tiDeviceHandle is NULL warning!!!!\n"));
5033 ostiFreeMemory(
5034 tiRoot,
5035 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
5036 sizeof(tdIORequestBody_t)
5037 );
5038 return;
5039 }
5040
5041 oneDeviceData = (tdsaDeviceData_t *)tiDeviceHandle->tdData;
5042 if (oneDeviceData == agNULL)
5043 {
5044 TI_DBG1(("ossaSSPAbortCB: oneDeviceData is NULL warning!!!!\n"));
5045 ostiFreeMemory(
5046 tiRoot,
5047 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
5048 sizeof(tdIORequestBody_t)
5049 );
5050 return;
5051 }
5052
5053 if (status == OSSA_IO_SUCCESS)
5054 {
5055 TI_DBG2(("ossaSSPAbortCB: OSSA_IO_SUCCESS\n"));
5056 /* clean up TD layer's IORequestBody */
5057 if (oneDeviceData->OSAbortAll == agTRUE)
5058 {
5059 oneDeviceData->OSAbortAll = agFALSE;
5060 ostiInitiatorEvent( tiRoot,
5061 agNULL,
5062 tiDeviceHandle,
5063 tiIntrEventTypeLocalAbort,
5064 tiAbortOK,
5065 agNULL);
5066 }
5067 else
5068 {
5069 TI_DBG2(("ossaSSPAbortCB: calling saDeregisterDeviceHandle\n"));
5070 saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, tdsaRotateQnumber(tiRoot, oneDeviceData));
5071 }
5072 TI_DBG2(("ossaSSPAbortCB: did %d\n", oneDeviceData->id));
5073 ostiFreeMemory(
5074 tiRoot,
5075 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
5076 sizeof(tdIORequestBody_t)
5077 );
5078
5079 }
5080 else if (status == OSSA_IO_NOT_VALID)
5081 {
5082 TI_DBG1(("ossaSSPAbortCB: OSSA_IO_NOT_VALID\n"));
5083 /* clean up TD layer's IORequestBody */
5084 if (oneDeviceData->OSAbortAll == agTRUE)
5085 {
5086 oneDeviceData->OSAbortAll = agFALSE;
5087 ostiInitiatorEvent( tiRoot,
5088 agNULL,
5089 tiDeviceHandle,
5090 tiIntrEventTypeLocalAbort,
5091 tiAbortFailed,
5092 agNULL );
5093 }
5094 else
5095 {
5096 TI_DBG2(("ossaSSPAbortCB: calling saDeregisterDeviceHandle\n"));
5097 saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, tdsaRotateQnumber(tiRoot, oneDeviceData));
5098 }
5099 TI_DBG2(("ossaSSPAbortCB: did %d\n", oneDeviceData->id));
5100 ostiFreeMemory(
5101 tiRoot,
5102 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
5103 sizeof(tdIORequestBody_t)
5104 );
5105 }
5106 else if (status == OSSA_IO_NO_DEVICE)
5107 {
5108 TI_DBG1(("ossaSSPAbortCB: OSSA_IO_NO_DEVICE\n"));
5109 /* clean up TD layer's IORequestBody */
5110 if (oneDeviceData->OSAbortAll == agTRUE)
5111 {
5112 oneDeviceData->OSAbortAll = agFALSE;
5113 ostiInitiatorEvent( tiRoot,
5114 agNULL,
5115 tiDeviceHandle,
5116 tiIntrEventTypeLocalAbort,
5117 tiAbortInProgress,
5118 agNULL );
5119 }
5120 else
5121 {
5122 TI_DBG2(("ossaSSPAbortCB: calling saDeregisterDeviceHandle\n"));
5123 saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, tdsaRotateQnumber(tiRoot, oneDeviceData));
5124 }
5125 TI_DBG2(("ossaSSPAbortCB: did %d\n", oneDeviceData->id));
5126 ostiFreeMemory(
5127 tiRoot,
5128 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
5129 sizeof(tdIORequestBody_t)
5130 );
5131 }
5132 else if (status == OSSA_IO_ABORT_IN_PROGRESS)
5133 {
5134 TI_DBG1(("ossaSSPAbortCB: OSSA_IO_ABORT_IN_PROGRESS\n"));
5135 /* clean up TD layer's IORequestBody */
5136 if (oneDeviceData->OSAbortAll == agTRUE)
5137 {
5138 oneDeviceData->OSAbortAll = agFALSE;
5139 ostiInitiatorEvent( tiRoot,
5140 agNULL,
5141 tiDeviceHandle,
5142 tiIntrEventTypeLocalAbort,
5143 tiAbortInProgress,
5144 agNULL );
5145 }
5146 else
5147 {
5148 TI_DBG2(("ossaSSPAbortCB: calling saDeregisterDeviceHandle\n"));
5149 saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, tdsaRotateQnumber(tiRoot, oneDeviceData));
5150 }
5151 TI_DBG2(("ossaSSPAbortCB: did %d\n", oneDeviceData->id));
5152 ostiFreeMemory(
5153 tiRoot,
5154 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
5155 sizeof(tdIORequestBody_t)
5156 );
5157 }
5158 #ifdef REMOVED
5159 else if (status == OSSA_IO_ABORT_DELAYED)
5160 {
5161 TI_DBG1(("ossaSSPAbortCB: OSSA_IO_ABORT_DELAYED\n"));
5162 /* clean up TD layer's IORequestBody */
5163 if (oneDeviceData->OSAbortAll == agTRUE)
5164 {
5165 oneDeviceData->OSAbortAll = agFALSE;
5166 ostiInitiatorEvent( tiRoot,
5167 agNULL,
5168 tiDeviceHandle,
5169 tiIntrEventTypeLocalAbort,
5170 tiAbortDelayed,
5171 agNULL );
5172 }
5173 else
5174 {
5175 TI_DBG2(("ossaSSPAbortCB: calling saDeregisterDeviceHandle\n"));
5176 saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, tdsaRotateQnumber(tiRoot, oneDeviceData));
5177 }
5178 TI_DBG2(("ossaSSPAbortCB: did %d\n", oneDeviceData->id));
5179 ostiFreeMemory(
5180 tiRoot,
5181 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
5182 sizeof(tdIORequestBody_t)
5183 );
5184 }
5185 #endif
5186 else
5187 {
5188 TI_DBG1(("ossaSSPAbortCB: other status %d\n", status));
5189 /* clean up TD layer's IORequestBody */
5190 if (oneDeviceData->OSAbortAll == agTRUE)
5191 {
5192 oneDeviceData->OSAbortAll = agFALSE;
5193 ostiInitiatorEvent( tiRoot,
5194 agNULL,
5195 tiDeviceHandle,
5196 tiIntrEventTypeLocalAbort,
5197 tiAbortInProgress,
5198 agNULL );
5199 }
5200 else
5201 {
5202 TI_DBG2(("ossaSSPAbortCB: calling saDeregisterDeviceHandle\n"));
5203 saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, tdsaRotateQnumber(tiRoot, oneDeviceData));
5204 }
5205 TI_DBG2(("ossaSSPAbortCB: did %d\n", oneDeviceData->id));
5206 ostiFreeMemory(
5207 tiRoot,
5208 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
5209 sizeof(tdIORequestBody_t)
5210 );
5211 }
5212 }
5213 else if (flag == 0)
5214 {
5215 TI_DBG2(("ossaSSPAbortCB: abort one\n"));
5216 taskTag = tdAbortIORequestBody->tiIOToBeAbortedRequest;
5217
5218 if ( taskTag == agNULL)
5219 {
5220 TI_DBG1(("ossaSSPAbortCB: taskTag is NULL; triggered by itdssQueryTaskCompleted\n"));
5221 }
5222 if (status == OSSA_IO_SUCCESS)
5223 {
5224 TI_DBG2(("ossaSSPAbortCB: OSSA_IO_SUCCESS\n"));
5225 if (taskTag != agNULL)
5226 {
5227 ostiInitiatorEvent( tiRoot,
5228 agNULL,
5229 agNULL,
5230 tiIntrEventTypeLocalAbort,
5231 tiAbortOK,
5232 taskTag );
5233 }
5234 ostiFreeMemory(
5235 tiRoot,
5236 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
5237 sizeof(tdIORequestBody_t)
5238 );
5239
5240 }
5241 else if (status == OSSA_IO_NOT_VALID)
5242 {
5243 TI_DBG1(("ossaSSPAbortCB: OSSA_IO_NOT_VALID\n"));
5244
5245 if (taskTag != agNULL)
5246 {
5247 ostiInitiatorEvent( tiRoot,
5248 agNULL,
5249 agNULL,
5250 tiIntrEventTypeLocalAbort,
5251 tiAbortFailed,
5252 taskTag );
5253 }
5254 ostiFreeMemory(
5255 tiRoot,
5256 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
5257 sizeof(tdIORequestBody_t)
5258 );
5259 }
5260 else if (status == OSSA_IO_NO_DEVICE)
5261 {
5262 TI_DBG1(("ossaSSPAbortCB: OSSA_IO_NO_DEVICE\n"));
5263
5264 if (taskTag != agNULL)
5265 {
5266 ostiInitiatorEvent( tiRoot,
5267 agNULL,
5268 agNULL,
5269 tiIntrEventTypeLocalAbort,
5270 tiAbortInProgress,
5271 taskTag );
5272 }
5273 ostiFreeMemory(
5274 tiRoot,
5275 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
5276 sizeof(tdIORequestBody_t)
5277 );
5278 }
5279 else if (status == OSSA_IO_ABORT_IN_PROGRESS)
5280 {
5281 TI_DBG1(("ossaSSPAbortCB: OSSA_IO_ABORT_IN_PROGRESS\n"));
5282
5283 if (taskTag != agNULL)
5284 {
5285 ostiInitiatorEvent( tiRoot,
5286 agNULL,
5287 agNULL,
5288 tiIntrEventTypeLocalAbort,
5289 tiAbortInProgress,
5290 taskTag );
5291 }
5292 ostiFreeMemory(
5293 tiRoot,
5294 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
5295 sizeof(tdIORequestBody_t)
5296 );
5297 }
5298 #ifdef REMOVED
5299 else if (status == OSSA_IO_ABORT_DELAYED)
5300 {
5301 TI_DBG1(("ossaSSPAbortCB: OSSA_IO_ABORT_DELAYED\n"));
5302
5303 if (taskTag != agNULL)
5304 {
5305 ostiInitiatorEvent( tiRoot,
5306 agNULL,
5307 agNULL,
5308 tiIntrEventTypeLocalAbort,
5309 tiAbortDelayed,
5310 taskTag );
5311 }
5312 ostiFreeMemory(
5313 tiRoot,
5314 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
5315 sizeof(tdIORequestBody_t)
5316 );
5317 }
5318 #endif
5319 else
5320 {
5321 TI_DBG1(("ossaSSPAbortCB: other status %d\n", status));
5322
5323 if (taskTag != agNULL)
5324 {
5325 ostiInitiatorEvent( tiRoot,
5326 agNULL,
5327 agNULL,
5328 tiIntrEventTypeLocalAbort,
5329 tiAbortFailed,
5330 taskTag );
5331 }
5332 ostiFreeMemory(
5333 tiRoot,
5334 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
5335 sizeof(tdIORequestBody_t)
5336 );
5337 }
5338 }
5339 else
5340 {
5341 TI_DBG1(("ossaSSPAbortCB: wrong flag %d\n", flag));
5342 }
5343 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Ya");
5344 return;
5345
5346 }
5347 #endif
5348
5349
5350 #ifdef TARGET_DRIVER
ossaSSPAbortCB(agsaRoot_t * agRoot,agsaIORequest_t * agIORequest,bit32 flag,bit32 status)5351 osGLOBAL void ossaSSPAbortCB(
5352 agsaRoot_t *agRoot,
5353 agsaIORequest_t *agIORequest,
5354 bit32 flag,
5355 bit32 status)
5356 {
5357 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
5358 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
5359 tdIORequestBody_t *tdAbortIORequestBody;
5360 tdsaDeviceData_t *oneDeviceData;
5361 tiDeviceHandle_t *tiDeviceHandle;
5362
5363 TI_DBG3(("ossaSSPAbortCB: start\n"));
5364 tdAbortIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
5365
5366 if (flag == 2)
5367 {
5368 /* abort per port */
5369 TI_DBG2(("ossaSSPAbortCB: abort per port\n"));
5370 }
5371 else if (flag == 1)
5372 {
5373 TI_DBG2(("ossaSSPAbortCB: abort all\n"));
5374 tiDeviceHandle = (tiDeviceHandle_t *)tdAbortIORequestBody->tiDevHandle;
5375 oneDeviceData = (tdsaDeviceData_t *)tiDeviceHandle->tdData;
5376 if (status == OSSA_IO_SUCCESS)
5377 {
5378 TI_DBG2(("ossaSSPAbortCB: OSSA_IO_SUCCESS\n"));
5379 /* clean up TD layer's IORequestBody */
5380 TI_DBG3(("ossaSSPAbortCB: calling saDeregisterDeviceHandle\n"));
5381 saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, tdsaRotateQnumber(tiRoot, oneDeviceData));
5382 TI_DBG2(("ossaSSPAbortCB: did %d\n", oneDeviceData->id));
5383 ostiFreeMemory(
5384 tiRoot,
5385 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
5386 sizeof(tdIORequestBody_t)
5387 );
5388
5389 }
5390 else if (status == OSSA_IO_NOT_VALID)
5391 {
5392 TI_DBG1(("ossaSSPAbortCB: OSSA_IO_NOT_VALID\n"));
5393 /* clean up TD layer's IORequestBody */
5394 TI_DBG2(("ossaSSPAbortCB: calling saDeregisterDeviceHandle\n"));
5395 saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, tdsaRotateQnumber(tiRoot, oneDeviceData));
5396 TI_DBG2(("ossaSSPAbortCB: did %d\n", oneDeviceData->id));
5397 ostiFreeMemory(
5398 tiRoot,
5399 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
5400 sizeof(tdIORequestBody_t)
5401 );
5402 }
5403 else if (status == OSSA_IO_NO_DEVICE)
5404 {
5405 TI_DBG1(("ossaSSPAbortCB: OSSA_IO_NO_DEVICE\n"));
5406 /* clean up TD layer's IORequestBody */
5407 TI_DBG2(("ossaSSPAbortCB: calling saDeregisterDeviceHandle\n"));
5408 saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, tdsaRotateQnumber(tiRoot, oneDeviceData));
5409 TI_DBG2(("ossaSSPAbortCB: did %d\n", oneDeviceData->id));
5410 ostiFreeMemory(
5411 tiRoot,
5412 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
5413 sizeof(tdIORequestBody_t)
5414 );
5415 }
5416 else if (status == OSSA_IO_ABORT_IN_PROGRESS)
5417 {
5418 TI_DBG1(("ossaSSPAbortCB: OSSA_IO_ABORT_IN_PROGRESS\n"));
5419 /* clean up TD layer's IORequestBody */
5420 TI_DBG2(("ossaSSPAbortCB: calling saDeregisterDeviceHandle\n"));
5421 saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, tdsaRotateQnumber(tiRoot, oneDeviceData));
5422 TI_DBG2(("ossaSSPAbortCB: did %d\n", oneDeviceData->id));
5423 ostiFreeMemory(
5424 tiRoot,
5425 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
5426 sizeof(tdIORequestBody_t)
5427 );
5428 }
5429 #ifdef REMOVED
5430 else if (status == OSSA_IO_ABORT_DELAYED)
5431 {
5432 TI_DBG1(("ossaSSPAbortCB: OSSA_IO_ABORT_DELAYED\n"));
5433 /* clean up TD layer's IORequestBody */
5434 TI_DBG2(("ossaSSPAbortCB: calling saDeregisterDeviceHandle\n"));
5435 saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, tdsaRotateQnumber(tiRoot, oneDeviceData));
5436 TI_DBG2(("ossaSSPAbortCB: did %d\n", oneDeviceData->id));
5437 ostiFreeMemory(
5438 tiRoot,
5439 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
5440 sizeof(tdIORequestBody_t)
5441 );
5442 }
5443 #endif
5444 else
5445 {
5446 TI_DBG1(("ossaSSPAbortCB: other status %d\n", status));
5447 /* clean up TD layer's IORequestBody */
5448 TI_DBG2(("ossaSSPAbortCB: calling saDeregisterDeviceHandle\n"));
5449 saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, tdsaRotateQnumber(tiRoot, oneDeviceData));
5450 TI_DBG1(("ossaSSPAbortCB: did %d\n", oneDeviceData->id));
5451 ostiFreeMemory(
5452 tiRoot,
5453 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
5454 sizeof(tdIORequestBody_t)
5455 );
5456 }
5457 }
5458 else if (flag == 0)
5459 {
5460 TI_DBG2(("ossaSSPAbortCB: abort one\n"));
5461 if (status == OSSA_IO_SUCCESS)
5462 {
5463 TI_DBG2(("ossaSSPAbortCB: OSSA_IO_SUCCESS\n"));
5464 ostiFreeMemory(
5465 tiRoot,
5466 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
5467 sizeof(tdIORequestBody_t)
5468 );
5469
5470 }
5471 else if (status == OSSA_IO_NOT_VALID)
5472 {
5473 TI_DBG1(("ossaSSPAbortCB: OSSA_IO_NOT_VALID\n"));
5474 ostiFreeMemory(
5475 tiRoot,
5476 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
5477 sizeof(tdIORequestBody_t)
5478 );
5479 }
5480 else if (status == OSSA_IO_NO_DEVICE)
5481 {
5482 TI_DBG1(("ossaSSPAbortCB: OSSA_IO_NO_DEVICE\n"));
5483 ostiFreeMemory(
5484 tiRoot,
5485 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
5486 sizeof(tdIORequestBody_t)
5487 );
5488 }
5489 else if (status == OSSA_IO_ABORT_IN_PROGRESS)
5490 {
5491 TI_DBG1(("ossaSSPAbortCB: OSSA_IO_ABORT_IN_PROGRESS\n"));
5492 ostiFreeMemory(
5493 tiRoot,
5494 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
5495 sizeof(tdIORequestBody_t)
5496 );
5497 }
5498 #ifdef REMOVED
5499 else if (status == OSSA_IO_ABORT_DELAYED)
5500 {
5501 TI_DBG1(("ossaSSPAbortCB: OSSA_IO_ABORT_DELAYED\n"));
5502 ostiFreeMemory(
5503 tiRoot,
5504 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
5505 sizeof(tdIORequestBody_t)
5506 );
5507 }
5508 #endif
5509 else
5510 {
5511 TI_DBG1(("ossaSSPAbortCB: other status %d\n", status));
5512 ostiFreeMemory(
5513 tiRoot,
5514 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
5515 sizeof(tdIORequestBody_t)
5516 );
5517 }
5518 }
5519 else
5520 {
5521 TI_DBG1(("ossaSSPAbortCB: wrong flag %d\n", flag));
5522 }
5523
5524 return;
5525
5526 }
5527 #endif
5528
5529
5530 /*****************************************************************************/
5531 /*! \brief ossaLocalPhyControlCB
5532 *
5533 *
5534 * Purpose: This routine is called by lower layer to indicate the status of
5535 * phy operations
5536 *
5537 * \param agRoot: Pointer to chip/driver Instance.
5538 * \param phyId Phy id
5539 * \param phyOperation Operation to be done on the phy
5540 * \param status Phy operation specific completion status
5541 * \param parm Additional parameter, phy operation and status specific
5542 *
5543 *
5544 * \return None.
5545 *
5546 */
5547 /*****************************************************************************/
ossaLocalPhyControlCB(agsaRoot_t * agRoot,agsaContext_t * agContext,bit32 phyId,bit32 phyOperation,bit32 status,void * parm)5548 osGLOBAL void ossaLocalPhyControlCB(
5549 agsaRoot_t *agRoot,
5550 agsaContext_t *agContext,
5551 bit32 phyId,
5552 bit32 phyOperation,
5553 bit32 status,
5554 void *parm
5555 )
5556 {
5557 #ifdef REMVOED
5558 agsaPhyErrCounters_t *agPhyErrCounters;
5559 #endif
5560 #ifdef INITIATOR_DRIVER
5561 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
5562 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
5563 tiIORequest_t *currentTaskTag;
5564 tdsaDeviceData_t *TargetDeviceData;
5565 satDeviceData_t *pSatDevData;
5566 agsaDevHandle_t *agDevHandle = agNULL;
5567 agsaContext_t *agContextDevice;
5568 #endif
5569
5570 smTraceFuncEnter(hpDBG_VERY_LOUD,"Yb");
5571 TI_DBG3(("ossaLocalPhyControlCB: start phyID %d\n", phyId));
5572 TI_DBG3(("ossaLocalPhyControlCB: phyOperation %d status 0x%x\n", phyOperation, status));
5573 switch (phyOperation)
5574 {
5575 case AGSA_PHY_LINK_RESET: /* fall through */
5576 case AGSA_PHY_HARD_RESET:
5577 if (phyOperation == AGSA_PHY_LINK_RESET)
5578 {
5579 TI_DBG1(("ossaLocalPhyControlCB: AGSA_PHY_LINK_RESET, status 0x%x\n", status));
5580 }
5581 else
5582 {
5583 TI_DBG1(("ossaLocalPhyControlCB: AGSA_PHY_HARD_RESET, status 0x%x\n", status));
5584 }
5585 #ifdef INITIATOR_DRIVER
5586 if (agContext != agNULL)
5587 {
5588 currentTaskTag = (tiIORequest_t *)agContext->osData;
5589 if (status == OSSA_SUCCESS)
5590 {
5591 if (currentTaskTag != agNULL)
5592 {
5593 TI_DBG2(("ossaLocalPhyControlCB: callback to OS layer with success\n"));
5594 TargetDeviceData = (tdsaDeviceData_t *)currentTaskTag->tdData;
5595 pSatDevData = (satDeviceData_t *)&(TargetDeviceData->satDevData);
5596 agDevHandle = TargetDeviceData->agDevHandle;
5597 TI_DBG2(("ossaLocalPhyControlCB: satPendingIO %d satNCQMaxIO %d\n", pSatDevData->satPendingIO, pSatDevData->satNCQMaxIO ));
5598 TI_DBG2(("ossaLocalPhyControlCB: satPendingNCQIO %d satPendingNONNCQIO %d\n", pSatDevData->satPendingNCQIO, pSatDevData->satPendingNONNCQIO));
5599 pSatDevData->satDriveState = SAT_DEV_STATE_NORMAL;
5600
5601 if (TargetDeviceData->TRflag == agTRUE)
5602 {
5603 saSetDeviceState(agRoot, agNULL, tdsaRotateQnumber(tiRoot, TargetDeviceData), agDevHandle, SA_DS_OPERATIONAL);
5604 TargetDeviceData->TRflag = agFALSE;
5605 ostiInitiatorEvent(tiRoot,
5606 TargetDeviceData->tdPortContext->tiPortalContext,
5607 &(TargetDeviceData->tiDeviceHandle),
5608 tiIntrEventTypeTransportRecovery,
5609 tiRecOK,
5610 agNULL
5611 );
5612 }
5613 else
5614 {
5615 agDevHandle = TargetDeviceData->agDevHandle;
5616 if (agDevHandle == agNULL)
5617 {
5618 TI_DBG1(("ossaLocalPhyControlCB: wrong, agDevHandle is NULL\n"));
5619 }
5620 /* move this to OSSA_HW_EVENT_PORT_RESET_COMPLETE in ossaHwCB() */
5621 agContextDevice = &(TargetDeviceData->agDeviceResetContext);
5622 agContextDevice->osData = currentTaskTag;
5623
5624 #ifdef REMOVED
5625 ostiInitiatorEvent( tiRoot,
5626 NULL,
5627 NULL,
5628 tiIntrEventTypeTaskManagement,
5629 tiTMOK,
5630 currentTaskTag );
5631 #endif
5632 }
5633 }
5634 }
5635 else
5636 {
5637 if (currentTaskTag != agNULL)
5638 {
5639 TI_DBG1(("ossaLocalPhyControlCB: callback to OS layer with failure\n"));
5640 TargetDeviceData = (tdsaDeviceData_t *)currentTaskTag->tdData;
5641 pSatDevData = (satDeviceData_t *)&(TargetDeviceData->satDevData);
5642 TI_DBG1(("ossaLocalPhyControlCB: satPendingIO %d satNCQMaxIO %d\n", pSatDevData->satPendingIO, pSatDevData->satNCQMaxIO ));
5643 TI_DBG1(("ossaLocalPhyControlCB: satPendingNCQIO %d satPendingNONNCQIO %d\n", pSatDevData->satPendingNCQIO, pSatDevData->satPendingNONNCQIO));
5644 if (TargetDeviceData->TRflag == agTRUE)
5645 {
5646 TargetDeviceData->TRflag = agFALSE;
5647 ostiInitiatorEvent(tiRoot,
5648 TargetDeviceData->tdPortContext->tiPortalContext,
5649 &(TargetDeviceData->tiDeviceHandle),
5650 tiIntrEventTypeTransportRecovery,
5651 tiRecFailed ,
5652 agNULL
5653 );
5654 }
5655 else
5656 {
5657 ostiInitiatorEvent( tiRoot,
5658 NULL,
5659 NULL,
5660 tiIntrEventTypeTaskManagement,
5661 tiTMFailed,
5662 currentTaskTag );
5663 }
5664 }
5665 }
5666 }
5667 #endif
5668 break;
5669 #ifdef REMOVED
5670 case AGSA_PHY_GET_ERROR_COUNTS:
5671
5672 TI_DBG2(("ossaLocalPhyControlCB: AGSA_PHY_GET_ERROR_COUNTS, status 0x%x\n", status));
5673 if(parm !=agNULL )
5674 {
5675 agPhyErrCounters = (agsaPhyErrCounters_t *)parm;
5676 TI_DBG2(("ossaLocalPhyControlCB: invalidDword %d\n", agPhyErrCounters->invalidDword));
5677 TI_DBG2(("ossaLocalPhyControlCB: runningDisparityError %d\n", agPhyErrCounters->runningDisparityError));
5678 TI_DBG2(("ossaLocalPhyControlCB: lostOfDwordSynch %d\n", agPhyErrCounters->lossOfDwordSynch));
5679 TI_DBG2(("ossaLocalPhyControlCB: phyResetProblem %d\n", agPhyErrCounters->phyResetProblem));
5680 TI_DBG2(("ossaLocalPhyControlCB: elasticityBufferOverflow %d\n", agPhyErrCounters->elasticityBufferOverflow));
5681 TI_DBG2(("ossaLocalPhyControlCB: receivedErrorPrimitive %d\n", agPhyErrCounters->receivedErrorPrimitive));
5682 }
5683 break;
5684 case AGSA_PHY_CLEAR_ERROR_COUNTS:
5685 TI_DBG2(("ossaLocalPhyControlCB: AGSA_PHY_CLEAR_ERROR_COUNTS, status 0x%x\n", status));
5686 break;
5687 #endif
5688 case AGSA_PHY_NOTIFY_ENABLE_SPINUP:
5689 TI_DBG2(("ossaLocalPhyControlCB: AGSA_PHY_NOTIFY_ENABLE_SPINUP, status 0x%x\n", status));
5690 break;
5691 case AGSA_PHY_BROADCAST_ASYNCH_EVENT:
5692 TI_DBG2(("ossaLocalPhyControlCB: AGSA_PHY_BROADCAST_ASYNCH_EVENT, status 0x%x\n", status));
5693 if (tIsSPC12SATA(agRoot))
5694 {
5695 TI_DBG1(("ossaLocalPhyControlCB: BROADCAST_ASYNCH_EVENT received for SATA Controller\n"));
5696 break;
5697 }
5698 break;
5699 case AGSA_PHY_COMINIT_OOB :
5700 TI_DBG2(("ossaLocalPhyControlCB: AGSA_PHY_COMINIT_OOB, status 0x%x\n", status));
5701 break;
5702 default:
5703 TI_DBG1(("ossaLocalPhyControlCB: UNKNOWN default case. phyOperation %d status 0x%x\n", phyOperation, status));
5704 break;
5705 }
5706 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Yb");
5707 return;
5708 }
5709
ossaGetPhyProfileCB(agsaRoot_t * agRoot,agsaContext_t * agContext,bit32 status,bit32 ppc,bit32 phyID,void * parm)5710 GLOBAL void ossaGetPhyProfileCB(
5711 agsaRoot_t *agRoot,
5712 agsaContext_t *agContext,
5713 bit32 status,
5714 bit32 ppc,
5715 bit32 phyID,
5716 void *parm )
5717 {
5718
5719 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
5720 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
5721 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData;
5722 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
5723 #ifdef CCFLAGS_PHYCONTROL_COUNTS
5724 agsaPhyAnalogSettingsPage_t *analog;
5725 #endif /* CCFLAGS_PHYCONTROL_COUNTS */
5726 tdPhyCount_t *PhyBlob = agNULL;
5727
5728 agsaPhyBWCountersPage_t *agBWCounters;
5729 agsaPhyErrCountersPage_t *agPhyErrCounters;
5730 TI_DBG1(("ossaGetPhyProfileCB: agContext %p parm %p\n", agContext, parm));
5731 /*
5732 if( tdsaAllShared->tdFWControlEx.inProgress )
5733 {
5734 tdsaAllShared->tdFWControlEx.inProgress = 0;
5735 PhyBlob = (tdPhyCount_t *)tdsaAllShared->tdFWControlEx.usrAddr;
5736 }
5737 */
5738 switch(ppc)
5739 {
5740 case AGSA_SAS_PHY_BW_COUNTERS_PAGE:
5741 TI_DBG1(("ossaGetPhyProfileCB: AGSA_SAS_PHY_BW_COUNTERS_PAGE, status 0x%x phyID %d\n", status, phyID));
5742 if(parm !=agNULL )
5743 {
5744 agBWCounters = (agsaPhyBWCountersPage_t *)parm;
5745 TI_DBG1(("ossaGetPhyProfileCB: RX %d TX %d\n", agBWCounters->RXBWCounter,agBWCounters->TXBWCounter));
5746 if(PhyBlob !=agNULL )
5747 {
5748 PhyBlob->InvalidDword = 0;
5749 PhyBlob->runningDisparityError = 0;
5750 PhyBlob->codeViolation = 0;
5751 PhyBlob->phyResetProblem = 0;
5752 PhyBlob->inboundCRCError = 0;
5753 PhyBlob->BW_rx = agBWCounters->RXBWCounter;
5754 PhyBlob->BW_tx = agBWCounters->TXBWCounter;
5755 }
5756
5757 }
5758 break;
5759 case AGSA_SAS_PHY_ERR_COUNTERS_PAGE:
5760 if( tdsaAllShared->tdFWControlEx.inProgress )
5761 {
5762 tdsaAllShared->tdFWControlEx.inProgress = 0;
5763 PhyBlob = (tdPhyCount_t *)tdsaAllShared->tdFWControlEx.usrAddr;
5764 }
5765 TI_DBG1(("ossaGetPhyProfileCB: AGSA_SAS_PHY_ERR_COUNTERS_PAGE, status 0x%x phyID %d\n", status, phyID));
5766 if(parm !=agNULL )
5767 {
5768 agPhyErrCounters = (agsaPhyErrCountersPage_t *)parm;
5769 if(PhyBlob !=agNULL )
5770 {
5771
5772 PhyBlob->InvalidDword = agPhyErrCounters->invalidDword;
5773 PhyBlob->runningDisparityError = agPhyErrCounters->runningDisparityError;
5774 PhyBlob->LossOfSyncDW = agPhyErrCounters->lossOfDwordSynch;
5775 PhyBlob->codeViolation = agPhyErrCounters->codeViolation;
5776 PhyBlob->phyResetProblem = agPhyErrCounters->phyResetProblem;
5777 PhyBlob->inboundCRCError = agPhyErrCounters->inboundCRCError;
5778 PhyBlob->BW_rx = 0;
5779 PhyBlob->BW_tx = 0;
5780
5781 TI_DBG2(("ossaGetPhyProfileCB: invalidDword %d\n", agPhyErrCounters->invalidDword));
5782 TI_DBG2(("ossaGetPhyProfileCB: runningDisparityError %d\n", agPhyErrCounters->runningDisparityError));
5783 TI_DBG2(("ossaGetPhyProfileCB: lostOfDwordSynch %d\n", agPhyErrCounters->lossOfDwordSynch));
5784 TI_DBG2(("ossaGetPhyProfileCB: phyResetProblem %d\n", agPhyErrCounters->phyResetProblem));
5785 TI_DBG2(("ossaGetPhyProfileCB: inboundCRCError %d\n", agPhyErrCounters->inboundCRCError));
5786 }
5787 }
5788 break;
5789 case AGSA_SAS_PHY_ERR_COUNTERS_CLR_PAGE:
5790 TI_DBG1(("ossaGetPhyProfileCB: AGSA_SAS_PHY_ERR_COUNTERS_CLR_PAGE status 0x%x phyID %d\n", status, phyID));
5791 break;
5792 case AGSA_SAS_PHY_ANALOG_SETTINGS_PAGE:
5793 TI_DBG1(("ossaGetPhyProfileCB:AGSA_SAS_PHY_ANALOG_SETTINGS_PAGE status 0x%x phyID %d\n", status, phyID));
5794 #ifdef CCFLAGS_PHYCONTROL_COUNTS
5795 if(parm !=agNULL )
5796 {
5797 analog = (agsaPhyAnalogSettingsPage_t *)parm;
5798 TI_DBG1(("ossaGetPhyProfileCB: 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n",
5799 analog->Dword0, analog->Dword1, analog->Dword2, analog->Dword3, analog->Dword4,
5800 analog->Dword5, analog->Dword6, analog->Dword7, analog->Dword8, analog->Dword9));
5801 tdsaAllShared->analog[phyID].spaRegister0 = analog->Dword0;
5802 tdsaAllShared->analog[phyID].spaRegister1 = analog->Dword1;
5803 tdsaAllShared->analog[phyID].spaRegister2 = analog->Dword2;
5804 tdsaAllShared->analog[phyID].spaRegister3 = analog->Dword3;
5805 tdsaAllShared->analog[phyID].spaRegister4 = analog->Dword4;
5806 saSetPhyProfile( agRoot,agContext,tdsaRotateQnumber(tiRoot, agNULL), AGSA_SAS_PHY_ANALOG_SETTINGS_PAGE,sizeof(agsaPhyAnalogSetupRegisters_t),&tdsaAllShared->analog[phyID],phyID);
5807 }
5808 #endif /* CCFLAGS_PHYCONTROL_COUNTS */
5809 break;
5810 case AGSA_SAS_PHY_OPEN_REJECT_RETRY_BACKOFF_THRESHOLD_PAGE:
5811 {
5812 TI_DBG1(("ossaGetPhyProfileCB:AGSA_SAS_PHY_OPEN_REJECT_RETRY_BACKOFF_THRESHOLD_PAGE status 0x%x phyID %d\n", status, phyID));
5813 if( parm !=agNULL )
5814 {
5815 #ifdef TD_DEBUG_ENABLE
5816 agsaSASPhyOpenRejectRetryBackOffThresholdPage_t *Backoff =
5817 (agsaSASPhyOpenRejectRetryBackOffThresholdPage_t *)parm;
5818 #endif
5819 TI_DBG2(("ossaGetPhyProfileCB: DW0 0x%X DW1 0x%X DW2 0x%X DW3 0x%X\n",
5820 Backoff->Dword0,Backoff->Dword1,
5821 Backoff->Dword2,Backoff->Dword3));
5822 }
5823 break;
5824 }
5825
5826 case AGSA_SAS_PHY_GENERAL_STATUS_PAGE:
5827 {
5828 agsaSASPhyGeneralStatusPage_t * GenStatus = NULL;
5829
5830 TI_DBG1(("ossaGetPhyProfileCB: AGSA_SAS_PHY_GENERAL_STATUS_PAGE status 0x%x phyID %d\n",
5831 status, phyID));
5832 if( parm !=agNULL )
5833 {
5834 GenStatus=
5835 (agsaSASPhyGeneralStatusPage_t *)parm;
5836 TI_DBG2(("ossaGetPhyProfileCB: "
5837 "AGSA_SAS_PHY_GENERAL_STATUS_PAGE status %d DW0 0x%x DW1 0x%x\n",
5838 status, GenStatus->Dword0, GenStatus->Dword1));
5839 }
5840 ostiGetPhyGeneralStatusRsp(tiRoot, GenStatus, phyID);
5841 // break;
5842 return ;
5843 }
5844
5845 default:
5846 TI_DBG1(("ossaGetPhyProfileCB: UNKNOWN default case. phyOperation %d status 0x%x\n", ppc, status));
5847 break;
5848
5849 }
5850
5851 ostiGetPhyProfileIOCTLRsp(tiRoot, status);
5852
5853 }
5854
5855
ossaSetPhyProfileCB(agsaRoot_t * agRoot,agsaContext_t * agContext,bit32 status,bit32 ppc,bit32 phyID,void * parm)5856 GLOBAL void ossaSetPhyProfileCB(
5857 agsaRoot_t *agRoot,
5858 agsaContext_t *agContext,
5859 bit32 status,
5860 bit32 ppc,
5861 bit32 phyID,
5862 void *parm )
5863 {
5864 TI_DBG1(("ossaSetPhyProfileCB:agContext %p status 0x%x ppc %d phyID %d parm %p\n",agContext, status, ppc, phyID,parm));
5865 }
5866
5867
5868 /*****************************************************************************/
5869 /*! \brief ossaGetDeviceHandlesCB
5870 *
5871 *
5872 * Purpose: This routine is called by lower layer to corresponding to
5873 * saGetDeviceHandles()
5874 *
5875 * \param agRoot: Pointer to chip/driver Instance.
5876 * \param agContext: Context of the get device handle request originally passed into
5877 * saGetDeviceHandles().
5878 * \param agPortContext:Pointer to this instance of a port context
5879 * \param agDev: Array containing pointers to the device handles
5880
5881 * \param validDevs Number of valid device handles
5882 *
5883 *
5884 * \return None.
5885 *
5886 * \note - The scope is shared target and initiator.
5887 * For details, refer to SAS/SATA Low-Level API Specification
5888 */
5889 /*****************************************************************************/
ossaGetDeviceHandlesCB(agsaRoot_t * agRoot,agsaContext_t * agContext,agsaPortContext_t * agPortContext,agsaDevHandle_t * agDev[],bit32 validDevs)5890 osGLOBAL void ossaGetDeviceHandlesCB(
5891 agsaRoot_t *agRoot,
5892 agsaContext_t *agContext,
5893 agsaPortContext_t *agPortContext,
5894 agsaDevHandle_t *agDev[],
5895 bit32 validDevs
5896 )
5897 {
5898 TI_DBG2(("ossaGetDeviceHandlesCB: start\n"));
5899 TI_DBG2(("ossaGetDeviceHandlesCB: validDevs %d\n", validDevs));
5900 smTraceFuncEnter(hpDBG_VERY_LOUD,"Yc");
5901 #ifdef TO_DO
5902 for (i = 0 ; i < validDevs ; i++)
5903 {
5904 agDev[i];
5905 }
5906 #endif
5907 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Yc");
5908 return;
5909 }
5910
5911 /*****************************************************************************/
5912 /*! \brief ossaGetDeviceInfoCB
5913 *
5914 *
5915 * Purpose: This routine is called by lower layer to corresponding to
5916 * saGetDeviceInfo()
5917 *
5918 * \param agRoot: Pointer to chip/driver Instance.
5919 * \param agDevHandle: Handle of the device
5920 * \param status: status
5921 * \param agInfo: Pointer to the structure that describes device information
5922 *
5923 *
5924 * \return None.
5925 *
5926 * \note - The scope is shared target and initiator.
5927 * For details, refer to SAS/SATA Low-Level API Specification
5928 */
5929 /*****************************************************************************/
ossaGetDeviceInfoCB(agsaRoot_t * agRoot,agsaContext_t * agContext,agsaDevHandle_t * agDevHandle,bit32 status,void * agInfo)5930 osGLOBAL void ossaGetDeviceInfoCB(
5931 agsaRoot_t *agRoot,
5932 agsaContext_t *agContext,
5933 agsaDevHandle_t *agDevHandle,
5934 bit32 status,
5935 void *agInfo
5936 )
5937 {
5938
5939 #ifdef TD_DEBUG_ENABLE
5940 agsaDeviceInfo_t *agDeviceInfo;
5941 agsaSASDeviceInfo_t *agSASDeviceInfo;
5942 agsaSATADeviceInfo_t *agSATADeviceInfo;
5943 #endif
5944 smTraceFuncEnter(hpDBG_VERY_LOUD,"Yd");
5945
5946 TI_DBG1(("ossaGetDeviceInfoCB: start agContext %p\n",agContext));
5947 switch (status)
5948 {
5949 case OSSA_DEV_INFO_INVALID_HANDLE:
5950 TI_DBG1(("ossaGetDeviceInfoCB: OSSA_DEV_INFO_INVALID_HANDLE\n"));
5951 /*ostiGetDeviceInfoIOCTLRsp(tiRoot, status, agNULL);*/
5952 break;
5953 case OSSA_DEV_INFO_NO_EXTENDED_INFO:
5954 #ifdef TD_DEBUG_ENABLE
5955 agDeviceInfo = (agsaDeviceInfo_t *)agInfo;
5956 #endif
5957 TI_DBG1(("ossaGetDeviceInfoCB: OSSA_DEV_INFO_NO_EXTENDED_INFO\n"));
5958 TI_DBG1(("ossaGetDeviceInfoCB: sasAddressHi 0x%08x\n", SA_DEVINFO_GET_SAS_ADDRESSHI(agDeviceInfo)));
5959 TI_DBG1(("ossaGetDeviceInfoCB: sasAddressLo 0x%08x\n", SA_DEVINFO_GET_SAS_ADDRESSLO(agDeviceInfo)));
5960 TI_DBG1(("ossaGetDeviceInfoCB: devType_S_Rate 0x%08x\n", agDeviceInfo->devType_S_Rate));
5961 TI_DBG1(("ossaGetDeviceInfoCB: firstBurstSize 0x%08x\n", agDeviceInfo->firstBurstSize));
5962
5963 /*ostiPortEvent (tiRoot, tiGetDevInfo, tiSuccess,(void *)agContext );*/
5964 /*ostiGetDeviceInfoIOCTLRsp(tiRoot, status, agDeviceInfo);*/
5965 break;
5966 case OSSA_DEV_INFO_SAS_EXTENDED_INFO:
5967 #ifdef TD_DEBUG_ENABLE
5968 agSASDeviceInfo = (agsaSASDeviceInfo_t *)agInfo;
5969 #endif
5970 TI_DBG2(("ossaGetDeviceInfoCB: OSSA_DEV_INFO_SAS_EXTENDED_INFO\n"));
5971 TI_DBG2(("ossaGetDeviceInfoCB: sasAddressHi 0x%08x\n", SA_DEVINFO_GET_SAS_ADDRESSHI(&agSASDeviceInfo->commonDevInfo)));
5972 TI_DBG2(("ossaGetDeviceInfoCB: sasAddressLo 0x%08x\n", SA_DEVINFO_GET_SAS_ADDRESSLO(&agSASDeviceInfo->commonDevInfo)));
5973 TI_DBG2(("ossaGetDeviceInfoCB: initiator_ssp_stp_smp %d\n", agSASDeviceInfo->initiator_ssp_stp_smp));
5974 TI_DBG2(("ossaGetDeviceInfoCB: target_ssp_stp_smp %d\n", agSASDeviceInfo->target_ssp_stp_smp));
5975 TI_DBG2(("ossaGetDeviceInfoCB: numOfPhys %d\n", agSASDeviceInfo->numOfPhys));
5976 TI_DBG2(("ossaGetDeviceInfoCB: phyIdentifier %d\n", agSASDeviceInfo->phyIdentifier));
5977
5978 break;
5979 case OSSA_DEV_INFO_SATA_EXTENDED_INFO:
5980 #ifdef TD_DEBUG_ENABLE
5981 agSATADeviceInfo = (agsaSATADeviceInfo_t *)agInfo;
5982 #endif
5983 TI_DBG2(("ossaGetDeviceInfoCB: OSSA_DEV_INFO_SATA_EXTENDED_INFO\n"));
5984 TI_DBG2(("ossaGetDeviceInfoCB: sasAddressHi 0x%08x\n", SA_DEVINFO_GET_SAS_ADDRESSHI(&agSATADeviceInfo->commonDevInfo)));
5985 TI_DBG2(("ossaGetDeviceInfoCB: sasAddressLo 0x%08x\n", SA_DEVINFO_GET_SAS_ADDRESSLO(&agSATADeviceInfo->commonDevInfo)));
5986 TI_DBG2(("ossaGetDeviceInfoCB: connection %d\n", agSATADeviceInfo->connection));
5987 TI_DBG2(("ossaGetDeviceInfoCB: portMultiplierField %d\n", agSATADeviceInfo->portMultiplierField));
5988 TI_DBG2(("ossaGetDeviceInfoCB: stpPhyIdentifier %d\n", agSATADeviceInfo->stpPhyIdentifier));
5989 #ifdef TD_DEBUG_ENABLE
5990 tdhexdump("ossaGetDeviceInfoCB: signature", (bit8 *)agSATADeviceInfo->signature, 8);
5991 #endif
5992 break;
5993 default:
5994 TI_DBG2(("ossaGetDeviceInfoCB: error default case, status is %d\n", status));
5995 break;
5996 }
5997 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Yd");
5998 return;
5999 }
6000
6001 /*****************************************************************************/
6002 /*! \brief ossaDeviceRegistrationCB
6003 *
6004 *
6005 * Purpose: This routine is called by lower layer to corresponding to
6006 * saRegisterNewDevice()
6007 *
6008 * \param agRoot: Pointer to chip/driver Instance.
6009 * \param agContext: Context of the get device handle request originally
6010 * passed into saRegisterNewDevice().
6011 * \param status: status
6012 * \param agDevHandle: Pointer to the assigned device handle for the
6013 * registered device.
6014 *
6015 *
6016 * \return None.
6017 *
6018 */
6019 /*****************************************************************************/
ossaDeviceRegistrationCB(agsaRoot_t * agRoot,agsaContext_t * agContext,bit32 status,agsaDevHandle_t * agDevHandle,bit32 deviceID)6020 osGLOBAL void ossaDeviceRegistrationCB(
6021 agsaRoot_t *agRoot,
6022 agsaContext_t *agContext,
6023 bit32 status,
6024 agsaDevHandle_t *agDevHandle,
6025 bit32 deviceID
6026 )
6027 {
6028 #ifdef INITIATOR_DRIVER
6029 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
6030 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
6031 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData;
6032 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
6033 bit32 Indenom = tdsaAllShared->QueueConfig.numInboundQueues;
6034 bit32 Outdenom = tdsaAllShared->QueueConfig.numOutboundQueues;
6035 tdsaDeviceData_t *oneDeviceData = (tdsaDeviceData_t *)agContext->osData;
6036 tdsaPortContext_t *onePortContext = oneDeviceData->tdPortContext;
6037 tiPortalContext_t *tiPortalContext = onePortContext->tiPortalContext;
6038 #ifdef FDS_DM
6039 dmRoot_t *dmRoot = &(tdsaAllShared->dmRoot);
6040 dmPortContext_t *dmPortContext = &(onePortContext->dmPortContext);
6041 dmDeviceInfo_t dmDeviceInfo;
6042 bit32 DMstatus = DM_RC_FAILURE;
6043 bit16 ext = 0;
6044 bit32 expanderType = 1;
6045 #endif
6046
6047 #if defined(FDS_DM) && !defined(FDS_SM)
6048 bit32 IDstatus;
6049 #endif
6050
6051 #ifdef FDS_SM
6052 smRoot_t *smRoot = &(tdsaAllShared->smRoot);
6053 bit32 SMstatus = SM_RC_FAILURE;
6054 #endif
6055 smTraceFuncEnter(hpDBG_VERY_LOUD,"Ye");
6056 TI_DBG3(("ossaDeviceRegistrationCB: start status 0x%x\n",status));
6057 TI_DBG3(("ossaDeviceRegistrationCB: device AddrHi 0x%08x\n", oneDeviceData->SASAddressID.sasAddressHi));
6058 TI_DBG3(("ossaDeviceRegistrationCB: device AddrLo 0x%08x\n", oneDeviceData->SASAddressID.sasAddressLo));
6059 TI_DBG3(("ossaDeviceRegistrationCB: did 0x%x\n", oneDeviceData->id));
6060 TI_DBG3(("ossaDeviceRegistrationCB: deviceID 0x%x\n", deviceID));
6061 TI_DBG3(("ossaDeviceRegistrationCB: agDevHandle %p %p %p\n",agDevHandle,agDevHandle->osData,agDevHandle->sdkData ));
6062
6063 /* transient period caused by tdssReportRemovals(), device was in the middle
6064 of registration but port is invalidated
6065 */
6066 if (oneDeviceData->valid == agFALSE && oneDeviceData->valid2 == agFALSE
6067 && oneDeviceData->DeviceType == TD_DEFAULT_DEVICE)
6068 {
6069 if (status == OSSA_SUCCESS)
6070 {
6071 TI_DBG2(("ossaDeviceRegistrationCB: transient, calling saDeregisterDeviceHandle, did %d\n", oneDeviceData->id));
6072 oneDeviceData->agDevHandle = agDevHandle;
6073 agDevHandle->osData = oneDeviceData;
6074 if (DEVICE_IS_SATA_DEVICE(oneDeviceData) || DEVICE_IS_STP_TARGET(oneDeviceData))
6075 {
6076 if (oneDeviceData->satDevData.IDDeviceValid == agFALSE)
6077 {
6078 saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, 0);
6079 }
6080 else
6081 {
6082 saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, tdsaRotateQnumber(tiRoot, oneDeviceData));
6083 }
6084 }
6085 else
6086 {
6087 saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, tdsaRotateQnumber(tiRoot, oneDeviceData));
6088 }
6089 }
6090 else if (status == OSSA_FAILURE_PORT_NOT_VALID_STATE || status == OSSA_ERR_PORT_STATE_NOT_VALID)
6091 {
6092 /* do nothing */
6093 TI_DBG2(("ossaDeviceRegistrationCB: transient, do nothing did %d\n", oneDeviceData->id));
6094 }
6095 return;
6096 }
6097
6098 if (agDevHandle == agNULL)
6099 {
6100 TI_DBG3(("ossaDeviceRegistrationCB: agDevHandle is NULL\n"));
6101 }
6102 else
6103 {
6104 TI_DBG3(("ossaDeviceRegistrationCB: agDevHandle is NOT NULL\n"));
6105 }
6106
6107 switch (status)
6108 {
6109 case OSSA_SUCCESS:
6110 TI_DBG3(("ossaDeviceRegistrationCB: success\n"));
6111 TI_DBG2(("ossaDeviceRegistrationCB: Success did %d FW did 0x%x\n", oneDeviceData->id, deviceID));
6112 TI_DBG2(("ossaDeviceRegistrationCB: Success pid %d\n", onePortContext->id));
6113 if (agDevHandle == agNULL)
6114 {
6115 TI_DBG1(("ossaDeviceRegistrationCB: agDevHandle is NULL, wrong!\n"));
6116 return;
6117 }
6118 oneDeviceData->agDevHandle = agDevHandle;
6119 agDevHandle->osData = oneDeviceData;
6120 oneDeviceData->registered = agTRUE;
6121 oneDeviceData->InQID = oneDeviceData->id % Indenom;
6122 oneDeviceData->OutQID = oneDeviceData->id % Outdenom;
6123 onePortContext->RegisteredDevNums++;
6124
6125 TI_DBG3(("ossaDeviceRegistrationCB: direct %d STP target %d target_ssp_stp_smp %d\n", oneDeviceData->directlyAttached, DEVICE_IS_STP_TARGET(oneDeviceData), oneDeviceData->target_ssp_stp_smp));
6126 TI_DBG3(("ossaDeviceRegistrationCB: pid %d registeredNumDevice %d\n", onePortContext->id, onePortContext->RegisteredDevNums));
6127 TI_DBG3(("ossaDeviceRegistrationCB: pid %d Count %d\n", onePortContext->id, onePortContext->Count));
6128
6129 #ifdef FDS_DM
6130 /* if device is an expander, register it to DM */
6131 if (onePortContext->valid == agTRUE)
6132 {
6133 if (DEVICE_IS_SMP_TARGET(oneDeviceData))
6134 {
6135 TI_DBG1(("ossaDeviceRegistrationCB: calling dmRegisterDevice\n"));
6136 TI_DBG1(("ossaDeviceRegistrationCB: device AddrHi 0x%08x\n", oneDeviceData->SASAddressID.sasAddressHi));
6137 TI_DBG1(("ossaDeviceRegistrationCB: device AddrLo 0x%08x\n", oneDeviceData->SASAddressID.sasAddressLo));
6138 /* set up dmDeviceInfo */
6139 osti_memset(&dmDeviceInfo, 0, sizeof(dmDeviceInfo_t));
6140 DEVINFO_PUT_SAS_ADDRESSLO(&dmDeviceInfo, oneDeviceData->SASAddressID.sasAddressLo);
6141 DEVINFO_PUT_SAS_ADDRESSHI(&dmDeviceInfo, oneDeviceData->SASAddressID.sasAddressHi);
6142 dmDeviceInfo.initiator_ssp_stp_smp = oneDeviceData->initiator_ssp_stp_smp;
6143 dmDeviceInfo.target_ssp_stp_smp = oneDeviceData->target_ssp_stp_smp;
6144 dmDeviceInfo.devType_S_Rate = oneDeviceData->agDeviceInfo.devType_S_Rate;
6145 if (oneDeviceData->directlyAttached == agTRUE)
6146 {
6147 /* setting SMP bit */
6148 ext = (bit16)(ext | 0x100);
6149 expanderType = SA_IDFRM_GET_DEVICETTYPE(&onePortContext->sasIDframe);
6150 ext = (bit16)( ext | (expanderType << 9));
6151 /* setting MCN field to 0xF */
6152 ext = (bit16)(ext | (bit16)(0xF << 11));
6153 TI_DBG1(("ossaDeviceRegistrationCB: directlyAttached ext 0x%x\n", ext));
6154 dmDeviceInfo.ext = ext;
6155 }
6156 DMstatus = dmRegisterDevice(dmRoot, dmPortContext, &dmDeviceInfo, oneDeviceData->agDevHandle);
6157 if (DMstatus != DM_RC_SUCCESS)
6158 {
6159 TI_DBG1(("ossaDeviceRegistrationCB: dmRegisterDevice failed!!! 0x%x\n", DMstatus));
6160 }
6161 }
6162 }
6163 #endif /* FDS_DM */
6164 #ifdef FDS_SM
6165 /* if device is SATA, register it to SM */
6166 if (onePortContext->valid == agTRUE)
6167 {
6168 if (DEVICE_IS_SATA_DEVICE(oneDeviceData) || DEVICE_IS_STP_TARGET(oneDeviceData))
6169 {
6170 TI_DBG1(("ossaDeviceRegistrationCB: calling smRegisterDevice\n"));
6171 if (oneDeviceData->directlyAttached == agTRUE)
6172 {
6173 SMstatus = smRegisterDevice(smRoot,
6174 agDevHandle,
6175 &(oneDeviceData->smDeviceHandle),
6176 agNULL,
6177 (bit32)oneDeviceData->phyID,
6178 oneDeviceData->satDevData.satDeviceType);
6179 }
6180 else
6181 {
6182 if (oneDeviceData->ExpDevice == agNULL)
6183 {
6184 TI_DBG1(("ossaDeviceRegistrationCB: oneDeviceData->ExpDevice NULL!!!\n"));
6185 return;
6186 }
6187 if (oneDeviceData->ExpDevice->agDevHandle == agNULL)
6188 {
6189 TI_DBG1(("ossaDeviceRegistrationCB: oneDeviceData->ExpDevice->agDevHandle NULL!!!\n"));
6190 }
6191 SMstatus = smRegisterDevice(smRoot,
6192 agDevHandle,
6193 &(oneDeviceData->smDeviceHandle),
6194 oneDeviceData->ExpDevice->agDevHandle,
6195 (bit32)oneDeviceData->phyID,
6196 oneDeviceData->satDevData.satDeviceType);
6197 }
6198 if (SMstatus != SM_RC_SUCCESS)
6199 {
6200 TI_DBG1(("ossaDeviceRegistrationCB: smRegisterDevice failed!!! 0x%x\n", DMstatus));
6201 }
6202 }
6203 }
6204 #endif /* FDS_SM */
6205 /* special case for directly attached targets */
6206 if (oneDeviceData->directlyAttached == agTRUE)
6207 {
6208 TI_DBG3(("ossaDeviceRegistrationCB: directly attached did %d\n", oneDeviceData->id));
6209 if (oneDeviceData->DeviceType == TD_SAS_DEVICE)
6210 {
6211 TI_DBG3(("ossaDeviceRegistrationCB: SAS target\n"));
6212 if (onePortContext->valid == agTRUE)
6213 {
6214 if (onePortContext->PortRecoverPhyID != 0xFF)
6215 {
6216 oneDeviceData->phyID = (bit8)onePortContext->PortRecoverPhyID;
6217 onePortContext->PortRecoverPhyID = 0xFF;
6218 TI_DBG3(("ossaDeviceRegistrationCB: PortRecoverPhyID %d\n", oneDeviceData->phyID));
6219 }
6220 /* link up and discovery ready event */
6221 if (onePortContext->DiscoveryRdyGiven == agFALSE)
6222 {
6223 TI_DBG2(("ossaDeviceRegistrationCB: link up and discovery ready\n"));
6224 TI_DBG3(("ossaDeviceRegistrationCB: phyID %d pid %d\n", oneDeviceData->phyID, onePortContext->id));
6225 TI_DBG3(("ossaDeviceRegistrationCB: tiPortalContext %p\n", tdsaAllShared->Ports[oneDeviceData->phyID].tiPortalContext));
6226 TI_DBG3(("ossaDeviceRegistrationCB: onePortContext->tiPortalContext %p\n", onePortContext->tiPortalContext));
6227 onePortContext->DiscoveryRdyGiven = agTRUE;
6228 if (onePortContext->DiscoveryState != ITD_DSTATE_NOT_STARTED)
6229 {
6230 TI_DBG1(("ossaDeviceRegistrationCB: wrong discovery state 0x%x\n", onePortContext->DiscoveryState));
6231 }
6232 /* notifying link up */
6233 ostiPortEvent (
6234 tiRoot,
6235 tiPortLinkUp,
6236 tiSuccess,
6237 (void *)onePortContext->tiPortalContext
6238 );
6239 #ifdef INITIATOR_DRIVER
6240 /* triggers discovery */
6241 ostiPortEvent(
6242 tiRoot,
6243 tiPortDiscoveryReady,
6244 tiSuccess,
6245 (void *)onePortContext->tiPortalContext
6246 );
6247 #endif
6248 }
6249 }
6250 else
6251 {
6252 TI_DBG2(("ossaDeviceRegistrationCB: abort call\n"));
6253 /* abort all followed by deregistration of sas target */
6254 tdsaAbortAll(tiRoot, agRoot, oneDeviceData);
6255 }
6256 }
6257 else
6258 {
6259 TI_DBG2(("ossaDeviceRegistrationCB: SATA target\n"));
6260 if (onePortContext->valid == agTRUE)
6261 {
6262 if (oneDeviceData->satDevData.IDDeviceValid == agFALSE)
6263 {
6264 #ifdef FDS_SM
6265 /* send identify device data */
6266 tdIDStart(tiRoot, agRoot, smRoot, oneDeviceData, onePortContext);
6267
6268 #else
6269 /* send identify device data */
6270 tdssSubAddSATAToSharedcontext(tiRoot, oneDeviceData);
6271 #endif
6272 }
6273 }
6274 else
6275 {
6276 TI_DBG2(("ossaDeviceRegistrationCB: abort call\n"));
6277 /* abort all followed by deregistration of sas target */
6278 tdsaAbortAll(tiRoot, agRoot, oneDeviceData);
6279 }
6280 }
6281 }
6282 else /* behind the expander */
6283 {
6284 #if defined(FDS_DM) && defined(FDS_SM)
6285 /* send ID to SATA targets
6286 needs go allocate tdIORequestBody_t for smIORequest
6287 */
6288
6289 if ( (DEVICE_IS_SATA_DEVICE(oneDeviceData) || DEVICE_IS_STP_TARGET(oneDeviceData))
6290 &&
6291 oneDeviceData->satDevData.IDDeviceValid == agFALSE)
6292 {
6293 tdIDStart(tiRoot, agRoot, smRoot, oneDeviceData, onePortContext);
6294 }
6295
6296 #elif defined(FDS_DM) /* worked with DM */
6297 if ( (DEVICE_IS_SATA_DEVICE(oneDeviceData) || DEVICE_IS_STP_TARGET(oneDeviceData))
6298 &&
6299 oneDeviceData->satDevData.IDDeviceValid == agFALSE)
6300 {
6301 IDstatus = tdsaDiscoveryStartIDDev(tiRoot,
6302 agNULL,
6303 &(oneDeviceData->tiDeviceHandle),
6304 agNULL,
6305 oneDeviceData);
6306
6307 if (IDstatus != tiSuccess)
6308 {
6309 /* identify device data is not valid */
6310 TI_DBG1(("ossaDeviceRegistrationCB: fail or busy %d\n", IDstatus));
6311 oneDeviceData->satDevData.IDDeviceValid = agFALSE;
6312 }
6313 }
6314 #endif
6315
6316
6317 }
6318 /* after discovery is finished */
6319 if (onePortContext->DiscoveryState == ITD_DSTATE_COMPLETED)
6320 {
6321 TI_DBG2(("ossaDeviceRegistrationCB: calling new device arrival\n"));
6322 if (DEVICE_IS_SSP_TARGET(oneDeviceData))
6323 {
6324 /* in case registration is finished after discovery is finished */
6325 #ifdef AGTIAPI_CTL
6326 if (tdsaAllShared->SASConnectTimeLimit)
6327 tdsaCTLSet(tiRoot, onePortContext, tiIntrEventTypeDeviceChange,
6328 tiDeviceArrival);
6329 else
6330 #endif
6331 ostiInitiatorEvent(
6332 tiRoot,
6333 tiPortalContext,
6334 agNULL,
6335 tiIntrEventTypeDeviceChange,
6336 tiDeviceArrival,
6337 agNULL
6338 );
6339 }
6340 else if ( (DEVICE_IS_SATA_DEVICE(oneDeviceData) || DEVICE_IS_STP_TARGET(oneDeviceData))
6341 &&
6342 oneDeviceData->satDevData.IDDeviceValid == agTRUE )
6343 {
6344 /* in case registration is finished after discovery is finished */
6345 ostiInitiatorEvent(
6346 tiRoot,
6347 tiPortalContext,
6348 agNULL,
6349 tiIntrEventTypeDeviceChange,
6350 tiDeviceArrival,
6351 agNULL
6352 );
6353 }
6354 }
6355 break;
6356 case OSSA_FAILURE_OUT_OF_RESOURCE: /* fall through */
6357 case OSSA_ERR_DEVICE_HANDLE_UNAVAILABLE:
6358 TI_DBG1(("ossaDeviceRegistrationCB: OSSA_FAILURE_OUT_OF_RESOURCE or OSSA_ERR_DEVICE_HANDLE_UNAVAILABLE\n"));
6359 oneDeviceData->registered = agFALSE;
6360 break;
6361 case OSSA_FAILURE_DEVICE_ALREADY_REGISTERED: /* fall through */
6362 case OSSA_ERR_DEVICE_ALREADY_REGISTERED:
6363 /* do nothing */
6364 TI_DBG1(("ossaDeviceRegistrationCB: OSSA_FAILURE_DEVICE_ALREADY_REGISTERED or OSSA_ERR_DEVICE_ALREADY_REGISTERED\n"));
6365 break;
6366 case OSSA_FAILURE_INVALID_PHY_ID: /* fall through */
6367 case OSSA_ERR_PHY_ID_INVALID:
6368 TI_DBG1(("ossaDeviceRegistrationCB: OSSA_FAILURE_INVALID_PHY_ID or OSSA_ERR_PHY_ID_INVALID\n"));
6369 oneDeviceData->registered = agFALSE;
6370 break;
6371 case OSSA_FAILURE_PHY_ID_ALREADY_REGISTERED: /* fall through */
6372 case OSSA_ERR_PHY_ID_ALREADY_REGISTERED:
6373 /* do nothing */
6374 TI_DBG1(("ossaDeviceRegistrationCB: OSSA_FAILURE_PHY_ID_ALREADY_REGISTERED or OSSA_ERR_PHY_ID_ALREADY_REGISTERED\n"));
6375 break;
6376 case OSSA_FAILURE_PORT_ID_OUT_OF_RANGE: /* fall through */
6377 case OSSA_ERR_PORT_INVALID:
6378 TI_DBG1(("ossaDeviceRegistrationCB: OSSA_FAILURE_PORT_ID_OUT_OF_RANGE or OSSA_ERR_PORT_INVALID\n"));
6379 oneDeviceData->registered = agFALSE;
6380 break;
6381 case OSSA_FAILURE_PORT_NOT_VALID_STATE: /* fall through */
6382 case OSSA_ERR_PORT_STATE_NOT_VALID:
6383 TI_DBG1(("ossaDeviceRegistrationCB: OSSA_FAILURE_PORT_NOT_VALID_STATE or OSSA_ERR_PORT_STATE_NOT_VALID\n"));
6384 TI_DBG2(("ossaDeviceRegistrationCB: did %d pid %d\n", oneDeviceData->id, onePortContext->id));
6385 oneDeviceData->registered = agFALSE;
6386 /* transient period between link up and link down/port recovery */
6387 onePortContext->Transient = agTRUE;
6388 if (onePortContext->valid == agTRUE && (oneDeviceData->valid == agTRUE || oneDeviceData->valid2 == agTRUE))
6389 {
6390 TI_DBG1(("ossaDeviceRegistrationCB: retries regisration\n"));
6391 #ifdef REMOVED
6392 //temp; setting MCN to tdsaAllShared->MCN
6393 oneDeviceData->agDeviceInfo.flag = oneDeviceData->agDeviceInfo.flag | (tdsaAllShared->MCN << 16);
6394 //end temp
6395 #endif
6396 saRegisterNewDevice( /* ossaDeviceRegistrationCB */
6397 agRoot,
6398 &oneDeviceData->agContext,
6399 0,
6400 &oneDeviceData->agDeviceInfo,
6401 onePortContext->agPortContext,
6402 0
6403 );
6404 }
6405 else if (oneDeviceData->directlyAttached == agTRUE && DEVICE_IS_SATA_DEVICE(oneDeviceData))
6406 {
6407 TI_DBG1(("ossaDeviceRegistrationCB: directly attached SATA, put back into free list\n"));
6408 tdsaDeviceDataReInit(tiRoot, oneDeviceData);
6409 tdsaSingleThreadedEnter(tiRoot, TD_DEVICE_LOCK);
6410 TDLIST_ENQUEUE_AT_TAIL(&(oneDeviceData->FreeLink), &(tdsaAllShared->FreeDeviceList));
6411 tdsaSingleThreadedLeave(tiRoot, TD_DEVICE_LOCK);
6412 }
6413 break;
6414 case OSSA_FAILURE_DEVICE_TYPE_NOT_VALID: /* fall through */
6415 case OSSA_ERR_DEVICE_TYPE_NOT_VALID:
6416 TI_DBG1(("ossaDeviceRegistrationCB: OSSA_FAILURE_DEVICE_TYPE_NOT_VALID or OSSA_ERR_DEVICE_TYPE_NOT_VALID\n"));
6417 oneDeviceData->registered = agFALSE;
6418 break;
6419 default:
6420 TI_DBG1(("ossaDeviceRegistrationCB: wrong. default status is %d\n", status));
6421 break;
6422
6423
6424 }
6425 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Ye");
6426 return;
6427 #endif
6428 }
6429
6430 /*****************************************************************************/
6431 /*! \brief ossaDeregisterDeviceHandleCB
6432 *
6433 *
6434 * Purpose: This routine is called by lower layer to corresponding to
6435 * saDeregisterDeviceHandle()
6436 *
6437 * \param agRoot: Pointer to chip/driver Instance.
6438 * \param agDevHandle: Pointer to the assigned device handle for the
6439 * registered device.
6440 * \param status: status
6441 *
6442 *
6443 * \return None.
6444 *
6445 */
6446 /*****************************************************************************/
ossaDeregisterDeviceHandleCB(agsaRoot_t * agRoot,agsaContext_t * agContext,agsaDevHandle_t * agDevHandle,bit32 status)6447 osGLOBAL void ossaDeregisterDeviceHandleCB(
6448 agsaRoot_t *agRoot,
6449 agsaContext_t *agContext,
6450 agsaDevHandle_t *agDevHandle,
6451 bit32 status
6452 )
6453 {
6454 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
6455 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
6456 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData;
6457 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
6458 tdsaDeviceData_t *oneDeviceData = agNULL;
6459 tdsaPortContext_t *onePortContext = agNULL;
6460 agsaEventSource_t *eventSource;
6461 bit32 HwAckSatus;
6462 bit32 PhyID;
6463 #ifdef FDS_DM
6464 dmRoot_t *dmRoot = &(tdsaAllShared->dmRoot);
6465 dmPortContext_t *dmPortContext = agNULL;
6466 dmPortInfo_t dmPortInfo;
6467 bit32 DMstatus = DM_RC_FAILURE;
6468 #endif
6469 #ifdef FDS_SM
6470 smRoot_t *smRoot = &(tdsaAllShared->smRoot);
6471 #endif
6472
6473 TI_DBG3(("ossaDeregisterDeviceHandleCB: start\n"));
6474 smTraceFuncEnter(hpDBG_VERY_LOUD,"Yf");
6475
6476 if (status == OSSA_ERR_DEVICE_HANDLE_INVALID)
6477 {
6478 /* there is no device handle to process */
6479 TI_DBG2(("ossaDeregisterDeviceHandleCB: OSSA_ERR_DEVICE_HANDLE_INVALID\n"));
6480 return;
6481 }
6482
6483 oneDeviceData = (tdsaDeviceData_t *)agDevHandle->osData;
6484 onePortContext = oneDeviceData->tdPortContext;
6485 #ifdef FDS_DM
6486 dmPortContext = &(onePortContext->dmPortContext);
6487 #endif
6488
6489 if (oneDeviceData->valid == agFALSE && oneDeviceData->valid2 == agFALSE &&
6490 oneDeviceData->DeviceType == TD_DEFAULT_DEVICE && onePortContext->valid == agTRUE)
6491 {
6492 TI_DBG2(("ossaDeregisterDeviceHandleCB: transient did %d\n", oneDeviceData->id));
6493 return;
6494 }
6495
6496 if (onePortContext != agNULL)
6497 {
6498 TI_DBG2(("ossaDeregisterDeviceHandleCB: pid %d registeredNumDevice %d\n", onePortContext->id, onePortContext->RegisteredDevNums));
6499 }
6500
6501 switch (status)
6502 {
6503 case OSSA_SUCCESS:
6504 TI_DBG3(("ossaDeregisterDeviceHandleCB: Success\n"));
6505 if (onePortContext == agNULL)
6506 {
6507 TI_DBG1(("ossaDeregisterDeviceHandleCB: onePortContext is NULL, wrong!\n"));
6508 return;
6509 }
6510 /* port is going down */
6511 if (onePortContext->valid == agFALSE)
6512 {
6513 if (!(oneDeviceData->valid == agFALSE && oneDeviceData->valid2 == agFALSE && oneDeviceData->DeviceType == TD_DEFAULT_DEVICE))
6514 {
6515 /* remove oneDevice from MainLink */
6516 TI_DBG2(("ossaDeregisterDeviceHandleCB: delete from MainLink\n"));
6517 #ifdef FDS_SM
6518 if (DEVICE_IS_SATA_DEVICE(oneDeviceData) || DEVICE_IS_STP_TARGET(oneDeviceData))
6519 {
6520 TI_DBG1(("ossaDeregisterDeviceHandleCB: did %d calling smDeregisterDevice\n", oneDeviceData->id));
6521 smDeregisterDevice(smRoot, oneDeviceData->agDevHandle, &(oneDeviceData->smDeviceHandle));
6522 }
6523 #endif
6524 tdsaDeviceDataReInit(tiRoot, oneDeviceData);
6525 osti_memset(&(oneDeviceData->satDevData.satIdentifyData), 0xFF, sizeof(agsaSATAIdentifyData_t));
6526
6527 tdsaSingleThreadedEnter(tiRoot, TD_DEVICE_LOCK);
6528 TDLIST_DEQUEUE_THIS(&(oneDeviceData->MainLink));
6529 TDLIST_ENQUEUE_AT_TAIL(&(oneDeviceData->FreeLink), &(tdsaAllShared->FreeDeviceList));
6530 tdsaSingleThreadedLeave(tiRoot, TD_DEVICE_LOCK);
6531 }
6532 /* for portcontext */
6533 PhyID = onePortContext->eventPhyID;
6534 TI_DBG3(("ossaDeregisterDeviceHandleCB: PhyID %d\n", PhyID));
6535 onePortContext->RegisteredDevNums--;
6536 /*
6537 check if valid in tdsaAllShared and the last registered device in a portcontext;
6538 if so, call saHwEventAck()
6539 */
6540 if (tdsaAllShared->eventSource[PhyID].EventValid == agTRUE &&
6541 onePortContext->RegisteredDevNums == 0 &&
6542 PhyID != 0xFF
6543 )
6544 {
6545 TI_DBG2(("ossaDeregisterDeviceHandleCB: calling saHwEventAck\n"));
6546 eventSource = &(tdsaAllShared->eventSource[PhyID].Source);
6547 HwAckSatus = saHwEventAck(
6548 agRoot,
6549 agNULL, /* agContext */
6550 0,
6551 eventSource, /* agsaEventSource_t */
6552 0,
6553 0
6554 );
6555 if ( HwAckSatus != AGSA_RC_SUCCESS)
6556 {
6557 TI_DBG1(("ossaDeregisterDeviceHandleCB: failing in saHwEventAck; status %d\n", HwAckSatus));
6558 }
6559
6560 /* toggle */
6561 tdsaAllShared->eventSource[PhyID].EventValid = agFALSE;
6562
6563 #ifdef FDS_DM
6564 if (onePortContext->UseDM == agTRUE)
6565 {
6566 TI_DBG1(("ossaDeregisterDeviceHandleCB: calling dmDestroyPort\n"));
6567 /* setup dmPortInfo */
6568 PORTINFO_PUT_SAS_REMOTE_ADDRESSLO(&dmPortInfo, onePortContext->sasRemoteAddressLo);
6569 PORTINFO_PUT_SAS_REMOTE_ADDRESSHI(&dmPortInfo, onePortContext->sasRemoteAddressHi);
6570 PORTINFO_PUT_SAS_LOCAL_ADDRESSLO(&dmPortInfo, onePortContext->sasLocalAddressLo);
6571 PORTINFO_PUT_SAS_LOCAL_ADDRESSHI(&dmPortInfo, onePortContext->sasLocalAddressHi);
6572 DMstatus = dmDestroyPort(dmRoot, dmPortContext, &dmPortInfo);
6573 if (DMstatus != DM_RC_SUCCESS)
6574 {
6575 TI_DBG1(("ossaDeregisterDeviceHandleCB: dmDestroyPort failed!!! 0x%x\n", DMstatus));
6576 }
6577 }
6578 #endif
6579 tdsaPortContextReInit(tiRoot, onePortContext);
6580 /*
6581 put all devices belonging to the onePortContext
6582 back to the free link
6583 */
6584
6585 tdsaSingleThreadedEnter(tiRoot, TD_PORT_LOCK);
6586 TDLIST_DEQUEUE_THIS(&(onePortContext->MainLink));
6587 TDLIST_ENQUEUE_AT_TAIL(&(onePortContext->FreeLink), &(tdsaAllShared->FreePortContextList));
6588 tdsaSingleThreadedLeave(tiRoot, TD_PORT_LOCK);
6589 }
6590 else if (tdsaAllShared->eventSource[PhyID].EventValid == NO_ACK &&
6591 onePortContext->RegisteredDevNums == 0
6592 )
6593 {
6594 TI_DBG2(("ossaDeregisterDeviceHandleCB: NO ACK case\n"));
6595 #ifdef FDS_DM
6596 if (onePortContext->UseDM == agTRUE)
6597 {
6598 TI_DBG1(("ossaDeregisterDeviceHandleCB: calling dmDestroyPort\n"));
6599 /* setup dmPortInfo */
6600 PORTINFO_PUT_SAS_REMOTE_ADDRESSLO(&dmPortInfo, onePortContext->sasRemoteAddressLo);
6601 PORTINFO_PUT_SAS_REMOTE_ADDRESSHI(&dmPortInfo, onePortContext->sasRemoteAddressHi);
6602 PORTINFO_PUT_SAS_LOCAL_ADDRESSLO(&dmPortInfo, onePortContext->sasLocalAddressLo);
6603 PORTINFO_PUT_SAS_LOCAL_ADDRESSHI(&dmPortInfo, onePortContext->sasLocalAddressHi);
6604 DMstatus = dmDestroyPort(dmRoot, dmPortContext, &dmPortInfo);
6605 if (DMstatus != DM_RC_SUCCESS)
6606 {
6607 TI_DBG1(("ossaDeregisterDeviceHandleCB: dmDestroyPort failed!!! 0x%x\n", DMstatus));
6608 }
6609 }
6610 #endif
6611 tdsaPortContextReInit(tiRoot, onePortContext);
6612 /*
6613 put all devices belonging to the onePortContext
6614 back to the free link
6615 */
6616
6617 tdsaSingleThreadedEnter(tiRoot, TD_PORT_LOCK);
6618 TDLIST_DEQUEUE_THIS(&(onePortContext->MainLink));
6619 TDLIST_ENQUEUE_AT_TAIL(&(onePortContext->FreeLink), &(tdsaAllShared->FreePortContextList));
6620 tdsaSingleThreadedLeave(tiRoot, TD_PORT_LOCK);
6621 }
6622 else
6623 {
6624 if (PhyID < TD_MAX_NUM_PHYS)
6625 {
6626 TI_DBG3(("ossaDeregisterDeviceHandleCB: pid %d eventvalid %d registeredNumDevice %d\n", onePortContext->id, tdsaAllShared->eventSource[PhyID].EventValid , onePortContext->RegisteredDevNums));
6627 }
6628 else
6629 {
6630 TI_DBG3(("ossaDeregisterDeviceHandleCB: pid %d registeredNumDevice %d wrong phyid %d\n", onePortContext->id, onePortContext->RegisteredDevNums, PhyID));
6631 }
6632 }
6633 }
6634 else
6635 {
6636 PhyID = onePortContext->eventPhyID;
6637 TI_DBG3(("ossaDeregisterDeviceHandleCB: PhyID %d\n", PhyID));
6638 onePortContext->RegisteredDevNums--;
6639 #ifdef FDS_SM
6640 oneDeviceData->satDevData.IDDeviceValid = agFALSE;
6641 if (DEVICE_IS_SATA_DEVICE(oneDeviceData) || DEVICE_IS_STP_TARGET(oneDeviceData))
6642 {
6643 smDeregisterDevice(smRoot, oneDeviceData->agDevHandle, &(oneDeviceData->smDeviceHandle));
6644 }
6645 #endif
6646 /*
6647 check if valid in tdsaAllShared and the last registered device in a portcontext;
6648 if so, call saHwEventAck()
6649 */
6650 if (tdsaAllShared->eventSource[PhyID].EventValid == agTRUE &&
6651 onePortContext->RegisteredDevNums == 0 &&
6652 PhyID != 0xFF
6653 )
6654 {
6655 TI_DBG2(("ossaDeregisterDeviceHandleCB: calling saHwEventAck\n"));
6656 eventSource = &(tdsaAllShared->eventSource[PhyID].Source);
6657 HwAckSatus = saHwEventAck(
6658 agRoot,
6659 agNULL, /* agContext */
6660 0,
6661 eventSource, /* agsaEventSource_t */
6662 0,
6663 0
6664 );
6665 if ( HwAckSatus != AGSA_RC_SUCCESS)
6666 {
6667 TI_DBG1(("ossaDeregisterDeviceHandleCB: failing in saHwEventAck; status %d\n", HwAckSatus));
6668 }
6669
6670 /* toggle */
6671 tdsaAllShared->eventSource[PhyID].EventValid = agFALSE;
6672 }
6673 #ifdef INITIATOR_DRIVER
6674 else if (onePortContext->RegisteredDevNums == 1)
6675 {
6676 TI_DBG1(("ossaDeregisterDeviceHandleCB: all devices have been deregistered except directly attached EXP\n"));
6677 /* qqqqq If broadcast has been seen, call incremental discovery*/
6678 if (onePortContext->DiscFailNSeenBC == agTRUE)
6679 {
6680 TI_DBG1(("ossaDeregisterDeviceHandleCB: calling dmDiscover, incremental, pid %d\n", onePortContext->id));
6681 dmDiscover(dmRoot, dmPortContext, DM_DISCOVERY_OPTION_INCREMENTAL_START);
6682 onePortContext->DiscFailNSeenBC = agFALSE;
6683 }
6684 else
6685 {
6686 TI_DBG1(("ossaDeregisterDeviceHandleCB: not calling dmDiscover\n"));
6687 /* qqqqq needs to change discovery state to onePortContext->DMDiscoveryState == dmDiscCompleted
6688 in dmQueryDiscovery
6689 change the discovery state from dmDiscFailed to dmDiscCompleted
6690 */
6691 dmResetFailedDiscovery(dmRoot, dmPortContext);
6692
6693 }
6694 }
6695 #endif
6696 else
6697 {
6698 if (PhyID < TD_MAX_NUM_PHYS)
6699 {
6700 TI_DBG3(("ossaDeregisterDeviceHandleCB: pid %d eventvalid %d registeredNumDevice %d\n", onePortContext->id, tdsaAllShared->eventSource[PhyID].EventValid , onePortContext->RegisteredDevNums));
6701 }
6702 else
6703 {
6704 TI_DBG3(("ossaDeregisterDeviceHandleCB: pid %d registeredNumDevice %d wrong phyid %d\n", onePortContext->id, onePortContext->RegisteredDevNums, PhyID));
6705 }
6706 }
6707 }
6708 break;
6709 case OSSA_INVALID_HANDLE:
6710 TI_DBG1(("ossaDeregisterDeviceHandleCB: OSSA_INVALID_HANDLE\n"));
6711 break;
6712 #ifdef REMOVED
6713 case OSSA_FAILURE_DEVICE_DIRECT_ATTACH:
6714 TI_DBG1(("ossaDeregisterDeviceHandleCB: OSSA_FAILURE_DEVICE_DIRECT_ATTACH\n"));
6715 break;
6716 #endif
6717 case OSSA_ERR_DEVICE_HANDLE_INVALID:
6718 TI_DBG1(("ossaDeregisterDeviceHandleCB: OSSA_ERR_DEVICE_HANDLE_INVALID\n"));
6719 break;
6720 case OSSA_ERR_DEVICE_BUSY:
6721 TI_DBG1(("ossaDeregisterDeviceHandleCB: OSSA_ERR_DEVICE_BUSY\n"));
6722 break;
6723 default:
6724 TI_DBG1(("ossaDeregisterDeviceHandleCB: unknown status 0x%x\n", status));
6725 break;
6726 }
6727
6728 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Yf");
6729 return;
6730 }
6731
6732 /*****************************************************************************/
6733 /*! \brief ossaDeviceHandleRemovedEvent
6734 *
6735 *
6736 * Purpose: This routine is called by lower layer to notify the device removal
6737 *
6738 *
6739 * \param agRoot: Pointer to chip/driver Instance.
6740 * \param agDevHandle: Pointer to the assigned device handle for the
6741 * registered device.
6742 * \param agPortContext:Pointer to this instance of port context.
6743 *
6744 *
6745 * \return None.
6746 *
6747 */
6748 /*****************************************************************************/
ossaDeviceHandleRemovedEvent(agsaRoot_t * agRoot,agsaDevHandle_t * agDevHandle,agsaPortContext_t * agPortContext)6749 osGLOBAL void ossaDeviceHandleRemovedEvent (
6750 agsaRoot_t *agRoot,
6751 agsaDevHandle_t *agDevHandle,
6752 agsaPortContext_t *agPortContext
6753 )
6754 {
6755 #ifdef NOT_YET
6756 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
6757 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
6758 #endif
6759 tdsaPortContext_t *onePortContext = agNULL;
6760 tdsaDeviceData_t *oneDeviceData = (tdsaDeviceData_t *)agDevHandle->osData;
6761
6762 smTraceFuncEnter(hpDBG_VERY_LOUD,"Yg");
6763 TI_DBG2(("ossaDeviceHandleRemovedEvent: start\n"));
6764 if (oneDeviceData == agNULL)
6765 {
6766 TI_DBG1(("ossaDeviceHandleRemovedEvent: Wrong! oneDeviceData is NULL\n"));
6767 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Yg");
6768 return;
6769 }
6770 TI_DBG2(("ossaDeviceHandleRemovedEvent: did %d\n", oneDeviceData->id));
6771 oneDeviceData->registered = agFALSE;
6772 onePortContext = (tdsaPortContext_t *)agPortContext->osData;
6773 if (onePortContext == agNULL)
6774 {
6775 TI_DBG1(("ossaDeviceHandleRemovedEvent: Wrong! onePortContext is NULL\n"));
6776 smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "Yg");
6777 return;
6778 }
6779 TI_DBG2(("ossaDeviceHandleRemovedEvent: pid %d\n", onePortContext->id));
6780 onePortContext->RegisteredDevNums--;
6781 #ifdef NOT_YET
6782 ostiInitiatorEvent(
6783 tiRoot,
6784 onePortContext->tiPortalContext,
6785 agNULL,
6786 tiIntrEventTypeDeviceChange,
6787 tiDeviceRemoval,
6788 agNULL
6789 );
6790 #endif
6791
6792 smTraceFuncExit(hpDBG_VERY_LOUD, 'c', "Yg");
6793 return;
6794 }
6795
6796 #ifdef SPC_ENABLE_PROFILE
6797 /*****************************************************************************/
6798 /*! \brief ossaFwProfileCB
6799 *
6800 *
6801 * Purpose: This routine is called by lower layer to corresponding to
6802 * saFwProfile()
6803 *
6804 * \param agRoot: Pointer to chip/driver Instance.
6805 * \param agContext: Context of the operation originally passed
6806 * into saFwProfile()
6807 * \param status: status
6808 *
6809 *
6810 * \return None.
6811 *
6812 */
6813 /*****************************************************************************/
ossaFwProfileCB(agsaRoot_t * agRoot,agsaContext_t * agContext,bit32 status,bit32 len)6814 osGLOBAL void ossaFwProfileCB(
6815 agsaRoot_t *agRoot,
6816 agsaContext_t *agContext,
6817 bit32 status,
6818 bit32 len)
6819 {
6820 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
6821 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
6822
6823 TI_DBG2(("ossaFwProfileCB: start\n"));
6824
6825 switch (status)
6826 {
6827 case AGSA_RC_SUCCESS:
6828 {
6829 TI_DBG2(("ossaFwProfileCB: SUCCESS\n"));
6830 break;
6831 }
6832 case AGSA_RC_FAILURE:
6833 {
6834 TI_DBG1(("ossaFwProfileCB: FAIL\n"));
6835 break;
6836 }
6837 default:
6838 {
6839 TI_DBG1(("ossaFwProfileCB: !!! default, status %d\n", status));
6840 break;
6841 }
6842 }
6843
6844 ostiFWProfileIOCTLRsp(tiRoot, status, len);
6845 return;
6846 }
6847 #endif
6848 /*****************************************************************************/
6849 /*! \brief ossaFwFlashUpdateCB
6850 *
6851 *
6852 * Purpose: This routine is called by lower layer to corresponding to
6853 * saFwFlashUpdate()
6854 *
6855 * \param agRoot: Pointer to chip/driver Instance.
6856 * \param agContext: Context of the operation originally passed
6857 * into saFwFlashUpdate()
6858 * \param status: status
6859 *
6860 *
6861 * \return None.
6862 *
6863 */
6864 /*****************************************************************************/
ossaFwFlashUpdateCB(agsaRoot_t * agRoot,agsaContext_t * agContext,bit32 status)6865 osGLOBAL void ossaFwFlashUpdateCB(
6866 agsaRoot_t *agRoot,
6867 agsaContext_t *agContext,
6868 bit32 status
6869 )
6870 {
6871 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
6872 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
6873
6874 TI_DBG2(("ossaFwFlashUpdateCB: start\n"));
6875
6876 smTraceFuncEnter(hpDBG_VERY_LOUD,"Yh");
6877 switch (status)
6878 {
6879 case OSSA_FLASH_UPDATE_COMPLETE_PENDING_REBOOT:
6880 {
6881 TI_DBG2(("ossaFwFlashUpdateCB: OSSA_FLASH_UPDATE_COMPLETE_PENDING_REBOOT\n"));
6882 break;
6883 }
6884 case OSSA_FLASH_UPDATE_IN_PROGRESS:
6885 {
6886 TI_DBG2(("ossaFwFlashUpdateCB: OSSA_FLASH_UPDATE_IN_PROGRESS\n"));
6887 break;
6888 }
6889 case OSSA_FLASH_UPDATE_HDR_ERR:
6890 {
6891 TI_DBG1(("ossaFwFlashUpdateCB: OSSA_FLASH_UPDATE_HDR_ERR\n"));
6892 break;
6893 }
6894 case OSSA_FLASH_UPDATE_OFFSET_ERR:
6895 {
6896 TI_DBG1(("ossaFwFlashUpdateCB: OSSA_FLASH_UPDATE_OFFSET_ERR\n"));
6897 break;
6898 }
6899 case OSSA_FLASH_UPDATE_CRC_ERR:
6900 {
6901 TI_DBG1(("ossaFwFlashUpdateCB: OSSA_FLASH_UPDATE_CRC_ERR\n"));
6902 break;
6903 }
6904 case OSSA_FLASH_UPDATE_LENGTH_ERR:
6905 {
6906 TI_DBG1(("ossaFwFlashUpdateCB: OSSA_FLASH_UPDATE_LENGTH_ERR\n"));
6907 break;
6908 }
6909 case OSSA_FLASH_UPDATE_HW_ERR:
6910 {
6911 TI_DBG1(("ossaFwFlashUpdateCB: OSSA_FLASH_UPDATE_HW_ERR\n"));
6912 break;
6913 }
6914 case OSSA_FLASH_UPDATE_DNLD_NOT_SUPPORTED:
6915 {
6916 TI_DBG1(("ossaFwFlashUpdateCB: OSSA_FLASH_UPDATE_DNLD_NOT_SUPPORTED\n"));
6917 break;
6918 }
6919 case OSSA_FLASH_UPDATE_DISABLED:
6920 {
6921 TI_DBG1(("ossaFwFlashUpdateCB: OSSA_FLASH_UPDATE_DISABLED\n"));
6922 break;
6923 }
6924 case OSSA_FLASH_FWDNLD_DEVICE_UNSUPPORT:
6925 {
6926 TI_DBG1(("ossaFwFlashUpdateCB: OSSA_FLASH_FWDNLD_DEVICE_UNSUPPORT\n"));
6927 break;
6928 }
6929 case OSSA_MPI_ERR_IO_RESOURCE_UNAVAILABLE:
6930 {
6931 TI_DBG1(("ossaFwFlashUpdateCB: OSSA_MPI_ERR_IO_RESOURCE_UNAVAILABLE\n"));
6932 break;
6933 }
6934 case OSSA_FLASH_UPDATE_HMAC_ERR:
6935 {
6936 TI_DBG1(("ossaFwFlashUpdateCB: OSSA_FLASH_UPDATE_HMAC_ERR\n"));
6937 break;
6938 }
6939
6940 default:
6941 {
6942 TI_DBG1(("ossaFwFlashUpdateCB: !!! default, status 0x%X\n", status));
6943 break;
6944 }
6945 }
6946
6947 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Yh");
6948 ostiCOMMgntIOCTLRsp(tiRoot, status);
6949 return;
6950
6951 }
6952
6953
ossaFlashExtExecuteCB(agsaRoot_t * agRoot,agsaContext_t * agContext,bit32 status,bit32 command,agsaFlashExtResponse_t * agFlashExtRsp)6954 GLOBAL void ossaFlashExtExecuteCB(
6955 agsaRoot_t *agRoot,
6956 agsaContext_t *agContext,
6957 bit32 status,
6958 bit32 command,
6959 agsaFlashExtResponse_t *agFlashExtRsp)
6960 {
6961 TI_DBG1(("ossaFlashExtExecuteCB: command 0x%X status 0x%X\n",command, status));
6962
6963 }
6964
6965
6966
6967 /*****************************************************************************/
6968 /*! \brief ossaGetNVMDResponseCB
6969 *
6970 *
6971 * Purpose: This routine is called by lower layer to corresponding to
6972 * saGetNVMDCommand()
6973 *
6974 * \param agRoot: Pointer to chip/driver Instance.
6975 * \param agContext: Context of the operation originally passed
6976 * into saGetVPDCommand()
6977 * \param status: status
6978 * \param indirectPayload: The value passed in agsaNVMDData_t when
6979 * calling saGetNVMDCommand()
6980 * \param agInfoLen: the length of VPD information
6981 * \param agFrameHandle: handler of VPD information
6982 *
6983 *
6984 * \return None.
6985 *
6986 */
6987 /*****************************************************************************/
ossaGetNVMDResponseCB(agsaRoot_t * agRoot,agsaContext_t * agContext,bit32 status,bit8 indirectPayload,bit32 agInfoLen,agsaFrameHandle_t agFrameHandle)6988 osGLOBAL void ossaGetNVMDResponseCB(
6989 agsaRoot_t *agRoot,
6990 agsaContext_t *agContext,
6991 bit32 status,
6992 bit8 indirectPayload,
6993 bit32 agInfoLen,
6994 agsaFrameHandle_t agFrameHandle
6995 )
6996 {
6997 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
6998 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
6999 TI_DBG2(("ossaGetNVMDResponseCB: start\n"));
7000 TI_DBG2(("ossaGetNVMDResponseCB: agInfoLen %d\n", agInfoLen));
7001 smTraceFuncEnter(hpDBG_VERY_LOUD,"Yi");
7002
7003 if (status == OSSA_SUCCESS)
7004 {
7005 TI_DBG2(("ossaGetNVMDResponseCB: Success status\n"));
7006 if (indirectPayload == 0 && agInfoLen != 0)
7007 {
7008 TI_DBG2(("ossaGetNVMDResponseCB: direct\n"));
7009 tdhexdump("ossaGetNVMDResponseCB", (bit8 *)agFrameHandle, agInfoLen);
7010 }
7011 }
7012 else
7013 {
7014 TI_DBG1(("ossaGetNVMDResponseCB: Status 0x%x\n", status));
7015 }
7016
7017 if (indirectPayload == 0)
7018 {
7019 TI_DBG2(("ossaGetNVMDResponseCB: direct\n"));
7020 }
7021 else
7022 {
7023 TI_DBG2(("ossaGetNVMDResponseCB: indirect\n"));
7024 }
7025
7026 ostiGetNVMDIOCTLRsp(tiRoot, status);
7027 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Yi");
7028 return;
7029 }
7030
7031
7032 /*****************************************************************************/
7033 /*! \brief ossaSetNVMDResponseCB
7034 *
7035 *
7036 * Purpose: This routine is called by lower layer to corresponding to
7037 * saSetNVMDCommand()
7038 *
7039 * \param agRoot: Pointer to chip/driver Instance.
7040 * \param agContext: Context of the operation originally passed
7041 * into saSetVPDCommand()
7042 * \param status: status
7043 *
7044 *
7045 * \return None.
7046 *
7047 */
7048 /*****************************************************************************/
ossaSetNVMDResponseCB(agsaRoot_t * agRoot,agsaContext_t * agContext,bit32 status)7049 osGLOBAL void ossaSetNVMDResponseCB(
7050 agsaRoot_t *agRoot,
7051 agsaContext_t *agContext,
7052 bit32 status
7053 )
7054 {
7055 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
7056 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
7057 TI_DBG2(("ossaSetNVMDResponseCB: start\n"));
7058 smTraceFuncEnter(hpDBG_VERY_LOUD,"Yj");
7059 if (status == OSSA_SUCCESS)
7060 {
7061 TI_DBG2(("ossaSetNVMDResponseCB: success\n"));
7062 }
7063 else
7064 {
7065 TI_DBG1(("ossaSetNVMDResponseCB: fail or undefined staus %d\n", status));
7066 }
7067 ostiSetNVMDIOCTLRsp(tiRoot, status);
7068 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Yj");
7069 return;
7070 }
7071
7072
7073 #ifdef REMOVED
7074 /*****************************************************************************/
7075 /*! \brief ossaGetVPDResponseCB
7076 *
7077 *
7078 * Purpose: This routine is called by lower layer to corresponding to
7079 * saGetVPDCommand()
7080 *
7081 * \param agRoot: Pointer to chip/driver Instance.
7082 * \param agContext: Context of the operation originally passed
7083 * into saGetVPDCommand()
7084 * \param status: status
7085 * \param agInfoLen: the length of VPD information
7086 * \param agFrameHandle:handler of VPD information
7087 *
7088 *
7089 * \return None.
7090 *
7091 */
7092 /*****************************************************************************/
ossaGetVPDResponseCB(agsaRoot_t * agRoot,agsaContext_t * agContext,bit32 status,bit8 indirectMode,bit32 agInfoLen,agsaFrameHandle_t agFrameHandle)7093 osGLOBAL void ossaGetVPDResponseCB(
7094 agsaRoot_t *agRoot,
7095 agsaContext_t *agContext,
7096 bit32 status,
7097 bit8 indirectMode,
7098 bit32 agInfoLen,
7099 agsaFrameHandle_t agFrameHandle
7100 )
7101 {
7102 bit8 VPDData[48];
7103
7104 TI_DBG2(("ossaGetVPDResponseCB: start\n"));
7105
7106 smTraceFuncEnter(hpDBG_VERY_LOUD,"Yk");
7107 if (status == OSSA_SUCCESS)
7108 {
7109 TI_DBG2(("ossaGetVPDResponseCB: agInfoLen %d\n", agInfoLen));
7110 osti_memset(VPDData, 0, 48);
7111 /* We can read only in case of Direct */
7112 saFrameReadBlock(agRoot, agFrameHandle, 0, VPDData, agInfoLen);
7113 tdhexdump("ossaGetVPDResponseCB", (bit8 *)VPDData, agInfoLen);
7114 /*
7115 callback osti....
7116 */
7117 }
7118 else
7119 {
7120 TI_DBG1(("ossaGetVPDResponseCB: fail or undefined staus %d\n", status));
7121 }
7122 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Yk");
7123 return;
7124 }
7125
7126
7127 /*****************************************************************************/
7128 /*! \brief ossaSetVPDResponseCB
7129 *
7130 *
7131 * Purpose: This routine is called by lower layer to corresponding to
7132 * saSetVPDCommand()
7133 *
7134 * \param agRoot: Pointer to chip/driver Instance.
7135 * \param agContext: Context of the operation originally passed
7136 * into saSetVPDCommand()
7137 * \param status: status
7138 *
7139 *
7140 * \return None.
7141 *
7142 */
7143 /*****************************************************************************/
ossaSetVPDResponseCB(agsaRoot_t * agRoot,agsaContext_t * agContext,bit32 status)7144 osGLOBAL void ossaSetVPDResponseCB(
7145 agsaRoot_t *agRoot,
7146 agsaContext_t *agContext,
7147 bit32 status
7148 )
7149 {
7150 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
7151 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
7152
7153 TI_DBG2(("ossaSetVPDResponseCB: start\n"));
7154 smTraceFuncEnter(hpDBG_VERY_LOUD,"Yl");
7155
7156 if (status == OSSA_SUCCESS)
7157 {
7158 TI_DBG2(("ossaSetVPDResponseCB: success\n"));
7159 ostiCOMMgntVPDSetIOCTLRsp(tiRoot, 0);
7160 /*
7161 callback osti.....
7162 */
7163
7164 #ifdef VPD_TESTING
7165 /* temporary to test saSetVPDCommand() and saGetVPDCommand */
7166 tdsaVPDGet(tiRoot);
7167 #endif
7168
7169 }
7170 else
7171 {
7172 TI_DBG1(("ossaSetVPDResponseCB: fail or undefined staus %d\n", status));
7173 }
7174 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Yl");
7175 return;
7176 }
7177 #endif
7178
7179 /*****************************************************************************/
7180 /*! \brief ossaEchoCB
7181 *
7182 *
7183 * Purpose: This routine is called by lower layer to corresponding to
7184 * saEchoCommand()
7185 *
7186 * \param agRoot: Pointer to chip/driver Instance.
7187 * \param agContext: Context of the operation originally passed
7188 * into saEchoCommand()
7189 * \param echoPayload: Pointer to the echo payload
7190 *
7191 *
7192 * \return None.
7193 *
7194 */
7195 /*****************************************************************************/
ossaEchoCB(agsaRoot_t * agRoot,agsaContext_t * agContext,void * echoPayload)7196 osGLOBAL void ossaEchoCB(
7197 agsaRoot_t *agRoot,
7198 agsaContext_t *agContext,
7199 void *echoPayload
7200 )
7201 {
7202 #ifdef ECHO_TESTING
7203 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
7204 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
7205 bit8 payload[56];
7206 #endif
7207
7208 TI_DBG2(("ossaEchoCB: start\n"));
7209 smTraceFuncEnter(hpDBG_VERY_LOUD,"Ym");
7210
7211 /* dumping received echo payload is 56 bytes */
7212 tdhexdump("ossaEchoCB: echoPayload", (bit8 *)(echoPayload), 56);
7213
7214 #ifdef ECHO_TESTING
7215 /* temporary to test saEchoCommand() */
7216
7217 /* new echo payload */
7218 osti_memset(payload,0, sizeof(payload));
7219
7220 payload[0] = gEcho;
7221 payload[55] = gEcho;
7222
7223 TI_DBG2(("ossaEchoCB: gEcho %d\n", gEcho));
7224
7225 saEchoCommand(agRoot, agNULL, tdsaRotateQnumber(tiRoot, agNULL), (void *)&payload);
7226
7227 if (gEcho == 0xFF)
7228 {
7229 gEcho = 0;
7230 }
7231 else
7232 {
7233 gEcho++;
7234 }
7235 #endif
7236
7237 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Ym");
7238 return;
7239 }
7240
7241 /*****************************************************************************/
7242 /*! \brief ossaGpioResponseCB
7243 *
7244 *
7245 * Purpose: This routine is called by lower layer to corresponding to
7246 * saGpioEventSetup(), saGpioPinSetup(), saGpioRead(), or
7247 * saGpioWrite()
7248 *
7249 * \param agRoot: Pointer to chip/driver Instance.
7250 * \param agContext: Context of the operation originally passed
7251 * in.
7252 * \param status: GPIO operation completion status
7253 * \param gpioReadValue: a bit map containing the corresponding
7254 * value for each GPIO pin.
7255 * \param gpioPinSetupInfo: Pointer to agsaGpioPinSetupInfo_t structure
7256 * describing the GPIO pin setup
7257 * \param gpioEventSetupInfo Pointer to agsaGpioEventSetupInfo_t structure
7258 * describing the GPIO event setups
7259 *
7260 *
7261 * \return None.
7262 *
7263 */
7264 /*****************************************************************************/
ossaGpioResponseCB(agsaRoot_t * agRoot,agsaContext_t * agContext,bit32 status,bit32 gpioReadValue,agsaGpioPinSetupInfo_t * gpioPinSetupInfo,agsaGpioEventSetupInfo_t * gpioEventSetupInfo)7265 osGLOBAL void ossaGpioResponseCB(
7266 agsaRoot_t *agRoot,
7267 agsaContext_t *agContext,
7268 bit32 status,
7269 bit32 gpioReadValue,
7270 agsaGpioPinSetupInfo_t *gpioPinSetupInfo,
7271 agsaGpioEventSetupInfo_t *gpioEventSetupInfo
7272 )
7273 {
7274 TI_DBG2(("ossaGpioResponseCB: start\n"));
7275 smTraceFuncEnter(hpDBG_VERY_LOUD,"Yn");
7276 if (status == OSSA_SUCCESS)
7277 {
7278 TI_DBG2(("ossaGpioResponseCB: Success\n"));
7279 /* printing gpioReadValue, agsaGpioPinSetupInfo_t and agsaGpioEventSetupInfo_t */
7280 TI_DBG2(("ossaGpioResponseCB: gpioReadValue 0x%x\n", gpioReadValue));
7281 TI_DBG2(("ossaGpioResponseCB: PinSetupInfo gpioInputEnabled 0x%x\n", gpioPinSetupInfo->gpioInputEnabled));
7282 TI_DBG2(("ossaGpioResponseCB: PinSetupInfo gpioTypePart1 0x%x\n", gpioPinSetupInfo->gpioTypePart1));
7283 TI_DBG2(("ossaGpioResponseCB: PinSetupInfo gpioTypePart2 0x%x\n", gpioPinSetupInfo->gpioTypePart2));
7284 TI_DBG2(("ossaGpioResponseCB: EventSetupInfo gpioEventLevel 0x%x\n", gpioEventSetupInfo->gpioEventLevel));
7285 TI_DBG2(("ossaGpioResponseCB: EventSetupInfo gpioEventRisingEdge 0x%x\n", gpioEventSetupInfo->gpioEventRisingEdge));
7286 TI_DBG2(("ossaGpioResponseCB: EventSetupInfo gpioEventFallingEdge 0x%x\n", gpioEventSetupInfo->gpioEventFallingEdge));
7287 }
7288 else
7289 {
7290 TI_DBG1(("ossaGpioResponseCB: Failure\n"));
7291 }
7292 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Yn");
7293 return;
7294 }
7295
7296 /*****************************************************************************/
7297 /*! \brief ossaGpioEvent
7298 *
7299 *
7300 * Purpose: This routine is called by lower layer to corresponding to
7301 * saGpioEventSetup(), saGpioPinSetup(), saGpioRead(), or
7302 * saGpioWrite()
7303 *
7304 * \param agRoot: Pointer to chip/driver Instance.
7305 * \param gpioEvent: a bit map that indicates which GPIO
7306 * input pins have generated the event.
7307 *
7308 *
7309 * \return None.
7310 *
7311 */
7312 /*****************************************************************************/
ossaGpioEvent(agsaRoot_t * agRoot,bit32 gpioEvent)7313 osGLOBAL void ossaGpioEvent(
7314 agsaRoot_t *agRoot,
7315 bit32 gpioEvent
7316 )
7317 {
7318 TI_DBG2(("ossaGpioEvent: start\n"));
7319 TI_DBG2(("ossaGpioEvent: gpioEvent 0x%x\n", gpioEvent));
7320 smTraceFuncEnter(hpDBG_VERY_LOUD,"Yo");
7321 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Yo");
7322 return;
7323 }
7324
7325
7326 /*****************************************************************************/
7327 /*! \brief ossaSASDiagExecuteCB
7328 *
7329 *
7330 * Purpose: This routine is called by lower layer to corresponding to
7331 * saSASDiagExecute()
7332 *
7333 * \param agRoot: Pointer to chip/driver Instance.
7334 * \param agContext: Context of the operation originally passed
7335 * in.
7336 * \param status: Diagnostic operation completion status
7337 * \param command: SAS diagnostic command field in agsaSASDiagExecute_t
7338 * structure passed in saSASDiagExecute().
7339 * \param reportData: Report Diagnostic Data
7340 *
7341 *
7342 * \return None.
7343 *
7344 */
7345 /*****************************************************************************/
ossaSASDiagExecuteCB(agsaRoot_t * agRoot,agsaContext_t * agContext,bit32 status,bit32 command,bit32 reportData)7346 osGLOBAL void ossaSASDiagExecuteCB(
7347 agsaRoot_t *agRoot,
7348 agsaContext_t *agContext,
7349 bit32 status,
7350 bit32 command,
7351 bit32 reportData)
7352 {
7353 smTraceFuncEnter(hpDBG_VERY_LOUD,"Yq");
7354 TI_DBG2(("ossaSASDiagExecuteCB: start\n"));
7355 TI_DBG2(("ossaSASDiagExecuteCB: status %d\n", status));
7356 TI_DBG2(("ossaSASDiagExecuteCB: command %d\n", command));
7357 TI_DBG2(("ossaSASDiagExecuteCB: reportData %d\n", reportData));
7358
7359 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Yq");
7360 return;
7361
7362 }
7363
7364
7365 /*****************************************************************************/
7366 /*! \brief ossaSASDiagStartEndCB
7367 *
7368 *
7369 * Purpose: This routine is called by lower layer to corresponding to
7370 * saSASDiagExecute()
7371 *
7372 * \param agRoot: Pointer to chip/driver Instance.
7373 * \param agContext: Context of the operation originally passed
7374 * in.
7375 * \param status: Diagnostic operation completion status
7376 *
7377 *
7378 * \return None.
7379 *
7380 */
7381 /*****************************************************************************/
ossaSASDiagStartEndCB(agsaRoot_t * agRoot,agsaContext_t * agContext,bit32 status)7382 osGLOBAL void ossaSASDiagStartEndCB(
7383 agsaRoot_t *agRoot,
7384 agsaContext_t *agContext,
7385 bit32 status)
7386 {
7387 TI_DBG2(("ossaSASDiagStartEndCB: start\n"));
7388 TI_DBG2(("ossaSASDiagStartEndCB: status %d\n", status));
7389 smTraceFuncEnter(hpDBG_VERY_LOUD,"Yr");
7390 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Yr");
7391 return;
7392 }
7393
7394 /*****************************************************************************/
7395 /*! \brief ossaReconfigSASParamsCB
7396 *
7397 *
7398 * Purpose: This routine is called by lower layer to corresponding to
7399 * saReconfigSASParams()
7400 *
7401 * \param agRoot: Pointer to chip/driver Instance.
7402 * \param agContext: Context of the operation originally passed
7403 * in saReconfigSASParams().
7404 * \param status: saReconfigSASParams() completion status
7405 * \param agSASConfig: Pointer to the data structure agsaSASReconfig_t
7406 *
7407 *
7408 * \return None.
7409 *
7410 */
7411 /*****************************************************************************/
ossaReconfigSASParamsCB(agsaRoot_t * agRoot,agsaContext_t * agContext,bit32 status,agsaSASReconfig_t * agSASConfig)7412 osGLOBAL void ossaReconfigSASParamsCB(
7413 agsaRoot_t *agRoot,
7414 agsaContext_t *agContext,
7415 bit32 status,
7416 agsaSASReconfig_t *agSASConfig)
7417 {
7418 TI_DBG2(("ossaReconfigSASParamsCB: status %d\n", status));
7419 return;
7420 }
7421
ossaPCIeDiagExecuteCB(agsaRoot_t * agRoot,agsaContext_t * agContext,bit32 status,bit32 command,agsaPCIeDiagResponse_t * resp)7422 GLOBAL void ossaPCIeDiagExecuteCB(
7423 agsaRoot_t *agRoot,
7424 agsaContext_t *agContext,
7425 bit32 status,
7426 bit32 command,
7427 agsaPCIeDiagResponse_t *resp )
7428 {
7429 TI_DBG2(("ossaPCIeDiagExecuteCB: status %d\n", status));
7430 TI_DBG2(("ossaPCIeDiagExecuteCB: ERR_BLKH 0x%X\n",resp->ERR_BLKH ));
7431 TI_DBG2(("ossaPCIeDiagExecuteCB: ERR_BLKL 0x%X\n",resp->ERR_BLKL ));
7432 TI_DBG2(("ossaPCIeDiagExecuteCB: DWord8 0x%X\n",resp->DWord8 ));
7433 TI_DBG2(("ossaPCIeDiagExecuteCB: DWord9 0x%X\n",resp->DWord9 ));
7434 TI_DBG2(("ossaPCIeDiagExecuteCB: DWord10 0x%X\n",resp->DWord10 ));
7435 TI_DBG2(("ossaPCIeDiagExecuteCB: DWord11 0x%X\n",resp->DWord11 ));
7436 TI_DBG2(("ossaPCIeDiagExecuteCB: DIF_ERR 0x%X\n",resp->DIF_ERR ));
7437
7438 return;
7439 }
7440
7441
7442 #ifndef BIOS
ossaSGpioCB(agsaRoot_t * agRoot,agsaContext_t * agContext,agsaSGpioReqResponse_t * pSgpioResponse)7443 GLOBAL void ossaSGpioCB(
7444 agsaRoot_t *agRoot,
7445 agsaContext_t *agContext,
7446 agsaSGpioReqResponse_t *pSgpioResponse
7447 )
7448 {
7449 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
7450 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
7451
7452 TI_DBG2(("ossaSGpioCB: smpFrameType: 0x%02x \n", pSgpioResponse->smpFrameType));
7453 // printf("SS:ossaSGpioCB: smpFrameType: 0x%02x \n", pSgpioResponse->smpFrameType);
7454 TI_DBG2(("ossaSGpioCB: function: 0x%02x \n", pSgpioResponse->function));
7455 TI_DBG2(("ossaSGpioCB: functionResult: 0x%02x \n", pSgpioResponse->functionResult));
7456 //printf("SS:ossaSGpioCB: functionResult: 0x%02x \n", pSgpioResponse->functionResult);
7457
7458 tdhexdump("ossaSGpioCB Response", (bit8 *)pSgpioResponse, sizeof(agsaSGpioReqResponse_t));
7459 ostiSgpioIoctlRsp(tiRoot, pSgpioResponse);
7460 }
7461
7462 #endif /* BIOS */
7463
7464 /*****************************************************************************/
7465 /*! \brief ossaLogDebugString
7466 *
7467 *
7468 * Purpose: This routine is called by lower layer to log.
7469 *
7470 * \param agRoot: Pointer to chip/driver Instance.
7471 * \param level: Detail of information desired.
7472 * \param string: Pointer to the character string.
7473 * \param ptr1: First pointer value.
7474 * \param ptr2: Second pointer value.
7475 * \param value1: First 32-bit value related to the specific information.
7476 * \param value2: Second 32-bit value related to the specific information.
7477 *
7478 * \return None.
7479 *
7480 */
7481 /*****************************************************************************/
ossaLogDebugString(agsaRoot_t * agRoot,bit32 level,char * string,void * ptr1,void * ptr2,bit32 value1,bit32 value2)7482 GLOBAL void ossaLogDebugString(
7483 agsaRoot_t *agRoot,
7484 bit32 level,
7485 char *string,
7486 void *ptr1,
7487 void *ptr2,
7488 bit32 value1,
7489 bit32 value2
7490 )
7491 {
7492 #if defined(SALLSDK_DEBUG)
7493 TIDEBUG_MSG(gLLDebugLevel, level, ("%s %p %p %d %d\n", string, ptr1, ptr2, value1, value2));
7494 #endif
7495 return;
7496 }
7497
7498 /*****************************************************************************/
7499 /*! \brief ossaHwEventAckCB
7500 *
7501 *
7502 * Purpose: This routine is called by lower layer to corresponding to
7503 * saHwEventAck(()
7504 *
7505 * \param agRoot: Pointer to chip/driver Instance.
7506 * \param agContext: Context of the operation originally passed
7507 * in.
7508 * \param status: Status
7509 *
7510 *
7511 * \return None.
7512 *
7513 */
7514 /*****************************************************************************/
ossaHwEventAckCB(agsaRoot_t * agRoot,agsaContext_t * agContext,bit32 status)7515 GLOBAL void ossaHwEventAckCB(
7516 agsaRoot_t *agRoot,
7517 agsaContext_t *agContext,
7518 bit32 status
7519 )
7520 {
7521 TI_DBG3(("ossaHwEventAckCB: start\n"));
7522 smTraceFuncEnter(hpDBG_VERY_LOUD,"Ys");
7523 if (status == tiSuccess)
7524 {
7525 TI_DBG3(("ossaHwEventAckCB: SUCCESS status\n"));
7526 }
7527 else
7528 {
7529 TI_DBG1(("ossaHwEventAckCB: FAIL status 0x%X\n", status));
7530 TI_DBG1(("ossaHwEventAckCB: invalid event status bit0 %d\n", status & 0x01));
7531 TI_DBG1(("ossaHwEventAckCB: invalid phyid status bit1 %d\n", (status & 0x02) >> 1 ));
7532 TI_DBG1(("ossaHwEventAckCB: invalid portcontext status bit2 %d\n", (status & 0x04) >> 2));
7533 TI_DBG1(("ossaHwEventAckCB: invalid param0 status bit3 %d\n", (status & 0x08) >> 3));
7534 }
7535
7536 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Ys");
7537 return;
7538 }
7539
7540 /*****************************************************************************/
7541 /*! \brief ossaGetTimeStampCB
7542 *
7543 *
7544 * Purpose: This routine is called by lower layer to corresponding to
7545 * saGetTimeStamp()
7546 *
7547 * \param agRoot: Pointer to chip/driver Instance.
7548 * \param agContext: Context of the operation originally passed
7549 * in.
7550 * \param timeStampLower: The controller lower 32-bit of internal time
7551 * stamp associated with event log.
7552 * \param timeStampUpper: The controller upper 32-bit of internal time
7553 * stamp associated with event log.
7554 *
7555 *
7556 * \return None.
7557 *
7558 */
7559 /*****************************************************************************/
ossaGetTimeStampCB(agsaRoot_t * agRoot,agsaContext_t * agContext,bit32 timeStampLower,bit32 timeStampUpper)7560 GLOBAL void ossaGetTimeStampCB(
7561 agsaRoot_t *agRoot,
7562 agsaContext_t *agContext,
7563 bit32 timeStampLower,
7564 bit32 timeStampUpper
7565 )
7566 {
7567 smTraceFuncEnter(hpDBG_VERY_LOUD,"Yt");
7568 TI_DBG4(("ossaGetTimeStampCB: start\n"));
7569 TI_DBG4(("ossaGetTimeStampCB: timeStampUpper 0x%x timeStampLower 0x%x\n", timeStampUpper, timeStampLower));
7570 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Yt");
7571 return;
7572 }
7573
7574
7575 /*****************************************************************************/
7576 /*! \brief ossaSMPAbortCB
7577 *
7578 *
7579 * Purpose: This routine is called by lower layer to corresponding to
7580 * saSMPAbort()
7581 *
7582 * \param agRoot: Pointer to chip/driver Instance.
7583 * \param agIORequest: This is the agIORequest parameter passed in
7584 * saSMPAbort()
7585 * \param status: Status of abort
7586 *
7587 * \return None.
7588 *
7589 */
7590 /*****************************************************************************/
ossaSMPAbortCB(agsaRoot_t * agRoot,agsaIORequest_t * agIORequest,bit32 flag,bit32 status)7591 GLOBAL void ossaSMPAbortCB(
7592 agsaRoot_t *agRoot,
7593 agsaIORequest_t *agIORequest,
7594 bit32 flag,
7595 bit32 status)
7596 {
7597 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
7598 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
7599 tdIORequestBody_t *tdAbortIORequestBody = agNULL;
7600 tdsaDeviceData_t *oneDeviceData = agNULL;
7601 tiDeviceHandle_t *tiDeviceHandle = agNULL;
7602
7603 TI_DBG4(("ossaSMPAbortCB: start\n"));
7604 TI_DBG4(("ossaSMPAbortCB: flag %d\n", flag));
7605 TI_DBG4(("ossaSMPAbortCB: status %d\n", status));
7606 smTraceFuncEnter(hpDBG_VERY_LOUD,"Yu");
7607
7608 tdAbortIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
7609 if (tdAbortIORequestBody == agNULL)
7610 {
7611 TI_DBG1(("ossaSMPAbortCB: tdAbortIORequestBody is NULL warning!!!!\n"));
7612 return;
7613 }
7614
7615 if (flag == 2)
7616 {
7617 /* abort per port */
7618 TI_DBG2(("ossaSMPAbortCB: abort per port\n"));
7619 }
7620 else if (flag == 1)
7621 {
7622 TI_DBG2(("ossaSMPAbortCB: abort all\n"));
7623
7624 tiDeviceHandle = (tiDeviceHandle_t *)tdAbortIORequestBody->tiDevHandle;
7625 if (tiDeviceHandle == agNULL)
7626 {
7627 TI_DBG1(("ossaSMPAbortCB: tiDeviceHandle is NULL warning!!!!\n"));
7628 ostiFreeMemory(
7629 tiRoot,
7630 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
7631 sizeof(tdIORequestBody_t)
7632 );
7633 return;
7634 }
7635
7636 oneDeviceData = (tdsaDeviceData_t *)tiDeviceHandle->tdData;
7637 if (oneDeviceData == agNULL)
7638 {
7639 TI_DBG1(("ossaSMPAbortCB: oneDeviceData is NULL warning!!!!\n"));
7640 ostiFreeMemory(
7641 tiRoot,
7642 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
7643 sizeof(tdIORequestBody_t)
7644 );
7645 return;
7646 }
7647
7648 if (status == OSSA_IO_SUCCESS)
7649 {
7650 TI_DBG2(("ossaSMPAbortCB: OSSA_IO_SUCCESS\n"));
7651 /* clean up TD layer's IORequestBody */
7652 TI_DBG3(("ossaSMPAbortCB: calling saDeregisterDeviceHandle\n"));
7653 saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, tdsaRotateQnumber(tiRoot, oneDeviceData));
7654 TI_DBG2(("ossaSMPAbortCB: did %d\n", oneDeviceData->id));
7655 ostiFreeMemory(
7656 tiRoot,
7657 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
7658 sizeof(tdIORequestBody_t)
7659 );
7660
7661 }
7662 else if (status == OSSA_IO_NOT_VALID)
7663 {
7664 TI_DBG1(("ossaSMPAbortCB: OSSA_IO_NOT_VALID\n"));
7665 /* clean up TD layer's IORequestBody */
7666 TI_DBG1(("ossaSMPAbortCB: calling saDeregisterDeviceHandle\n"));
7667 saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, tdsaRotateQnumber(tiRoot, oneDeviceData));
7668 TI_DBG1(("ossaSMPAbortCB: did %d\n", oneDeviceData->id));
7669 ostiFreeMemory(
7670 tiRoot,
7671 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
7672 sizeof(tdIORequestBody_t)
7673 );
7674 }
7675 else if (status == OSSA_IO_NO_DEVICE)
7676 {
7677 TI_DBG1(("ossaSMPAbortCB: OSSA_IO_NO_DEVICE\n"));
7678 /* clean up TD layer's IORequestBody */
7679 TI_DBG1(("ossaSMPAbortCB: calling saDeregisterDeviceHandle\n"));
7680 saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, tdsaRotateQnumber(tiRoot, oneDeviceData));
7681 TI_DBG1(("ossaSMPAbortCB: did %d\n", oneDeviceData->id));
7682 ostiFreeMemory(
7683 tiRoot,
7684 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
7685 sizeof(tdIORequestBody_t)
7686 );
7687 }
7688 else if (status == OSSA_IO_ABORT_IN_PROGRESS)
7689 {
7690 TI_DBG1(("ossaSMPAbortCB: OSSA_IO_ABORT_IN_PROGRESS\n"));
7691 /* clean up TD layer's IORequestBody */
7692 TI_DBG1(("ossaSMPAbortCB: calling saDeregisterDeviceHandle\n"));
7693 saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, tdsaRotateQnumber(tiRoot, oneDeviceData));
7694 TI_DBG1(("ossaSMPAbortCB: did %d\n", oneDeviceData->id));
7695 ostiFreeMemory(
7696 tiRoot,
7697 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
7698 sizeof(tdIORequestBody_t)
7699 );
7700 }
7701 #ifdef REMOVED
7702 else if (status == OSSA_IO_ABORT_DELAYED)
7703 {
7704 TI_DBG1(("ossaSMPAbortCB: OSSA_IO_ABORT_DELAYED\n"));
7705 /* clean up TD layer's IORequestBody */
7706 TI_DBG1(("ossaSMPAbortCB: calling saDeregisterDeviceHandle\n"));
7707 saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, tdsaRotateQnumber(tiRoot, oneDeviceData));
7708 TI_DBG1(("ossaSMPAbortCB: did %d\n", oneDeviceData->id));
7709 ostiFreeMemory(
7710 tiRoot,
7711 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
7712 sizeof(tdIORequestBody_t)
7713 );
7714 }
7715 #endif
7716 else
7717 {
7718 TI_DBG1(("ossaSMPAbortCB: other status %d\n", status));
7719 /* clean up TD layer's IORequestBody */
7720 TI_DBG1(("ossaSMPAbortCB: calling saDeregisterDeviceHandle\n"));
7721 saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, tdsaRotateQnumber(tiRoot, oneDeviceData));
7722 TI_DBG1(("ossaSMPAbortCB: did %d\n", oneDeviceData->id));
7723 ostiFreeMemory(
7724 tiRoot,
7725 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
7726 sizeof(tdIORequestBody_t)
7727 );
7728 }
7729 }
7730 else if (flag == 0)
7731 {
7732 TI_DBG2(("ossaSMPAbortCB: abort one\n"));
7733 if (status == OSSA_IO_SUCCESS)
7734 {
7735 TI_DBG2(("ossaSMPAbortCB: OSSA_IO_SUCCESS\n"));
7736 ostiFreeMemory(
7737 tiRoot,
7738 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
7739 sizeof(tdIORequestBody_t)
7740 );
7741
7742 }
7743 else if (status == OSSA_IO_NOT_VALID)
7744 {
7745 TI_DBG1(("ossaSMPAbortCB: OSSA_IO_NOT_VALID\n"));
7746 ostiFreeMemory(
7747 tiRoot,
7748 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
7749 sizeof(tdIORequestBody_t)
7750 );
7751 }
7752 else if (status == OSSA_IO_NO_DEVICE)
7753 {
7754 TI_DBG1(("ossaSMPAbortCB: OSSA_IO_NO_DEVICE\n"));
7755 ostiFreeMemory(
7756 tiRoot,
7757 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
7758 sizeof(tdIORequestBody_t)
7759 );
7760 }
7761 else if (status == OSSA_IO_ABORT_IN_PROGRESS)
7762 {
7763 TI_DBG1(("ossaSMPAbortCB: OSSA_IO_ABORT_IN_PROGRESS\n"));
7764 ostiFreeMemory(
7765 tiRoot,
7766 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
7767 sizeof(tdIORequestBody_t)
7768 );
7769 }
7770 #ifdef REMOVED
7771 else if (status == OSSA_IO_ABORT_DELAYED)
7772 {
7773 TI_DBG1(("ossaSMPAbortCB: OSSA_IO_ABORT_DELAYED\n"));
7774 ostiFreeMemory(
7775 tiRoot,
7776 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
7777 sizeof(tdIORequestBody_t)
7778 );
7779 }
7780 #endif
7781 else
7782 {
7783 TI_DBG1(("ossaSMPAbortCB: other status %d\n", status));
7784 ostiFreeMemory(
7785 tiRoot,
7786 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
7787 sizeof(tdIORequestBody_t)
7788 );
7789 }
7790 }
7791 else
7792 {
7793 TI_DBG1(("ossaSMPAbortCB: wrong flag %d\n", flag));
7794 }
7795
7796
7797 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Yu");
7798 return;
7799 }
7800
7801 /*****************************************************************************/
7802 /*! \brief ossaGeneralEvent
7803 *
7804 *
7805 * Purpose: This is the event notification for debugging purposes sent to
7806 * inform the OS layer of some general error related to a specific
7807 * inbound operation.
7808 *
7809 * \param agRoot: Pointer to chip/driver Instance.
7810 * \param status: Status associated with this event
7811 * \param msg: Pointer to controller specific command
7812 * massage that caused the error
7813 *
7814 * \return None.
7815 *
7816 */
7817 /*****************************************************************************/
ossaGeneralEvent(agsaRoot_t * agRoot,bit32 status,agsaContext_t * agContext,bit32 * msg)7818 GLOBAL void ossaGeneralEvent(
7819 agsaRoot_t *agRoot,
7820 bit32 status,
7821 agsaContext_t *agContext,
7822 bit32 *msg)
7823 {
7824 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
7825 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
7826
7827 TI_DBG1(("ossaGeneralEvent: start\n"));
7828 TI_DBG1(("ossaGeneralEvent: status %d\n", status));
7829
7830 if(msg)
7831 {
7832 TI_DBG1(("ossaGeneralEvent: *msg %X\n", *msg));
7833 }
7834
7835 smTraceFuncEnter(hpDBG_VERY_LOUD,"Yv");
7836 ostiGenEventIOCTLRsp(tiRoot, status);
7837 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Yv");
7838 return;
7839 }
7840
ossaGetForensicDataCB(agsaRoot_t * agRoot,agsaContext_t * agContext,bit32 status,agsaForensicData_t * forensicData)7841 GLOBAL void ossaGetForensicDataCB (
7842 agsaRoot_t *agRoot,
7843 agsaContext_t *agContext,
7844 bit32 status,
7845 agsaForensicData_t *forensicData)
7846 {
7847 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
7848 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
7849
7850 ostiGetForensicDataIOCTLRsp(tiRoot, status, forensicData);
7851 return;
7852 }
7853
7854
7855 #ifdef INITIATOR_DRIVER
7856
ossaGetIOErrorStatsCB(agsaRoot_t * agRoot,agsaContext_t * agContext,bit32 status,agsaIOErrorEventStats_t * stats)7857 GLOBAL void ossaGetIOErrorStatsCB (
7858 agsaRoot_t *agRoot,
7859 agsaContext_t *agContext,
7860 bit32 status,
7861 agsaIOErrorEventStats_t *stats)
7862
7863 {
7864 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
7865 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
7866
7867 ostiGetIoErrorStatsIOCTLRsp(tiRoot, status, stats);
7868 }
7869 #else
ossaGetIOErrorStatsCB(agsaRoot_t * agRoot,agsaContext_t * agContext,bit32 status,agsaIOErrorEventStats_t * stats)7870 GLOBAL void ossaGetIOErrorStatsCB (
7871 agsaRoot_t *agRoot,
7872 agsaContext_t *agContext,
7873 bit32 status,
7874 agsaIOErrorEventStats_t *stats)
7875
7876 {
7877
7878 }
7879
7880 #endif
7881
ossaGetIOEventStatsCB(agsaRoot_t * agRoot,agsaContext_t * agContext,bit32 status,agsaIOErrorEventStats_t * stats)7882 GLOBAL void ossaGetIOEventStatsCB (
7883 agsaRoot_t *agRoot,
7884 agsaContext_t *agContext,
7885 bit32 status,
7886 agsaIOErrorEventStats_t *stats)
7887
7888 {
7889 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
7890 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
7891
7892 ostiGetIoEventStatsIOCTLRsp(tiRoot, status, stats);
7893 }
7894
7895
7896 /*****************************************************************************/
7897 /*! \brief ossaGetRegisterDumpCB
7898 *
7899 *
7900 * Purpose: ossaGetRegisterDumpCB() is the response callback function
7901 * called by the LL Layer to indicate a response to
7902 * saGetRegisterDump()
7903 *
7904 * \param agRoot: Pointer to chip/driver Instance.
7905 * \param agContext: Context of the operation originally
7906 * passed into saGetRegisterDump()
7907 * \param status: status
7908 *
7909 * \return None.
7910 *
7911 */
7912 /*****************************************************************************/
ossaGetRegisterDumpCB(agsaRoot_t * agRoot,agsaContext_t * agContext,bit32 status)7913 GLOBAL void ossaGetRegisterDumpCB(
7914 agsaRoot_t *agRoot,
7915 agsaContext_t *agContext,
7916 bit32 status
7917 )
7918 {
7919 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
7920 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
7921
7922 TI_DBG4(("ossaGetRegisterDumpCB: start\n"));
7923 TI_DBG4(("ossaGetRegisterDumpCB: status %d\n", status));
7924 smTraceFuncEnter(hpDBG_VERY_LOUD,"Yw");
7925
7926 ostiRegDumpIOCTLRsp(tiRoot, status);
7927 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Yw");
7928 return;
7929 }
7930
7931 /*****************************************************************************/
7932 /*! \brief ossaSetDeviceStateCB
7933 *
7934 *
7935 * Purpose: ossaSetDeviceStateCB() is the response callback function
7936 * called by the LL Layer to indicate a response to
7937 * saSetDeviceState()
7938 *
7939 * \param agRoot: Pointer to chip/driver Instance.
7940 * \param agContext: Context of the operation originally
7941 * passed into saGetRegisterDump()
7942 * \param agDevHandle Pointer to the device handle of the device
7943 * \param status: status
7944 * \param newDeviceState: newly set device status
7945 * \param previousDeviceState: old device status
7946 *
7947 * \return None.
7948 *
7949 */
7950 /*****************************************************************************/
ossaSetDeviceStateCB(agsaRoot_t * agRoot,agsaContext_t * agContext,agsaDevHandle_t * agDevHandle,bit32 status,bit32 newDeviceState,bit32 previousDeviceState)7951 GLOBAL void ossaSetDeviceStateCB(
7952 agsaRoot_t *agRoot,
7953 agsaContext_t *agContext,
7954 agsaDevHandle_t *agDevHandle,
7955 bit32 status,
7956 bit32 newDeviceState,
7957 bit32 previousDeviceState
7958 )
7959 {
7960 tdsaDeviceData_t *oneDeviceData = agNULL;
7961
7962 TI_DBG2(("ossaSetDeviceStateCB: start\n"));
7963 TI_DBG2(("ossaSetDeviceStateCB: status %d\n", status));
7964 TI_DBG2(("ossaSetDeviceStateCB: newDeviceState %d\n", newDeviceState));
7965 TI_DBG2(("ossaSetDeviceStateCB: previousDeviceState %d\n", previousDeviceState));
7966
7967 if (agDevHandle == agNULL)
7968 {
7969 TI_DBG4(("ossaSetDeviceStateCB: agDevHandle is NULL\n"));
7970 return;
7971 }
7972
7973 oneDeviceData = (tdsaDeviceData_t *)agDevHandle->osData;
7974
7975 if (oneDeviceData == agNULL)
7976 {
7977 TI_DBG1(("ossaSetDeviceStateCB: wrong; oneDeviceData is NULL\n"));
7978 }
7979 else
7980 {
7981 TI_DBG2(("ossaSetDeviceStateCB: did %d\n", oneDeviceData->id));
7982 }
7983
7984 return;
7985 }
7986
7987 /*****************************************************************************/
7988 /*! \brief ossaGetDeviceStateCB
7989 *
7990 *
7991 * Purpose: ossaGetDeviceStateCB() is the response callback function
7992 * called by the LL Layer to indicate a response to
7993 * saGetDeviceState()
7994 *
7995 * \param agRoot: Pointer to chip/driver Instance.
7996 * \param agContext: Context of the operation originally
7997 * passed into saGetRegisterDump()
7998 * \param agDevHandle Pointer to the device handle of the device
7999 * \param status: status
8000 * \param deviceState: device status
8001 *
8002 * \return None.
8003 *
8004 */
8005 /*****************************************************************************/
ossaGetDeviceStateCB(agsaRoot_t * agRoot,agsaContext_t * agContext,agsaDevHandle_t * agDevHandle,bit32 status,bit32 deviceState)8006 GLOBAL void ossaGetDeviceStateCB(
8007 agsaRoot_t *agRoot,
8008 agsaContext_t *agContext,
8009 agsaDevHandle_t *agDevHandle,
8010 bit32 status,
8011 bit32 deviceState
8012 )
8013 {
8014 TI_DBG4(("ossaGetDeviceStateCB: start\n"));
8015 TI_DBG4(("ossaGetDeviceStateCB: status %d\n", status));
8016 TI_DBG4(("ossaGetDeviceStateCB: deviceState %d\n", deviceState));
8017
8018 return;
8019 }
8020
8021 #ifdef INITIATOR_DRIVER
8022 /*****************************************************************************/
8023 /*! \brief ossaIniSetDeviceInfoCB
8024 *
8025 *
8026 * Purpose: ossaIniSetDeviceInfoCB() is the response callback function
8027 * called by the LL Layer to indicate a response to
8028 * saSetDeviceInfo()
8029 *
8030 * \param agRoot: Pointer to chip/driver Instance.
8031 * \param agContext: Context of the operation originally
8032 * passed into saSetDeviceInfo()
8033 * \param agDevHandle Pointer to the device handle of the device
8034 * \param status: status
8035 * \param option: option parameter passed in saSetDeviceInfo()
8036 * \param param: param parameter passed in saSetDeviceInfo()
8037 *
8038 * \return None.
8039 *
8040 */
8041 /*****************************************************************************/
8042 osGLOBAL void
ossaIniSetDeviceInfoCB(agsaRoot_t * agRoot,agsaContext_t * agContext,agsaDevHandle_t * agDevHandle,bit32 status,bit32 option,bit32 param)8043 ossaIniSetDeviceInfoCB(
8044 agsaRoot_t *agRoot,
8045 agsaContext_t *agContext,
8046 agsaDevHandle_t *agDevHandle,
8047 bit32 status,
8048 bit32 option,
8049 bit32 param
8050 )
8051 {
8052 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
8053 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
8054 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData;
8055 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
8056 itdsaIni_t *Initiator = (itdsaIni_t *)tdsaAllShared->itdsaIni;
8057 bit32 intContext = osData->IntContext;
8058 tdIORequestBody_t *tdIORequestBody = agNULL;
8059 agsaIORequest_t *agIORequest = agNULL;
8060 bit32 saStatus = AGSA_RC_FAILURE;
8061 bit8 devType_S_Rate;
8062 tdsaDeviceData_t *oneDeviceData = agNULL;
8063
8064 TI_DBG4(("ossaIniSetDeviceInfoCB: start\n"));
8065 TI_DBG4(("ossaIniSetDeviceInfoCB: status 0x%x\n", status));
8066 TI_DBG4(("ossaIniSetDeviceInfoCB: option 0x%x\n", option));
8067 TI_DBG4(("ossaIniSetDeviceInfoCB: param 0x%x\n", param));
8068
8069 if (status != OSSA_SUCCESS)
8070 {
8071 TI_DBG1(("ossaIniSetDeviceInfoCB: status %d\n", status));
8072 TI_DBG1(("ossaIniSetDeviceInfoCB: option 0x%x\n", option));
8073 TI_DBG1(("ossaIniSetDeviceInfoCB: param 0x%x\n", param));
8074 if (option == 32) /* set connection rate */
8075 {
8076 TI_DBG1(("ossaIniSetDeviceInfoCB: IO failure\n"));
8077 agIORequest = (agsaIORequest_t *)agContext->osData;
8078 tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
8079 ostiInitiatorIOCompleted(
8080 tiRoot,
8081 tdIORequestBody->tiIORequest,
8082 tiIOFailed,
8083 tiDetailOtherError,
8084 agNULL,
8085 intContext
8086 );
8087 }
8088 }
8089 if (agDevHandle == agNULL)
8090 {
8091 TI_DBG4(("ossaIniSetDeviceInfoCB: agDevHandle is NULL\n"));
8092 return;
8093 }
8094 oneDeviceData = (tdsaDeviceData_t *)agDevHandle->osData;
8095 if (oneDeviceData == agNULL)
8096 {
8097 TI_DBG1(("ossaIniSetDeviceInfoCB: wrong; oneDeviceData is NULL\n"));
8098 return;
8099 }
8100 else
8101 {
8102 TI_DBG4(("ossaIniSetDeviceInfoCB: did %d\n", oneDeviceData->id));
8103 }
8104
8105 /* retry IOs */
8106 if (option == 32) /* set connection rate */
8107 {
8108 TI_DBG1(("ossaIniSetDeviceInfoCB: set connection rate option\n"));
8109 agIORequest = (agsaIORequest_t *)agContext->osData;
8110 tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
8111 devType_S_Rate = oneDeviceData->agDeviceInfo.devType_S_Rate;
8112 devType_S_Rate = (devType_S_Rate & 0xF0) | (param >> 28);
8113 oneDeviceData->agDeviceInfo.devType_S_Rate = devType_S_Rate;
8114 TI_DBG1(("ossaIniSetDeviceInfoCB: new rate is 0x%x\n", DEVINFO_GET_LINKRATE(&oneDeviceData->agDeviceInfo)));
8115 if (oneDeviceData->valid == agTRUE && oneDeviceData->registered == agTRUE &&
8116 oneDeviceData->tdPortContext != agNULL )
8117 {
8118 saStatus = saSSPStart(agRoot,
8119 agIORequest,
8120 tdsaRotateQnumber(tiRoot, oneDeviceData),
8121 agDevHandle,
8122 tdIORequestBody->agRequestType,
8123 &(tdIORequestBody->transport.SAS.agSASRequestBody),
8124 agNULL,
8125 &ossaSSPCompleted);
8126 if (saStatus == AGSA_RC_SUCCESS)
8127 {
8128 TI_DBG1(("ossaIniSetDeviceInfoCB: retried\n"));
8129 Initiator->NumIOsActive++;
8130 tdIORequestBody->ioStarted = agTRUE;
8131 tdIORequestBody->ioCompleted = agFALSE;
8132 return;
8133 }
8134 else
8135 {
8136 TI_DBG1(("ossaIniSetDeviceInfoCB: retry failed\n"));
8137 tdIORequestBody->ioStarted = agFALSE;
8138 tdIORequestBody->ioCompleted = agTRUE;
8139 ostiInitiatorIOCompleted(
8140 tiRoot,
8141 tdIORequestBody->tiIORequest,
8142 tiIOFailed,
8143 tiDetailOtherError,
8144 agNULL,
8145 intContext
8146 );
8147 }
8148 }
8149 }
8150 return;
8151 }
8152 #endif
8153 /*****************************************************************************/
8154 /*! \brief ossaSetDeviceInfoCB
8155 *
8156 *
8157 * Purpose: ossaSetDeviceInfoCB() is the response callback function
8158 * called by the LL Layer to indicate a response to
8159 * saSetDeviceInfo()
8160 *
8161 * \param agRoot: Pointer to chip/driver Instance.
8162 * \param agContext: Context of the operation originally
8163 * passed into saSetDeviceInfo()
8164 * \param agDevHandle Pointer to the device handle of the device
8165 * \param status: status
8166 * \param option: option parameter passed in saSetDeviceInfo()
8167 * \param param: param parameter passed in saSetDeviceInfo()
8168 *
8169 * \return None.
8170 *
8171 */
8172 /*****************************************************************************/
ossaSetDeviceInfoCB(agsaRoot_t * agRoot,agsaContext_t * agContext,agsaDevHandle_t * agDevHandle,bit32 status,bit32 option,bit32 param)8173 GLOBAL void ossaSetDeviceInfoCB(
8174 agsaRoot_t *agRoot,
8175 agsaContext_t *agContext,
8176 agsaDevHandle_t *agDevHandle,
8177 bit32 status,
8178 bit32 option,
8179 bit32 param
8180 )
8181 {
8182 tdsaDeviceData_t *oneDeviceData = agNULL;
8183
8184 TI_DBG4(("ossaSetDeviceInfoCB: start\n"));
8185 TI_DBG4(("ossaSetDeviceInfoCB: status 0x%x\n", status));
8186 TI_DBG4(("ossaSetDeviceInfoCB: option 0x%x\n", option));
8187 TI_DBG4(("ossaSetDeviceInfoCB: param 0x%x\n", param));
8188
8189 if (status != OSSA_SUCCESS)
8190 {
8191 TI_DBG1(("ossaSetDeviceInfoCB: status %d\n", status));
8192 TI_DBG1(("ossaSetDeviceInfoCB: option 0x%x\n", option));
8193 TI_DBG1(("ossaSetDeviceInfoCB: param 0x%x\n", param));
8194 }
8195
8196 if (agDevHandle == agNULL)
8197 {
8198 TI_DBG4(("ossaSetDeviceInfoCB: agDevHandle is NULL\n"));
8199 return;
8200 }
8201
8202 oneDeviceData = (tdsaDeviceData_t *)agDevHandle->osData;
8203
8204 if (oneDeviceData == agNULL)
8205 {
8206 TI_DBG1(("ossaSetDeviceInfoCB: wrong; oneDeviceData is NULL\n"));
8207 }
8208 else
8209 {
8210 TI_DBG4(("ossaSetDeviceInfoCB: did %d\n", oneDeviceData->id));
8211 }
8212
8213 return;
8214 }
8215
8216 /*****************************************************************************/
8217 /*! \brief ossaGetDFEDataCB
8218 *
8219 *
8220 * Purpose: ossaGetDFEDataCB() is the response callback function
8221 * called by the LL Layer to indicate a response to
8222 * saGetDFEData()
8223 *
8224 * \param agRoot: Pointer to chip/driver Instance.
8225 * \param agContext: Context of the operation originally
8226 * passed into saGetDFEData()
8227 * \param status: status
8228 * \param agInfoLen: length in bytes of DFE data captured and transferred
8229 *
8230 * \return None.
8231 *
8232 */
8233 /*****************************************************************************/
ossaGetDFEDataCB(agsaRoot_t * agRoot,agsaContext_t * agContext,bit32 status,bit32 agInfoLen)8234 GLOBAL void ossaGetDFEDataCB(
8235 agsaRoot_t *agRoot,
8236 agsaContext_t *agContext,
8237 bit32 status,
8238 bit32 agInfoLen)
8239 {
8240 TI_DBG1(("ossaGetDFEDataCB: start\n"));
8241 TI_DBG1(("ossaGetDFEDataCB: status 0x%x agInfoLen 0x%x\n", status, agInfoLen));
8242 return;
8243 }
8244
8245 /*****************************************************************************/
8246 /*! \brief ossaVhistCaptureCB
8247 *
8248 *
8249 * Purpose: ossaVhistCaptureCB() is the response callback function
8250 * called by the LL Layer to indicate a response to
8251 * saGetDFEData()
8252 *
8253 * \param agRoot: Pointer to chip/driver Instance.
8254 * \param agContext: Context of the operation originally
8255 * passed into ()
8256 * \param status: status
8257 * \param len: length in bytes of Vis data captured and transferred
8258 *
8259 * \return None.
8260 *
8261 */
8262 /*****************************************************************************/
8263
ossaVhistCaptureCB(agsaRoot_t * agRoot,agsaContext_t * agContext,bit32 status,bit32 len)8264 void ossaVhistCaptureCB(
8265 agsaRoot_t *agRoot,
8266 agsaContext_t *agContext,
8267 bit32 status,
8268 bit32 len)
8269 {
8270 TI_DBG1(("ossaVhistCaptureCB: start\n"));
8271 TI_DBG1(("ossaVhistCaptureCB: status 0x%x agInfoLen 0x%x\n", status,len ));
8272 return;
8273 }
8274
ossaOperatorManagementCB(agsaRoot_t * agRoot,agsaContext_t * agContext,bit32 status,bit32 eq)8275 GLOBAL void ossaOperatorManagementCB(
8276 agsaRoot_t *agRoot,
8277 agsaContext_t *agContext,
8278 bit32 status,
8279 bit32 eq
8280 )
8281 {
8282 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
8283 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
8284 tiEncryptPort_t encryptEventData;
8285
8286 TI_DBG1(("ossaOperatorManagementCB: status 0x%x eq 0x%x\n", status, eq));
8287
8288 osti_memset(&encryptEventData, 0, sizeof(tiEncryptPort_t));
8289 encryptEventData.encryptEvent = tiEncryptOperatorManagement;
8290 encryptEventData.subEvent = eq;
8291 encryptEventData.pData = agNULL;
8292
8293 ostiPortEvent(tiRoot,
8294 tiEncryptOperation,
8295 status,
8296 &encryptEventData);
8297 }
8298
ossaEncryptSelftestExecuteCB(agsaRoot_t * agRoot,agsaContext_t * agContext,bit32 status,bit32 type,bit32 length,void * TestResult)8299 GLOBAL void ossaEncryptSelftestExecuteCB (
8300 agsaRoot_t *agRoot,
8301 agsaContext_t *agContext,
8302 bit32 status,
8303 bit32 type,
8304 bit32 length,
8305 void *TestResult
8306 )
8307 {
8308 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
8309 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
8310 tiEncryptPort_t encryptEventData;
8311
8312 TI_DBG1(("ossaEncryptSelftestExecuteCB: status 0x%x type 0x%x length 0x%x\n", status, type, length));
8313
8314 osti_memset(&encryptEventData, 0, sizeof(tiEncryptPort_t));
8315 encryptEventData.encryptEvent = tiEncryptSelfTest;
8316 encryptEventData.subEvent = type;
8317 encryptEventData.pData = (void*)TestResult;
8318
8319 ostiPortEvent(tiRoot,
8320 tiEncryptOperation,
8321 status,
8322 &encryptEventData);
8323 }
8324
ossaGetOperatorCB(agsaRoot_t * agRoot,agsaContext_t * agContext,bit32 status,bit32 option,bit32 num,bit32 role,agsaID_t * id)8325 GLOBAL void ossaGetOperatorCB(
8326 agsaRoot_t *agRoot,
8327 agsaContext_t *agContext,
8328 bit32 status,
8329 bit32 option,
8330 bit32 num,
8331 bit32 role,
8332 agsaID_t *id
8333 )
8334 {
8335
8336 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
8337 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
8338 tiEncryptPort_t encryptEventData;
8339
8340 TI_DBG1(("ossaGetOperatorCB: status 0x%x option 0x%x num 0x%x role 0x%x\n",
8341 status, option, num, role));
8342 TI_DBG1(("ossaGetOperatorCB: agContext %p id %p\n",agContext,id));
8343 osti_memset(&encryptEventData, 0, sizeof(tiEncryptPort_t));
8344 encryptEventData.encryptEvent = tiEncryptGetOperator;
8345 encryptEventData.subEvent = option;
8346 encryptEventData.pData = agNULL;
8347
8348 switch(status)
8349 {
8350 case OSSA_IO_SUCCESS:
8351 TI_DBG1(("ossaGetOperatorCB: OSSA_IO_SUCCESS option 0x%x\n", option));
8352 if(option == 1)
8353 {
8354 TI_DBG2(("ossaGetOperatorCB: 0x%02x 0x%02x 0x%02x 0x%02x\n",id->ID[0], id->ID[1], id->ID[2], id->ID[3]));
8355 TI_DBG2(("ossaGetOperatorCB: 0x%02x 0x%02x 0x%02x 0x%02x\n",id->ID[4], id->ID[5], id->ID[6], id->ID[7]));
8356 TI_DBG2(("ossaGetOperatorCB: 0x%02x 0x%02x 0x%02x 0x%02x\n",id->ID[8], id->ID[9], id->ID[10],id->ID[11]));
8357 TI_DBG2(("ossaGetOperatorCB: 0x%02x 0x%02x 0x%02x 0x%02x\n",id->ID[12],id->ID[13],id->ID[14],id->ID[15]));
8358 TI_DBG2(("ossaGetOperatorCB: 0x%02x 0x%02x 0x%02x 0x%02x\n",id->ID[16],id->ID[17],id->ID[18],id->ID[19]));
8359 TI_DBG2(("ossaGetOperatorCB: 0x%02x 0x%02x 0x%02x 0x%02x\n",id->ID[20],id->ID[21],id->ID[22],id->ID[23]));
8360 TI_DBG2(("ossaGetOperatorCB: 0x%02x 0x%02x 0x%02x 0x%02x\n",id->ID[24],id->ID[25],id->ID[26],id->ID[27]));
8361 TI_DBG2(("ossaGetOperatorCB: 0x%02x 0x%02x 0x%02x\n", id->ID[28],id->ID[29],id->ID[30]));
8362 }else if(option == 2)
8363 {
8364 TI_DBG1(("ossaGetOperatorCB: number operators 0x%02x\n", num ));
8365 }
8366
8367 encryptEventData.pData = id;
8368 break;
8369 case OSSA_MPI_ENC_ERR_UNSUPPORTED_OPTION:
8370 TI_DBG1(("ossaGetOperatorCB: OSSA_MPI_ENC_ERR_UNSUPPORTED_OPTION 0x%x\n",option));
8371 break;
8372 case OSSA_MPI_ENC_ERR_ID_TRANSFER_FAILURE:
8373 TI_DBG1(("ossaGetOperatorCB: OSSA_MPI_ENC_ERR_ID_TRANSFER_FAILURE 0x%x\n",option));
8374 break;
8375 default:
8376 TI_DBG1(("ossaGetOperatorCB: Unknown status 0x%x\n",status));
8377 }
8378 ostiPortEvent(tiRoot,
8379 tiEncryptOperation,
8380 status,
8381 &encryptEventData);
8382
8383 }
8384
ossaSetOperatorCB(agsaRoot_t * agRoot,agsaContext_t * agContext,bit32 status,bit32 eq)8385 GLOBAL void ossaSetOperatorCB(
8386 agsaRoot_t *agRoot,
8387 agsaContext_t *agContext,
8388 bit32 status,
8389 bit32 eq
8390 )
8391 {
8392 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
8393 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
8394 tiEncryptPort_t encryptEventData;
8395
8396 TI_DBG1(("ossaSetOperatorCB: agContext %p status 0x%x eq 0x%x\n",agContext, status, eq));
8397
8398 osti_memset(&encryptEventData, 0, sizeof(tiEncryptPort_t));
8399 encryptEventData.encryptEvent = tiEncryptSetOperator;
8400 encryptEventData.subEvent = 0;
8401 switch(status)
8402 {
8403 case OSSA_IO_SUCCESS:
8404 TI_DBG1(("ossaSetOperatorCB: OSSA_IO_SUCCESS\n"));
8405 encryptEventData.pData = agNULL;
8406 break;
8407 case OSSA_MPI_ENC_ERR_CONTROLLER_NOT_IDLE:
8408 TI_DBG1(("ossaSetOperatorCB: OSSA_MPI_ENC_ERR_CONTROLLER_NOT_IDLE\n"));
8409 break;
8410 case OSSA_MPI_ENC_OPERATOR_AUTH_FAILURE:
8411 TI_DBG1(("ossaSetOperatorCB: OSSA_MPI_ENC_OPERATOR_AUTH_FAILURE error qualifier 0x%x\n",eq));
8412 break;
8413 case OSSA_MPI_ENC_OPERATOR_OPERATOR_ALREADY_LOGGED_IN:
8414 TI_DBG1(("ossaSetOperatorCB: OSSA_MPI_ENC_OPERATOR_OPERATOR_ALREADY_LOGGED_IN\n"));
8415 break;
8416 case OSSA_MPI_ENC_OPERATOR_ILLEGAL_PARAMETER:
8417 TI_DBG1(("ossaSetOperatorCB: OSSA_MPI_ENC_OPERATOR_ILLEGAL_PARAMETER\n"));
8418 break;
8419 case OSSA_MPI_ENC_ERR_UNSUPPORTED_OPTION:
8420 TI_DBG1(("ossaSetOperatorCB: OSSA_MPI_ENC_ERR_UNSUPPORTED_OPTION\n"));
8421 break;
8422 case OSSA_MPI_ENC_ERR_ID_TRANSFER_FAILURE:
8423 TI_DBG1(("ossaSetOperatorCB: OSSA_MPI_ENC_ERR_ID_TRANSFER_FAILURE\n"));
8424 break;
8425 default:
8426 TI_DBG1(("ossaGetOperatorCB: Unknown status 0x%x\n",status));
8427 }
8428 ostiPortEvent(tiRoot,
8429 tiEncryptOperation,
8430 status,
8431 &encryptEventData);
8432 }
8433
ossaDIFEncryptionOffloadStartCB(agsaRoot_t * agRoot,agsaContext_t * agContext,bit32 status,agsaOffloadDifDetails_t * agsaOffloadDifDetails)8434 GLOBAL void ossaDIFEncryptionOffloadStartCB(
8435 agsaRoot_t *agRoot,
8436 agsaContext_t *agContext,
8437 bit32 status,
8438 agsaOffloadDifDetails_t *agsaOffloadDifDetails)
8439 {
8440 TI_DBG1(("ossaDIFEncryptionOffloadStartCB: start\n"));
8441 TI_DBG1(("ossaDIFEncryptionOffloadStartCB: status 0x%x agsaOffloadDifDetails=%p\n", status, agsaOffloadDifDetails));
8442 return;
8443 }
8444
ossaTimeStamp(agsaRoot_t * agRoot)8445 GLOBAL bit32 ossaTimeStamp( agsaRoot_t *agRoot )
8446 {
8447 tdsaRootOsData_t *osData= agNULL;
8448 tiRoot_t *tiRoot= agNULL;
8449 if(agRoot)
8450 {
8451 osData = (tdsaRootOsData_t *)agRoot->osData;
8452 }
8453 if(osData)
8454 {
8455 tiRoot = (tiRoot_t *)osData->tiRoot;
8456 }
8457 return(ostiTimeStamp(tiRoot));
8458 }
8459
ossaTimeStamp64(agsaRoot_t * agRoot)8460 GLOBAL bit64 ossaTimeStamp64( agsaRoot_t *agRoot)
8461 {
8462 tdsaRootOsData_t *osData= agNULL;
8463 tiRoot_t *tiRoot= agNULL;
8464 if(agRoot)
8465 {
8466 osData = (tdsaRootOsData_t *)agRoot->osData;
8467 }
8468 if(osData)
8469 {
8470 tiRoot = (tiRoot_t *)osData->tiRoot;
8471 }
8472 return(ostiTimeStamp64(tiRoot));
8473 }
8474
8475 #ifdef FDS_SM
8476 osGLOBAL void
tdIDStartTimer(tiRoot_t * tiRoot,smIORequest_t * smIORequest,tdsaDeviceData_t * oneDeviceData)8477 tdIDStartTimer(tiRoot_t *tiRoot,
8478 smIORequest_t *smIORequest,
8479 tdsaDeviceData_t *oneDeviceData
8480 )
8481 {
8482 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData;
8483 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
8484 itdsaIni_t *Initiator = (itdsaIni_t *)tdsaAllShared->itdsaIni;
8485
8486 TI_DBG1(("tdIDStartTimer: start\n"));
8487
8488 tdsaSingleThreadedEnter(tiRoot, TD_TIMER_LOCK);
8489 if (oneDeviceData->tdIDTimer.timerRunning == agTRUE)
8490 {
8491 tdsaSingleThreadedLeave(tiRoot, TD_TIMER_LOCK);
8492 tdsaKillTimer(
8493 tiRoot,
8494 &oneDeviceData->tdIDTimer
8495 );
8496 }
8497 else
8498 {
8499 tdsaSingleThreadedLeave(tiRoot, TD_TIMER_LOCK);
8500 }
8501
8502 tdsaSetTimerRequest(
8503 tiRoot,
8504 &oneDeviceData->tdIDTimer,
8505 SATA_ID_DEVICE_DATA_TIMER_VALUE/Initiator->OperatingOption.UsecsPerTick,
8506 tdIDStartTimerCB,
8507 smIORequest,
8508 oneDeviceData,
8509 agNULL
8510 );
8511
8512 tdsaAddTimer(
8513 tiRoot,
8514 &Initiator->timerlist,
8515 &oneDeviceData->tdIDTimer
8516 );
8517 TI_DBG1(("tdIDStartTimer: end\n"));
8518 return;
8519 }
8520
8521 osGLOBAL void
tdIDStartTimerCB(tiRoot_t * tiRoot,void * timerData1,void * timerData2,void * timerData3)8522 tdIDStartTimerCB(
8523 tiRoot_t * tiRoot,
8524 void * timerData1,
8525 void * timerData2,
8526 void * timerData3
8527 )
8528 {
8529 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData;
8530 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
8531 smIORequest_t *smIORequest;
8532 tdsaDeviceData_t *oneDeviceData;
8533 smRoot_t *smRoot;
8534 tdIORequestBody_t *tdIORequestBody;
8535 smDeviceHandle_t *smDeviceHandle;
8536 tdsaPortContext_t *onePortContext;
8537 #ifdef REMOVED
8538 agsaRoot_t *agRoot;
8539 bit32 IDstatus;
8540 //#endif
8541 //#ifdef REMOVED
8542 agsaIORequest_t *agAbortIORequest = agNULL;
8543 tdIORequestBody_t *tdAbortIORequestBody = agNULL;
8544 bit32 PhysUpper32;
8545 bit32 PhysLower32;
8546 bit32 memAllocStatus;
8547 void *osMemHandle;
8548 #endif // REMOVED
8549 #ifdef TD_DEBUG_ENABLE
8550 bit32 status = AGSA_RC_FAILURE;
8551 #endif
8552
8553 TI_DBG1(("tdIDStartTimerCB start\n"));
8554 smIORequest = (smIORequest_t *)timerData1;
8555 oneDeviceData = (tdsaDeviceData_t *)timerData2;
8556 smRoot = &(tdsaAllShared->smRoot);
8557 #ifdef REMOVED
8558 agRoot = oneDeviceData->agRoot;
8559 #endif // REMOVED
8560
8561 if (smIORequest == agNULL)
8562 {
8563 TI_DBG1(("tdIDStartTimerCB: smIORequest == agNULL !!!!!!\n"));
8564 return;
8565 }
8566
8567 if (oneDeviceData == agNULL)
8568 {
8569 TI_DBG1(("tdIDStartTimerCB: oneDeviceData == agNULL !!!!!!\n"));
8570 return;
8571 }
8572
8573 if (oneDeviceData->satDevData.IDPending == agFALSE || oneDeviceData->satDevData.IDDeviceValid == agTRUE)
8574 {
8575 /*the Identify Device command already normally completed, just return*/
8576 return;
8577 }
8578
8579 tdIORequestBody = (tdIORequestBody_t *)smIORequest->tdData;
8580 smDeviceHandle = (smDeviceHandle_t *)&(oneDeviceData->smDeviceHandle);
8581 onePortContext = oneDeviceData->tdPortContext;
8582 if (tdIORequestBody == agNULL)
8583 {
8584 TI_DBG1(("tdIDStartTimerCB: tdIORequestBody == agNULL !!!!!!\n"));
8585 return;
8586 }
8587
8588 if (smDeviceHandle == agNULL)
8589 {
8590 TI_DBG1(("tdIDStartTimerCB: smDeviceHandle == agNULL !!!!!!\n"));
8591 return;
8592 }
8593
8594 if (onePortContext == agNULL)
8595 {
8596 TI_DBG1(("tdIDStartTimerCB: onePortContext == agNULL !!!!!!\n"));
8597 return;
8598 }
8599
8600 TI_DBG1(("tdIDStartTimerCB: did %d\n", oneDeviceData->id));
8601 /*
8602 1. smIOabort()
8603 2. in tdsmIDCompletedCB(), retry
8604 */
8605 if (oneDeviceData->valid == agFALSE)
8606 {
8607 TI_DBG1(("tdIDStartTimerCB: invalid device\n"));
8608 return;
8609 }
8610 #ifdef TD_DEBUG_ENABLE
8611 status = smIOAbort( smRoot, smIORequest );
8612 #else
8613 smIOAbort( smRoot, smIORequest );
8614 #endif
8615
8616 #ifdef REMOVED
8617 /* allocating agIORequest for abort itself */
8618 memAllocStatus = ostiAllocMemory(
8619 tiRoot,
8620 &osMemHandle,
8621 (void **)&tdAbortIORequestBody,
8622 &PhysUpper32,
8623 &PhysLower32,
8624 8,
8625 sizeof(tdIORequestBody_t),
8626 agTRUE
8627 );
8628 if (memAllocStatus != tiSuccess)
8629 {
8630 /* let os process IO */
8631 TI_DBG1(("tdIDStartTimerCB: ostiAllocMemory failed...; can't retry ID data \n"));
8632 return;
8633 }
8634 if (tdAbortIORequestBody == agNULL)
8635 {
8636 /* let os process IO */
8637 TI_DBG1(("tdIDStartTimerCB: ostiAllocMemory returned NULL tdAbortIORequestBody; can't retry ID data\n"));
8638 return;
8639 }
8640 /* setup task management structure */
8641 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle = osMemHandle;
8642 /* setting callback but not used later */
8643 tdAbortIORequestBody->IOCompletionFunc = agNULL;
8644 //tdAbortIORequestBody->IOCompletionFunc = itdssIOAbortedHandler;
8645 tdAbortIORequestBody->tiDevHandle = (tiDeviceHandle_t *)&(oneDeviceData->tiDeviceHandle);
8646 /* initialize agIORequest */
8647 agAbortIORequest = &(tdAbortIORequestBody->agIORequest);
8648 agAbortIORequest->osData = (void *) tdAbortIORequestBody;
8649 agAbortIORequest->sdkData = agNULL; /* LL takes care of this */
8650 //#endif
8651 //#ifdef REMOVED
8652 status = saSATAAbort(agRoot,
8653 agAbortIORequest,
8654 0,
8655 oneDeviceData->agDevHandle,
8656 1, /* abort all */
8657 agNULL,
8658 ossaSATAIDAbortCB
8659 );
8660 status = saSATAAbort(agRoot,
8661 agAbortIORequest,
8662 0,
8663 oneDeviceData->agDevHandle,
8664 0, /* abort one */
8665 agIORequest,
8666 ossaSATAIDAbortCB
8667 );
8668 //#endif
8669 //#ifdef REMOVED
8670 if (status != AGSA_RC_SUCCESS)
8671 {
8672 TI_DBG1(("tdIDStartTimerCB: saSATAAbort failed; can't retry ID data\n"));
8673 }
8674 if (oneDeviceData->satDevData.IDDeviceValid == agTRUE)
8675 {
8676 TI_DBG1(("tdIDStartTimerCB: IDDeviceValid is valid, no need to retry\n"));
8677 return;
8678 }
8679 if (tdIORequestBody->reTries <= SM_RETRIES)
8680 {
8681 tdIORequestBody->tiIORequest = agNULL; /* not in use */
8682 tdIORequestBody->pid = onePortContext->id;
8683 smIORequest->tdData = tdIORequestBody;
8684 smIORequest->smData = &tdIORequestBody->smIORequestBody;
8685 smDeviceHandle->tdData = oneDeviceData;
8686 IDstatus = smIDStart(smRoot, smIORequest, smDeviceHandle );
8687 if (IDstatus == SM_RC_SUCCESS)
8688 {
8689 TI_DBG1(("tdIDStartTimerCB: being retried!!!\n"));
8690 tdIORequestBody->reTries++;
8691 tdIORequestBody->ioCompleted = agFALSE;
8692 tdIORequestBody->ioStarted = agTRUE;
8693 tdIDStartTimer(tiRoot, smIORequest, oneDeviceData);
8694 }
8695 else
8696 {
8697 /* identify device data is not valid */
8698 TI_DBG1(("tdIDStartTimerCB: smIDStart fail or busy %d!!!\n", IDstatus));
8699 tdIORequestBody->reTries = 0;
8700 tdIORequestBody->ioCompleted = agTRUE;
8701 tdIORequestBody->ioStarted = agFALSE;
8702 ostiFreeMemory( tiRoot,
8703 tdIORequestBody->osMemHandle,
8704 sizeof(tdIORequestBody_t)
8705 );
8706 oneDeviceData->satDevData.IDDeviceValid = agFALSE;
8707 smReportRemoval(tiRoot, agRoot, oneDeviceData, onePortContext);
8708 return;
8709 }
8710 }
8711 else
8712 {
8713 /* give up */
8714 TI_DBG1(("tdIDStartTimerCB: retries are over!!!\n"));
8715 if (oneDeviceData->tdIDTimer.timerRunning == agTRUE)
8716 {
8717 tdsaKillTimer( tiRoot, &oneDeviceData->tdIDTimer );
8718 }
8719 tdIORequestBody->reTries = 0;
8720 tdIORequestBody->ioCompleted = agTRUE;
8721 tdIORequestBody->ioStarted = agFALSE;
8722 ostiFreeMemory(
8723 tiRoot,
8724 tdIORequestBody->osMemHandle,
8725 sizeof(tdIORequestBody_t)
8726 );
8727 oneDeviceData->satDevData.IDDeviceValid = agFALSE;
8728
8729 if (oneDeviceData->SMNumOfID <= 0) /* does SMP HARD RESET only upto one time */
8730 {
8731 TI_DBG1(("tdIDStartTimerCB: fail; sending HARD_RESET\n"));
8732 oneDeviceData->SMNumOfID++;
8733 if (oneDeviceData->directlyAttached == agTRUE)
8734 {
8735 saLocalPhyControl(agRoot, agNULL, 0, oneDeviceData->phyID, AGSA_PHY_HARD_RESET, agNULL);
8736 }
8737 else
8738 {
8739 tdsaPhyControlSend(tiRoot,
8740 oneDeviceData,
8741 SMP_PHY_CONTROL_HARD_RESET,
8742 agNULL);
8743 }
8744 }
8745 else
8746 {
8747 /* given up after one time of SMP HARD RESET; */
8748 TI_DBG1(("tdIDStartTimerCB: fail; but giving up sending HARD_RESET!!!\n"));
8749 if (oneDeviceData->directlyAttached == agTRUE)
8750 {
8751 smReportRemovalDirect(tiRoot, agRoot, oneDeviceData);
8752 }
8753 else
8754 {
8755 smReportRemoval(tiRoot, agRoot, oneDeviceData, onePortContext);
8756 }
8757 }
8758 }
8759 #endif // REMOVED
8760
8761 TI_DBG1(("tdIDStartTimerCB: end, smIOAbort status %d\n", status));
8762 return;
8763 }
8764 #endif // FDS_SM
8765
8766
8767 #if defined(FDS_DM) && defined(FDS_SM)
8768 //start here
8769 GLOBAL void
tdIDStart(tiRoot_t * tiRoot,agsaRoot_t * agRoot,smRoot_t * smRoot,tdsaDeviceData_t * oneDeviceData,tdsaPortContext_t * onePortContext)8770 tdIDStart(
8771 tiRoot_t *tiRoot,
8772 agsaRoot_t *agRoot,
8773 smRoot_t *smRoot,
8774 tdsaDeviceData_t *oneDeviceData,
8775 tdsaPortContext_t *onePortContext
8776 )
8777 {
8778 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData;
8779 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
8780 bit32 SMstatus = SM_RC_FAILURE;
8781 tdIORequestBody_t *tdIORequestBody;
8782 smIORequest_t *smIORequest;
8783 smDeviceHandle_t *smDeviceHandle;
8784 bit32 PhysUpper32;
8785 bit32 PhysLower32;
8786 bit32 memAllocStatus;
8787 void *osMemHandle;
8788
8789
8790 TI_DBG1(("tdIDStart: start, did %d\n",oneDeviceData->id));
8791
8792 if ( (DEVICE_IS_SATA_DEVICE(oneDeviceData)|| DEVICE_IS_STP_TARGET(oneDeviceData))
8793 &&
8794 oneDeviceData->satDevData.IDDeviceValid == agFALSE
8795 &&
8796 oneDeviceData->satDevData.IDPending == agFALSE
8797 )
8798 {
8799 TI_DBG2(("tdIDStart: in loop, did %d\n", oneDeviceData->id));
8800 /* allocating tdIORequestBody */
8801 memAllocStatus = ostiAllocMemory(
8802 tiRoot,
8803 &osMemHandle,
8804 (void **)&tdIORequestBody,
8805 &PhysUpper32,
8806 &PhysLower32,
8807 8,
8808 sizeof(tdIORequestBody_t),
8809 agTRUE
8810 );
8811 if (memAllocStatus != tiSuccess || tdIORequestBody == agNULL)
8812 {
8813 /* let os process IO */
8814 TI_DBG1(("tdIDStart: ostiAllocMemory failed... or ostiAllocMemory returned NULL tdIORequestBody!!!\n"));
8815 oneDeviceData->satDevData.IDDeviceValid = agFALSE;
8816 if (oneDeviceData->directlyAttached == agTRUE)
8817 {
8818 /* notifying link up */
8819 ostiPortEvent(
8820 tiRoot,
8821 tiPortLinkUp,
8822 tiSuccess,
8823 (void *)onePortContext->tiPortalContext
8824 );
8825 #ifdef INITIATOR_DRIVER
8826 /* triggers discovery */
8827 ostiPortEvent(
8828 tiRoot,
8829 tiPortDiscoveryReady,
8830 tiSuccess,
8831 (void *) onePortContext->tiPortalContext
8832 );
8833 #endif
8834 }
8835 }
8836 else
8837 {
8838 /* initialize */
8839 osti_memset(tdIORequestBody, 0, sizeof(tdIORequestBody_t));
8840
8841 tdIORequestBody->osMemHandle = osMemHandle;
8842 TI_DBG2(("tdIDStart: tdIORequestBody %p tdIORequestBody->osMemHandle %p\n", tdIORequestBody, tdIORequestBody->osMemHandle));
8843
8844 /* not in use */
8845 tdIORequestBody->IOCompletionFunc = agNULL;
8846 tdIORequestBody->tiDevHandle = agNULL;
8847
8848 tdIORequestBody->tiIORequest = agNULL; /* not in use */
8849 tdIORequestBody->pid = onePortContext->id;
8850 tdIORequestBody->reTries = 0;
8851 smIORequest = (smIORequest_t *)&(tdIORequestBody->smIORequest);
8852 smIORequest->tdData = tdIORequestBody;
8853 smIORequest->smData = &tdIORequestBody->smIORequestBody;
8854
8855 smDeviceHandle = (smDeviceHandle_t *)&(oneDeviceData->smDeviceHandle);
8856 smDeviceHandle->tdData = oneDeviceData;
8857
8858 TI_DBG2(("tdIDStart: smIORequest %p\n", smIORequest));
8859
8860 SMstatus = smIDStart(smRoot,
8861 smIORequest,
8862 &(oneDeviceData->smDeviceHandle)
8863 );
8864
8865 if (SMstatus == SM_RC_SUCCESS)
8866 {
8867 if (oneDeviceData->directlyAttached == agTRUE)
8868 {
8869 TI_DBG2(("tdIDStart: successfully sent identify device data\n"));
8870
8871 /* Add the devicedata to the mainlink */
8872 tdsaSingleThreadedEnter(tiRoot, TD_DEVICE_LOCK);
8873 TDLIST_ENQUEUE_AT_TAIL(&(oneDeviceData->MainLink), &(tdsaAllShared->MainDeviceList));
8874 tdsaSingleThreadedLeave(tiRoot, TD_DEVICE_LOCK);
8875 TI_DBG6(("tdIDStart: one case did %d \n", oneDeviceData->id));
8876 }
8877 oneDeviceData->satDevData.IDPending = agTRUE;
8878 /* start a timer */
8879 tdIDStartTimer(tiRoot, smIORequest, oneDeviceData);
8880 }
8881 else
8882 {
8883 /* failed to send */
8884 TI_DBG1(("tdIDStart: smIDStart fail or busy %d\n", SMstatus));
8885
8886 /* free up allocated memory */
8887 ostiFreeMemory(
8888 tiRoot,
8889 tdIORequestBody->IOType.InitiatorTMIO.osMemHandle,
8890 sizeof(tdIORequestBody_t)
8891 );
8892
8893 oneDeviceData->satDevData.IDDeviceValid = agFALSE;
8894 if (oneDeviceData->directlyAttached == agTRUE)
8895 {
8896 TI_DBG1(("tdIDStart: failed in sending identify device data\n"));
8897 /* put onedevicedata back to free list */
8898 tdsaSingleThreadedEnter(tiRoot, TD_DEVICE_LOCK);
8899 TDLIST_ENQUEUE_AT_TAIL(&(oneDeviceData->FreeLink), &(tdsaAllShared->FreeDeviceList));
8900 tdsaSingleThreadedLeave(tiRoot, TD_DEVICE_LOCK);
8901 /* notifying link up */
8902 ostiPortEvent(
8903 tiRoot,
8904 tiPortLinkUp,
8905 tiSuccess,
8906 (void *)onePortContext->tiPortalContext
8907 );
8908 #ifdef INITIATOR_DRIVER
8909 /* triggers discovery */
8910 ostiPortEvent(
8911 tiRoot,
8912 tiPortDiscoveryReady,
8913 tiSuccess,
8914 (void *) onePortContext->tiPortalContext
8915 );
8916 #endif
8917 }
8918 else
8919 {
8920 smReportRemoval(tiRoot, agRoot, oneDeviceData, onePortContext);
8921 }
8922 }
8923 }
8924 }
8925 TI_DBG1(("tdIDStart: exit\n"));
8926 return;
8927 }
8928
8929 #endif
8930
8931 #ifdef SALLSDK_OS_IOMB_LOG_ENABLE
ossaLogIomb(agsaRoot_t * agRoot,bit32 queueNum,agBOOLEAN isInbound,void * pMsg,bit32 msgLength)8932 GLOBAL void ossaLogIomb(agsaRoot_t *agRoot,
8933 bit32 queueNum,
8934 agBOOLEAN isInbound,
8935 void *pMsg,
8936 bit32 msgLength)
8937 {
8938 return;
8939 }
8940 #endif /* SALLSDK_OS_IOMB_LOG_ENABLE */
8941
8942 #ifndef SATA_ENABLE
8943 /*
8944 * These callback routines are defined in ossasat.c which are included in the
8945 * compilation if SATA_ENABLED is defined.
8946 */
8947
8948 /*****************************************************************************
8949 *! \brief ossaDiscoverSataCB
8950 *
8951 * Purpose: This function is called by lower layer to inform TD layer of
8952 * STP/SATA discovery results
8953 *
8954 *
8955 * \param agRoot Pointer to chip/driver Instance.
8956 * \param agPortContext Pointer to the port context of TD and Lower layer
8957 * \param event event type
8958 * \param pParm1 Pointer to data associated with event
8959 * \param pParm2 Pointer to data associated with event
8960 *
8961 * \return: none
8962 *
8963 * \note - For details, refer to SAS/SATA Low-Level API Specification
8964 *
8965 *****************************************************************************/
8966
ossaDiscoverSataCB(agsaRoot_t * agRoot,agsaPortContext_t * agPortContext,bit32 event,void * pParm1,void * pParm2)8967 osGLOBAL void ossaDiscoverSataCB( agsaRoot_t *agRoot,
8968 agsaPortContext_t *agPortContext,
8969 bit32 event,
8970 void *pParm1,
8971 void *pParm2
8972 )
8973 {
8974 return;
8975 }
8976
8977
8978 /*****************************************************************************
8979 *! \brief ossaSATACompleted
8980 *
8981 * This routine is called to complete a SATA request previously issued to the
8982 * LL Layer in saSATAStart()
8983 *
8984 * \param agRoot: Handles for this instance of SAS/SATA hardware
8985 * \param agIORequest: Pointer to the LL I/O request context for this I/O.
8986 * \param agIOStatus: Status of completed I/O.
8987 * \param agFirstDword:Pointer to the four bytes of FIS.
8988 * \param agIOInfoLen: Length in bytes of overrun/underrun residual or FIS
8989 * length.
8990 * \param agParam: Additional info based on status.
8991 *
8992 * \return: none
8993 *
8994 *****************************************************************************/
ossaSATACompleted(agsaRoot_t * agRoot,agsaIORequest_t * agIORequest,bit32 agIOStatus,void * agFirstDword,bit32 agIOInfoLen,void * agParam)8995 GLOBAL void ossaSATACompleted(
8996 agsaRoot_t *agRoot,
8997 agsaIORequest_t *agIORequest,
8998 bit32 agIOStatus,
8999 void *agFirstDword,
9000 bit32 agIOInfoLen,
9001 void *agParam
9002 )
9003 {
9004 return;
9005 }
9006
9007
9008 /*****************************************************************************
9009 *! \brief ossaSATAEvent
9010 *
9011 * This routine is called to notify the OS Layer of an event associated with
9012 * SATA port or SATA device
9013 *
9014 * \param agRoot: Handles for this instance of SAS/SATA hardware
9015 * \param agIORequest: Pointer to the LL I/O request context for this I/O.
9016 * \param agPortContext Pointer to the port context of TD and Lower layer
9017 * \param agDevHandle: Pointer to a device handle
9018 * \param event: event type
9019 *
9020 * \return: none
9021 *
9022 *****************************************************************************/
ossaSATAEvent(agsaRoot_t * agRoot,agsaIORequest_t * agIORequest,agsaPortContext_t * agPortContext,agsaDevHandle_t * agDevHandle,bit32 event,bit32 agIOInfoLen,void * agParam)9023 osGLOBAL void ossaSATAEvent(
9024 agsaRoot_t *agRoot,
9025 agsaIORequest_t *agIORequest,
9026 agsaPortContext_t *agPortContext,
9027 agsaDevHandle_t *agDevHandle,
9028 bit32 event,
9029 bit32 agIOInfoLen,
9030 void *agParam
9031 )
9032 {
9033 return;
9034 }
9035
9036
9037 /*****************************************************************************
9038 *! \brief ossaSATADeviceResetCB
9039 *
9040 * This routine is called to complete a SATA device reset request previously
9041 * issued to the LL Layer in saSATADeviceReset().
9042 *
9043 * \param agRoot: Handles for this instance of SAS/SATA hardware
9044 * \param agDevHandle: Pointer to a device handle
9045 * \param resetStatus: Reset status:
9046 * OSSA_SUCCESS: The reset operation completed successfully.
9047 * OSSA_FAILURE: The reset operation failed.
9048 * \param resetparm: Pointer to the Device-To-Host FIS received from the device.
9049 *
9050 * \return: none
9051 *
9052 *****************************************************************************/
ossaSATADeviceResetCB(agsaRoot_t * agRoot,agsaDevHandle_t * agDevHandle,bit32 resetStatus,void * resetparm)9053 osGLOBAL void ossaSATADeviceResetCB(
9054 agsaRoot_t *agRoot,
9055 agsaDevHandle_t *agDevHandle,
9056 bit32 resetStatus,
9057 void *resetparm)
9058 {
9059
9060 return;
9061
9062 }
9063
9064 /*****************************************************************************
9065 *! \brief ossaDiscoverSasCB
9066 *
9067 * Purpose: This function is called by lower layer to inform TD layer of
9068 * SAS discovery results
9069 *
9070 *
9071 * \param agRoot Pointer to chip/driver Instance.
9072 * \param agPortContext Pointer to the port context of TD and Lower layer
9073 * \param event event type
9074 * \param pParm1 Pointer to data associated with event
9075 * \param pParm2 Pointer to data associated with event
9076 *
9077 * \return: none
9078 *
9079 * \note - For details, refer to SAS/SATA Low-Level API Specification
9080 *
9081 *****************************************************************************/
ossaDiscoverSasCB(agsaRoot_t * agRoot,agsaPortContext_t * agPortContext,bit32 event,void * pParm1,void * pParm2)9082 osGLOBAL void ossaDiscoverSasCB(agsaRoot_t *agRoot,
9083 agsaPortContext_t *agPortContext,
9084 bit32 event,
9085 void *pParm1,
9086 void *pParm2
9087 )
9088 {
9089 return;
9090 }
9091 #endif
9092
9093