i2c.c

WinCE5.0BSP for Renesas SH7770

	)
{
DWORD	Length;
PBYTE	pWrite = (PBYTE)pBuf;
RegMCR	mcr;
RegMIER	mier;
RegMSR	msr;
PI2C_DRIVER_INFO	pI2c = pOpen -> pI2CHandle;

	if ( dwLen < 2 ) return 0;

	if ( InitializeI2C(pOpen, TRUE) == FALSE )
		goto write_failure;
	if ( SetCCR(pOpen) == FALSE )
		goto write_failure;

	try {
		mcr.AsDWORD = READ_REGISTER_ULONG(pI2c -> MCR);
		mcr.bits.ESG = 0;
		mcr.bits.MIE = 1;
		mcr.bits.TSBE = 0;
		mcr.bits.FSB = 0;
		if ( pOpen -> bSingleStage == TRUE ){
			mcr.bits.MDBS = 1;
		}else{
			mcr.bits.MDBS = 0;
		}
		WRITE_REGISTER_ULONG(pI2c -> MCR, mcr.AsDWORD);
		mcr.AsDWORD = READ_REGISTER_ULONG(pI2c -> MCR);
	} except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
		EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
		goto write_failure;
	}

	if ( mcr.bits.FSDA ){
//	Other I2C device is using the I2C bus.
		SetLastError( I2C_BUS_BUSY );
		goto write_failure;
	}

	try {
		WRITE_REGISTER_ULONG(pI2c -> MAR, *(pWrite++) & 0xfe);
		dwLen --;
		WRITE_REGISTER_ULONG(pI2c -> TXD, *pWrite);
	} except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
		EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
		goto write_failure;
	}
	ResetEvent( pI2c -> hIntEvent );

	mier.AsDWORD = 0;
	mier.bits.MATE = 1;
	mier.bits.MDEE = 1;
	mier.bits.MALE = 1;
	mier.bits.MNRE = 1;
	mier.bits.MSTE = 1;
	try {
		WRITE_REGISTER_ULONG(pI2c -> MIER, mier.AsDWORD);
	} except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
		EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
		goto write_failure;
	}

	pI2c -> data -> dwType = I2C_MASTER_TX;
	pI2c -> data -> dwCount = dwLen;
	pI2c -> data -> dwPoint = 1;
	for( Length = 0;Length < dwLen;Length ++ ){
		pI2c -> data -> bBuffer[Length] = *(pWrite++);
	}

	mcr.bits.ESG = 1;

	try {
		WRITE_REGISTER_ULONG(pI2c -> MCR, mcr.AsDWORD);
	} except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
		EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
		goto write_failure;
	}

	if ( WaitForSingleObject(pI2c -> hIntEvent, I2C_WRITE_TIMEOUT) == WAIT_TIMEOUT ){
		SetLastError( I2C_TIMEOUT );
		goto write_failure;
	}
	// for 100Kbps
	Sleep(1);
	try {
		msr.AsDWORD = READ_REGISTER_ULONG(pI2c -> MSR);
	} except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
		EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
		goto write_failure;
	}

	if ( msr.bits.MAL ){
		SetLastError( I2C_MASTER_ARBITRATION_LOST );
		goto write_failure;
	}
	if ( msr.bits.MNR ){
		SetLastError( I2C_MASTER_NACK_RECEIVED );
		goto write_failure;
	}

	try {
		msr.AsDWORD = 0;
		WRITE_REGISTER_ULONG(pI2c -> MSR, msr.AsDWORD);
		mcr.bits.MIE = 0;
		WRITE_REGISTER_ULONG(pI2c -> MCR, mcr.AsDWORD);
	} except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
		EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
		goto write_failure;
	}
	return pI2c -> data -> dwPoint;

write_failure:
	DEBUGMSG(ZONE_ERROR, (TEXT("Write failure\r\n")));
	try {
		msr.AsDWORD = 0;
		mcr.AsDWORD = 0;

		WRITE_REGISTER_ULONG(pI2c -> MSR, msr.AsDWORD);
		WRITE_REGISTER_ULONG(pI2c -> MIER, 0);
		WRITE_REGISTER_ULONG(pI2c -> MCR, READ_REGISTER_ULONG(pI2c -> MCR) & mcr.AsDWORD);

	} except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
		EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
	}
	return 0;
}

