You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
515 lines
13 KiB
515 lines
13 KiB
/*++
|
|
|
|
Copyright (c) 1990-2001 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
i2c2.c
|
|
|
|
Abstract:
|
|
|
|
This is the NT Video port I2C helper code for interface version 2.
|
|
|
|
Author:
|
|
|
|
Michael Maciesowicz (mmacie) 23-Apr-2001
|
|
|
|
Environment:
|
|
|
|
kernel mode only
|
|
|
|
Notes:
|
|
|
|
--*/
|
|
|
|
#include "videoprt.h"
|
|
|
|
//
|
|
// Define constants used by I2C.
|
|
//
|
|
|
|
#define I2C_START_RETRIES 10
|
|
#define I2C_SCL_READ_RETRIES 10
|
|
#define I2C_DELAY(pI2CControl) DELAY_MICROSECONDS((pI2CControl)->I2CDelay / 10)
|
|
|
|
#ifdef ALLOC_PRAGMA
|
|
#pragma alloc_text (PAGE, I2CStart2)
|
|
#pragma alloc_text (PAGE, I2CStop2)
|
|
#pragma alloc_text (PAGE, I2CWrite2)
|
|
#pragma alloc_text (PAGE, I2CRead2)
|
|
#pragma alloc_text (PAGE, I2CWriteByte2)
|
|
#pragma alloc_text (PAGE, I2CReadByte2)
|
|
#pragma alloc_text (PAGE, I2CWaitForClockLineHigh2)
|
|
#endif // ALLOC_PRAGMA
|
|
|
|
//
|
|
// Routines exported via VideoPortQueryServices().
|
|
//
|
|
|
|
BOOLEAN
|
|
I2CStart2(
|
|
IN PVOID pHwDeviceExtension,
|
|
IN PVIDEO_I2C_CONTROL pI2CControl
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine starts I2C communication.
|
|
|
|
Arguments:
|
|
|
|
pHwDeviceExtension - Points to per-adapter device extension.
|
|
pI2CControl - I2C hardware specific functions.
|
|
|
|
Returns:
|
|
|
|
TRUE - Start OK.
|
|
FALSE - Start failed.
|
|
|
|
--*/
|
|
|
|
{
|
|
ULONG ulRetry;
|
|
|
|
PAGED_CODE();
|
|
ASSERT(NULL != pHwDeviceExtension);
|
|
ASSERT(NULL != pI2CControl);
|
|
ASSERT(NULL != pI2CControl->WriteClockLine);
|
|
ASSERT(NULL != pI2CControl->WriteDataLine);
|
|
ASSERT(NULL != pI2CControl->ReadClockLine);
|
|
ASSERT(NULL != pI2CControl->ReadDataLine);
|
|
ASSERT(IS_HW_DEVICE_EXTENSION(pHwDeviceExtension) == TRUE);
|
|
|
|
//
|
|
// The I2C communications start signal is a SDA high->low while the SCL is high.
|
|
//
|
|
|
|
for (ulRetry = 0; ulRetry <= I2C_START_RETRIES; ulRetry++)
|
|
{
|
|
pI2CControl->WriteDataLine(pHwDeviceExtension, 1); // Set SDA high
|
|
I2C_DELAY(pI2CControl);
|
|
if (pI2CControl->ReadDataLine(pHwDeviceExtension) == FALSE) // SDA didn't take - ulRetry
|
|
continue;
|
|
pI2CControl->WriteClockLine(pHwDeviceExtension, 1); // Set SCL high
|
|
I2C_DELAY(pI2CControl);
|
|
if (I2CWaitForClockLineHigh2(pHwDeviceExtension, pI2CControl) == FALSE)
|
|
{
|
|
pVideoDebugPrint((Warn, "VIDEOPRT: I2CStart2: SCL didn't take\n"));
|
|
break;
|
|
}
|
|
pI2CControl->WriteDataLine(pHwDeviceExtension, 0); // Set SDA low
|
|
I2C_DELAY(pI2CControl);
|
|
pI2CControl->WriteClockLine(pHwDeviceExtension, 0); // Set SCL low
|
|
I2C_DELAY(pI2CControl);
|
|
return TRUE;
|
|
}
|
|
|
|
pVideoDebugPrint((Warn, "VIDEOPRT: I2CStart2: Failed\n"));
|
|
return FALSE;
|
|
} // I2CStart2()
|
|
|
|
BOOLEAN
|
|
I2CStop2(
|
|
IN PVOID pHwDeviceExtension,
|
|
IN PVIDEO_I2C_CONTROL pI2CControl
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine stops I2C communication.
|
|
|
|
Arguments:
|
|
|
|
pHwDeviceExtension - Points to per-adapter device extension.
|
|
pI2CControl - I2C hardware specific functions.
|
|
|
|
Returns:
|
|
|
|
TRUE - Stop OK.
|
|
FALSE - Stop failed.
|
|
|
|
--*/
|
|
|
|
{
|
|
PAGED_CODE();
|
|
ASSERT(NULL != pHwDeviceExtension);
|
|
ASSERT(NULL != pI2CControl);
|
|
ASSERT(NULL != pI2CControl->WriteClockLine);
|
|
ASSERT(NULL != pI2CControl->WriteDataLine);
|
|
ASSERT(NULL != pI2CControl->ReadClockLine);
|
|
ASSERT(NULL != pI2CControl->ReadDataLine);
|
|
ASSERT(IS_HW_DEVICE_EXTENSION(pHwDeviceExtension) == TRUE);
|
|
|
|
//
|
|
// The I2C communications stop signal is a SDA low->high while the SCL is high.
|
|
//
|
|
|
|
pI2CControl->WriteDataLine(pHwDeviceExtension, 0); // Set SDA low
|
|
I2C_DELAY(pI2CControl);
|
|
pI2CControl->WriteClockLine(pHwDeviceExtension, 1); // Set SCL high
|
|
I2C_DELAY(pI2CControl);
|
|
if (I2CWaitForClockLineHigh2(pHwDeviceExtension, pI2CControl) == FALSE)
|
|
{
|
|
pVideoDebugPrint((Warn, "VIDEOPRT: I2CStop2: SCL didn't take\n"));
|
|
return FALSE;
|
|
}
|
|
pI2CControl->WriteDataLine(pHwDeviceExtension, 1); // Set SDA high
|
|
I2C_DELAY(pI2CControl);
|
|
if (pI2CControl->ReadDataLine(pHwDeviceExtension) != 1)
|
|
{
|
|
pVideoDebugPrint((Warn, "VIDEOPRT: I2CStop2: SDA didn't take\n"));
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
} // I2CStop2()
|
|
|
|
BOOLEAN
|
|
I2CWrite2(
|
|
IN PVOID pHwDeviceExtension,
|
|
IN PVIDEO_I2C_CONTROL pI2CControl,
|
|
IN PUCHAR pucBuffer,
|
|
IN ULONG ulLength
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine writes data over the I2C channel.
|
|
|
|
Arguments:
|
|
|
|
pHwDeviceExtension - Points to per-adapter device extension.
|
|
pI2CControl - I2C hardware specific functions.
|
|
pucBuffer - Points to data to be written.
|
|
ulLength - Number of bytes to write.
|
|
|
|
Returns:
|
|
|
|
TRUE - Write OK.
|
|
FALSE - Write failed.
|
|
|
|
--*/
|
|
|
|
{
|
|
ULONG ulCount;
|
|
|
|
PAGED_CODE();
|
|
ASSERT(NULL != pHwDeviceExtension);
|
|
ASSERT(NULL != pI2CControl);
|
|
ASSERT(NULL != pucBuffer);
|
|
ASSERT(NULL != pI2CControl->WriteClockLine);
|
|
ASSERT(NULL != pI2CControl->WriteDataLine);
|
|
ASSERT(NULL != pI2CControl->ReadClockLine);
|
|
ASSERT(NULL != pI2CControl->ReadDataLine);
|
|
ASSERT(IS_HW_DEVICE_EXTENSION(pHwDeviceExtension) == TRUE);
|
|
|
|
for (ulCount = 0; ulCount < ulLength; ulCount++)
|
|
{
|
|
if (I2CWriteByte2(pHwDeviceExtension, pI2CControl, pucBuffer[ulCount]) == FALSE)
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
} // I2CWrite2()
|
|
|
|
BOOLEAN
|
|
I2CRead2(
|
|
IN PVOID pHwDeviceExtension,
|
|
IN PVIDEO_I2C_CONTROL pI2CControl,
|
|
OUT PUCHAR pucBuffer,
|
|
IN ULONG ulLength,
|
|
IN BOOLEAN bEndOfRead
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine reads data over the I2C channel.
|
|
|
|
Arguments:
|
|
|
|
pHwDeviceExtension - Points to per-adapter device extension.
|
|
pI2CControl - I2C hardware specific functions.
|
|
pucBuffer - Points to storage for data.
|
|
ulLength - Number of bytes to read.
|
|
bEndOfRead - Indicates end of read requests so we can send NAK.
|
|
|
|
Returns:
|
|
|
|
TRUE - Read OK.
|
|
FALSE - Read failed.
|
|
|
|
--*/
|
|
|
|
{
|
|
ULONG ulCount;
|
|
|
|
PAGED_CODE();
|
|
ASSERT(NULL != pHwDeviceExtension);
|
|
ASSERT(NULL != pI2CControl);
|
|
ASSERT(NULL != pucBuffer);
|
|
ASSERT(NULL != pI2CControl->WriteClockLine);
|
|
ASSERT(NULL != pI2CControl->WriteDataLine);
|
|
ASSERT(NULL != pI2CControl->ReadClockLine);
|
|
ASSERT(NULL != pI2CControl->ReadDataLine);
|
|
ASSERT(IS_HW_DEVICE_EXTENSION(pHwDeviceExtension) == TRUE);
|
|
|
|
//
|
|
// On all but the last byte, we must send an ACK in order to ensure that the sending device will
|
|
// send subsequent data bytes. On the last byte, we must send a NAK so that it will shut up.
|
|
//
|
|
|
|
for (ulCount = 0; ulCount < ulLength; ulCount++)
|
|
{
|
|
if ((ulLength - 1 == ulCount && bEndOfRead))
|
|
{
|
|
if (I2CReadByte2(pHwDeviceExtension, pI2CControl, pucBuffer + ulCount, TRUE) == FALSE) // Last byte
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (I2CReadByte2(pHwDeviceExtension, pI2CControl, pucBuffer + ulCount, FALSE) == FALSE)
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
} // I2CRead2()
|
|
|
|
//
|
|
// Local routines.
|
|
//
|
|
|
|
BOOLEAN
|
|
I2CWriteByte2(
|
|
IN PVOID pHwDeviceExtension,
|
|
IN PVIDEO_I2C_CONTROL pI2CControl,
|
|
IN UCHAR ucByte
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine writes byte over the I2C channel.
|
|
|
|
Arguments:
|
|
|
|
pHwDeviceExtension - Points to per-adapter device extension.
|
|
pI2CControl - I2C hardware specific functions.
|
|
ucByte - Byte to write.
|
|
|
|
Returns:
|
|
|
|
TRUE - Write OK.
|
|
FALSE - Write failed.
|
|
|
|
--*/
|
|
|
|
{
|
|
LONG lShift;
|
|
UCHAR ucAck;
|
|
|
|
PAGED_CODE();
|
|
ASSERT(NULL != pHwDeviceExtension);
|
|
ASSERT(NULL != pI2CControl);
|
|
|
|
//
|
|
// Bits are transmitted serially starting with the MSB.
|
|
//
|
|
|
|
for (lShift = 7; lShift >= 0; lShift--)
|
|
{
|
|
//
|
|
// Transmitt data bit.
|
|
//
|
|
|
|
pI2CControl->WriteDataLine(pHwDeviceExtension, (UCHAR)((ucByte >> lShift) & 0x01)); // Set SDA
|
|
I2C_DELAY(pI2CControl);
|
|
|
|
//
|
|
// After each data bit we must send high->low SCL pulse.
|
|
//
|
|
|
|
pI2CControl->WriteClockLine(pHwDeviceExtension, 1); // Set SCL high
|
|
I2C_DELAY(pI2CControl);
|
|
if (I2CWaitForClockLineHigh2(pHwDeviceExtension, pI2CControl) == FALSE)
|
|
{
|
|
pVideoDebugPrint((Warn, "VIDEOPRT: I2CWriteByte2: SCL didn't take\n"));
|
|
return FALSE;
|
|
}
|
|
pI2CControl->WriteClockLine(pHwDeviceExtension, 0); // Set SCL low
|
|
I2C_DELAY(pI2CControl);
|
|
}
|
|
|
|
//
|
|
// The monitor sends ACK by preventing the SDA from going high after the clock pulse we use
|
|
// to send our last data bit. If the SDA goes high after this bit, it is a NAK from the monitor.
|
|
//
|
|
|
|
pI2CControl->WriteDataLine(pHwDeviceExtension, 1); // Set SDA high
|
|
I2C_DELAY(pI2CControl);
|
|
pI2CControl->WriteClockLine(pHwDeviceExtension, 1); // Set SCL high
|
|
I2C_DELAY(pI2CControl);
|
|
if (I2CWaitForClockLineHigh2(pHwDeviceExtension, pI2CControl) == FALSE)
|
|
{
|
|
pVideoDebugPrint((Warn, "VIDEOPRT: I2CWriteByte2: SCL didn't take - ACK failed\n"));
|
|
return FALSE;
|
|
}
|
|
ucAck = pI2CControl->ReadDataLine(pHwDeviceExtension); // Read ACK bit
|
|
pI2CControl->WriteClockLine(pHwDeviceExtension, 0); // Set SCL low
|
|
I2C_DELAY(pI2CControl);
|
|
|
|
if (1 == ucAck) // NAK from the monitor
|
|
{
|
|
pVideoDebugPrint((Warn, "VIDEOPRT: I2CWriteByte2: NAK received\n"));
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
} // I2CWriteByte2()
|
|
|
|
BOOLEAN
|
|
I2CReadByte2(
|
|
IN PVOID pHwDeviceExtension,
|
|
IN PVIDEO_I2C_CONTROL pI2CControl,
|
|
OUT PUCHAR pucByte,
|
|
IN BOOLEAN bEndOfRead
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine reads byte over the I2C channel.
|
|
|
|
Arguments:
|
|
|
|
pHwDeviceExtension - Points to per-adapter device extension.
|
|
pI2CControl - I2C hardware specific functions.
|
|
pucBuffer - Points to storage for data.
|
|
bEndOfRead - TRUE if this is last byte to read.
|
|
|
|
Returns:
|
|
|
|
TRUE - Read OK.
|
|
FALSE - Read failed.
|
|
|
|
--*/
|
|
|
|
{
|
|
LONG lShift;
|
|
|
|
PAGED_CODE();
|
|
ASSERT(NULL != pHwDeviceExtension);
|
|
ASSERT(NULL != pI2CControl);
|
|
ASSERT(NULL != pucByte);
|
|
|
|
*pucByte = 0;
|
|
|
|
//
|
|
// The data bits are read from MSB to LSB. A data bit is read while the SCL is high.
|
|
//
|
|
|
|
for (lShift = 7; lShift >= 0; lShift--)
|
|
{
|
|
pI2CControl->WriteClockLine(pHwDeviceExtension, 1); // Set SCL high
|
|
I2C_DELAY(pI2CControl);
|
|
if (I2CWaitForClockLineHigh2(pHwDeviceExtension, pI2CControl) == FALSE)
|
|
{
|
|
pVideoDebugPrint((Warn, "VIDEOPRT: I2CReadByte2: SCL didn't take\n"));
|
|
return FALSE;
|
|
}
|
|
*pucByte |= pI2CControl->ReadDataLine(pHwDeviceExtension) << lShift; // Read SDA
|
|
pI2CControl->WriteClockLine(pHwDeviceExtension, 0); // Set SCL low
|
|
I2C_DELAY(pI2CControl);
|
|
}
|
|
|
|
//
|
|
// Send the acknowledge bit. SDA low = ACK, SDA high = NAK.
|
|
//
|
|
|
|
if (bEndOfRead)
|
|
{
|
|
pI2CControl->WriteDataLine(pHwDeviceExtension, 1); // Set SDA high - NAK
|
|
}
|
|
else
|
|
{
|
|
pI2CControl->WriteDataLine(pHwDeviceExtension, 0); // Set SDA low - ACK
|
|
}
|
|
I2C_DELAY(pI2CControl);
|
|
|
|
//
|
|
// Send a SCL high->low pulse, then release the SDA by setting it high.
|
|
//
|
|
|
|
pI2CControl->WriteClockLine(pHwDeviceExtension, 1); // Set SCL high
|
|
I2C_DELAY(pI2CControl);
|
|
if (I2CWaitForClockLineHigh2(pHwDeviceExtension, pI2CControl) == FALSE)
|
|
{
|
|
pVideoDebugPrint((Warn, "VIDEOPRT: I2CReadByte2: SCL didn't take - ACK failed\n"));
|
|
return FALSE;
|
|
}
|
|
pI2CControl->WriteClockLine(pHwDeviceExtension, 0); // Set SCL low
|
|
I2C_DELAY(pI2CControl);
|
|
pI2CControl->WriteDataLine(pHwDeviceExtension, 1); // Set SDA high
|
|
I2C_DELAY(pI2CControl);
|
|
|
|
return TRUE;
|
|
} // I2CReadByte2()
|
|
|
|
BOOLEAN
|
|
I2CWaitForClockLineHigh2(
|
|
IN PVOID pHwDeviceExtension,
|
|
IN PVIDEO_I2C_CONTROL pI2CControl
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine waits till SCL goes high
|
|
(SCL low period can be stretched by slow devices).
|
|
|
|
Arguments:
|
|
|
|
pHwDeviceExtension - Points to per-adapter device extension.
|
|
pI2CControl - I2C hardware specific functions.
|
|
|
|
Returns:
|
|
|
|
TRUE - OK - SCL high.
|
|
FALSE - SCL didn't take.
|
|
|
|
--*/
|
|
|
|
{
|
|
ULONG ulCount;
|
|
|
|
PAGED_CODE();
|
|
ASSERT(NULL != pHwDeviceExtension);
|
|
ASSERT(NULL != pI2CControl);
|
|
|
|
for (ulCount = 0; ulCount < I2C_SCL_READ_RETRIES; ulCount++)
|
|
{
|
|
if (pI2CControl->ReadClockLine(pHwDeviceExtension) == TRUE)
|
|
return TRUE;
|
|
|
|
I2C_DELAY(pI2CControl);
|
|
}
|
|
|
|
return FALSE;
|
|
} // I2CWaitForClockLineHigh2()
|