#include "fm25v02.h"
#include "spi.h"
#include "delay.h"
#include "devicegpioinit.h"

//eeprom ¶ÁÊÇ1¸ö×Ö½Ú50us¡£




void EEPROM_Wait_Busy(void)   
{   
	while ((FM25V02_stat_read()&0x01)==0x01);   //wait BUSY=0
}  

/******************************************
 * func:    FM25V02_data_write
 * desc:    write 1 byte data to fram
 * input:   
 *   data   - 1 byte data
 *   addr16 - destination address for write
 * output:  none
 * return:  none
 *****************************************/
void FM25V02_data_write(uint8 data,uint32 addr16)
{
//	  uint8 haddr,laddr;
	u32	addr_fit;
	addr_fit = addr16 ;
// 	  haddr = (addr16 >> 8) & 0x7f;//high 7 bit address  
// 	  laddr = (addr16 & 0xff);     //low  8 bit address 
//	  delay_us(10);
	FM25V02_CS_LOW;  
	FM_ReadWriteByte(FM_WREN);             
	FM25V02_CS_HIGH; 	
//	  delay_us(10);	
	FM25V02_CS_LOW;
	FM_ReadWriteByte(FM_WRITE);
	FM_ReadWriteByte((u8)((addr_fit)>>16));
	FM_ReadWriteByte((u8)((addr_fit)>>8));
	FM_ReadWriteByte((u8)((addr_fit)));
	FM_ReadWriteByte(data);
	FM25V02_CS_HIGH;
//		Test_GPIO_High;
	EEPROM_Wait_Busy();	
//		Test_GPIO_Low;
}

/******************************************
 * func:    FM25V02_data_read
 * desc:    read 1 byte data from fram
 * input:   
 *   addr16 - destination address for read 1byte data
 * output:  none
 * return:  1 byte data read from fram
 *****************************************/
uint8 FM25V02_data_read(uint32 addr16) 
{ 
	uint8 data;
//	uint8 haddr,laddr;
	u32	addr_fit;
	addr_fit = addr16 ;
// 	haddr = (addr16 >> 8) & 0x7f;//high 7 bit address  
// 	laddr = (addr16 & 0xff);     //low  8 bit address 
	FM25V02_CS_LOW;
	FM_ReadWriteByte(FM_READ);
	FM_ReadWriteByte((u8)(addr_fit>>16));
	FM_ReadWriteByte((u8)(addr_fit>>8));
	FM_ReadWriteByte((u8)(addr_fit));
	data = FM_ReadWriteByte(0xff);//data = FM_ReadWriteByte(0xff);
	FM25V02_CS_HIGH;
	
	return data;
}

/******************************************
 * func:    FM25V02_stat_write
 * desc:    write 1 byte status data to fram 
 * input:   
 *   data  - 1 byte state data to fram status register
 * output:  none
 * return:  none
 *****************************************/
void FM25V02_stat_write(uint8 stat) 
{
	FM25V02_CS_LOW;                 
	FM_ReadWriteByte(FM_WREN);             
	FM25V02_CS_HIGH;               

	FM25V02_CS_LOW;
	FM_ReadWriteByte(FM_WRSR);
	FM_ReadWriteByte(stat);
	FM25V02_CS_HIGH;
	
}

/******************************************
 * func:    FM25V02_stat_read
 * desc:    read 1 byte status data from fram
 * input:   none
 * output:  none
 * return:  1 byte status data read from fram
 *****************************************/
uint8 FM25V02_stat_read(void)
{ 
	uint8 stat;
	
	delay_us(10);
	FM25V02_CS_LOW;
	FM_ReadWriteByte(FM_RDSR);
	stat = FM_ReadWriteByte(0xff);
	FM25V02_CS_HIGH;
	
	return stat;
}

/******************************************
 * func:    FM25V02_sleep
 * desc:    take fram into sleep mode
 * input:   none
 * output:  none
 * return:  none
 *****************************************/
