/******************************************************************************
/
/	File:			I2C.cpp
/
/	Description:	ATI Radeon I2C Serial Bus interface.
/
/	Copyright 2001, Carlos Hasan
/
*******************************************************************************/

#include <Debug.h>
#include "I2CPort.h"

CI2CPort::CI2CPort(CRadeon & radeon, int rate)
	:	fRadeon(radeon),
		fNfactor(0),
		fMfactor(0),
		fTimeLimit(0),
		si(NULL)
{
	
	PRINT(("CI2CPort::CI2CPort()\n"));
	
	if( fRadeon.InitCheck() == B_OK ) {
		int refFreq, refDiv, minFreq, maxFreq, xclock;
		double n;
		
		fRadeon.GetPLLParameters(refFreq, refDiv, minFreq, maxFreq, xclock);
		si = fRadeon.GetSharedInfo();
		
		if ( si->asic == rt_rv200 ) {
			n = (xclock * 40000.0) / (1.0 * rate);
		} else {
			n = (xclock * 10000.0) / (4.0 * rate);
		}
		
		for (fNfactor = 1; fNfactor < 255; fNfactor++) {
			if (fNfactor * (fNfactor - 1) > n)
				break;
		}
		fMfactor = fNfactor - 1;
		fTimeLimit = 2 * fNfactor;
	
		// enable I2C bus
		fRadeon.SetRegister(C_RADEON_I2C_CNTL_1, 0x00ff0000,
			C_RADEON_I2C_SEL | C_RADEON_I2C_EN);
		
		fRadeon.SetRegister(C_RADEON_I2C_CNTL_0, 0x000000ff,
			C_RADEON_I2C_DONE | C_RADEON_I2C_NACK |
			C_RADEON_I2C_HALT | C_RADEON_I2C_SOFT_RST |
			C_RADEON_I2C_DRIVE_EN | C_RADEON_I2C_DRIVE_SEL);
			
#if DEBUG
		PRINT(("CI2CPort::CI2CPort() - I2C devices found at ports: "));
		for (int address = 0x80; address <= 0xff; address += 0x02) {
			if (Probe(address))
				PRINT(("0x%02x ", address));
		}
		PRINT(("\n"));
#endif
	}
}

CI2CPort::~CI2CPort()
{
	PRINT(("CI2CPort::~CI2CPort()\n"));
	if( fRadeon.InitCheck() == B_OK ) {
		// disable I2C bus
		fRadeon.SetRegister(C_RADEON_I2C_CNTL_1, 0);
	}
}

status_t CI2CPort::InitCheck() const
{
	if (fRadeon.InitCheck() != B_OK)
		return B_ERROR;
		
	if ( si == NULL )
		return B_ERROR;
	
	if ( si->has_no_i2c ) {
		PRINT(("This Chips I2C is BLACKLISTED!"));
		return B_ERROR;
	}	
	return B_OK;
}

CRadeon & CI2CPort::Radeon() const
{
	return fRadeon;
}

bool CI2CPort::Probe(int address)
{
	char buffer[1];
	
	return Read(address, buffer, sizeof(buffer));
}

bool CI2CPort::Write(int address, const char * buffer, int length)
{
	if (Send(address, buffer, length, true, true) == length)
		return true;
	return false;
}

bool CI2CPort::Read(int address, char * buffer, int length)
{
	if (Receive(address, buffer, length, true, true) == length)
		return true;
	return false;
}

bool CI2CPort::Write(int address, const char * buffer, int length, char * result, int reslen)
{
	if (Send(address, buffer, length, true, false) == length)
		if (Receive(address, result, reslen, true, true) == reslen)
			return true;
	return false;
}

int CI2CPort::Register(int address, int index)
{
	char value = index;

	if (Send(address, &value, sizeof(value), true, false) == sizeof(value)) {
		if (Receive(address, &value, sizeof(value), true, true) == sizeof(value))
			return value & 0xff;
	}
	PRINT(("CI2CPort::Register() - error\n"));
	return -1;
}

void CI2CPort::SetRegister(int address, int index, int value)
{
	char buffer[2];
	
	buffer[0] = index;
	buffer[1] = value;
	
	if (Send(address, buffer, sizeof(buffer), true, true) != sizeof(buffer))
		PRINT(("CI2CPort::SetRegister() - error\n"));
}

