/*******************************************************************************
* mvCpuIfTargetWinEnable - Enable/disable a CPU address decode window
*
* DESCRIPTION:
* This function enable/disable a CPU address decode window.
* if parameter 'enable' == MV_TRUE the routine will enable the
* window, thus enabling CPU accesses (before enabling the window it is
* tested for overlapping). Otherwise, the window will be disabled.
*
* INPUT:
* target - Peripheral target enumerator.
* enable - Enable/disable parameter.
*
* OUTPUT:
* N/A
*
* RETURN:
* MV_ERROR if protection window number was wrong, or the window
* overlapps other target window.
*
*******************************************************************************/
MV_STATUS mvCpuIfTargetWinEnable(MV_TARGET target,MV_BOOL enable)
{
MV_U32 winNum, temp;
MV_CPU_DEC_WIN addrDecWin;
/* Check parameters */
if (target >= MAX_TARGETS)
{
mvOsPrintf("mvCpuIfTargetWinEnable: target %d is Illigal\n", target);
return MV_ERROR;
}
/* get the window and check if it exist */
temp = mvCpuIfTargetWinGet(target, &addrDecWin);
if (MV_NO_SUCH == temp)
{
return (enable? MV_ERROR: MV_OK);
}
else if( MV_OK != temp)
{
mvOsPrintf("%s: ERR. Getting target %d failed.\n",__FUNCTION__, target);
return MV_ERROR;
}
/* check overlap */
if (MV_TRUE == enable)
{
if (MV_TRUE == cpuTargetWinOverlap(target, &addrDecWin.addrWin))
{
DB(mvOsPrintf("%s: ERR. Target %d overlap\n",__FUNCTION__, target));
return MV_ERROR;
}
}
if (!MV_TARGET_IS_DRAM(target))
{
/* get the Window number associated with this target */
winNum = mvAhbToMbusWinTargetGet(target);
if (winNum >= MAX_AHB_TO_MBUS_WINS)
{
return (enable? MV_ERROR: MV_OK);
}
if (mvAhbToMbusWinEnable(winNum , enable) != MV_OK)
{
mvOsPrintf("mvCpuIfTargetWinGet: Failed to enable window = %d\n",
winNum);
return MV_ERROR;
}
}
return MV_OK;
}
static void save_kw2_cpu_win_state(void)
{
u32 i;
MV_AHB_TO_MBUS_DEC_WIN winInfo;
/* Save CPU windows state, and enable access for Bootrom *
** according to SoC default address decoding windows. */
for(i = 0; i < MAX_AHB_TO_MBUS_WINS; i++) {
mvAhbToMbusWinGet(i, &ahbAddrDecWin[i]);
mvAhbToMbusWinRemapGet(i, &ahbAddrWinRemap[i]);
/* Disable the window */
mvAhbToMbusWinEnable(i, MV_FALSE);
}
/* Open default windows for Bootrom, PnC and internal regs. */
/* Bootrom */
winInfo.target = BOOT_ROM_CS;
winInfo.addrWin.baseLow = 0xF8000000;
winInfo.addrWin.baseHigh = 0x0;
winInfo.addrWin.size = _128M;
winInfo.enable = MV_TRUE;
mvAhbToMbusWinSet(7, &winInfo);
/* PnC */
winInfo.target = PNC_BM;
winInfo.addrWin.baseLow = 0xC0060000;
winInfo.addrWin.baseHigh = 0x0;
winInfo.addrWin.size = _64K;
winInfo.enable = MV_TRUE;
mvAhbToMbusWinSet(6, &winInfo);
#if 0
/* Internal regs */
winInfo.target = INTER_REGS;
winInfo.addrWin.baseLow = 0xD0000000;
winInfo.addrWin.baseHigh = 0x0;
winInfo.addrWin.size = _1M;
winInfo.enable = MV_TRUE;
mvAhbToMbusWinSet(MV_AHB_TO_MBUS_INTREG_WIN, &winInfo);
#endif
/* Cesa SRAM */
winInfo.target = CRYPT1_ENG;
winInfo.addrWin.baseLow = 0xC8010000;
winInfo.addrWin.baseHigh = 0x0;
winInfo.addrWin.size = _64K;
winInfo.enable = MV_TRUE;
mvAhbToMbusWinSet(4, &winInfo);
}
/*******************************************************************************
* mvCpuIfTargetWinSet - Set CPU-to-peripheral target address window
*
* DESCRIPTION:
* This function sets a peripheral target (e.g. SDRAM bank0, PCI0_MEM0)
* address window, also known as address decode window.
* A new address decode window is set for specified target address window.
* If address decode window parameter structure enables the window,
* the routine will also enable the target window, allowing CPU to access
* the target window.
*
* INPUT:
* target - Peripheral target enumerator.
* pAddrDecWin - CPU target window data structure.
*
* OUTPUT:
* N/A
*
* RETURN:
* MV_OK if CPU target window was set correctly, MV_ERROR in case of
* address window overlapps with other active CPU target window or
* trying to assign 36bit base address while CPU does not support that.
* The function returns MV_NOT_SUPPORTED, if the target is unsupported.
*
*******************************************************************************/
MV_STATUS mvCpuIfTargetWinSet(MV_TARGET target, MV_CPU_DEC_WIN *pAddrDecWin)
{
MV_AHB_TO_MBUS_DEC_WIN decWin;
MV_U32 existingWinNum;
MV_DRAM_DEC_WIN addrDecWin;
target = MV_CHANGE_BOOT_CS(target);
/* Check parameters */
if (target >= MAX_TARGETS)
{
mvOsPrintf("mvCpuIfTargetWinSet: target %d is illegal\n", target);
return MV_ERROR;
}
/* 2) Check if the requested window overlaps with current windows */
if (MV_TRUE == cpuTargetWinOverlap(target, &pAddrDecWin->addrWin))
{
mvOsPrintf("mvCpuIfTargetWinSet: ERR. Target %d overlap\n", target);
return MV_BAD_PARAM;
}
if (MV_TARGET_IS_DRAM(target))
{
/* copy relevant data to MV_DRAM_DEC_WIN structure */
addrDecWin.addrWin.baseHigh = pAddrDecWin->addrWin.baseHigh;
addrDecWin.addrWin.baseLow = pAddrDecWin->addrWin.baseLow;
addrDecWin.addrWin.size = pAddrDecWin->addrWin.size;
addrDecWin.enable = pAddrDecWin->enable;
if (mvDramIfWinSet(target,&addrDecWin) != MV_OK);
{
mvOsPrintf("mvCpuIfTargetWinSet: mvDramIfWinSet Failed\n");
return MV_ERROR;
}
}
else
{
/* copy relevant data to MV_AHB_TO_MBUS_DEC_WIN structure */
decWin.addrWin.baseLow = pAddrDecWin->addrWin.baseLow;
decWin.addrWin.baseHigh = pAddrDecWin->addrWin.baseHigh;
decWin.addrWin.size = pAddrDecWin->addrWin.size;
decWin.enable = pAddrDecWin->enable;
decWin.target = target;
existingWinNum = mvAhbToMbusWinTargetGet(target);
/* check if there is already another Window configured
for this target */
if ((existingWinNum < MAX_AHB_TO_MBUS_WINS )&&
(existingWinNum != pAddrDecWin->winNum))
{
/* if we want to enable the new winow number
passed by the user , then the old one should
be disabled */
if (MV_TRUE == pAddrDecWin->enable)
{
/* be sure it is disabled */
mvAhbToMbusWinEnable(existingWinNum , MV_FALSE);
}
}
if (mvAhbToMbusWinSet(pAddrDecWin->winNum,&decWin) != MV_OK)
{
mvOsPrintf("mvCpuIfTargetWinSet: mvAhbToMbusWinSet Failed\n");
return MV_ERROR;
}
}
return MV_OK;
}
MV_STATUS mvAhbToMbusWinTargetSwap(MV_TARGET target1,MV_TARGET target2)
{
MV_U32 winNum1,winNum2;
MV_AHB_TO_MBUS_DEC_WIN winDec1,winDec2,winDecTemp;
AHB_TO_MBUS_REMAP_REG_OFFS remapRegs1,remapRegs2;
MV_U32 remapBaseLow1=0,remapBaseLow2=0;
MV_U32 remapBaseHigh1=0,remapBaseHigh2=0;
/* Check parameters */
if (target1 >= MAX_TARGETS)
{
mvOsPrintf("mvAhbToMbusWinTargetSwap: target %d is Illigal\n", target1);
return MV_ERROR;
}
if (target2 >= MAX_TARGETS)
{
mvOsPrintf("mvAhbToMbusWinTargetSwap: target %d is Illigal\n", target1);
return MV_ERROR;
}
/* get window associated with this target */
winNum1 = mvAhbToMbusWinTargetGet(target1);
if (winNum1 == 0xffffffff)
{
mvOsPrintf("mvAhbToMbusWinTargetSwap: target %d has illigal win %d\n",
target1,winNum1);
return MV_ERROR;
}
/* get window associated with this target */
winNum2 = mvAhbToMbusWinTargetGet(target2);
if (winNum2 == 0xffffffff)
{
mvOsPrintf("mvAhbToMbusWinTargetSwap: target %d has illigal win %d\n",
target2,winNum2);
return MV_ERROR;
}
/* now Get original values of both Windows */
if (MV_OK != mvAhbToMbusWinGet(winNum1,&winDec1))
{
mvOsPrintf("mvAhbToMbusWinTargetSwap: mvAhbToMbusWinGet failed win %d\n",
winNum1);
return MV_ERROR;
}
if (MV_OK != mvAhbToMbusWinGet(winNum2,&winDec2))
{
mvOsPrintf("mvAhbToMbusWinTargetSwap: mvAhbToMbusWinGet failed win %d\n",
winNum2);
return MV_ERROR;
}
/* disable both windows */
if (MV_OK != mvAhbToMbusWinEnable(winNum1,MV_FALSE))
{
mvOsPrintf("mvAhbToMbusWinTargetSwap: failed to enable window %d\n",
winNum1);
return MV_ERROR;
}
if (MV_OK != mvAhbToMbusWinEnable(winNum2,MV_FALSE))
{
mvOsPrintf("mvAhbToMbusWinTargetSwap: failed to enable windo %d\n",
winNum2);
return MV_ERROR;
}
/* now swap targets */
/* first save winDec2 values */
winDecTemp.addrWin.baseHigh = winDec2.addrWin.baseHigh;
winDecTemp.addrWin.baseLow = winDec2.addrWin.baseLow;
winDecTemp.addrWin.size = winDec2.addrWin.size;
winDecTemp.enable = winDec2.enable;
winDecTemp.target = winDec2.target;
/* winDec2 = winDec1 */
winDec2.addrWin.baseHigh = winDec1.addrWin.baseHigh;
winDec2.addrWin.baseLow = winDec1.addrWin.baseLow;
winDec2.addrWin.size = winDec1.addrWin.size;
winDec2.enable = winDec1.enable;
winDec2.target = winDec1.target;
/* winDec1 = winDecTemp */
winDec1.addrWin.baseHigh = winDecTemp.addrWin.baseHigh;
winDec1.addrWin.baseLow = winDecTemp.addrWin.baseLow;
winDec1.addrWin.size = winDecTemp.addrWin.size;
winDec1.enable = winDecTemp.enable;
winDec1.target = winDecTemp.target;
/* now set the new values */
mvAhbToMbusWinSet(winNum1,&winDec1);
mvAhbToMbusWinSet(winNum2,&winDec2);
/* now we will treat the remap windows if exist */
/* now check if one or both windows has a remap window
as well after the swap ! */
/* if a window had a remap value differnt than the base value
before the swap , then after the swap the remap value will be
equal to the base value unless both windows has a remap windows*/
/* first get old values */
if (MV_NO_SUCH != ahbToMbusRemapRegOffsGet(winNum1,&remapRegs1))
{
remapBaseLow1 = MV_REG_READ(remapRegs1.lowRegOffs);
remapBaseHigh1 = MV_REG_READ(remapRegs1.highRegOffs);
}
if (MV_NO_SUCH != ahbToMbusRemapRegOffsGet(winNum2,&remapRegs2))
{
remapBaseLow2 = MV_REG_READ(remapRegs2.lowRegOffs);
remapBaseHigh2 = MV_REG_READ(remapRegs2.highRegOffs);
}
/* now do the swap */
if (MV_NO_SUCH != ahbToMbusRemapRegOffsGet(winNum1,&remapRegs1))
{
if (MV_NO_SUCH != ahbToMbusRemapRegOffsGet(winNum2,&remapRegs2))
{
/* Two windows has a remap !!! so swap */
MV_REG_WRITE(remapRegs2.highRegOffs,remapBaseHigh1);
MV_REG_WRITE(remapRegs2.lowRegOffs,remapBaseLow1);
MV_REG_WRITE(remapRegs1.highRegOffs,remapBaseHigh2);
MV_REG_WRITE(remapRegs1.lowRegOffs,remapBaseLow2);
}
else
{
/* remap == base */
MV_REG_WRITE(remapRegs1.highRegOffs,winDec1.addrWin.baseHigh);
MV_REG_WRITE(remapRegs1.lowRegOffs,winDec1.addrWin.baseLow);
}
}
else if (MV_NO_SUCH != ahbToMbusRemapRegOffsGet(winNum2,&remapRegs2))
{
/* remap == base */
MV_REG_WRITE(remapRegs2.highRegOffs,winDec2.addrWin.baseHigh);
MV_REG_WRITE(remapRegs2.lowRegOffs,winDec2.addrWin.baseLow);
}
return MV_OK;
}
/*******************************************************************************
* mvAhbToMbusWinSet - Set CPU-to-peripheral winNum address window
*
* DESCRIPTION:
* This function sets
* address window, also known as address decode window.
* A new address decode window is set for specified winNum address window.
* If address decode window parameter structure enables the window,
* the routine will also enable the winNum window, allowing CPU to access
* the winNum window.
*
* INPUT:
* winNum - Windows number.
* pAddrDecWin - CPU winNum window data structure.
*
* OUTPUT:
* N/A
*
* RETURN:
* MV_OK if CPU winNum window was set correctly, MV_ERROR in case of
* address window overlapps with other active CPU winNum window or
* trying to assign 36bit base address while CPU does not support that.
* The function returns MV_NOT_SUPPORTED, if the winNum is unsupported.
*
*******************************************************************************/
MV_STATUS mvAhbToMbusWinSet(MV_U32 winNum, MV_AHB_TO_MBUS_DEC_WIN *pAddrDecWin)
{
MV_TARGET_ATTRIB targetAttribs;
MV_DEC_REGS decRegs;
/* Parameter checking */
if (winNum >= MAX_AHB_TO_MBUS_WINS)
{
mvOsPrintf("mvAhbToMbusWinSet: ERR. Invalid winNum %d\n", winNum);
return MV_NOT_SUPPORTED;
}
/* read base register*/
if (winNum != MV_AHB_TO_MBUS_INTREG_WIN)
{
decRegs.baseReg = MV_REG_READ(AHB_TO_MBUS_WIN_BASE_REG(winNum));
}
else
{
decRegs.baseReg = MV_REG_READ(AHB_TO_MBUS_WIN_INTEREG_REG);
}
/* check if address is aligned to the size */
if(MV_IS_NOT_ALIGN(pAddrDecWin->addrWin.baseLow, pAddrDecWin->addrWin.size))
{
mvOsPrintf("mvAhbToMbusWinSet:Error setting AHB to MBUS window %d to "\
"target %s.\nAddress 0x%08x is unaligned to size 0x%x.\n",
winNum,
mvCtrlTargetNameGet(pAddrDecWin->target),
pAddrDecWin->addrWin.baseLow,
pAddrDecWin->addrWin.size);
return MV_ERROR;
}
/* read control register*/
if (winNum != MV_AHB_TO_MBUS_INTREG_WIN)
{
decRegs.sizeReg = MV_REG_READ(AHB_TO_MBUS_WIN_CTRL_REG(winNum));
}
if (MV_OK != mvCtrlAddrDecToReg(&(pAddrDecWin->addrWin),&decRegs))
{
mvOsPrintf("mvAhbToMbusWinSet:mvCtrlAddrDecToReg Failed\n");
return MV_ERROR;
}
/* enable\Disable */
if (MV_TRUE == pAddrDecWin->enable)
{
decRegs.sizeReg |= ATMWCR_WIN_ENABLE;
}
else
{
decRegs.sizeReg &= ~ATMWCR_WIN_ENABLE;
}
mvCtrlAttribGet(pAddrDecWin->target,&targetAttribs);
/* set attributes */
decRegs.sizeReg &= ~ATMWCR_WIN_ATTR_MASK;
decRegs.sizeReg |= targetAttribs.attrib << ATMWCR_WIN_ATTR_OFFS;
/* set target ID */
decRegs.sizeReg &= ~ATMWCR_WIN_TARGET_MASK;
decRegs.sizeReg |= targetAttribs.targetId << ATMWCR_WIN_TARGET_OFFS;
#if !defined(MV_RUN_FROM_FLASH)
/* To be on the safe side we disable the window before writing the */
/* new values. */
if (winNum != MV_AHB_TO_MBUS_INTREG_WIN)
{
mvAhbToMbusWinEnable(winNum,MV_FALSE);
}
#endif
/* 3) Write to address decode Base Address Register */
if (winNum != MV_AHB_TO_MBUS_INTREG_WIN)
{
MV_REG_WRITE(AHB_TO_MBUS_WIN_BASE_REG(winNum), decRegs.baseReg);
}
else
{
MV_REG_WRITE(AHB_TO_MBUS_WIN_INTEREG_REG, decRegs.baseReg);
}
/* Internal register space have no size */
/* register. Do not perform size register assigment for those targets */
if (winNum != MV_AHB_TO_MBUS_INTREG_WIN)
{
/* Write to address decode Size Register */
MV_REG_WRITE(AHB_TO_MBUS_WIN_CTRL_REG(winNum), decRegs.sizeReg);
}
return MV_OK;
}
/*******************************************************************************
* mvAhbToMbusWinSet - Set CPU-to-peripheral winNum address window
*
* DESCRIPTION:
* This function sets
* address window, also known as address decode window.
* A new address decode window is set for specified winNum address window.
* If address decode window parameter structure enables the window,
* the routine will also enable the winNum window, allowing CPU to access
* the winNum window.
*
* INPUT:
* winNum - Windows number.
* pAddrDecWin - CPU winNum window data structure.
*
* OUTPUT:
* N/A
*
* RETURN:
* MV_OK if CPU winNum window was set correctly, MV_ERROR in case of
* address window overlapps with other active CPU winNum window or
* trying to assign 36bit base address while CPU does not support that.
* The function returns MV_NOT_SUPPORTED, if the winNum is unsupported.
*
*******************************************************************************/
MV_STATUS mvAhbToMbusWinSet(MV_U32 winNum, MV_AHB_TO_MBUS_DEC_WIN *pAddrDecWin)
{
MV_TARGET_ATTRIB targetAttribs;
MV_DEC_REGS decRegs;
MV_U32 sizeToReg;
/* Parameter checking */
if (winNum >= MAX_AHB_TO_MBUS_WINS) {
mvOsPrintf("mvAhbToMbusWinSet: ERR. Invalid winNum %d\n", winNum);
return MV_NOT_SUPPORTED;
}
/* check if address is aligned to the size */
if (MV_IS_NOT_ALIGN(pAddrDecWin->addrWin.baseLow, pAddrDecWin->addrWin.size)) {
mvOsPrintf("mvAhbToMbusWinSet:Error setting AHB to MBUS window %d to "
"target %s.\nAddress 0x%08x is unaligned to size 0x%llx.\n",
winNum,
mvCtrlTargetNameGet(pAddrDecWin->target),
pAddrDecWin->addrWin.baseLow, pAddrDecWin->addrWin.size);
return MV_ERROR;
}
/* Size parameter validity check. */
if (MV_IS_NOT_ALIGN(pAddrDecWin->addrWin.size, ATMWCR_WIN_SIZE_ALIGNMENT)) {
mvOsPrintf("mvAhbToMbusWinSet: Failed, size not aligned to 0x%x.\n", ATMWCR_WIN_SIZE_ALIGNMENT);
return MV_BAD_PARAM;
}
/* Write to address decode Base Address Register */
decRegs.baseReg = (pAddrDecWin->addrWin.baseLow & ATMWBR_BASE_MASK);
/* Get size register value according to window size */
sizeToReg = (pAddrDecWin->addrWin.size / ATMWCR_WIN_SIZE_ALIGNMENT) - 1;
/* set size */
decRegs.ctrlReg = (sizeToReg << ATMWCR_WIN_SIZE_OFFS);
/* enable\Disable */
if (MV_TRUE == pAddrDecWin->enable)
decRegs.ctrlReg |= ATMWCR_WIN_ENABLE;
else
decRegs.ctrlReg &= ~ATMWCR_WIN_ENABLE;
mvCtrlAttribGet(pAddrDecWin->target, &targetAttribs);
/* set attributes */
decRegs.ctrlReg &= ~ATMWCR_WIN_ATTR_MASK;
decRegs.ctrlReg |= targetAttribs.attrib << ATMWCR_WIN_ATTR_OFFS;
/* set target ID */
decRegs.ctrlReg &= ~ATMWCR_WIN_TARGET_MASK;
decRegs.ctrlReg |= targetAttribs.targetId << ATMWCR_WIN_TARGET_OFFS;
#if !defined(MV_RUN_FROM_FLASH)
/* To be on the safe side we disable the window before writing the */
/* new values. */
if (winNum != MV_AHB_TO_MBUS_INTREG_WIN)
mvAhbToMbusWinEnable(winNum, MV_FALSE);
#endif
/* 3) Write to address decode Base Address Register */
if (winNum != MV_AHB_TO_MBUS_INTREG_WIN)
MV_REG_WRITE(AHB_TO_MBUS_WIN_BASE_REG(winNum), decRegs.baseReg);
else
MV_REG_WRITE(AHB_TO_MBUS_WIN_INTEREG_REG, decRegs.baseReg);
/* Internal register space have no size */
/* register. Do not perform size register assigment for those targets */
if (winNum != MV_AHB_TO_MBUS_INTREG_WIN) {
/* Write to address decode Size Register */
MV_REG_WRITE(AHB_TO_MBUS_WIN_CTRL_REG(winNum), decRegs.ctrlReg);
}
return MV_OK;
}
/*******************************************************************************
* mvCpuIfInit - Initialize Controller CPU interface
*
* DESCRIPTION:
* This function initialize Controller CPU interface:
* 1. Set CPU interface configuration registers.
* 2. Set CPU master Pizza arbiter control according to static
* configuration described in configuration file.
* 3. Opens CPU address decode windows. DRAM windows are assumed to be
* already set (auto detection).
*
* INPUT:
* None.
*
* OUTPUT:
* None.
*
* RETURN:
* None.
*
*******************************************************************************/
MV_STATUS mvCpuIfInit(MV_CPU_DEC_WIN *cpuAddrWinMap)
{
MV_U32 regVal, i;
MV_TARGET target;
MV_ADDR_WIN addrWin;
if (cpuAddrWinMap == NULL) {
DB(mvOsPrintf("mvCpuIfInit:ERR. cpuAddrWinMap == NULL\n"));
return MV_ERROR;
}
/* Set CPU Configuration register */
regVal = MV_REG_READ(CPU_CONFIG_REG);
regVal &= ~CPU_CONFIG_DEFAULT_MASK;
regVal |= CPU_CONFIG_DEFAULT;
MV_REG_WRITE(CPU_CONFIG_REG, regVal);
for (i = 0; i < MAX_AHB_TO_MBUS_WINS-1; i++)
mvAhbToMbusWinEnable(i, MV_FALSE);
/* Disable all SRAM windows */
mvCpuIfSramWinDisable();
/* First disable all CPU target windows */
for (target = 0; cpuAddrWinMap[target].enable != TBL_TERM; target++) {
if ((MV_TARGET_IS_DRAM(target)) || (target == INTER_REGS))
continue;
#if defined(MV_MEM_OVER_PEX_WA) || defined(MV_UART_OVER_PEX_WA)
/* If the target PEX or PCI and memory is over PEX or PCI we don't touch this CPU windows */
if (MV_TARGET_IS_PEX(target))
continue;
#endif
#if defined(MV_RUN_FROM_FLASH)
/* Don't disable the boot device. */
if (target == DEV_BOOCS)
continue;
#endif /* MV_RUN_FROM_FLASH */
mvCpuIfTargetWinEnable(MV_CHANGE_BOOT_CS(target), MV_FALSE);
}
#if defined(MV_RUN_FROM_FLASH)
/* Resize the bootcs windows before other windows, because this */
/* window is enabled and will cause an overlap if not resized. */
target = DEV_BOOCS;
if (MV_OK != mvCpuIfTargetWinSet(target, &cpuAddrWinMap[target])) {
DB(mvOsPrintf("mvCpuIfInit:ERR. mvCpuIfTargetWinSet fail\n"));
return MV_ERROR;
}
addrWin.baseLow = cpuAddrWinMap[target].addrWin.baseLow;
addrWin.baseHigh = cpuAddrWinMap[target].addrWin.baseHigh;
if (0xffffffff == mvAhbToMbusWinRemap(cpuAddrWinMap[target].winNum, &addrWin)) {
DB(mvOsPrintf("mvCpuIfInit:WARN. mvAhbToMbusWinRemap can't remap winNum=%d\n",
cpuAddrWinMap[target].winNum));
}
#endif /* MV_RUN_FROM_FLASH */
/* Go through all targets in user table until table terminator */
for (target = 0; cpuAddrWinMap[target].enable != TBL_TERM; target++) {
#if defined(MV_RUN_FROM_FLASH)
if (target == DEV_BOOCS)
continue;
#endif /* MV_RUN_FROM_FLASH */
/* if DRAM auto sizing is used do not initialized DRAM target windows, */
/* assuming this already has been done earlier. */
#ifdef MV_DRAM_AUTO_SIZE
if (MV_TARGET_IS_DRAM(target))
continue;
#endif
#if defined(MV_MEM_OVER_PEX_WA) || defined(MV_UART_OVER_PEX_WA)
/* If the target PEX or PCI and memory is over PEX or PCI we don't touch this CPU windows */
if (MV_TARGET_IS_PEX(target))
continue;
#endif
if ((0 == cpuAddrWinMap[target].addrWin.size) || (DIS == cpuAddrWinMap[target].enable)) {
if (MV_OK != mvCpuIfTargetWinEnable(target, MV_FALSE)) {
DB(mvOsPrintf("mvCpuIfInit:ERR. mvCpuIfTargetWinEnable fail\n"));
return MV_ERROR;
}
} else {
if (MV_OK != mvCpuIfTargetWinSet(target, &cpuAddrWinMap[target])) {
DB(mvOsPrintf("mvCpuIfInit:ERR. mvCpuIfTargetWinSet fail\n"));
return MV_ERROR;
}
addrWin.baseLow = cpuAddrWinMap[target].addrWin.baseLow;
addrWin.baseHigh = cpuAddrWinMap[target].addrWin.baseHigh;
if (0xffffffff == mvAhbToMbusWinRemap(cpuAddrWinMap[target].winNum, &addrWin)) {
DB(mvOsPrintf("mvCpuIfInit:WARN. mvAhbToMbusWinRemap can't remap winNum=%d\n",
cpuAddrWinMap[target].winNum));
}
}
}
return MV_OK;
}