void FM25V02_sleep(void)
{ 
	delay_us(10);
	FM25V02_CS_LOW;
	FM_ReadWriteByte(FM_SLEEP);
	FM25V02_CS_HIGH;
}


/******************************************
 * func:    FM25V02_ID_read
 * desc:    read 9 byte ID data from fram
 * input:   none
 * output:  9 byte ID data read from fram,write to dst
 * return:  none
 *****************************************/
void FM25V02_ID_read(uint8 *dst)
{ 
	uint8 i;

	delay_us(10);
	FM25V02_CS_LOW;
	FM_ReadWriteByte(FM_RDID);
	for(i = 0;i < 9;i ++)
	{
		dst[i] = FM_ReadWriteByte(0xff);
	}
	FM25V02_CS_HIGH;
}

/******************************************
 * func:    FM25V02_data_read_float
 * desc:    read float data from fram
 * input:   
 *   addr16 - destination address for read 1byte data
 * output:  none
 * return:  
 *****************************************/
float FM25V02_data_read_float(uint32 addr16) 
{
	//float_un f;
	float_un k;
	k.data[0] = FM25V02_data_read(addr16);
	k.data[1] = FM25V02_data_read(addr16+1);
	k.data[2] = FM25V02_data_read(addr16+2);
	k.data[3] = FM25V02_data_read(addr16+3);
	
	
	return	(k.flo);
}

/******************************************
 * func:    FM25V02_data_write_float
 * desc:    write float data from fram
 * input:   
 *   addr16 - destination address for read 1byte data
 * output:  none
 * return:  
 *****************************************/
void FM25V02_data_write_float(uint32 addr16, float data) 
{
	float_un f;
	f.flo = data;
	
	EEPROM_MultipleWrite(f.data,addr16,4);
}

/******************************************
 * func:    FM25V02_data_read_float
 * desc:    read float data from fram
 * input:   
 *   addr16 - destination address for read 1byte data
 * output:  none
 * return:  
 *****************************************/
double FM25V02_data_read_double(uint32 addr16) 
{
	double_un d;
	d.data[0] = FM25V02_data_read(addr16);
	d.data[1] = FM25V02_data_read(addr16+1);
	d.data[2] = FM25V02_data_read(addr16+2);
	d.data[3] = FM25V02_data_read(addr16+3);
	d.data[4] = FM25V02_data_read(addr16+4);
	d.data[5] = FM25V02_data_read(addr16+5);
	d.data[6] = FM25V02_data_read(addr16+6);
	d.data[7] = FM25V02_data_read(addr16+7);
	if( (d.data[0]==0xff) && (d.data[1]==0xff)&&(d.data[2]==0xff) && (d.data[3]==0xff)&&(d.data[4]==0xff) && (d.data[5]==0xff)&&(d.data[6]==0xff) && (d.data[7]==0xff))
	{
		d.dou=0;
	}
	return	(d.dou);
}

/******************************************
 * func:    FM25V02_data_read_float
 * desc:    read float data from fram
 * input:   
 *   addr16 - destination address for read 1byte data
 * output:  none
 * return:  
 *****************************************/
void FM25V02_data_write_double(uint32 addr16, double data) 
{
	double_un d;
	d.dou = data;
	
	EEPROM_MultipleWrite(d.data,addr16,8);
}


/******************************************
 * func:    FM25V02_data_read_float
 * desc:    read float data from fram
 * input:   
 *   addr16 - destination address for read 1byte data
 * output:  none
 * return:  
 *****************************************/
u32 FM25V02_data_read_uint32(uint32 addr16) 
{

	u32_un t;
	t.data[0] = FM25V02_data_read(addr16);
	t.data[1] = FM25V02_data_read(addr16+1);
	t.data[2] = FM25V02_data_read(addr16+2);
	t.data[3] = FM25V02_data_read(addr16+3);
	return	(t.uio);
}

