memory.c

microwindows移植到S3C44B0的源码

*********************************************************************/
bool mapDevices0_1and2MemorySpace(unsigned int device0Base,
				  unsigned int device0Length,
				  unsigned int device1Base,
				  unsigned int device1Length,
				  unsigned int device2Base,
				  unsigned int device2Length)
{
	unsigned int deviceBank0Top =
	    (unsigned int) (device0Base + device0Length);
	unsigned int deviceBank1Top =
	    (unsigned int) (device1Base + device1Length);
	unsigned int deviceBank2Top =
	    (unsigned int) (device2Base + device2Length);
	unsigned int device0BaseTemp = 0, device0TopTemp = 0;
	unsigned int bank0Base, bank0Top;
	unsigned int bank1Base, bank1Top;
	unsigned int bank2Base, bank2Top;
	bank0Base = ((unsigned int) (device0Base & 0x0fffffff)) >> 20;
	bank0Top = ((unsigned int) (deviceBank0Top & 0x0fffffff)) >> 20;
	bank1Base = ((unsigned int) (device1Base & 0x0fffffff)) >> 20;
	bank1Top = ((unsigned int) (deviceBank1Top & 0x0fffffff)) >> 20;
	bank2Base = ((unsigned int) (device2Base & 0x0fffffff)) >> 20;
	bank2Top = ((unsigned int) (deviceBank2Top & 0x0fffffff)) >> 20;

	if (device0Length == 0)
		deviceBank0Top++;
	if (device1Length == 0)
		deviceBank1Top++;
	if (device2Length == 0)
		deviceBank2Top++;

	if (device0Base <= device1Base && device0Base <= device2Base) {
		if ((device0Base + device0Length) > device1Base || \
		    (device0Base + device0Length) > device2Base)
			return false;
		if (device1Base <= device2Base) {
			if ((device1Base + device1Length) > device2Base)
				return false;
		} else {
			if ((device2Base + device2Length) > device1Base)
				return false;
		}
	}

	if (device1Base <= device0Base && device1Base <= device2Base) {
		if ((device1Base + device1Length) > device0Base ||
		    (device1Base + device1Length) > device2Base)
			return false;
		if (device0Base <= device2Base) {
			if ((device0Base + device0Length) > device2Base)
				return false;
		} else {
			if ((device2Base + device2Length) > device0Base)
				return false;
		}
	}

	if (device2Base <= device1Base && device2Base <= device0Base) {
		if ((device2Base + device2Length) > device1Base ||
		    (device2Base + device2Length) > device0Base)
			return false;
		if (device0Base <= device1Base) {
			if ((device0Base + device0Length) > device1Base)
				return false;
		} else {
			if ((device1Base + device1Length) > device0Base)
				return false;
		}
	}

	if ((deviceBank2Top > deviceBank1Top) && (deviceBank1Top >
						  deviceBank0Top)) {
		device0BaseTemp = device0Base >> 21;
		device0TopTemp =
		    ((unsigned int) (deviceBank2Top & 0x0fffffff)) >> 21;
	}
	if ((deviceBank2Top > deviceBank0Top)
	    && (deviceBank0Top > deviceBank1Top)) {
		device0BaseTemp = device1Base >> 21;
		device0TopTemp =
		    ((unsigned int) (deviceBank2Top & 0x0fffffff)) >> 21;
	}
	if ((deviceBank1Top > deviceBank2Top)
	    && (deviceBank2Top > deviceBank0Top)) {
		device0BaseTemp = device0Base >> 21;
		device0TopTemp =
		    ((unsigned int) (deviceBank1Top & 0x0fffffff)) >> 21;
	}
	if ((deviceBank1Top > deviceBank0Top)
	    && (deviceBank0Top > deviceBank2Top)) {
		device0BaseTemp = device2Base >> 21;
		device0TopTemp =
		    ((unsigned int) (deviceBank1Top & 0x0fffffff)) >> 21;
	}
	if ((deviceBank0Top > deviceBank2Top)
	    && (deviceBank2Top > deviceBank1Top)) {
		device0BaseTemp = device1Base >> 21;
		device0TopTemp =
		    ((unsigned int) (deviceBank0Top & 0x0fffffff)) >> 21;
	}
	if ((deviceBank0Top > deviceBank1Top)
	    && (deviceBank1Top > deviceBank2Top)) {
		device0BaseTemp = device2Base >> 21;
		device0TopTemp =
		    ((unsigned int) (deviceBank0Top & 0x0fffffff)) >> 21;
	}
	GT_REG_WRITE(CS_2_0_LOW_DECODE_ADDRESS, device0BaseTemp);
	if ((device0Length + device1Length + device2Length) != 0) {
		GT_REG_WRITE(CS_2_0_HIGH_DECODE_ADDRESS,
			     device0TopTemp - 1);
	} else {
		GT_REG_WRITE(CS_2_0_HIGH_DECODE_ADDRESS, 0x0);
	}
	GT_REG_WRITE(CS_0_LOW_DECODE_ADDRESS, bank0Base);
	if (device0Length != 0) {
		GT_REG_WRITE(CS_0_HIGH_DECODE_ADDRESS, bank0Top - 1);
	} else {
		GT_REG_WRITE(CS_0_HIGH_DECODE_ADDRESS, 0x0);
	}
	GT_REG_WRITE(CS_1_LOW_DECODE_ADDRESS, bank1Base);
	if (device1Length != 0) {
		GT_REG_WRITE(CS_1_HIGH_DECODE_ADDRESS, bank1Top - 1);
	} else {
		GT_REG_WRITE(CS_1_HIGH_DECODE_ADDRESS, 0x0);
	}
	GT_REG_WRITE(CS_2_LOW_DECODE_ADDRESS, bank2Base);
	if (device2Length != 0) {
		GT_REG_WRITE(CS_2_HIGH_DECODE_ADDRESS, bank2Top - 1);
	} else {
		GT_REG_WRITE(CS_2_HIGH_DECODE_ADDRESS, 0x0);
	}
	return true;
}

