/*
    ANY-LICENSE V1.0
    ----------------

    You can use these files under any license approved by the
    Open Source Initiative, preferrably one of the popular licenses,
    as long as the license you choose is compatible to the
    dependencies of these files.

    See http://www.opensource.org/licenses/ for a list of
    approved licenses.

    Author:     Martin Furter <mf@borg.ch>
    Project:    Tins AVR Lib
    Repository: http://repos.borg.ch/projects/tins_avr_lib/trunk
    Copyright:  2016
*/

#include <tal/i2c.h>
#include <avr/io.h>
#include <util/twi.h>

#if 0
#include <avr/pgmspace.h>
#include <tal/usart_funcs.h>
extern void flash_print( const char* PROGMEM str );
#define P(s)	do { static const char tmp_str[] PROGMEM = s; flash_print( tmp_str ); } while(0)
#else
#define P(x)
#define usart_add_hexbyte(x)
#endif

uint8_t i2c_last_status;
uint8_t i2c_exp_status;

void i2c_init( bool fast )
{
	// SCL-freq = F_CPU / 16+2(TWBR)
	// => 16+2(TWBR) = F_CPU / SCL-Freq
	// => 2(TWBR) = F_CPU / SCL-Freq - 16
	// => TWBR = (F_CPU / SCL-Freq - 16) / 2
	if( fast )
	{
		TWBR = (F_CPU / 400000 - 16) / 2;
	}
	else
	{
		TWBR = (F_CPU / 125000 - 16) / 2;
	}
	// TWPS1 TWPS0 prescaler values
	TWSR = 0;
	// TWSR = (1<<TWPS0);
	TWCR |= (1<<TWEN);
}

uint8_t i2c_write( uint8_t addr, uint8_t count, uint8_t* data )
{
	return i2c_write2( addr, count, data, 0, 0, false );
}

uint8_t i2c_write2( uint8_t addr, uint8_t count, uint8_t* data,
			uint8_t count2, uint8_t* data2, bool nostop )
{
	// increase count to include address
	if( count2 == 0 )
	{
		count++;
	}
	else
	{
		count2++;
	}
	// add write bit to address
	addr = (addr << 1) | TW_WRITE;

	// Send START condition.
	TWCR = (1<<TWINT) | (1<<TWSTA) | (1<<TWEN);
	// Wait for TWINT Flag set. This indicates that the START condition
	// has been transmitted.
	P( "start W\r\n" );
	while( !(TWCR & (1<<TWINT)) )
	{
	}
	P( "started\r\n" );
	// Check value of TWI Status Register. Mask prescaler bits. If status
	// different from START go to ERROR
	i2c_last_status = TW_STATUS;
	i2c_exp_status = TW_START;
	if( i2c_last_status != i2c_exp_status && i2c_last_status != TW_REP_START )
	{
		return false;
	}
	i2c_exp_status = TW_MT_SLA_ACK;
	while( count > 0 || count2 > 0 )
	{
		// Load SLA_W into TWDR Register. Clear TWINT bit in TWCR to start
		// transmission of address
		TWDR = addr;
		TWCR = (1<<TWINT) | (1<<TWEN);
		// prepare for next byte
		addr = *data;
		data++;
		count--;
		if( count == 0 )
		{
			// second data part
			count = count2;
			data = data2;
			count2 = 0;
			data2 = 0;
		}
		// Wait for TWINT Flag set. This indicates that the SLA+W has been
		// transmitted, and ACK/NACK has been received.
	P( "sending\r\n" );
		while( !(TWCR & (1<<TWINT)) )
		{
		}
	P( "sent\r\n" );
		// Check value of TWI Status Register. Mask prescaler bits. If status
		// different from MT_SLA_ACK go to ERROR
		i2c_last_status = TW_STATUS;
		if( i2c_last_status != i2c_exp_status )
		{
			return false;
		}
		i2c_exp_status = TW_MT_DATA_ACK;
	}
	if( nostop )
	{
		return true;
	}
	// Transmit STOP condition
	P( "stop\r\n" );
	TWCR = (1<<TWINT) | (1<<TWEN)| (1<<TWSTO);
	return true;
}

uint8_t i2c_read( uint8_t addr, uint8_t count, uint8_t* data )
{
	/*
	if( ignore_nack )
	{
		ignore_nack = TW_MR_DATA_NACK;
	}
	else
	{
		ignore_nack = TW_MR_DATA_ACK;
	}
	*/
	// add read bit to address
	addr = (addr << 1) | TW_READ;

	// Send START condition.
	TWCR = (1<<TWINT) | (1<<TWSTA) | (1<<TWEN);
	// Wait for TWINT Flag set. This indicates that the START condition
	// has been transmitted.
	P( "start R\r\n" );
	while( !(TWCR & (1<<TWINT)) )
	{
	}
	P( "started\r\n" );
	// Check value of TWI Status Register. Mask prescaler bits. If status
	// different from START go to ERROR
	i2c_last_status = TW_STATUS;
	i2c_exp_status = TW_START;
	if( i2c_last_status != i2c_exp_status && i2c_last_status != TW_REP_START )
	{
		return false;
	}

	// Load SLA_W into TWDR Register. Clear TWINT bit in TWCR to start
	// transmission of address
	TWDR = addr;
	TWCR = (1<<TWINT) | (1<<TWEN);
	// Wait for TWINT Flag set. This indicates that the SLA+W has been
	// transmitted, and ACK/NACK has been received.
	P( "sla\r\n" );
	while( !(TWCR & (1<<TWINT)) )
	{
	}
	P( "sla ok\r\n" );
	// Check value of TWI Status Register. Mask prescaler bits. If status
	// different from MT_SLA_ACK go to ERROR
	i2c_last_status = TW_STATUS;
	i2c_exp_status = TW_MR_SLA_ACK;
	if( i2c_last_status != i2c_exp_status )
	{
		return false;
	}
	while( count > 0 )
	{
		// initiate transfer
		if( count > 1 )
		{
			TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWEA);
		}
		else
		{
			TWCR = (1<<TWINT) | (1<<TWEN);
		}
		// Wait for TWINT Flag set. This indicates that the SLA+W has been
		// transmitted, and ACK/NACK has been received.
	P( "reading\r\n" );
		while( !(TWCR & (1<<TWINT)) )
		{
		}
	P( "read " );
	usart_add_hexbyte( TWDR );
	P( "\r\n" );
		/*
		// 0x38, 0x40, or 0x48.
		switch( TWSR & TW_STATUS_MASK )
		{
			case TW_MR_ARB_LOST:
				// Arbitration lost in SLA+R or NOT ACK bit.
				return false;
			case TW_MR_SLA_ACK:
				// SLA+R transmitted, ACK received.
				break;
			case TW_MR_SLA_NACK:
				// SLA+R transmitted, NACK received.
				return false;
			default:
				// unexpected value
				return false;
		}
		*/
		i2c_last_status = TW_STATUS;
		i2c_exp_status = count > 1 ? TW_MR_DATA_ACK : TW_MR_DATA_NACK;
		if( i2c_last_status != i2c_exp_status )
		{
			return false;
		}
		// got a data byte
		*data = TWDR;
		data++;
		count--;
	}
	// Transmit STOP condition
	P( "stop\r\n" );
	TWCR = (1<<TWINT) | (1<<TWEN)| (1<<TWSTO);
	return true;
}