/*
 * sht20.c
 *
 *  Created on: Jan 19, 2023
 *      Author: Wenxue
 */

#include <stdio.h>
#include <string.h>
#include "isl1208.h"

/*+--------------------------------------+
 *|      RTC Chipset ISL1208 Register    |
 *+--------------------------------------+*/
/* rtc section */
#define ISL1208_REG_SC			0x00
#define ISL1208_REG_MN			0x01
#define ISL1208_REG_HR			0x02
#define ISL1208_REG_HR_MIL     (1<<7)   /* 24h/12h mode */
#define ISL1208_REG_HR_PM      (1<<5)   /* PM/AM bit in 12h mode */
#define ISL1208_REG_DT			0x03
#define ISL1208_REG_MO			0x04
#define ISL1208_REG_YR			0x05
#define ISL1208_REG_DW			0x06
#define ISL1208_RTC_SECTION_LEN	7 /* RTC Section register */
#define REGS_RTC_SR_LEN			8 /* RTC Section and status register  */

/* control/status section */
#define ISL1208_REG_SR			0x07
#define ISL1208_REG_SR_ARST    (1<<7)   /* auto reset */
#define ISL1208_REG_SR_XTOSCB  (1<<6)   /* crystal oscillator */
#define ISL1208_REG_SR_WRTC    (1<<4)   /* write rtc */
#define ISL1208_REG_SR_EVT     (1<<3)   /* event */
#define ISL1208_REG_SR_ALM     (1<<2)   /* alarm */
#define ISL1208_REG_SR_BAT     (1<<1)   /* battery */
#define ISL1208_REG_SR_RTCF    (1<<0)   /* rtc fail */
#define ISL1208_REG_INT			0x08
#define ISL1208_REG_INT_ALME   (1<<6)   /* alarm enable */
#define ISL1208_REG_INT_IM     (1<<7)   /* interrupt/alarm mode */
#define ISL1219_REG_EV			0x09
#define ISL1219_REG_EV_EVEN    (1<<4)   /* event detection enable */
#define ISL1219_REG_EV_EVIENB  (1<<7)   /* event in pull-up disable */
#define ISL1208_REG_ATR			0x0a
#define ISL1208_REG_DTR			0x0b

/* alarm section */
#define ISL1208_REG_SCA			0x0c
#define ISL1208_REG_MNA			0x0d
#define ISL1208_REG_HRA			0x0e
#define ISL1208_REG_DTA			0x0f
#define ISL1208_REG_MOA			0x10
#define ISL1208_REG_DWA			0x11
#define ISL1208_ALARM_SECTION_LEN 6

/* user section */
#define ISL1208_REG_USR1		0x12
#define ISL1208_REG_USR2		0x13
#define ISL1208_USR_SECTION_LEN	2

#define ISL1208_REGS_MAX		0x13

const char *weekday[7]={"Sun.","Mon.","Tue.","Wed.","Thu.","Fri.","Sat." };

#define CONFIG_RTC_DEBUG

#ifdef  CONFIG_RTC_DEBUG
#define rtc_print(format,args...) printf(format, ##args)
#else
#define rtc_print(format,args...) do{} while(0)
#endif

#ifdef CONFIG_RTC_DEBUG
__attribute__((unused)) static void dump_buf(const char *prompt, uint8_t *buf, uint32_t size)
{
	int      i;
	
	if(!buf)
		return ;
	
	if(prompt)
		printf("%s\r\n", prompt);
	
	for(i=0; i<size; i++)
		printf("%02x ", buf[i]);
	
	printf("\r\n");
}
#endif
	

/*
 *+----------------------------------+
 *|     ISL1208 Low level API        |
 *+----------------------------------+
 */

