MV_STATUS mvCtrlParamsToAddrDec(MV_DEC_WIN_PARAMS *pWinParam,
MV_DEC_WIN *pAddrDecWin)
{
MV_TARGET_ATTRIB targetAttrib;
pAddrDecWin->addrWin.baseLow = pWinParam->baseAddr;
/* Upper 32bit address base is supported under PCI High Address remap */
pAddrDecWin->addrWin.baseHigh = 0;
/* Prepare sizeReg to ctrlRegToSize function */
pAddrDecWin->addrWin.size = ctrlRegToSize(pWinParam->size, CTRL_DEC_SIZE_ALIGNMENT);
if (-1 == pAddrDecWin->addrWin.size)
{
DB(mvOsPrintf("mvCtrlParamsToAddrDec: ERR. ctrlRegToSize failed.\n"));
return MV_BAD_PARAM;
}
targetAttrib.targetId = pWinParam->targetId;
targetAttrib.attrib = pWinParam->attrib;
pAddrDecWin->target = mvCtrlTargetGet(&targetAttrib);
return MV_OK;
}
/*******************************************************************************
* mvAhbToMbusWinGet - Get CPU-to-peripheral winNum address window
*
* DESCRIPTION:
* Get the CPU peripheral winNum address window.
*
* INPUT:
* winNum - Peripheral winNum enumerator
*
* OUTPUT:
* pAddrDecWin - CPU winNum window information data structure.
*
* RETURN:
* MV_OK if winNum exist, MV_ERROR otherwise.
*
*******************************************************************************/
MV_STATUS mvAhbToMbusWinGet(MV_U32 winNum, MV_AHB_TO_MBUS_DEC_WIN *pAddrDecWin)
{
MV_DEC_REGS decRegs;
MV_TARGET_ATTRIB targetAttrib;
MV_U32 sizeRegVal;
/* Parameter checking */
if (winNum >= MAX_AHB_TO_MBUS_WINS) {
mvOsPrintf("mvAhbToMbusWinGet: ERR. Invalid winNum %d\n", winNum);
return MV_NOT_SUPPORTED;
}
/* Internal register space size have no size register */
if (winNum != MV_AHB_TO_MBUS_INTREG_WIN)
decRegs.ctrlReg = MV_REG_READ(AHB_TO_MBUS_WIN_CTRL_REG(winNum));
else
decRegs.ctrlReg = 0;
/* Read base and size */
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);
pAddrDecWin->addrWin.baseHigh = 0;
pAddrDecWin->addrWin.baseLow = decRegs.baseReg & ATMWBR_BASE_MASK;
sizeRegVal = (decRegs.ctrlReg & ATMWCR_WIN_SIZE_MASK) >> ATMWCR_WIN_SIZE_OFFS;
pAddrDecWin->addrWin.size = (sizeRegVal + 1) * ATMWCR_WIN_SIZE_ALIGNMENT;
if (winNum == MV_AHB_TO_MBUS_INTREG_WIN) {
pAddrDecWin->addrWin.size = INTER_REGS_SIZE;
pAddrDecWin->target = INTER_REGS;
pAddrDecWin->enable = MV_TRUE;
return MV_OK;
}
if (decRegs.ctrlReg & ATMWCR_WIN_ENABLE)
pAddrDecWin->enable = MV_TRUE;
else
pAddrDecWin->enable = MV_FALSE;
if (-1 == pAddrDecWin->addrWin.size)
return MV_ERROR;
/* attrib and targetId */
targetAttrib.attrib = (decRegs.ctrlReg & ATMWCR_WIN_ATTR_MASK) >> ATMWCR_WIN_ATTR_OFFS;
targetAttrib.targetId = (decRegs.ctrlReg & ATMWCR_WIN_TARGET_MASK) >> ATMWCR_WIN_TARGET_OFFS;
pAddrDecWin->target = mvCtrlTargetGet(&targetAttrib);
return MV_OK;
}
/*******************************************************************************
* mvDmaWinGet - Get dma peripheral target address window.
*
* DESCRIPTION:
* Get IDMA peripheral target address window.
*
* INPUT:
* winNum - IDMA to target address decode window number.
*
* OUTPUT:
* pAddrDecWin - IDMA target window data structure.
*
* RETURN:
* MV_ERROR if register parameters are invalid.
*
*******************************************************************************/
MV_STATUS mvDmaWinGet(MV_U32 winNum, MV_DMA_DEC_WIN *pAddrDecWin)
{
MV_DEC_REGS decRegs;
MV_TARGET_ATTRIB targetAttrib;
/* Parameter checking */
if (winNum >= IDMA_MAX_ADDR_DEC_WIN)
{
mvOsPrintf("mvDmaWinGet: ERR. Invalid winNum %d\n", winNum);
return MV_NOT_SUPPORTED;
}
decRegs.baseReg = MV_REG_READ(IDMA_BASE_ADDR_REG(winNum));
decRegs.sizeReg = MV_REG_READ(IDMA_SIZE_REG(winNum));
if (MV_OK != mvCtrlRegToAddrDec(&decRegs,&(pAddrDecWin->addrWin)))
{
mvOsPrintf("mvDmaWinGet: mvCtrlRegToAddrDec Failed \n");
return MV_ERROR;
}
/* attrib and targetId */
targetAttrib.attrib =
(decRegs.baseReg & IDMA_WIN_ATTR_MASK) >> IDMA_WIN_ATTR_OFFS;
targetAttrib.targetId =
(decRegs.baseReg & IDMA_WIN_TARGET_MASK) >> IDMA_WIN_TARGET_OFFS;
pAddrDecWin->target = mvCtrlTargetGet(&targetAttrib);
/* Check if window is enabled */
if (~(MV_REG_READ(IDMA_BASE_ADDR_ENABLE_REG)) & (IBAER_ENABLE(winNum)))
{
pAddrDecWin->enable = MV_TRUE;
}
else
{
pAddrDecWin->enable = MV_FALSE;
}
return MV_OK;
}
/*******************************************************************************
* mvTsuWinGet
*
* DESCRIPTION:
* Get TSU peripheral target address window.
*
* INPUT:
* winNum - TSU to target address decode window number.
*
* OUTPUT:
* pAddrDecWin - TSU target window data structure.
*
* RETURN:
* MV_ERROR if register parameters are invalid.
*
*******************************************************************************/
MV_STATUS mvTsuWinGet(MV_U32 winNum, MV_TSU_DEC_WIN *pAddrDecWin)
{
MV_DEC_REGS decRegs;
MV_TARGET_ATTRIB targetAttrib;
/* Parameter checking */
if(winNum >= TSU_MAX_DECODE_WIN)
{
mvOsPrintf("mvTsuWinGet: ERR. Invalid winNum %d\n", winNum);
return MV_NOT_SUPPORTED;
}
decRegs.baseReg = MV_REG_READ(MV_TSU_WIN_BASE_REG(winNum));
decRegs.sizeReg = MV_REG_READ(MV_TSU_WIN_CTRL_REG(winNum));
if(MV_OK != mvCtrlRegToAddrDec(&decRegs,&(pAddrDecWin->addrWin)))
{
mvOsPrintf("mvTsuWinGet: mvCtrlRegToAddrDec Failed \n");
return MV_ERROR;
}
/* attrib and targetId */
targetAttrib.attrib =
(decRegs.sizeReg & TSU_WIN_CTRL_ATTR_MASK) >> TSU_WIN_CTRL_ATTR_OFFS;
targetAttrib.targetId =
(decRegs.sizeReg & TSU_WIN_CTRL_TARGET_MASK) >> TSU_WIN_CTRL_TARGET_OFFS;
pAddrDecWin->target = mvCtrlTargetGet(&targetAttrib);
/* Check if window is enabled */
if((MV_REG_READ(MV_TSU_WIN_CTRL_REG(winNum)) & TSU_WIN_CTRL_EN_MASK))
{
pAddrDecWin->enable = MV_TRUE;
}
else
{
pAddrDecWin->enable = MV_FALSE;
}
return MV_OK;
}
/*******************************************************************************
* mvSdmmcWinGet - Get SDMMC peripheral target address window.
*
* DESCRIPTION:
* Get SDMMC peripheral target address window.
*
* INPUT:
* winNum - SDMMC target address decode window number.
*d
* OUTPUT:
* pAddrDecWin - SDMMC target window data structure.
*
* RETURN:
* MV_ERROR if register parameters are invalid.
*
*******************************************************************************/
MV_STATUS mvSdmmcWinGet(int dev, MV_U32 winNum, MV_SDMMC_DEC_WIN *pAddrDecWin)
{
MV_DEC_REGS decRegs;
MV_TARGET_ATTRIB targetAttrib;
/* Parameter checking */
if (winNum >= MV_SDMMC_MAX_ADDR_DECODE_WIN)
{
mvOsPrintf("%s (dev=%d): ERR. Invalid winNum %d\n",
__FUNCTION__, dev, winNum);
return MV_NOT_SUPPORTED;
}
decRegs.baseReg = MV_REG_READ( MV_SDMMC_WIN_BASE_REG(dev, winNum) );
decRegs.sizeReg = MV_REG_READ( MV_SDMMC_WIN_CTRL_REG(dev, winNum) );
if (MV_OK != mvCtrlRegToAddrDec(&decRegs, &pAddrDecWin->addrWin) )
{
mvOsPrintf("%s: mvCtrlRegToAddrDec Failed\n", __FUNCTION__);
return MV_ERROR;
}
/* attrib and targetId */
targetAttrib.attrib = (decRegs.sizeReg & MV_SDMMC_WIN_ATTR_MASK) >>
MV_SDMMC_WIN_ATTR_OFFSET;
targetAttrib.targetId = (decRegs.sizeReg & MV_SDMMC_WIN_TARGET_MASK) >>
MV_SDMMC_WIN_TARGET_OFFSET;
pAddrDecWin->target = mvCtrlTargetGet(&targetAttrib);
/* Check if window is enabled */
if(decRegs.sizeReg & MV_SDMMC_WIN_ENABLE_MASK)
{
pAddrDecWin->enable = MV_TRUE;
}
else
{
pAddrDecWin->enable = MV_FALSE;
}
return MV_OK;
}
/*******************************************************************************
* mvXorTargetWinGet - Get xor peripheral target address window.
*
* DESCRIPTION:
* Get xor peripheral target address window.
*
* INPUT:
* winNum - One of the possible XOR memory decode windows.
*
* OUTPUT:
* base - Window base address.
* size - Window size.
* enable - window enable/disable.
*
* RETURN:
* MV_BAD_PARAM if parameters to function invalid, MV_OK otherwise.
*
*******************************************************************************/
MV_STATUS mvXorTargetWinGet(MV_U32 unit,MV_U32 winNum, MV_XOR_DEC_WIN *pAddrDecWin)
{
MV_DEC_REGS xorDecRegs;
MV_TARGET_ATTRIB targetAttrib;
MV_U32 chan=0,chanWinEn;
/* Parameter checking */
if (winNum >= XOR_MAX_ADDR_DEC_WIN)
{
DB(mvOsPrintf("%s: ERR. Invalid win num %d\n",__FUNCTION__ , winNum));
return MV_ERROR;
}
if (NULL == pAddrDecWin)
{
DB(mvOsPrintf("%s: ERR. pAddrDecWin is NULL pointer\n", __FUNCTION__ ));
return MV_BAD_PTR;
}
chanWinEn = MV_REG_READ(XOR_WINDOW_CTRL_REG(unit,0)) & XEXWCR_WIN_EN_MASK(winNum);
for (chan = 0; chan < MV_XOR_MAX_CHAN_PER_UNIT; chan++)
{
/* Check if enable bit is equal for all channels */
if ((MV_REG_READ(XOR_WINDOW_CTRL_REG(unit,chan)) &
XEXWCR_WIN_EN_MASK(winNum)) != chanWinEn)
{
mvOsPrintf("%s: ERR. Window enable field must be equal in "
"all channels\n",__FUNCTION__);
return MV_ERROR;
}
}
xorDecRegs.baseReg = MV_REG_READ(XOR_BASE_ADDR_REG(unit,winNum));
xorDecRegs.sizeReg = MV_REG_READ(XOR_SIZE_MASK_REG(unit,winNum));
if (MV_OK != mvCtrlRegToAddrDec(&xorDecRegs, &pAddrDecWin->addrWin))
{
mvOsPrintf("%s: ERR. mvCtrlRegToAddrDec failed\n", __FUNCTION__);
return MV_ERROR;
}
/* attrib and targetId */
targetAttrib.attrib =
(xorDecRegs.baseReg & XEBARX_ATTR_MASK) >> XEBARX_ATTR_OFFS;
targetAttrib.targetId =
(xorDecRegs.baseReg & XEBARX_TARGET_MASK) >> XEBARX_TARGET_OFFS;
pAddrDecWin->target = mvCtrlTargetGet(&targetAttrib);
if(chanWinEn)
{
pAddrDecWin->enable = MV_TRUE;
}
else pAddrDecWin->enable = MV_FALSE;
return MV_OK;
}
/*******************************************************************************
* mvAhbToMbusWinGet - Get CPU-to-peripheral winNum address window
*
* DESCRIPTION:
* Get the CPU peripheral winNum address window.
*
* INPUT:
* winNum - Peripheral winNum enumerator
*
* OUTPUT:
* pAddrDecWin - CPU winNum window information data structure.
*
* RETURN:
* MV_OK if winNum exist, MV_ERROR otherwise.
*
*******************************************************************************/
MV_STATUS mvAhbToMbusWinGet(MV_U32 winNum, MV_AHB_TO_MBUS_DEC_WIN *pAddrDecWin)
{
MV_DEC_REGS decRegs;
MV_TARGET_ATTRIB targetAttrib;
/* Parameter checking */
if (winNum >= MAX_AHB_TO_MBUS_WINS)
{
mvOsPrintf("mvAhbToMbusWinGet: ERR. Invalid winNum %d\n", winNum);
return MV_NOT_SUPPORTED;
}
/* Internal register space size have no size register*/
if (winNum != MV_AHB_TO_MBUS_INTREG_WIN)
{
decRegs.sizeReg = MV_REG_READ(AHB_TO_MBUS_WIN_CTRL_REG(winNum));
}
else
{
decRegs.sizeReg = 0;
}
/* Read base and size */
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);
}
if (MV_OK != mvCtrlRegToAddrDec(&decRegs,&(pAddrDecWin->addrWin)))
{
mvOsPrintf("mvAhbToMbusWinGet: mvCtrlRegToAddrDec Failed \n");
return MV_ERROR;
}
if (winNum == MV_AHB_TO_MBUS_INTREG_WIN)
{
pAddrDecWin->addrWin.size = INTER_REGS_SIZE;
pAddrDecWin->target = INTER_REGS;
pAddrDecWin->enable = MV_TRUE;
return MV_OK;
}
if (decRegs.sizeReg & ATMWCR_WIN_ENABLE)
{
pAddrDecWin->enable = MV_TRUE;
}
else
{
pAddrDecWin->enable = MV_FALSE;
}
if (-1 == pAddrDecWin->addrWin.size)
{
return MV_ERROR;
}
/* attrib and targetId */
targetAttrib.attrib = (decRegs.sizeReg & ATMWCR_WIN_ATTR_MASK) >>
ATMWCR_WIN_ATTR_OFFS;
targetAttrib.targetId = (decRegs.sizeReg & ATMWCR_WIN_TARGET_MASK) >>
ATMWCR_WIN_TARGET_OFFS;
pAddrDecWin->target = mvCtrlTargetGet(&targetAttrib);
return MV_OK;
}
/*******************************************************************************
* mvPexTargetWinGet - Get PEX to peripheral target address window
*
* DESCRIPTION:
* Get the PEX to peripheral target address window BAR.
*
* INPUT:
* pexIf - PEX interface number.
* bar - BAR to be accessed by slave.
*
* OUTPUT:
* pAddrBarWin - PEX target window information data structure.
*
* RETURN:
* MV_BAD_PARAM for bad parameters ,MV_ERROR on error ! otherwise MV_OK
*
*******************************************************************************/
MV_STATUS mvPexTargetWinGet(MV_U32 pexIf, MV_U32 winNum,
MV_PEX_DEC_WIN *pAddrDecWin)
{
MV_TARGET_ATTRIB targetAttrib;
MV_DEC_REGS decRegs;
PEX_WIN_REG_INFO winRegInfo;
/* Parameter checking */
if(pexIf >= mvCtrlPexMaxIfGet())
{
mvOsPrintf("mvPexTargetWinGet: ERR. Invalid PEX interface %d\n", pexIf);
return MV_BAD_PARAM;
}
if (winNum >= PEX_MAX_TARGET_WIN)
{
mvOsPrintf("mvPexTargetWinGet: ERR. Invalid PEX winNum %d\n", winNum);
return MV_BAD_PARAM;
}
/* get the pex Window registers offsets */
pexWinRegInfoGet(pexIf,winNum,&winRegInfo);
/* read base register*/
if (winRegInfo.baseLowRegOffs)
{
decRegs.baseReg = MV_REG_READ(winRegInfo.baseLowRegOffs);
}
else
{
decRegs.baseReg = 0;
}
/* read size reg */
if (winRegInfo.sizeRegOffs)
{
decRegs.sizeReg = MV_REG_READ(winRegInfo.sizeRegOffs);
}
else
{
decRegs.sizeReg =0;
}
if (MV_OK != mvCtrlRegToAddrDec(&decRegs,&(pAddrDecWin->addrWin)))
{
mvOsPrintf("mvPexTargetWinGet: mvCtrlRegToAddrDec Failed \n");
return MV_ERROR;
}
if (decRegs.sizeReg & PXWCR_WIN_EN)
{
pAddrDecWin->enable = MV_TRUE;
}
else
{
pAddrDecWin->enable = MV_FALSE;
}
#if 0
if (-1 == pAddrDecWin->addrWin.size)
{
return MV_ERROR;
}
#endif
/* get target bar */
if ((decRegs.sizeReg & PXWCR_WIN_BAR_MAP_MASK) == PXWCR_WIN_BAR_MAP_BAR1 )
{
pAddrDecWin->targetBar = 1;
}
else if ((decRegs.sizeReg & PXWCR_WIN_BAR_MAP_MASK) ==
PXWCR_WIN_BAR_MAP_BAR2 )
{
pAddrDecWin->targetBar = 2;
}
/* attrib and targetId */
pAddrDecWin->attrib = (decRegs.sizeReg & PXWCR_ATTRIB_MASK) >>
PXWCR_ATTRIB_OFFS;
pAddrDecWin->targetId = (decRegs.sizeReg & PXWCR_TARGET_MASK) >>
PXWCR_TARGET_OFFS;
targetAttrib.attrib = pAddrDecWin->attrib;
targetAttrib.targetId = pAddrDecWin->targetId;
pAddrDecWin->target = mvCtrlTargetGet(&targetAttrib);
return MV_OK;
}
