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 #include <sys/cdefs.h>
23 #include <dev/pms/config.h>
24
25 #include <dev/pms/freebsd/driver/common/osenv.h>
26 #include <dev/pms/freebsd/driver/common/ostypes.h>
27 #include <dev/pms/freebsd/driver/common/osdebug.h>
28
29 #include <dev/pms/RefTisa/tisa/api/titypes.h>
30 #include <dev/pms/RefTisa/tisa/api/ostiapi.h>
31 #include <dev/pms/RefTisa/tisa/api/tiapi.h>
32 /* for TIDEBUG_MSG */
33 #include <dev/pms/RefTisa/tisa/api/tiglobal.h>
34
35 #ifdef FDS_SM
36
37 #include <dev/pms/RefTisa/sat/api/sm.h>
38 #include <dev/pms/RefTisa/sat/api/smapi.h>
39 #include <dev/pms/RefTisa/sat/api/tdsmapi.h>
40
41 #ifdef FDS_DM
42 #include <dev/pms/RefTisa/discovery/api/dm.h>
43 #endif
44
45 #ifdef INITIATOR_DRIVER
46 #include <dev/pms/RefTisa/tisa/sassata/sas/ini/itdtypes.h>
47 #endif
48
49 #include <dev/pms/RefTisa/tisa/sassata/sas/common/tdtypes.h>
50 #include <dev/pms/RefTisa/tisa/sassata/common/tdsatypes.h>
51 #include <dev/pms/RefTisa/tisa/sassata/common/tdproto.h>
52
53 #if defined(SM_DEBUG)
54 extern bit32 gSMDebugLevel;
55 #endif
56
57 osGLOBAL void
smReportRemovalDirect(tiRoot_t * tiRoot,agsaRoot_t * agRoot,tdsaDeviceData_t * oneDeviceData)58 smReportRemovalDirect(
59 tiRoot_t *tiRoot,
60 agsaRoot_t *agRoot,
61 tdsaDeviceData_t *oneDeviceData
62 )
63 {
64 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData;
65 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
66 bit8 PhyID;
67
68 TI_DBG2(("smReportRemovalDirect: start\n"));
69
70 PhyID = oneDeviceData->phyID;
71
72 tdsaAbortAll(tiRoot, agRoot, oneDeviceData);
73 oneDeviceData->valid = agFALSE;
74 oneDeviceData->valid2 = agFALSE;
75 /* put onedevicedata back to free list */
76 osti_memset(&(oneDeviceData->satDevData.satIdentifyData), 0xFF, sizeof(agsaSATAIdentifyData_t));
77 TDLIST_DEQUEUE_THIS(&(oneDeviceData->MainLink));
78 TDLIST_ENQUEUE_AT_TAIL(&(oneDeviceData->FreeLink), &(tdsaAllShared->FreeDeviceList));
79
80 /* notifying link up */
81 ostiPortEvent (
82 tiRoot,
83 tiPortLinkUp,
84 tiSuccess,
85 (void *)tdsaAllShared->Ports[PhyID].tiPortalContext
86 );
87 #ifdef INITIATOR_DRIVER
88 /* triggers discovery */
89 ostiPortEvent(
90 tiRoot,
91 tiPortDiscoveryReady,
92 tiSuccess,
93 (void *) tdsaAllShared->Ports[PhyID].tiPortalContext
94 );
95 #endif
96 return;
97 }
98
99 osGLOBAL void
smReportRemoval(tiRoot_t * tiRoot,agsaRoot_t * agRoot,tdsaDeviceData_t * oneDeviceData,tdsaPortContext_t * onePortContext)100 smReportRemoval(
101 tiRoot_t *tiRoot,
102 agsaRoot_t *agRoot,
103 tdsaDeviceData_t *oneDeviceData,
104 tdsaPortContext_t *onePortContext
105 )
106 {
107 TI_DBG2(("smReportRemoval: start\n"));
108
109 if (oneDeviceData->registered == agTRUE)
110 {
111 /*
112 1. remove this device
113 2. device removal event
114 */
115 tdsaAbortAll(tiRoot, agRoot, oneDeviceData);
116 oneDeviceData->valid = agFALSE;
117 oneDeviceData->valid2 = agFALSE;
118 oneDeviceData->registered = agFALSE;
119 ostiInitiatorEvent(
120 tiRoot,
121 onePortContext->tiPortalContext,
122 agNULL,
123 tiIntrEventTypeDeviceChange,
124 tiDeviceRemoval,
125 agNULL
126 );
127 }
128
129 return;
130 }
131 osGLOBAL void
smHandleDirect(tiRoot_t * tiRoot,agsaRoot_t * agRoot,tdsaDeviceData_t * oneDeviceData,void * IDdata)132 smHandleDirect(
133 tiRoot_t *tiRoot,
134 agsaRoot_t *agRoot,
135 tdsaDeviceData_t *oneDeviceData,
136 void *IDdata
137 )
138 {
139 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData;
140 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
141 agsaSATAIdentifyData_t *pSATAIdData;
142 tdList_t *DeviceListList;
143 tdsaDeviceData_t *tmpOneDeviceData = agNULL;
144 int new_device = agTRUE;
145 bit8 PhyID;
146
147 TI_DBG2(("smHandleDirect: start\n"));
148 PhyID = oneDeviceData->phyID;
149
150 pSATAIdData = (agsaSATAIdentifyData_t *)IDdata;
151 //tdhexdump("satAddSATAIDDevCB after", (bit8 *)pSATAIdData, sizeof(agsaSATAIdentifyData_t));
152
153 /* compare idenitfy device data to the exiting list */
154 DeviceListList = tdsaAllShared->MainDeviceList.flink;
155 while (DeviceListList != &(tdsaAllShared->MainDeviceList))
156 {
157 tmpOneDeviceData = TDLIST_OBJECT_BASE(tdsaDeviceData_t, MainLink, DeviceListList);
158 if (tmpOneDeviceData == agNULL)
159 {
160 TI_DBG1(("smHandleDirect: tmpOneDeviceData is NULL!!!\n"));
161 return;
162 }
163 TI_DBG1(("smHandleDirect: LOOP tmpOneDeviceData %p did %d\n", tmpOneDeviceData, tmpOneDeviceData->id));
164 //tdhexdump("smHandleDirect LOOP", (bit8 *)&tmpOneDeviceData->satDevData.satIdentifyData, sizeof(agsaSATAIdentifyData_t));
165
166 /* what is unique ID for sata device -> response of identify devicedata; not really
167 Let's compare serial number, firmware version, model number
168 */
169 if ( tmpOneDeviceData->DeviceType == TD_SATA_DEVICE &&
170 (osti_memcmp (tmpOneDeviceData->satDevData.satIdentifyData.serialNumber,
171 pSATAIdData->serialNumber,
172 20) == 0) &&
173 (osti_memcmp (tmpOneDeviceData->satDevData.satIdentifyData.firmwareVersion,
174 pSATAIdData->firmwareVersion,
175 8) == 0) &&
176 (osti_memcmp (tmpOneDeviceData->satDevData.satIdentifyData.modelNumber,
177 pSATAIdData->modelNumber,
178 40) == 0)
179 )
180 {
181 TI_DBG2(("smHandleDirect: did %d\n", tmpOneDeviceData->id));
182 new_device = agFALSE;
183 break;
184 }
185 DeviceListList = DeviceListList->flink;
186 }
187
188
189 if (new_device == agFALSE)
190 {
191 TI_DBG2(("smHandleDirect: old device data\n"));
192 tmpOneDeviceData->valid = agTRUE;
193 tmpOneDeviceData->valid2 = agTRUE;
194 /* save data field from new device data */
195 tmpOneDeviceData->agRoot = agRoot;
196 tmpOneDeviceData->agDevHandle = oneDeviceData->agDevHandle;
197 tmpOneDeviceData->agDevHandle->osData = tmpOneDeviceData; /* TD layer */
198 tmpOneDeviceData->tdPortContext = oneDeviceData->tdPortContext;
199 tmpOneDeviceData->phyID = oneDeviceData->phyID;
200
201 /*
202 one SATA directly attached device per phy;
203 Therefore, deregister then register
204 */
205 saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, tdsaRotateQnumber(tiRoot, oneDeviceData));
206
207 if (tmpOneDeviceData->registered == agFALSE)
208 {
209 TI_DBG2(("smHandleDirect: re-registering old device data\n"));
210 /* already has old information; just register it again */
211 saRegisterNewDevice( /* smHandleDirect */
212 agRoot,
213 &tmpOneDeviceData->agContext,
214 0,/*tdsaRotateQnumber(tiRoot, tmpOneDeviceData),*/
215 &tmpOneDeviceData->agDeviceInfo,
216 tmpOneDeviceData->tdPortContext->agPortContext,
217 0
218 );
219 }
220
221 // tdsaAbortAll(tiRoot, agRoot, oneDeviceData);
222 /* put tmpOneDeviceData back to free list */
223 osti_memset(&(oneDeviceData->satDevData.satIdentifyData), 0xFF, sizeof(agsaSATAIdentifyData_t));
224 TDLIST_DEQUEUE_THIS(&(oneDeviceData->MainLink));
225 TDLIST_ENQUEUE_AT_TAIL(&(oneDeviceData->FreeLink), &(tdsaAllShared->FreeDeviceList));
226
227 TI_DBG2(("smHandleDirect: pid %d\n", tdsaAllShared->Ports[PhyID].portContext->id));
228 /* notifying link up */
229 ostiPortEvent (
230 tiRoot,
231 tiPortLinkUp,
232 tiSuccess,
233 (void *)tdsaAllShared->Ports[PhyID].tiPortalContext
234 );
235
236
237 #ifdef INITIATOR_DRIVER
238 /* triggers discovery */
239 ostiPortEvent(
240 tiRoot,
241 tiPortDiscoveryReady,
242 tiSuccess,
243 (void *) tdsaAllShared->Ports[PhyID].tiPortalContext
244 );
245 #endif
246 return;
247 }
248
249 TI_DBG2(("smHandleDirect: new device data\n"));
250 oneDeviceData->satDevData.satIdentifyData = *pSATAIdData;
251 /* notifying link up */
252 ostiPortEvent (
253 tiRoot,
254 tiPortLinkUp,
255 tiSuccess,
256 (void *)tdsaAllShared->Ports[PhyID].tiPortalContext
257 );
258 #ifdef INITIATOR_DRIVER
259 /* triggers discovery */
260 ostiPortEvent(
261 tiRoot,
262 tiPortDiscoveryReady,
263 tiSuccess,
264 (void *) tdsaAllShared->Ports[PhyID].tiPortalContext
265 );
266 #endif
267
268 return;
269 }
270
271 /*
272 combine satAddSATAIDDevCB(expander) and satAddSATAIDDevCB(directly attached)
273 */
274 osGLOBAL void
tdsmIDCompletedCB(smRoot_t * smRoot,smIORequest_t * smIORequest,smDeviceHandle_t * smDeviceHandle,bit32 status,void * IDdata)275 tdsmIDCompletedCB(
276 smRoot_t *smRoot,
277 smIORequest_t *smIORequest,
278 smDeviceHandle_t *smDeviceHandle,
279 bit32 status,
280 void *IDdata
281 )
282 {
283 tdsaRoot_t *tdsaRoot;
284 tdsaContext_t *tdsaAllShared;
285 tiRoot_t *tiRoot;
286 agsaRoot_t *agRoot;
287 tdIORequestBody_t *tdIORequestBody;
288 tdsaDeviceData_t *oneDeviceData;
289 tdsaPortContext_t *onePortContext;
290 tiPortalContext_t *tiPortalContext;
291 bit32 pid = 0xff;
292 bit32 IDstatus;
293 agsaSATAIdentifyData_t *pSATAIdData;
294
295 TI_DBG2(("tdsmIDCompletedCB: start\n"));
296
297 tdsaRoot = (tdsaRoot_t *)smRoot->tdData;
298 tdsaAllShared = &(tdsaRoot->tdsaAllShared);
299 tiRoot = tdsaAllShared->agRootOsDataForInt.tiRoot;
300 tdIORequestBody = (tdIORequestBody_t *)smIORequest->tdData;
301
302 if (smDeviceHandle == agNULL)
303 {
304 TI_DBG1(("tdsmIDCompletedCB: smDeviceHandle is NULL !!!!\n"));
305 ostiFreeMemory(
306 tiRoot,
307 tdIORequestBody->osMemHandle,
308 sizeof(tdIORequestBody_t)
309 );
310 return;
311 }
312
313 oneDeviceData = (tdsaDeviceData_t *)smDeviceHandle->tdData;
314 onePortContext = oneDeviceData->tdPortContext;
315 agRoot = oneDeviceData->agRoot;
316 pid = tdIORequestBody->pid;
317
318
319 // oneDeviceData->satDevData.IDDeviceValid = agFALSE;
320 oneDeviceData->satDevData.IDPending = agFALSE;
321
322 TI_DBG2(("tdsmIDCompletedCB: tdIORequestBody %p tdIORequestBody->osMemHandle %p\n", tdIORequestBody, tdIORequestBody->osMemHandle));
323
324 tdsaSingleThreadedEnter(tiRoot, TD_TIMER_LOCK);
325
326 if (oneDeviceData->tdIDTimer.timerRunning == agTRUE)
327 {
328 tdsaSingleThreadedLeave(tiRoot, TD_TIMER_LOCK);
329 tdsaKillTimer(
330 tiRoot,
331 &oneDeviceData->tdIDTimer
332 );
333 }
334 else
335 {
336 tdsaSingleThreadedLeave(tiRoot, TD_TIMER_LOCK);
337 }
338
339 if (onePortContext == agNULL)
340 {
341 TI_DBG1(("tdsmIDCompletedCB: onePortContext is NULL!!!\n"));
342 ostiFreeMemory(
343 tiRoot,
344 tdIORequestBody->osMemHandle,
345 sizeof(tdIORequestBody_t)
346 );
347 return;
348 }
349
350 /* check port id */
351 if (pid != onePortContext->id)
352 {
353 TI_DBG1(("tdsmIDCompletedCB: not matching pid; pid %d onePortContext->id %d!!!\n", pid, onePortContext->id));
354 if (oneDeviceData->directlyAttached == agTRUE)
355 {
356 smReportRemovalDirect(tiRoot, agRoot, oneDeviceData);
357 }
358 else
359 {
360 smReportRemoval(tiRoot, agRoot, oneDeviceData, onePortContext);
361 }
362 ostiFreeMemory(
363 tiRoot,
364 tdIORequestBody->osMemHandle,
365 sizeof(tdIORequestBody_t)
366 );
367 return;
368 }
369
370 tiPortalContext= onePortContext->tiPortalContext;
371
372 if (tiPortalContext == agNULL)
373 {
374 TI_DBG1(("tdsmIDCompletedCB: tiPortalContext is NULL!!!\n"));
375 if (oneDeviceData->directlyAttached == agTRUE)
376 {
377 smReportRemovalDirect(tiRoot, agRoot, oneDeviceData);
378 }
379 else
380 {
381 smReportRemoval(tiRoot, agRoot, oneDeviceData, onePortContext);
382 }
383 ostiFreeMemory(
384 tiRoot,
385 tdIORequestBody->osMemHandle,
386 sizeof(tdIORequestBody_t)
387 );
388 return;
389 }
390
391 if (agRoot == agNULL)
392 {
393 TI_DBG1(("tdsmIDCompletedCB: agRoot is NULL!!!\n"));
394 ostiFreeMemory(
395 tiRoot,
396 tdIORequestBody->osMemHandle,
397 sizeof(tdIORequestBody_t)
398 );
399 return;
400 }
401
402 if (status == smIOSuccess)
403 {
404 TI_DBG2(("tdsmIDCompletedCB: smIOSuccess\n"));
405
406 oneDeviceData->satDevData.IDDeviceValid = agTRUE;
407 if (oneDeviceData->directlyAttached == agTRUE)
408 {
409 TI_DBG2(("tdsmIDCompletedCB: directlyAttached\n"));
410 pSATAIdData = (agsaSATAIdentifyData_t *)IDdata;
411 smHandleDirect(tiRoot, agRoot, oneDeviceData, IDdata);
412 /* filling in */
413 osti_memcpy(onePortContext->remoteName, pSATAIdData->serialNumber, 20);
414 osti_memcpy(&(onePortContext->remoteName[20]), pSATAIdData->firmwareVersion, 8);
415 osti_memcpy(&(onePortContext->remoteName[28]), pSATAIdData->modelNumber, 40);
416 }
417 else /* expander attached */
418 {
419
420 TI_DBG2(("tdsmIDCompletedCB: expander attached\n"));
421
422 if (onePortContext->DiscoveryState == ITD_DSTATE_COMPLETED)
423 {
424 TI_DBG1(("tdsmIDCompletedCB: ID completed after discovery is done; tiDeviceArrival\n"));
425 /* ID data completed after discovery is completed */
426 ostiInitiatorEvent(
427 tiRoot,
428 tiPortalContext,
429 agNULL,
430 tiIntrEventTypeDeviceChange,
431 tiDeviceArrival,
432 agNULL
433 );
434 }
435 }
436 TI_DBG2(("tdsmIDCompletedCB: tdIORequestBody %p tdIORequestBody->osMemHandle %p\n", tdIORequestBody, tdIORequestBody->osMemHandle));
437 ostiFreeMemory(
438 tiRoot,
439 tdIORequestBody->osMemHandle,
440 sizeof(tdIORequestBody_t)
441 );
442
443 }
444 else if ( status == smIORetry)
445 {
446 TI_DBG1(("tdsmIDCompletedCB: smIORetry!!!\n"));
447 if ( !(oneDeviceData->valid == agTRUE && oneDeviceData->registered == agTRUE &&
448 oneDeviceData->tdPortContext != agNULL)
449 )
450 {
451 TI_DBG1(("tdsmIDCompletedCB: smIORetry but device is not valid!!!\n"));
452 tdIORequestBody->reTries = 0;
453 tdIORequestBody->ioCompleted = agTRUE;
454 tdIORequestBody->ioStarted = agFALSE;
455 ostiFreeMemory(
456 tiRoot,
457 tdIORequestBody->osMemHandle,
458 sizeof(tdIORequestBody_t)
459 );
460 oneDeviceData->satDevData.IDDeviceValid = agFALSE;
461 return;
462 }
463
464 if (tdIORequestBody->reTries <= SM_RETRIES)
465 {
466 tdIORequestBody->tiIORequest = agNULL; /* not in use */
467 tdIORequestBody->pid = onePortContext->id;
468 smIORequest->tdData = tdIORequestBody;
469 smIORequest->smData = &tdIORequestBody->smIORequestBody;
470
471 smDeviceHandle->tdData = oneDeviceData;
472
473 oneDeviceData->satDevData.IDDeviceValid = agFALSE;
474
475 IDstatus = smIDStart(smRoot,
476 smIORequest,
477 smDeviceHandle
478 );
479 if (IDstatus != SM_RC_SUCCESS)
480 {
481 /* identify device data is not valid */
482 TI_DBG1(("tdsmIDCompletedCB: smIDStart fail or busy %d!!!\n", IDstatus));
483 tdIORequestBody->reTries = 0;
484 tdIORequestBody->ioCompleted = agTRUE;
485 tdIORequestBody->ioStarted = agFALSE;
486 ostiFreeMemory(
487 tiRoot,
488 tdIORequestBody->osMemHandle,
489 sizeof(tdIORequestBody_t)
490 );
491 smReportRemoval(tiRoot, agRoot, oneDeviceData, onePortContext);
492 return;
493 }
494 tdIORequestBody->reTries++;
495 tdIORequestBody->ioCompleted = agFALSE;
496 tdIORequestBody->ioStarted = agTRUE;
497 oneDeviceData->satDevData.IDPending = agTRUE;
498 /* start a timer */
499 tdIDStartTimer(tiRoot, smIORequest, oneDeviceData);
500 TI_DBG1(("tdsmIDCompletedCB: being retried!!!\n"));
501 }
502 else
503 {
504 /* give up */
505 TI_DBG1(("tdsmIDCompletedCB: retries are over!!!\n"));
506 tdIORequestBody->reTries = 0;
507 tdIORequestBody->ioCompleted = agTRUE;
508 tdIORequestBody->ioStarted = agFALSE;
509 ostiFreeMemory(
510 tiRoot,
511 tdIORequestBody->osMemHandle,
512 sizeof(tdIORequestBody_t)
513 );
514 oneDeviceData->satDevData.IDDeviceValid = agFALSE;
515 /* SATA device is not usable; remove it */
516 smReportRemoval(tiRoot, agRoot, oneDeviceData, onePortContext);
517 }
518 }
519 else if ( status == smIOSTPResourceBusy)
520 {
521 /* decides to send smp hard reset or not */
522 TI_DBG1(("tdsmIDCompletedCB: smIOSTPResourceBusy\n"));
523 ostiFreeMemory(
524 tiRoot,
525 tdIORequestBody->osMemHandle,
526 sizeof(tdIORequestBody_t)
527 );
528 oneDeviceData->satDevData.IDDeviceValid = agFALSE;
529 if (tdsaAllShared->FCA)
530 {
531 if (oneDeviceData->SMNumOfFCA <= 0) /* does SMP HARD RESET only upto one time */
532 {
533 TI_DBG1(("tdsmIDCompletedCB: OSSA_IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY; sending HARD_RESET\n"));
534 oneDeviceData->SMNumOfFCA++;
535 tdsaPhyControlSend(tiRoot,
536 oneDeviceData,
537 SMP_PHY_CONTROL_HARD_RESET,
538 agNULL,
539 tdsaRotateQnumber(tiRoot, oneDeviceData)
540 );
541 }
542 else
543 {
544 /* given up after one time of SMP HARD RESET; */
545 TI_DBG1(("tdsmIDCompletedCB: OSSA_IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY; but giving up sending HARD_RESET!!!\n"));
546 smReportRemoval(tiRoot, agRoot, oneDeviceData, onePortContext);
547 }
548 }
549 else
550 {
551 /* do nothing */
552 }
553 }
554 else
555 {
556 TI_DBG1(("tdsmIDCompletedCB: smIDStart fail, status 0x%x!!!\n", status));
557 TI_DBG1(("tdsmIDCompletedCB: did %d!!!\n", oneDeviceData->id));
558 if ( !(oneDeviceData->valid == agTRUE && oneDeviceData->registered == agTRUE &&
559 oneDeviceData->tdPortContext != agNULL)
560 )
561 {
562 TI_DBG1(("tdsmIDCompletedCB: fail but device is not valid!!!\n"));
563 tdIORequestBody->reTries = 0;
564 tdIORequestBody->ioCompleted = agTRUE;
565 tdIORequestBody->ioStarted = agFALSE;
566 ostiFreeMemory(
567 tiRoot,
568 tdIORequestBody->osMemHandle,
569 sizeof(tdIORequestBody_t)
570 );
571 oneDeviceData->satDevData.IDDeviceValid = agFALSE;
572 return;
573 }
574 tdsaAllShared->IDRetry = agTRUE;
575 if (tdsaAllShared->IDRetry)
576 {
577 if (tdIORequestBody->reTries <= SM_RETRIES)
578 {
579 tdIORequestBody->tiIORequest = agNULL; /* not in use */
580 tdIORequestBody->pid = onePortContext->id;
581 smIORequest->tdData = tdIORequestBody;
582 smIORequest->smData = &tdIORequestBody->smIORequestBody;
583
584 smDeviceHandle->tdData = oneDeviceData;
585 IDstatus = smIDStart(smRoot,
586 smIORequest,
587 smDeviceHandle
588 );
589 if (IDstatus != SM_RC_SUCCESS)
590 {
591 /* identify device data is not valid */
592 TI_DBG1(("tdsmIDCompletedCB: smIDStart fail or busy %d!!!\n", IDstatus));
593 tdIORequestBody->reTries = 0;
594 tdIORequestBody->ioCompleted = agTRUE;
595 tdIORequestBody->ioStarted = agFALSE;
596 ostiFreeMemory(
597 tiRoot,
598 tdIORequestBody->osMemHandle,
599 sizeof(tdIORequestBody_t)
600 );
601 oneDeviceData->satDevData.IDDeviceValid = agFALSE;
602 if (oneDeviceData->directlyAttached == agTRUE)
603 {
604 smReportRemovalDirect(tiRoot, agRoot, oneDeviceData);
605 }
606 else
607 {
608 smReportRemoval(tiRoot, agRoot, oneDeviceData, onePortContext);
609 }
610 return;
611 }
612 tdIORequestBody->reTries++;
613 tdIORequestBody->ioCompleted = agFALSE;
614 tdIORequestBody->ioStarted = agTRUE;
615 oneDeviceData->satDevData.IDPending = agTRUE;
616 /* start a timer */
617 tdIDStartTimer(tiRoot, smIORequest, oneDeviceData);
618 TI_DBG1(("tdsmIDCompletedCB: being retried!!!\n"));
619 }
620 else
621 {
622 /* give up */
623 TI_DBG1(("tdsmIDCompletedCB: retries are over; sending hard reset!!!\n"));
624 tdIORequestBody->reTries = 0;
625 tdIORequestBody->ioCompleted = agTRUE;
626 tdIORequestBody->ioStarted = agFALSE;
627 ostiFreeMemory(
628 tiRoot,
629 tdIORequestBody->osMemHandle,
630 sizeof(tdIORequestBody_t)
631 );
632 oneDeviceData->satDevData.IDDeviceValid = agFALSE;
633
634 if (oneDeviceData->SMNumOfID <= 0) /* does SMP HARD RESET only upto one time */
635 {
636 TI_DBG1(("tdsmIDCompletedCB: fail; sending HARD_RESET\n"));
637 oneDeviceData->SMNumOfID++;
638 if (oneDeviceData->directlyAttached == agTRUE)
639 {
640 saLocalPhyControl(agRoot, agNULL, tdsaRotateQnumber(tiRoot, oneDeviceData), oneDeviceData->phyID, AGSA_PHY_HARD_RESET, agNULL);
641 }
642 else
643 {
644 tdsaPhyControlSend(tiRoot,
645 oneDeviceData,
646 SMP_PHY_CONTROL_HARD_RESET,
647 agNULL,
648 tdsaRotateQnumber(tiRoot, oneDeviceData)
649 );
650 }
651 }
652 else
653 {
654 /* given up after one time of SMP HARD RESET; */
655 TI_DBG1(("tdsmIDCompletedCB: fail; but giving up sending HARD_RESET!!!\n"));
656 if (oneDeviceData->directlyAttached == agTRUE)
657 {
658 smReportRemovalDirect(tiRoot, agRoot, oneDeviceData);
659 }
660 else
661 {
662 smReportRemoval(tiRoot, agRoot, oneDeviceData, onePortContext);
663 }
664 }
665 }
666 }
667 else
668 {
669 /* do nothing */
670 }
671
672
673 }
674
675
676 return;
677 }
678
679 FORCEINLINE void
tdsmIOCompletedCB(smRoot_t * smRoot,smIORequest_t * smIORequest,bit32 status,bit32 statusDetail,smSenseData_t * senseData,bit32 interruptContext)680 tdsmIOCompletedCB(
681 smRoot_t *smRoot,
682 smIORequest_t *smIORequest,
683 bit32 status,
684 bit32 statusDetail,
685 smSenseData_t *senseData,
686 bit32 interruptContext
687 )
688 {
689 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *)smRoot->tdData;
690 tdsaContext_t *tdsaAllShared = &(tdsaRoot->tdsaAllShared);
691 tiRoot_t *tiRoot = tdsaAllShared->agRootOsDataForInt.tiRoot;
692 tdIORequestBody_t *tdIORequestBody = (tdIORequestBody_t *)smIORequest->tdData;
693 tiIORequest_t *tiIORequest = tdIORequestBody->tiIORequest;
694
695 tdsaDeviceData_t *oneDeviceData;
696 tiDeviceHandle_t *tiDeviceHandle;
697 smDeviceHandle_t *smDeviceHandle;
698 smScsiInitiatorRequest_t *smSCSIRequest;
699 smSuperScsiInitiatorRequest_t *smSuperSCSIRequest;
700
701 bit32 SMStatus = SM_RC_FAILURE;
702
703
704 TI_DBG5(("tdsmIOCompletedCB: start\n"));
705
706 if (status == smIOSuccess)
707 {
708 ostiInitiatorIOCompleted( tiRoot,
709 tiIORequest,
710 status,
711 statusDetail,
712 (tiSenseData_t *)senseData,
713 interruptContext);
714 }
715 else if (status == smIORetry)
716 {
717 TI_DBG1(("tdsmIOCompletedCB: smIORetry!!!\n"));
718 smIORequest = (smIORequest_t *)&(tdIORequestBody->smIORequest);
719 tiDeviceHandle = tdIORequestBody->tiDevHandle;
720 oneDeviceData = (tdsaDeviceData_t *)tiDeviceHandle->tdData;
721
722 if (! (oneDeviceData->valid == agTRUE && oneDeviceData->registered == agTRUE &&
723 oneDeviceData->tdPortContext != agNULL)
724 )
725 {
726 TI_DBG1(("tdsmIOCompletedCB: smIORetry but device is not valid!!!\n"));
727 tdIORequestBody->reTries = 0;
728 tdIORequestBody->ioCompleted = agTRUE;
729 tdIORequestBody->ioStarted = agFALSE;
730 ostiInitiatorIOCompleted( tiRoot,
731 tiIORequest,
732 status,
733 statusDetail,
734 (tiSenseData_t *)senseData,
735 interruptContext);
736 return;
737 }
738 if (tdIORequestBody->reTries <= SM_RETRIES)
739 {
740 smDeviceHandle = (smDeviceHandle_t *)&(oneDeviceData->smDeviceHandle);
741 if (tdIORequestBody->superIOFlag == agTRUE)
742 {
743 smSuperSCSIRequest = (smSuperScsiInitiatorRequest_t *)&(tdIORequestBody->SM.smSuperSCSIRequest);
744 SMStatus = smSuperIOStart(smRoot,
745 smIORequest,
746 smDeviceHandle,
747 smSuperSCSIRequest,
748 oneDeviceData->SASAddressID.sasAddressHi,
749 oneDeviceData->SASAddressID.sasAddressLo,
750 interruptContext);
751 }
752 else
753 {
754 smSCSIRequest = (smScsiInitiatorRequest_t *)&(tdIORequestBody->SM.smSCSIRequest);
755 SMStatus = smIOStart(smRoot,
756 smIORequest,
757 smDeviceHandle,
758 smSCSIRequest,
759 interruptContext);
760 }
761
762
763 if (SMStatus != SM_RC_SUCCESS)
764 {
765 TI_DBG1(("tdsmIOCompletedCB: smIDStart fail or busy %d!!!\n", SMStatus));
766 tdIORequestBody->reTries = 0;
767 tdIORequestBody->ioCompleted = agTRUE;
768 tdIORequestBody->ioStarted = agFALSE;
769 ostiInitiatorIOCompleted( tiRoot,
770 tiIORequest,
771 status,
772 statusDetail,
773 (tiSenseData_t *)senseData,
774 interruptContext);
775 return;
776 }
777 else
778 {
779 TI_DBG1(("tdsmIOCompletedCB: being retried!!!\n"));
780 tdIORequestBody->reTries++;
781 tdIORequestBody->ioCompleted = agFALSE;
782 tdIORequestBody->ioStarted = agTRUE;
783 }
784 }
785 else
786 {
787 /* give up; complete IO */
788 TI_DBG1(("tdsmIOCompletedCB: retries are over!!!\n"));
789 tdIORequestBody->reTries = 0;
790 tdIORequestBody->ioCompleted = agTRUE;
791 tdIORequestBody->ioStarted = agFALSE;
792 ostiInitiatorIOCompleted( tiRoot,
793 tiIORequest,
794 status,
795 statusDetail,
796 (tiSenseData_t *)senseData,
797 interruptContext);
798 return;
799 }
800
801 }
802 else if ( status == smIOSTPResourceBusy)
803 {
804 /* decides to send smp hard reset or not */
805 TI_DBG1(("tdsmIOCompletedCB: smIOSTPResourceBusy\n"));
806 if (tdsaAllShared->FCA)
807 {
808 smIORequest = (smIORequest_t *)&(tdIORequestBody->smIORequest);
809 tiDeviceHandle = tdIORequestBody->tiDevHandle;
810 oneDeviceData = (tdsaDeviceData_t *)tiDeviceHandle->tdData;
811 if (oneDeviceData->SMNumOfFCA <= 0) /* does SMP HARD RESET only upto one time */
812 {
813 TI_DBG1(("tdsmIOCompletedCB: OSSA_IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY; sending HARD_RESET\n"));
814 oneDeviceData->SMNumOfFCA++;
815 tdsaPhyControlSend(tiRoot,
816 oneDeviceData,
817 SMP_PHY_CONTROL_HARD_RESET,
818 agNULL,
819 tdsaRotateQnumber(tiRoot, oneDeviceData)
820 );
821 }
822 else
823 {
824 /* given up after one time of SMP HARD RESET; */
825 TI_DBG1(("tdsmIOCompletedCB: OSSA_IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY; but giving up sending HARD_RESET!!!\n"));
826 }
827 }
828 ostiInitiatorIOCompleted( tiRoot,
829 tiIORequest,
830 status,
831 statusDetail,
832 (tiSenseData_t *)senseData,
833 interruptContext);
834 return;
835 }
836 else
837 {
838 if (statusDetail == smDetailAborted)
839 {
840 tiDeviceHandle = tdIORequestBody->tiDevHandle;
841 oneDeviceData = (tdsaDeviceData_t *)tiDeviceHandle->tdData;
842 TI_DBG1(("tdsmIOCompletedCB: agIOStatus = OSSA_IO_ABORTED did %d\n", oneDeviceData->id));
843 }
844 ostiInitiatorIOCompleted( tiRoot,
845 tiIORequest,
846 status,
847 statusDetail,
848 (tiSenseData_t *)senseData,
849 interruptContext);
850 }
851
852 return;
853 }
854
855 /* completion of taskmanagement
856 osGLOBAL void ostiInitiatorEvent (
857 tiRoot_t *tiRoot,
858 tiPortalContext_t *portalContext,
859 tiDeviceHandle_t *tiDeviceHandle,
860 tiIntrEventType_t eventType,
861 bit32 eventStatus,
862 void *parm
863 );
864
865 */
866 //qqq1
867 osGLOBAL void
tdsmEventCB(smRoot_t * smRoot,smDeviceHandle_t * smDeviceHandle,smIntrEventType_t eventType,bit32 eventStatus,void * parm)868 tdsmEventCB(
869 smRoot_t *smRoot,
870 smDeviceHandle_t *smDeviceHandle,
871 smIntrEventType_t eventType,
872 bit32 eventStatus,
873 void *parm
874 )
875 {
876 tdsaRoot_t *tdsaRoot;
877 tdsaContext_t *tdsaAllShared;
878 tiRoot_t *tiRoot;
879 tdIORequestBody_t *tdIORequestBody;
880 smIORequest_t *SMcurrentTaskTag;
881 tiIORequest_t *currentTaskTag;
882 tdsaDeviceData_t *oneDeviceData;
883 void *osMemHandle;
884 tdsaPortContext_t *onePortContext;
885 tiPortalContext_t *tiportalContext;
886 tiDeviceHandle_t *tiDeviceHandle;
887
888 /* be sure to free using tdIORequestBody->->IOType.InitiatorTMIO.osMemHandle but how???
889 parm = pSatDevData->satTmTaskTag (currentTaskTag in tiINITaskManagement)
890 In this case, parm is smIORequest_t
891 */
892
893 TI_DBG2(("tdsmEventCB: start\n"));
894
895 tdsaRoot = (tdsaRoot_t *)smRoot->tdData;
896 tdsaAllShared = &(tdsaRoot->tdsaAllShared);
897 tiRoot = tdsaAllShared->agRootOsDataForInt.tiRoot;
898
899
900 if (eventType == smIntrEventTypeLocalAbort)
901 {
902 oneDeviceData = (tdsaDeviceData_t *)smDeviceHandle->tdData;
903 if (oneDeviceData == agNULL)
904 {
905 TI_DBG1(("tdsmEventCB: oneDeviceData is NULL\n"));
906 return;
907 }
908 else
909 {
910 tiDeviceHandle = &(oneDeviceData->tiDeviceHandle);
911 if (oneDeviceData->OSAbortAll == agTRUE)
912 {
913 oneDeviceData->OSAbortAll = agFALSE;
914 ostiInitiatorEvent( tiRoot,
915 agNULL,
916 tiDeviceHandle,
917 tiIntrEventTypeLocalAbort,
918 tiAbortOK,
919 agNULL);
920 }
921 }
922 }
923 else
924 {
925
926 SMcurrentTaskTag = (smIORequest_t *)parm;
927 if (SMcurrentTaskTag == agNULL)
928 {
929 TI_DBG1(("tdsmEventCB: SMcurrentTaskTag is NULL!!!\n"));
930 return;
931 }
932
933 tdIORequestBody = (tdIORequestBody_t *)SMcurrentTaskTag->tdData;
934 if (tdIORequestBody == agNULL)
935 {
936 TI_DBG1(("tdsmEventCB: tdIORequestBody is NULL!!!\n"));
937 return;
938 }
939
940 osMemHandle = tdIORequestBody->IOType.InitiatorTMIO.osMemHandle;
941 currentTaskTag = tdIORequestBody->IOType.InitiatorTMIO.CurrentTaskTag;
942
943
944 oneDeviceData = (tdsaDeviceData_t *)smDeviceHandle->tdData;
945 if (oneDeviceData == agNULL)
946 {
947 TI_DBG1(("tdsmEventCB: oneDeviceData is NULL!!!\n"));
948 return;
949 }
950
951 tiDeviceHandle = &(oneDeviceData->tiDeviceHandle);
952 onePortContext = oneDeviceData->tdPortContext;
953 if (onePortContext == agNULL)
954 {
955 TI_DBG1(("tdsmEventCB: onePortContext is NULL!!!\n"));
956 return;
957 }
958 tiportalContext = onePortContext->tiPortalContext;
959
960 /* free tdIORequestBody */
961 ostiFreeMemory(
962 tiRoot,
963 osMemHandle,
964 sizeof(tdIORequestBody_t)
965 );
966
967
968 TI_DBG2(("tdsmEventCB: calling ostiInitiatorEvent\n"));
969 ostiInitiatorEvent(
970 tiRoot,
971 tiportalContext,
972 tiDeviceHandle,
973 eventType,
974 eventStatus,
975 (void *)currentTaskTag
976 );
977
978
979 /* completion of taskmanagement
980 osGLOBAL void ostiInitiatorEvent (
981 tiRoot_t *tiRoot,
982 tiPortalContext_t *portalContext,
983 tiDeviceHandle_t *tiDeviceHandle,
984 tiIntrEventType_t eventType,
985 bit32 eventStatus,
986 void *parm
987 );
988
989
990 ostiFreeAlloc()
991 */
992
993 }
994
995 return;
996 }
997
998
999 FORCEINLINE void
tdsmSingleThreadedEnter(smRoot_t * smRoot,bit32 syncLockId)1000 tdsmSingleThreadedEnter(
1001 smRoot_t *smRoot,
1002 bit32 syncLockId
1003 )
1004 {
1005 tdsaRoot_t *tdsaRoot;
1006 tdsaContext_t *tdsaAllShared;
1007 tiRoot_t *tiRoot;
1008 bit32 offset = 0;
1009
1010 TI_DBG7(("tdsmSingleThreadedEnter: start\n"));
1011
1012 tdsaRoot = (tdsaRoot_t *)smRoot->tdData;
1013 if (tdsaRoot == agNULL)
1014 {
1015 TI_DBG1(("tdsmSingleThreadedEnter: tdsaRoot is NULL\n"));
1016 return;
1017 }
1018
1019 tdsaAllShared = &(tdsaRoot->tdsaAllShared);
1020 if (tdsaAllShared == agNULL)
1021 {
1022 TI_DBG1(("tdsmSingleThreadedEnter: tdsaAllShared is NULL\n"));
1023 return;
1024 }
1025
1026 tiRoot = tdsaAllShared->agRootOsDataForInt.tiRoot;
1027 if (tiRoot == agNULL)
1028 {
1029 TI_DBG1(("tdsmSingleThreadedEnter: tiRoot is NULL\n"));
1030 return;
1031 }
1032
1033 offset = tdsaAllShared->MaxNumLLLocks + tdsaAllShared->MaxNumOSLocks + TD_MAX_LOCKS + tdsaAllShared->MaxNumDMLocks;
1034
1035 ostiSingleThreadedEnter(tiRoot, syncLockId + offset);
1036
1037 return;
1038 }
1039
1040 FORCEINLINE void
tdsmSingleThreadedLeave(smRoot_t * smRoot,bit32 syncLockId)1041 tdsmSingleThreadedLeave(
1042 smRoot_t *smRoot,
1043 bit32 syncLockId
1044 )
1045 {
1046 tdsaRoot_t *tdsaRoot;
1047 tdsaContext_t *tdsaAllShared;
1048 tiRoot_t *tiRoot;
1049 bit32 offset = 0;
1050
1051 TI_DBG7(("tdsmSingleThreadedLeave: start\n"));
1052
1053 tdsaRoot = (tdsaRoot_t *)smRoot->tdData;
1054 if (tdsaRoot == agNULL)
1055 {
1056 TI_DBG1(("tdsmSingleThreadedLeave: tdsaRoot is NULL\n"));
1057 return;
1058 }
1059
1060 tdsaAllShared = &(tdsaRoot->tdsaAllShared);
1061 if (tdsaAllShared == agNULL)
1062 {
1063 TI_DBG1(("tdsmSingleThreadedLeave: tdsaAllShared is NULL\n"));
1064 return;
1065 }
1066
1067 tiRoot = tdsaAllShared->agRootOsDataForInt.tiRoot;
1068 if (tiRoot == agNULL)
1069 {
1070 TI_DBG1(("tdsmSingleThreadedLeave: tiRoot is NULL\n"));
1071 return;
1072 }
1073 offset = tdsaAllShared->MaxNumLLLocks + tdsaAllShared->MaxNumOSLocks + TD_MAX_LOCKS + tdsaAllShared->MaxNumDMLocks;
1074
1075 ostiSingleThreadedLeave(tiRoot, syncLockId + offset);
1076
1077 return;
1078 }
1079
1080 osGLOBAL FORCEINLINE bit8
tdsmBitScanForward(smRoot_t * smRoot,bit32 * Index,bit32 Mask)1081 tdsmBitScanForward(
1082 smRoot_t *smRoot,
1083 bit32 *Index,
1084 bit32 Mask
1085 )
1086 {
1087 return ostiBitScanForward(agNULL, Index, Mask);
1088 }
1089
1090 #ifdef LINUX_VERSION_CODE
1091
1092 osGLOBAL FORCEINLINE sbit32
tdsmInterlockedIncrement(smRoot_t * smRoot,sbit32 volatile * Addend)1093 tdsmInterlockedIncrement(
1094 smRoot_t *smRoot,
1095 sbit32 volatile *Addend
1096 )
1097 {
1098 return ostiAtomicIncrement(agNULL, Addend);
1099 }
1100
1101 osGLOBAL FORCEINLINE sbit32
tdsmInterlockedDecrement(smRoot_t * smRoot,sbit32 volatile * Addend)1102 tdsmInterlockedDecrement(
1103 smRoot_t *smRoot,
1104 sbit32 volatile *Addend
1105 )
1106 {
1107 return ostiAtomicDecrement(agNULL, Addend);
1108 }
1109
1110
1111
1112 osGLOBAL FORCEINLINE sbit32
tdsmAtomicBitClear(smRoot_t * smRoot,sbit32 volatile * Destination,sbit32 Value)1113 tdsmAtomicBitClear(
1114 smRoot_t *smRoot,
1115 sbit32 volatile *Destination,
1116 sbit32 Value
1117 )
1118 {
1119 return ostiAtomicBitClear(agNULL, Destination, Value);
1120 }
1121
1122 osGLOBAL FORCEINLINE sbit32
tdsmAtomicBitSet(smRoot_t * smRoot,sbit32 volatile * Destination,sbit32 Value)1123 tdsmAtomicBitSet(
1124 smRoot_t *smRoot,
1125 sbit32 volatile *Destination,
1126 sbit32 Value
1127 )
1128 {
1129 return ostiAtomicBitSet(agNULL, Destination, Value);
1130 }
1131
1132 osGLOBAL FORCEINLINE sbit32
tdsmAtomicExchange(smRoot_t * smRoot,sbit32 volatile * Target,sbit32 Value)1133 tdsmAtomicExchange(
1134 smRoot_t *smRoot,
1135 sbit32 volatile *Target,
1136 sbit32 Value
1137 )
1138 {
1139 return ostiAtomicExchange(agNULL, Target, Value);
1140 }
1141
1142 #else
1143
1144 osGLOBAL FORCEINLINE sbit32
tdsmInterlockedIncrement(smRoot_t * smRoot,sbit32 volatile * Addend)1145 tdsmInterlockedIncrement(
1146 smRoot_t *smRoot,
1147 sbit32 volatile *Addend
1148 )
1149 {
1150 return ostiInterlockedIncrement(agNULL, Addend);
1151 }
1152
1153 osGLOBAL FORCEINLINE sbit32
tdsmInterlockedDecrement(smRoot_t * smRoot,sbit32 volatile * Addend)1154 tdsmInterlockedDecrement(
1155 smRoot_t *smRoot,
1156 sbit32 volatile *Addend
1157 )
1158 {
1159 return ostiInterlockedDecrement(agNULL, Addend);
1160 }
1161
1162
1163
1164 osGLOBAL FORCEINLINE sbit32
tdsmInterlockedAnd(smRoot_t * smRoot,sbit32 volatile * Destination,sbit32 Value)1165 tdsmInterlockedAnd(
1166 smRoot_t *smRoot,
1167 sbit32 volatile *Destination,
1168 sbit32 Value
1169 )
1170 {
1171
1172 return ostiInterlockedAnd(agNULL, Destination, Value);
1173 }
1174
1175 osGLOBAL FORCEINLINE sbit32
tdsmInterlockedOr(smRoot_t * smRoot,sbit32 volatile * Destination,sbit32 Value)1176 tdsmInterlockedOr(
1177 smRoot_t *smRoot,
1178 sbit32 volatile *Destination,
1179 sbit32 Value
1180 )
1181 {
1182 return ostiInterlockedOr(agNULL, Destination, Value);
1183 }
1184
1185 osGLOBAL FORCEINLINE sbit32
tdsmInterlockedExchange(smRoot_t * smRoot,sbit32 volatile * Target,sbit32 Value)1186 tdsmInterlockedExchange(
1187 smRoot_t *smRoot,
1188 sbit32 volatile *Target,
1189 sbit32 Value
1190 )
1191 {
1192 return ostiInterlockedExchange(agNULL, Target, Value);
1193 }
1194
1195 #endif /*LINUX_VERSION_CODE*/
1196
1197 osGLOBAL bit32
tdsmAllocMemory(smRoot_t * smRoot,void ** osMemHandle,void ** virtPtr,bit32 * physAddrUpper,bit32 * physAddrLower,bit32 alignment,bit32 allocLength,smBOOLEAN isCacheable)1198 tdsmAllocMemory(
1199 smRoot_t *smRoot,
1200 void **osMemHandle,
1201 void ** virtPtr,
1202 bit32 * physAddrUpper,
1203 bit32 * physAddrLower,
1204 bit32 alignment,
1205 bit32 allocLength,
1206 smBOOLEAN isCacheable
1207 )
1208 {
1209 tdsaRoot_t *tdsaRoot;
1210 tdsaContext_t *tdsaAllShared;
1211 tiRoot_t *tiRoot;
1212 bit32 status;
1213
1214 TI_DBG5(("tdsmAllocMemory: start\n"));
1215
1216 tdsaRoot = (tdsaRoot_t *)smRoot->tdData;
1217 if (tdsaRoot == agNULL)
1218 {
1219 TI_DBG1(("tdsmAllocMemory: tdsaRoot is NULL\n"));
1220 return SM_RC_FAILURE;
1221 }
1222
1223 tdsaAllShared = &(tdsaRoot->tdsaAllShared);
1224 if (tdsaAllShared == agNULL)
1225 {
1226 TI_DBG1(("tdsmAllocMemory: tdsaAllShared is NULL\n"));
1227 return SM_RC_FAILURE;
1228 }
1229
1230 tiRoot = tdsaAllShared->agRootOsDataForInt.tiRoot;
1231 if (tiRoot == agNULL)
1232 {
1233 TI_DBG1(("tdsmAllocMemory: tiRoot is NULL\n"));
1234 return SM_RC_FAILURE;
1235 }
1236
1237 status = ostiAllocMemory(tiRoot,
1238 osMemHandle,
1239 virtPtr,
1240 physAddrUpper,
1241 physAddrLower,
1242 alignment,
1243 allocLength,
1244 isCacheable);
1245
1246 if (status == tiSuccess)
1247 {
1248 return SM_RC_SUCCESS;
1249 }
1250 else
1251 {
1252 return SM_RC_FAILURE;
1253 }
1254
1255 }
1256
1257 osGLOBAL bit32
tdsmFreeMemory(smRoot_t * smRoot,void * osDMAHandle,bit32 allocLength)1258 tdsmFreeMemory(
1259 smRoot_t *smRoot,
1260 void *osDMAHandle,
1261 bit32 allocLength
1262 )
1263 {
1264 tdsaRoot_t *tdsaRoot;
1265 tdsaContext_t *tdsaAllShared;
1266 tiRoot_t *tiRoot;
1267 bit32 status;
1268
1269 TI_DBG5(("tdsmFreeMemory: start\n"));
1270
1271 tdsaRoot = (tdsaRoot_t *)smRoot->tdData;
1272 if (tdsaRoot == agNULL)
1273 {
1274 TI_DBG1(("tdsmFreeMemory: tdsaRoot is NULL\n"));
1275 return SM_RC_FAILURE;
1276 }
1277
1278 tdsaAllShared = &(tdsaRoot->tdsaAllShared);
1279 if (tdsaAllShared == agNULL)
1280 {
1281 TI_DBG1(("tdsmFreeMemory: tdsaAllShared is NULL\n"));
1282 return SM_RC_FAILURE;
1283 }
1284
1285 tiRoot = tdsaAllShared->agRootOsDataForInt.tiRoot;
1286 if (tiRoot == agNULL)
1287 {
1288 TI_DBG1(("tdsmFreeMemory: tiRoot is NULL\n"));
1289 return SM_RC_FAILURE;
1290 }
1291
1292 status = ostiFreeMemory(tiRoot,
1293 osDMAHandle,
1294 allocLength);
1295
1296 if (status == tiSuccess)
1297 {
1298 return SM_RC_SUCCESS;
1299 }
1300 else
1301 {
1302 return SM_RC_FAILURE;
1303 }
1304 }
1305
1306 FORCEINLINE bit32
tdsmRotateQnumber(smRoot_t * smRoot,smDeviceHandle_t * smDeviceHandle)1307 tdsmRotateQnumber(smRoot_t *smRoot,
1308 smDeviceHandle_t *smDeviceHandle
1309 )
1310 {
1311 tdsaRoot_t *tdsaRoot;
1312 tdsaContext_t *tdsaAllShared;
1313 tiRoot_t *tiRoot;
1314 tdsaDeviceData_t *oneDeviceData;
1315 bit32 ret = 0;
1316
1317 tdsaRoot = (tdsaRoot_t *)smRoot->tdData;
1318 tdsaAllShared = &(tdsaRoot->tdsaAllShared);
1319 tiRoot = tdsaAllShared->agRootOsDataForInt.tiRoot;
1320
1321
1322 TI_DBG6(("tdsmRotateQnumber: start\n"));
1323
1324 if (smDeviceHandle == agNULL)
1325 {
1326 TI_DBG1(("tdsmRotateQnumber: smDeviceHandle is NULL !!!!\n"));
1327 return ret;
1328 }
1329 oneDeviceData = (tdsaDeviceData_t *)smDeviceHandle->tdData;
1330 if (oneDeviceData == agNULL)
1331 {
1332 TI_DBG1(("tdsmRotateQnumber: oneDeviceData is NULL !!!!\n"));
1333 return ret;
1334 }
1335 return tdsaRotateQnumber(tiRoot, oneDeviceData);
1336 }
1337
1338 osGLOBAL bit32
tdsmSetDeviceQueueDepth(smRoot_t * smRoot,smIORequest_t * smIORequest,bit32 QueueDepth)1339 tdsmSetDeviceQueueDepth(smRoot_t *smRoot,
1340 smIORequest_t *smIORequest,
1341 bit32 QueueDepth
1342 )
1343 {
1344 tdsaRoot_t *tdsaRoot = agNULL;
1345 tdsaContext_t *tdsaAllShared = agNULL;
1346 tiRoot_t *tiRoot = agNULL;
1347 tdIORequestBody_t *tdIORequestBody = (tdIORequestBody_t *)smIORequest->tdData;
1348 tiIORequest_t *tiIORequest = tdIORequestBody->tiIORequest;
1349
1350
1351 TI_DBG5(("tdsmSetDeviceQueueDepth: start\n"));
1352
1353 tdsaRoot = (tdsaRoot_t *)smRoot->tdData;
1354 if (tdsaRoot == agNULL)
1355 {
1356 TI_DBG1(("tdsmSetDeviceQueueDepth: tdsaRoot is NULL\n"));
1357 return SM_RC_FAILURE;
1358 }
1359
1360 tdsaAllShared = &(tdsaRoot->tdsaAllShared);
1361 if (tdsaAllShared == agNULL)
1362 {
1363 TI_DBG1(("tdsmSetDeviceQueueDepth: tdsaAllShared is NULL\n"));
1364 return SM_RC_FAILURE;
1365 }
1366
1367 tiRoot = tdsaAllShared->agRootOsDataForInt.tiRoot;
1368 if (tiRoot == agNULL)
1369 {
1370 TI_DBG1(("tdsmFreeMemory: tiRoot is NULL\n"));
1371 return SM_RC_FAILURE;
1372 }
1373
1374 return ostiSetDeviceQueueDepth(tiRoot, tiIORequest, QueueDepth);
1375 }
1376
tdsmGetTransportParam(smRoot_t * smRoot,char * key,char * subkey1,char * subkey2,char * subkey3,char * subkey4,char * subkey5,char * valueName,char * buffer,bit32 bufferLen,bit32 * lenReceived)1377 osGLOBAL bit32 tdsmGetTransportParam(
1378 smRoot_t *smRoot,
1379 char *key,
1380 char *subkey1,
1381 char *subkey2,
1382 char *subkey3,
1383 char *subkey4,
1384 char *subkey5,
1385 char *valueName,
1386 char *buffer,
1387 bit32 bufferLen,
1388 bit32 *lenReceived
1389 )
1390 {
1391 bit32 ret = tiError;
1392
1393 TI_DBG7(("tdsmGetTransportParam: start\n"));
1394 ret = ostiGetTransportParam(agNULL,
1395 key,
1396 subkey1,
1397 subkey2,
1398 subkey3,
1399 subkey4,
1400 subkey5,
1401 valueName,
1402 buffer,
1403 bufferLen,
1404 lenReceived
1405 );
1406 return ret;
1407 }
1408 #endif /* FDS_SM */
1409
1410