DWORD
I2C_MasterRead(
	PI2C_OPEN_INFO		pOpen,
	LPCVOID				pBuf,
	DWORD				dwLen
	)
{
DWORD	Length;
PBYTE	pRead = (PBYTE)pBuf;
RegMCR	mcr;
RegMIER	mier;
RegMSR	msr;
PI2C_DRIVER_INFO pI2c = pOpen -> pI2CHandle;

	InitializeI2C(pOpen, TRUE);
	try {
		mcr.AsDWORD = READ_REGISTER_ULONG(pI2c -> MCR);
		mcr.bits.ESG = 0;
		mcr.bits.MIE = 1;
		mcr.bits.FSB = 0;
		if ( pOpen -> bSingleStage == TRUE ){
			mcr.bits.MDBS = 1;
		}else{
			mcr.bits.MDBS = 0;
		}
		WRITE_REGISTER_ULONG(pI2c -> MCR, mcr.AsDWORD);
	} except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
		EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
		return 0;
	}
	if ( SetCCR(pOpen) == FALSE ){
		return 0;
	}
	try {
		mcr.AsDWORD = READ_REGISTER_ULONG(pI2c -> MCR);
	} except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
		EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
		return 0;
	}
	if ( mcr.bits.FSDA ){
//	Other I2C device is using the I2C bus.
		mcr.AsDWORD = 0;
		mcr.bits.FSB = 1;
		WRITE_REGISTER_ULONG(pI2c -> MCR, READ_REGISTER_ULONG(pI2c -> MCR) & mcr.AsDWORD);
		SetLastError( I2C_BUS_BUSY );
		return 0;
	}

	try {
		mier.AsDWORD = 0;
		mier.bits.MATE = 1;
		mier.bits.MDRE = 1;
		mier.bits.MSTE = 1;
		mier.bits.MALE = 1;
		mier.bits.MNRE = 1;
		WRITE_REGISTER_ULONG(pI2c -> MIER, mier.AsDWORD);
		WRITE_REGISTER_ULONG(pI2c -> MAR, *pRead | 0x01);
	} except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
		EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
		return 0;
	}

	pI2c -> data -> dwType = I2C_MASTER_RX;
	pI2c -> data -> dwPoint = 0;
	pI2c -> data -> dwCount = dwLen;
	ResetEvent( pI2c -> hIntEvent );

	mcr.bits.ESG = 1;
	if ( dwLen == 1 ){
		mcr.bits.FSB = 1;
	}
	try {
		WRITE_REGISTER_ULONG(pI2c -> MCR, mcr.AsDWORD);
	} except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
		EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
		return 0;
	}

	if ( WaitForSingleObject(pI2c -> hIntEvent, I2C_READ_TIMEOUT) != WAIT_TIMEOUT ){
		for( Length = 0;Length < pI2c -> data -> dwPoint;Length ++ ){
			*(pRead++) = pI2c -> data -> bBuffer[Length];
		}
	}
	else{
		Length = 0;
		SetLastError( I2C_TIMEOUT );
	}

	try {
		msr.AsDWORD = READ_REGISTER_ULONG(pI2c -> MSR);
		if ( msr.bits.MAL ){
			SetLastError( I2C_MASTER_ARBITRATION_LOST );
			msr.bits.MAL = 0;
			WRITE_REGISTER_ULONG(pI2c -> MSR, msr.AsDWORD);
			Length = 0;
		}
//	WRITE_REGISTER_ULONG(pI2c -> MIER, 0);
		msr.AsDWORD = 0;
		mcr.AsDWORD = 0;
		mcr.bits.FSB = 1;

		WRITE_REGISTER_ULONG(pI2c -> MSR, msr.AsDWORD);
		WRITE_REGISTER_ULONG(pI2c -> MCR, READ_REGISTER_ULONG(pI2c -> MCR) & mcr.AsDWORD);
	} except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
		EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
		return 0;
	}
	return Length;

}