/******************************************
 * func:    FM25V02_data_write_float
 * desc:    write float data from fram
 * input:   
 *   addr16 - destination address for read 1byte data
 * output:  none
 * return:  
 *****************************************/
void FM25V02_data_write_uint32(uint32 addr16, uint32 data) 
{
	u32_un t;
	t.uio = data;
	
	EEPROM_MultipleWrite(t.data,addr16,4);	
}
/******************************************
 * func:    FM25V02_data_read_uint32_Check
 * desc:    read float data from fram
 * input:   
 *   addr16 - destination address for read 1byte data
 * output:  none
 * return:  
 *****************************************/
u32 FM25V02_data_read_uint32_Check(uint32 addr16) 
{
	u32_un t;
	u32_un t1;
	u32_un t2;
	
	EEPROM_MultipleRead_Continue(t.data,addr16,4);
	
	delay_us(100);
	EEPROM_MultipleRead_Continue(t1.data,addr16,4);
	
	if(t.uio == t1.uio)
	{
		if(t.uio <= 900000000)
		{
			return t.uio;
		}
		else
		{
			t.uio = 0xffffffff;
			return t.uio;
		}
	}
	else
	{
		delay_us(100);
		EEPROM_MultipleRead_Continue(t2.data,addr16,4);
		
		if(t.uio == t1.uio || t.uio == t2.uio)
		{
			if(t.uio <= 900000000)
			{
				return t.uio;
			}
			else
			{
				t.uio = 0xffffffff;
				return t.uio;
			}			
		}
		else if(t1.uio == t2.uio)
		{
			if(t1.uio <= 900000000)
			{
				return t1.uio;
			}
			else
			{
				t1.uio = 0xffffffff;
				return t1.uio;
			}				
		}
		else
		{
			t1.uio = 0xffffffff;
			return t1.uio;
		}
	}
}
/******************************************
 * func:    FM25V02_data_write_float
 * desc:    write float data from fram
 * input:   
 *   addr16 - destination address for read 1byte data
 * output:  none
 * return:  
 *****************************************/
void FM25V02_data_write_uint32_WRCheck(uint32 addr16, uint32 data) 
{
	u32_un t;
	u8 count_i;
	u32_un t1;
	
  for(count_i=0; count_i<3; count_i++)
	{
		t.uio = data;
		EEPROM_MultipleWrite(t.data,addr16,4);
		delay_ms(1);
		EEPROM_MultipleRead_Continue(t1.data,addr16,4);
		delay_ms(1);
		if(t1.uio == data)
		{
			break;
		}
		else if(count_i == 2)
		{
			t.uio = 0xffffffff;
			EEPROM_MultipleWrite(t.data,addr16,4);			
		}
	}
}
/******************************************
 * func:    FM25V02_data_read_float
 * desc:    read float data from fram
 * input:   
 *   addr16 - destination address for read 1byte data
 * output:  none
 * return:  
 *****************************************/
u16 FM25V02_data_read_uint16(uint32 addr16) 
{

	u16_un t;
	t.data[0] = FM25V02_data_read(addr16);
	t.data[1] = FM25V02_data_read(addr16+1);
	return	(t.uso);
}

/******************************************
 * func:    FM25V02_data_write_float
 * desc:    write float data from fram
 * input:   
 *   addr16 - destination address for read 1byte data
 * output:  none
 * return:  
 *****************************************/
void FM25V02_data_write_uint16(uint32 addr16, uint16 data) 
{
	u16_un t;
	t.uso = data;	

	EEPROM_MultipleWrite(t.data,addr16,2);
}

/******************************************
 * func:    EEPROM_MultipleWrite
 * desc:    EEPROM write multiple bytes
 * input:   
 *   data   - 1 byte data
 *   addr16 - destination address for write
 *   bytes - Number of bytes
 * output:  none
 * return:  none
 *****************************************/
