/******************************************************************************* * mvCpuIfPexRemap - Set CPU remap register for address windows. * * DESCRIPTION: * * INPUT: * pexTarget - Peripheral target enumerator. Must be a PEX target. * pAddrDecWin - CPU target window information data structure. * Note that caller has to fill in the base field only. The * size field is ignored. * * OUTPUT: * None. * * RETURN: * MV_ERROR if target is not a PEX one, MV_OK otherwise. * *******************************************************************************/ MV_U32 mvCpuIfPexRemap(MV_TARGET pexTarget, MV_ADDR_WIN *pAddrDecWin) { MV_U32 winNum; /* Check parameters */ if (mvCtrlPexMaxIfGet() > 1) { if ((!MV_TARGET_IS_PEX1(pexTarget))&&(!MV_TARGET_IS_PEX0(pexTarget))) { mvOsPrintf("mvCpuIfPexRemap: target %d is illegal\n",pexTarget); return 0xffffffff; } } else { if (!MV_TARGET_IS_PEX0(pexTarget)) { mvOsPrintf("mvCpuIfPexRemap: target %d is illegal\n",pexTarget); return 0xffffffff; } } /* get the Window number associated with this target */ winNum = mvAhbToMbusWinTargetGet(pexTarget); if (winNum >= MAX_AHB_TO_MBUS_WINS) { mvOsPrintf("mvCpuIfPexRemap: mvAhbToMbusWinTargetGet Failed\n"); return 0xffffffff; } return mvAhbToMbusWinRemap(winNum , pAddrDecWin); }
/******************************************************************************* * mvCpuIfTargetWinGet - Get CPU-to-peripheral target address window * * DESCRIPTION: * Get the CPU peripheral target address window. * * INPUT: * target - Peripheral target enumerator * * OUTPUT: * pAddrDecWin - CPU target window information data structure. * * RETURN: * MV_OK if target exist, MV_ERROR otherwise. * *******************************************************************************/ MV_STATUS mvCpuIfTargetWinGet(MV_TARGET target, MV_CPU_DEC_WIN *pAddrDecWin) { MV_U32 winNum=0xffffffff; MV_AHB_TO_MBUS_DEC_WIN decWin; MV_DRAM_DEC_WIN addrDecWin; target = MV_CHANGE_BOOT_CS(target); /* Check parameters */ if (target >= MAX_TARGETS) { mvOsPrintf("mvCpuIfTargetWinGet: target %d is illegal\n", target); return MV_ERROR; } if (MV_TARGET_IS_DRAM(target)) { if (mvDramIfWinGet(target,&addrDecWin) != MV_OK) { mvOsPrintf("mvCpuIfTargetWinGet: Failed to get window target %d\n", target); return MV_ERROR; } /* copy relevant data to MV_CPU_DEC_WIN structure */ pAddrDecWin->addrWin.baseLow = addrDecWin.addrWin.baseLow; pAddrDecWin->addrWin.baseHigh = addrDecWin.addrWin.baseHigh; pAddrDecWin->addrWin.size = addrDecWin.addrWin.size; pAddrDecWin->enable = addrDecWin.enable; pAddrDecWin->winNum = 0xffffffff; } else { /* get the Window number associated with this target */ winNum = mvAhbToMbusWinTargetGet(target); if (winNum >= MAX_AHB_TO_MBUS_WINS) { return MV_NO_SUCH; } if (mvAhbToMbusWinGet(winNum , &decWin) != MV_OK) { mvOsPrintf("%s: mvAhbToMbusWinGet Failed at winNum = %d\n", __FUNCTION__, winNum); return MV_ERROR; } /* copy relevant data to MV_CPU_DEC_WIN structure */ pAddrDecWin->addrWin.baseLow = decWin.addrWin.baseLow; pAddrDecWin->addrWin.baseHigh = decWin.addrWin.baseHigh; pAddrDecWin->addrWin.size = decWin.addrWin.size; pAddrDecWin->enable = decWin.enable; pAddrDecWin->winNum = winNum; } return MV_OK; }
/******************************************************************************* * mvCpuIfTargetWinEnable - Enable/disable a CPU address decode window * * DESCRIPTION: * This function enable/disable a CPU address decode window. * if parameter 'enable' == MV_TRUE the routine will enable the * window, thus enabling CPU accesses (before enabling the window it is * tested for overlapping). Otherwise, the window will be disabled. * * INPUT: * target - Peripheral target enumerator. * enable - Enable/disable parameter. * * OUTPUT: * N/A * * RETURN: * MV_ERROR if protection window number was wrong, or the window * overlapps other target window. * *******************************************************************************/ MV_STATUS mvCpuIfTargetWinEnable(MV_TARGET target,MV_BOOL enable) { MV_U32 winNum, temp; MV_CPU_DEC_WIN addrDecWin; /* Check parameters */ if (target >= MAX_TARGETS) { mvOsPrintf("mvCpuIfTargetWinEnable: target %d is Illigal\n", target); return MV_ERROR; } /* get the window and check if it exist */ temp = mvCpuIfTargetWinGet(target, &addrDecWin); if (MV_NO_SUCH == temp) { return (enable? MV_ERROR: MV_OK); } else if( MV_OK != temp) { mvOsPrintf("%s: ERR. Getting target %d failed.\n",__FUNCTION__, target); return MV_ERROR; } /* check overlap */ if (MV_TRUE == enable) { if (MV_TRUE == cpuTargetWinOverlap(target, &addrDecWin.addrWin)) { DB(mvOsPrintf("%s: ERR. Target %d overlap\n",__FUNCTION__, target)); return MV_ERROR; } } if (!MV_TARGET_IS_DRAM(target)) { /* get the Window number associated with this target */ winNum = mvAhbToMbusWinTargetGet(target); if (winNum >= MAX_AHB_TO_MBUS_WINS) { return (enable? MV_ERROR: MV_OK); } if (mvAhbToMbusWinEnable(winNum , enable) != MV_OK) { mvOsPrintf("mvCpuIfTargetWinGet: Failed to enable window = %d\n", winNum); return MV_ERROR; } } return MV_OK; }
/******************************************************************************* * mvCpuIfPciRemap - Set CPU remap register for address windows. * * DESCRIPTION: * * INPUT: * pciTarget - Peripheral target enumerator. Must be a PCI target. * pAddrDecWin - CPU target window information data structure. * Note that caller has to fill in the base field only. The * size field is ignored. * * OUTPUT: * None. * * RETURN: * MV_ERROR if target is not a PCI one, MV_OK otherwise. * *******************************************************************************/ MV_U32 mvCpuIfPciRemap(MV_TARGET pciIfTarget, MV_ADDR_WIN *pAddrDecWin) { MV_U32 winNum; /* get the Window number associated with this target */ winNum = mvAhbToMbusWinTargetGet(pciIfTarget); if (winNum >= MAX_AHB_TO_MBUS_WINS) { mvOsPrintf("mvCpuIfPexRemap: mvAhbToMbusWinTargetGet Failed\n"); return 0xffffffff; } return mvAhbToMbusWinRemap(winNum, pAddrDecWin); }
/******************************************************************************* * mvCpuIfPciRemap - Set CPU remap register for address windows. * * DESCRIPTION: * * INPUT: * pciTarget - Peripheral target enumerator. Must be a PCI target. * pAddrDecWin - CPU target window information data structure. * Note that caller has to fill in the base field only. The * size field is ignored. * * OUTPUT: * None. * * RETURN: * MV_ERROR if target is not a PCI one, MV_OK otherwise. * *******************************************************************************/ MV_U32 mvCpuIfPciRemap(MV_TARGET pciTarget, MV_ADDR_WIN *pAddrDecWin) { MV_U32 winNum; /* Check parameters */ if (!MV_TARGET_IS_PCI(pciTarget)) { mvOsPrintf("mvCpuIfPciRemap: target %d is illegal\n", pciTarget); return 0xffffffff; } /* get the Window number associated with this target */ winNum = mvAhbToMbusWinTargetGet(pciTarget); if (winNum >= MAX_AHB_TO_MBUS_WINS) { mvOsPrintf("mvCpuIfPciRemap: mvAhbToMbusWinTargetGet Failed\n"); return 0xffffffff; } return mvAhbToMbusWinRemap(winNum, pAddrDecWin); }
MV_U32 mvPexHwConfigRead (MV_U32 pexIf, MV_U32 bus, MV_U32 dev, MV_U32 func, MV_U32 regOff) { #endif MV_U32 pexData = 0; MV_U32 localDev,localBus; /* Parameter checking */ if (PEX_DEFAULT_IF != pexIf) { if (pexIf >= mvCtrlPexMaxIfGet()) { mvOsPrintf("mvPexConfigRead: ERR. Invalid PEX interface %d\n",pexIf); return 0xFFFFFFFF; } } if (dev >= MAX_PEX_DEVICES) { DB(mvOsPrintf("mvPexConfigRead: ERR. device number illigal %d\n", dev)); return 0xFFFFFFFF; } if (func >= MAX_PEX_FUNCS) { DB(mvOsPrintf("mvPexConfigRead: ERR. function num illigal %d\n", func)); return 0xFFFFFFFF; } if (bus >= MAX_PEX_BUSSES) { DB(mvOsPrintf("mvPexConfigRead: ERR. bus number illigal %d\n", bus)); return MV_ERROR; } DB(mvOsPrintf("mvPexConfigRead: pexIf %d, bus %d, dev %d, func %d, regOff 0x%x\n", pexIf, bus, dev, func, regOff)); localDev = mvPexLocalDevNumGet(pexIf); localBus = mvPexLocalBusNumGet(pexIf); /* Speed up the process. In case on no link, return MV_ERROR */ if ((dev != localDev) || (bus != localBus)) { pexData = MV_REG_READ(PEX_STATUS_REG(pexIf)); if ((pexData & PXSR_DL_DOWN)) { return MV_ERROR; } } /* in PCI Express we have only one device number */ /* and this number is the first number we encounter else that the localDev*/ /* spec pex define return on config read/write on any device */ if (bus == localBus) { if (localDev == 0) { /* if local dev is 0 then the first number we encounter after 0 is 1 */ if ((dev != 1)&&(dev != localDev)) { return MV_ERROR; } } else { /* if local dev is not 0 then the first number we encounter is 0 */ if ((dev != 0)&&(dev != localDev)) { return MV_ERROR; } } if(func != 0 ) /* i.e bridge */ { return MV_ERROR; } } /* Creating PEX address to be passed */ pexData = (bus << PXCAR_BUS_NUM_OFFS); pexData |= (dev << PXCAR_DEVICE_NUM_OFFS); pexData |= (func << PXCAR_FUNC_NUM_OFFS); pexData |= (regOff & PXCAR_REG_NUM_MASK); /* lgacy register space */ /* extended register space */ pexData |=(((regOff & PXCAR_REAL_EXT_REG_NUM_MASK) >> PXCAR_REAL_EXT_REG_NUM_OFFS) << PXCAR_EXT_REG_NUM_OFFS); pexData |= PXCAR_CONFIG_EN; /* Write the address to the PEX configuration address register */ MV_REG_WRITE(PEX_CFG_ADDR_REG(pexIf), pexData); DB(mvOsPrintf("mvPexConfigRead:address pexData=%x ",pexData)); /* In order to let the PEX controller absorbed the address of the read */ /* transaction we perform a validity check that the address was written */ if(pexData != MV_REG_READ(PEX_CFG_ADDR_REG(pexIf))) { return MV_ERROR; } /* cleaning Master Abort */ MV_REG_BIT_SET(PEX_CFG_DIRECT_ACCESS(pexIf,PEX_STATUS_AND_COMMAND), PXSAC_MABORT); #if 0 /* Guideline (GL# PCI Express-1) Erroneous Read Data on Configuration */ /* This guideline is relevant for all devices except of the following devices: 88F5281-BO and above, 88F5181L-A0 and above, 88F1281 A0 and above 88F6183 A0 and above, 88F6183L */ if ( ( (dev != localDev) || (bus != localBus) ) && ( !(MV_5281_DEV_ID == mvCtrlModelGet())&& !((MV_5181_DEV_ID == mvCtrlModelGet())&& (mvCtrlRevGet() >= MV_5181L_A0_REV))&& !(MV_1281_DEV_ID == mvCtrlModelGet())&& !(MV_6183_DEV_ID == mvCtrlModelGet())&& !(MV_6183L_DEV_ID == mvCtrlModelGet())&& !(MV_6281_DEV_ID == mvCtrlModelGet())&& !(MV_6192_DEV_ID == mvCtrlModelGet())&& !(MV_6190_DEV_ID == mvCtrlModelGet())&& !(MV_6180_DEV_ID == mvCtrlModelGet())&& !(MV_78XX0_DEV_ID == mvCtrlModelGet()) )) { /* PCI-Express configuration read work-around */ /* we will use one of the Punit (AHBToMbus) windows to access the xbar and read the data from there */ /* Need to configure the 2 free Punit (AHB to MBus bridge) address decoding windows: Configure the flash Window to handle Configuration space requests for PEX0/1: 1. write 0x7931/0x7941 to the flash window and the size, 79-xbar attr (pci cfg), 3/4-xbar target (pex0/1), 1-WinEn 2. write base to flash window Configuration transactions from the CPU should write/read the data to/from address of the form: addr[31:28] = 0x5 (for PEX0) or 0x6 (for PEX1) addr[27:24] = extended register number addr[23:16] = bus number addr[15:11] = device number addr[10:8] = function number addr[7:0] = register number */ #include "ctrlEnv/sys/mvAhbToMbus.h" { MV_U32 winNum; MV_AHB_TO_MBUS_DEC_WIN originWin; MV_U32 pciAddr=0; MV_U32 remapLow=0,remapHigh=0; /* We will use DEV_CS2\Flash window for this workarround */ winNum = mvAhbToMbusWinTargetGet(PEX_CONFIG_RW_WA_TARGET); /* save remap values if exist */ if ((1 == winNum)||(0 == winNum)) { remapLow = MV_REG_READ(AHB_TO_MBUS_WIN_REMAP_LOW_REG(winNum)); remapHigh = MV_REG_READ(AHB_TO_MBUS_WIN_REMAP_HIGH_REG(winNum)); } /* save the original window values */ mvAhbToMbusWinGet(winNum,&originWin); if (PEX_CONFIG_RW_WA_USE_ORIGINAL_WIN_VALUES) { /* set the window as xbar window */ if (pexIf) { MV_REG_WRITE(AHB_TO_MBUS_WIN_CTRL_REG(winNum), (0x7931 | (((originWin.addrWin.size >> 16)-1) ) << 16)); } else { MV_REG_WRITE(AHB_TO_MBUS_WIN_CTRL_REG(winNum), (0x7941 | (((originWin.addrWin.size >> 16)-1) ) << 16)); } MV_REG_WRITE(AHB_TO_MBUS_WIN_BASE_REG(winNum), originWin.addrWin.baseLow); /*pciAddr = originWin.addrWin.baseLow;*/ pciAddr = (MV_U32)CPU_MEMIO_UNCACHED_ADDR( (MV_U32)originWin.addrWin.baseLow); }
/******************************************************************************* * 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; }
/******************************************************************************* * mvCpuIfTargetWinGet - Get CPU-to-peripheral target address window * * DESCRIPTION: * Get the CPU peripheral target address window. * * INPUT: * target - Peripheral target enumerator * * OUTPUT: * pAddrDecWin - CPU target window information data structure. * * RETURN: * MV_OK if target exist, MV_ERROR otherwise. * *******************************************************************************/ MV_STATUS mvCpuIfTargetWinGet(MV_TARGET target, MV_CPU_DEC_WIN *pAddrDecWin) { MV_U32 winNum = 0xffffffff; MV_AHB_TO_MBUS_DEC_WIN decWin; MV_DRAM_DEC_WIN addrDecWin; MV_U32 dramEn = 0; MV_TARGET i; target = MV_CHANGE_BOOT_CS(target); /* Check parameters */ if (target >= MAX_TARGETS) { mvOsPrintf("mvCpuIfTargetWinGet: target %d is illegal\n", target); return MV_ERROR; } if (MV_TARGET_IS_DRAM(target)) { /* If none of the DRAM windows is enabled, then the CPU DRAM ** access is going through the XBAR. */ for (i = SDRAM_CS0; i < SDRAM_CS3; i++) { if (mvDramIfWinGet(target, &addrDecWin) != MV_OK) { mvOsPrintf("mvCpuIfTargetWinGet: Failed to get window target %d\n", i); return MV_ERROR; } if (addrDecWin.enable == MV_TRUE) dramEn = 1; } } if ((dramEn == 1) && (MV_TARGET_IS_DRAM(target))) { if (mvDramIfWinGet(target, &addrDecWin) != MV_OK) { mvOsPrintf("mvCpuIfTargetWinGet: Failed to get window target %d\n", target); return MV_ERROR; } /* copy relevant data to MV_CPU_DEC_WIN structure */ pAddrDecWin->addrWin.baseLow = addrDecWin.addrWin.baseLow; pAddrDecWin->addrWin.baseHigh = addrDecWin.addrWin.baseHigh; pAddrDecWin->addrWin.size = addrDecWin.addrWin.size; pAddrDecWin->enable = addrDecWin.enable; pAddrDecWin->winNum = 0xffffffff; } else { /* get the Window number associated with this target */ winNum = mvAhbToMbusWinTargetGet(target); if (winNum >= MAX_AHB_TO_MBUS_WINS) return MV_NO_SUCH; if (mvAhbToMbusWinGet(winNum, &decWin) != MV_OK) { mvOsPrintf("%s: mvAhbToMbusWinGet Failed at winNum = %d\n", __func__, winNum); return MV_ERROR; } /* copy relevant data to MV_CPU_DEC_WIN structure */ pAddrDecWin->addrWin.baseLow = decWin.addrWin.baseLow; pAddrDecWin->addrWin.baseHigh = decWin.addrWin.baseHigh; pAddrDecWin->addrWin.size = decWin.addrWin.size; pAddrDecWin->enable = decWin.enable; pAddrDecWin->winNum = winNum; } return MV_OK; }