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;
}
