/***********************************************************************************************************
 * Copyright (c)  2021 - 2022, Unicmicro Co.,Ltd .
 * All rights reserved.
 * Filename    : i2c.c
 * Description : i2c driver source file
 * Author(s)   : yanhaihua
 * Version     : V1.0
 * Modify date : 2021-09-24
 ***********************************************************************************************************/
#include "i2c.h"

#ifdef UM2080F32_USING_I2C

#define I2C_READ 									(1<<0)
#define I2C_WRITE 									(0<<0)

#define I2C_TIMEOUT									0x4000   												/* 0x10000:20ms, 0x8000:10ms, 0x4000:5ms, */

#define I2C_CLKEN  	            					(uint32_t)(0x1<<15)										/* SYSCFG REG (PERI_CLKEN) I2C 时钟选择(test) */	
#define I2C_RESET  	            					(uint32_t)(0x1<<15)										/* I2C复位(test)	 */

/*************************************************** REG I2C_CR ********************************************/
#define I2C_CR_GCAVAL  	           					(uint32_t)(1<<8)										/* General Call使能 */
#define I2C_CR_IEN  	           					(uint32_t)(1<<7)										/* I2C中断使能 */
#define I2C_CR_ENAB  	           					(uint32_t)(1<<6)										/* I2C模块从模式使能位 */
#define I2C_CR_STA  	           					(uint32_t)(1<<5)										/* 发送START标志 */
#define I2C_CR_STP  	           					(uint32_t)(1<<4)										/* 发送STOP标志 */
#define I2C_CR_IFLG  	           					(uint32_t)(1<<3)										/* 中断标志位 */
#define I2C_CR_AAK  	           					(uint32_t)(1<<2)										/* 发送ACK标志 */
#define I2C_CR_SLAV10M  	       					(uint32_t)(1<<1)										/* 从模式时，收到的数据与SLAVE拓展地址寄存器中的数值相匹配 */
#define I2C_CR_SLAV7M	  	       					(uint32_t)(1<<0)										/* 从模式时，收到的数据与SLAVE地址寄存器中的数值相匹配 */

/*************************************************** REG I2C_STAT ******************************************/
#define I2C_STA_START_BIT_SENT  	    			(uint8_t)(0x08)											/* 已发送START */
#define I2C_STA_RESTART_BIT_SENT  	    			(uint8_t)(0x10)											/* 已发送RESTART */
#define I2C_STA_TX_ADDR_W_ACK 	         			(uint8_t)(0x18)											/* 已发送SLAVE地址加写标志，并接收ACK */
#define I2C_STA_TX_ADDR_W_NAK 	         			(uint8_t)(0x20)											/* 已发送SLAVE地址加写标志，并接收NACK */
#define I2C_STA_TX_DATA_ACK   	         			(uint8_t)(0x28)
#define I2C_STA_TX_DATA_NAK  	         			(uint8_t)(0x30)
#define I2C_STA_ID_LOST  	         				(uint8_t)(0x38)
#define I2C_STA_TX_ADDR_R_ACK 	         			(uint8_t)(0x40)											/* 已发送SLAVE地址加读标志，并接收ACK */
#define I2C_STA_TX_ADDR_R_NAK 	         			(uint8_t)(0x48)											/* 已发送SLAVE地址加读标志，并接收NACK */
#define I2C_STA_RX_DATA_ACK  	        			(uint8_t)(0x50)
#define I2C_STA_RX_DATA_NAK  	        			(uint8_t)(0x58)
#define I2C_STA_SLAVE_RX_DEVADDRW_ACK     			(uint8_t)(0x60)
#define I2C_STA_SLAVE_RX_DEVADDR_ACK      			(uint8_t)(0x68)
#define I2C_STA_SLAVE_RX_ADDR0			    		(uint8_t)(0x70)
#define I2C_STA_SLAVE_RX_ADDR0W	      				(uint8_t)(0x78)
#define I2C_STA_SLAVE_LRX_ADDR_ACK					(uint8_t)(0x80)
#define I2C_STA_SLAVE_LRX_ADDR_NAK	      			(uint8_t)(0x88)
#define I2C_STA_SLAVE_LRX_ADDR0_ACK		    		(uint8_t)(0x90)
#define I2C_STA_SLAVE_LRX_ADDR0_NAK      			(uint8_t)(0x98)
#define I2C_STA_SLAVE_RX_STP_RSTA      				(uint8_t)(0xA0)
#define I2C_STA_SLAVE_RX_ADDR_ACK      				(uint8_t)(0xA8)
#define I2C_STA_SLAVE_RX_ADDR0R		    			(uint8_t)(0xB0)
#define I2C_STA_SLAVE_TX_DATA_ACK	    			(uint8_t)(0xB8)
#define I2C_STA_SLAVE_TX_DATA_NAK	    			(uint8_t)(0xC0)
#define I2C_STA_SLAVE_TX_BYTE_ACK	    			(uint8_t)(0xC8)
#define I2C_STA_SECOND_ADD_ACK						(uint8_t)(0xe0)
#define I2C_STA_SECOND_ADD_NAK						(uint8_t)(0xe8)

