hal_indirect.c

s1d13716的源码 windiws ce 或8位单片机

//	RETURNS:
//		The value read from the offset specified by addr.
//---------------------------------------------------------------------------
UInt8 halpParReadDisplay8( UInt32 addr )
{
	UInt8 val;

	halSetProcessExclusivity( TRUE );

	SetDisplayAddrParallel(addr);
	val = *HalIndInfo.pData8;

	halSetProcessExclusivity( FALSE );

	return val;
}


//---------------------------------------------------------------------------
//	FUNCTION: halpParReadDisplay16()
//
//	DESCRIPTION:
//		This routine reads sixteen bits of data (word) from the specified
//		display memory offset using parallel indirect I/O.
//
//	PARAMETERS:
//		addr	- The address to read the LSB of data from
//
//	RETURNS:
//		The 16-bit value read from display memory.
//---------------------------------------------------------------------------
UInt16 halpParReadDisplay16( UInt32 addr )
{
	UInt16 val;

	halSetProcessExclusivity( TRUE );

	SetDisplayAddrParallel(addr);
	val = *HalIndInfo.pData8;
	val =val + (((unsigned short) (*HalIndInfo.pData8))<<8);

	halSetProcessExclusivity( FALSE );

	return val;
}


//---------------------------------------------------------------------------
//	FUNCTION: halpParReadDisplay32()
//
//	DESCRIPTION:
//		This routine reads thirty-two bits of data (dword) from the specified
//		display memory offset using parallel indirect I/O.
//
//	PARAMETERS:
//		addr	- The address to read the LSB of data from
//
//	RETURNS:
//		The 32-bit value read from display memory.
//---------------------------------------------------------------------------
UInt32 halpParReadDisplay32( UInt32 addr )
{
	UInt16 loword, hiword;

	halSetProcessExclusivity( TRUE );

	SetDisplayAddrParallel(addr);

	loword = *HalIndInfo.pData8;
	loword =loword+(((unsigned short) (*HalIndInfo.pData8))<<8);
	hiword = *HalIndInfo.pData8;
	hiword =hiword+(((unsigned short) (*HalIndInfo.pData8))<<8);	

//	loword = *HalIndInfo.pData16;
//	hiword = *HalIndInfo.pData16;

	halSetProcessExclusivity( FALSE );

	return MAKELONG(loword, hiword);
}


//---------------------------------------------------------------------------
//	FUNCTION: halpSerWriteReg8()
//
//	DESCRIPTION:
//		Writes one eight bit register with the specified data using indirect
//		serial I/O
//
//	PARAMETERS:
//		index	- the register offset to write the value to
//		value	- an 8-bit value to be written to the specified register
//---------------------------------------------------------------------------
void halpSerWriteReg8( UInt32 index, UInt8 value )
{
	halSetProcessExclusivity( TRUE );

	*HalIndInfo.pIndex8 = SER_SET_ADDR;
	*HalIndInfo.pData8  = LOBYTE(index);
	*HalIndInfo.pData8  = HIBYTE(index);
	*HalIndInfo.pIndex8 = SER_WRITE;
	*HalIndInfo.pData8  = value;

	halSetProcessExclusivity( FALSE );
}


//---------------------------------------------------------------------------
//	FUNCTION: halpSerWriteReg16()
//
//	DESCRIPTION:
//		Writes two eight bit registers with the specified data using indirect
//		serial I/O
//
//	PARAMETERS:
//		index	- the register offset to write the LSB of value to
//		value	- a 16-bit value to be written to the specified register
//---------------------------------------------------------------------------
void halpSerWriteReg16( UInt32 index, UInt16 value )
{
	halSetProcessExclusivity( TRUE );

	// Write first 8-bit value.
	*HalIndInfo.pIndex8  = SER_SET_ADDR;
	*HalIndInfo.pData8   = LOBYTE(index);
	*HalIndInfo.pData8   = HIBYTE(index);
	*HalIndInfo.pIndex8  = SER_WRITE;
	*HalIndInfo.pData8   = LOBYTE(value);

	// Write second 8-bit value.
	index++;
	*HalIndInfo.pIndex8  = SER_SET_ADDR;
	*HalIndInfo.pData8   = LOBYTE(index);
	*HalIndInfo.pData8   = HIBYTE(index);
	*HalIndInfo.pIndex8  = SER_WRITE;
	*HalIndInfo.pData8   = HIBYTE(value);

	halSetProcessExclusivity( FALSE );
}