/********************************************************************
* mapDevices3andBootMemorySpace - Sets new bases and boundaries for devices: 
*                                 3 and boot
*                     - Pay attention to the PCI mappings and make sure to 
*                       coordinate between the two interfaces!!!
*                     - It is the programmer`s responsibility to make sure 
*                       there are no conflicts with other memory spaces!!!
*                     - If a device needs to be closed , give it a 0 length.
*
* INPUTS: base and length of device 3and boot
* RETURNS: true on success, false on failure
*********************************************************************/
bool mapDevices3andBootMemorySpace(unsigned int device3Base,
				   unsigned int device3Length,
				   unsigned int bootDeviceBase,
				   unsigned int bootDeviceLength)
{
	unsigned int deviceBank3Top =
	    (unsigned int) (device3Base + device3Length);
	unsigned int deviceBankBootTop =
	    (unsigned int) (bootDeviceBase + bootDeviceLength);
	unsigned int bank3Base, bank3Top;
	unsigned int bank4Base, bank4Top;
	unsigned int Device1Base, Device1Top;

	bank3Top = ((unsigned int) (deviceBank3Top & 0x0fffffff)) >> 20;
	bank4Top = ((unsigned int) (deviceBankBootTop & 0x0fffffff)) >> 20;
	bank3Base = ((unsigned int) (device3Base & 0x0fffffff)) >> 20;
	bank4Base = ((unsigned int) (bootDeviceBase & 0x0fffffff)) >> 20;

	if (device3Base <= bootDeviceBase) {
		if (deviceBank3Top > bootDeviceBase)
			return false;
	} else {
		if (deviceBankBootTop > device3Base)
			return false;
	}

	if (deviceBankBootTop > deviceBank3Top) {
		Device1Base = device3Base >> 21;
		Device1Top =
		    ((unsigned int) (deviceBankBootTop & 0x0fffffff)) >>
		    21;
	} else {
		Device1Base = bootDeviceBase >> 21;
		Device1Top =
		    ((unsigned int) (deviceBank3Top & 0x0fffffff)) >> 21;
	}
	GT_REG_WRITE(CS_3_BOOTCS_LOW_DECODE_ADDRESS, Device1Base);
	if ((device3Length + bootDeviceLength) != 0) {
		GT_REG_WRITE(CS_3_BOOTCS_HIGH_DECODE_ADDRESS,
			     Device1Top - 1);
	} else {
		GT_REG_WRITE(CS_3_BOOTCS_HIGH_DECODE_ADDRESS, 0x0);
	}
	GT_REG_WRITE(CS_3_LOW_DECODE_ADDRESS, bank3Base);
	if (device3Length != 0) {
		GT_REG_WRITE(CS_3_HIGH_DECODE_ADDRESS, bank3Top - 1);
	} else {
		GT_REG_WRITE(CS_3_HIGH_DECODE_ADDRESS, 0x0);
	}
	GT_REG_WRITE(BOOTCS_LOW_DECODE_ADDRESS, bank4Base);
	if (bootDeviceLength != 0) {
		GT_REG_WRITE(BOOTCS_HIGH_DECODE_ADDRESS, bank4Top - 1);
	} else {
		GT_REG_WRITE(BOOTCS_HIGH_DECODE_ADDRESS, 0x0);
	}
	return true;
}