/***********************************************************************************************************
 * Function     : i2c_get_int_status
 * Description  : i2c_get_int_status
 * Input		: none
 * Output		: none
 * Return		: 1: IFLG status is 1, 0: IFLG status is 0
 ***********************************************************************************************************/
uint8_t i2c_get_int_status(void)
{
	if(REG_I2C_CR & I2C_CR_IFLG)
	{		
		return 1;
	}	
	return 0;	
}

/***********************************************************************************************************
 * Function     : i2c_get_status
 * Description  : i2c_get_status
 * Input		: none
 * Output		: none
 * Return		: status_flag
 ***********************************************************************************************************/
uint8_t i2c_get_status(void)
{
	return REG_I2C_STAT;
}

/***********************************************************************************************************
 * Function     : i2c_write_byte
 * Description  : i2c_write_byte
 * Input        : 发送的数据（1 Byte）
 * Output		: none
 * Return		: none
 ***********************************************************************************************************/
void i2c_write_byte(uint8_t data)
{
	REG_I2C_DATA = data;
}

/***********************************************************************************************************
 * Function     : i2c_read_byte
 * Description  : i2c_read_byte
 * Input		: none
 * Output		: none
 * Return		: rdata: 接收数据（1 Byte）
 ***********************************************************************************************************/
uint8_t i2c_read_byte(void)
{
	return REG_I2C_DATA;
}

/***********************************************************************************************************
 * Function     : i2c_wait_state
 * Description  : i2c_wait_state
 * Input 	    : uint8_t status: expected status
 *  			: uint32_t wait_time: wait time
 * Output		: none
 * Return		: 0:TIMEOUT  1: expected status OK ，2：unexpected status OK   
 ***********************************************************************************************************/
uint8_t i2c_wait_state(uint8_t status,uint32_t wait_time)
{
	uint8_t value;
	
	while(wait_time--)	
	{
		value = REG_I2C_STAT;
		if(value == status)   																				/* 状态匹配 */
		{	
			return 1;
		}	
        
		if((value == I2C_STA_TX_ADDR_W_NAK) || (value == I2C_STA_TX_DATA_NAK) || (value == I2C_STA_TX_ADDR_R_NAK) || (value == I2C_STA_SLAVE_TX_DATA_NAK))			
		{
			return 2;
		}
		
		if(value == I2C_STA_SLAVE_RX_STP_RSTA)
		{
			return 3;
		}			
	}
	return 0; 
}

/***********************************************************************************************************
 * Function     : i2c_write_byte_wait_status
 * Description  : i2c_write_byte_wait_status
 * Input		: uint8_t byte,uint8_t status
 * Output		: none
 * Return		: result ，0 error， other：OK  
 ***********************************************************************************************************/
uint8_t i2c_write_byte_wait_status(uint8_t byte,uint8_t status)
{
    uint8_t result = 0;
    i2c_write_byte(byte);
	REG_I2C_CLR |= I2C_CR_IFLG;																				/* 清中断标志 ，数据填好后清标志（slave下 释放时钟，master下开始发时钟） */ 
    result = i2c_wait_state(status,I2C_TIMEOUT);
    return result;
}

/***********************************************************************************************************
 * Function     : i2c_read_byte_wait_status
 * Description  : i2c_read_byte_wait_status
 * Input		: uint8_t *byte, uint8_t status
 * Output		: none
 * Return		: result, 0: error， other: OK  
 ***********************************************************************************************************/
