/******************************************************************************* * mvCtrlGetAttrib - * * DESCRIPTION: * * INPUT: * * OUTPUT: * * RETURN: * *******************************************************************************/ MV_TARGET mvCtrlTargetGet(MV_TARGET_ATTRIB *targetAttrib) { MV_TARGET target; MV_TARGET x; for (target = SDRAM_CS0; target < MAX_TARGETS; target++) { x = MV_CHANGE_BOOT_CS(target); if ((mvTargetDefaultsArray[x].attrib == targetAttrib->attrib) && (mvTargetDefaultsArray[MV_CHANGE_BOOT_CS(target)].targetId == targetAttrib->targetId)) { /* found it */ break; } } return target; }
/******************************************************************************* * mvCtrlTargetByWinInfoGet - * * DESCRIPTION: * * INPUT: * * OUTPUT: * * RETURN: * *******************************************************************************/ MV_TARGET mvCtrlTargetByWinInfoGet(MV_UNIT_WIN_INFO *unitWinInfo) { MV_TARGET target; MV_TARGET x; for (target = SDRAM_CS0; target < MAX_TARGETS; target++) { x = MV_CHANGE_BOOT_CS(target); if ((mvTargetDefaultsArray[x].attrib == unitWinInfo->attrib) && (mvTargetDefaultsArray[MV_CHANGE_BOOT_CS(target)].targetId == unitWinInfo->targetId)) { /* found it */ break; } } return target; }
/******************************************************************************* * mvCpuIfTargetWinBaseHighGet - Get CPU target address window base high * * DESCRIPTION: * CPU-to-peripheral target address window base is constructed of * two parts: Low and high. * This function gets the CPU peripheral target high base address. * * INPUT: * target - Peripheral target enumerator * * OUTPUT: * None. * * RETURN: * 32bit high base address. * *******************************************************************************/ MV_U32 mvCpuIfTargetWinBaseHighGet(MV_TARGET target) { MV_CPU_DEC_WIN addrDecWin; target = MV_CHANGE_BOOT_CS(target); /* Check parameters */ if (target >= MAX_TARGETS) { mvOsPrintf("mvCpuIfTargetWinBaseLowGet: target %d is illegal\n", target); return 0xffffffff; } /* Get the target window */ if (MV_OK != mvCpuIfTargetWinGet(target, &addrDecWin)) { mvOsPrintf("mvCpuIfTargetWinBaseHighGet:ERR. Getting target %d failed.\n", target); return 0xffffffff; } if (MV_FALSE == addrDecWin.enable) { return 0; } return (addrDecWin.addrWin.baseHigh); }
/******************************************************************************* * 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; }
/******************************************************************************* * mvCpuIfTargetWinSizeGet - Get CPU target address window size * * DESCRIPTION: * Get the size of CPU-to-peripheral target window. * * INPUT: * target - Peripheral target enumerator * * OUTPUT: * None. * * RETURN: * 32bit size. Function also returns '0' if window is closed. * Function returns 0xFFFFFFFF in case of an error. * *******************************************************************************/ MV_U32 mvCpuIfTargetWinSizeGet(MV_TARGET target) { MV_CPU_DEC_WIN addrDecWin; target = MV_CHANGE_BOOT_CS(target); /* Check parameters */ if (target >= MAX_TARGETS) { mvOsPrintf("mvCpuIfTargetWinSizeGet: target %d is illegal\n", target); return 0; } /* Get the winNum window */ if (MV_OK != mvCpuIfTargetWinGet(target, &addrDecWin)) { mvOsPrintf("mvCpuIfTargetWinSizeGet:ERR. Getting target %d failed.\n", target); return 0; } /* Check if window is enabled */ if (addrDecWin.enable == MV_TRUE) { return (addrDecWin.addrWin.size); } else { return 0; /* Window disabled. return 0 */ } }
/******************************************************************************* * cpuTargetWinOverlap - Detect CPU address decode windows overlapping * * DESCRIPTION: * An unpredicted behaviur is expected in case CPU address decode * windows overlapps. * This function detects CPU address decode windows overlapping of a * specified target. The function does not check the target itself for * overlapping. The function also skipps disabled address decode windows. * * INPUT: * target - Peripheral target enumerator. * pAddrDecWin - An address decode window struct. * * OUTPUT: * None. * * RETURN: * MV_TRUE if the given address window overlaps current address * decode map, MV_FALSE otherwise. * *******************************************************************************/ static MV_BOOL cpuTargetWinOverlap(MV_TARGET target, MV_ADDR_WIN *pAddrWin) { MV_U32 targetNum; MV_CPU_DEC_WIN addrDecWin; MV_STATUS status; for(targetNum = 0; targetNum < MAX_TARGETS; targetNum++) { #if defined(MV_RUN_FROM_FLASH) if(MV_TARGET_IS_AS_BOOT(target)) { if (MV_CHANGE_BOOT_CS(targetNum) == target) continue; } #endif /* MV_RUN_FROM_FLASH */ /* don't check our target or illegal targets */ if (targetNum == target) { continue; } /* Get window parameters */ status = mvCpuIfTargetWinGet(targetNum, &addrDecWin); if(MV_NO_SUCH == status) { continue; } if(MV_OK != status) { DB(mvOsPrintf("cpuTargetWinOverlap: ERR. TargetWinGet failed\n")); return MV_TRUE; } /* Do not check disabled windows */ if (MV_FALSE == addrDecWin.enable) { continue; } if(MV_TRUE == ctrlWinOverlapTest(pAddrWin, &addrDecWin.addrWin)) { DB(mvOsPrintf( "cpuTargetWinOverlap: Required target %d overlap current %d\n", target, targetNum)); return MV_TRUE; } } return MV_FALSE; }
/******************************************************************************* * 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; target = MV_CHANGE_BOOT_CS(target); /* Check parameters */ if (target >= MAX_TARGETS) { mvOsPrintf("mvCpuIfTargetWinEnable: target %d is illegal\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", __func__, 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", __func__, target)); return MV_ERROR; } } if (MV_TARGET_IS_DRAM(target)) { if (mvDramIfWinEnable(target, enable) != MV_OK) { mvOsPrintf("mvCpuIfTargetWinGet: mvDramIfWinEnable Failed at \n"); return MV_ERROR; } } else { /* 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; }
/******************************************************************************* * 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; }
/******************************************************************************* * mvCpuIfInit - Initialize Controller CPU interface * * DESCRIPTION: * This function initialize Controller CPU interface: * 1. Set CPU interface configuration registers. * 2. Set CPU master Pizza arbiter control according to static * configuration described in configuration file. * 3. Opens CPU address decode windows. DRAM windows are assumed to be * already set (auto detection). * * INPUT: * None. * * OUTPUT: * None. * * RETURN: * None. * *******************************************************************************/ MV_STATUS mvCpuIfInit(MV_CPU_DEC_WIN *cpuAddrWinMap) { MV_U32 regVal; MV_TARGET target; MV_ADDR_WIN addrWin; int ii; if (cpuAddrWinMap == NULL) { DB(mvOsPrintf("mvCpuIfInit:ERR. cpuAddrWinMap == NULL\n")); return MV_ERROR; } /* Set ARM Configuration register */ regVal = MV_REG_READ(CPU_CONFIG_REG); regVal &= ~CPU_CONFIG_DEFAULT_MASK; /* regVal |= CPU_CONFIG_DEFAULT; Note: not needed */ MV_REG_WRITE(CPU_CONFIG_REG,regVal); /* First disable all CPU target windows */ for (target = 0; cpuAddrWinMap[target].enable != TBL_TERM; target++) { if ((MV_TARGET_IS_DRAM(target))||(target == INTER_REGS)) { continue; } #if defined(MV_MEM_OVER_PCI_WA) || defined(MV_UART_OVER_PCI_WA) /* If the target PEX or PCI and memory is over PEX or PCI we don't touch this CPU windows */ if (MV_TARGET_IS_PCI(target)) { continue; } #endif #if defined(MV_MEM_OVER_PEX_WA) || defined(MV_UART_OVER_PEX_WA) /* If the target PEX or PCI and memory is over PEX or PCI we don't touch this CPU windows */ if (MV_TARGET_IS_PEX(target)) { continue; } #endif #if defined(MV_RUN_FROM_FLASH) /* Don't disable the boot device. */ if (target == DEV_BOOCS) { continue; } #endif /* MV_RUN_FROM_FLASH */ mvCpuIfTargetWinEnable(MV_CHANGE_BOOT_CS(target),MV_FALSE); } /* TODO */ for (ii = 0; ii < 8; ii++) MV_REG_WRITE(AHB_TO_MBUS_WIN_CTRL_REG(ii), 0); #if defined(MV_RUN_FROM_FLASH) /* Resize the bootcs windows before other windows, because this */ /* window is enabled and will cause an overlap if not resized. */ target = DEV_BOOCS; if (MV_OK != mvCpuIfTargetWinSet(target, &cpuAddrWinMap[target])) { DB(mvOsPrintf("mvCpuIfInit:ERR. mvCpuIfTargetWinSet fail\n")); return MV_ERROR; } addrWin.baseLow = cpuAddrWinMap[target].addrWin.baseLow; addrWin.baseHigh = cpuAddrWinMap[target].addrWin.baseHigh; if (0xffffffff == mvAhbToMbusWinRemap(cpuAddrWinMap[target].winNum ,&addrWin)) { DB(mvOsPrintf("mvCpuIfInit:WARN. mvAhbToMbusWinRemap can't remap winNum=%d\n", cpuAddrWinMap[target].winNum)); } #endif /* MV_RUN_FROM_FLASH */ /* Go through all targets in user table until table terminator */ for (target = 0; cpuAddrWinMap[target].enable != TBL_TERM; target++) { #if defined(MV_RUN_FROM_FLASH) if (target == DEV_BOOCS) { continue; } #endif /* MV_RUN_FROM_FLASH */ /* if DRAM auto sizing is used do not initialized DRAM target windows, */ /* assuming this already has been done earlier. */ #ifdef MV_DRAM_AUTO_SIZE if (MV_TARGET_IS_DRAM(target)) { continue; } #endif #if defined(MV_MEM_OVER_PCI_WA) || defined(MV_UART_OVER_PCI_WA) /* If the target PEX or PCI and memory is over PEX or PCI we don't touch this CPU windows */ if (MV_TARGET_IS_PCI(target)) { continue; } #endif #if defined(MV_MEM_OVER_PEX_WA) || defined(MV_UART_OVER_PEX_WA) /* If the target PEX or PCI and memory is over PEX or PCI we don't touch this CPU windows */ if (MV_TARGET_IS_PEX(target)) { continue; } #endif /* If the target attribute is the same as the boot device attribute */ /* then it's stays disable */ if (MV_TARGET_IS_AS_BOOT(target)) { continue; } if((0 == cpuAddrWinMap[target].addrWin.size) || (DIS == cpuAddrWinMap[target].enable)) { if (MV_OK != mvCpuIfTargetWinEnable(target, MV_FALSE)) { DB(mvOsPrintf("mvCpuIfInit:ERR. mvCpuIfTargetWinEnable fail\n")); return MV_ERROR; } } else { if (MV_OK != mvCpuIfTargetWinSet(target, &cpuAddrWinMap[target])) { DB(mvOsPrintf("mvCpuIfInit:ERR. mvCpuIfTargetWinSet fail\n")); return MV_ERROR; } addrWin.baseLow = cpuAddrWinMap[target].addrWin.baseLow; addrWin.baseHigh = cpuAddrWinMap[target].addrWin.baseHigh; if (0xffffffff == mvAhbToMbusWinRemap(cpuAddrWinMap[target].winNum ,&addrWin)) { DB(mvOsPrintf("mvCpuIfInit:WARN. mvAhbToMbusWinRemap can't remap winNum=%d\n", cpuAddrWinMap[target].winNum)); } } } #ifdef MV_INCLUDE_PEX mvCpuIfEnablePex(); #endif #ifdef MV_INCLUDE_PMU mvCpuIfEnablePmu(); #endif return MV_OK; }
/******************************************************************************* * mvCpuIfInit - Initialize Controller CPU interface * * DESCRIPTION: * This function initialize Controller CPU interface: * 1. Set CPU interface configuration registers. * 2. Set CPU master Pizza arbiter control according to static * configuration described in configuration file. * 3. Opens CPU address decode windows. DRAM windows are assumed to be * already set (auto detection). * * INPUT: * None. * * OUTPUT: * None. * * RETURN: * None. * *******************************************************************************/ MV_STATUS mvCpuIfInit(MV_CPU_DEC_WIN *cpuAddrWinMap) { MV_U32 regVal; MV_TARGET target; MV_ADDR_WIN addrWin; if (cpuAddrWinMap == NULL) { DB(mvOsPrintf("mvCpuIfInit:ERR. cpuAddrWinMap == NULL\n")); return MV_ERROR; } /*Initialize the boot target array according to device type*/ if(mvCtrlModelGet() == MV_6180_DEV_ID || mvCtrlModelGet() == MV_6280_DEV_ID) sampleAtResetTargetArray = sampleAtResetTargetArray6180P; else sampleAtResetTargetArray = sampleAtResetTargetArrayP; /* Set ARM Configuration register */ regVal = MV_REG_READ(CPU_CONFIG_REG); regVal &= ~CPU_CONFIG_DEFAULT_MASK; regVal |= CPU_CONFIG_DEFAULT; MV_REG_WRITE(CPU_CONFIG_REG,regVal); /* First disable all CPU target windows */ for (target = 0; cpuAddrWinMap[target].enable != TBL_TERM; target++) { if ((MV_TARGET_IS_DRAM(target))||(target == INTER_REGS)) { continue; } #if defined(MV_MEM_OVER_PCI_WA) || defined(MV_UART_OVER_PCI_WA) /* If the target PEX or PCI and memory is over PEX or PCI we don't touch this CPU windows */ if (MV_TARGET_IS_PCI(target)) { continue; } #endif #if defined(MV_MEM_OVER_PEX_WA) || defined(MV_UART_OVER_PEX_WA) /* If the target PEX or PCI and memory is over PEX or PCI we don't touch this CPU windows */ if (MV_TARGET_IS_PEX(target)) { continue; } #endif #if defined(MV_RUN_FROM_FLASH) /* Don't disable the boot device. */ if (target == DEV_BOOCS) { continue; } #endif /* MV_RUN_FROM_FLASH */ /* Only MV88F6282 have 2 PCIe interfaces */ if((mvCtrlModelGet() != MV_6282_DEV_ID) && MV_TARGET_IS_PEX1(target)) continue; mvCpuIfTargetWinEnable(MV_CHANGE_BOOT_CS(target),MV_FALSE); } #if defined(MV_RUN_FROM_FLASH) /* Resize the bootcs windows before other windows, because this */ /* window is enabled and will cause an overlap if not resized. */ target = DEV_BOOCS; if (MV_OK != mvCpuIfTargetWinSet(target, &cpuAddrWinMap[target])) { DB(mvOsPrintf("mvCpuIfInit:ERR. mvCpuIfTargetWinSet fail\n")); return MV_ERROR; } addrWin.baseLow = cpuAddrWinMap[target].addrWin.baseLow; addrWin.baseHigh = cpuAddrWinMap[target].addrWin.baseHigh; if (0xffffffff == mvAhbToMbusWinRemap(cpuAddrWinMap[target].winNum ,&addrWin)) { DB(mvOsPrintf("mvCpuIfInit:WARN. mvAhbToMbusWinRemap can't remap winNum=%d\n", cpuAddrWinMap[target].winNum)); } #endif /* MV_RUN_FROM_FLASH */ /* Go through all targets in user table until table terminator */ for (target = 0; cpuAddrWinMap[target].enable != TBL_TERM; target++) { #if defined(MV_RUN_FROM_FLASH) if (target == DEV_BOOCS) { continue; } #endif /* MV_RUN_FROM_FLASH */ /* if DRAM auto sizing is used do not initialized DRAM target windows, */ /* assuming this already has been done earlier. */ #ifdef MV_DRAM_AUTO_SIZE if (MV_TARGET_IS_DRAM(target)) { continue; } #endif #if defined(MV_MEM_OVER_PCI_WA) || defined(MV_UART_OVER_PCI_WA) /* If the target PEX or PCI and memory is over PEX or PCI we don't touch this CPU windows */ if (MV_TARGET_IS_PCI(target)) { continue; } #endif #if defined(MV_MEM_OVER_PEX_WA) || defined(MV_UART_OVER_PEX_WA) /* If the target PEX or PCI and memory is over PEX or PCI we don't touch this CPU windows */ if (MV_TARGET_IS_PEX(target)) { continue; } #endif /* If the target attribute is the same as the boot device attribute */ /* then it's stays disable */ if (MV_TARGET_IS_AS_BOOT(target)) { continue; } /* Only MV88F6282 have 2 PCIe interfaces */ if((mvCtrlModelGet() != MV_6282_DEV_ID) && MV_TARGET_IS_PEX1(target)) continue; if((0 == cpuAddrWinMap[target].addrWin.size) || (DIS == cpuAddrWinMap[target].enable)) { if (MV_OK != mvCpuIfTargetWinEnable(target, MV_FALSE)) { DB(mvOsPrintf("mvCpuIfInit:ERR. mvCpuIfTargetWinEnable fail\n")); return MV_ERROR; } } else { if (MV_OK != mvCpuIfTargetWinSet(target, &cpuAddrWinMap[target])) { DB(mvOsPrintf("mvCpuIfInit:ERR. mvCpuIfTargetWinSet fail\n")); return MV_ERROR; } addrWin.baseLow = cpuAddrWinMap[target].addrWin.baseLow; addrWin.baseHigh = cpuAddrWinMap[target].addrWin.baseHigh; if (0xffffffff == mvAhbToMbusWinRemap(cpuAddrWinMap[target].winNum ,&addrWin)) { DB(mvOsPrintf("mvCpuIfInit:WARN. mvAhbToMbusWinRemap can't remap winNum=%d\n", cpuAddrWinMap[target].winNum)); } } } 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; }