/* * Copyright - Galileo technology. * * See file CREDITS for list of people who contributed to this * project. * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of * the License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * MA 02111-1307 USA *//* * * written or collected and sometimes rewritten by * Ingo Assmus <ingo.assmus@keymile.com> * */#include <common.h>#include "../include/core.h"#include "../include/memory.h"/******************************************************************************** memoryGetBankBaseAddress - Returns the base address of a memory bank.* DESCRIPTION:*       This function returns the base address of one of the SDRAM抯 memory*       banks. There are 4 memory banks and each one represents one DIMM side.* INPUT:*       MEMORY_BANK bank - Selects one of the four banks as defined in Memory.h.* OUTPUT:*       None.* RETURN:*       32 bit Memory bank base address.*******************************************************************************/static unsigned long memoryGetBankRegOffset (MEMORY_BANK bank){	switch (bank) {	case BANK0:		return SCS_0_LOW_DECODE_ADDRESS;	case BANK1:		return SCS_1_LOW_DECODE_ADDRESS;	case BANK2:		return SCS_2_LOW_DECODE_ADDRESS;	case BANK3:		return SCS_3_LOW_DECODE_ADDRESS;	}	return SCS_0_LOW_DECODE_ADDRESS;	/* default value */}unsigned int memoryGetBankBaseAddress (MEMORY_BANK bank){	unsigned int base;	unsigned int regOffset = memoryGetBankRegOffset (bank);	GT_REG_READ (regOffset, &base);	base = base << 16;	/* MV6436x */	return base;}/******************************************************************************** memoryGetDeviceBaseAddress - Returns the base address of a device.* DESCRIPTION:*       This function returns the base address of a device on the system. There*       are 5 possible devices (0 - 4 and one boot device) as defined in*       gtMemory.h. Each of the device parameters is maped to one of the CS*       (Devices chip selects) base address register.* INPUT:*       device - Selects one of the five devices as defined in Memory.h.* OUTPUT:*       None.* RETURN:*       32 bit Device base address.********************************************************************************/static unsigned int memoryGetDeviceRegOffset (DEVICE device){	switch (device) {	case DEVICE0:		return CS_0_LOW_DECODE_ADDRESS;	case DEVICE1:		return CS_1_LOW_DECODE_ADDRESS;	case DEVICE2:		return CS_2_LOW_DECODE_ADDRESS;	case DEVICE3:		return CS_3_LOW_DECODE_ADDRESS;	case BOOT_DEVICE:		return BOOTCS_LOW_DECODE_ADDRESS;	}	return CS_0_LOW_DECODE_ADDRESS;	/* default value */}unsigned int memoryGetDeviceBaseAddress (DEVICE device){	unsigned int regBase;	unsigned int regOffset = memoryGetDeviceRegOffset (device);	GT_REG_READ (regOffset, &regBase);	regBase = regBase << 16;	/* MV6436x */	return regBase;}/******************************************************************************** MemoryGetPciBaseAddr - Returns the base address of a PCI window.* DESCRIPTION:*       This function returns the base address of a PCI window. There are 5*       possible PCI windows (memory 0 - 3 and one for I/O) for each PCI*       interface as defined in gtMemory.h, used by the CPU's address decoding*       mechanism.*	New in MV6436x* INPUT:*       pciWindow - Selects one of the PCI windows as defined in Memory.h.* OUTPUT:*       None.* RETURN:*       32 bit PCI window base address.*******************************************************************************/unsigned int MemoryGetPciBaseAddr (PCI_MEM_WINDOW pciWindow){	unsigned int baseAddrReg, base;	switch (pciWindow) {	case PCI_0_IO:		baseAddrReg = PCI_0I_O_LOW_DECODE_ADDRESS;	/*PCI_0_IO_BASE_ADDR;  */		break;	case PCI_0_MEM0:		baseAddrReg = PCI_0MEMORY0_LOW_DECODE_ADDRESS;	/*PCI_0_MEMORY0_BASE_ADDR; */		break;	case PCI_0_MEM1:		baseAddrReg = PCI_0MEMORY1_LOW_DECODE_ADDRESS;	/*PCI_0_MEMORY1_BASE_ADDR; */		break;	case PCI_0_MEM2:		baseAddrReg = PCI_0MEMORY2_LOW_DECODE_ADDRESS;	/*PCI_0_MEMORY2_BASE_ADDR;  */		break;	case PCI_0_MEM3:		baseAddrReg = PCI_0MEMORY3_LOW_DECODE_ADDRESS;	/*PCI_0_MEMORY3_BASE_ADDR;  */		break;#ifdef INCLUDE_PCI_1	case PCI_1_IO:		baseAddrReg = PCI_1I_O_LOW_DECODE_ADDRESS;	/*PCI_1_IO_BASE_ADDR;  */		break;	case PCI_1_MEM0:		baseAddrReg = PCI_1MEMORY0_LOW_DECODE_ADDRESS;	/*PCI_1_MEMORY0_BASE_ADDR; */		break;	case PCI_1_MEM1:		baseAddrReg = PCI_1MEMORY1_LOW_DECODE_ADDRESS;	/*PCI_1_MEMORY1_BASE_ADDR;  */		break;	case PCI_1_MEM2:		baseAddrReg = PCI_1MEMORY2_LOW_DECODE_ADDRESS;	/*PCI_1_MEMORY2_BASE_ADDR;  */		break;	case PCI_1_MEM3:		baseAddrReg = PCI_1MEMORY3_LOW_DECODE_ADDRESS;	/*PCI_1_MEMORY3_BASE_ADDR; */		break;#endif /* INCLUDE_PCI_1 */	default:		return 0xffffffff;	}	GT_REG_READ (baseAddrReg, &base);	return (base << 16);}/******************************************************************************** memoryGetBankSize - Returns the size of a memory bank.* DESCRIPTION:*       This function returns the size of memory bank as described in*       'gtMemoryGetBankBaseAddress' function.* INPUT:*       bank - Selects one of the four banks as defined in Memory.h.* OUTPUT:*       None.* RETURN:*       32 bit size memory bank size or 0 for a closed or non populated bank.********************************************************************************/unsigned int memoryGetBankSize (MEMORY_BANK bank){	unsigned int sizeReg, size;	MEMORY_WINDOW window;	switch (bank) {	case BANK0:		sizeReg = SCS_0_HIGH_DECODE_ADDRESS;	/* CS_0_SIZE; */		window = CS_0_WINDOW;		break;	case BANK1:		sizeReg = SCS_1_HIGH_DECODE_ADDRESS;	/* CS_1_SIZE; */		window = CS_1_WINDOW;		break;	case BANK2:		sizeReg = SCS_2_HIGH_DECODE_ADDRESS;	/* CS_2_SIZE; */		window = CS_2_WINDOW;		break;	case BANK3:		sizeReg = SCS_3_HIGH_DECODE_ADDRESS;	/* CS_3_SIZE; */		window = CS_3_WINDOW;		break;	default:		return 0;		break;	}	/* If the window is closed, a size of 0 is returned */	if (MemoryGetMemWindowStatus (window) != MEM_WINDOW_ENABLED)		return 0;	GT_REG_READ (sizeReg, &size);	size = ((size << 16) | 0xffff) + 1;	return size;}/******************************************************************************** memoryGetDeviceSize - Returns the size of a device memory space.* DESCRIPTION:*       This function returns the memory space size of a given device.* INPUT:*       device - Selects one of the five devices as defined in Memory.h.* OUTPUT:*       None.* RETURN:*       32 bit size of a device memory space.*******************************************************************************/unsigned int memoryGetDeviceSize (DEVICE device){	unsigned int sizeReg, size;	MEMORY_WINDOW window;	switch (device) {	case DEVICE0:		sizeReg = CS_0_HIGH_DECODE_ADDRESS;	/*DEV_CS0_SIZE; */		window = DEVCS_0_WINDOW;		break;	case DEVICE1:		sizeReg = CS_1_HIGH_DECODE_ADDRESS;	/*DEV_CS1_SIZE; */		window = DEVCS_1_WINDOW;		break;	case DEVICE2:		sizeReg = CS_2_HIGH_DECODE_ADDRESS;	/*DEV_CS2_SIZE; */		window = DEVCS_2_WINDOW;		break;	case DEVICE3:		sizeReg = CS_3_HIGH_DECODE_ADDRESS;	/*DEV_CS3_SIZE; */		window = DEVCS_3_WINDOW;		break;	case BOOT_DEVICE:		sizeReg = BOOTCS_HIGH_DECODE_ADDRESS;	/*BOOTCS_SIZE; */		window = BOOT_CS_WINDOW;		break;	default:		return 0;		break;	}	/* If the window is closed, a size of 0 is returned */	if (MemoryGetMemWindowStatus (window) != MEM_WINDOW_ENABLED)		return 0;	GT_REG_READ (sizeReg, &size);	size = ((size << 16) | 0xffff) + 1;	return size;}/******************************************************************************** MemoryGetPciWindowSize - Returns the size of a PCI memory window.* DESCRIPTION:*       This function returns the size of a PCI window.* INPUT:*       pciWindow - Selects one of the PCI memory windows as defined in*       Memory.h.* OUTPUT:*       None.* RETURN:*       32 bit size of a PCI memory window.*******************************************************************************/unsigned int MemoryGetPciWindowSize (PCI_MEM_WINDOW pciWindow){	unsigned int sizeReg, size;	switch (pciWindow) {	case PCI_0_IO:		sizeReg = PCI_0I_O_HIGH_DECODE_ADDRESS;	/*PCI_0_IO_SIZE; */		break;	case PCI_0_MEM0:		sizeReg = PCI_0MEMORY0_HIGH_DECODE_ADDRESS;	/*PCI_0_MEMORY0_SIZE; */		break;	case PCI_0_MEM1:		sizeReg = PCI_0MEMORY1_HIGH_DECODE_ADDRESS;	/*PCI_0_MEMORY1_SIZE; */		break;	case PCI_0_MEM2:		sizeReg = PCI_0MEMORY2_HIGH_DECODE_ADDRESS;	/*PCI_0_MEMORY2_SIZE; */		break;	case PCI_0_MEM3:		sizeReg = PCI_0MEMORY3_HIGH_DECODE_ADDRESS;	/*PCI_0_MEMORY3_SIZE; */		break;#ifdef INCLUDE_PCI_1	case PCI_1_IO:		sizeReg = PCI_1I_O_HIGH_DECODE_ADDRESS;	/*PCI_1_IO_SIZE; */		break;	case PCI_1_MEM0:		sizeReg = PCI_1MEMORY0_HIGH_DECODE_ADDRESS;	/*PCI_1_MEMORY0_SIZE; */		break;	case PCI_1_MEM1:		sizeReg = PCI_1MEMORY1_HIGH_DECODE_ADDRESS;	/*PCI_1_MEMORY1_SIZE;  */		break;	case PCI_1_MEM2:		sizeReg = PCI_1MEMORY2_HIGH_DECODE_ADDRESS;	/*PCI_1_MEMORY2_SIZE;  */		break;	case PCI_1_MEM3:		sizeReg = PCI_1MEMORY3_HIGH_DECODE_ADDRESS;	/*PCI_1_MEMORY3_SIZE; */		break;#endif /* INCLUDE_PCI_1 */	default:		return 0x0;	}	/* If the memory window is disabled, retrun size = 0 */	if (MemoryGetMemWindowStatus (PCI_0_IO_WINDOW << pciWindow)	    == MEM_WINDOW_DISABLED)		return 0;	GT_REG_READ (sizeReg, &size);	size = ((size << 16) | 0xffff) + 1;	return size;}/******************************************************************************** memoryGetDeviceWidth - Returns the width of a given device.* DESCRIPTION:*       The MV's device interface supports up to 32 Bit wide devices. A device*       can have a  1, 2, 4 or 8 Bytes data width. This function returns the*       width of a device as defined by the user or the operating system.* INPUT:*       device - Selects one of the five devices as defined in Memory.h.* OUTPUT:*       None.* RETURN:*       Device width in Bytes (1,2,4 or 8), 0 if error had occurred.*******************************************************************************/unsigned int memoryGetDeviceWidth (DEVICE device){	unsigned int width;	unsigned int regValue;	GT_REG_READ (DEVICE_BANK0PARAMETERS + device * 4, &regValue);	width = (regValue & (BIT20 | BIT21)) >> 20;	return (BIT0 << width);}/******************************************************************************** memoryMapBank - Set new base address and size for one of the memory*                         banks.** DESCRIPTION:*       The CPU interface address decoding map consists of 21 address windows*       for the different devices (e.g. CS[3:0] ,PCI0 Mem 0/1/2/3...). Each*       window can have a minimum of 1Mbytes of address space, and up to 4Gbyte*       space. Each address window is defined by two registers - base and size.*       The CPU address is compared with the values in the various CPU windows*       until a match is found and the address is than targeted to that window.*       This function sets new base and size for one the memory banks*       (CS0 - CS3). It is the programmer`s responsibility to make sure that*       there are no conflicts with other memory spaces. When two memory spaces*       overlap, the MV抯 behavior is not defined .If a bank needs to be closed,*       set the 抌ankLength