//---------------------------------------------------------------------------
//	FUNCTION: halpSerWriteReg32()
//
//	DESCRIPTION:
//		Writes four eight bit registers with the specified data using indirect
//		serial I/O
//
//	PARAMETERS:
//		index	- the register offset to write the LSB of value
//		value	- a 32-bit value to be written to the specified register
//---------------------------------------------------------------------------
void halpSerWriteReg32( UInt32 index, UInt32 value )
{
	UInt8  hibyte;

	halSetProcessExclusivity( TRUE );

	// Setup the register address
	hibyte = HIBYTE(index);
	*HalIndInfo.pIndex8  = SER_SET_ADDR;
	*HalIndInfo.pData8   = LOBYTE(index);
	*HalIndInfo.pData8   = HIBYTE(index);
	*HalIndInfo.pIndex8  = SER_WRITE;
	*HalIndInfo.pData8   = LOBYTE(LOWORD(value));
	*HalIndInfo.pData8   = HIBYTE(LOWORD(value));

	// Set the next register address
	*HalIndInfo.pIndex8  = SER_SET_ADDR;
	*HalIndInfo.pData8   = LOBYTE(index+2);
	if( hibyte!=HIBYTE(index+2) )
		*HalIndInfo.pData8 = HIBYTE(index+2);
	*HalIndInfo.pIndex8  = SER_WRITE;
	*HalIndInfo.pData8   = LOBYTE(HIWORD(value));
	*HalIndInfo.pData8   = HIBYTE(HIWORD(value));

	halSetProcessExclusivity( FALSE );
}


//---------------------------------------------------------------------------
//	FUNCTION: halpSerReadReg8()
//
//	DESCRIPTION:
//		This routine reads one eight bit value from the register specified by
//		index using serial indirect I/O.
//
//	PARAMETERS:
//		index	- The register offset to read data from
//
//	RETURNS:
//		The 8-bit value read from the register.
//---------------------------------------------------------------------------
UInt8 halpSerReadReg8( UInt32 index )
{
	UInt8 val;

	halSetProcessExclusivity( TRUE );

	*HalIndInfo.pIndex8  = SER_SET_ADDR;
	*HalIndInfo.pData8   = LOBYTE(index);
	*HalIndInfo.pData8   = HIBYTE(index);
	*HalIndInfo.pIndex8 = SER_READ;
	val = *HalIndInfo.pData8;

	halSetProcessExclusivity( FALSE );
	return val;
}


//---------------------------------------------------------------------------
//	FUNCTION: halpSerReadReg16()
//
//	DESCRIPTION:
//		This routine reads two eight bit registers using serial indirect I/O
//		and returns the result as a sixteen bit value. Must always read 8-bit values.
//
//	PARAMETERS:
//		index	- the register offset to read the LSB of the return value.
//
//	RETURNS:
//		The sixteen bit combined value of the two registers.
//---------------------------------------------------------------------------
UInt16 halpSerReadReg16( UInt32 index )
{
	UInt16 val;

	halSetProcessExclusivity( TRUE );

	// Read first 8-bit value.
	*HalIndInfo.pIndex8 = SER_SET_ADDR;
	*HalIndInfo.pData8  = LOBYTE(index);
	*HalIndInfo.pData8  = HIBYTE(index);
	*HalIndInfo.pIndex8 = SER_READ;
	val = *HalIndInfo.pData8;

	// Read second 8-bit value.
	index++;
	*HalIndInfo.pIndex8 = SER_SET_ADDR;
	*HalIndInfo.pData8  = LOBYTE(index);
	*HalIndInfo.pData8  = HIBYTE(index);
	*HalIndInfo.pIndex8 = SER_READ;
	val |= (UInt16)(*HalIndInfo.pData8)<<8;

	halSetProcessExclusivity( FALSE );
	return val;
}