int CI2CPort::Send(int address, const char * buffer, int length, bool start, bool stop)
{
	//fRadeon.WaitForFifo(4 + length);
	
	// clear status bit
	fRadeon.SetRegister(C_RADEON_I2C_CNTL_0,
		C_RADEON_I2C_DONE |	C_RADEON_I2C_NACK |
		C_RADEON_I2C_HALT |	C_RADEON_I2C_SOFT_RST);

	// write address
	fRadeon.SetRegister(C_RADEON_I2C_DATA, address & ~(1));

	// write data
	for (int offset = 0; offset < length; offset++)
		fRadeon.SetRegister(C_RADEON_I2C_DATA, buffer[offset]);

	//
	if (si->asic >= rt_r200) {
		fRadeon.SetRegister(C_RADEON_I2C_CNTL_1,
			(fTimeLimit << 24) | length |
			C_RADEON_I2C_EN | C_RADEON_I2C_SEL | 0x010);
	} else {
		fRadeon.SetRegister(C_RADEON_I2C_CNTL_1,
			(fTimeLimit << 24) | length |
			C_RADEON_I2C_EN | C_RADEON_I2C_SEL | 0x100);
	}
	
	fRadeon.SetRegister(C_RADEON_I2C_CNTL_0,
		(fNfactor << 24) | (fMfactor << 16) |
		C_RADEON_I2C_GO | C_RADEON_I2C_DRIVE_EN |
		(start ? C_RADEON_I2C_START : 0) | (stop ? C_RADEON_I2C_STOP : 0));
		
	for (int wait = 0; wait < 100; wait++) {
		if ((fRadeon.Register(C_RADEON_I2C_CNTL_0) & C_RADEON_I2C_GO) == 0)
			break;
	}

	if (WaitAck() != C_RADEON_I2C_DONE) {
		Stop();
		return 0;
	}
	
	return length;
}

int CI2CPort::Receive(int address, char * buffer, int length, bool start, bool stop)
{
	//fRadeon.WaitForFifo(length + 4);
	
	fRadeon.SetRegister(C_RADEON_I2C_CNTL_0,
		C_RADEON_I2C_DONE | C_RADEON_I2C_NACK |
		C_RADEON_I2C_HALT | C_RADEON_I2C_SOFT_RST);
	
	fRadeon.SetRegister(C_RADEON_I2C_DATA, address | 0x00000001);
	
	if (si->asic >= rt_r200) {
		fRadeon.SetRegister(C_RADEON_I2C_CNTL_1,
			(fTimeLimit << 24) | C_RADEON_I2C_EN | C_RADEON_I2C_SEL |
			length | 0x010);
	} else {
		fRadeon.SetRegister(C_RADEON_I2C_CNTL_1,
			(fTimeLimit << 24) | C_RADEON_I2C_EN | C_RADEON_I2C_SEL |
			length | 0x100);
	}
		
	fRadeon.SetRegister(C_RADEON_I2C_CNTL_0,
		(fNfactor << 24) | (fMfactor << 16) | C_RADEON_I2C_GO |
		(start ? C_RADEON_I2C_START : 0) | (stop ? C_RADEON_I2C_STOP : 0) |
		C_RADEON_I2C_DRIVE_EN | C_RADEON_I2C_RECEIVE);
	
	
	for (int wait = 0; wait < 100; wait++) {
		if ((fRadeon.Register(C_RADEON_I2C_CNTL_0) & C_RADEON_I2C_GO) == 0)
			break;
	}

	if (WaitAck() != C_RADEON_I2C_DONE)
		return 0;

	snooze(1000);
	
	for (int offset = 0; offset < length; offset++) {
		//fRadeon.WaitForFifo(1);
		buffer[offset] = fRadeon.Register(C_RADEON_I2C_DATA) & 0xff;
	}

	return length;
}

int CI2CPort::WaitAck()
{
	for (int wait = 0; wait < 100; wait++) {
		int control = fRadeon.Register(C_RADEON_I2C_CNTL_0);
		if ((control & C_RADEON_I2C_HALT) != 0)
			return C_RADEON_I2C_HALT;
		if ((control & C_RADEON_I2C_NACK) != 0)
			return C_RADEON_I2C_NACK;
		if ((control & C_RADEON_I2C_DONE) != 0)
			return C_RADEON_I2C_DONE;
		snooze(1000);
	}
	PRINT(("CI2CPort::WaitAck() - Time out!\n"));
	return C_RADEON_I2C_HALT;		
}

void CI2CPort::Stop()
{
	// reset status flags
	fRadeon.SetRegister(C_RADEON_I2C_CNTL_0,
		C_RADEON_I2C_DONE | C_RADEON_I2C_NACK | C_RADEON_I2C_HALT, 0);

	// issue abort call
	fRadeon.SetRegister(C_RADEON_I2C_CNTL_0_PLUS1,
		C_RADEON_I2C_ABORT | C_RADEON_I2C_GO, C_RADEON_I2C_ABORT | C_RADEON_I2C_GO);
	
	// wait GO bit to go low
	for (int wait = 0; wait < 100; wait++) {
		if ((fRadeon.Register(C_RADEON_I2C_CNTL_0) & C_RADEON_I2C_GO) == 0)
		snooze(1000);
	}
	PRINT(("CI2CPort::Stop() - Time out!\n"));
}