?? hal_indirect16.c
字號:
// This routine reads one eight bit value from the specified display
// memory address using parallel indirect I/O.
//
// PARAMETERS:
// addr - The address to read from
//
// 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.pData16;
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.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 )
?? 快捷鍵說明
復制代碼
Ctrl + C
搜索代碼
Ctrl + F
全屏模式
F11
切換主題
Ctrl + Shift + D
顯示快捷鍵
?
增大字號
Ctrl + =
減小字號
Ctrl + -