//---------------------------------------------------------------------------
//	FUNCTION: halpIndirectReadReg32()
//
//	DESCRIPTION:
//		This routine reads four eight bit registers using serial indirect I/O
//		and returns the result as a thirty-two bit value.
//
//	PARAMETERS:
//		index	- the register offset to read the LSB of the return value.
//
//	RETURNS:
//		The thirty-two bit combined value of the four registers.
//---------------------------------------------------------------------------
UInt32 halpSerReadReg32( UInt32 index )
{
	UInt8	hibyte;
	UInt16	loword, hiword;

	halSetProcessExclusivity( TRUE );

	hibyte = HIBYTE(index);
	*HalIndInfo.pIndex8  = SER_SET_ADDR;
	*HalIndInfo.pData8   = LOBYTE(index);
	*HalIndInfo.pData8   = HIBYTE(index);
	*HalIndInfo.pIndex8 = SER_READ;
	loword  = *HalIndInfo.pData8;
	loword |= (UInt16)(*HalIndInfo.pData8<<8);

	*HalIndInfo.pIndex8  = SER_SET_ADDR;
	*HalIndInfo.pData8   = LOBYTE(index+2);
	if( hibyte!=HIBYTE(index+2) )
		*HalIndInfo.pData8   = HIBYTE(index+2);
	*HalIndInfo.pIndex8 = SER_READ;
	hiword  = *HalIndInfo.pData8;
	hiword |= (UInt16)(*HalIndInfo.pData8<<8);

	halSetProcessExclusivity( FALSE );
	return MAKELONG(loword, hiword);
}


//---------------------------------------------------------------------------
//	FUNCTION: halpIndirectWriteDisplay8()
//
//	DESCRIPTION:
//		This routine writes one eight bit value to the specified display
//		memory offset using serial indirect I/O.
//
//	PARAMETERS:
//		addr	- The offset in display memory to write the value to.
//		data	- The eight bit value to be written to display memory.
//---------------------------------------------------------------------------
void halpSerWriteDisplay8( UInt32 addr, UInt8 data, UInt32 count )
{
	UInt32 loop;

	halSetProcessExclusivity( TRUE );

	SetDisplayAddrSerial(addr);
	
	*HalIndInfo.pIndex8  = SER_WRITE;
	for (loop = 0; loop < count; loop++)
		*HalIndInfo.pData8 = data;

	halSetProcessExclusivity( FALSE );
}


//---------------------------------------------------------------------------
//	FUNCTION: halpIndirectWriteDisplay16()
//
//	DESCRIPTION:
//		This routine writes one sixteen bit value to two consective
//		display memory addresses using serial indirect I/O.
//
//	PARAMETERS:
//		addr	- The offset in display memory to write the LSB of value to
//				  The MSB will be wrtten 
//		data	- The 16-bit value to be written to display memory.
//---------------------------------------------------------------------------
void halpSerWriteDisplay16( UInt32 addr, UInt16 data, UInt32 count )
{
	UInt32 loop;

	halSetProcessExclusivity( TRUE );

	SetDisplayAddrSerial(addr);
	
	*HalIndInfo.pIndex8  = SER_WRITE;
	if (HalInfo.dwFlags & fINDIRECT_DATA16)
    {
	    for (loop = 0; loop < count; loop++)
		    *HalIndInfo.pData16 = data;
    } else
    {
	    for (loop = 0; loop < count; loop++)
        {
		    *HalIndInfo.pData8 = LOBYTE(data);
		    *HalIndInfo.pData8 = HIBYTE(data);
        }   
    }
	halSetProcessExclusivity( FALSE );
}