uint8_t i2c_read_byte_wait_status(uint8_t *byte, uint8_t status)
{
    uint8_t result = 0;
    result = i2c_wait_state(status,I2C_TIMEOUT);
    if(result)
    {
		*byte = i2c_read_byte();	
		REG_I2C_CLR |= I2C_CR_IFLG;																			/* 清中断标志 ，数据读走后清标志（slave下 释放时钟，master下开始发时钟）		 */
    }
    return result;
}

/***********************************************************************************************************
 * Function     : i2c_speed
 * Description  : i2c speed config，FOSCL = FSCL = PCLK / (2M×(N+1)×10)；其中，FOSCL是I2C接口输出的SCL得频率。
 * Input		: uint8_t speed：1M、400K、100K
 * Output		: none
 * Return		: none
 ***********************************************************************************************************/
void i2c_speed(em_i2c_speed_t speed)
{ 
	REG_I2C_CCR=0;
	switch(speed)            
	{ 
		case I2C_SPEED_STAD:   																				/* 100Kbps */
		{			
			REG_I2C_CCR|=(3<<4)|(3<<0); 	
			break;
		}
		case I2C_SPEED_FAST:																				/* 400K */
		{			
			REG_I2C_CCR|=(1<<4)|(3<<0);	 	
			break;
		}	
		case I2C_SPEED_HIGH:  																				/* 1M */
		{
			REG_I2C_CCR|=(2<<0);    		
			break;	
		}
		default: 
		{
			break;
		}
	}
}

/***********************************************************************************************************
 * Function     : i2c_master_init
 * Description  : i2c pin init, config interruption
 * Input        : uint8_t speed:  i2c SCL clk
 * Output		: none
 * Return		: none
 ***********************************************************************************************************/
void i2c_master_init(em_i2c_speed_t speed)
{										
	REG_SCU_PERICLKEN |= I2C_CLKEN; 																		/* 开启I2C时钟 */
	REG_SCU_PERIRESET |= I2C_RESET;			 																/* SCU复位控制寄存器 */	
	REG_I2C_SRST = 1;							        													/* i2c 复位 */
	
	i2c_speed(speed);
}

/***********************************************************************************************************
 * Function     : i2c_start
 * Description  : i2c_start 
 * Input		: none
 * Output		: none
 * Return		: status not 0 is ok 
 ***********************************************************************************************************/
uint8_t i2c_start(void)
{
	REG_I2C_CR |= I2C_CR_STA;
	return i2c_wait_state(I2C_STA_START_BIT_SENT,I2C_TIMEOUT);;
}

/***********************************************************************************************************
 * Function     : i2c_restart
 * Description  : i2c_restart
 * Input		: none
 * Output		: none
 * Return		: status not 0 is ok 
 ***********************************************************************************************************/
static uint8_t i2c_restart(void)
{
	REG_I2C_CR |= I2C_CR_STA;
	REG_I2C_CLR |= I2C_CR_IFLG;																				/* 清中断标志 ，master下开始发时钟 */
	return i2c_wait_state(I2C_STA_RESTART_BIT_SENT,I2C_TIMEOUT);;
}

/***********************************************************************************************************
 * Function     : i2c_stop
 * Description  : i2c_stop
 * Input		: none
 * Output		: none
 * Return		: none
 ***********************************************************************************************************/
static void i2c_stop(void)
{
	REG_I2C_CR |= I2C_CR_STP;
}


/***********************************************************************************************************
 * Function     : i2c_master_send
 * Description  : i2c master send data by commond mode
 * Input        : uint8_t dev_addr   : slave device address 
 *              : uint8_t *buff      : data buff
 *              : uint32_t length    : data length
 * Output		: none
 * Return		: 0: success other: error  
 ***********************************************************************************************************/
uint8_t i2c_master_send(uint8_t dev_addr, uint8_t *buff, uint32_t len)
{
	uint8_t  status = 0;

	status = i2c_start();                                   												/* 起始信号 */
	if(status != 1)	
	{
		i2c_stop();
		return 1;		
	}

	status = i2c_write_byte_wait_status((dev_addr|I2C_WRITE), I2C_STA_TX_ADDR_W_ACK);  						/* 设备地址+W标志 */ 
	if(status !=1)	 
	{
		i2c_stop();
		return 1;	
	}		
          
	for(uint32_t i=0; i<len; i++)   																		/* 传输要写数据 */                      
	{
		status = i2c_write_byte_wait_status(buff[i], I2C_STA_TX_DATA_ACK);  
		if(status==0)		
		{
			i2c_stop();
			return 1;
		}			
		if(status==2) 	
		{
			break;																							/* 收到NACK */
		}
	}	
	i2c_stop();	
	return 0;		
}

