/******************************************************************************* * mvCpuIfDramInit - Initialize Controller DRAM Fastpath windows * * DESCRIPTION: * This function initialize Controller DRAM Fastpath windows * It takes the CS size information from the 0x1500 scratch registers * and sets the correct windows sizes and base addresses accordingly * INPUT: * None. * * OUTPUT: * None. * * RETURN: * None. * *******************************************************************************/ MV_STATUS mvCpuIfDramInit() { MV_U32 base = 0; MV_U32 size, cs, temp; for (cs = 0; cs < SDRAM_MAX_CS; cs++) { size = MV_REG_READ(SDRAM_SIZE_REG(cs)) & SDRAM_ADDR_MASK; if (size > 0 && base < SDRAM_MAX_ADDR) { size |= ~(SDRAM_ADDR_MASK); /* Set Base Address */ MV_REG_WRITE(SDRAM_WIN_BASE_REG(cs), (base & SDRAM_ADDR_MASK)); /* Check if out of max window size and resize the window */ if (base+size > SDRAM_MAX_ADDR) { size = SDRAM_MAX_ADDR - base - 1; MV_REG_WRITE(SDRAM_SIZE_REG(cs), 0); } temp = (MV_REG_READ(SDRAM_WIN_CTRL_REG(cs)) & ~(SDRAM_ADDR_MASK)) | (1<<SDRAM_WIN_CTRL_WIN_ENA_OFFS); temp |= (size & SDRAM_ADDR_MASK); MV_REG_WRITE(SDRAM_WIN_CTRL_REG(cs), temp); base += (size + 1); } } return MV_OK; }
/******************************************************************************* * mvDramIfWinEnable - Enable/Disable SDRAM address decode window * * DESCRIPTION: * This function enable/Disable SDRAM address decode window. * * INPUT: * target - System target. Use only SDRAM targets. * * OUTPUT: * None. * * RETURN: * MV_ERROR in case function parameter are invalid, MV_OK otherewise. * *******************************************************************************/ MV_STATUS mvDramIfWinEnable(MV_TARGET target,MV_BOOL enable) { MV_DRAM_DEC_WIN addrDecWin; /* Check parameters */ if (!MV_TARGET_IS_DRAM(target)) { mvOsPrintf("mvDramIfWinEnable: target %d is Illigal\n", target); return MV_ERROR; } if (enable == MV_TRUE) { /* First check for overlap with other enabled windows */ if (MV_OK != mvDramIfWinGet(target, &addrDecWin)) { mvOsPrintf("mvDramIfWinEnable:ERR. Getting target %d failed.\n", target); return MV_ERROR; } /* Check for overlapping */ if (MV_FALSE == sdramIfWinOverlap(target, &(addrDecWin.addrWin))) { /* No Overlap. Enable address decode winNum window */ MV_REG_BIT_SET(SDRAM_SIZE_REG(target), SCSR_WIN_EN); } else { /* Overlap detected */ mvOsPrintf("mvDramIfWinEnable: ERR. Target %d overlap detect\n", target); return MV_ERROR; } } else { /* Disable address decode winNum window */ MV_REG_BIT_RESET(SDRAM_SIZE_REG(target), SCSR_WIN_EN); } return MV_OK; }
/******************************************************************************* * mvDramIfWinGet - Get DRAM interface address decode window * * DESCRIPTION: * This function gets DRAM interface address decode window. * * INPUT: * target - System target. Use only SDRAM targets. * * OUTPUT: * pAddrDecWin - SDRAM address window structure. * * RETURN: * MV_BAD_PARAM if parameters are invalid or window is invalid, MV_OK * otherwise. *******************************************************************************/ MV_STATUS mvDramIfWinGet(MV_TARGET target, MV_DRAM_DEC_WIN *pAddrDecWin) { MV_U32 baseReg,sizeReg; MV_U32 sizeRegVal; /* Check parameters */ if (!MV_TARGET_IS_DRAM(target)) { mvOsPrintf("mvDramIfWinGet: target %d is Illigal\n", target); return MV_ERROR; } /* Read base and size registers */ sizeReg = MV_REG_READ(SDRAM_SIZE_REG(target)); baseReg = MV_REG_READ(SDRAM_BASE_ADDR_REG(target)); sizeRegVal = (sizeReg & SCSR_SIZE_MASK) >> SCSR_SIZE_OFFS; pAddrDecWin->addrWin.size = ctrlRegToSize(sizeRegVal, SCSR_SIZE_ALIGNMENT); /* Check if ctrlRegToSize returned OK */ if (-1 == pAddrDecWin->addrWin.size) { mvOsPrintf("mvDramIfWinGet: size of target %d is Illigal\n", target); return MV_ERROR; } /* Extract base address */ /* Base register [31:16] ==> baseLow[31:16] */ pAddrDecWin->addrWin.baseLow = baseReg & SCBAR_BASE_MASK; pAddrDecWin->addrWin.baseHigh = 0; if (sizeReg & SCSR_WIN_EN) { pAddrDecWin->enable = MV_TRUE; } else { pAddrDecWin->enable = MV_FALSE; } return MV_OK; }
/******************************************************************************* * mvDramIfWinSet - Set DRAM interface address decode window * * DESCRIPTION: * This function sets DRAM interface address decode window. * * INPUT: * target - System target. Use only SDRAM targets. * pAddrDecWin - SDRAM address window structure. * * OUTPUT: * None * * RETURN: * MV_BAD_PARAM if parameters are invalid or window is invalid, MV_OK * otherwise. *******************************************************************************/ MV_STATUS mvDramIfWinSet(MV_TARGET target, MV_DRAM_DEC_WIN *pAddrDecWin) { MV_U32 baseReg=0,sizeReg=0; MV_U32 baseToReg=0 , sizeToReg=0; /* Check parameters */ if (!MV_TARGET_IS_DRAM(target)) { mvOsPrintf("mvDramIfWinSet: target %d is not SDRAM\n", target); return MV_BAD_PARAM; } /* Check if the requested window overlaps with current enabled windows */ if (MV_TRUE == sdramIfWinOverlap(target, &pAddrDecWin->addrWin)) { mvOsPrintf("mvDramIfWinSet: ERR. Target %d overlaps\n", target); return MV_BAD_PARAM; } /* check if address is aligned to the size */ if(MV_IS_NOT_ALIGN(pAddrDecWin->addrWin.baseLow, pAddrDecWin->addrWin.size)) { mvOsPrintf("mvDramIfWinSet:Error setting DRAM interface window %d."\ "\nAddress 0x%08x is unaligned to size 0x%x.\n", target, pAddrDecWin->addrWin.baseLow, pAddrDecWin->addrWin.size); return MV_ERROR; } /* read base register*/ baseReg = MV_REG_READ(SDRAM_BASE_ADDR_REG(target)); /* read size register */ sizeReg = MV_REG_READ(SDRAM_SIZE_REG(target)); /* BaseLow[31:16] => base register [31:16] */ baseToReg = pAddrDecWin->addrWin.baseLow & SCBAR_BASE_MASK; /* Write to address decode Base Address Register */ baseReg &= ~SCBAR_BASE_MASK; baseReg |= baseToReg; /* Translate the given window size to register format */ sizeToReg = ctrlSizeToReg(pAddrDecWin->addrWin.size, SCSR_SIZE_ALIGNMENT); /* Size parameter validity check. */ if (-1 == sizeToReg) { mvOsPrintf("mvCtrlAddrDecToReg: ERR. Win %d size invalid.\n",target); return MV_BAD_PARAM; } /* set size */ sizeReg &= ~SCSR_SIZE_MASK; /* Size is located at upper 16 bits */ sizeReg |= (sizeToReg << SCSR_SIZE_OFFS); /* enable/Disable */ if (MV_TRUE == pAddrDecWin->enable) { sizeReg |= SCSR_WIN_EN; } else { sizeReg &= ~SCSR_WIN_EN; } /* 3) Write to address decode Base Address Register */ MV_REG_WRITE(SDRAM_BASE_ADDR_REG(target), baseReg); /* Write to address decode Size Register */ MV_REG_WRITE(SDRAM_SIZE_REG(target), sizeReg); return MV_OK; }