#include "c_def.h"
#include "debug.h"
#include "oem.h"


#ifdef EEPROM

#include "app_i2c.h"
#include "app_timer.h"
#include "app_gpio.h"
#include "AT24c02.h"
#include "app_main.h"
#include "am29lv400bt.h"
#include "app_flash_program.h"


//#ifndef POWER_STANDBY
#define COST_DOWN
#define I2C_ADDRESS		0xA0

//Page Address array of our AT24C02 EEPROM
/*U8 PageAddress[] = 
{
	0x00, 0x08, 0x10, 0x18,
	0x20, 0x28, 0x30, 0x38, 
	0x40, 0x48, 0x50, 0x58, 
	0x60, 0x68, 0x70, 0x78,
	0x80, 0x88, 0x90, 0x98,
	0xA0, 0xA8, 0xB0, 0xB8,
	0xC0, 0xC8, 0xD0, 0xD8,
	0xE0, 0xE8, 0xF0, 0xF8,
};*/

void AT24c02_Init(void)
{
}

void AT24c02_Open(void)
{
//	app_i2c0_init();
//	asm("halt");
//	Test();
}

void AT24c02_Close(void)
{
}

U8 AT24c02_ReadPage(BYTE addr, BYTE *pbuf, WORD len)
{
	U32 r;
	U8 *rbuf;

	rbuf = pbuf;
	r = I2C0_read_sub (I2C_ADDRESS, addr, rbuf, len);
	DBG_Assert(r == I2C_SUCCESS);

	if (r == I2C_SUCCESS)
	{
		return TRUE;
	}
	
	return FALSE;
}

U8 AT24c02_WritePage(BYTE addr, BYTE *pbuf, WORD len)
{
	U32 r;
	U8 *wbuf;

	wbuf = pbuf;
	r = I2C0_write_sub (I2C_ADDRESS, addr, wbuf, len);
	DBG_Assert(r == I2C_SUCCESS);
	delayms(4); // min delay 4ms

	if (r == I2C_SUCCESS)
	{
		return TRUE;
	}
	
	return FALSE;
}

U8 AT24c02_Write(BYTE addr, BYTE *pbuf, WORD len)
{
	U8 i;
	U8 *wbuf;
	U32 r;
	volatile U8 temp;
	U16 len1;

#if 1
	wbuf = pbuf;
	len1 = len/(EEPROM_PAGE_BYTE*EEPROM_PAGE_SIZE);

	for (i=0; i<len1; i++)
	{
		r = I2C0_write_sub (I2C_ADDRESS, addr, wbuf, 8);
		DBG_Assert(r == I2C_SUCCESS);
		addr += EEPROM_PAGE_BYTE;
		wbuf += EEPROM_PAGE_BYTE;
		delayms(4); // min delay 4ms
	}

	temp = len%(EEPROM_PAGE_BYTE*EEPROM_PAGE_SIZE);
	if (temp)
	{
		I2C0_write_sub (I2C_ADDRESS, addr, wbuf, temp);
		DBG_Assert(r == I2C_SUCCESS);
		delayms(4); // min delay 4ms
	}
#endif

#if 0
	wbuf = pbuf;
	r = I2C0_write_sub (I2C_ADDRESS, addr, wbuf, len);
	DBG_Assert(r == I2C_SUCCESS);
	delayms(4); // min delay 4ms
#endif

	if (r == I2C_SUCCESS)
	{
		return TRUE;
	}
	
	return FALSE;
}

U8 AT24c02_Read(BYTE addr, BYTE *pbuf, WORD len)
{
	U8 i;
	U8 *rbuf;
	U32 r;
	volatile U8 temp;
	U16 len1;

#if 0
	rbuf = pbuf;
	len1 = len/(EEPROM_PAGE_BYTE*EEPROM_PAGE_SIZE);

	for (i=0; i<len; i++)
	{
		I2C0_read_sub (I2C_ADDRESS, addr, rbuf, 8);
		DBG_Assert(r == I2C_SUCCESS);
		addr += EEPROM_PAGE_BYTE;
		rbuf += EEPROM_PAGE_BYTE;
	}

	temp = len%(EEPROM_PAGE_BYTE*EEPROM_PAGE_SIZE);
	if (temp)
	{
		I2C0_read_sub (I2C_ADDRESS, addr, rbuf, temp);
		DBG_Assert(r == I2C_SUCCESS);
	}
#endif

#if 1
	rbuf = pbuf;
	r = I2C0_read_sub (I2C_ADDRESS, addr, rbuf, len);
	DBG_Assert(r == I2C_SUCCESS);
#endif

	if (r == I2C_ERROR)
	{
		memset(pbuf, 0, len);
	}

	if (r == I2C_SUCCESS)
	{
		return TRUE;
	}
	
	return FALSE;
}