/***********************************************************************************************************
 * Function     : i2c_master_recv
 * Description  : i2c_master receive data
 * Input        : uint8_t dev_addr  : slave device address 
 *			    : uint8_t *buff     : data buff
 * 			    : uint32_t len      : data length
 * Output		: none
 * Return		: 0: success other: error
 ***********************************************************************************************************/
uint8_t i2c_master_recv(uint8_t dev_addr,uint8_t *buff, uint32_t len)
{
	uint8_t  status = 0;

	status = i2c_start();        																			/* START  ，start 3us后，会自动发1个字节的时钟，*/
	if(status !=1)	
	{
		i2c_stop();
		return 1;
	}		

	status = i2c_write_byte_wait_status((dev_addr|I2C_READ), I2C_STA_TX_ADDR_R_ACK); 						/* 设备地址+R标志 */
	if(status !=1)	
	{
		i2c_stop();
		return 1;
	}		

	REG_I2C_CR  |= I2C_CR_AAK;	
	REG_I2C_CLR |= I2C_CR_IFLG;																				/* 清中断标志 ，master下开始发时钟 */
	
	for(uint32_t i=0;i<len;i++)
	{	
		if(i==(len-1))																						/* 最后一个字节回NAK */
		{
			REG_I2C_CLR |= (1<<2);   																		/* NAK 只有设置了该位才能设置NACK */
			status = i2c_read_byte_wait_status(buff++, I2C_STA_RX_DATA_NAK);
			if(status !=1)	
			{
				i2c_stop();
				return 1;
			}				
			break;
		}		

		status = i2c_read_byte_wait_status(buff++, I2C_STA_RX_DATA_ACK);
		if(status !=1)	
		{
			i2c_stop();
			return 1;
		}			
	}
	
	i2c_stop();
	return 0;
}

/***********************************************************************************************************
 * Function     : i2c_master_send_mix
 * Description  : i2c master send data by mix mode （针对需要单独发memory地址的设备，如I2C EEPROM设备）
 * Input        : uint8_t dev_addr : slave device address 
 * 				: uint8_t addr     ：write address
 * 			    : uint8_t *buff    : data buff
 * 			    : uint32_t len     : data length
 * Output		: none
 * Return		: 0: success other: failed  
 ***********************************************************************************************************/
uint8_t i2c_master_send_mix(uint8_t dev_addr, uint8_t addr, uint8_t *buff, uint16_t len)
{
	uint8_t status = 0;

	status = i2c_start();                                  													/* 起始信号 */ 
	if(status != 1)	
	{
		i2c_stop();
		return 1;
	}
	
	status = i2c_write_byte_wait_status(dev_addr | I2C_WRITE, I2C_STA_TX_ADDR_W_ACK); 						/* 设备地址+W标志 */
	if(status != 1)	
	{
		i2c_stop();
		return 1;
	}

	status = i2c_write_byte_wait_status(addr, I2C_STA_TX_DATA_ACK);				
	if(status != 1)
	{
		i2c_stop();
		return 1;
	}		
	
	status = i2c_restart();				
	if(status != 1)
	{
		i2c_stop();
		return 1;	
	}
	
	status = i2c_write_byte_wait_status(dev_addr|I2C_WRITE, I2C_STA_TX_ADDR_W_ACK); 						/* 设备地址+W标志 */	
	if(status !=1)
	{
		i2c_stop();
		return 1;
	}

	for(uint16_t i=0; i<len; i++)   																		/* 传输要写数据 */                      
	{
		status = i2c_write_byte_wait_status(buff[i], I2C_STA_TX_DATA_ACK);  
		if(status==0)
		{
			i2c_stop();
			return 1;
		}
		if(status==2)
		{
			break;																							/* 收到NACK */
		}
	}	

	i2c_stop();	
	return 0;	
		
}

