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