U8 AT24c08_Write(BYTE addr, BYTE *pbuf, WORD len)
{
	U8 i;
	U8 j;
	U8 *wbuf;
	U32 r;
	volatile U8 temp;
	U8 i2c_addr = 0;
	U16 len1;

	wbuf = pbuf;
	len1 = len / (EEPROM_PAGE_BYTE*EEPROM_PAGE_SIZE);

	for (j=0; j<len1; j++)
	{
		for (i=0; i<EEPROM_PAGE_SIZE; i++)
		{
			i2c_addr = I2C_ADDRESS + (i << 1);
			r = I2C0_write_sub (i2c_addr, addr, wbuf, EEPROM_PAGE_BYTE);
			DBG_Assert(r == I2C_SUCCESS);
			wbuf += EEPROM_PAGE_BYTE;
			//delayms(8); // min delay 4ms
			delayms(4); // min delay 4ms
		}

		//addr += EEPROM_PAGE_BYTE*EEPROM_PAGE_SIZE;
		addr += EEPROM_PAGE_BYTE;
	}

	len1 = len - len1*(EEPROM_PAGE_BYTE*EEPROM_PAGE_SIZE);

	temp = len1/ EEPROM_PAGE_BYTE;
	for (i=0; i<temp; i++)
	{
		i2c_addr = I2C_ADDRESS + (i << 1);
		r = I2C0_write_sub (i2c_addr, addr, wbuf, EEPROM_PAGE_BYTE);
		DBG_Assert(r == I2C_SUCCESS);
		wbuf += EEPROM_PAGE_BYTE;
		//delayms(8); // min delay 4ms
		delayms(4); // min delay 4ms
	}

	temp = len1%EEPROM_PAGE_BYTE;
	if (temp)
	{
		i2c_addr = I2C_ADDRESS + (i << 1);
		//addr += EEPROM_PAGE_BYTE;
		//wbuf += EEPROM_PAGE_BYTE;

		r = I2C0_write_sub (i2c_addr, addr, wbuf, temp);
		DBG_Assert(r == I2C_SUCCESS);
		//delayms(8); // min delay 4ms
		delayms(4); // min delay 4ms
	}

	if (r == I2C_SUCCESS)
	{
		return TRUE;
	}
	
	return FALSE;
}

U8 AT24c08_Read(BYTE addr, BYTE *pbuf, WORD len)
{
	U8 i;
	U8 j;
	U8 *rbuf;
	U32 r = I2C_SUCCESS;
	volatile U8 temp;
	U8 i2c_addr = 0;
	U16 len1;

	rbuf = pbuf;
	len1 = len / (EEPROM_PAGE_BYTE*EEPROM_PAGE_SIZE);

	for (j=0; j<len1; j++)
	{
		for (i=0; i<EEPROM_PAGE_SIZE; i++)
		{
			i2c_addr = I2C_ADDRESS + (i << 1);
			r = I2C0_read_sub (i2c_addr, addr, rbuf, EEPROM_PAGE_BYTE);
			DBG_Assert(r == I2C_SUCCESS);
			delayms(8);										// min delay 4ms
			rbuf += EEPROM_PAGE_BYTE;
		}
		
		//addr += EEPROM_PAGE_BYTE*EEPROM_PAGE_SIZE;
		addr += EEPROM_PAGE_BYTE;
	}

	len1 = len - len1*(EEPROM_PAGE_BYTE*EEPROM_PAGE_SIZE);

	temp = len1/ EEPROM_PAGE_BYTE;
	for (i=0; i<temp; i++)
	{
		i2c_addr = I2C_ADDRESS + (i << 1);
		r = I2C0_read_sub (i2c_addr, addr, rbuf, EEPROM_PAGE_BYTE);
		DBG_Assert(r == I2C_SUCCESS);
		delayms(8);										// min delay 4ms
		rbuf += EEPROM_PAGE_BYTE;
	}

	temp = len1%EEPROM_PAGE_BYTE;
	if (temp)
	{
		i2c_addr = I2C_ADDRESS + (i << 1);
		//addr += EEPROM_PAGE_BYTE;
		//rbuf += EEPROM_PAGE_BYTE;

		r = I2C0_read_sub (i2c_addr, addr, rbuf, temp);
		DBG_Assert(r == I2C_SUCCESS);
		delayms(8);										// min delay 4ms
	}

	if (r == I2C_ERROR)
	{
		memset(pbuf, 0, len);
	}

	if (r == I2C_SUCCESS)
	{
		return TRUE;
	}
	
	return FALSE;
}

U8 AT24cxx_Write(BYTE addr, BYTE *pbuf, WORD len)
{
	U8 ret = FALSE;
	
#if (defined EEPROM_AT24C01 || defined EEPROM_AT24C02)
	//for AT24C01 and at24c02
	ret = AT24c02_Write(addr, pbuf, len);
#elif (defined EEPROM_AT24C08 || defined EEPROM_AT24C16)
	//for AT24C08
	ret = AT24c08_Write(addr, pbuf, len);
#endif

	return ret;
}

U8 AT24cxx_Read(BYTE addr, BYTE *pbuf, WORD len)
{
	U8 ret = FALSE;

#if (defined EEPROM_AT24C01 || defined EEPROM_AT24C02)
	//for AT24C01 and at24c02
	ret = AT24c02_Read(addr, pbuf, len);
#elif (defined EEPROM_AT24C08 || defined EEPROM_AT24C16)
	//for AT24C08 and EEPROM_AT24C16
	ret = AT24c08_Read(addr, pbuf, len);
#endif

	return ret;
}

#if 0
static Test(void)
{
	U8 wBuf[] = "ABCDEFGHIGKLMNOPQ";
	U8 rBuf[16];
	U8 addr;
	U32 r;

	addr = 0;
	r = AT24c02_Write(addr, (U8 *)wBuf, 8);
	DBG_Assert(r == I2C_SUCCESS);
	
	r = AT24c02_Read(addr, (U8 *)rBuf, 8);
	DBG_Assert(r == I2C_SUCCESS);
}
#endif

//#endif //POWER_STANDBY

#endif