static int isl1208_i2c_read_regs(uint8_t regaddr, uint8_t *regs, uint8_t len)
{
	uint8_t        i;
	int            rv = 0;
	uint8_t        byte;
	uint8_t        ack;
	
	if( !regs || len<=0 )
	{
		rtc_print("ISL1208: Invalid input arguments\r\n");
		return -PARM_ERROR;
	}

	I2C_StartCondition(ISL1208_I2CBUS);
	
	if( NO_ERROR != (rv=I2C_SendAddress(ISL1208_I2CBUS, I2C_WR)) )
	{
		rtc_print("ISL1208: Send chipset address[W] failure: rv=0x%02x\r\n", rv);
		rv = -rv;
		goto OUT;
	}
	
	if( NO_ERROR != (rv=I2C_WriteByte(ISL1208_I2CBUS, regaddr) ) )
	{
		rtc_print("ISL1208: Set register[0x%02x] failure: rv=0x%02x\r\n", regaddr, rv);
		rv = -rv;
		goto OUT;
	}
	
	I2C_StartCondition(ISL1208_I2CBUS);
	
	if( NO_ERROR != (rv=I2C_SendAddress( ISL1208_I2CBUS, I2C_RD ) ) )
	{
		rtc_print("ISL1208: Send chipset address[W] failure: rv=0x%02x\r\n", rv);
		rv = -rv;
		goto OUT;
	}
	
	for (i=0; i<len; i++)
	{
		 if( i == (len-1) )
			 ack = ACK_NONE;
		 else
			 ack = ACK; 
		 
		 rv = I2C_ReadByte(ISL1208_I2CBUS, &byte, ack, I2C_CLK_STRETCH_TIMEOUT);
		 if( NO_ERROR != rv )
		 {
			 rtc_print("ISL1208: Read register data failure: rv=0x%02x\r\n", rv);	
			 rv = -rv;
			 goto OUT;
		 }
		 
		 regs[i] = byte;
	}

OUT:
	I2C_StopCondition(ISL1208_I2CBUS);
	return rv;
}

static int isl1208_i2c_write_regs(uint8_t regaddr, uint8_t *regs, uint8_t len)
{
	uint8_t        i;
	int            rv = 0;

	I2C_StartCondition(ISL1208_I2CBUS);
	
	if( NO_ERROR != (rv=I2C_SendAddress(ISL1208_I2CBUS, I2C_WR ) ) )
	{
		rtc_print("ISL1208: Send chipset address[W] failure: rv=0x%02x\r\n", rv);
		rv = -rv;
		goto OUT;
	}
	
	if( NO_ERROR != (rv=I2C_WriteByte(ISL1208_I2CBUS, regaddr) ) )
	{
		rtc_print("ISL1208: Set register[0x%02x] failure: rv=0x%02x\r\n", regaddr, rv);
		rv = -rv;
		goto OUT;
	}

	for (i=0; i<len; i++)
	{
		rv = I2C_WriteByte(ISL1208_I2CBUS, regs[i]);
		if( NO_ERROR != rv )
		{
			rtc_print("ISL1208: Write register data failure: rv=0x%02x\r\n", rv);
			rv = -rv;
			goto OUT;
		}
	}		

	rv = 0;
	
OUT:
	I2C_StopCondition(ISL1208_I2CBUS);
	return rv;
}


#define bcd2bin(x)    (((x) & 0x0f) + ((x) >> 4) * 10)
#define bin2bcd(x)    ((((x) / 10) << 4) + (x) % 10)