/********************************************************************
* modifyDeviceParameters - This function can be used to modify a device`s 
*                          parameters.
*                        - Be advised to check the spec before modifying them.
* Inputs:
* Returns: false if one of the parameters is erroneous,true otherwise.
*********************************************************************/
bool modifyDeviceParameters(DEVICE device, unsigned int turnOff,
			    unsigned int accToFirst,
			    unsigned int accToNext, unsigned int aleToWr,
			    unsigned int wrActive, unsigned int wrHigh,
			    unsigned int width, bool paritySupport)
{
	unsigned int data, oldValue;

	if ((turnOff > 0x7 && turnOff != DONT_MODIFY)
	    || (accToFirst > 0xf && accToFirst != DONT_MODIFY)
	    || (accToNext > 0xf && accToNext != DONT_MODIFY)
	    || (aleToWr > 0x7 && aleToWr != DONT_MODIFY)
	    || (wrActive > 0x7 && wrActive != DONT_MODIFY)
	    || (wrHigh > 0x7 && wrHigh != DONT_MODIFY)) {
		return false;
	}

	GT_REG_READ((DEVICE_BANK0PARAMETERS + device * 4), &oldValue);
	if (turnOff == DONT_MODIFY)
		turnOff = oldValue & 0x00000007;
	else
		turnOff = turnOff;

	if (accToFirst == DONT_MODIFY)
		accToFirst = oldValue & 0x00000078;
	else
		accToFirst = accToFirst << 3;

	if (accToNext == DONT_MODIFY)
		accToNext = oldValue & 0x00000780;
	else
		accToNext = accToNext << 7;

	if (aleToWr == DONT_MODIFY)
		aleToWr = oldValue & 0x00003800;
	else
		aleToWr = aleToWr << 11;

	if (wrActive == DONT_MODIFY)
		wrActive = oldValue & 0x0001c000;
	else
		wrActive = wrActive << 14;

	if (wrHigh == DONT_MODIFY)
		wrHigh = oldValue & 0x000e0000;
	else
		wrHigh = wrHigh << 17;

	data =
	    turnOff | accToFirst | accToNext | aleToWr | wrActive | wrHigh;
	switch (width) {
	case _8BIT:
		break;
	case _16BIT:
		data = data | _16BIT;
		break;
	case _32BIT:
		data = data | _32BIT;
		break;
	case _64BIT:
		data = data | _64BIT;
		break;
	default:
		return false;
	}
	if (paritySupport == true)
		data = data | PARITY_SUPPORT;
	GT_REG_WRITE(DEVICE_BANK0PARAMETERS + device * 4, data);
	return true;
}

/********************************************************************
* remapAddress - This fubction used for address remapping 
* Inputs:      - regOffset: remap register 
*                remapHeader : remapped address
* Returns: false if one of the parameters is erroneous,true otherwise.
*********************************************************************/
bool remapAddress(unsigned int remapReg, unsigned int remapValue)
{
	unsigned int valueForReg;
	valueForReg = (remapValue & 0xffe00000) >> 21;
	GT_REG_WRITE(remapReg, valueForReg);
	return true;
}