/***********************************************************************************************************
 * Function     : i2c_master_receive_mix
 * Description  : i2c_master receive data （针对需要单独发memory地址的设备，如I2C EEPROM设备）
 * Input 	    : uint8_t dev_addr   : slave device address 
 *			  	: uint32_t read_addr ：read address
 *			  	: uint8_t addr       ：addr
 *			  	: uint8_t *buff      : data buff
 *			  	: uint32_t len       : data length
 * Output		: none
 * Return		: 0:success ,other:failed 
 ***********************************************************************************************************/
uint8_t i2c_master_recv_mix(uint8_t dev_addr, uint8_t addr, uint8_t *buff, uint16_t len)
{
	uint8_t  status = 0;
	
	status = i2c_start();                                               									/* START */
	if(status != 1)
	{
		i2c_stop();
		return 1;	
	}

	status = i2c_write_byte_wait_status(dev_addr|I2C_WRITE, I2C_STA_TX_ADDR_W_ACK); 						/* 设备地址+W标志 */
	if(status != 1)	
	{
		i2c_stop();
		return 1;	
	}		
	
	status = i2c_write_byte_wait_status(addr, I2C_STA_TX_DATA_ACK);				
	if(status != 1)
	{
		i2c_stop();
		return 1;	
	}
	
	status = i2c_restart();																					/* RESTART */
	if(status != 1)
	{
		i2c_stop();
		return 1;	
	}
	
	status = i2c_write_byte_wait_status(dev_addr|I2C_READ, I2C_STA_TX_ADDR_R_ACK); 							/* 设备地址+R标志 */
	if(status != 1)	
	{
		i2c_stop();
		return 1;
	}

	REG_I2C_CR |= I2C_CR_AAK;	
	REG_I2C_CLR |= I2C_CR_IFLG;																				/* 清中断标志 ，master下开始发时钟 */
	
	for(uint16_t  i=0;i<len;i++)
	{			
		if(i == (len-1))
		{
			REG_I2C_CLR |= (1<<2);    																		/* NAK  只有设置了该位才能设置NACK */
			status = i2c_read_byte_wait_status(buff++, I2C_STA_RX_DATA_NAK);
			if(status != 1)	
			{
				i2c_stop();
				return 1;
			}
			break;
		}		

		status = i2c_read_byte_wait_status(buff++, I2C_STA_RX_DATA_ACK);
		if(status==0)		
		{
			i2c_stop();
			return 1;
		}
		if(status==2)
		{
			break;
		}
	}	

	i2c_stop();
	return 0;					
}

/***********************************************************************************************************
 * Function     : i2c_slave_init
 * Description  : i2c init, config interruption
 * Input 	    : uint8_t dev_addr   : slave device address 
 * Output		: none
 * Return		: none
 ***********************************************************************************************************/
void i2c_slave_init(uint8_t dev_addr)
{	
	REG_SCU_PERICLKEN |= I2C_CLKEN; 																		/* 开启I2C时钟 */
	REG_SCU_PERIRESET |= I2C_RESET;			 																/* SCU复位控制寄存器 */	
	REG_I2C_SRST = 1;							     														/* i2c 复位 */

	REG_I2C_CR = I2C_CR_ENAB|I2C_CR_AAK ;       															/* 从模式使能，AAK使能 */
	REG_I2C_SAD0 = dev_addr;
	REG_I2C_SADM0= 0xfe;	
	REG_I2C_XSADM0 = (uint32_t)0x00;   																		/* 屏蔽10bit地址 */
}

/***********************************************************************************************************
 * Function     : i2c_slave_send_data
 * Description  : i2c从机发送处理函数
 * Input        : uint8_t *buff  : data buffer
 *				: uint32_t len: send data length
 * Output		: none
 * Return		: 0:success, other:failed
 ***********************************************************************************************************/