DWORD
I2C_SlaveWrite(
	PI2C_OPEN_INFO		pOpen,
	LPVOID				pBuf,
	DWORD				dwLen
	)
{
PBYTE	pWrite = (PBYTE)pBuf;
RegSCR	scr;
RegSIER	sier;
DWORD	Length;
PI2C_DRIVER_INFO pI2c = pOpen -> pI2CHandle;


	if ( InitializeI2C(pOpen, FALSE) == FALSE )
		goto write_failure;

	try {
		scr.AsDWORD = 0;
		scr.bits.SIE = 1;
		if ( pOpen -> bSingleStage == TRUE ){
			scr.bits.SDBS = 1;
		}else{
			scr.bits.SDBS = 0;
		}
		WRITE_REGISTER_ULONG(pI2c -> SAR, *(pWrite++));
		dwLen --;
		WRITE_REGISTER_ULONG(pI2c -> SCR, scr.AsDWORD);
		WRITE_REGISTER_ULONG(pI2c -> TXD, *pWrite);
	} except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
		EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
		goto write_failure;
	}

	pI2c -> data -> dwType = I2C_SLAVE_TX;
	pI2c -> data -> dwCount = dwLen;
	pI2c -> data -> dwPoint = 1;
	for( Length = 0;Length < dwLen;Length ++ ){
		pI2c -> data -> bBuffer[Length] = *(pWrite++);
	}

	try {
		sier.AsDWORD = 0;
		sier.bits.SARE = 1;
		sier.bits.SDEE = 1;
		sier.bits.SSRE = 1;
		WRITE_REGISTER_ULONG(pI2c -> SIER, sier.AsDWORD);
	} except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
		EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
		goto write_failure;
	}

	ResetEvent( pI2c -> hIntEvent );

	if ( WaitForSingleObject(pI2c -> hIntEvent, I2C_SWRITE_TIMEOUT) == WAIT_TIMEOUT ){
		SetLastError( I2C_TIMEOUT );
		goto write_failure;
	}
	try {
		sier.AsDWORD = 0;
		WRITE_REGISTER_ULONG(pI2c -> SIER, sier.AsDWORD);
		scr.AsDWORD = 0;
		WRITE_REGISTER_ULONG(pI2c -> SCR, scr.AsDWORD);
	} except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
		EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
		goto write_failure;
	}
	return pI2c -> data -> dwPoint;

write_failure:
	try {
		sier.AsDWORD = 0;
		WRITE_REGISTER_ULONG(pI2c -> SIER, sier.AsDWORD);
		scr.AsDWORD = 0;
		WRITE_REGISTER_ULONG(pI2c -> SCR, scr.AsDWORD);
	} except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
		EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
	}
	return 0;
}

DWORD
I2C_SlaveRead(
	PI2C_OPEN_INFO		pOpen,
	LPCVOID				pBuf,
	DWORD				dwLen
	)
{
DWORD	Length;
PBYTE	pRead = (PBYTE)pBuf;
RegSCR	scr;
//RegSSR	ssr;
RegSIER	sier;
PI2C_DRIVER_INFO pI2c = pOpen -> pI2CHandle;

	if ( InitializeI2C(pOpen, pOpen -> dwBaudrate) == FALSE )
		return 0;

	try {
		WRITE_REGISTER_ULONG(pI2c -> SAR, *pRead);

		scr.AsDWORD = 0;
		scr.bits.SIE = 1;
		if ( pOpen -> bSingleStage == TRUE ){
			scr.bits.SDBS = 1;
		}else{
			scr.bits.SDBS = 0;
		}
		WRITE_REGISTER_ULONG(pI2c -> SCR, scr.AsDWORD);

		pI2c -> data -> dwType = I2C_SLAVE_RX;
		pI2c -> data -> dwPoint = 0;
		pI2c -> data -> dwCount = dwLen;

		sier.AsDWORD = 0;
		sier.bits.SARE = 1;
		sier.bits.SDRE = 1;
		sier.bits.SSRE = 1;
		WRITE_REGISTER_ULONG(pI2c -> SIER, sier.AsDWORD);
	} except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
		EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
		return 0;
	}
	ResetEvent( pI2c -> hIntEvent );

	if ( WaitForSingleObject(pI2c -> hIntEvent, I2C_SREAD_TIMEOUT) != WAIT_TIMEOUT ){
		for( Length = 0;Length < pI2c -> data -> dwPoint;Length ++ ){
			*(pRead++) = pI2c -> data -> bBuffer[Length];
		}
	}else{
		SetLastError(I2C_TIMEOUT);
		Length = 0;
	}

	try {
		sier.AsDWORD = 0;
		WRITE_REGISTER_ULONG(pI2c -> SIER, sier.AsDWORD);
		scr.AsDWORD = 0;
		WRITE_REGISTER_ULONG(pI2c -> SCR, scr.AsDWORD);
	} except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
		EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
		return 0;
	}
	return Length;
}