int set_rtc_time(rtc_time_t tm)
{
	int                     rv;
	uint8_t                 regs[ISL1208_RTC_SECTION_LEN] = { 0, };
	uint8_t                 sr;

	regs[ISL1208_REG_SC] = bin2bcd(tm.tm_sec);
	regs[ISL1208_REG_MN] = bin2bcd(tm.tm_min);
	regs[ISL1208_REG_HR] = bin2bcd(tm.tm_hour) | ISL1208_REG_HR_MIL;
	
	regs[ISL1208_REG_DT] = bin2bcd(tm.tm_mday);
	regs[ISL1208_REG_MO] = bin2bcd(tm.tm_mon);
	regs[ISL1208_REG_YR] = bin2bcd(tm.tm_year - 2000);
	//regs[ISL1208_REG_DW] = bin2bcd(tm.tm_wday & 7);
	
	if( i2c_init(ISL1208_I2CBUS, ISL1208_CHIPADDR) )
	{
		rtc_print("ISL1208: Initial I2C bus failure!\r\n");
		return -2;
	}

	rv = isl1208_i2c_read_regs(ISL1208_REG_SR, &sr, 1);
	if( rv < 0 )
	{
		rtc_print("ISL1208: read Status Register failure, rv=%d!\r\n", rv);
		rv = -3;
		goto OUT;
	}
	sr |= ISL1208_REG_SR_WRTC;
	rv = isl1208_i2c_write_regs(ISL1208_REG_SR, &sr, 1);
	if( rv < 0 )
	{
		rtc_print("ISL1208: Set Status Register WRTC failure, rv=%d!\r\n", rv);
		rv = -4;
		goto OUT;
	}	

	rv=isl1208_i2c_write_regs(ISL1208_REG_SC, regs, ISL1208_RTC_SECTION_LEN);
	if(rv < 0 )
	{
		rtc_print("ISL1208: Set RTC section registeres failure, rv=%d!\r\n", rv);
		rv = -5;
		goto OUT;
	}	
	
	sr &= (~ISL1208_REG_SR_WRTC);
	rv = isl1208_i2c_write_regs(ISL1208_REG_SR, &sr, 1);
	if( rv < 0 )
	{
		rtc_print("ISL1208: Clear Status Register WRTC failure, rv=%d!\r\n", rv);
		rv = -6;
		goto OUT;
	}		
	
OUT:
	i2c_term(ISL1208_I2CBUS);
	return rv;
}

int get_rtc_time(rtc_time_t *tm)
{
	int									rv = 0;
	uint8_t 							regs[REGS_RTC_SR_LEN] = { 0, };
	
	if( !tm )
	{
		rtc_print("ISL1208: Invalid input arugments!\r\n");
		return -1;
	}
	
	if( i2c_init(ISL1208_I2CBUS, ISL1208_CHIPADDR) )
	{
		rtc_print("ISL1208: Initial I2C bus failure!\r\n");
		return -2;
	}

	rv = isl1208_i2c_read_regs(ISL1208_REG_SC, regs, REGS_RTC_SR_LEN);
	if (rv < 0)
	{
		rtc_print("ISL1208: read RTC_SECTION and SR registeres failure, rv=%d!\r\n", rv);
		rv = -3;
		goto OUT;
	}
	
	if( regs[ISL1208_REG_SR] & ISL1208_REG_SR_RTCF )
	{
		rtc_print("ISL1208: Initialize RTC time after power failure!\r\n");
		rv = -4;
		goto OUT;
	}

	tm->tm_sec = bcd2bin(regs[ISL1208_REG_SC]);
	tm->tm_min = bcd2bin(regs[ISL1208_REG_MN]);
	
	{
		const uint8_t _hr = regs[ISL1208_REG_HR];
			
		if (_hr & ISL1208_REG_HR_MIL)  /* 24H */
		{
			tm->tm_hour = bcd2bin(_hr & 0x3f);
		}
		else  /* 12H */
		{
			tm->tm_hour = bcd2bin(_hr & 0x1f);
			if (_hr & ISL1208_REG_HR_PM)
				tm->tm_hour += 12;
		}
	}
		
	tm->tm_mday = bcd2bin(regs[ISL1208_REG_DT]);
	tm->tm_mon  = bcd2bin(regs[ISL1208_REG_MO]); 
	tm->tm_year = bcd2bin(regs[ISL1208_REG_YR]) + 2000;
	tm->tm_wday = bcd2bin(regs[ISL1208_REG_DW]);
	
OUT:
	i2c_term(ISL1208_I2CBUS);
	return rv;
}

void print_rtc_time(void)
{
	rtc_time_t tm;

	if( get_rtc_time(&tm) < 0 )
		return ;

	printf("%04d-%02d-%02d %02d:%02d:%02d %s\r\n", tm.tm_year, tm.tm_mon, tm.tm_mday,
		tm.tm_hour, tm.tm_min, tm.tm_sec, weekday[tm.tm_wday]);
}