uint8_t i2c_slave_send_data(uint8_t *buff, uint16_t len)
{
	uint8_t status = 0;
	
	REG_I2C_CR  |= I2C_CR_AAK;   																			/* ACK */
	REG_I2C_CLR |= I2C_CR_IEN ;     																		/* 中断屏蔽 */
	
	status=i2c_wait_state(I2C_STA_SLAVE_RX_ADDR_ACK,0xFFFFFFFF);   	  										/* A8;接收到自身地址+R ，死等master消息 */
	if(status !=1)
	{
		REG_I2C_CLR |= I2C_CR_IFLG;																			/* 清中断标志 ， 释放时钟 */
		REG_I2C_CR |= I2C_CR_IEN ;     																		/*  中断使能 */
		return 1;
	}

	for(uint16_t i=0;i<len;i++)
	{ 	   
		status=i2c_write_byte_wait_status(buff[i],I2C_STA_SLAVE_TX_DATA_ACK);   							/* B8; 发data等ACK */
		if( (status==0)||(status==3))																		/* 超时或意外接收到stop	*/
		{
			REG_I2C_CLR |= I2C_CR_IFLG;																		/* 清中断标志 ， 释放时钟 */
			REG_I2C_CR |= I2C_CR_IEN ;     																	/*  中断使能 */
			return 1;
		}
		if(status==2)
		{
			break;																							/* 收到NAK（到了master实际可接收的长度）*/	
		}			
	}
	
	REG_I2C_CLR |= I2C_CR_IFLG;																				/* 清中断标志 ， 释放时钟 */
	status=i2c_wait_state(I2C_STA_SLAVE_RX_STP_RSTA,I2C_TIMEOUT);   										/* A0; 等待接收stop */
	if(status == 0) 
	{
		REG_I2C_CLR |= I2C_CR_IFLG;																			/* 清中断标志 ， 释放时钟 */
		REG_I2C_CR |= I2C_CR_IEN ;     																		/*  中断使能 */
		return 1;
	}		
	
	REG_I2C_CLR |= I2C_CR_IFLG;																				/* 清中断标志 ， 释放时钟 */
	REG_I2C_CR |= I2C_CR_IEN ;     																			/*  中断使能  */
	return 0;
}


/***********************************************************************************************************
 * Function     : i2c_slave_recv_data
 * Description  : i2c从机接收处理函数,查询模式 
 * Input        : uint8_t *buff  : data buffer
 *				: uint16_t len   : receive data length , （传入的length可能大于master实际发送的数据长度）
 * Output		: none
 * Return		: 0:success, other:failed
 ***********************************************************************************************************/
uint8_t i2c_slave_recv_data(uint8_t *buff, uint16_t len)
{
	uint8_t status = 0;

	status=i2c_wait_state(I2C_STA_SLAVE_RX_DEVADDRW_ACK,I2C_TIMEOUT);   									/* 60;接收到自身地址+W */
	if(status != 1)
	{
		REG_I2C_CLR |= I2C_CR_IFLG;																			/* 清中断标志 ， 释放时钟 */
		return 1;
	}
	
	REG_I2C_CLR |= I2C_CR_IFLG;																				/* 清中断标志 ， 释放时钟 */	
	for(uint8_t i=0;i<len;i++)
	{ 
		if(i==(len-1))																						/* 最后一个字节回NAK */
		{
			REG_I2C_CLR |= (1<<2);    																		/* NAK  */
			status = i2c_read_byte_wait_status(buff++, I2C_STA_SLAVE_LRX_ADDR_NAK); 						/* 88; 接收到数据，返回NACK */
			REG_I2C_CR |= I2C_CR_AAK;   																	/* 恢复ACK */
			
			if(status==0)
			{				
				return 1;
			}
			if(status == 3)
			{				
				return 0;																					/* A0; 已收到stop（覆盖了NACK）*/	
			}
			break;
		}	

		status = i2c_read_byte_wait_status(buff++, I2C_STA_SLAVE_LRX_ADDR_ACK); 							/* 80; 接收到数据，返回ACK */
		if(status==0) 	
		{
			REG_I2C_CLR |= I2C_CR_IFLG;																		/* 清中断标志 ， 释放时钟 */
			return 1;
		}
		
		if(status==3) 																						/* 特殊情况：提前收到stop结束（针对length大于master实际发送的数据长度） */
		{
			REG_I2C_CLR |= I2C_CR_IFLG;																		/* 清中断标志 ， 释放时钟 */
			return 0;																						/* 提前结束流程	*/
		}
	}	
	
	status=i2c_wait_state(I2C_STA_SLAVE_RX_STP_RSTA,I2C_TIMEOUT);   										/* A0; 等待接收stop */
	if(status==0)
	{
		REG_I2C_CLR |= I2C_CR_IFLG;																			/* 清中断标志 ， 释放时钟 */
		return 0;
	}
	
	REG_I2C_CLR |= I2C_CR_IFLG;																				/* 清中断标志 ， 释放时钟 */	
	return 0;
}

#endif