u8 EEPROM_MultipleWrite(u8 *data,u32 addr,u16 bytes)
{
	u8 flag;
	u8 *ptr_data;
	u16 i;
	u32	addr_temp;
	u32 index,byte_write_num_left,bytewrite;
	//u32 banknum1,banknum2;
	//ÏÈÅжÏÊý¾ÝÊÇ·ñ´¦ÓÚ256µÄÕâ¸öÇø¼äÄØ
	if(bytes > 4000 )
		return 0;
	ptr_data = data;
	flag = 0;
	addr_temp = addr;
	byte_write_num_left = bytes;
	if(byte_write_num_left > 0) //ÐèҪдµÄÊý¾Ý»¹ÓÐÊ£Óà
	{		
		index = (addr_temp/256) + 1;
		if(((index * 256) - addr_temp) >=	byte_write_num_left)
		{
			bytewrite = byte_write_num_left;			
		}else
		{
			bytewrite = (index * 256) - addr_temp;
		}
		flag = 1;
	}else
	{
		flag = 0;
	}
		
	while(flag)
	{				
		FM25V02_CS_LOW;  
		FM_ReadWriteByte(FM_WREN);             
		FM25V02_CS_HIGH; 
			
		FM25V02_CS_LOW;
		FM_ReadWriteByte(FM_WRITE);
		FM_ReadWriteByte((u8)((addr_temp)>>16));
		FM_ReadWriteByte((u8)((addr_temp)>>8));
		FM_ReadWriteByte((u8)(addr_temp));
		for(i = 0;i < bytewrite;i ++)
		  FM_ReadWriteByte(*ptr_data ++);
		FM25V02_CS_HIGH;
				
		addr_temp = addr_temp + bytewrite;
		byte_write_num_left = byte_write_num_left - bytewrite;
		if(byte_write_num_left > 0) //ÐèҪдµÄÊý¾Ý»¹ÓÐÊ£Óà
		{			
			index = (addr_temp/256) + 1;
			if( ((index * 256) - addr_temp) >=	byte_write_num_left)
			{
				bytewrite = byte_write_num_left;				
			}else
			{
				bytewrite = (index * 256) - addr_temp;
			}
			flag = 1;
		}else
		{
			flag = 0;
		}
		EEPROM_Wait_Busy();			
	}
	
	return 0;
}

/******************************************
 * func:    EEPROM_MultipleRead
 * desc:    EEPROM read multiple bytes
 * input:   
 *   data   - 1 byte data
 *   addr16 - destination address for write
 *   bytes - Number of bytes
 * output:  none
 * return:  none
 *****************************************/
void EEPROM_MultipleRead(u8 *data, u32 addr, u16 bytes) 
{

	u16 	index;
	u32		addr_index;
	
	addr_index = addr;
	for(index = 0; index < bytes; index ++)
	{
		data[index] = FM25V02_data_read(addr_index ++);
	}
	
}

/******************************************
 * func:    EEPROM_MultipleRead_Continue
 * desc:    EEPROM read multiple bytes
 * input:   
 *   data   - 1 byte data
 *   addr16 - destination address for write
 *   bytes - Number of bytes
 * output:  none
 * return:  none
 *****************************************/
void 	EEPROM_MultipleRead_Continue(u8 *data, u32 addr, u16 bytes)
{
	u16 	index;
	u32		addr_index;
	u16 length;
	addr_index = addr;
	length = bytes;
	
	FM25V02_CS_LOW;
	FM_ReadWriteByte(FM_READ);
	FM_ReadWriteByte((u8)(addr_index>>16));
	FM_ReadWriteByte((u8)(addr_index>>8));
	FM_ReadWriteByte((u8)(addr_index));
	for(index = 0; index < length;index++)
	{
		data[index] = FM_ReadWriteByte(0xff);//data = FM_ReadWriteByte(0xff);	
	}

	FM25V02_CS_HIGH;
}