/*******************************************************************************
* mvAudioWinInit
*
* DESCRIPTION:
* Initialize the AUDIO peripheral target address window.
*
* INPUT:
* unit : The unit number to initialize the address decoding for.
* addWinMap: An array holding the address decoding information for the
* system.
*
* OUTPUT:
* None.
*
* RETURN:
* MV_ERROR if register parameters are invalid.
*
*******************************************************************************/
MV_STATUS mvAudioWinInit(MV_U32 unit, MV_UNIT_WIN_INFO *addrWinMap)
{
MV_32 winNum;
MV_UNIT_WIN_INFO *cpuAddrDecWin;
/* Initiate Audio address decode */
/* First disable all address decode windows */
for (winNum = 0; winNum < MV_AUDIO_MAX_ADDR_DECODE_WIN; winNum++) {
MV_U32 regVal = MV_REG_READ(MV_AUDIO_WIN_CTRL_REG(unit, winNum));
regVal &= ~MV_AUDIO_WIN_ENABLE_MASK;
MV_REG_WRITE(MV_AUDIO_WIN_CTRL_REG(unit, winNum), regVal);
}
for (winNum = 0; winNum < MV_AUDIO_MAX_ADDR_DECODE_WIN; winNum++) {
/* We will set the Window to DRAM_CS0 in default */
/* first get attributes from CPU If */
cpuAddrDecWin = &addrWinMap[SDRAM_CS0];
if (cpuAddrDecWin->enable == MV_TRUE) {
if (MV_OK != mvAudioWinWrite(unit, winNum, cpuAddrDecWin))
return MV_ERROR;
}
}
#ifndef MV_AUDIO_SKIP_WIN_DECODING
/* Initialize the address decoding map in the audio driver */
mvAudioSetAddDecMap(addrWinMap);
#endif
return MV_OK;
}
/*******************************************************************************
* mvAudioWinInit - Initialize the integrated AUDIO target address window.
*
* DESCRIPTION:
* Initialize the AUDIO peripheral target address window.
*
* INPUT:
*
*
* OUTPUT:
*
*
* RETURN:
* MV_ERROR if register parameters are invalid.
*
*******************************************************************************/
MV_STATUS mvAudioWinInit(int unit)
{
int winNum;
MV_AUDIO_DEC_WIN audioWin;
MV_CPU_DEC_WIN cpuAddrDecWin;
MV_U32 status;
/* Initiate Audio address decode */
/* First disable all address decode windows */
for(winNum = 0; winNum < MV_AUDIO_MAX_ADDR_DECODE_WIN; winNum++)
{
MV_U32 regVal = MV_REG_READ(MV_AUDIO_WIN_CTRL_REG(unit, winNum));
regVal &= ~MV_AUDIO_WIN_ENABLE_MASK;
MV_REG_WRITE(MV_AUDIO_WIN_CTRL_REG(unit, winNum), regVal);
}
for(winNum = 0; winNum < MV_AUDIO_MAX_ADDR_DECODE_WIN; winNum++)
{
/* We will set the Window to DRAM_CS0 in default */
/* first get attributes from CPU If */
status = mvCpuIfTargetWinGet(SDRAM_CS0, &cpuAddrDecWin);
if (MV_OK != status)
{
mvOsPrintf("%s: ERR. mvCpuIfTargetWinGet failed\n", __FUNCTION__);
return MV_ERROR;
}
if (cpuAddrDecWin.enable == MV_TRUE)
{
audioWin.addrWin.baseHigh = cpuAddrDecWin.addrWin.baseHigh;
audioWin.addrWin.baseLow = cpuAddrDecWin.addrWin.baseLow;
audioWin.addrWin.size = cpuAddrDecWin.addrWin.size;
audioWin.enable = MV_TRUE;
audioWin.target = SDRAM_CS0;
if(MV_OK != mvAudioWinSet(unit, winNum, &audioWin))
{
return MV_ERROR;
}
}
}
return MV_OK;
}
/*******************************************************************************
* mvAudioWinSet - Set AUDIO target address window
*
* DESCRIPTION:
* This function sets a peripheral target (e.g. SDRAM bank0, PCI_MEM0)
* address window, also known as address decode window.
* After setting this target window, the AUDIO will be able to access the
* target within the address window.
*
* INPUT:
* winNum - AUDIO target address decode window number.
* pAddrDecWin - AUDIO target window data structure.
*
* OUTPUT:
* None.
*
* RETURN:
* MV_ERROR if address window overlapps with other address decode windows.
* MV_BAD_PARAM if base address is invalid parameter or target is
* unknown.
*
*******************************************************************************/
MV_STATUS mvAudioWinSet(int unit, MV_U32 winNum, MV_AUDIO_DEC_WIN *pAddrDecWin)
{
MV_TARGET_ATTRIB targetAttribs;
MV_DEC_REGS decRegs;
/* Parameter checking */
if (winNum >= MV_AUDIO_MAX_ADDR_DECODE_WIN)
{
mvOsPrintf("%s: ERR. Invalid win num %d\n",__FUNCTION__, winNum);
return MV_BAD_PARAM;
}
/* check if address is aligned to the size */
if(MV_IS_NOT_ALIGN(pAddrDecWin->addrWin.baseLow, pAddrDecWin->addrWin.size))
{
mvOsPrintf("mvAudioWinSet:Error setting AUDIO 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;
}
decRegs.baseReg = 0;
decRegs.sizeReg = 0;
if (MV_OK != mvCtrlAddrDecToReg(&(pAddrDecWin->addrWin),&decRegs))
{
mvOsPrintf("%s: mvCtrlAddrDecToReg Failed\n", __FUNCTION__);
return MV_ERROR;
}
mvCtrlAttribGet(pAddrDecWin->target, &targetAttribs);
/* set attributes */
decRegs.sizeReg &= ~MV_AUDIO_WIN_ATTR_MASK;
decRegs.sizeReg |= (targetAttribs.attrib << MV_AUDIO_WIN_ATTR_OFFSET);
/* set target ID */
decRegs.sizeReg &= ~MV_AUDIO_WIN_TARGET_MASK;
decRegs.sizeReg |= (targetAttribs.targetId << MV_AUDIO_WIN_TARGET_OFFSET);
if (pAddrDecWin->enable == MV_TRUE)
{
decRegs.sizeReg |= MV_AUDIO_WIN_ENABLE_MASK;
}
else
{
decRegs.sizeReg &= ~MV_AUDIO_WIN_ENABLE_MASK;
}
MV_REG_WRITE( MV_AUDIO_WIN_CTRL_REG(unit, winNum), decRegs.sizeReg);
MV_REG_WRITE( MV_AUDIO_WIN_BASE_REG(unit, winNum), decRegs.baseReg);
return MV_OK;
}
/*******************************************************************************
* mvAudioWinWrite
*
* DESCRIPTION:
* This function writes the address decoding registers according to the
* given window configuration.
*
* INPUT:
* unit - The Audio unit number to configure.
* winNum - AUDIO target address decode window number.
* pAddrDecWin - AUDIO target window data structure.
*
* OUTPUT:
* None.
*
* RETURN:
* MV_OK on success,
* MV_BAD_PARAM if winNum is invalid.
* MV_ERROR otherwise.
*
*******************************************************************************/
MV_STATUS mvAudioWinWrite(MV_U32 unit, MV_U32 winNum, MV_UNIT_WIN_INFO *pAddrDecWin)
{
MV_U32 baseReg;
MV_U32 sizeReg;
MV_U32 size;
MV_U32 alignment;
/* Parameter checking */
if (winNum >= MV_AUDIO_MAX_ADDR_DECODE_WIN) {
mvOsPrintf("%s: ERR. Invalid win num %d\n", __func__, winNum);
return MV_BAD_PARAM;
}
/* check if address is aligned to the size */
if (MV_IS_NOT_ALIGN(pAddrDecWin->addrWin.baseLow, pAddrDecWin->addrWin.size)) {
mvOsPrintf("mvAudioWinWrite:Error setting AUDIO window %d to "
"Address 0x%08x is unaligned to size 0x%x.\n",
winNum, pAddrDecWin->addrWin.baseLow, pAddrDecWin->addrWin.size);
return MV_ERROR;
}
size = pAddrDecWin->addrWin.size;
if (!MV_IS_POWER_OF_2(size)) {
mvOsPrintf("mvAudioWinWrite: Error setting AUDIO window %d. "
"Window size is not a power to 2.", winNum);
return MV_BAD_PARAM;
}
alignment = 1 << MV_AUDIO_WIN_SIZE_OFFSET;
sizeReg = (size / alignment - 1) << MV_AUDIO_WIN_SIZE_OFFSET;
/* BaseLow[31:16] => base register [31:16] */
baseReg = pAddrDecWin->addrWin.baseLow & MV_AUDIO_WIN_BASE_MASK;
/* set attributes */
sizeReg &= ~MV_AUDIO_WIN_ATTR_MASK;
sizeReg |= (pAddrDecWin->attrib << MV_AUDIO_WIN_ATTR_OFFSET);
/* set target ID */
sizeReg &= ~MV_AUDIO_WIN_TARGET_MASK;
sizeReg |= (pAddrDecWin->targetId << MV_AUDIO_WIN_TARGET_OFFSET);
if (pAddrDecWin->enable == MV_TRUE)
sizeReg |= MV_AUDIO_WIN_ENABLE_MASK;
else
sizeReg &= ~MV_AUDIO_WIN_ENABLE_MASK;
MV_REG_WRITE(MV_AUDIO_WIN_CTRL_REG(unit, winNum), sizeReg);
MV_REG_WRITE(MV_AUDIO_WIN_BASE_REG(unit, winNum), baseReg);
return MV_OK;
}
/*******************************************************************************
* mvAudioWinGet - Get AUDIO peripheral target address window.
*
* DESCRIPTION:
* Get AUDIO peripheral target address window.
*
* INPUT:
* winNum - AUDIO target address decode window number.
*
* OUTPUT:
* pAddrDecWin - AUDIO target window data structure.
*
* RETURN:
* MV_ERROR if register parameters are invalid.
*
*******************************************************************************/
MV_STATUS mvAudioWinGet(int unit, MV_U32 winNum, MV_AUDIO_DEC_WIN *pAddrDecWin)
{
MV_DEC_REGS decRegs;
MV_TARGET_ATTRIB targetAttrib;
/* Parameter checking */
if (winNum >= MV_AUDIO_MAX_ADDR_DECODE_WIN)
{
mvOsPrintf("%s : ERR. Invalid winNum %d\n",
__FUNCTION__, winNum);
return MV_NOT_SUPPORTED;
}
decRegs.baseReg = MV_REG_READ( MV_AUDIO_WIN_BASE_REG(unit, winNum) );
decRegs.sizeReg = MV_REG_READ( MV_AUDIO_WIN_CTRL_REG(unit, 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_AUDIO_WIN_ATTR_MASK) >>
MV_AUDIO_WIN_ATTR_OFFSET;
targetAttrib.targetId = (decRegs.sizeReg & MV_AUDIO_WIN_TARGET_MASK) >>
MV_AUDIO_WIN_TARGET_OFFSET;
pAddrDecWin->target = mvCtrlTargetGet(&targetAttrib);
/* Check if window is enabled */
if(decRegs.sizeReg & MV_AUDIO_WIN_ENABLE_MASK)
{
pAddrDecWin->enable = MV_TRUE;
}
else
{
pAddrDecWin->enable = MV_FALSE;
}
return MV_OK;
}
/*******************************************************************************
* mvAudioWinRead
*
* DESCRIPTION:
* Read AUDIO peripheral target address window.
*
* INPUT:
* winNum - AUDIO target address decode window number.
*
* OUTPUT:
* pAddrDecWin - AUDIO target window data structure.
*
* RETURN:
* MV_BAD_PARAM if winNum is invalid.
* MV_ERROR otherwise.
*
*******************************************************************************/
MV_STATUS mvAudioWinRead(MV_U32 unit, MV_U32 winNum, MV_UNIT_WIN_INFO *pAddrDecWin)
{
MV_U32 baseReg, sizeReg;
MV_U32 sizeRegVal;
MV_U32 alignment;
if (winNum >= MV_AUDIO_MAX_ADDR_DECODE_WIN) {
mvOsPrintf("%s : ERR. Invalid winNum %d\n", __func__, winNum);
return MV_BAD_PARAM;
}
baseReg = MV_REG_READ(MV_AUDIO_WIN_BASE_REG(unit, winNum));
sizeReg = MV_REG_READ(MV_AUDIO_WIN_CTRL_REG(unit, winNum));
alignment = 1 << MV_AUDIO_WIN_SIZE_OFFSET;
sizeRegVal = (sizeReg & MV_AUDIO_WIN_SIZE_MASK) >> MV_AUDIO_WIN_SIZE_OFFSET;
pAddrDecWin->addrWin.size = (sizeRegVal + 1) * alignment;
/* Extract base address */
/* Base register [31:16] ==> baseLow[31:16] */
pAddrDecWin->addrWin.baseLow = baseReg & MV_AUDIO_WIN_BASE_MASK;
pAddrDecWin->addrWin.baseHigh = 0;
/* attrib and targetId */
pAddrDecWin->attrib = (sizeReg & MV_AUDIO_WIN_ATTR_MASK) >> MV_AUDIO_WIN_ATTR_OFFSET;
pAddrDecWin->targetId = (sizeReg & MV_AUDIO_WIN_TARGET_MASK) >> MV_AUDIO_WIN_TARGET_OFFSET;
/* Check if window is enabled */
if (sizeReg & MV_AUDIO_WIN_ENABLE_MASK)
pAddrDecWin->enable = MV_TRUE;
else
pAddrDecWin->enable = MV_FALSE;
return MV_OK;
}
