1 /*******************************************************************************
2 *Copyright (c) 2014 PMC-Sierra, Inc. All rights reserved.
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
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.
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
21 ********************************************************************************/
22 /*******************************************************************************/
24 * \brief The file implements the functions for reset and shutdown
26 /******************************************************************************/
27 #include <sys/cdefs.h>
28 __FBSDID("$FreeBSD$");
29 #include <dev/pms/config.h>
31 #include <dev/pms/RefTisa/sallsdk/spc/saglobal.h>
32 #ifdef SA_ENABLE_HDA_FUNCTIONS
33 #ifndef SA_EXCLUDE_FW_IMG
42 #if defined(SALLSDK_DEBUG)
43 extern bit32 gLLSoftResetCounter;
46 #ifdef SA_ENABLE_TRACE_FUNCTIONS
50 #define siTraceFileID 'E'
61 LOCAL bit32 si_V_SoftReset(agsaRoot_t *agRoot, bit32 signature);
64 LOCAL bit32 siSpcSoftResetRDYChk(agsaRoot_t *agRoot);
66 #ifdef SA_ENABLE_HDA_FUNCTIONS
67 LOCAL void siPciMemCpy(agsaRoot_t *agRoot, bit32 dstoffset, void *src,
68 bit32 DWcount, bit32 busBaseNumber);
70 LOCAL bit32 siBar4Cpy(agsaRoot_t *agRoot, bit32 offset, bit8 *parray, bit32 array_size);
73 /******************************************************************************/
74 /*! \brief Function to reset the Hardware
76 * The saHwReset() function is called to reset the SAS/SATA HW controller
77 * All outstanding I/Os are explicitly aborted.
78 * This API need to access before saInitialize() so checking saRoot is needed
80 * \param agRoot Handles for this instance of SAS/SATA hardware
81 * \param resetType The reset type
82 * \param resetParm The paramter passed for reset operation
86 /*******************************************************************************/
87 GLOBAL void saHwReset(
93 agsaLLRoot_t *saRoot = agNULL;
94 bit32 ret = AGSA_RC_SUCCESS;
96 bit32 sysIntsActive = agFALSE;
97 #if defined(SALLSDK_DEBUG)
99 agsaControllerStatus_t controllerStatus;
100 agsaFatalErrorInfo_t fatal_error;
103 #ifdef SOFT_RESET_TEST
104 DbgPrint("Reset Start\n");
107 smTraceFuncEnter(hpDBG_VERY_LOUD, "5a");
110 SA_ASSERT( (agNULL != agRoot), "");
111 if (agNULL != agRoot)
113 if (agNULL != agRoot->sdkData)
115 saRoot = (agsaLLRoot_t*) agRoot->sdkData;
116 sysIntsActive = saRoot->sysIntsActive;
119 saSystemInterruptsActive(agRoot,agFALSE);
125 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "5a");
130 #if defined(SALLSDK_DEBUG)
132 if (agNULL != agRoot->sdkData)
134 /* check fatal errors */
135 value = siHalRegReadExt(agRoot, GEN_MSGU_SCRATCH_PAD_1, MSGU_SCRATCH_PAD_1);
136 value1 = siHalRegReadExt(agRoot, GEN_MSGU_SCRATCH_PAD_2, MSGU_SCRATCH_PAD_2);
137 /* check AAP error */
138 if( smIS_SPC(agRoot) )
140 value &= SCRATCH_PAD_STATE_MASK;
141 value1 &= SCRATCH_PAD_STATE_MASK;
143 if ((SCRATCH_PAD1_ERR == value) || (SCRATCH_PAD2_ERR == value1))
146 si_memset(&fatal_error, 0, sizeof(agsaFatalErrorInfo_t));
147 /* read detail fatal errors */
148 value = siHalRegReadExt(agRoot, GEN_MSGU_SCRATCH_PAD_0, MSGU_SCRATCH_PAD_0);
149 fatal_error.errorInfo0 = value;
150 SA_DBG1(("saHwReset: ScratchPad0 AAP error code 0x%x\n", value));
151 value = siHalRegReadExt(agRoot, GEN_MSGU_SCRATCH_PAD_1, MSGU_SCRATCH_PAD_1);
152 fatal_error.errorInfo1 = value;
153 /* AAP error state */
154 SA_DBG1(("saHwReset: AAP error state and error code 0x%x\n", value));
155 value = siHalRegReadExt(agRoot, GEN_MSGU_SCRATCH_PAD_2, MSGU_SCRATCH_PAD_2);
156 fatal_error.errorInfo2 = value;
157 /* IOP error state */
158 SA_DBG1(("saHwReset: IOP error state and error code 0x%x\n", value));
159 value = siHalRegReadExt(agRoot, GEN_MSGU_SCRATCH_PAD_3, MSGU_SCRATCH_PAD_3);
160 SA_DBG1(("saHwReset: ScratchPad3 IOP error code 0x%x\n", value));
161 fatal_error.errorInfo3 = value;
162 if (agNULL != saRoot)
164 fatal_error.regDumpBusBaseNum0 = saRoot->mainConfigTable.regDumpPCIBAR;
165 fatal_error.regDumpBusBaseNum1 = saRoot->mainConfigTable.regDumpPCIBAR;
166 fatal_error.regDumpLen0 = saRoot->mainConfigTable.FatalErrorDumpLength0;
167 fatal_error.regDumpLen1 = saRoot->mainConfigTable.FatalErrorDumpLength1;
168 fatal_error.regDumpOffset0 = saRoot->mainConfigTable.FatalErrorDumpOffset0;
169 fatal_error.regDumpOffset1 = saRoot->mainConfigTable.FatalErrorDumpOffset1;
172 /* Call Back with error */
173 SA_DBG1(("saHwReset: OSSA_HW_EVENT_MALFUNCTION SPC SP1 0x%x\n", value1));
174 ossaHwCB(agRoot, agNULL, OSSA_HW_EVENT_MALFUNCTION, 0, (void *)&fatal_error, agNULL);
179 if( ( (value & SCRATCH_PAD1_V_BOOTLDR_ERROR) == SCRATCH_PAD1_V_BOOTLDR_ERROR))
181 SA_DBG1(("saHwReset: ScratchPad1 SCRATCH_PAD1_V_BOOTLDR_ERROR 0x%x\n", value));
183 if(SCRATCH_PAD1_V_ERROR_STATE(value))
185 SA_DBG1(("saHwReset: ScratchPad1 SCRATCH_PAD1_V_ERROR_STATE 0x%x\n",SCRATCH_PAD1_V_ERROR_STATE(value) ));
187 if( (value & SCRATCH_PAD1_V_READY) == SCRATCH_PAD1_V_READY )
189 SA_DBG1(("saHwReset: ScratchPad1 SCRATCH_PAD1_V_READY 0x%x\n", value));
192 saGetControllerStatus(agRoot, &controllerStatus);
193 if (agNULL != saRoot)
195 /* display all pending Ios */
196 siDumpActiveIORequests(agRoot, saRoot->swConfig.maxActiveIOs);
200 #endif /* SALLSDK_DEBUG */
202 /* Check the resetType */
205 /* Reset the whole chip */
206 case AGSA_CHIP_RESET:
208 /* callback with RESET_START */
209 ossaHwCB(agRoot, agNULL, OSSA_HW_EVENT_RESET_START, OSSA_SUCCESS << SHIFT8, agNULL, agNULL);
211 if (agNULL != agRoot->sdkData && agNULL != saRoot)
213 /* Set chip status */
214 saRoot->chipStatus |= CHIP_RESETTING;
216 /* Disable all interrupt */
217 saSystemInterruptsActive(agRoot,agFALSE);
223 if (agNULL != saRoot)
225 /* clear up the internal resource */
226 siInitResources(agRoot,
227 &saRoot->memoryAllocated,
230 saRoot->usecsPerTick);
233 /* callback with CHIP_RESET_COMPLETE with OSSA_SUCCESS */
234 ossaHwCB(agRoot, agNULL, OSSA_HW_EVENT_RESET_COMPLETE, OSSA_SUCCESS << SHIFT8, agNULL, agNULL);
236 if (agNULL != saRoot)
238 /* mask off reset FW status */
239 saRoot->chipStatus &= ~CHIP_RESETTING;
243 case AGSA_SOFT_RESET:
246 if( smIS_SPCV(agRoot) )
248 SA_DBG1(("saHwReset: AGSA_SOFT_RESET chip type V %d\n",smIS_SPCV(agRoot) ));
249 ossaHwCB(agRoot, agNULL, OSSA_HW_EVENT_RESET_START, OSSA_SUCCESS << SHIFT8, agNULL, agNULL);
250 if (agNULL != saRoot)
252 saRoot->ResetStartTick = saRoot->timeTick;
253 saCountActiveIORequests( agRoot);
256 ret = siChipResetV( agRoot, SPC_SOFT_RESET_SIGNATURE );
260 /* clear up the internal resource */
261 siInitResources(agRoot,
262 &saRoot->memoryAllocated,
265 saRoot->usecsPerTick);
268 if (AGSA_RC_SUCCESS == ret)
270 /* callback with CHIP_RESET_COMPLETE with OSSA_SUCCESS */
271 SA_DBG1(("saHwReset: siChipResetV AGSA_RC_SUCCESS\n" ));
272 ossaHwCB(agRoot, agNULL, OSSA_HW_EVENT_RESET_COMPLETE, OSSA_SUCCESS << SHIFT8, agNULL, agNULL);
276 /* callback with CHIP_RESET_COMPLETE with OSSA_FAILURE */
277 SA_DBG1(("saHwReset: siChipResetV not AGSA_RC_SUCCESS (0x%x)\n" ,ret));
278 ossaHwCB(agRoot, agNULL, OSSA_HW_EVENT_RESET_COMPLETE, OSSA_FAILURE << SHIFT8, agNULL, agNULL);
279 if (agNULL != saRoot)
281 saRoot->ResetFailed = agTRUE;
282 SA_DBG1(("saHwReset: siChipResetV saRoot->ResetFailed ret (0x%x)\n" ,ret));
290 if (agNULL != saRoot)
292 /* get register dump from GSM and save it to LL local memory */
293 siGetRegisterDumpGSM(agRoot, (void *)&saRoot->registerDump0[0],
294 REG_DUMP_NUM0, 0, saRoot->mainConfigTable.FatalErrorDumpLength0);
295 siGetRegisterDumpGSM(agRoot, (void *)&saRoot->registerDump1[0],
296 REG_DUMP_NUM1, 0, saRoot->mainConfigTable.FatalErrorDumpLength1);
299 /* callback with RESET_START */
300 ossaHwCB(agRoot, agNULL, OSSA_HW_EVENT_RESET_START, OSSA_SUCCESS << SHIFT8, agNULL, agNULL);
302 if (agNULL != agRoot->sdkData && agNULL != saRoot)
304 /* Set chip status */
305 saRoot->chipStatus |= CHIP_RESET_FW;
307 /* Disable all interrupt */
308 saSystemInterruptsActive(agRoot,agFALSE);
309 saCountActiveIORequests( agRoot); //delray start
314 value = ossaHwRegReadExt(agRoot, PCIBAR3, HDA_RSP_OFFSET1MB+HDA_CMD_CODE_OFFSET) & HDA_STATUS_BITS;
316 if (value == BOOTTLOADERHDA_IDLE)
319 SA_DBG1(("saHwReset: HDA mode, value = 0x%x\n", value));
320 ret = AGSA_RC_HDA_NO_FW_RUNNING;
325 ret = siSpcSoftReset(agRoot, SPC_SOFT_RESET_SIGNATURE);
329 /* clear up the internal resource */
330 siInitResources(agRoot,
331 &saRoot->memoryAllocated,
334 saRoot->usecsPerTick);
336 if (AGSA_RC_SUCCESS == ret)
338 /* callback with CHIP_RESET_COMPLETE with OSSA_SUCCESS */
339 ossaHwCB(agRoot, agNULL, OSSA_HW_EVENT_RESET_COMPLETE, OSSA_SUCCESS << SHIFT8, agNULL, agNULL);
341 else if (AGSA_RC_HDA_NO_FW_RUNNING == ret)
343 /* callback with CHIP_RESET_COMPLETE with OSSA_CHIP_FAILED */
344 ossaHwCB(agRoot, agNULL, OSSA_HW_EVENT_RESET_COMPLETE, OSSA_SUCCESS << SHIFT8, agNULL, agNULL);
348 /* callback with CHIP_RESET_COMPLETE with OSSA_FAILURE */
349 ossaHwCB(agRoot, agNULL, OSSA_HW_EVENT_RESET_COMPLETE, (OSSA_FAILURE << SHIFT8), agNULL, agNULL);
352 if (agNULL != saRoot)
354 /* mask off reset FW status */
355 saRoot->chipStatus &= ~CHIP_RESET_FW;
360 /* Unsupported type */
363 SA_DBG1(("saHwReset: Unsupported reset type %X\n",resetType));
368 if (agNULL != saRoot)
370 if(sysIntsActive && ret == AGSA_RC_SUCCESS)
372 saSystemInterruptsActive(agRoot,agTRUE);
375 saCountActiveIORequests( agRoot);
376 smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "5a");
382 /******************************************************************************/
383 /*! \brief Function to shutdown the Hardware
385 * The saHwShutdown() function is called to discontinue the use of the SAS/SATA
386 * hardware. Upon return, the SASA/SAT hardware instance does not generate any
387 * interrupts or any other bus accesses. All LL Layer hardware host resources
388 * (i.e. both cached and noncached memory) are no longer owned by the LL Layer.
390 * \param agRoot handles for this instance of SAS/SATA hardware
394 /*******************************************************************************/
395 GLOBAL void saHwShutdown(
399 agsaLLRoot_t *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
401 smTraceFuncEnter(hpDBG_VERY_LOUD,"5b");
404 SA_ASSERT( (agNULL != agRoot), "");
405 SA_DBG1(("saHwShutdown: Shutting down .....\n"));
410 spad0 = siHalRegReadExt(agRoot, GEN_MSGU_SCRATCH_PAD_0,MSGU_SCRATCH_PAD_0);
412 if(0xFFFFFFFF == spad0)
414 SA_ASSERT(0xFFFFFFFF == spad0, "saHwShutdown Chip PCI dead");
416 SA_DBG1(("saHwShutdown: Chip PCI dead SCRATCH_PAD0 0x%x\n", spad0));
417 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "5b");
422 #if defined(SALLSDK_DEBUG)
423 SA_DBG1(("saHwShutdown: SCRATCH_PAD0 value = 0x%x\n", siHalRegReadExt(agRoot, GEN_MSGU_SCRATCH_PAD_0, MSGU_SCRATCH_PAD_0)));
424 SA_DBG1(("saHwShutdown: SCRATCH_PAD1 value = 0x%x\n", siHalRegReadExt(agRoot, GEN_MSGU_SCRATCH_PAD_1, MSGU_SCRATCH_PAD_1)));
425 SA_DBG1(("saHwShutdown: SCRATCH_PAD2 value = 0x%x\n", siHalRegReadExt(agRoot, GEN_MSGU_SCRATCH_PAD_2, MSGU_SCRATCH_PAD_2)));
426 SA_DBG1(("saHwShutdown: SCRATCH_PAD3 value = 0x%x\n", siHalRegReadExt(agRoot, GEN_MSGU_SCRATCH_PAD_3, MSGU_SCRATCH_PAD_3)));
430 mpiOCQueue_t *circularQ;
432 SA_DBG4(("saHwShutdown:\n"));
433 for ( i = 0; i < saRoot->QueueConfig.numOutboundQueues; i++ )
435 circularQ = &saRoot->outboundQueue[i];
436 OSSA_READ_LE_32(circularQ->agRoot, &circularQ->producerIdx, circularQ->piPointer, 0);
437 if(circularQ->producerIdx != circularQ->consumerIdx)
439 SA_DBG1(("saHwShutdown: PI 0x%03x CI 0x%03x\n",circularQ->producerIdx, circularQ->consumerIdx ));
443 #endif /* SALLSDK_DBG */
445 if(smIS_SPCV(agRoot))
448 siScratchDump(agRoot);
450 SA_DBG1(("saHwShutdown: SPC_V\n" ));
452 /* Set chip status */
453 saRoot->chipStatus |= CHIP_SHUTDOWN;
455 /* Un-Initialization Configuration Table */
456 mpiUnInitConfigTable(agRoot);
457 if (saRoot->swConfig.hostDirectAccessSupport && !saRoot->swConfig.hostDirectAccessMode)
459 /* HDA mode - do HDAsoftReset */
463 siSpcSoftReset(agRoot, SPC_HDASOFT_RESET_SIGNATURE);
465 if(smIS_SPCV(agRoot))
467 siChipResetV(agRoot, SPC_HDASOFT_RESET_SIGNATURE);
468 SA_DBG1(("saHwShutdown: HDA saRoot->ChipId == VEN_DEV_SPCV\n"));
473 /* do Normal softReset */
476 /* Soft Reset the SPC */
477 siSpcSoftReset(agRoot, SPC_SOFT_RESET_SIGNATURE);
479 if(smIS_SPCV(agRoot))
481 SA_DBG1(("saHwShutdown: saRoot->ChipId == VEN_DEV_SPCV\n"));
482 siChipResetV(agRoot, SPC_SOFT_RESET_SIGNATURE);
487 /* clean the LL resources */
488 siInitResources(agRoot,
489 &saRoot->memoryAllocated,
492 saRoot->usecsPerTick);
493 SA_DBG1(("saHwShutdown: Shutting down Complete\n"));
497 SA_DBG1(("saHwShutdown: No saRoot\n"));
498 if( smIS_SPCV(agRoot) )
500 siChipResetV(agRoot, SPC_SOFT_RESET_SIGNATURE);
504 siSpcSoftReset(agRoot, SPC_SOFT_RESET_SIGNATURE);
507 /* agroot/saroot null do not access -trace OK */
509 SA_ASSERT( (agNULL != agRoot), "10");
511 smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "5b");
516 /******************************************************************************/
517 /*! \brief Generic Reset
519 * The siChipReset() function is called to reset the SPC chip. Upon return,
520 * the SPC chip got reset. The PCIe bus got reset.
522 * \param agRoot handles for this instance of SAS/SATA hardware
526 /*******************************************************************************/
528 GLOBAL void siChipReset(
532 agsaLLRoot_t *saRoot;
535 SA_ASSERT( (agNULL != agRoot), "");
537 saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
540 smTraceFuncEnter(hpDBG_VERY_LOUD,"2C");
542 SA_DBG1(("siChipReset: saRoot->ChipId == VEN_DEV_SPCV\n"));
543 if(smIS_SPC(agRoot) )
545 /* Soft Reset the SPC */
546 siChipResetSpc( agRoot);
547 }else /* saRoot->ChipId == VEN_DEV_SPCV */
549 siChipResetV( agRoot, SPC_SOFT_RESET_SIGNATURE);
551 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "2C");
557 /******************************************************************************/
558 /*! \brief Function to Reset the SPC V Hardware
560 * The siChipResetV() function is called to reset the SPC chip. Upon return,
561 * the SPC chip got reset. The PCIe bus got reset.
563 * \param agRoot handles for this instance of SAS/SATA hardware
567 /*******************************************************************************/
569 GLOBAL bit32 siChipResetV(
575 bit32 returnVal = AGSA_RC_SUCCESS;
577 smTraceFuncEnter(hpDBG_VERY_LOUD,"3A");
578 smTrace(hpDBG_LOUD,"Lr",ossaTimeStamp64(agRoot));
579 regVal = ossaHwRegReadExt(agRoot,PCIBAR0 ,V_SoftResetRegister );
581 SA_DBG1(("siChipResetV: signature %X V_SoftResetRegister %X\n",signature,regVal));
583 if (signature == SPC_SOFT_RESET_SIGNATURE)
585 SA_DBG1(("siChipResetV: SPC_SOFT_RESET_SIGNATURE 0x%X\n",regVal));
586 regVal = SPCv_Reset_Write_NormalReset;
588 else if (signature == SPC_HDASOFT_RESET_SIGNATURE)
590 SA_DBG1(("siChipResetV: SPCv load HDA 0x%X\n",regVal));
591 regVal = SPCv_Reset_Write_SoftResetHDA;
595 SA_DBG1(("siChipResetV: Invalid SIGNATURE 0x%X regVal 0x%X a\n",signature ,regVal));
599 smTrace(hpDBG_LOUD,"Ls",ossaTimeStamp64(agRoot));
600 ossaHwRegWriteExt(agRoot, PCIBAR0, V_SoftResetRegister, regVal); /* siChipResetV */
601 smTrace(hpDBG_LOUD,"Lt",ossaTimeStamp64(agRoot));
602 ossaStallThread(agRoot, (500 * 1000)); /* wait 500 milliseconds or PCIe will hang */
603 /* Soft reset sequence (Normal mode) */
604 smTrace(hpDBG_LOUD,"Lv",ossaTimeStamp64(agRoot));
606 if (signature == SPC_HDASOFT_RESET_SIGNATURE)
610 hda_status = (ossaHwRegReadExt(agRoot, PCIBAR0, SPC_V_HDA_RESPONSE_OFFSET+28));
612 SA_DBG1(("siChipResetV: hda_status 0x%x\n",hda_status));
614 if((hda_status & SPC_V_HDAR_RSPCODE_MASK) != SPC_V_HDAR_IDLE)
616 SA_DBG1(("siChipResetV:SPC_HDASOFT_RESET_SIGNATURE SCRATCH_PAD1 = 0x%x \n",ossaHwRegReadExt(agRoot, PCIBAR0, MSGU_SCRATCH_PAD_1)));
619 SA_DBG1(("siChipResetV: SPC_HDASOFT_RESET_SIGNATURE %X\n",regVal));
621 regVal = ossaHwRegReadExt(agRoot, PCIBAR0, V_SoftResetRegister ); /* siChipResetV */
622 SA_DBG1(("siChipResetV: SPC_HDASOFT_RESET_SIGNATURE %X\n",regVal));
624 if((regVal & SPCv_Reset_Read_Mask) == SPCv_Reset_Read_NoReset)
626 SA_DBG1(("siChipResetV: SPC_HDASOFT_RESET_SIGNATURE AGSA_RC_FAILURE %X\n",regVal));
627 returnVal = AGSA_RC_FAILURE;
629 if((regVal & SPCv_Reset_Read_Mask) == SPCv_Reset_Read_NormalResetOccurred )
631 SA_DBG1(("siChipResetV: SPC_HDASOFT_RESET_SIGNATURE AGSA_RC_FAILURE %X\n",regVal));
632 returnVal = AGSA_RC_FAILURE;
634 if((regVal & SPCv_Reset_Read_Mask) == SPCv_Reset_Read_SoftResetHDAOccurred)
636 SA_DBG1(("siChipResetV: SPC_HDASOFT_RESET_SIGNATURE AGSA_RC_SUCCESS %X\n",regVal));
637 returnVal = AGSA_RC_SUCCESS;
639 if((regVal & SPCv_Reset_Read_Mask) == SPCv_Reset_Read_ChipResetOccurred)
641 SA_DBG1(("siChipResetV: SPC_HDASOFT_RESET_SIGNATURE AGSA_RC_FAILURE %X\n",regVal));
642 returnVal = AGSA_RC_FAILURE;
644 if(regVal == 0xFFFFFFFF)
646 SA_DBG1(("siChipResetV: SPC_HDASOFT_RESET_SIGNATURE AGSA_RC_FAILURE %X\n",regVal));
647 returnVal = AGSA_RC_FAILURE;
650 SA_DBG1(("siChipResetV:SCRATCH_PAD1 = 0x%x a\n",ossaHwRegReadExt(agRoot, PCIBAR0, MSGU_SCRATCH_PAD_1)));
652 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "3A");
655 else if (signature == SPC_SOFT_RESET_SIGNATURE)
659 bit32 max_wait_count;
660 smTrace(hpDBG_LOUD,"Lw",ossaTimeStamp64(agRoot));
661 regVal = ossaHwRegReadExt(agRoot, PCIBAR0, V_SoftResetRegister ); /* siChipResetV */
662 SA_DBG1(("siChipResetV: SPC_SOFT_RESET_SIGNATURE 0x%X\n",regVal));
664 if(regVal == 0xFFFFFFFF)
666 SA_DBG1(("siChipResetV: SPC_SOFT_RESET_SIGNATURE AGSA_RC_FAILURE %X\n",regVal));
667 returnVal = AGSA_RC_FAILURE;
669 else if((regVal & SPCv_Reset_Read_Mask) == SPCv_Reset_Read_NoReset)
671 SA_DBG1(("siChipResetV:SPC_SOFT_RESET_SIGNATURE AGSA_RC_FAILURE %X\n",regVal));
672 returnVal = AGSA_RC_FAILURE;
674 else if((regVal & SPCv_Reset_Read_Mask) == SPCv_Reset_Read_SoftResetHDAOccurred)
676 SA_DBG1(("siChipResetV: SPC_SOFT_RESET_SIGNATURE AGSA_RC_FAILURE 0x%X\n",regVal));
677 returnVal = AGSA_RC_FAILURE;
679 else if((regVal & SPCv_Reset_Read_Mask) == SPCv_Reset_Read_ChipResetOccurred)
681 SA_DBG1(("siChipResetV: SPC_SOFT_RESET_SIGNATURE AGSA_RC_FAILURE 0x%X\n",regVal));
682 returnVal = AGSA_RC_FAILURE;
684 else if((regVal & SPCv_Reset_Read_Mask) == SPCv_Reset_Read_NormalResetOccurred )
686 SA_DBG1(("siChipResetV: SPC_SOFT_RESET_SIGNATURE AGSA_RC_SUCCESS 0x%X\n",regVal));
687 returnVal = AGSA_RC_SUCCESS;
689 SA_DBG1(("siChipResetV:SCRATCH_PAD1 = 0x%x b\n",ossaHwRegReadExt(agRoot, PCIBAR0, MSGU_SCRATCH_PAD_1)));
691 if( returnVal != AGSA_RC_SUCCESS)
693 SCRATCH_PAD1 = ossaHwRegReadExt(agRoot, PCIBAR0, MSGU_SCRATCH_PAD_1) & SCRATCH_PAD1_V_BOOTSTATE_MASK;
694 if(SCRATCH_PAD1 == SCRATCH_PAD1_V_BOOTSTATE_HDA_SEEPROM )
696 SA_DBG1(("siChipResetV: Reset done FW did not start BOOTSTATE_HDA_SEEPROM\n"));
699 else if(SCRATCH_PAD1 == SCRATCH_PAD1_V_BOOTSTATE_HDA_BOOTSTRAP)
701 SA_DBG1(("siChipResetV: Reset done FW did not start BOOTSTATE_HDA_BOOTSTRAP\n"));
704 else if(SCRATCH_PAD1 == SCRATCH_PAD1_V_BOOTSTATE_HDA_SOFTRESET )
706 SA_DBG1(("siChipResetV: Reset done FW did not start BOOTSTATE_HDA_SOFTRESET\n"));
709 else if(SCRATCH_PAD1 == SCRATCH_PAD1_V_BOOTSTATE_CRIT_ERROR )
711 SA_DBG1(("siChipResetV: Reset done FW did not start BOOTSTATE_CRIT_ERROR\n"));
712 smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "3A");
718 smTrace(hpDBG_LOUD,"Lx",ossaTimeStamp64(agRoot));
719 max_wait_time = (100 * 1000); /* wait 100 milliseconds */
720 max_wait_count = MAKE_MODULO(max_wait_time,WAIT_INCREMENT) - WAIT_INCREMENT;
723 ossaStallThread(agRoot, WAIT_INCREMENT);
724 SCRATCH_PAD1 = ossaHwRegReadExt(agRoot, PCIBAR0, MSGU_SCRATCH_PAD_1);
725 } while ((SCRATCH_PAD1 == 0xFFFFFFFF ) && (max_wait_count -= WAIT_INCREMENT));
727 smTrace(hpDBG_LOUD,"Ly",ossaTimeStamp64(agRoot));
728 SA_DBG1(("siChipResetV:SCRATCH_PAD1 = 0x%x (0x%x) PCIe ready took %d\n", SCRATCH_PAD1,ossaHwRegReadExt(agRoot, PCIBAR0, MSGU_SCRATCH_PAD_1),(max_wait_time - max_wait_count)));
730 max_wait_time = (1000 * 1000); /* wait 1000 milliseconds */
731 max_wait_count = MAKE_MODULO(max_wait_time,WAIT_INCREMENT) - WAIT_INCREMENT;
734 ossaStallThread(agRoot, WAIT_INCREMENT);
735 SCRATCH_PAD1 = ossaHwRegReadExt(agRoot, PCIBAR0, MSGU_SCRATCH_PAD_1);
736 } while (((SCRATCH_PAD1 & SCRATCH_PAD1_V_ILA_MASK) != SCRATCH_PAD1_V_ILA_MASK) && (max_wait_count -= WAIT_INCREMENT));
737 SA_DBG1(("siChipResetV:SCRATCH_PAD1 = 0x%x SCRATCH_PAD1_V_ILA_MASK (0x%x)(0x%x) took %d\n", SCRATCH_PAD1,SCRATCH_PAD1_V_ILA_MASK,ossaHwRegReadExt(agRoot, PCIBAR0, MSGU_SCRATCH_PAD_1),(max_wait_time - max_wait_count)));
741 returnVal = AGSA_RC_FAILURE;
742 SA_DBG1(("siChipResetV:Timeout SCRATCH_PAD1_V_ILA_MASK (0x%x) not set SCRATCH_PAD1 = 0x%x\n",SCRATCH_PAD1_V_ILA_MASK, SCRATCH_PAD1));
745 smTrace(hpDBG_LOUD,"Lz",ossaTimeStamp64(agRoot));
746 max_wait_time = (1800 * 1000); /* wait 1800 milliseconds */
747 max_wait_count = MAKE_MODULO(max_wait_time,WAIT_INCREMENT) - WAIT_INCREMENT;
750 ossaStallThread(agRoot, WAIT_INCREMENT);
751 SCRATCH_PAD1 = ossaHwRegReadExt(agRoot, PCIBAR0, MSGU_SCRATCH_PAD_1);
752 } while (((SCRATCH_PAD1 & SCRATCH_PAD1_V_RAAE_MASK) != SCRATCH_PAD1_V_RAAE_MASK) && (max_wait_count -= WAIT_INCREMENT));
754 SA_DBG1(("siChipResetV:SCRATCH_PAD1 = 0x%x SCRATCH_PAD1_V_RAAE_MASK (0x%x)(0x%x) took %d\n", SCRATCH_PAD1,SCRATCH_PAD1_V_RAAE_MASK,ossaHwRegReadExt(agRoot, PCIBAR0, MSGU_SCRATCH_PAD_1),(max_wait_time - max_wait_count)));
758 returnVal = AGSA_RC_FAILURE;
759 SA_DBG1(("siChipResetV:Timeout SCRATCH_PAD1_V_RAAE_MASK (0x%x) not set SCRATCH_PAD1 = 0x%x\n",SCRATCH_PAD1_V_RAAE_MASK, SCRATCH_PAD1));
762 smTrace(hpDBG_LOUD,"La",ossaTimeStamp64(agRoot));
763 max_wait_time = (600 * 1000); /* wait 600 milliseconds */
764 max_wait_count = MAKE_MODULO(max_wait_time,WAIT_INCREMENT) - WAIT_INCREMENT;
767 ossaStallThread(agRoot, WAIT_INCREMENT);
768 SCRATCH_PAD1 = ossaHwRegReadExt(agRoot, PCIBAR0, MSGU_SCRATCH_PAD_1);
769 } while (((SCRATCH_PAD1 & SCRATCH_PAD1_V_IOP0_MASK) != SCRATCH_PAD1_V_IOP0_MASK) && (max_wait_count -= WAIT_INCREMENT));
770 SA_DBG1(("siChipResetV:SCRATCH_PAD1 = 0x%x SCRATCH_PAD1_V_IOP0_MASK(0x%x)(0x%x) took %d\n", SCRATCH_PAD1,SCRATCH_PAD1_V_IOP0_MASK,ossaHwRegReadExt(agRoot, PCIBAR0, MSGU_SCRATCH_PAD_1),(max_wait_time - max_wait_count)));
774 returnVal = AGSA_RC_FAILURE;
775 SA_DBG1(("siChipResetV:Timeout SCRATCH_PAD1_V_IOP0_MASK (0x%x) not set SCRATCH_PAD1 = 0x%x\n",SCRATCH_PAD1_V_IOP0_MASK ,SCRATCH_PAD1));
778 if(smIS_SPCV_2_IOP(agRoot))
781 smTrace(hpDBG_LOUD,"Lb",ossaTimeStamp64(agRoot));
782 max_wait_time = (200 * 1000); /* wait 200 milliseconds */
783 max_wait_count = MAKE_MODULO(max_wait_time,WAIT_INCREMENT) - WAIT_INCREMENT;
786 ossaStallThread(agRoot, WAIT_INCREMENT);
787 SCRATCH_PAD1 = ossaHwRegReadExt(agRoot, PCIBAR0, MSGU_SCRATCH_PAD_1);
788 } while (((SCRATCH_PAD1 & SCRATCH_PAD1_V_IOP1_MASK) != SCRATCH_PAD1_V_IOP1_MASK) && (max_wait_count -= WAIT_INCREMENT));
789 SA_DBG1(("siChipResetV:SCRATCH_PAD1 = 0x%x SCRATCH_PAD1_V_IOP1_MASK (0x%x) (0x%x)(0x%x)\n", SCRATCH_PAD1,SCRATCH_PAD1_V_IOP1_MASK,ossaHwRegReadExt(agRoot, PCIBAR0, MSGU_SCRATCH_PAD_1),(max_wait_time - max_wait_count)));
793 returnVal = AGSA_RC_FAILURE;
794 SA_DBG1(("siChipResetV: SCRATCH_PAD1_V_IOP1_MASK (0x%x) not set SCRATCH_PAD1 = 0x%x\n",SCRATCH_PAD1_V_IOP1_MASK, SCRATCH_PAD1));
797 smTrace(hpDBG_LOUD,"Lc",ossaTimeStamp64(agRoot));
798 regVal = ossaHwRegReadExt(agRoot,PCIBAR0 ,V_SoftResetRegister );
799 SA_DBG1(("siChipResetV: Reset done 0x%X ERROR_STATE 0x%X\n",regVal,
800 SCRATCH_PAD1_V_ERROR_STATE( ossaHwRegReadExt(agRoot, PCIBAR0, MSGU_SCRATCH_PAD_1) ) ));
801 if(SCRATCH_PAD1_V_ERROR_STATE( ossaHwRegReadExt(agRoot, PCIBAR0, MSGU_SCRATCH_PAD_1)) )
803 smTraceFuncExit(hpDBG_VERY_LOUD, 'c', "3A");
804 return AGSA_RC_FAILURE;
808 else /* signature = unknown */
810 smTraceFuncExit(hpDBG_VERY_LOUD, 'd', "3A");
811 return AGSA_RC_FAILURE;
814 smTrace(hpDBG_LOUD,"Ld",ossaTimeStamp64(agRoot));
816 SA_DBG1(("siChipResetV: out V_SoftResetRegister %08X\n", ossaHwRegReadExt(agRoot, PCIBAR0, V_SoftResetRegister) ));
817 #ifdef SOFT_RESET_TEST
818 DbgPrint("SCRATCH_PAD1 = 0x%x \n",ossaHwRegReadExt(agRoot, PCIBAR0, MSGU_SCRATCH_PAD_1));
820 smTraceFuncExit(hpDBG_VERY_LOUD, 'e', "3A");
824 /******************************************************************************/
825 /*! \brief Function to Reset the SPC Hardware
827 * The siChipResetSpc() function is called to reset the SPC chip. Upon return,
828 * the SPC chip got reset. The PCIe bus got reset.
830 * \param agRoot handles for this instance of SAS/SATA hardware
834 /*******************************************************************************/
835 GLOBAL void siChipResetSpc(
841 smTraceFuncEnter(hpDBG_VERY_LOUD,"5c");
843 SA_DBG1(("siChipResetSpc: Chip Reset start\n"));
846 regVal = ossaHwRegReadExt(agRoot, PCIBAR2, SPC_REG_RESET);
847 regVal &= ~(SPC_REG_RESET_DEVICE);
848 ossaHwRegWriteExt(agRoot, PCIBAR2, SPC_REG_RESET, regVal); /* siChipResetSpc */
851 ossaStallThread(agRoot, WAIT_INCREMENT);
853 /* bring chip reset out of reset */
854 regVal = ossaHwRegReadExt(agRoot, PCIBAR2, SPC_REG_RESET);
855 regVal |= SPC_REG_RESET_DEVICE;
856 ossaHwRegWriteExt(agRoot, PCIBAR2, SPC_REG_RESET, regVal); /* siChipResetSpc */
859 ossaStallThread(agRoot, WAIT_INCREMENT);
861 /* wait for 20 msec until the firmware gets reloaded */
862 ossaStallThread(agRoot, (20 * 1000));
864 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "5c");
866 SA_DBG1(("siChipResetSpc: Chip Reset Complete\n"));
872 GLOBAL bit32 siSoftReset(
877 bit32 ret = AGSA_RC_SUCCESS;
879 if(smIS_SPCV(agRoot))
881 ret = si_V_SoftReset(agRoot, signature );
885 ret = siSpcSoftReset(agRoot, signature );
891 LOCAL bit32 si_V_SoftReset(
897 bit32 ret = AGSA_RC_SUCCESS;
899 ret = siChipResetV(agRoot, signature);
901 if (signature == SPC_SOFT_RESET_SIGNATURE)
903 SA_DBG1(("si_V_SoftReset:SPC_SOFT_RESET_SIGNATURE\n"));
905 else if (signature == SPC_HDASOFT_RESET_SIGNATURE)
907 SA_DBG1(("si_V_SoftReset: SPC_HDASOFT_RESET_SIGNATURE\n"));
910 SA_DBG1(("si_V_SoftReset: Reset Complete status 0x%X\n",ret));
914 /******************************************************************************/
915 /*! \brief Function to soft/FW reset the SPC
917 * The siSpcSoftReset() function is called to soft reset SPC. Upon return,
918 * the SPC FW got reset. The PCIe bus is not touched.
920 * \param agRoot handles for this instance of SAS/SATA hardware
921 * \param signature soft reset normal signature or HDA soft reset signature
925 /*******************************************************************************/
926 GLOBAL bit32 siSpcSoftReset(
931 spc_configMainDescriptor_t mainCfg;
932 bit32 regVal, toggleVal;
934 bit32 max_wait_count;
935 bit32 regVal1, regVal2, regVal3;
939 SA_ASSERT( (agNULL != agRoot), "agNULL != agRoot");
940 if(agNULL != agRoot->sdkData)
942 smTraceFuncEnter(hpDBG_VERY_LOUD,"5t");
945 SA_DBG1(("siSpcSoftReset: start\n"));
948 #if defined(SALLSDK_DEBUG)
949 /* count SoftReset */
950 gLLSoftResetCounter++;
951 SA_DBG1(("siSpcSoftReset: ResetCount = 0x%x\n", gLLSoftResetCounter));
954 /* step1: Check FW is ready for soft reset */
956 smTrace(hpDBG_VERY_LOUD,"Q1", 1);
957 /* TP:Q1 siSpcSoftReset */
959 if(AGSA_RC_FAILURE == siSpcSoftResetRDYChk(agRoot))
961 SA_DBG1(("siSoftReset:siSoftResetRDYChk failed\n"));
962 if(agNULL != agRoot->sdkData)
964 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "5t");
966 return AGSA_RC_FAILURE;
969 /* step 2: clear NMI status register on AAP1 and IOP, write the same value to clear */
970 /* map 0x60000 to BAR4(0x20), BAR2(win) */
971 smTrace(hpDBG_VERY_LOUD,"Q2", 2);
972 /* TP:Q2 siSpcSoftReset */
973 if (AGSA_RC_FAILURE == siBar4Shift(agRoot, MBIC_AAP1_ADDR_BASE))
975 SA_DBG1(("siSpcSoftReset:Shift Bar4 to 0x%x failed\n", MBIC_AAP1_ADDR_BASE));
976 if(agNULL != agRoot->sdkData)
978 smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "5t");
981 SA_DBG1(("siSpcSoftReset: Soft Reset AGSA_RC_FAILURE %d\n",1));
982 return AGSA_RC_FAILURE;
984 regVal = ossaHwRegReadExt(agRoot, PCIBAR2, MBIC_NMI_ENABLE_VPE0_IOP);
985 SA_DBG1(("MBIC(A) - NMI Enable VPE0 (IOP): = 0x%x\n", regVal));
986 ossaHwRegWriteExt(agRoot, PCIBAR2, MBIC_NMI_ENABLE_VPE0_IOP, 0x0); /* siSpcSoftReset */
988 /* map 0x70000 to BAR4(0x20), BAR2(win) */
989 if (AGSA_RC_FAILURE == siBar4Shift(agRoot, MBIC_IOP_ADDR_BASE))
991 SA_DBG1(("siSpcSoftReset:Shift Bar4 to 0x%x failed\n", MBIC_IOP_ADDR_BASE));
992 if(agNULL != agRoot->sdkData)
994 smTraceFuncExit(hpDBG_VERY_LOUD, 'c', "5t");
996 SA_DBG1(("siSpcSoftReset: Soft Reset AGSA_RC_FAILURE %d\n",2));
997 return AGSA_RC_FAILURE;
999 regVal = ossaHwRegReadExt(agRoot, PCIBAR2, MBIC_NMI_ENABLE_VPE0_AAP1);
1000 SA_DBG1(("MBIC(A) - NMI Enable VPE0 (AAP1): = 0x%x\n", regVal));
1001 ossaHwRegWriteExt(agRoot, PCIBAR2, MBIC_NMI_ENABLE_VPE0_AAP1, 0x0); /* siSpcSoftReset */
1003 regVal = ossaHwRegReadExt(agRoot, PCIBAR1, PCIE_EVENT_INTERRUPT_ENABLE);
1004 SA_DBG1(("PCIE - Event Interrupt Enable Register: = 0x%x\n", regVal));
1005 ossaHwRegWriteExt(agRoot, PCIBAR1, PCIE_EVENT_INTERRUPT_ENABLE, 0x0); /* siSpcSoftReset */
1007 regVal = ossaHwRegReadExt(agRoot, PCIBAR1, PCIE_EVENT_INTERRUPT);
1008 SA_DBG1(("PCIE - Event Interrupt Register: = 0x%x\n", regVal));
1009 ossaHwRegWriteExt(agRoot, PCIBAR1, PCIE_EVENT_INTERRUPT, regVal); /* siSpcSoftReset */
1011 regVal = ossaHwRegReadExt(agRoot, PCIBAR1, PCIE_ERROR_INTERRUPT_ENABLE);
1012 SA_DBG1(("PCIE - Error Interrupt Enable Register: = 0x%x\n", regVal));
1013 ossaHwRegWriteExt(agRoot, PCIBAR1, PCIE_ERROR_INTERRUPT_ENABLE, 0x0); /* siSpcSoftReset */
1015 regVal = ossaHwRegReadExt(agRoot, PCIBAR1, PCIE_ERROR_INTERRUPT);
1016 SA_DBG1(("PCIE - Error Interrupt Register: = 0x%x\n", regVal));
1017 ossaHwRegWriteExt(agRoot, PCIBAR1, PCIE_ERROR_INTERRUPT, regVal); /* siSpcSoftReset */
1019 /* read the scratch pad 1 register bit 2 */
1020 regVal = ossaHwRegRead(agRoot, MSGU_SCRATCH_PAD_1) & SCRATCH_PAD1_RST;
1021 toggleVal = regVal ^ SCRATCH_PAD1_RST;
1023 /* set signature in host scratch pad0 register to tell SPC that the host performs the soft reset */
1024 ossaHwRegWrite(agRoot, MSGU_HOST_SCRATCH_PAD_0, signature);
1026 /* read required registers for confirmming */
1027 /* map 0x0700000 to BAR4(0x20), BAR2(win) */
1028 if (AGSA_RC_FAILURE == siBar4Shift(agRoot, GSM_ADDR_BASE))
1030 SA_DBG1(("siSpcSoftReset:Shift Bar4 to 0x%x failed\n", GSM_ADDR_BASE));
1031 if(agNULL != agRoot->sdkData)
1033 smTraceFuncExit(hpDBG_VERY_LOUD, 'd', "5t");
1035 SA_DBG1(("siSpcSoftReset: Soft Reset AGSA_RC_FAILURE %d\n",3));
1036 return AGSA_RC_FAILURE;
1039 SA_DBG1(("GSM 0x0 (0x00007b88) - GSM Configuration and Reset = 0x%x\n", ossaHwRegReadExt(agRoot, PCIBAR2, GSM_CONFIG_RESET)));
1041 smTrace(hpDBG_VERY_LOUD,"Q3", 3);
1042 /* TP:Q3 siSpcSoftReset */
1044 /* step 3: host read GSM Configuration and Reset register */
1045 regVal = ossaHwRegReadExt(agRoot, PCIBAR2, GSM_CONFIG_RESET);
1046 /* Put those bits to low */
1047 /* GSM XCBI offset = 0x70 0000
1048 0x00 Bit 13 COM_SLV_SW_RSTB 1
1049 0x00 Bit 12 QSSP_SW_RSTB 1
1050 0x00 Bit 11 RAAE_SW_RSTB 1
1051 0x00 Bit 9 RB_1_SW_RSTB 1
1052 0x00 Bit 8 SM_SW_RSTB 1
1054 regVal &= ~(0x00003b00);
1055 /* host write GSM Configuration and Reset register */
1056 ossaHwRegWriteExt(agRoot, PCIBAR2, GSM_CONFIG_RESET, regVal); /* siSpcSoftReset */
1057 SA_DBG1(("GSM 0x0 (0x00007b88 ==> 0x00004088) - GSM Configuration and Reset is set to = 0x%x\n", ossaHwRegReadExt(agRoot, PCIBAR2, GSM_CONFIG_RESET)));
1059 #if defined(SALLSDK_DEBUG)
1060 /* debugging messge */
1061 SA_DBG1(("GSM 0x700018 - RAM ECC Double Bit Error Indication = 0x%x\n", ossaHwRegReadExt(agRoot, PCIBAR2, RAM_ECC_DB_ERR)));
1063 SA_DBG1(("GSM 0x700058 - Read Address Parity Error Indication = 0x%x\n", ossaHwRegReadExt(agRoot, PCIBAR2, GSM_READ_ADDR_PARITY_INDIC)));
1064 SA_DBG1(("GSM 0x700060 - Write Address Parity Error Indication = 0x%x\n", ossaHwRegReadExt(agRoot, PCIBAR2, GSM_WRITE_ADDR_PARITY_INDIC)));
1065 SA_DBG1(("GSM 0x700068 - Write Data Parity Error Indication = 0x%x\n", ossaHwRegReadExt(agRoot, PCIBAR2, GSM_WRITE_DATA_PARITY_INDIC)));
1069 /* disable GSM - Read Address Parity Check */
1070 smTrace(hpDBG_VERY_LOUD,"Q4", 4);
1071 /* TP:Q4 siSpcSoftReset */
1072 regVal1 = ossaHwRegReadExt(agRoot, PCIBAR2, GSM_READ_ADDR_PARITY_CHECK);
1073 SA_DBG1(("GSM 0x700038 - Read Address Parity Check Enable = 0x%x\n", regVal1));
1074 ossaHwRegWriteExt(agRoot, PCIBAR2, GSM_READ_ADDR_PARITY_CHECK, 0x0); /* siSpcSoftReset */
1075 SA_DBG1(("GSM 0x700038 - Read Address Parity Check Enable is set to = 0x%x\n", ossaHwRegReadExt(agRoot, PCIBAR2, GSM_READ_ADDR_PARITY_CHECK)));
1077 /* disable GSM - Write Address Parity Check */
1078 regVal2 = ossaHwRegReadExt(agRoot, PCIBAR2, GSM_WRITE_ADDR_PARITY_CHECK);
1079 SA_DBG1(("GSM 0x700040 - Write Address Parity Check Enable = 0x%x\n", regVal2));
1080 ossaHwRegWriteExt(agRoot, PCIBAR2, GSM_WRITE_ADDR_PARITY_CHECK, 0x0); /* siSpcSoftReset */
1081 SA_DBG1(("GSM 0x700040 - Write Address Parity Check Enable is set to = 0x%x\n", ossaHwRegReadExt(agRoot, PCIBAR2, GSM_WRITE_ADDR_PARITY_CHECK)));
1083 /* disable GSM - Write Data Parity Check */
1084 regVal3 = ossaHwRegReadExt(agRoot, PCIBAR2, GSM_WRITE_DATA_PARITY_CHECK);
1085 SA_DBG1(("GSM 0x300048 - Write Data Parity Check Enable = 0x%x\n", regVal3));
1086 ossaHwRegWriteExt(agRoot, PCIBAR2, GSM_WRITE_DATA_PARITY_CHECK, 0x0); /* siSpcSoftReset */
1087 SA_DBG1(("GSM 0x700048 - Write Data Parity Check Enable is set to = 0x%x\n", ossaHwRegReadExt(agRoot, PCIBAR2, GSM_WRITE_DATA_PARITY_CHECK)));
1088 /* step 5-a: delay 10 usec */
1089 smTrace(hpDBG_VERY_LOUD,"Q5", 5);
1090 /* TP:Q5 siSpcSoftReset */
1091 ossaStallThread(agRoot, 10);
1093 /* step 5-b: set GPIO-0 output control to tristate anyway */
1094 if (AGSA_RC_FAILURE == siBar4Shift(agRoot, GPIO_ADDR_BASE))
1096 SA_DBG1(("siSpcSoftReset:Shift Bar4 to 0x%x failed\n", GPIO_ADDR_BASE));
1097 if(agNULL != agRoot->sdkData)
1099 smTraceFuncExit(hpDBG_VERY_LOUD, 'e', "5t");
1101 SA_DBG1(("siSpcSoftReset: Soft Reset AGSA_RC_FAILURE %d\n",4));
1102 return AGSA_RC_FAILURE;
1104 regVal = ossaHwRegReadExt(agRoot, PCIBAR2, GPIO_GPIO_0_0UTPUT_CTL_OFFSET);
1105 SA_DBG1(("GPIO Output Control Register: = 0x%x\n", regVal));
1106 /* set GPIO-0 output control to tri-state */
1107 regVal &= 0xFFFFFFFC;
1108 ossaHwRegWriteExt(agRoot, PCIBAR2, GPIO_GPIO_0_0UTPUT_CTL_OFFSET, regVal); /* siSpcSoftReset */
1110 /* Step 6: Reset the IOP and AAP1 */
1111 /* map 0x00000 to BAR4(0x20), BAR2(win) */
1112 smTrace(hpDBG_VERY_LOUD,"Q6", 6);
1113 /* TP:Q6 siSpcSoftReset */
1114 if (AGSA_RC_FAILURE == siBar4Shift(agRoot, SPC_TOP_LEVEL_ADDR_BASE))
1116 SA_DBG1(("siSpcSoftReset:Shift Bar4 to 0x%x failed\n", SPC_TOP_LEVEL_ADDR_BASE));
1117 if(agNULL != agRoot->sdkData)
1119 smTraceFuncExit(hpDBG_VERY_LOUD, 'f', "5t");
1121 SA_DBG1(("siSpcSoftReset: Soft Reset AGSA_RC_FAILURE %d\n",5));
1122 return AGSA_RC_FAILURE;
1124 regVal = ossaHwRegReadExt(agRoot, PCIBAR2, SPC_REG_RESET);
1125 SA_DBG1(("Top Register before resetting IOP/AAP1: = 0x%x\n", regVal));
1126 regVal &= ~(SPC_REG_RESET_PCS_IOP_SS | SPC_REG_RESET_PCS_AAP1_SS);
1127 ossaHwRegWriteExt(agRoot, PCIBAR2, SPC_REG_RESET, regVal); /* siSpcSoftReset */
1129 /* step 7: Reset the BDMA/OSSP */
1130 smTrace(hpDBG_VERY_LOUD,"Q7", 7);
1131 /* TP:Q7 siSpcSoftReset */
1132 regVal = ossaHwRegReadExt(agRoot, PCIBAR2, SPC_REG_RESET);
1133 SA_DBG1(("Top Register before resetting BDMA/OSSP: = 0x%x\n", regVal));
1134 regVal &= ~(SPC_REG_RESET_BDMA_CORE | SPC_REG_RESET_OSSP);
1135 ossaHwRegWriteExt(agRoot, PCIBAR2, SPC_REG_RESET, regVal); /* siSpcSoftReset */
1137 /* step 8: delay 10 usec */
1138 smTrace(hpDBG_VERY_LOUD,"Q8", 8);
1139 /* TP:Q8 siSpcSoftReset */
1141 ossaStallThread(agRoot, WAIT_INCREMENT);
1143 /* step 9: bring the BDMA and OSSP out of reset */
1144 smTrace(hpDBG_VERY_LOUD,"Q9", 9);
1145 /* TP:Q9 siSpcSoftReset */
1146 regVal = ossaHwRegReadExt(agRoot, PCIBAR2, SPC_REG_RESET);
1147 SA_DBG1(("Top Register before bringing up BDMA/OSSP: = 0x%x\n", regVal));
1148 regVal |= (SPC_REG_RESET_BDMA_CORE | SPC_REG_RESET_OSSP);
1149 ossaHwRegWriteExt(agRoot, PCIBAR2, SPC_REG_RESET, regVal); /* siSpcSoftReset */
1151 /* step 10: delay 10 usec */
1152 smTrace(hpDBG_VERY_LOUD,"QA", 10);
1153 /* TP:QA siSpcSoftReset */
1154 ossaStallThread(agRoot, WAIT_INCREMENT);
1156 /* step 11: reads and sets the GSM Configuration and Reset Register */
1157 /* map 0x0700000 to BAR4(0x20), BAR2(win) */
1158 smTrace(hpDBG_VERY_LOUD,"QB", 11);
1159 /* TP:QB siSpcSoftReset */
1160 if (AGSA_RC_FAILURE == siBar4Shift(agRoot, GSM_ADDR_BASE))
1162 SA_DBG1(("siSpcSoftReset:Shift Bar4 to 0x%x failed\n", GSM_ADDR_BASE));
1163 if(agNULL != agRoot->sdkData)
1165 smTraceFuncExit(hpDBG_VERY_LOUD, 'g', "5t");
1167 SA_DBG1(("siSpcSoftReset: Soft Reset AGSA_RC_FAILURE %d\n",5));
1168 return AGSA_RC_FAILURE;
1170 SA_DBG1(("GSM 0x0 (0x00007b88) - GSM Configuration and Reset = 0x%x\n", ossaHwRegReadExt(agRoot, PCIBAR2, GSM_CONFIG_RESET)));
1171 regVal = ossaHwRegReadExt(agRoot, PCIBAR2, GSM_CONFIG_RESET);
1172 /* Put those bits to high */
1173 /* GSM XCBI offset = 0x70 0000
1174 0x00 Bit 13 COM_SLV_SW_RSTB 1
1175 0x00 Bit 12 QSSP_SW_RSTB 1
1176 0x00 Bit 11 RAAE_SW_RSTB 1
1177 0x00 Bit 9 RB_1_SW_RSTB 1
1178 0x00 Bit 8 SM_SW_RSTB 1
1180 regVal |= (GSM_CONFIG_RESET_VALUE);
1181 ossaHwRegWriteExt(agRoot, PCIBAR2, GSM_CONFIG_RESET, regVal); /* siSpcSoftReset */
1182 SA_DBG1(("GSM 0x0 (0x00004088 ==> 0x00007b88) - GSM Configuration and Reset is set to = 0x%x\n", ossaHwRegReadExt(agRoot, PCIBAR2, GSM_CONFIG_RESET)));
1184 #if defined(SALLSDK_DEBUG)
1185 /* debugging messge */
1186 SA_DBG1(("GSM 0x700018 - RAM ECC Double Bit Error Indication = 0x%x\n", ossaHwRegReadExt(agRoot, PCIBAR2, RAM_ECC_DB_ERR)));
1187 SA_DBG1(("GSM 0x700058 - Read Address Parity Error Indication = 0x%x\n", ossaHwRegReadExt(agRoot, PCIBAR2, GSM_READ_ADDR_PARITY_INDIC)));
1188 SA_DBG1(("GSM 0x700060 - Write Address Parity Error Indication = 0x%x\n", ossaHwRegReadExt(agRoot, PCIBAR2, GSM_WRITE_ADDR_PARITY_INDIC)));
1189 SA_DBG1(("GSM 0x700068 - Write Data Parity Error Indication = 0x%x\n", ossaHwRegReadExt(agRoot, PCIBAR2, GSM_WRITE_DATA_PARITY_INDIC)));
1192 /* step 12: Restore GSM - Read Address Parity Check */
1193 smTrace(hpDBG_VERY_LOUD,"QC", 12);
1194 /* TP:QC siSpcSoftReset */
1195 regVal = ossaHwRegReadExt(agRoot, PCIBAR2, GSM_READ_ADDR_PARITY_CHECK); /* just for debugging */
1196 SA_DBG1(("GSM 0x700038 - Read Address Parity Check Enable = 0x%x\n", regVal));
1197 ossaHwRegWriteExt(agRoot, PCIBAR2, GSM_READ_ADDR_PARITY_CHECK, regVal1); /* siSpcSoftReset */
1198 SA_DBG1(("GSM 0x700038 - Read Address Parity Check Enable is set to = 0x%x\n", ossaHwRegReadExt(agRoot, PCIBAR2, GSM_READ_ADDR_PARITY_CHECK)));
1200 /* Restore GSM - Write Address Parity Check */
1201 regVal = ossaHwRegReadExt(agRoot, PCIBAR2, GSM_WRITE_ADDR_PARITY_CHECK); /* just for debugging */
1202 SA_DBG1(("GSM 0x700040 - Write Address Parity Check Enable = 0x%x\n", regVal));
1203 ossaHwRegWriteExt(agRoot, PCIBAR2, GSM_WRITE_ADDR_PARITY_CHECK, regVal2); /* siSpcSoftReset */
1204 SA_DBG1(("GSM 0x700040 - Write Address Parity Check Enable is set to = 0x%x\n", ossaHwRegReadExt(agRoot, PCIBAR2, GSM_WRITE_ADDR_PARITY_CHECK)));
1206 /* Restore GSM - Write Data Parity Check */
1207 regVal = ossaHwRegReadExt(agRoot, PCIBAR2, GSM_WRITE_DATA_PARITY_CHECK); /* just for debugging */
1208 SA_DBG1(("GSM 0x700048 - Write Data Parity Check Enable = 0x%x\n", regVal));
1209 ossaHwRegWriteExt(agRoot, PCIBAR2, GSM_WRITE_DATA_PARITY_CHECK, regVal3); /* siSpcSoftReset */
1210 SA_DBG1(("GSM 0x700048 - Write Data Parity Check Enable is set to = 0x%x\n", ossaHwRegReadExt(agRoot, PCIBAR2, GSM_WRITE_DATA_PARITY_CHECK)));
1212 /* step 13: bring the IOP and AAP1 out of reset */
1213 /* map 0x00000 to BAR4(0x20), BAR2(win) */
1214 smTrace(hpDBG_VERY_LOUD,"QD", 13);
1215 /* TP:QD siSpcSoftReset */
1216 if (AGSA_RC_FAILURE == siBar4Shift(agRoot, SPC_TOP_LEVEL_ADDR_BASE))
1218 SA_DBG1(("siSpcSoftReset:Shift Bar4 to 0x%x failed\n", SPC_TOP_LEVEL_ADDR_BASE));
1219 if(agNULL != agRoot->sdkData)
1221 smTraceFuncExit(hpDBG_VERY_LOUD, 'h', "5t");
1223 SA_DBG1(("siSpcSoftReset: Soft Reset AGSA_RC_FAILURE %d\n",7));
1224 return AGSA_RC_FAILURE;
1226 regVal = ossaHwRegReadExt(agRoot, PCIBAR2, SPC_REG_RESET);
1227 SA_DBG1(("Top Register before bringing up IOP/AAP1: = 0x%x\n", regVal));
1228 regVal |= (SPC_REG_RESET_PCS_IOP_SS | SPC_REG_RESET_PCS_AAP1_SS);
1229 ossaHwRegWriteExt(agRoot, PCIBAR2, SPC_REG_RESET, regVal); /* siSpcSoftReset */
1231 if (signature == SPC_SOFT_RESET_SIGNATURE)
1233 /* step 14: delay 20 milli - Normal Mode */
1234 ossaStallThread(agRoot, WAIT_INCREMENT);
1235 }else if (signature == SPC_HDASOFT_RESET_SIGNATURE)
1237 /* step 14: delay 200 milli - HDA Mode */
1238 ossaStallThread(agRoot, 200 * 1000);
1241 /* check Soft Reset Normal mode or Soft Reset HDA mode */
1242 if (signature == SPC_SOFT_RESET_SIGNATURE)
1244 /* step 15 (Normal Mode): wait until scratch pad1 register bit 2 toggled */
1245 max_wait_time = WAIT_SECONDS(2); /* 2 sec */
1246 max_wait_count = MAKE_MODULO(max_wait_time,WAIT_INCREMENT) - WAIT_INCREMENT;
1249 ossaStallThread(agRoot, WAIT_INCREMENT);
1250 regVal = ossaHwRegRead(agRoot, MSGU_SCRATCH_PAD_1) & SCRATCH_PAD1_RST;
1251 } while ((regVal != toggleVal) && (max_wait_count -=WAIT_INCREMENT));
1253 if ( !max_wait_count)
1255 regVal = ossaHwRegRead(agRoot, MSGU_SCRATCH_PAD_1);
1256 SA_DBG1(("siSpcSoftReset: TIMEOUT:ToggleVal 0x%x, MSGU_SCRATCH_PAD1 = 0x%x\n", toggleVal, regVal));
1257 if(agNULL != agRoot->sdkData)
1259 smTraceFuncExit(hpDBG_VERY_LOUD, 'i', "5t");
1261 #if defined(SALLSDK_DEBUG)
1262 SA_DBG1(("siSpcSoftReset: SCRATCH_PAD0 value = 0x%x\n", ossaHwRegRead(agRoot, MSGU_SCRATCH_PAD_0)));
1263 SA_DBG1(("siSpcSoftReset: SCRATCH_PAD2 value = 0x%x\n", ossaHwRegRead(agRoot, MSGU_SCRATCH_PAD_2)));
1264 SA_DBG1(("siSpcSoftReset: SCRATCH_PAD3 value = 0x%x\n", ossaHwRegRead(agRoot, MSGU_SCRATCH_PAD_3)));
1266 SA_DBG1(("siSpcSoftReset: Soft Reset AGSA_RC_FAILURE %d\n",8));
1267 return AGSA_RC_FAILURE;
1270 /* step 16 (Normal)step 15 (HDA) - Clear ODMR and ODCR */
1271 smTrace(hpDBG_VERY_LOUD,"QG", 16);
1272 /* TP:QG siSpcSoftReset */
1274 ossaHwRegWrite(agRoot, MSGU_ODCR, ODCR_CLEAR_ALL);
1275 ossaHwRegWrite(agRoot, MSGU_ODMR, ODMR_CLEAR_ALL);
1277 else if (signature == SPC_HDASOFT_RESET_SIGNATURE)
1279 if(agNULL != agRoot->sdkData)
1281 SA_DBG1(("siSpcSoftReset: HDA Soft Reset Complete\n"));
1282 smTraceFuncExit(hpDBG_VERY_LOUD, 'j', "5t");
1284 return AGSA_RC_SUCCESS;
1288 /* step 17 (Normal Mode): wait for the FW and IOP to get ready - 1 sec timeout */
1289 /* Wait for the SPC Configuration Table to be ready */
1290 if (mpiWaitForConfigTable(agRoot, &mainCfg) == AGSA_RC_FAILURE)
1292 regVal = ossaHwRegRead(agRoot, MSGU_SCRATCH_PAD_1);
1293 /* return error if MPI Configuration Table not ready */
1294 SA_DBG1(("siSpcSoftReset: SPC FW not ready SCRATCH_PAD1 = 0x%x\n", regVal));
1295 regVal = ossaHwRegRead(agRoot, MSGU_SCRATCH_PAD_2);
1296 /* return error if MPI Configuration Table not ready */
1297 SA_DBG1(("siSpcSoftReset: SPC FW not ready SCRATCH_PAD2 = 0x%x\n", regVal));
1298 if(agNULL != agRoot->sdkData)
1300 smTraceFuncExit(hpDBG_VERY_LOUD, 'k', "5t");
1302 #if defined(SALLSDK_DEBUG)
1303 SA_DBG1(("siSpcSoftReset: SCRATCH_PAD0 value = 0x%x\n", ossaHwRegRead(agRoot, MSGU_SCRATCH_PAD_0)));
1304 SA_DBG1(("siSpcSoftReset: SCRATCH_PAD3 value = 0x%x\n", ossaHwRegRead(agRoot, MSGU_SCRATCH_PAD_3)));
1306 SA_DBG1(("siSpcSoftReset: Soft Reset AGSA_RC_FAILURE %d\n",9));
1307 return AGSA_RC_FAILURE;
1309 smTrace(hpDBG_VERY_LOUD,"QI", 18);
1310 /* TP:QI siSpcSoftReset */
1312 if(agNULL != agRoot->sdkData)
1314 smTraceFuncExit(hpDBG_VERY_LOUD, 'l', "5t");
1317 SA_DBG1(("siSpcSoftReset: Soft Reset Complete\n"));
1319 return AGSA_RC_SUCCESS;
1322 /******************************************************************************/
1323 /*! \brief Function to do BAR shifting
1325 * The siBarShift() function is called to shift BAR base address
1327 * \param agRoot handles for this instance of SAS/SATA hardware
1328 * \param shiftValue shifting value
1330 * \return success or fail
1332 /*******************************************************************************/
1333 GLOBAL bit32 siBar4Shift(
1339 bit32 max_wait_time;
1340 bit32 max_wait_count;
1342 smTraceFuncEnter(hpDBG_VERY_LOUD,"5e");
1343 smTrace(hpDBG_VERY_LOUD,"GA",shiftValue);
1344 /* TP:GA shiftValue */
1346 SA_DBG2(("siBar4Shift: shiftValue 0x%x\n",shiftValue));
1348 if(smIS_SPCV(agRoot) )
1350 ossaHwRegWriteExt(agRoot, PCIBAR0, V_MEMBASE_II_ShiftRegister, shiftValue);
1351 /* confirm the setting is written */
1352 max_wait_time = WAIT_SECONDS(1); /* 1 sec */
1353 max_wait_count = MAKE_MODULO(max_wait_time,WAIT_INCREMENT) - WAIT_INCREMENT;
1356 ossaStallThread(agRoot, WAIT_INCREMENT);
1357 regVal = ossaHwRegReadExt(agRoot, PCIBAR0, V_MEMBASE_II_ShiftRegister);
1358 } while ((regVal != shiftValue) && (max_wait_count -= WAIT_INCREMENT));
1360 if (!max_wait_count)
1362 SA_DBG1(("siBar4Shift: TIMEOUT: SPC_IBW_AXI_TRANSLATION_LOW = 0x%x\n", regVal));
1363 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "5e");
1364 return AGSA_RC_FAILURE;
1367 else if(smIS_SPC(agRoot))
1369 /* program the inbound AXI translation Lower Address */
1370 ossaHwRegWriteExt(agRoot, PCIBAR1, SPC_IBW_AXI_TRANSLATION_LOW, shiftValue);
1372 /* confirm the setting is written */
1373 max_wait_time = WAIT_SECONDS(1); /* 1 sec */
1374 max_wait_count = MAKE_MODULO(max_wait_time,WAIT_INCREMENT) - WAIT_INCREMENT;
1377 ossaStallThread(agRoot, WAIT_INCREMENT);
1378 regVal = ossaHwRegReadExt(agRoot, PCIBAR1, SPC_IBW_AXI_TRANSLATION_LOW);
1379 } while ((regVal != shiftValue) && (max_wait_count -= WAIT_INCREMENT));
1381 if (!max_wait_count)
1383 SA_DBG1(("siBar4Shift: TIMEOUT: SPC_IBW_AXI_TRANSLATION_LOW = 0x%x\n", regVal));
1384 smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "5e");
1385 return AGSA_RC_FAILURE;
1390 SA_DBG1(("siBar4Shift: hba type is not support\n"));
1391 return AGSA_RC_FAILURE;
1393 smTraceFuncExit(hpDBG_VERY_LOUD, 'c', "5e");
1395 return AGSA_RC_SUCCESS;
1398 #ifdef SA_ENABLE_HDA_FUNCTIONS
1399 /******************************************************************************/
1400 /*! \brief Function to force HDA mode the SPC
1402 * The siHDAMode() function is called to force to HDA mode. Upon return,
1403 * the SPC FW loaded. The PCIe bus is not touched.
1405 * \param agRoot handles for this instance of SAS/SATA hardware
1406 * \param HDAMode 0 - HDA soft reset mode, 1 - HDA mode
1407 * \param fwImg points to structure containing fw images
1411 /*******************************************************************************/
1412 GLOBAL bit32 siHDAMode(
1415 agsaFwImg_t *userFwImg
1418 spc_configMainDescriptor_t mainCfg;
1420 bit32 max_wait_time;
1421 bit32 max_wait_count;
1422 agsaFwImg_t flashImg;
1423 bit32 startTime, endTime; // TestBase
1424 bit32 stepTime[12]; // TestBase
1426 bit32 HDA_Been_Reset = agFALSE;
1428 smTraceFuncEnter(hpDBG_VERY_LOUD,"5d");
1431 SA_ASSERT( (agNULL != agRoot), "");
1433 SA_DBG1(("siHDAMode: start\n"));
1435 si_memset(&flashImg, 0, sizeof(flashImg));
1436 #ifndef SA_EXCLUDE_FW_IMG
1438 /* Set up built-in (default) FW image pointers */
1440 flashImg.aap1Img = (bit8*)(&aap1array);
1441 flashImg.aap1Len = sizeof(aap1array);
1442 flashImg.ilaImg = (bit8*)(&ilaarray);
1443 flashImg.ilaLen = sizeof(ilaarray);
1444 flashImg.iopImg = (bit8*)(&ioparray);
1445 flashImg.iopLen = sizeof(ioparray);
1450 /* Set up user FW image pointers (if passed in) */
1453 SA_DBG1(("siHDAMode: User fw structure @ %p\n",userFwImg));
1454 if (userFwImg->aap1Img && userFwImg->aap1Len)
1456 flashImg.aap1Img = userFwImg->aap1Img;
1457 flashImg.aap1Len = userFwImg->aap1Len;
1458 SA_DBG1(("siHDAMode: User fw aap1 @ %p (%d)\n", flashImg.aap1Img, flashImg.aap1Len));
1460 if (userFwImg->ilaImg && userFwImg->ilaLen)
1462 flashImg.ilaImg = userFwImg->ilaImg;
1463 flashImg.ilaLen = userFwImg->ilaLen;
1464 SA_DBG1(("siHDAMode: User fw ila @ %p (%d)\n", flashImg.ilaImg, flashImg.ilaLen));
1466 if (userFwImg->iopImg && userFwImg->iopLen)
1468 flashImg.iopImg = userFwImg->iopImg;
1469 flashImg.iopLen = userFwImg->iopLen;
1470 SA_DBG1(("siHDAMode: User fw iop @ %p (%d)\n", flashImg.iopImg, flashImg.iopLen));
1472 if (userFwImg->istrImg && userFwImg->istrLen)
1474 flashImg.istrImg = userFwImg->istrImg;
1475 flashImg.istrLen = userFwImg->istrLen;
1476 SA_DBG1(("siHDAMode: User fw istr @ %p (%d)\n", flashImg.istrImg, flashImg.istrLen));
1481 SA_DBG1(("siHDAMode: user supplied FW is not found\n"));
1482 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "5d");
1483 return AGSA_RC_FAILURE;
1486 #ifdef SA_EXCLUDE_FW_IMG
1487 /* Check that fw images are setup properly */
1488 if (!(flashImg.aap1Img && flashImg.aap1Len &&
1489 flashImg.ilaImg && flashImg.ilaLen &&
1490 flashImg.iopImg && flashImg.iopLen &&
1491 flashImg.istrImg && flashImg.istrLen))
1493 SA_DBG1(("siHDAMode: Built-in FW img excluded and not user defined.\n"));
1494 smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "5d");
1495 return AGSA_RC_FAILURE;
1499 /* Check HDA mode with Soft Reset */
1502 /* Try soft reset until it goes into HDA mode */
1503 siSpcSoftReset(agRoot, SPC_HDASOFT_RESET_SIGNATURE);
1505 /* read response state */
1506 regVal = ossaHwRegReadExt(agRoot, PCIBAR3, HDA_RSP_OFFSET1MB+HDA_CMD_CODE_OFFSET) & HDA_STATUS_BITS;
1507 if (regVal != BOOTTLOADERHDA_IDLE)
1509 /* Can not go into HDA mode with 200 ms wait - HDA Soft Reset failed */
1510 SA_DBG1(("siHDAMode: HDA_RSP_OFFSET1MB+HDA_CMD_CODE_OFFSET = 0x%x\n", regVal));
1511 smTraceFuncExit(hpDBG_VERY_LOUD, 'c', "5d");
1512 return AGSA_RC_FAILURE;
1515 /* HDA Mode - Clear ODMR and ODCR */
1516 ossaHwRegWrite(agRoot, MSGU_ODCR, ODCR_CLEAR_ALL);
1517 ossaHwRegWrite(agRoot, MSGU_ODMR, ODMR_CLEAR_ALL);
1520 /* Step 1: Poll BOOTTLOADERHDA_IDLE - HDA mode */
1521 SA_DBG1(("siHDAMode: Step1:Poll for HDAR_IDLE\n"));
1522 max_wait_time = WAIT_SECONDS(gWait_2); /* 2 sec */
1523 max_wait_count = MAKE_MODULO(max_wait_time,WAIT_INCREMENT) - WAIT_INCREMENT;
1526 ossaStallThread(agRoot, WAIT_INCREMENT);
1527 regVal = ossaHwRegReadExt(agRoot, PCIBAR3, HDA_RSP_OFFSET1MB+HDA_CMD_CODE_OFFSET) & HDA_STATUS_BITS;
1528 } while ((regVal != BOOTTLOADERHDA_IDLE) && (max_wait_count -= WAIT_INCREMENT));
1530 if (!max_wait_count)
1533 if( !HDA_Been_Reset )
1536 SA_DBG1(("siHDAMode: Reset: Step1:regVal =0x%x expect 0x%x\n", regVal,ILAHDA_AAP1_IMG_GET ));
1537 siSpcSoftReset(agRoot, SPC_HDASOFT_RESET_SIGNATURE);
1538 HDA_Been_Reset = agTRUE;
1543 SA_DBG1(("siHDAMode: Step1:TIMEOUT: HDA_RSP_OFFSET1MB+HDA_CMD_CODE_OFFSET = 0x%x\n", regVal));
1544 smTraceFuncExit(hpDBG_VERY_LOUD, 'd', "5d");
1545 return AGSA_RC_FAILURE;
1548 /* Step 2: Push the init string to 0x0047E000 & data compare */
1549 SA_DBG1(("siHDAMode: Step2:Push the init string to 0x0047E000!\n"));
1551 if (AGSA_RC_FAILURE == siBar4Cpy(agRoot, ILA_ISTR_ADDROFFSETHDA, flashImg.istrImg, flashImg.istrLen))
1553 SA_DBG1(("siHDAMode: Step2:Copy ISTR array to 0x%x failed\n", ILA_ISTR_ADDROFFSETHDA));
1554 smTraceFuncExit(hpDBG_VERY_LOUD, 'e', "5d");
1555 return AGSA_RC_FAILURE;
1558 /* Tell FW ISTR is ready */
1559 regVal = (HDA_ISTR_DONE | (bit32)flashImg.istrLen);
1560 ossaHwRegWrite(agRoot, MSGU_HOST_SCRATCH_PAD_3, regVal);
1561 SA_DBG1(("siHDAMode: Step2:Host Scratchpad 3 (AAP1-ISTR): 0x%x\n", regVal));
1563 stepTime[2] = ossaTimeStamp(agRoot); // TestBase
1564 SA_DBG1(("siHDAMode: End Step2: (step_time[2] = %d)\n", stepTime[2])); // TestBase
1566 /* Step 3: Write the HDA mode SoftReset signature */
1567 SA_DBG1(("siHDAMode: Step3:Set Signature!\n"));
1568 /* set signature in host scratch pad0 register to tell SPC that the host performs the HDA mode */
1569 ossaHwRegWrite(agRoot, MSGU_HOST_SCRATCH_PAD_0, SPC_HDASOFT_RESET_SIGNATURE);
1571 stepTime[3] = ossaTimeStamp(agRoot); // TestBase
1572 SA_DBG1(("siHDAMode: End Step3: (step_time[3] = %d)\n", stepTime[3])); // TestBase
1574 // Priya (Apps) requested that the FW load time measurement be started here
1575 startTime = ossaTimeStamp(agRoot);
1576 SA_DBG1(("siHDAMode: Step4: Ready to push ILA to 0x00400000! (start_time = %d)\n", startTime)); // TestBase
1578 /* Step 4: Push the ILA image to 0x00400000 */
1579 SA_DBG1(("siHDAMode: Step4:Push the ILA to 0x00400000!\n"));
1581 if (AGSA_RC_FAILURE == siBar4Cpy(agRoot, 0x0, flashImg.ilaImg, flashImg.ilaLen))
1583 SA_DBG1(("siHDAMode:Step4:Copy ILA array to 0x%x failed\n", 0x0));
1584 smTraceFuncExit(hpDBG_VERY_LOUD, 'f', "5d");
1585 return AGSA_RC_FAILURE;
1588 stepTime[4] = ossaTimeStamp(agRoot);
1589 SA_DBG1(("siHDAMode: End Step4: (step_time[4] = %d, %d ms)\n", stepTime[4], (stepTime[4] - startTime))); // TestBase
1591 /* Step 5: Tell boot ROM to authenticate ILA and execute it */
1592 ossaHwRegWriteExt(agRoot, PCIBAR3, HDA_CMD_OFFSET1MB, 0);
1593 ossaHwRegWriteExt(agRoot, PCIBAR3, HDA_CMD_OFFSET1MB+HDA_PAR_LEN_OFFSET, flashImg.ilaLen);
1594 regVal = (ossaHwRegReadExt(agRoot, PCIBAR3, HDA_RSP_OFFSET1MB+HDA_CMD_CODE_OFFSET) & HDA_SEQ_ID_BITS ) >> SHIFT16;
1596 regVal = (HDA_C_PA << SHIFT24) | (regVal << SHIFT16) | HDAC_EXEC_CMD;
1597 SA_DBG1(("siHDAMode: Step5:Execute ILA CMD: 0x%x\n", regVal));
1598 ossaHwRegWriteExt(agRoot, PCIBAR3, HDA_CMD_OFFSET1MB+HDA_CMD_CODE_OFFSET, regVal); /* Execute Command */
1600 stepTime[5] = ossaTimeStamp(agRoot);
1601 SA_DBG1(("siHDAMode: End Step5: (step_time[5] = %d, %d ms)\n", stepTime[5], (stepTime[5] - startTime))); // TestBase
1604 /* Step 6: Checking response status from boot ROM, HDAR_EXEC (good), HDAR_BAD_CMD and HDAR_BAD_IMG */
1605 SA_DBG1(("siHDAMode: Step6:Checking boot ROM reponse status!\n"));
1606 max_wait_time = WAIT_SECONDS(gWait_2); /* 2 sec */
1607 max_wait_count = MAKE_MODULO(max_wait_time,WAIT_INCREMENT) - WAIT_INCREMENT;
1610 ossaStallThread(agRoot, WAIT_INCREMENT);
1611 regVal = ossaHwRegReadExt(agRoot, PCIBAR3, HDA_RSP_OFFSET1MB+HDA_CMD_CODE_OFFSET) & HDA_STATUS_BITS;
1612 if ((HDAR_EXEC == regVal) || (HDAR_BAD_IMG == regVal) || (HDAR_BAD_CMD == regVal))
1614 } while (max_wait_count-=WAIT_INCREMENT);
1616 if (HDAR_BAD_IMG == regVal)
1618 SA_DBG1(("siHDAMode: Step6:BAD IMG: HDA_RSP_OFFSET1MB+HDA_CMD_CODE_OFFSET = 0x%x\n", regVal));
1619 smTraceFuncExit(hpDBG_VERY_LOUD, 'g', "5d");
1620 return AGSA_RC_FAILURE;
1622 if (HDAR_BAD_CMD == regVal)
1624 SA_DBG1(("siHDAMode: Step6:BAD IMG: HDA_RSP_OFFSET1MB+HDA_CMD_CODE_OFFSET = 0x%x\n", regVal));
1625 smTraceFuncExit(hpDBG_VERY_LOUD, 'h', "5d");
1626 return AGSA_RC_FAILURE;
1628 if (!max_wait_count)
1630 SA_DBG1(("siHDAMode: Step6:TIMEOUT: HDA_RSP_OFFSET1MB+HDA_CMD_CODE_OFFSET = 0x%x\n", regVal));
1631 smTraceFuncExit(hpDBG_VERY_LOUD, 'i', "5d");
1632 return AGSA_RC_FAILURE;
1635 stepTime[6] = ossaTimeStamp(agRoot);
1636 SA_DBG1(("siHDAMode: End Step6: (step_time[6] = %d, %d ms)\n", stepTime[6], (stepTime[6] - startTime))); // TestBase
1638 /* Step 7: Poll ILAHDA_AAP1IMGGET/Offset in MSGU Scratchpad 0 */
1639 /* Check MSGU Scratchpad 1 [1,0] == 00 */
1640 SA_DBG1(("siHDAMode: Step7:Poll ILAHDA_AAP1_IMG_GET!\n"));
1641 regVal = ossaHwRegRead(agRoot, MSGU_SCRATCH_PAD_1) & SCRATCH_PAD1_RST;
1642 SA_DBG1(("siHDAMode: Step7:MSG Scratchpad 1: 0x%x\n", regVal));
1643 max_wait_time = WAIT_SECONDS(gWait_3); /* 3 sec */
1644 max_wait_count = MAKE_MODULO(max_wait_time,WAIT_INCREMENT) - WAIT_INCREMENT;
1647 ossaStallThread(agRoot, WAIT_INCREMENT);
1648 regVal = ossaHwRegRead(agRoot, MSGU_SCRATCH_PAD_0) >> SHIFT24;
1649 } while ((regVal != ILAHDA_AAP1_IMG_GET) && (max_wait_count -= WAIT_INCREMENT));
1651 if (!max_wait_count)
1654 if( !HDA_Been_Reset )
1657 SA_DBG1(("siHDAMode: Reset: Step7:regVal =0x%x expect 0x%x\n", regVal,ILAHDA_AAP1_IMG_GET ));
1658 siSpcSoftReset(agRoot, SPC_HDASOFT_RESET_SIGNATURE);
1659 HDA_Been_Reset = agTRUE;
1664 SA_DBG1(("siHDAMode: TIMEOUT: Step7:regVal =0x%x expect 0x%x\n", regVal,ILAHDA_AAP1_IMG_GET ));
1665 #if defined(SALLSDK_DEBUG)
1666 SA_DBG1(("siHDAMode: SCRATCH_PAD0 value = 0x%x\n", ossaHwRegRead(agRoot, MSGU_SCRATCH_PAD_0)));
1667 SA_DBG1(("siHDAMode: SCRATCH_PAD1 value = 0x%x\n", ossaHwRegRead(agRoot, MSGU_SCRATCH_PAD_1)));
1668 SA_DBG1(("siHDAMode: SCRATCH_PAD2 value = 0x%x\n", ossaHwRegRead(agRoot, MSGU_SCRATCH_PAD_2)));
1669 SA_DBG1(("siHDAMode: SCRATCH_PAD3 value = 0x%x\n", ossaHwRegRead(agRoot, MSGU_SCRATCH_PAD_3)));
1671 smTraceFuncExit(hpDBG_VERY_LOUD, 'j', "5d");
1672 return AGSA_RC_FAILURE;
1674 regVal = ossaHwRegRead(agRoot, MSGU_SCRATCH_PAD_0);
1675 SA_DBG1(("siHDAMode: Step7:MSG Scratchpad 0: 0x%x\n", regVal));
1676 regVal = ossaHwRegRead(agRoot, MSGU_SCRATCH_PAD_0) & 0x00FFFFFF;
1678 stepTime[7] = ossaTimeStamp(agRoot);
1679 SA_DBG1(("siHDAMode: End Step7: (step_time[7] = %d, %d ms)\n", stepTime[7], (stepTime[7] - startTime))); // TestBase
1681 /* Step 8: Copy AAP1 image, update the Host Scratchpad 3 */
1682 SA_DBG1(("siHDAMode: Step8:Push the AAP1 to 0x00400000 plus 0x%x\n", regVal));
1684 if (AGSA_RC_FAILURE == siBar4Cpy(agRoot, regVal, flashImg.aap1Img, flashImg.aap1Len))
1686 SA_DBG1(("siHDAMode: Step8:Copy AAP1 array to 0x%x failed\n", regVal));
1687 #if defined(SALLSDK_DEBUG)
1688 SA_DBG1(("siHDAMode: SCRATCH_PAD0 value = 0x%x\n", ossaHwRegRead(agRoot, MSGU_SCRATCH_PAD_0)));
1689 SA_DBG1(("siHDAMode: SCRATCH_PAD1 value = 0x%x\n", ossaHwRegRead(agRoot, MSGU_SCRATCH_PAD_1)));
1690 SA_DBG1(("siHDAMode: SCRATCH_PAD2 value = 0x%x\n", ossaHwRegRead(agRoot, MSGU_SCRATCH_PAD_2)));
1691 SA_DBG1(("siHDAMode: SCRATCH_PAD3 value = 0x%x\n", ossaHwRegRead(agRoot, MSGU_SCRATCH_PAD_3)));
1693 smTraceFuncExit(hpDBG_VERY_LOUD, 'k', "5d");
1694 return AGSA_RC_FAILURE;
1697 regVal = (HDA_AAP1_DONE | (bit32)flashImg.aap1Len);
1698 ossaHwRegWrite(agRoot, MSGU_HOST_SCRATCH_PAD_3, regVal);
1699 SA_DBG1(("siHDAMode: Step8:Host Scratchpad 3 (AAP1): 0x%x\n", regVal));
1701 stepTime[8] = ossaTimeStamp(agRoot);
1702 SA_DBG1(("siHDAMode: End Step8: (step_time[8] = %d, %d ms)\n", stepTime[8], (stepTime[8] - startTime))); // TestBase
1704 /* Step 9: Poll ILAHDA_IOPIMGGET/Offset in MSGU Scratchpad 0 */
1705 SA_DBG1(("siHDAMode: Step9:Poll ILAHDA_IOP_IMG_GET!\n"));
1706 max_wait_time = WAIT_SECONDS(gWait_2); /* 2 sec */
1707 max_wait_count = MAKE_MODULO(max_wait_time,WAIT_INCREMENT) - WAIT_INCREMENT;
1710 ossaStallThread(agRoot, WAIT_INCREMENT);
1711 regVal = ossaHwRegRead(agRoot, MSGU_SCRATCH_PAD_0) >> SHIFT24;
1712 } while ((regVal != ILAHDA_IOP_IMG_GET) && (max_wait_count -= WAIT_INCREMENT));
1714 if (!max_wait_count)
1716 SA_DBG1(("siHDAMode: Step9:TIMEOUT:MSGU_SCRATCH_PAD_0 = 0x%x\n", regVal));
1717 #if defined(SALLSDK_DEBUG)
1718 SA_DBG1(("siHDAMode: SCRATCH_PAD1 value = 0x%x\n", ossaHwRegRead(agRoot, MSGU_SCRATCH_PAD_1)));
1719 SA_DBG1(("siHDAMode: SCRATCH_PAD2 value = 0x%x\n", ossaHwRegRead(agRoot, MSGU_SCRATCH_PAD_2)));
1720 SA_DBG1(("siHDAMode: SCRATCH_PAD3 value = 0x%x\n", ossaHwRegRead(agRoot, MSGU_SCRATCH_PAD_3)));
1722 smTraceFuncExit(hpDBG_VERY_LOUD, 'l', "5d");
1723 return AGSA_RC_FAILURE;
1725 regVal = ossaHwRegRead(agRoot, MSGU_SCRATCH_PAD_0);
1726 SA_DBG1(("siHDAMode: Step9:MSG Scratchpad 0: 0x%x\n", regVal));
1727 regVal = ossaHwRegRead(agRoot, MSGU_SCRATCH_PAD_0) & HDA_GSM_OFFSET_BITS;
1729 stepTime[9] = ossaTimeStamp(agRoot);
1730 SA_DBG1(("siHDAMode: End Step9: (step_time[9] = %d, %d ms)\n", stepTime[9], (stepTime[9] - startTime))); // TestBase
1732 // saHdaLoadForceHalt(agRoot); // TestBase
1734 /* Step 10: Copy IOP image, update the Host Scratchpad 3 */
1735 SA_DBG1(("siHDAMode: Step10:Push the IOP to 0x00400000 plus 0x%x!\n", regVal));
1737 if (AGSA_RC_FAILURE == siBar4Cpy(agRoot, regVal, flashImg.iopImg, flashImg.iopLen))
1739 SA_DBG1(("siHDAMode: Step10:Copy IOP array to 0x%x failed\n", regVal));
1740 #if defined(SALLSDK_DEBUG)
1741 SA_DBG1(("siHDAMode: SCRATCH_PAD1 value = 0x%x\n", ossaHwRegRead(agRoot, MSGU_SCRATCH_PAD_1)));
1742 SA_DBG1(("siHDAMode: SCRATCH_PAD2 value = 0x%x\n", ossaHwRegRead(agRoot, MSGU_SCRATCH_PAD_2)));
1743 SA_DBG1(("siHDAMode: SCRATCH_PAD3 value = 0x%x\n", ossaHwRegRead(agRoot, MSGU_SCRATCH_PAD_3)));
1745 smTraceFuncExit(hpDBG_VERY_LOUD, 'm', "5d");
1746 return AGSA_RC_FAILURE;
1749 regVal = (HDA_IOP_DONE | (bit32)flashImg.iopLen);
1750 ossaHwRegWrite(agRoot, MSGU_HOST_SCRATCH_PAD_3, regVal);
1751 SA_DBG1(("siHDAMode: Step10:Host Scratchpad 3 (IOP): 0x%x\n", regVal));
1753 stepTime[10] = ossaTimeStamp(agRoot);
1754 SA_DBG1(("siHDAMode: End Step10: (step_time[10] = %d, %d ms)\n", stepTime[10], (stepTime[10] - startTime))); // TestBase
1756 /* Clear the signature */
1757 ossaHwRegWrite(agRoot, MSGU_HOST_SCRATCH_PAD_0, 0);
1759 /* step 11: wait for the FW and IOP to get ready - 1 sec timeout */
1760 /* Wait for the SPC Configuration Table to be ready */
1761 stepTime[11] = ossaTimeStamp(agRoot);
1762 SA_DBG1(("siHDAMode: Start Step11: Wait for FW ready. (step_time[11.1] = %d, %d ms)\n", stepTime[11], (stepTime[11] - startTime))); // TestBase
1764 endTime = ossaTimeStamp(agRoot);
1765 SA_DBG1(("siHDAMode: End Step11: FW ready! (end_time= %d, fw_load_time = %d ms)\n", endTime, endTime - startTime)); // TestBase
1767 SA_DBG1(("siHDAMode: Step11:Poll for FW ready!\n"));
1768 if (mpiWaitForConfigTable(agRoot, &mainCfg) == AGSA_RC_FAILURE)
1770 regVal = ossaHwRegRead(agRoot, MSGU_SCRATCH_PAD_1);
1771 /* return error if MPI Configuration Table not ready */
1772 SA_DBG1(("siHDAMode: Step11:SPC FW not ready SCRATCH_PAD1 = 0x%x\n", regVal));
1773 regVal = ossaHwRegRead(agRoot, MSGU_SCRATCH_PAD_2);
1774 /* return error if MPI Configuration Table not ready */
1775 SA_DBG1(("siHDAMode: Step11:SPC FW not ready SCRATCH_PAD2 = 0x%x\n", regVal));
1776 /* read detail fatal errors */
1777 regVal = ossaHwRegRead(agRoot, MSGU_SCRATCH_PAD_0);
1778 SA_DBG1(("siHDAMode: Step11:ScratchPad0 AAP error code 0x%x\n", regVal));
1779 regVal = ossaHwRegRead(agRoot, MSGU_SCRATCH_PAD_3);
1780 SA_DBG1(("siHDAMode: Step11:ScratchPad3 IOP error code 0x%x\n", regVal));
1781 smTraceFuncExit(hpDBG_VERY_LOUD, 'n', "5d");
1782 return AGSA_RC_FAILURE;
1785 smTraceFuncExit(hpDBG_VERY_LOUD, 'o', "5d");
1787 SA_DBG1(("siHDAMode: HDA Mode Complete\n"));
1789 return AGSA_RC_SUCCESS;
1792 /******************************************************************************/
1793 /*! \brief memcopy cross PCI from host memory to card memory
1795 * \param agRoot handles for this instance of SAS/SATA hardware
1796 * \param dstoffset distination offset
1797 * \param src source pointer
1798 * \param DWcount DWord count
1799 * \param busBaseNumber PCI Bus Base number
1804 /*******************************************************************************/
1805 LOCAL void siPciMemCpy(agsaRoot_t *agRoot,
1815 src1 = (bit32 *)src;
1817 for (i= 0; i < DWcount; i++)
1819 val = BIT32_TO_LEBIT32(src1[i]);
1820 ossaHwRegWriteExt(agRoot, busBaseNumber, (dstoffset + i * 4), val);
1826 /******************************************************************************/
1827 /*! \brief Function to copy FW array
1829 * The siBar4Cpy() function is called to copy FW array via BAR4
1830 * (PCIe spec: BAR4, MEMBASE-III in PM, PCIBAR2 in host driver)
1831 * in 64-KB MEMBASE MODE.
1833 * \param agRoot handles for this instance of SAS/SATA hardware
1834 * \param offset destination offset
1835 * \param parray pointer of array
1836 * \param array_size size of array
1838 * \return AGSA_RC_SUCCESS or AGSA_RC_FAILURE
1840 /*******************************************************************************/
1841 LOCAL bit32 siBar4Cpy(
1848 bit32 dest_shift_addr, dest_offset, cpy_size;
1850 smTraceFuncEnter(hpDBG_VERY_LOUD,"5f");
1852 /* first time to shift */
1853 dest_shift_addr = (GSMSM_AXI_LOWERADDR+offset) & SHIFT_MASK;
1854 dest_offset = offset & OFFSET_MASK;
1857 if (AGSA_RC_FAILURE == siBar4Shift(agRoot, dest_shift_addr))
1859 SA_DBG1(("siHDAMode:Shift Bar4 to 0x%x failed\n", dest_shift_addr));
1860 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "5f");
1861 return AGSA_RC_FAILURE;
1864 if ((dest_offset+array_size) > SIZE_64KB)
1866 cpy_size = SIZE_64KB - dest_offset;
1869 cpy_size = array_size;
1871 siPciMemCpy(agRoot, dest_offset, parray, (bit32)(CEILING(cpy_size,4)), PCIBAR2);
1873 array_size -= cpy_size;
1874 dest_shift_addr += SIZE_64KB;
1876 parray = parray + cpy_size;
1877 } while (array_size !=0 );
1879 /* Shift back to BAR4 original address */
1880 if (AGSA_RC_FAILURE == siBar4Shift(agRoot, 0x0))
1882 SA_DBG1(("siHDAMode:Shift Bar4 to 0x%x failed\n", 0x0));
1883 smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "5f");
1884 return AGSA_RC_FAILURE;
1887 smTraceFuncExit(hpDBG_VERY_LOUD, 'c', "5f");
1889 return AGSA_RC_SUCCESS;
1896 agsaFwImg_t *userFwImg
1899 bit32 returnVal = AGSA_RC_FAILURE;
1900 bit32 save,i,biggest;
1902 bit32 hda_command_complete = 0;
1903 bit32 max_wait_time;
1904 bit32 max_wait_count;
1910 spcv_hda_cmd_t hdacmd;
1911 spcv_hda_rsp_t hdarsp;
1913 agsaLLRoot_t *saRoot;
1916 SA_ASSERT( (agNULL != agRoot), "");
1918 saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
1921 SA_ASSERT( (agNULL != saRoot), "saRoot is NULL");
1923 smTraceFuncEnter(hpDBG_VERY_LOUD,"2W");
1925 SA_DBG1(("siHDAMode_V: HDAMode %X\n",HDAMode));
1927 siScratchDump(agRoot);
1928 if( agNULL == userFwImg)
1930 SA_DBG1(("siHDAMode_V: No image agNULL == userFwImg\n" ));
1931 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "2W");
1935 hda_status = (ossaHwRegReadExt(agRoot, PCIBAR0, SPC_V_HDA_RESPONSE_OFFSET+28));
1937 SA_DBG1(("siHDAMode_V: hda_status 0x%08X\n",hda_status ));
1938 SA_DBG1(("siHDAMode_V: STEP 1\n"));
1940 smTrace(hpDBG_VERY_LOUD,"2X",1 );
1943 /* Find largest Physical chunk memory */
1944 for(i=0,biggest = 0,save = 0; i < saRoot->memoryAllocated.count; i++)
1946 if( saRoot->memoryAllocated.agMemory[i].totalLength > biggest)
1949 if(biggest < saRoot->memoryAllocated.agMemory[i].totalLength)
1952 biggest = saRoot->memoryAllocated.agMemory[i].totalLength;
1958 Step 1 The host reads the HDA response field RSP_CODE at byte offset 28:29 of the response block
1959 for HDAR_IDLE (0x8002) via MEMBASE-I. A value other than HDAR_IDLE (0x8002) indicates that the
1960 SPCv controller is not in HDA mode. Follow the steps described in Section 4.21.1 to bring the
1961 SPCv controller into HDA mode. When the host reads the correct RSP_CODE, it indicates that the
1962 SPCv controller boot ROM is ready to proceed to the next step of HDA initialization
1965 base_Hi = saRoot->memoryAllocated.agMemory[save].phyAddrUpper;
1966 base_Lo = saRoot->memoryAllocated.agMemory[save].phyAddrLower;
1967 pbase = saRoot->memoryAllocated.agMemory[save].virtPtr;
1968 SA_DBG1(("siHDAMode_V:Use DMA memory at [%d] size 0x%x (%d) DMA Loc U 0x%08x L 0x%08x @%p\n",save,
1977 SA_DBG1(("siHDAMode_V: HDA aap1Img %p len %8d 0x%x\n", userFwImg->aap1Img, userFwImg->aap1Len , userFwImg->aap1Len ));
1978 SA_DBG1(("siHDAMode_V: HDA ilaImg %p len %8d 0x%x\n", userFwImg->ilaImg, userFwImg->ilaLen , userFwImg->ilaLen ));
1979 SA_DBG1(("siHDAMode_V: HDA iopImg %p len %8d 0x%x\n", userFwImg->iopImg, userFwImg->iopLen , userFwImg->iopLen ));
1980 if(userFwImg->aap1Len > biggest)
1982 SA_DBG1(("siHDAMode_V: HDA DMA area too small %d < %d aap1Len\n", biggest ,userFwImg->aap1Len));
1983 SA_ASSERT( (agNULL != agRoot), "aap1Len > biggest");
1984 smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "2W");
1987 if(userFwImg->ilaLen > biggest)
1989 SA_DBG1(("siHDAMode_V: HDA DMA area too small %d < %d ilaLen\n", biggest ,userFwImg->ilaLen));
1990 SA_ASSERT( (agNULL != agRoot), "ilaLen > biggest");
1991 smTraceFuncExit(hpDBG_VERY_LOUD, 'c', "2W");
1994 if(userFwImg->iopLen > biggest)
1996 SA_DBG1(("siHDAMode_V: HDA DMA area too small %d < %d iopLen\n", biggest ,userFwImg->iopLen));
1997 SA_ASSERT( (agNULL != agRoot), "iopLen > biggest");
1998 smTraceFuncExit(hpDBG_VERY_LOUD, 'd', "2W");
2005 si_memset(pbase, 0, biggest);
2007 if( userFwImg->ilaLen < biggest)
2009 si_memcpy(pbase,userFwImg->ilaImg, userFwImg->ilaLen );
2013 SA_DBG1(("siHDAMode_V: userFwImg->ilaLen 0x%x < biggest 0x%x\n",userFwImg->ilaLen,biggest));
2016 si_memset(&hdacmd,0,sizeof(spcv_hda_cmd_t));
2017 si_memset(&hdarsp,0,sizeof(spcv_hda_rsp_t));
2019 hda_status = ossaHwRegReadExt(agRoot, PCIBAR0, SPC_V_HDA_RESPONSE_OFFSET+28);
2020 if((hda_status & SPC_V_HDAR_RSPCODE_MASK) == SPC_V_HDAR_IDLE)
2023 hdacmd.cmdparm_0 = base_Lo; /* source DmaBase_l*/
2024 hdacmd.cmdparm_1 = base_Hi; /* source DmaBase_u*/
2025 hdacmd.cmdparm_2 = 0x1e200000; /* destin */
2026 hdacmd.cmdparm_3 = 0; /* destin */
2027 hdacmd.cmdparm_4 = userFwImg->ilaLen ; /* length */
2028 hdacmd.cmdparm_5 = 0;/* not used */
2029 hdacmd.cmdparm_6 = 0;/* not used */
2031 hdacmd.C_PA_SEQ_ID_CMD_CODE = ( SPC_V_HDAC_PA << SHIFT24 ) | ( seq_id << SHIFT16 )| SPC_V_HDAC_DMA;
2033 SA_DBG1(("siHDAMode_V: Write SPC_V_HDAC_DMA STEP 2\n"));
2036 The host writes the HDAC_DMA (0x000 24) in the command field CMD_CODE via MEMBASE-I
2037 for issuing the DMA command to ask the boot ROM to pull the ILA image via DMA into
2038 GSM with the following parameters set up first:
2039 Parameter 1:0: Host physical address for holding the HDA-ILA image.
2040 Parameter 3:2: GSM physical address 0x1E20_0000.
2041 Parameter 4: the length of the HDAILA image.
2044 SA_DBG2(("siHDAMode_V: Write ILA to offset %X\n",hdacmd.cmdparm_2));
2046 ossaHwRegWriteExt(agRoot, PCIBAR0, SPC_V_HDA_COMMAND_OFFSET+0,hdacmd.cmdparm_0);
2047 ossaHwRegWriteExt(agRoot, PCIBAR0, SPC_V_HDA_COMMAND_OFFSET+4,hdacmd.cmdparm_1);
2048 ossaHwRegWriteExt(agRoot, PCIBAR0, SPC_V_HDA_COMMAND_OFFSET+8,hdacmd.cmdparm_2);
2049 ossaHwRegWriteExt(agRoot, PCIBAR0, SPC_V_HDA_COMMAND_OFFSET+12,hdacmd.cmdparm_3);
2050 ossaHwRegWriteExt(agRoot, PCIBAR0, SPC_V_HDA_COMMAND_OFFSET+16,hdacmd.cmdparm_4);
2051 ossaHwRegWriteExt(agRoot, PCIBAR0, SPC_V_HDA_COMMAND_OFFSET+20,hdacmd.cmdparm_5);
2052 ossaHwRegWriteExt(agRoot, PCIBAR0, SPC_V_HDA_COMMAND_OFFSET+24,hdacmd.cmdparm_6);
2053 ossaHwRegWriteExt(agRoot, PCIBAR0, SPC_V_HDA_COMMAND_OFFSET+28,hdacmd.C_PA_SEQ_ID_CMD_CODE);
2055 SA_DBG2(("siHDAMode_V: Command 0 0x%08X 0x%08X 0x%08X 0x%08X 0x%08X 0x%08X 0x%08X 0x%08X\n",
2056 ossaHwRegReadExt(agRoot, PCIBAR0, SPC_V_HDA_COMMAND_OFFSET+0),
2057 ossaHwRegReadExt(agRoot, PCIBAR0, SPC_V_HDA_COMMAND_OFFSET+4),
2058 ossaHwRegReadExt(agRoot, PCIBAR0, SPC_V_HDA_COMMAND_OFFSET+8),
2059 ossaHwRegReadExt(agRoot, PCIBAR0, SPC_V_HDA_COMMAND_OFFSET+12),
2060 ossaHwRegReadExt(agRoot, PCIBAR0, SPC_V_HDA_COMMAND_OFFSET+16),
2061 ossaHwRegReadExt(agRoot, PCIBAR0, SPC_V_HDA_COMMAND_OFFSET+20),
2062 ossaHwRegReadExt(agRoot, PCIBAR0, SPC_V_HDA_COMMAND_OFFSET+24),
2063 ossaHwRegReadExt(agRoot, PCIBAR0, SPC_V_HDA_COMMAND_OFFSET+28) ));
2065 SA_DBG2(("siHDAMode_V: command %X\n",hdacmd.C_PA_SEQ_ID_CMD_CODE ));
2067 max_wait_time = (2000 * 1000); /* wait 2 seconds */
2068 max_wait_count = MAKE_MODULO(max_wait_time,WAIT_INCREMENT) - WAIT_INCREMENT;
2069 hda_command_complete = 0;
2072 ossaStallThread(agRoot, WAIT_INCREMENT);
2073 hda_command_complete = ((ossaHwRegReadExt(agRoot, PCIBAR0, SPC_V_HDA_RESPONSE_OFFSET+28) & SPC_V_HDAR_SEQID_MASK ) >> SHIFT16) == seq_id;
2074 } while (!hda_command_complete && (max_wait_count -= WAIT_INCREMENT));
2075 SA_DBG1(("siHDAMode_V:SCRATCH_PAD1 = 0x%x STEP 2 took %d\n", ossaHwRegReadExt(agRoot, PCIBAR0, MSGU_SCRATCH_PAD_1),(max_wait_time - max_wait_count)));
2077 smTrace(hpDBG_VERY_LOUD,"2Y",(max_wait_time - max_wait_count) );
2078 /* TP:2Y STEP 2 took */
2081 if(! hda_command_complete)
2083 SA_DBG1(("siHDAMode_V:2SCRATCH_PAD0 value = 0x%x\n", ossaHwRegReadExt(agRoot, PCIBAR0, V_Scratchpad_0_Register)));
2084 SA_DBG1(("siHDAMode_V: SCRATCH_PAD1 value = 0x%x\n", ossaHwRegReadExt(agRoot, PCIBAR0, V_Scratchpad_1_Register)));
2085 SA_DBG1(("siHDAMode_V: SCRATCH_PAD2 value = 0x%x\n", ossaHwRegReadExt(agRoot, PCIBAR0, V_Scratchpad_2_Register)));
2086 SA_DBG1(("siHDAMode_V: SCRATCH_PAD3 value = 0x%x\n", ossaHwRegReadExt(agRoot, PCIBAR0, V_Scratchpad_3_Register)));
2087 SA_DBG1(("siHDAMode_V:hda_command_complete failed Step 2\n" ));
2088 smTraceFuncExit(hpDBG_VERY_LOUD, 'e', "2W");
2093 SA_DBG2(("siHDAMode_V:2SCRATCH_PAD0 value = 0x%x\n", ossaHwRegReadExt(agRoot, PCIBAR0, V_Scratchpad_0_Register)));
2094 SA_DBG2(("siHDAMode_V: SCRATCH_PAD1 value = 0x%x\n", ossaHwRegReadExt(agRoot, PCIBAR0, V_Scratchpad_1_Register)));
2095 SA_DBG2(("siHDAMode_V: SCRATCH_PAD2 value = 0x%x\n", ossaHwRegReadExt(agRoot, PCIBAR0, V_Scratchpad_2_Register)));
2096 SA_DBG2(("siHDAMode_V: SCRATCH_PAD3 value = 0x%x\n", ossaHwRegReadExt(agRoot, PCIBAR0, V_Scratchpad_3_Register)));
2100 SA_DBG1(("siHDAMode_V: ILA DMA done\n" ));
2106 SA_DBG1(("siHDAMode_V: STEP 3\n"));
2109 The host polls the HDA response field RSP_CODE for HDAR_IDLE (0x8002) via MEMBASE-I. The polling timeout
2110 should be no more than 1 second. The response status, HDAR_IDLE with its status equal to 0x10,
2111 indicates a DMA success response from the boot ROM. Response states that indicate a failure are:
2112 HDAR_BAD_CMD HDAR_BAD_IMG HDAR_IDLE with its status equal to 0x11
2116 max_wait_time = (2000 * 1000); /* wait 2 seconds */
2117 max_wait_count = MAKE_MODULO(max_wait_time,WAIT_INCREMENT) - WAIT_INCREMENT;
2118 hda_command_complete = 0;
2121 ossaStallThread(agRoot, WAIT_INCREMENT);
2122 hda_command_complete = ((ossaHwRegReadExt(agRoot, PCIBAR0, SPC_V_HDA_RESPONSE_OFFSET+28) & SPC_V_HDAR_SEQID_MASK ) >> SHIFT16) == seq_id;
2123 } while (!hda_command_complete && (max_wait_count -= WAIT_INCREMENT));
2125 SA_DBG1(("siHDAMode_V:SCRATCH_PAD1 = 0x%x STEP 3 took %d\n", ossaHwRegReadExt(agRoot, PCIBAR0, MSGU_SCRATCH_PAD_1),(max_wait_time - max_wait_count)));
2126 smTrace(hpDBG_VERY_LOUD,"2Z",(max_wait_time - max_wait_count) );
2127 /* TP:2Z STEP 3 took */
2129 if(! hda_command_complete)
2132 SA_DBG1(("siHDAMode_V: Response 0 0x%08X 0x%08X 0x%08X 0x%08X 0x%08X 0x%08X 0x%08X 0x%08X\n",
2133 ossaHwRegReadExt(agRoot, PCIBAR0, SPC_V_HDA_RESPONSE_OFFSET+0),
2134 ossaHwRegReadExt(agRoot, PCIBAR0, SPC_V_HDA_RESPONSE_OFFSET+4),
2135 ossaHwRegReadExt(agRoot, PCIBAR0, SPC_V_HDA_RESPONSE_OFFSET+8),
2136 ossaHwRegReadExt(agRoot, PCIBAR0, SPC_V_HDA_RESPONSE_OFFSET+12),
2137 ossaHwRegReadExt(agRoot, PCIBAR0, SPC_V_HDA_RESPONSE_OFFSET+16),
2138 ossaHwRegReadExt(agRoot, PCIBAR0, SPC_V_HDA_RESPONSE_OFFSET+20),
2139 ossaHwRegReadExt(agRoot, PCIBAR0, SPC_V_HDA_RESPONSE_OFFSET+24),
2140 ossaHwRegReadExt(agRoot, PCIBAR0, SPC_V_HDA_RESPONSE_OFFSET+28) ));
2143 SA_DBG1(("siHDAMode_V:3SCRATCH_PAD0 value = 0x%x\n", ossaHwRegReadExt(agRoot, PCIBAR0, V_Scratchpad_0_Register)));
2144 SA_DBG1(("siHDAMode_V: SCRATCH_PAD1 value = 0x%x\n", ossaHwRegReadExt(agRoot, PCIBAR0, V_Scratchpad_1_Register)));
2145 SA_DBG1(("siHDAMode_V: SCRATCH_PAD2 value = 0x%x\n", ossaHwRegReadExt(agRoot, PCIBAR0, V_Scratchpad_2_Register)));
2146 SA_DBG1(("siHDAMode_V: SCRATCH_PAD3 value = 0x%x\n", ossaHwRegReadExt(agRoot, PCIBAR0, V_Scratchpad_3_Register)));
2147 SA_DBG1(("siHDAMode_V:hda_command_complete failed Step 3\n" ));
2148 smTraceFuncExit(hpDBG_VERY_LOUD, 'f', "2W");
2153 hda_command_complete = ((ossaHwRegReadExt(agRoot, PCIBAR0, SPC_V_HDA_RESPONSE_OFFSET+28) & SPC_V_HDAR_SEQID_MASK ) >> SHIFT16) == seq_id;
2154 hda_status = (ossaHwRegReadExt(agRoot, PCIBAR0, SPC_V_HDA_RESPONSE_OFFSET+28) & SPC_V_HDAR_RSPCODE_MASK );
2156 SA_DBG2(("siHDAMode_V:ILA is ready hda_status %X hda_command_complete %d\n",hda_status ,hda_command_complete));
2158 /* Tell FW ILA is ready */
2159 SA_DBG2(("siHDAMode_V: Response 0 0x%08X 0x%08X 0x%08X 0x%08X 0x%08X 0x%08X 0x%08X 0x%08X\n",
2160 ossaHwRegReadExt(agRoot, PCIBAR0, SPC_V_HDA_RESPONSE_OFFSET+0),
2161 ossaHwRegReadExt(agRoot, PCIBAR0, SPC_V_HDA_RESPONSE_OFFSET+4),
2162 ossaHwRegReadExt(agRoot, PCIBAR0, SPC_V_HDA_RESPONSE_OFFSET+8),
2163 ossaHwRegReadExt(agRoot, PCIBAR0, SPC_V_HDA_RESPONSE_OFFSET+12),
2164 ossaHwRegReadExt(agRoot, PCIBAR0, SPC_V_HDA_RESPONSE_OFFSET+16),
2165 ossaHwRegReadExt(agRoot, PCIBAR0, SPC_V_HDA_RESPONSE_OFFSET+20),
2166 ossaHwRegReadExt(agRoot, PCIBAR0, SPC_V_HDA_RESPONSE_OFFSET+24),
2167 ossaHwRegReadExt(agRoot, PCIBAR0, SPC_V_HDA_RESPONSE_OFFSET+28) ));
2169 SA_DBG2(("siHDAMode_V:3SCRATCH_PAD0 value = 0x%x\n", ossaHwRegReadExt(agRoot, PCIBAR0, V_Scratchpad_0_Register)));
2170 SA_DBG2(("siHDAMode_V: SCRATCH_PAD1 value = 0x%x\n", ossaHwRegReadExt(agRoot, PCIBAR0, V_Scratchpad_1_Register)));
2171 SA_DBG2(("siHDAMode_V: SCRATCH_PAD2 value = 0x%x\n", ossaHwRegReadExt(agRoot, PCIBAR0, V_Scratchpad_2_Register)));
2172 SA_DBG2(("siHDAMode_V: SCRATCH_PAD3 value = 0x%x\n", ossaHwRegReadExt(agRoot, PCIBAR0, V_Scratchpad_3_Register)));
2174 SA_DBG2(("siHDAMode_V: Step 3 MSGU_HOST_SCRATCH_PAD_3 write %X\n",HDA_ISTR_DONE));
2175 ossaHwRegWriteExt(agRoot, PCIBAR0,MSGU_HOST_SCRATCH_PAD_3 ,HDA_ISTR_DONE );
2177 SA_DBG2(("siHDAMode_V:3SCRATCH_PAD0 value = 0x%x\n", ossaHwRegReadExt(agRoot, PCIBAR0, V_Scratchpad_0_Register)));
2178 SA_DBG2(("siHDAMode_V: SCRATCH_PAD1 value = 0x%x\n", ossaHwRegReadExt(agRoot, PCIBAR0, V_Scratchpad_1_Register)));
2179 SA_DBG2(("siHDAMode_V: SCRATCH_PAD2 value = 0x%x\n", ossaHwRegReadExt(agRoot, PCIBAR0, V_Scratchpad_2_Register)));
2180 SA_DBG2(("siHDAMode_V: SCRATCH_PAD3 value = 0x%x\n", ossaHwRegReadExt(agRoot, PCIBAR0, V_Scratchpad_3_Register)));
2187 SA_DBG2(("siHDAMode_V: Exec ILA\n"));
2188 si_memset(&hdacmd,0,sizeof(spcv_hda_cmd_t));
2189 si_memset(&hdarsp,0,sizeof(spcv_hda_rsp_t));
2191 hdacmd.cmdparm_0 = 0x200000; /* length SPC_V_HDAC_EXEC*/;
2192 hdacmd.cmdparm_1 = userFwImg->ilaLen ; /* length SPC_V_HDAC_EXEC*/;
2195 hdacmd.C_PA_SEQ_ID_CMD_CODE = ( SPC_V_HDAC_PA << SHIFT24 ) | ( seq_id << SHIFT16 )| SPC_V_HDAC_EXEC;
2197 SA_DBG1(("siHDAMode_V: STEP 4\n"));
2201 The host writes the HDAC_EXEC command (0x0002) via MEMBASE-I for the boot ROM to authenticate
2202 and execute the HDA-ILA image. The host sets parameter 0 and parameter 1 for the HDA-ILA image
2204 Parameter 0: Entry offset this value must be 0x20_0000.
2205 Parameter 1: the HDA-ILA image length.
2208 ossaHwRegWriteExt(agRoot, PCIBAR0, SPC_V_HDA_COMMAND_OFFSET+0 ,hdacmd.cmdparm_0);
2209 ossaHwRegWriteExt(agRoot, PCIBAR0, SPC_V_HDA_COMMAND_OFFSET+4 ,hdacmd.cmdparm_1);
2210 ossaHwRegWriteExt(agRoot, PCIBAR0, SPC_V_HDA_COMMAND_OFFSET+8 ,hdacmd.cmdparm_2);
2211 ossaHwRegWriteExt(agRoot, PCIBAR0, SPC_V_HDA_COMMAND_OFFSET+12,hdacmd.cmdparm_3);
2212 ossaHwRegWriteExt(agRoot, PCIBAR0, SPC_V_HDA_COMMAND_OFFSET+16,hdacmd.cmdparm_4);
2213 ossaHwRegWriteExt(agRoot, PCIBAR0, SPC_V_HDA_COMMAND_OFFSET+20,hdacmd.cmdparm_5);
2214 ossaHwRegWriteExt(agRoot, PCIBAR0, SPC_V_HDA_COMMAND_OFFSET+24,hdacmd.cmdparm_6);
2215 ossaHwRegWriteExt(agRoot, PCIBAR0, SPC_V_HDA_COMMAND_OFFSET+28,hdacmd.C_PA_SEQ_ID_CMD_CODE);
2217 SA_DBG1(("siHDAMode_V: Exec ILA\n" ));
2219 SA_DBG2(("siHDAMode_V: Command 0 0x%08X 0x%08X 0x%08X 0x%08X 0x%08X 0x%08X 0x%08X 0x%08X\n",
2220 ossaHwRegReadExt(agRoot, PCIBAR0, SPC_V_HDA_COMMAND_OFFSET+0),
2221 ossaHwRegReadExt(agRoot, PCIBAR0, SPC_V_HDA_COMMAND_OFFSET+4),
2222 ossaHwRegReadExt(agRoot, PCIBAR0, SPC_V_HDA_COMMAND_OFFSET+8),
2223 ossaHwRegReadExt(agRoot, PCIBAR0, SPC_V_HDA_COMMAND_OFFSET+12),
2224 ossaHwRegReadExt(agRoot, PCIBAR0, SPC_V_HDA_COMMAND_OFFSET+16),
2225 ossaHwRegReadExt(agRoot, PCIBAR0, SPC_V_HDA_COMMAND_OFFSET+20),
2226 ossaHwRegReadExt(agRoot, PCIBAR0, SPC_V_HDA_COMMAND_OFFSET+24),
2227 ossaHwRegReadExt(agRoot, PCIBAR0, SPC_V_HDA_COMMAND_OFFSET+28) ));
2229 SA_DBG2(("siHDAMode_V: command %X\n",hdacmd.C_PA_SEQ_ID_CMD_CODE ));
2231 SA_DBG2(("siHDAMode_V:4SCRATCH_PAD0 value = 0x%x\n", ossaHwRegReadExt(agRoot, PCIBAR0, V_Scratchpad_0_Register)));
2232 SA_DBG2(("siHDAMode_V: SCRATCH_PAD1 value = 0x%x\n", ossaHwRegReadExt(agRoot, PCIBAR0, V_Scratchpad_1_Register)));
2233 SA_DBG2(("siHDAMode_V: SCRATCH_PAD2 value = 0x%x\n", ossaHwRegReadExt(agRoot, PCIBAR0, V_Scratchpad_2_Register)));
2234 SA_DBG2(("siHDAMode_V: SCRATCH_PAD3 value = 0x%x\n", ossaHwRegReadExt(agRoot, PCIBAR0, V_Scratchpad_3_Register)));
2238 SA_DBG1(("siHDAMode_V: start wait STEP 5\n"));
2242 The host continues polling for the HDA-ILA status via MEMBASE-I. The polling timeout should
2243 be no more than 1 second. The response status HDAR_EXEC indicates a good response from the
2244 boot ROM. Response states that indicate a failure are:
2249 max_wait_time = (2000 * 1000); /* wait 2 seconds */
2250 max_wait_count = MAKE_MODULO(max_wait_time,WAIT_INCREMENT) - WAIT_INCREMENT;
2251 hda_command_complete = 0;
2252 hda_status = (ossaHwRegReadExt(agRoot, PCIBAR0, SPC_V_HDA_RESPONSE_OFFSET+28) & SPC_V_HDAR_RSPCODE_MASK );
2253 SA_DBG1(("siHDAMode_V:SCRATCH_PAD1 = 0x%x hda_status 0x%x Begin STEP 5\n", ossaHwRegReadExt(agRoot, PCIBAR0, MSGU_SCRATCH_PAD_1),hda_status));
2257 ossaStallThread(agRoot, WAIT_INCREMENT);
2258 hda_status = (ossaHwRegReadExt(agRoot, PCIBAR0, SPC_V_HDA_RESPONSE_OFFSET+28) & SPC_V_HDAR_RSPCODE_MASK );
2259 hda_command_complete = ((ossaHwRegReadExt(agRoot, PCIBAR0, SPC_V_HDA_RESPONSE_OFFSET+28) & SPC_V_HDAR_SEQID_MASK ) >> SHIFT16) == seq_id;
2260 } while (hda_status != SPC_V_HDAR_EXEC && (max_wait_count -= WAIT_INCREMENT));
2262 SA_DBG1(("siHDAMode_V:SCRATCH_PAD1 = 0x%x hda_status 0x%x hda_command_complete 0x%x STEP 5 wait for seq_id took %d\n",
2263 ossaHwRegReadExt(agRoot, PCIBAR0, MSGU_SCRATCH_PAD_1),
2265 hda_command_complete,
2266 (max_wait_time - max_wait_count)));
2268 smTrace(hpDBG_VERY_LOUD,"2Z",(max_wait_time - max_wait_count) );
2269 /* TP:2Z STEP 5 took */
2271 if(! hda_command_complete)
2273 SA_DBG1(("siHDAMode_V: Response 0 0x%08X 0x%08X 0x%08X 0x%08X 0x%08X 0x%08X 0x%08X 0x%08X\n",
2274 ossaHwRegReadExt(agRoot, PCIBAR0, SPC_V_HDA_RESPONSE_OFFSET+0),
2275 ossaHwRegReadExt(agRoot, PCIBAR0, SPC_V_HDA_RESPONSE_OFFSET+4),
2276 ossaHwRegReadExt(agRoot, PCIBAR0, SPC_V_HDA_RESPONSE_OFFSET+8),
2277 ossaHwRegReadExt(agRoot, PCIBAR0, SPC_V_HDA_RESPONSE_OFFSET+12),
2278 ossaHwRegReadExt(agRoot, PCIBAR0, SPC_V_HDA_RESPONSE_OFFSET+16),
2279 ossaHwRegReadExt(agRoot, PCIBAR0, SPC_V_HDA_RESPONSE_OFFSET+20),
2280 ossaHwRegReadExt(agRoot, PCIBAR0, SPC_V_HDA_RESPONSE_OFFSET+24),
2281 ossaHwRegReadExt(agRoot, PCIBAR0, SPC_V_HDA_RESPONSE_OFFSET+28) ));
2283 SA_DBG1(("siHDAMode_V:5SCRATCH_PAD0 value = 0x%x\n", ossaHwRegReadExt(agRoot, PCIBAR0, V_Scratchpad_0_Register)));
2284 SA_DBG1(("siHDAMode_V: SCRATCH_PAD1 value = 0x%x\n", ossaHwRegReadExt(agRoot, PCIBAR0, V_Scratchpad_1_Register)));
2285 SA_DBG1(("siHDAMode_V: SCRATCH_PAD2 value = 0x%x\n", ossaHwRegReadExt(agRoot, PCIBAR0, V_Scratchpad_2_Register)));
2286 SA_DBG1(("siHDAMode_V: SCRATCH_PAD3 value = 0x%x\n", ossaHwRegReadExt(agRoot, PCIBAR0, V_Scratchpad_3_Register)));
2287 SA_DBG1(("siHDAMode_V:hda_command_complete failed Step 5\n" ));
2288 smTraceFuncExit(hpDBG_VERY_LOUD, 'g', "2W");
2292 if (hda_status != SPC_V_HDAR_EXEC)
2294 SA_DBG1(("siHDAMode_V:ILA_EXEC_ERROR hda_status %X hda_command_complete %d\n",hda_status ,hda_command_complete));
2295 smTraceFuncExit(hpDBG_VERY_LOUD, 'h', "2W");
2298 SA_DBG1(("siHDAMode_V: end seq_id updated STEP 5\n"));
2303 SA_DBG1(("siHDAMode_V: start STEP 6\n"));
2307 The host polls the upper 8 bits [31:24] 5 of the Scratchpad 0 Register
2308 (page 609) for the ILAHDA_RAAE_IMG_GET (0x11) state. Polling timeout
2309 should be no more than 2 seconds. If a polling timeout occurs, the host
2310 should check for a fatal error as described in Section 12.2.
2311 If successful, the Host Scratchpad 4 Register (page 620) and Host
2312 Scratchpad 5 Register (page 621) are set as follows: Host Scratchpad 4
2313 Register (page 620) holds the lower 32-bit host address of
2314 the RAAE image. Host Scratchpad 5 Register (page 621)
2315 holds the upper 32-bit host address of the RAAE image.
2316 Then the host writes the command ILAHDAC_RAAE_IMG_DONE(0x81) to the upper
2317 8 bits [31:24] of the Host Scratchpad 3 Register (page 619) and writes the
2318 sizeof the RAAE image to the lower 24 bits [23:0].
2321 max_wait_time = (2000 * 1000); /* wait 2 seconds */
2322 max_wait_count = MAKE_MODULO(max_wait_time,WAIT_INCREMENT) - WAIT_INCREMENT;
2323 hda_command_complete = 0;
2326 ossaStallThread(agRoot, WAIT_INCREMENT);
2327 hda_command_complete = ((ossaHwRegReadExt(agRoot, PCIBAR0,V_Scratchpad_0_Register) & 0xff000000 ) >> SHIFT24 ) == ILAHDA_RAAE_IMG_GET;
2328 } while (!hda_command_complete && (max_wait_count -= WAIT_INCREMENT));
2330 SA_DBG1(("siHDAMode_V:SCRATCH_PAD0 = 0x%x STEP 6 wait for ILAHDA_RAAE_IMG_GET took %d\n", ossaHwRegReadExt(agRoot, PCIBAR0, V_Scratchpad_0_Register),(max_wait_time - max_wait_count)));
2331 smTrace(hpDBG_VERY_LOUD,"2b",(max_wait_time - max_wait_count) );
2332 /* TP:2b STEP 6 took */
2333 if(! hda_command_complete)
2335 SA_DBG1(("siHDAMode_V:hda_command_complete failed Step 6\n" ));
2336 smTraceFuncExit(hpDBG_VERY_LOUD, 'i', "2W");
2340 si_memset(pbase, 0, biggest);
2342 if( userFwImg->aap1Len < biggest)
2344 si_memcpy(pbase,userFwImg->aap1Img, userFwImg->aap1Len );
2348 SA_DBG1(("siHDAMode_V: userFwImg->aap1Len 0x%x < biggest 0x%x\n",userFwImg->aap1Len,biggest));
2353 ossaHwRegWrite(agRoot, MSGU_HOST_SCRATCH_PAD_5, base_Hi );
2354 SA_DBG3(("siHDAMode_V: MSGU_HOST_SCRATCH_PAD_5 0x%X\n", base_Hi));
2356 ossaHwRegWrite(agRoot, MSGU_HOST_SCRATCH_PAD_4, base_Lo );
2357 SA_DBG3(("siHDAMode_V: MSGU_HOST_SCRATCH_PAD_4 0x%X\n",base_Lo));
2359 ossaHwRegWriteExt(agRoot, PCIBAR0,MSGU_HOST_SCRATCH_PAD_3 ,(ILAHDAC_RAAE_IMG_DONE << SHIFT24) | userFwImg->aap1Len );
2360 SA_DBG1(("siHDAMode_V: write ILAHDAC_RAAE_IMG_DONE to MSGU_HOST_SCRATCH_PAD_3 0x%X\n",(ILAHDAC_RAAE_IMG_DONE << SHIFT24) | userFwImg->aap1Len));
2361 // ossaHwRegWriteExt(agRoot, PCIBAR0,MSGU_HOST_SCRATCH_PAD_4 , userFwImg->DmaBase_l);
2363 ossaStallThread(agRoot, gWaitmSec * 1000);
2364 if(1) /* step in question */
2366 max_wait_time = (2000 * 1000); /* wait 2 seconds */
2367 max_wait_count = MAKE_MODULO(max_wait_time,WAIT_INCREMENT) - WAIT_INCREMENT;
2368 hda_command_complete = 0;
2371 ossaStallThread(agRoot, WAIT_INCREMENT);
2372 hda_command_complete = ((ossaHwRegReadExt(agRoot, PCIBAR0,V_Scratchpad_0_Register) & 0xff000000 ) >> SHIFT24 ) == ILAHDA_IOP_IMG_GET;
2373 } while (!hda_command_complete && (max_wait_count -= WAIT_INCREMENT));
2375 SA_DBG1(("siHDAMode_V:SCRATCH_PAD1 = 0x%x STEP 7 wait for ILAHDA_IOP_IMG_GET took %d\n", ossaHwRegReadExt(agRoot, PCIBAR0, MSGU_SCRATCH_PAD_1),(max_wait_time - max_wait_count)));
2376 smTrace(hpDBG_VERY_LOUD,"2c",(max_wait_time - max_wait_count) );
2377 /* TP:2c STEP 6a ILAHDA_IOP_IMG_GET took */
2378 smTrace(hpDBG_VERY_LOUD,"2y",hda_command_complete );
2379 /* TP:2y hda_command_complete */
2381 if(! hda_command_complete)
2383 SA_DBG1(("siHDAMode_V:hda_command_complete failed Step 7\n" ));
2384 smTraceFuncExit(hpDBG_VERY_LOUD, 'j', "2W");
2388 SA_DBG1(("siHDAMode_V: End V_Scratchpad_0_Register 0x%08X STEP 6\n",ossaHwRegReadExt(agRoot, PCIBAR0,V_Scratchpad_0_Register)));
2393 SA_DBG1(("siHDAMode_V: STEP 7\n"));
2396 The host polls (reads) the upper 8 bits 7 [31:24] of the Scratchpad 0 Register (page 609)
2397 for ILAHDA_IOP_IMG_GET (0x10) state. The polling timeout should be no more than 2 seconds.
2398 If a polling timeout occurs, the host should check for a fatal error as described in
2399 Section 12.2. If successful, the Host Scratchpad 4 Register (page 620) and Host
2400 Scratchpad 5 Register (page 621) are set as follows:
2401 Host Scratchpad 4 Register (page 620) holds the lower host address of the IOP image.
2402 Host Scratchpad 5 Register (page 621) holds the upper host address of the IOP image.
2403 Then host writes the command ILAHDAC_IOP_IMG_DONE(0x80) to the upper 8 bits [31:24] of the
2404 Host Scratchpad 3 Register (page 614)and writes the sizeof the IOP image to the lower 24
2409 si_memset(pbase, 0, biggest);
2411 if( userFwImg->iopLen < biggest)
2413 si_memcpy(pbase,userFwImg->iopImg, userFwImg->iopLen );
2417 SA_DBG1(("siHDAMode_V: userFwImg->iopImg 0x%x < biggest 0x%x\n",userFwImg->iopLen,biggest));
2421 ossaHwRegWrite(agRoot, MSGU_HOST_SCRATCH_PAD_5, base_Hi );
2422 SA_DBG3(("siHDAMode_V: MSGU_HOST_SCRATCH_PAD_5 0x%X\n", base_Hi));
2424 ossaHwRegWrite(agRoot, MSGU_HOST_SCRATCH_PAD_4, base_Lo );
2425 SA_DBG3(("siHDAMode_V: MSGU_HOST_SCRATCH_PAD_4 0x%X\n",base_Lo));
2426 SA_DBG2(("siHDAMode_V: MSGU_HOST_SCRATCH_PAD_4\n"));
2428 ossaHwRegWriteExt(agRoot, PCIBAR0,MSGU_HOST_SCRATCH_PAD_3 ,(ILAHDAC_IOP_IMG_DONE << SHIFT24) | userFwImg->iopLen );
2429 SA_DBG2(("siHDAMode_V: MSGU_HOST_SCRATCH_PAD_3 0x%X\n",(ILAHDAC_IOP_IMG_DONE << SHIFT24) | userFwImg->iopLen));
2432 if(saRoot->swConfig.hostDirectAccessMode & 2 )
2434 /* Hda AES DIF offload */
2435 ossaHwRegWrite(agRoot, V_Scratchpad_Rsvd_0_Register, HDA_AES_DIF_FUNC);
2436 SA_DBG1(("siHDAMode_V: V_Scratchpad_Rsvd_0_Register, HDA_AES_DIF_FUNC 0x%X\n",HDA_AES_DIF_FUNC));
2437 /* Hda AES DIF offload */
2440 SA_DBG2(("siHDAMode_V: SCRATCH_PAD0 value = 0x%x\n", ossaHwRegReadExt(agRoot, PCIBAR0, V_Scratchpad_0_Register)));
2441 SA_DBG2(("siHDAMode_V: SCRATCH_PAD1 value = 0x%x\n", ossaHwRegReadExt(agRoot, PCIBAR0, V_Scratchpad_1_Register)));
2444 max_wait_time = (2000 * 1000); /* wait 2 seconds */
2445 max_wait_count = MAKE_MODULO(max_wait_time,WAIT_INCREMENT) - WAIT_INCREMENT;
2446 hda_command_complete = 0;
2449 ossaStallThread(agRoot, WAIT_INCREMENT);
2450 hda_command_complete = ((ossaHwRegReadExt(agRoot, PCIBAR0,V_Scratchpad_0_Register) & 0xff000000 ) >> SHIFT24 ) == ILAHDA_IOP_IMG_GET;
2451 } while (!hda_command_complete && (max_wait_count -= WAIT_INCREMENT));
2453 smTrace(hpDBG_VERY_LOUD,"2d",(max_wait_time - max_wait_count) );
2454 /* TP:2d STEP 7 ILAHDA_IOP_IMG_GET took */
2455 smTrace(hpDBG_VERY_LOUD,"2z",hda_command_complete );
2456 /* TP:2z hda_command_complete */
2458 SA_DBG2(("siHDAMode_V:SCRATCH_PAD0 = 0x%x STEP 7 wait for ILAHDA_IOP_IMG_GET took %d\n", ossaHwRegReadExt(agRoot, PCIBAR0, V_Scratchpad_0_Register),(max_wait_time - max_wait_count)));
2460 if(! hda_command_complete)
2462 SA_DBG1(("siHDAMode_V:7SCRATCH_PAD0 value = 0x%x\n", ossaHwRegReadExt(agRoot, PCIBAR0, V_Scratchpad_0_Register)));
2463 SA_DBG1(("siHDAMode_V: SCRATCH_PAD1 value = 0x%x\n", ossaHwRegReadExt(agRoot, PCIBAR0, V_Scratchpad_1_Register)));
2464 SA_DBG1(("siHDAMode_V: SCRATCH_PAD2 value = 0x%x\n", ossaHwRegReadExt(agRoot, PCIBAR0, V_Scratchpad_2_Register)));
2465 SA_DBG1(("siHDAMode_V: SCRATCH_PAD3 value = 0x%x\n", ossaHwRegReadExt(agRoot, PCIBAR0, V_Scratchpad_3_Register)));
2466 SA_DBG1(("siHDAMode_V:hda_command_complete failed Step 7\n" ));
2467 smTraceFuncExit(hpDBG_VERY_LOUD, 'k', "2W");
2472 SA_DBG2(("siHDAMode_V:7SCRATCH_PAD0 value = 0x%x\n", ossaHwRegReadExt(agRoot, PCIBAR0, V_Scratchpad_0_Register)));
2473 SA_DBG2(("siHDAMode_V: SCRATCH_PAD1 value = 0x%x\n", ossaHwRegReadExt(agRoot, PCIBAR0, V_Scratchpad_1_Register)));
2474 SA_DBG2(("siHDAMode_V: SCRATCH_PAD2 value = 0x%x\n", ossaHwRegReadExt(agRoot, PCIBAR0, V_Scratchpad_2_Register)));
2475 SA_DBG2(("siHDAMode_V: SCRATCH_PAD3 value = 0x%x\n", ossaHwRegReadExt(agRoot, PCIBAR0, V_Scratchpad_3_Register)));
2476 SA_DBG1(("siHDAMode_V: End STEP 7\n"));
2484 SA_DBG1(("siHDAMode_V: Check fw ready Step 8\n"));
2488 IOP0/1 start-up sequence. The host polls the Scratchpad 1 Register (page 610)
2489 bits [1:0] for RAAE_STATE, bits [13:12] for IOP1_STATE, and
2490 bits [11:10] for IOP0_STATE to go to 11b (Ready state).
2491 The polling timeout should be no more than 1 second. If a polling timeout occurs,
2492 the host should check for a fatal error in Section 12.2.
2495 returnVal = AGSA_RC_SUCCESS;
2497 max_wait_time = (1000 * 1000); /* wait 1000 milliseconds */
2498 max_wait_count = MAKE_MODULO(max_wait_time,WAIT_INCREMENT) - WAIT_INCREMENT;
2501 ossaStallThread(agRoot, WAIT_INCREMENT);
2502 SCRATCH_PAD1 = ossaHwRegReadExt(agRoot, PCIBAR0, MSGU_SCRATCH_PAD_1);
2503 } while ((SCRATCH_PAD1 == 0xFFFFFFFF ) && (max_wait_count -= WAIT_INCREMENT));
2504 smTrace(hpDBG_VERY_LOUD,"HZ",(max_wait_time - max_wait_count) );
2505 /* TP:2f Step 8 PCI took */
2507 SA_DBG1(("siHDAMode_V:SCRATCH_PAD1 = 0x%x (0x%x) Step 8 PCIe took %d\n", SCRATCH_PAD1,ossaHwRegReadExt(agRoot, PCIBAR0, MSGU_SCRATCH_PAD_1),(max_wait_time - max_wait_count)));
2509 max_wait_time = (1000 * 1000); /* wait 1000 milliseconds */
2510 max_wait_count = MAKE_MODULO(max_wait_time,WAIT_INCREMENT) - WAIT_INCREMENT;
2513 ossaStallThread(agRoot, WAIT_INCREMENT);
2514 SCRATCH_PAD1 = ossaHwRegReadExt(agRoot, PCIBAR0, MSGU_SCRATCH_PAD_1);
2515 } while (((SCRATCH_PAD1 & SCRATCH_PAD1_V_ILA_MASK) != SCRATCH_PAD1_V_ILA_MASK) && (max_wait_count -= WAIT_INCREMENT));
2517 smTrace(hpDBG_VERY_LOUD,"2g",(max_wait_time - max_wait_count) );
2518 /* TP:2g Step 8 ILA took */
2520 SA_DBG2(("siHDAMode_V:SCRATCH_PAD1 = 0x%x SCRATCH_PAD1_V_ILA_MASK (0x%x)(0x%x) took %d\n", SCRATCH_PAD1,SCRATCH_PAD1_V_ILA_MASK,ossaHwRegReadExt(agRoot, PCIBAR0, MSGU_SCRATCH_PAD_1),(max_wait_time - max_wait_count)));
2522 if (!max_wait_count)
2524 // Ignore for now returnVal = AGSA_RC_FAILURE;
2525 SA_DBG1(("siHDAMode_V:Timeout SCRATCH_PAD1_V_ILA_MASK (0x%x) not set SCRATCH_PAD1 = 0x%x\n",SCRATCH_PAD1_V_ILA_MASK, SCRATCH_PAD1));
2528 SA_DBG1(("siHDAMode_V:SCRATCH_PAD1 = 0x%x SCRATCH_PAD1_V_ILA_MASK (0x%x)(0x%x) took %d\n", SCRATCH_PAD1,SCRATCH_PAD1_V_ILA_MASK,ossaHwRegReadExt(agRoot, PCIBAR0, MSGU_SCRATCH_PAD_1),(max_wait_time - max_wait_count)));
2531 max_wait_time = (1800 * 1000); /* wait 1800 milliseconds */
2532 max_wait_count = MAKE_MODULO(max_wait_time,WAIT_INCREMENT) - WAIT_INCREMENT;
2535 ossaStallThread(agRoot, WAIT_INCREMENT);
2536 SCRATCH_PAD1 = ossaHwRegReadExt(agRoot, PCIBAR0, MSGU_SCRATCH_PAD_1);
2537 } while (((SCRATCH_PAD1 & SCRATCH_PAD1_V_RAAE_MASK) != SCRATCH_PAD1_V_RAAE_MASK) && (max_wait_count -= WAIT_INCREMENT));
2539 SA_DBG1(("siHDAMode_V:SCRATCH_PAD1 = 0x%x SCRATCH_PAD1_V_RAAE_MASK (0x%x)(0x%x) took %d\n", SCRATCH_PAD1,SCRATCH_PAD1_V_RAAE_MASK,ossaHwRegReadExt(agRoot, PCIBAR0, MSGU_SCRATCH_PAD_1),(max_wait_time - max_wait_count)));
2540 smTrace(hpDBG_VERY_LOUD,"2h",(max_wait_time - max_wait_count) );
2541 /* TP:2h Step 8 RAAE took */
2543 if (!max_wait_count)
2545 SA_DBG1(("siHDAMode_V:Timeout SCRATCH_PAD1_V_RAAE_MASK (0x%x) not set SCRATCH_PAD1 = 0x%x\n",SCRATCH_PAD1_V_RAAE_MASK, SCRATCH_PAD1));
2549 max_wait_time = (600 * 1000); /* wait 600 milliseconds */
2550 max_wait_count = MAKE_MODULO(max_wait_time,WAIT_INCREMENT) - WAIT_INCREMENT;
2553 ossaStallThread(agRoot, WAIT_INCREMENT);
2554 SCRATCH_PAD1 = ossaHwRegReadExt(agRoot, PCIBAR0, MSGU_SCRATCH_PAD_1);
2555 } while (((SCRATCH_PAD1 & SCRATCH_PAD1_V_IOP0_MASK) != SCRATCH_PAD1_V_IOP0_MASK) && (max_wait_count -= WAIT_INCREMENT));
2557 SA_DBG1(("siHDAMode_V:SCRATCH_PAD1 = 0x%x SCRATCH_PAD1_V_IOP0_MASK(0x%x)(0x%x) took %d\n", SCRATCH_PAD1,SCRATCH_PAD1_V_IOP0_MASK,ossaHwRegReadExt(agRoot, PCIBAR0, MSGU_SCRATCH_PAD_1),(max_wait_time - max_wait_count)));
2558 smTrace(hpDBG_VERY_LOUD,"2i",(max_wait_time - max_wait_count) );
2559 /* TP:2i Step 8 IOP took */
2561 if (!max_wait_count)
2563 returnVal = AGSA_RC_FAILURE;
2564 SA_DBG1(("siHDAMode_V:Timeout SCRATCH_PAD1_V_IOP0_MASK (0x%x) not set SCRATCH_PAD1 = 0x%x\n",SCRATCH_PAD1_V_IOP0_MASK ,SCRATCH_PAD1));
2569 SA_DBG1(("siHDAMode_V: Step 8 0x%X ERROR_STATE 0x%X\n",ossaHwRegReadExt(agRoot,PCIBAR0 ,V_SoftResetRegister ),
2570 SCRATCH_PAD1_V_ERROR_STATE( ossaHwRegReadExt(agRoot, PCIBAR0, MSGU_SCRATCH_PAD_1) ) ));
2571 if (SCRATCH_PAD1_V_ERROR_STATE( ossaHwRegReadExt(agRoot, PCIBAR0, MSGU_SCRATCH_PAD_1) ))
2573 if(smIS_ENCRYPT(agRoot))
2575 SA_DBG1(("siHDAMode_V: Encryption and HDA mode not supported - failed Step 8\n" ));
2579 SA_DBG1(("siHDAMode_V: ERROR_STATE failed Step 8\n" ));
2581 returnVal = AGSA_RC_FAILURE;
2582 smTraceFuncExit(hpDBG_VERY_LOUD, 'l', "2W");
2587 SA_DBG1(("siHDAMode_V: returnVal 0x%X Step 8\n",returnVal));
2590 The host continues with the normal SPCv Configuration Table initialization sequence
2591 as described in Section 6.2.8.1.
2593 if(saRoot->swConfig.hostDirectAccessMode & 2 )
2595 /* Hda AES DIF offload */
2596 SA_DBG1(("siHDAMode_V: AES/DIF 0x%08X offload enabled %s\n",ossaHwRegRead(agRoot, MSGU_SCRATCH_PAD_3 ),
2597 ((ossaHwRegRead(agRoot, MSGU_SCRATCH_PAD_3 ) & (1 << SHIFT15)) ? "yes" :"no") ));
2598 /* Hda AES DIF offload */
2599 /* ossaHwRegWrite(agRoot, V_Scratchpad_Rsvd_0_Register, 0); */
2600 /* Hda AES DIF offload */
2603 smTraceFuncExit(hpDBG_VERY_LOUD, 'm', "2W");
2607 SA_DBG2(("siHDAMode_V: Response 0 0x%08X 0x%08X 0x%08X 0x%08X 0x%08X 0x%08X 0x%08X 0x%08X\n",
2608 ossaHwRegReadExt(agRoot, PCIBAR0, SPC_V_HDA_RESPONSE_OFFSET+0),
2609 ossaHwRegReadExt(agRoot, PCIBAR0, SPC_V_HDA_RESPONSE_OFFSET+4),
2610 ossaHwRegReadExt(agRoot, PCIBAR0, SPC_V_HDA_RESPONSE_OFFSET+8),
2611 ossaHwRegReadExt(agRoot, PCIBAR0, SPC_V_HDA_RESPONSE_OFFSET+12),
2612 ossaHwRegReadExt(agRoot, PCIBAR0, SPC_V_HDA_RESPONSE_OFFSET+16),
2613 ossaHwRegReadExt(agRoot, PCIBAR0, SPC_V_HDA_RESPONSE_OFFSET+20),
2614 ossaHwRegReadExt(agRoot, PCIBAR0, SPC_V_HDA_RESPONSE_OFFSET+24),
2615 ossaHwRegReadExt(agRoot, PCIBAR0, SPC_V_HDA_RESPONSE_OFFSET+28) ));
2618 SA_DBG2(("siHDAMode_V: SCRATCH_PAD0 value = 0x%x\n", ossaHwRegReadExt(agRoot, PCIBAR0, V_Scratchpad_0_Register)));
2619 SA_DBG2(("siHDAMode_V: SCRATCH_PAD1 value = 0x%x\n", ossaHwRegReadExt(agRoot, PCIBAR0, V_Scratchpad_1_Register)));
2620 SA_DBG2(("siHDAMode_V: SCRATCH_PAD2 value = 0x%x\n", ossaHwRegReadExt(agRoot, PCIBAR0, V_Scratchpad_2_Register)));
2621 SA_DBG2(("siHDAMode_V: SCRATCH_PAD3 value = 0x%x\n", ossaHwRegReadExt(agRoot, PCIBAR0, V_Scratchpad_3_Register)));
2625 #endif /* SA_ENABLE_HDA_FUNCTIONS */
2630 /******************************************************************************/
2631 /*! \brief Function to check FW is ready for soft reset
2633 * The siSpcSoftResetRDYChk() function is called to check status of FW
2635 * \param agRoot handles for this instance of SAS/SATA hardware
2637 * \return success or fail
2639 /*******************************************************************************/
2640 LOCAL bit32 siSpcSoftResetRDYChk(agsaRoot_t *agRoot)
2645 bit32 spad2notready = 0;
2646 #if defined(SALLSDK_DEBUG)
2649 #endif /* SALLSDK_DEBUG */
2651 /* read the scratch pad 2 register bit 2 */
2652 regVal = ossaHwRegRead(agRoot, MSGU_SCRATCH_PAD_2) & SCRATCH_PAD2_FWRDY_RST;
2653 Scratchpad1 = ossaHwRegRead(agRoot, MSGU_SCRATCH_PAD_1);
2654 if (regVal == SCRATCH_PAD2_FWRDY_RST)
2656 /* FW assert happened, it is ready for soft reset */
2661 /* read bootloader response state */
2662 regVal = ossaHwRegReadExt(agRoot, PCIBAR3, HDA_RSP_OFFSET1MB+HDA_CMD_CODE_OFFSET) & HDA_STATUS_BITS;
2663 if (regVal == BOOTTLOADERHDA_IDLE)
2665 /* For customers wants to do soft reset even the chip is already in HDA mode */
2666 /* Do not need to trigger RB6 twice */
2671 /* Trigger NMI twice via RB6 */
2672 if (AGSA_RC_FAILURE == siBar4Shift(agRoot, RB6_ACCESS_REG))
2674 SA_DBG1(("siSpcSoftReset:Shift Bar4 to 0x%x failed\n", RB6_ACCESS_REG));
2675 return AGSA_RC_FAILURE;
2678 if(Scratchpad1 != (SCRATCH_PAD1_FW_INIT_ERR | SCRATCH_PAD1_AAP_ERROR_STATE))
2680 ossaHwRegWriteExt(agRoot, PCIBAR2, SPC_RB6_OFFSET , RB6_MAGIC_NUMBER_RST);
2682 ossaHwRegWriteExt(agRoot, PCIBAR2, SPC_RB6_OFFSET , RB6_MAGIC_NUMBER_RST);
2686 SA_DBG1(("siSoftReset: ILA load fail SKIP RB6 access 0x%x\n",Scratchpad1 ));
2689 /* wait for 100 ms */
2690 ossaStallThread(agRoot, ONE_HUNDRED_MILLISECS );
2691 Scratchpad2 = ossaHwRegRead(agRoot, MSGU_SCRATCH_PAD_2);
2692 regVal = Scratchpad2 & SCRATCH_PAD2_FWRDY_RST;
2693 if (regVal != SCRATCH_PAD2_FWRDY_RST)
2695 if (spad2notready > WAIT_SECONDS(12) / ONE_HUNDRED_MILLISECS ) /**/
2697 #if defined(SALLSDK_DEBUG)
2698 regVal1 = ossaHwRegRead(agRoot, MSGU_SCRATCH_PAD_1);
2699 regVal2 = ossaHwRegRead(agRoot, MSGU_SCRATCH_PAD_2);
2700 SA_DBG1(("siSpcSoftResetRDYChk: TIMEOUT:MSGU_SCRATCH_PAD1=0x%x, MSGU_SCRATCH_PAD2=0x%x\n", regVal1, regVal2));
2701 SA_DBG1(("siSpcSoftResetRDYChk: SCRATCH_PAD0 value = 0x%x\n", ossaHwRegRead(agRoot, MSGU_SCRATCH_PAD_0)));
2702 SA_DBG1(("siSpcSoftResetRDYChk: SCRATCH_PAD3 value = 0x%x\n", ossaHwRegRead(agRoot, MSGU_SCRATCH_PAD_3)));
2703 #endif /* SALLSDK_DEBUG */
2704 return AGSA_RC_SUCCESS; /* Timeout Ok reset anyway */
2708 goto SPAD2_NOT_READY;
2713 return AGSA_RC_SUCCESS;
2717 agsaBarOffset_t SPCTable[] =
2720 { GEN_MSGU_IBDB_SET, PCIBAR0, MSGU_IBDB_SET, SIZE_DW }, /* 0x00 */
2721 { GEN_MSGU_ODR, PCIBAR0, MSGU_ODR, SIZE_DW }, /* 0x01 */
2722 { GEN_MSGU_ODCR, PCIBAR0, MSGU_ODCR, SIZE_DW }, /* 0x02 */
2723 { GEN_MSGU_SCRATCH_PAD_0, PCIBAR0, MSGU_SCRATCH_PAD_0, SIZE_DW }, /* 0x03 */
2724 { GEN_MSGU_SCRATCH_PAD_1, PCIBAR0, MSGU_SCRATCH_PAD_1, SIZE_DW }, /* 0x04 */
2725 { GEN_MSGU_SCRATCH_PAD_2, PCIBAR0, MSGU_SCRATCH_PAD_2, SIZE_DW }, /* 0x05 */
2726 { GEN_MSGU_SCRATCH_PAD_3, PCIBAR0, MSGU_SCRATCH_PAD_3, SIZE_DW }, /* 0x06 */
2727 { GEN_MSGU_HOST_SCRATCH_PAD_0, PCIBAR0, MSGU_HOST_SCRATCH_PAD_0, SIZE_DW }, /* 0x07 */
2728 { GEN_MSGU_HOST_SCRATCH_PAD_1, PCIBAR0, MSGU_HOST_SCRATCH_PAD_1, SIZE_DW }, /* 0x08 */
2729 { GEN_MSGU_HOST_SCRATCH_PAD_2, PCIBAR0, MSGU_HOST_SCRATCH_PAD_2, SIZE_DW }, /* 0x09 */
2730 { GEN_MSGU_HOST_SCRATCH_PAD_3, PCIBAR0, MSGU_HOST_SCRATCH_PAD_3, SIZE_DW }, /* 0x0a */
2731 { GEN_MSGU_ODMR, PCIBAR0, MSGU_ODMR, SIZE_DW }, /* 0x0b */
2732 { GEN_PCIE_TRIGGER, PCIBAR0, PCIE_TRIGGER_ON_REGISTER_READ, SIZE_DW }, /* 0x0c */
2733 { GEN_SPC_REG_RESET, PCIBAR2, SPC_REG_RESET, SIZE_DW }, /* 0x0d */
2736 agsaBarOffset_t SPC_V_Table[] =
2739 { GEN_MSGU_IBDB_SET, PCIBAR0, V_Inbound_Doorbell_Set_Register, SIZE_DW }, /* 0x00 */
2740 { GEN_MSGU_ODR, PCIBAR0, V_Outbound_Doorbell_Set_Register, SIZE_DW }, /* 0x01 */
2741 { GEN_MSGU_ODCR, PCIBAR0, V_Outbound_Doorbell_Clear_Register, SIZE_DW }, /* 0x02 */
2742 { GEN_MSGU_SCRATCH_PAD_0, PCIBAR0, V_Scratchpad_0_Register, SIZE_DW }, /* 0x03 */
2743 { GEN_MSGU_SCRATCH_PAD_1, PCIBAR0, V_Scratchpad_1_Register, SIZE_DW }, /* 0x04 */
2744 { GEN_MSGU_SCRATCH_PAD_2, PCIBAR0, V_Scratchpad_2_Register, SIZE_DW }, /* 0x05 */
2745 { GEN_MSGU_SCRATCH_PAD_3, PCIBAR0, V_Scratchpad_3_Register, SIZE_DW }, /* 0x06 */
2746 { GEN_MSGU_HOST_SCRATCH_PAD_0, PCIBAR0, V_Host_Scratchpad_0_Register, SIZE_DW }, /* 0x07 */
2747 { GEN_MSGU_HOST_SCRATCH_PAD_1, PCIBAR0, V_Host_Scratchpad_1_Register, SIZE_DW }, /* 0x08 */
2748 { GEN_MSGU_HOST_SCRATCH_PAD_2, PCIBAR0, V_Host_Scratchpad_2_Register, SIZE_DW }, /* 0x09 */
2749 { GEN_MSGU_HOST_SCRATCH_PAD_3, PCIBAR0, V_Host_Scratchpad_3_Register, SIZE_DW }, /* 0x0a */
2750 { GEN_MSGU_ODMR, PCIBAR0, V_Outbound_Doorbell_Mask_Set_Register, SIZE_DW }, /* 0x0b */
2751 { GEN_PCIE_TRIGGER, PCIBAR0, PCIE_TRIGGER_ON_REGISTER_READ, SIZE_DW }, /* 0x0c */
2752 { GEN_SPC_REG_RESET, PCIBAR0, V_SoftResetRegister, SIZE_DW }, /* 0x0d */
2756 /*******************************************************************************/
2760 * \param agsaRoot Pointer to a data structure containing both application
2761 * and LL layer context handles
2762 * \param Spc_type Device Id of hardware
2767 /*******************************************************************************/
2768 GLOBAL void siUpdateBarOffsetTable(agsaRoot_t *agRoot,
2773 agsaLLRoot_t *saRoot = (agsaLLRoot_t *) (agRoot->sdkData);
2776 smTraceFuncEnter(hpDBG_VERY_LOUD,"mf");
2778 smTrace(hpDBG_VERY_LOUD,"9A",Spc_Type);
2779 /* TP:9A Spc_Type */
2781 if(Spc_Type == VEN_DEV_SPC)
2783 si_memcpy(&saRoot->SpcBarOffset, SPCTable, sizeof(SPCTable));
2784 SA_DBG5(("siUpdateBarOffsetTable:sizeof(SPCTable) sizeof(agsaBarOffset_t)sizeof(SPCTable) / sizeof(agsaBarOffset_t) %X %X %X\n",
2785 (unsigned int)sizeof(SPCTable), (unsigned int)sizeof(agsaBarOffset_t),
2786 (unsigned int)(sizeof(SPCTable) / sizeof(agsaBarOffset_t))
2789 else /* VEN_DEV_SPCV */
2791 si_memcpy(&saRoot->SpcBarOffset, SPC_V_Table, sizeof(SPC_V_Table));
2792 SA_DBG5(("siUpdateBarOffsetTable:sizeof(SPC_V_Table) sizeof(agsaBarOffset_t)sizeof(SPC_V_Table) / sizeof(agsaBarOffset_t) %X %X %X\n",
2793 (unsigned int)sizeof(SPC_V_Table),
2794 (unsigned int)sizeof(agsaBarOffset_t),
2795 (unsigned int)(sizeof(SPC_V_Table) / sizeof(agsaBarOffset_t))
2799 for(x=0;x < sizeof(SPCTable) / sizeof(agsaBarOffset_t);x++)
2802 SA_DBG4(("%8X: %8X %8X %8X\n",saRoot->SpcBarOffset[x].Generic,
2803 saRoot->SpcBarOffset[x].Bar,
2804 saRoot->SpcBarOffset[x].Offset,
2805 saRoot->SpcBarOffset[x].Length
2807 if(saRoot->SpcBarOffset[x].Generic != x)
2809 SA_DBG1(("siUpdateBarOffsetTable: saRoot->SpcBarOffset[%x].Generic %X != %X\n",x, saRoot->SpcBarOffset[x].Generic, x));
2813 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "mf");
2818 GLOBAL bit32 siHalRegReadExt( agsaRoot_t *agRoot,
2824 agsaBarOffset_t * Table = agNULL;
2828 SA_ASSERT( (agNULL != agRoot), "agRoot");
2829 Table = WHATTABLE(agRoot);
2830 SA_ASSERT( (agNULL != Table), "Table");
2833 if(Table[generic].Offset != regOffset)
2836 SA_DBG1(("siHalRegReadExt: Table[%x].Offset %x != regOffset %x\n",generic,
2837 Table[generic].Offset,
2842 if(Table[generic].Bar)
2844 retVal = ossaHwRegReadExt(agRoot,
2846 Table[generic].Offset);
2850 retVal = ossaHwRegRead(agRoot,
2851 Table[generic].Offset);
2858 GLOBAL void siHalRegWriteExt(
2865 agsaBarOffset_t * Table = agNULL;
2868 SA_ASSERT( (agNULL != agRoot), "agRoot");
2870 Table = WHATTABLE(agRoot);
2871 SA_ASSERT( (agNULL != Table), "Table");
2875 if(Table[generic].Offset != regOffset)
2878 SA_DBG1(("siHalRegWriteExt: Table[%x].Offset %x != regOffset %x\n",generic,
2879 Table[generic].Offset,
2884 SA_DBG6(("siHalRegWriteExt: Bar %x Offset %8X Wrote %8X\n",
2886 Table[generic].Offset,
2890 if(Table[generic].Bar)
2892 ossaHwRegWriteExt(agRoot,
2894 Table[generic].Offset,
2898 ossaHwRegWrite(agRoot,
2899 Table[generic].Offset,
2907 GLOBAL void siPCITriger(agsaRoot_t *agRoot)
2910 SA_DBG1(("siPCITriger: Read PCIe Bar zero plus 0x%x\n", PCIE_TRIGGER_ON_REGISTER_READ));
2911 ossaHwRegReadExt(agRoot,PCIBAR0 ,PCIE_TRIGGER_ON_REGISTER_READ );
2915 GLOBAL bit32 siGetPciBar(
2919 bit32 MSGUCfgTblBase = 0;
2921 MSGUCfgTblBase = siHalRegReadExt(agRoot, GEN_MSGU_SCRATCH_PAD_0,MSGU_SCRATCH_PAD_0);
2922 pcibar = (MSGUCfgTblBase & SCRATCH_PAD0_BAR_MASK) >> SHIFT26;
2923 /* get pci Bar index */
2924 pcibar = (bit8)mpiGetPCIBarIndex(agRoot, pcibar);
2929 GLOBAL bit32 siGetTableOffset(
2931 bit32 TableOffsetInTable
2935 bit32 MSGUCfgTblBase;
2936 /* read scratch pad0 to get PCI BAR and offset of configuration table */
2937 MSGUCfgTblBase = siHalRegReadExt(agRoot, GEN_MSGU_SCRATCH_PAD_0,MSGU_SCRATCH_PAD_0);
2939 MSGUCfgTblBase &= SCRATCH_PAD0_OFFSET_MASK;
2941 TableOffset = ossaHwRegReadExt(agRoot,siGetPciBar(agRoot) ,MSGUCfgTblBase +TableOffsetInTable );
2942 SA_DBG4(("GetTableOffset:TableOffset with size 0x%x\n", TableOffset));
2945 TableOffset &= 0xFFFFFF;
2946 TableOffset +=MSGUCfgTblBase;
2947 return(TableOffset);
2952 GLOBAL void siCheckQs(
2956 agsaLLRoot_t *saRoot = (agsaLLRoot_t *) (agRoot->sdkData);
2958 mpiOCQueue_t *circularOQ;
2959 mpiICQueue_t *circularIQ;
2962 for ( i = 0; i < saRoot->QueueConfig.numInboundQueues; i++ )
2964 circularIQ = &saRoot->inboundQueue[i];
2966 OSSA_READ_LE_32(circularIQ->agRoot, &circularIQ->consumerIdx, circularIQ->ciPointer, 0);
2967 if(circularIQ->producerIdx != circularIQ->consumerIdx)
2969 SA_DBG1(("siCheckQs: In Q %d PI 0x%03x CI 0x%03x (%d) \n",i,
2970 circularIQ->producerIdx,
2971 circularIQ->consumerIdx,
2972 (circularIQ->producerIdx > circularIQ->consumerIdx ? (circularIQ->producerIdx - circularIQ->consumerIdx) : (circularIQ->numElements - circularIQ->consumerIdx ) + circularIQ->producerIdx)));
2976 for ( i = 0; i < saRoot->QueueConfig.numOutboundQueues; i++ )
2978 circularOQ = &saRoot->outboundQueue[i];
2979 OSSA_READ_LE_32(circularOQ->agRoot, &circularOQ->producerIdx, circularOQ->piPointer, 0);
2980 if(circularOQ->producerIdx != circularOQ->consumerIdx)
2982 SA_DBG1(("siCheckQs: Out Q %d PI 0x%03x CI 0x%03x (%d) \n",i,
2983 circularOQ->producerIdx,
2984 circularOQ->consumerIdx,
2985 (circularOQ->producerIdx > circularOQ->consumerIdx ? (circularOQ->producerIdx - circularOQ->consumerIdx) : (circularOQ->numElements - circularOQ->consumerIdx ) + circularOQ->producerIdx)));
2991 GLOBAL void siPciCpyMem(agsaRoot_t *agRoot,
2998 bit32 i, val,offset;
3001 dst1 = (bit32 *)dst;
3003 SA_DBG1(("siPciCpyMem:copy DWcount %d from offset 0x%x to %p\n",DWcount,soffset,dst));
3005 for (i= 0; i < DWcount; i+=4,dst1++)
3007 offset = (soffset + i / 4);
3008 SA_ASSERT( (offset < (64 * 1024)), "siPciCpyMem offset too large");
3009 if(offset < (64 * 1024))
3011 val = ossaHwRegReadExt(agRoot, busBaseNumber, offset);
3012 *dst1 = BIT32_TO_LEBIT32(val);