//---------------------------------------------------------------------------
//	FUNCTION: halpIndirectWriteDisplay32()
//
//	DESCRIPTION:
//		This routine writes four consective eight bit display memory addresses
//		with the thirty-two bits of data using serial indirect I/O.
//
//	PARAMETERS:
//		addr	- Specifies the offset to the LSB of the data to be written
//		data	- The 32-bit data to be written to the specified address
//---------------------------------------------------------------------------
void halpSerWriteDisplay32( UInt32 addr, UInt32 data, UInt32 count )
{
	UInt32 loop;

	halSetProcessExclusivity( TRUE );

	SetDisplayAddrSerial(addr);
	
	*HalIndInfo.pIndex8  = SER_WRITE;
	if (HalInfo.dwFlags & fINDIRECT_DATA16)
	{
		for (loop = 0; loop < count; loop++)
		{
			*HalIndInfo.pData16 = LOWORD(data);
			*HalIndInfo.pData16 = HIWORD(data);
		}
	} else
	{
		for (loop = 0; loop < count; loop++)
		{
			*HalIndInfo.pData8 = LOBYTE(LOWORD(data));
			*HalIndInfo.pData8 = HIBYTE(LOWORD(data));
			*HalIndInfo.pData8 = LOBYTE(HIWORD(data));
			*HalIndInfo.pData8 = HIBYTE(HIWORD(data));
		}
	}

	halSetProcessExclusivity( FALSE );
}


//---------------------------------------------------------------------------
//	FUNCTION: halpSerReadDisplay8()
//
//	DESCRIPTION:
//		This routine reads one eight bit value from the specified display
//		memory address using serial indirect I/O.
//
//	PARAMETERS:
//		addr	- The address to read from
//
//	RETURNS:
//		The value read from the offset specified by addr.
//---------------------------------------------------------------------------
UInt8 halpSerReadDisplay8( UInt32 addr )
{
	UInt8 val;

	halSetProcessExclusivity( TRUE );

	SetDisplayAddrSerial(addr);
	
	*HalIndInfo.pIndex8  = SER_READ;
	val = *HalIndInfo.pData8;

	halSetProcessExclusivity( FALSE );

	return val;
}



//---------------------------------------------------------------------------
//	FUNCTION: halpSerReadDisplay16()
//
//	DESCRIPTION:
//		This routine reads sixteen bits of data (word) from the specified
//		display memory offset using serial indirect I/O.
//
//	PARAMETERS:
//		addr	- The address to read the LSB of data from
//
//	RETURNS:
//		The 16-bit value read from display memory.
//---------------------------------------------------------------------------
UInt16 halpSerReadDisplay16( UInt32 addr )
{
	UInt16 val;

	halSetProcessExclusivity( TRUE );

	SetDisplayAddrSerial(addr);
	
	*HalIndInfo.pIndex8  = SER_READ;
	if (HalInfo.dwFlags & fINDIRECT_DATA16)
	    val = *HalIndInfo.pData16;
    else
    {
	    val  = *HalIndInfo.pData8;
	    val |= (UInt16)((*HalIndInfo.pData8)<<8);
    }

	halSetProcessExclusivity( FALSE );

	return val;
}


//---------------------------------------------------------------------------
//	FUNCTION: halpSerReadDisplay32()
//
//	DESCRIPTION:
//		This routine reads thirty-two bits of data (dword) from the specified
//		display memory offset using serial indirect I/O.
//
//	PARAMETERS:
//		addr	- The address to read the LSB of data from
//
//	RETURNS:
//		The 32-bit value read from display memory.
//---------------------------------------------------------------------------
UInt32 halpSerReadDisplay32( UInt32 addr )
{
	UInt16 loword, hiword;

	halSetProcessExclusivity( TRUE );

	SetDisplayAddrSerial(addr);