/*
 *  stc3117_battery.c
 *  fuel-gauge systems for lithium-ion (Li+) batteries
 *
 *  Copyright (C) 2011 STMicroelectronics.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 * Revision:
 *   2016.11.30 1.00a: Origin - 10 level dynamic early empty compensation
 *   2016.12.13 1.00b: 27 level deec and dynamic entry point for deec.
 *   2016.12.15 1.00c: Avoid SOC deep drop when heavy to light loading.
 *   2016.12.27 1.01a: Fine tune each loading for deec and voltage aging feature.
 */
#define pr_fmt(fmt) "STC311x: %s: " fmt, __func__

#include <linux/module.h>
#include <linux/init.h>
#include <linux/platform_device.h>
#include <linux/mutex.h>
#include <linux/err.h>
#include <linux/i2c.h>
#include <linux/delay.h>
#include <linux/power_supply.h>
#include <linux/stc3117_battery.h>
#include <linux/slab.h>
#include <linux/debugfs.h>

#define GG_VERSION "1.01a"
#define CONFIG_ENABLE_STC311X_DUMPREG
//#define STC3117_AGING_FEATURE
//#define STC3117_AGING_VOLTAGE_FEATURE
/*Function declaration*/
int STC31xx_SetPowerSavingMode(void);
int STC31xx_StopPowerSavingMode(void);
int STC31xx_AlarmSet(void);
int STC31xx_AlarmStop(void);
int STC31xx_AlarmGet(void);
int STC31xx_AlarmClear(void);
int STC31xx_AlarmSetVoltageThreshold(int VoltThresh);
int STC31xx_AlarmSetSOCThreshold(int SOCThresh);
int STC31xx_RelaxTmrSet(int CurrentThreshold);


/* ******************************************************************************** */
/*        STC311x DEVICE SELECTION                                                  */
/* STC3117 version only                                                             */
/* -------------------------------------------------------------------------------- */
#define STC3117

#define BATD_UC8
/* ******************************************************************************** */


/* Private define ------------------------------------------------------------*/


/* ******************************************************************************** */
/*        SPECIAL FUNCTIONS                                                         */
/* -------------------------------------------------------------------------------- */
/*                                                                                  */
/* define TEMPCOMP_SOC to enable SOC temperature compensation */
#define TEMPCOMP_SOC

/* ******************************************************************************** */


/* ******************************************************************************** */
/*        INTERNAL PARAMETERS                                                       */
/*   TO BE ADJUSTED ACCORDING TO BATTERY/APPLICATION CHARACTERISTICS                */
/* -------------------------------------------------------------------------------- */
/*                                                                                  */
#define BATT_CHG_VOLTAGE	4350	/* min voltage at the end of the charge (mV)      */
#define BATT_MIN_VOLTAGE	3600	/* nearly empty battery detection level (mV)      */
#define MAX_HRSOC		51200	/* 100% in 1/512% units*/
#define MAX_SOC			1000	/* 100% in 0.1% units */
#define FIRST_EEC_SOC		50
#define SECOND_EEC_SOC		30
#define THIRD_EEC_SOC		10
/*                                                                                  */
#define CHG_MIN_CURRENT       90		/* min charge current in mA                       */
#define CHG_END_CURRENT       20		/* end charge current in mA                       */
#define CHG_NOT_CHARGE        20		/* current to be consider as not charge in mA     */
#define APP_MIN_CURRENT       (-5)	/* minimum application current consumption in mA ( <0 !) */
#define OFFSET_CURRENT        (-3)
#define APP_MIN_VOLTAGE       3500	/* application cut-off voltage                    */
#define APP_MIN_VOLTAGE_EMPTY 3000	/* to darin all battery capacity, so we lock batt level at 1% for 3.0V ~ 3.5V(APP_MIN_VOLTAGE) */
#if defined(STC3117_AGING_VOLTAGE_FEATURE)
#define AGING_CHECK_VOLTAGE   3571	/* aging check point voltage                    */
#endif /* STC3117_AGING_VOLTAGE_FEATURE */
#define TEMP_MIN_ADJ          (-5)	/* minimum temperature for gain adjustment */

#define VMTEMPTABLE		{ 85, 90, 100, 160, 320, 440, 840 }	/* normalized VM_CNF at 60, 40, 25, 10, 0, -10 degreeC, -20 degreeC */

#define AVGFILTER		4		/* average filter constant */

/* #define CurrentFactor	(24084/SENSERESISTOR)	LSB=5.88uV/R= ~24084/R/4096 - convert to mA  */
#define VoltageFactor		9011	/* LSB=2.20mV ~9011/4096 - convert to mV         */

/* ******************************************************************************** */


/* Private define ------------------------------------------------------------*/

#define STC31xx_SLAVE_ADDRESS			0xE0	/* STC31xx 8-bit address byte */

/*Address of the STC311x register --------------------------------------------*/
#define STC311x_REG_MODE			0x00	/* Mode Register             */
#define STC311x_REG_CTRL			0x01	/* Control and Status Register */
#define STC311x_REG_SOC				0x02	/* SOC Data (2 bytes) */
#define STC311x REG_COUNTER			0x04	/* Number of Conversion (2 bytes) */
#define STC311x_REG_CURRENT			0x06	/* Battery Current (2 bytes) */
#define STC311x_REG_VOLTAGE			0x08	/* Battery Voltage (2 bytes) */
#define STC311x_REG_TEMPERATURE			0x0A	/* Temperature               */
#ifdef STC3117
#define STC311x_REG_AVG_CURRENT			0x0B	/* Battery Average Current (2 bytes)   */
#endif
#define STC311x_REG_OCV				0x0D	/* Battery OCV (2 bytes) */
#define STC311x_REG_CC_CNF			0x0F	/* CC configuration (2 bytes)    */
#define STC311x_REG_VM_CNF			0x11	/* VM configuration (2 bytes)    */
#define STC311x_REG_ALARM_SOC			0x13	/* SOC alarm level         */
#define STC311x_REG_ALARM_VOLTAGE		0x14	/* Low voltage alarm level */
#define STC311x_REG_CURRENT_THRES		0x15	/* Current threshold for relaxation */
#define STC311x_REG_CMONIT_COUNT		0x16	/* Current monitoring counter   */
#define STC311x_REG_CMONIT_MAX			0x17	/* Current monitoring max count */

#define STC311x_REG_CC_ADJ			0x1B	/* CC adjustement (2 bytes)    */
#define STC311x_REG_VM_ADJ			0x1D	/* VM adjustement (2 bytes)    */

/*Bit mask definition*/
#define STC311x_VMODE				0x01	/* Voltage mode bit mask     */
#define STC311x_ALM_ENA				0x08	/* Alarm enable bit mask     */
#define STC311x_GG_RUN				0x10	/* Alarm enable bit mask     */
#define STC311x_FORCE_CC			0x20	/* Force CC bit mask     */
#define STC311x_FORCE_VM			0x40	/* Force VM bit mask     */
#define STC311x_SOFTPOR				0x11	/* soft reset     */

#define STC311x_BATD_PU				0x02	/* Enable internal Pull-Up on BATD bit mask */
#define STC311x_FORCE_CD			0x04	/* Force CD high bit mask */

#define STC311x_REG_ID				0x18	/* Chip ID (1 byte)       */
#define STC3117_ID				0x16	/* STC3117 ID */

#define STC311x_REG_RAM				0x20	/* General Purpose RAM Registers */
#define RAM_SIZE				16	/* Total RAM size of STC311x in bytes */

#define STC311x_REG_OCVTAB			0x30
#define OCVTAB_SIZE				16	/* OCVTAB size of STC311x */
#define STC311x_REG_SOCTAB			0x50
#define SOCTAB_SIZE				16	/* SOCTAB size of STC311x */

#define VCOUNT					0	/* counter value for 1st current/temp measurements */


#define M_STAT			0x1010		/* GG_RUN & PORDET mask in STC311x_BattDataTypeDef status word */
//#define M_RST			0x1800		/* BATFAIL & PORDET mask */
#define M_RST			0x9800		/* UVLOD & BATFAIL & PORDET mask */
#define M_RUN			0x0010		/* GG_RUN mask in STC311x_BattDataTypeDef status word */
#define M_GGVM			0x0400		/* GG_VM mask */
#define M_BATFAIL		0x0800		/* BATFAIL mask*/
#define M_UVLOD			0x8000		/* UVLOD mask (STC3117 only) */

#define M_VMOD			0x0001		/* VMODE mask */

#define OK			0

/* Battery charge state definition for BattState */
#define BATT_CHARGING	3
#define BATT_ENDCHARG	2
#define BATT_FULCHARG	1
#define BATT_IDLE	0
#define BATT_DISCHARG	(-1)
#define BATT_LOWBATT	(-2)

/* STC311x RAM test word */
#define RAM_TSTWORD	0x53A9

/* Gas gauge states */
#define GG_INIT		'I'
#define GG_RUNNING	'R'
#define GG_POWERDN	'D'

#define VM_MODE		1
#define CC_MODE		0

/* gas gauge structure definition ------------------------------------*/

/* Private constants ---------------------------------------------------------*/

#define NTEMP		7
static const int TempTable[NTEMP] = {60, 40, 25, 10, 0, -10, -20} ;   /* temperature table from 60 degreeC to -20 degreeC (descending order!) */
static const int DefVMTempTable[NTEMP] = VMTEMPTABLE;

/* Dynamic early empty 7% voltage mapping */
static int deec_7_voltage_lvl[] = {
	3655, 3660, 3648, 3625, 3594, 3554, 3523, 3495, 3486,
	3462, 3448, 3420, 3367, 3347, 3325, 3303, 3290, 3281,
	3254, 3226, 3220, 3228, 3232, 3236, 3236, 3234, 3230,
};

/* Dynamic early empty 3% voltage mapping */
static int deec_3_voltage_lvl[] = {
	3493, 3498, 3493, 3481, 3462, 3429, 3402, 3377, 3369,
	3350, 3335, 3312, 3266, 3248, 3227, 3208, 3197, 3187,
	3157, 3128, 3125, 3134, 3139, 3143, 3145, 3140, 3139,
};

/* Dynamic early empty 1% voltage mapping */
static int deec_1_voltage_lvl[] = {
	3307, 3311, 3306, 3295, 3281, 3259, 3242, 3223, 3218,
	3205, 3192, 3176, 3141, 3132, 3119, 3105, 3098, 3093,
	3073, 3054, 3055, 3060, 3063, 3067, 3070, 3062, 3065,
};

/* Bypass 3 secs heavy loading drop */
static int three_secs_voltage_filter_tbl[] = {
	0, 0, 0, 5, 11, 18, 24, 30, 33,
	33, 39, 45, 50, 56, 61, 67, 57, 62,
	67, 72, 77, 75, 65, 70, 65, 70, 62,
};

#if defined(STC3117_AGING_VOLTAGE_FEATURE)
static bool aging_trigger_flag = false;

/* Defined three percentage level at 3.571V with difference current loading*/
static int aging_comparsion_tbl[] = {
	45,	/* 4.5% when current <= 100mA*/
	58,	/* 5.8% when current > 100mA && <=150 */
	83,	/* 8.3% when current > 150mA && <= 200mA*/
	116	/* 11.6% when current > 200mA && <= 250mA*/
};
#endif /* STC3117_AGING_VOLTAGE_FEATURE */

#if defined(STC3117_AGING_FEATURE)
static int aging_counter;
static int battery_capacity_aging_level;
#endif /* STC3117_AGING_FEATURE */

/* Private variables ---------------------------------------------------------*/

/* structure of the STC311x battery monitoring parameters */
typedef struct {
	int Voltage;		/* battery voltage in mV */
	int Current;		/* battery current in mA */
	int Temperature;	/* battery temperature in 0.1 degreeC */
	int SOC;		/* battery relative SOC (%) in 0.1% */
	int OCV;
	int AvgSOC;
	int AvgCurrent;
	int AvgVoltage;
	int AvgTemperature;
	int ChargeValue;	/* remaining capacity in mAh */
	int RemTime;		/* battery remaining operating time during discharge (min) */
	int State;		/* charge (>0)/discharge(<0) state */
	int CalStat;		/* Internal status */
	/* -- parameters -- */
	int Vmode;		/* 1=Voltage mode, 0=mixed mode */
	int Alm_SOC;		/* SOC alm level */
	int Alm_Vbat;		/* Vbat alm level */
	int CC_cnf;		/* nominal CC_cnf */
	int VM_cnf;		/* nominal VM cnf */
	int Cnom;		/* nominal capacity in mAh */
	int Rsense;		/* sense resistor */
	int Rint;		/* battery internal resistance */
	int RelaxCurrent;	/* current for relaxation (< C/20) */
	int Adaptive;		/* adaptive mode */
	int CapDerating[7];	/* capacity derating in 0.1%, for temp = 60, 40, 25, 10,   0, -10, -20 degreeC */
	int OCVValue[16];	/* OCV curve values */
	//int SOCValue[16];	/* SOC curve values */
	int ExternalTemperature;
	int ForceExternalTemperature;
	int Ropt;
	int Var1;
} GasGauge_DataTypeDef;

/* structure of the STC311x battery monitoring data */
typedef struct {
	/* STC311x data */
	int STC_Status;		/* status word  */
	int Vmode;		/* 1=Voltage mode, 0=mixed mode */
	int Voltage;		/* voltage in mV            */
	int Current;		/* current in mA            */
	int Temperature;	/* temperature in 0.1 degreeC     */
	int HRSOC;		/* uncompensated SOC in 1/512%   */
	int OCV;		/* OCV in mV*/
	int ConvCounter;	/* convertion counter       */
	int RelaxTimer;		/* current relax timer value */
	int CC_adj;		/* CC adj */
	int VM_adj;		/* VM adj */
	/* results & internals */
	int SOC;		/* compensated SOC in 0.1% */
	int AvgSOC;		/* in 0.1% */
	int AvgVoltage;
	int AvgCurrent;
	int AvgTemperature;
	int AccSOC;
	int AccVoltage;
	int AccCurrent;
	int AccTemperature;
	int BattState;
	int GG_Mode;		/* 1=VM active, 0=CC active */
	int LastTemperature;
	int BattOnline;		/* BATD */
	int IDCode;
	/* parameters */
	int Alm_SOC;		/* SOC alm level in % */
	int Alm_Vbat;		/* Vbat alm level in mV */
	int CC_cnf;		/* nominal CC_cnf */
	int VM_cnf;		/* nominal VM cnf */
	int Cnom;		/* nominal capacity is mAh */
	int Rsense;		/* sense resistor in milliOhms */
	int Rint;		/* internal resistance in milliOhms */
	int CurrentFactor;
	int CRateFactor;
	int RelaxThreshold;	/* current threshold for VM (mA)  */
	int VM_TempTable[NTEMP];
	int CapacityDerating[NTEMP];
	int  OCVValue[OCVTAB_SIZE];
	//unsigned char SOCValue[SOCTAB_SIZE];
	int  Ropt;
	int  Nropt;
	int  LastSOC;
} STC311x_BattDataTypeDef;

static STC311x_BattDataTypeDef BattData;	/* STC311x data */

/* structure of the STC311x RAM registers for the Gas Gauge algorithm data */
static union {
	unsigned char db[RAM_SIZE];  /* last byte holds the CRC */
	struct {
		short int TstWord;     /* 0-1 */
		short int HRSOC;       /* 2-3 SOC backup */
		short int CC_cnf;      /* 4-5 current CC_cnf */
		short int VM_cnf;      /* 6-7 current VM_cnf */
		char SOC;              /* 8 SOC for trace (in %) */
		char GG_Status;        /* 9  */
		/* bytes ..RAM_SIZE-2 are free, last byte RAM_SIZE-1 is the CRC */
	} reg;
} GG_Ram;


int Capacity_Adjust;
extern bool chg_full_flag;
extern bool force_full_flag;

/* -------------------------------------------------------------------------------- */
/*        INTERNAL ANDROID DRIVER PARAMETERS                                        */
/*   TO BE ADJUSTED ACCORDING TO BATTERY/APPLICATION CHARACTERISTICS                */
/* -------------------------------------------------------------------------------- */

#define STC3100_BATTERY_FULL	95
#define STC311x_DELAY		1000

/* ******************************************************************************** */

static struct i2c_client *sav_client;

struct stc311x_chip {
	struct i2c_client		*client;
	struct delayed_work		work;
	struct power_supply		battery;
	struct stc311x_platform_data	*pdata;
	struct dentry			*debug_root;
	u32				peek_poke_address;

	/* State Of Connect */
	int online;
	/* battery SOC (capacity) */
	int batt_soc;
	/* battery SOC (capacity) - previous value */
	int batt_soc_last;
	/* battery voltage */
	int batt_voltage;
	/* Current */
	int batt_current;
	/* Temperature */
	int batt_temp;
#if defined(STC3117_AGING_FEATURE)
	/* Charge cycle */
	int batt_charge_cycle;
#endif /* STC3117_AGING_FEATURE */
	/* State Of Charge */
	int status;
};

static int stc311x_get_property(struct power_supply *psy,
			enum power_supply_property psp,
			union power_supply_propval *val)
{
	struct stc311x_chip *chip = container_of(psy,
				struct stc311x_chip, battery);

/* from power_supply.h:
 * All voltages, currents, charges, energies, time and temperatures in uV,
 * uA, uAh, uWh, seconds and tenths of degree Celsius unless otherwise
 * stated. It's driver's job to convert its raw values to units in which
 * this class operates.
 */

	switch (psp) {
		case POWER_SUPPLY_PROP_STATUS:
			val->intval = chip->status;
			break;
		case POWER_SUPPLY_PROP_ONLINE:
			val->intval = chip->online;
			break;
#if defined(STC3117_AGING_FEATURE)
		case POWER_SUPPLY_PROP_CYCLE_COUNT:
			val->intval = chip->batt_charge_cycle;
			break;
#endif /* STC3117_AGING_FEATURE */
		case POWER_SUPPLY_PROP_VOLTAGE_NOW:
			val->intval = chip->batt_voltage * 1000;  /* in uV */
			break;
		case POWER_SUPPLY_PROP_CURRENT_NOW:
			val->intval = chip->batt_current * 1000 * -1;  /* in uA */
			break;
		case POWER_SUPPLY_PROP_CAPACITY:
			val->intval = chip->batt_soc;
			break;
		case POWER_SUPPLY_PROP_TEMP:
			val->intval = chip->batt_temp;
			break;
		default:
			return -EINVAL;
	}
	return 0;
}

static void stc311x_get_version(struct i2c_client *client)
{
	dev_info(&client->dev, "STC3117 Fuel-Gauge Ver %s\n", GG_VERSION);
}

static void stc311x_get_online(struct i2c_client *client)
{
	struct stc311x_chip *chip = i2c_get_clientdata(client);

	if (chip->pdata && chip->pdata->battery_online)
		chip->online = chip->pdata->battery_online();
	else
		chip->online = BattData.BattOnline;
}

static void stc311x_get_status(struct i2c_client *client)
{
	struct stc311x_chip *chip = i2c_get_clientdata(client);

	if (!chip->pdata || !chip->pdata->charger_online ||
		!chip->pdata->charger_enable) {
		chip->status = POWER_SUPPLY_STATUS_UNKNOWN;
		return;
	}

	if (chip->pdata->charger_online()) {
		if (chip->pdata->charger_enable())
			chip->status = POWER_SUPPLY_STATUS_CHARGING;
		else
			chip->status = POWER_SUPPLY_STATUS_NOT_CHARGING;
	} else {
		chip->status = POWER_SUPPLY_STATUS_DISCHARGING;
	}

	if (chip->batt_soc > STC3100_BATTERY_FULL)
		chip->status = POWER_SUPPLY_STATUS_FULL;
}

/* -------------------------------------------------------------------------- */
/* I2C interface */

/* -----------------------------------------------------------------
 The following routines interface with the I2C primitives
   I2C_Read(u8_I2C_address, u8_NumberOfBytes, u8_RegAddress, pu8_RxBuffer);
   I2C_Write(u8_I2C_address, u8_NumberOfBytes, u8_RegAddress, pu8_TxBuffer);
  note: here I2C_Address is the 8-bit address byte
 ----------------------------------------------------------------- */

#define NBRETRY		5

/*******************************************************************************
* Function Name  : STC31xx_Write
* Description    : utility function to write several bytes to STC311x registers
* Input          : NumberOfBytes, RegAddress, TxBuffer
* Return         : error status
* Note: Recommended implementation is to used I2C block write. If not available,
* STC311x registers can be written by 2-byte words (unless NumberOfBytes=1)
* or byte per byte.
*******************************************************************************/
static int STC31xx_Write(int length, int reg , unsigned char *values)
{
	int ret;

	ret = i2c_smbus_write_i2c_block_data(sav_client, reg, length, values);
	if (ret < 0)
		dev_err(&sav_client->dev, "%s: err %d\n", __func__, ret);

	return ret;
}

/*******************************************************************************
* Function Name  : STC31xx_Read
* Description    : utility function to read several bytes from STC311x registers
* Input          : NumberOfBytes, RegAddress, , RxBuffer
* Return         : error status
* Note: Recommended implementation is to used I2C block read. If not available,
* STC311x registers can be read by 2-byte words (unless NumberOfBytes=1)
* Using byte per byte read is not recommended since it doesn't ensure register data integrity
*******************************************************************************/
static int STC31xx_Read(int length, int reg , unsigned char *values)
{
	int ret;

	ret = i2c_smbus_read_i2c_block_data(sav_client, reg, length, values);
	if (ret < 0)
		dev_err(&sav_client->dev, "%s: err %d\n", __func__, ret);

	return ret;
}


/* ---- end of I2C primitive interface --------------------------------------------- */


/*******************************************************************************
* Function Name  : STC31xx_ReadByte
* Description    : utility function to read the value stored in one register
* Input          : RegAddress: STC311x register,
* Return         : 8-bit value, or 0 if error
*******************************************************************************/
static int STC31xx_ReadByte(int RegAddress)
{
	unsigned char data[2];
	int res;

	res=STC31xx_Read(1, RegAddress, data);

	if (res >= 0) {
		/* no error */
		return data[0];
	}
	else
		return 0;
}


/*******************************************************************************
* Function Name  : STC31xx_WriteByte
* Description    : utility function to write a 8-bit value into a register
* Input          : RegAddress: STC311x register, Value: 8-bit value to write
* Return         : error status (OK, !OK)
*******************************************************************************/
static int STC31xx_WriteByte(int RegAddress, unsigned char Value)
{
	int res;
	unsigned char data[2];

	data[0]= Value;
	res = STC31xx_Write(1, RegAddress, data);

	return(res);
}


/*******************************************************************************
* Function Name  : STC31xx_ReadWord
* Description    : utility function to read the value stored in one register pair
* Input          : RegAddress: STC311x register,
* Return         : 16-bit value, or 0 if error
*******************************************************************************/
static int STC31xx_ReadWord(int RegAddress)
{
	unsigned char data[2];
	int res;

	res=STC31xx_Read(2, RegAddress, data);

	if (res >= 0) {
		return ((data[1] << 8) + data[0]);
	}
	else
		return 0;
}


/*******************************************************************************
* Function Name  : STC31xx_WriteWord
* Description    : utility function to write a 16-bit value into a register pair
* Input          : RegAddress: STC311x register, Value: 16-bit value to write
* Return         : error status (OK, !OK)
*******************************************************************************/
static int STC31xx_WriteWord(int RegAddress, int Value)
{
	int res;
	unsigned char data[2];

	data[0]= Value & 0xff;
	data[1]= (Value>>8) & 0xff;
	res = STC31xx_Write(2, RegAddress, data);

	return(res);
}

/*******************************************************************************
* Function Name  : conv
* Description    : conversion utility
*  convert a raw 16-bit value from STC311x registers into user units (mA, mAh, mV, degreeC)
*  (optimized routine for efficient operation on 8-bit processors such as STM8)
* Input          : value, factor
* Return         : result = value * factor / 4096
*******************************************************************************/
static int conv(short value, unsigned short factor)
{
	int v;

	v= ( (long) value * factor ) >> 11;
	v= (v+1)/2;

	return (v);
}


/* ---- end of I2C R/W interface --------------------------------------------- */

#define LAST_CFG_REG	0x1E
static int show_cfg_regs(struct seq_file *m, void *data)
{
	//struct stc311x_chip *chip = m->private;
	u8 reg;
	u8 addr;

	for (addr = 0; addr <= LAST_CFG_REG; addr++) {
		reg = STC31xx_ReadByte(addr);
		seq_printf(m, "0x%02x = 0x%02x\n", addr, reg);
	}

	return 0;
}

static int cfg_debugfs_open(struct inode *inode, struct file *file)
{
	struct stc311x_chip *chip = inode->i_private;

	return single_open(file, show_cfg_regs, chip);
}

static const struct file_operations cfg_debugfs_ops = {
	.owner		= THIS_MODULE,
	.open		= cfg_debugfs_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= single_release,
};

static int show_ocvtab_regs(struct seq_file *m, void *data)
{
	int i;
	u16 ocv_mv;

	for (i = 0 ; i < OCVTAB_SIZE; i++) {
		ocv_mv = STC31xx_ReadWord(STC311x_REG_OCVTAB + (i * 2));
		//ocv_mv = get_val(&reg[1]);
		ocv_mv &= 0x3fff; /* mask unused bits */
		if (ocv_mv >= 0x02000) ocv_mv -= 0x4000;  /* convert to signed value */
		ocv_mv = conv(ocv_mv, VoltageFactor);
		ocv_mv = (ocv_mv + 2) / 4;  /* divide by 4 with rounding */
		seq_printf(m, "0x%02x, ocv=%hu\n",
		STC311x_REG_OCVTAB + (i * 2), ocv_mv);
	}

	return 0;
}

static int ocv_debugfs_open(struct inode *inode, struct file *file)
{
	struct stc311x_chip *chip = inode->i_private;

	return single_open(file, show_ocvtab_regs, chip);
}

static const struct file_operations ocv_debugfs_ops = {
	.owner		= THIS_MODULE,
	.open		= ocv_debugfs_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= single_release,
};

static int show_soctab_regs(struct seq_file *m, void *data)
{
	int i;
	u8 reg;

	for (i = 0 ; i < SOCTAB_SIZE; i++) {
		reg = STC31xx_ReadByte(STC311x_REG_SOCTAB + i);
		seq_printf(m, "0x%02x = 0x%02x(%3d%%)\n",
		STC311x_REG_SOCTAB + i, reg, reg / 2);
	}

	return 0;
}

static int soc_debugfs_open(struct inode *inode, struct file *file)
{
	struct stc311x_chip *chip = inode->i_private;

	return single_open(file, show_soctab_regs, chip);
}

static const struct file_operations soc_debugfs_ops = {
	.owner		= THIS_MODULE,
	.open		= soc_debugfs_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= single_release,
};

static int show_ram_regs(struct seq_file *m, void *data)
{
	u8 reg;
	u8 addr;

	for (addr = STC311x_REG_RAM; addr < STC311x_REG_RAM + RAM_SIZE; addr++) {
		reg = STC31xx_ReadByte(addr);
		seq_printf(m, "0x%02x = 0x%02x\n", addr, reg);
	}

	return 0;
}

static int ram_debugfs_open(struct inode *inode, struct file *file)
{
	struct stc311x_chip *chip = inode->i_private;

	return single_open(file, show_ram_regs, chip);
}

static const struct file_operations ram_debugfs_ops = {
	.owner		= THIS_MODULE,
	.open		= ram_debugfs_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= single_release,
};

static int get_reg(void *data, u64 *val)
{
	struct stc311x_chip *chip = data;
	int rc;
	u8 temp;

	rc = STC31xx_Read(1, chip->peek_poke_address, &temp);
	if (rc < 0) {
		pr_err("failed to read reg %x rc = %d\n",
				chip->peek_poke_address, rc);
		return -EAGAIN;
	}
	*val = temp;

	return 0;
}

static int set_reg(void *data, u64 val)
{
	struct stc311x_chip *chip = data;
	int rc;
	u8 temp;

	temp = (u8)val;
	rc = STC31xx_Write(1, chip->peek_poke_address, &temp);
	if (rc < 0) {
		pr_err("failed to read reg %x rc = %d\n",
				chip->peek_poke_address, rc);
		return -EAGAIN;
	}

	return 0;
}

DEFINE_SIMPLE_ATTRIBUTE(poke_poke_debug_ops, get_reg, set_reg, "0x%02llx\n");

static void create_debugfs_entries(struct stc311x_chip *chip)
{
	struct dentry *ent;

	chip->debug_root = debugfs_create_dir("stc311x", NULL);
	if (!chip->debug_root) {
		pr_err("failed to create debug dir\n");
		return;
	}
	ent = debugfs_create_file("config_registers", S_IFREG | S_IRUGO,
			chip->debug_root, chip, &cfg_debugfs_ops);
	if (!ent)
		pr_err("failed to create config_resgisters debug file\n");

	ent = debugfs_create_file("ocv_tab", S_IFREG | S_IRUGO,
			chip->debug_root, chip, &ocv_debugfs_ops);
	if (!ent)
		pr_err("failed to create ocv_tab debug file\n");

	ent = debugfs_create_file("soc_tab", S_IFREG | S_IRUGO,
			chip->debug_root, chip, &soc_debugfs_ops);
	if (!ent)
		pr_err("failed to create soc_tab debug file\n");

	ent = debugfs_create_file("ram_dump", S_IFREG | S_IRUGO,
			chip->debug_root, chip, &ram_debugfs_ops);
	if (!ent)
		pr_err("failed to create ram_dump debug file\n");


	ent = debugfs_create_x32("address", S_IFREG | S_IWUSR | S_IRUGO,
			chip->debug_root, &chip->peek_poke_address);
	if (!ent)
		pr_err("failed to create address debug file\n");

	ent = debugfs_create_file("data", S_IFREG | S_IWUSR | S_IRUGO,
			chip->debug_root, chip,  &poke_poke_debug_ops);
	if (!ent)
		pr_err("failed to create data debug file\n");

#if defined(STC3117_AGING_FEATURE)
	ent = debugfs_create_u32("cycle_counter", S_IFREG | S_IWUSR | S_IRUGO,
			chip->debug_root, &aging_counter);
	if (!ent)
		pr_err("failed to create data debug file\n");
#endif /* STC3117_AGING_FEATURE */
}

/* -------------------------------------------------------------------------- */


/*******************************************************************************
* Function Name  : STC311x_Status
* Description    :  Read the STC311x status
* Input          : None
* Return         : status word (REG_MODE / REG_CTRL), -1 if error
*******************************************************************************/
static int STC311x_Status(void)
{
	int value;

	/* first, check the presence of the STC311x by reading first byte of dev. ID */
	BattData.IDCode = STC31xx_ReadByte(STC311x_REG_ID);
	if (BattData.IDCode!= STC3117_ID) return (-1);

	/* read REG_MODE and REG_CTRL */
	value = STC31xx_ReadWord(STC311x_REG_MODE);

	return (value);
}


/*******************************************************************************
* Function Name  : STC311x_SetParam
* Description    :  initialize the STC311x parameters
* Input          : rst: init algo param
* Return         : 0
*******************************************************************************/
static void STC311x_SetParam(void)
{
	int value;
	int ii;

	STC31xx_WriteByte(STC311x_REG_MODE,0x01);  /*   set GG_RUN=0 before changing algo parameters */

	/* init OCV curve */
	for (ii=0;ii<OCVTAB_SIZE;ii++)
		if (BattData.OCVValue[ii]!=0) STC31xx_WriteWord(STC311x_REG_OCVTAB+ii*2, BattData.OCVValue[ii]*100/55);
		//if (BattData.SOCValue[1]!=0) STC31xx_Write(SOCTAB_SIZE, STC311x_REG_SOCTAB, (unsigned char *) BattData.SOCValue);

	/* set alm level if different from default */
	if (BattData.Alm_SOC !=0 )
		STC31xx_WriteByte(STC311x_REG_ALARM_SOC,BattData.Alm_SOC*2);

	if (BattData.Alm_Vbat !=0 ) {
		value= ((BattData.Alm_Vbat << 9) / VoltageFactor); /* LSB=8*2.44mV */
		STC31xx_WriteByte(STC311x_REG_ALARM_VOLTAGE, value);
	}

	// Avery
	pr_err("%s: BattData.CurrentFactor=%d", __func__, BattData.CurrentFactor);
	/* relaxation timer */
	if (BattData.RelaxThreshold !=0) {
		value= ((BattData.RelaxThreshold << 9) / BattData.CurrentFactor);   /* LSB=8*5.88uV/Rsense */
		value = value & 0x7f;
		STC31xx_WriteByte(STC311x_REG_CURRENT_THRES,value);
	}

	/* set parameters if different from default, only if a restart is done (battery change) */
	if (GG_Ram.reg.CC_cnf !=0 ) STC31xx_WriteWord(STC311x_REG_CC_CNF,GG_Ram.reg.CC_cnf);
	if (GG_Ram.reg.VM_cnf !=0 ) STC31xx_WriteWord(STC311x_REG_VM_CNF,GG_Ram.reg.VM_cnf);

	//STC31xx_WriteByte(STC311x_REG_CTRL,0x03);  /*   clear PORDET, BATFAIL and ALARMs free ALM pin, reset conv counter */
	STC31xx_WriteByte(STC311x_REG_CTRL,0x83);  /*   clear BATFAIL and ALARMs, free ALM pin, reset conv counter */
	if (BattData.Vmode)
		STC31xx_WriteByte(STC311x_REG_MODE,0x19);  /*   set GG_RUN=1, voltage mode, alm enabled */
	else
		STC31xx_WriteByte(STC311x_REG_MODE,0x18);  /*   set GG_RUN=1, mixed mode, alm enabled */

	return;
}


/*******************************************************************************
* Function Name  : STC311x_Startup
* Description    :  initialize and start the STC311x at application startup
* Input          : None
* Return         : 0 if ok, -1 if error
*******************************************************************************/
static int STC311x_Startup(void)
{
	int res;
	int ocv, curr;

	/* check STC310x status */
	res = STC311x_Status();
	if (res<0) return(res);

	/* read OCV */
	ocv=STC31xx_ReadWord(STC311x_REG_OCV);

	STC311x_SetParam();  /* set parameters  */

	/* with STC3117, it is possible here to read the current and compensate OCV: */
	curr=STC31xx_ReadWord(STC311x_REG_CURRENT);
	curr &= 0x3fff;   /* mask unused bits */
	if (curr>=0x2000) curr -= 0x4000;  /* convert to signed value */
	ocv = ocv - BattData.Rint * curr * 588 / BattData.Rsense / 55000 ;

	/* rewrite ocv to start SOC with updated OCV curve */
	STC31xx_WriteWord(STC311x_REG_OCV,ocv);

	return(0);
}


/*******************************************************************************
* Function Name  : STC311x_Restore
* Description    :  Restore STC311x state
* Input          : None
* Return         :
*******************************************************************************/
static int STC311x_Restore(void)
{
	int res;
	int ocv;

	/* check STC310x status */
	res = STC311x_Status();
	if (res<0)
		return(res);

	/* read OCV */
	ocv=STC31xx_ReadWord(STC311x_REG_OCV);

	STC311x_SetParam();  /* set parameters  */

#if 1
	/* if restore from unexpected reset, restore SOC (system dependent) */
	if (GG_Ram.reg.GG_Status == GG_RUNNING)
		if (GG_Ram.reg.SOC != 0)
			STC31xx_WriteWord(STC311x_REG_SOC,GG_Ram.reg.HRSOC);  /*   restore SOC */
#else
	/* rewrite ocv to start SOC with updated OCV curve */
	STC31xx_WriteWord(STC311x_REG_OCV,ocv);
#endif
	return(0);
}


/*******************************************************************************
* Function Name  : STC311x_Powerdown
* Description    :  stop the STC311x at application power down
* Input          : None
* Return         : error status (OK, !OK)
*******************************************************************************/
static int STC311x_Powerdown(void)
{
	int res;

	/* write 0x01 into the REG_CTRL to release IO0 pin open, */
	STC31xx_WriteByte(STC311x_REG_CTRL, 0x01);

	/* write 0 into the REG_MODE register to put the STC311x in standby mode */
	res = STC31xx_WriteByte(STC311x_REG_MODE, 0);
	if (res!= OK)
		return (res);

	return (OK);
}


/*******************************************************************************
* Function Name  : STC311x_xxxx
* Description    :  misc STC311x utility functions
* Input          : None
* Return         : None
*******************************************************************************/
static void STC311x_Reset(void)
{
	STC31xx_WriteByte(STC311x_REG_CTRL, STC311x_SOFTPOR);  /*   set soft POR */
}

static void STC311x_SetSOC(int SOC)
{
	STC31xx_WriteWord(STC311x_REG_SOC,SOC);
}

#if 0
static void STC311x_ForceVM(void)
{
	int value;

	value=STC31xx_ReadByte(STC311x_REG_MODE);
	STC31xx_WriteByte(STC311x_REG_MODE,value | STC311x_FORCE_VM);   /*   force VM mode */
}
#endif

static void STC311x_ForceCC(void)
{
	int value;

	value=STC31xx_ReadByte(STC311x_REG_MODE);
	STC31xx_WriteByte(STC311x_REG_MODE,value | STC311x_FORCE_CC);  /*   force CC mode */
}


#if 0
static int STC311x_SaveCnf(void)
{
	int reg_mode,value;

	/* mode register*/
	reg_mode = BattData.STC_Status & 0xff;

	reg_mode &= ~STC311x_GG_RUN;  /*   set GG_RUN=0 before changing algo parameters */
	STC31xx_WriteByte(STC311x_REG_MODE, reg_mode);

	STC31xx_ReadByte(STC311x_REG_ID);

	STC31xx_WriteWord(STC311x_REG_VM_CNF,GG_Ram.reg.VM_cnf);
	value = STC31xx_ReadWord(STC311x_REG_SOC);
	STC31xx_WriteWord(STC311x_REG_SOC,value);
	STC31xx_WriteWord(STC311x_REG_CC_CNF,GG_Ram.reg.CC_cnf);

	if (BattData.Vmode) {
		STC31xx_WriteByte(STC311x_REG_MODE,0x19);  /*   set GG_RUN=1, voltage mode, alm enabled */
	}
	else {
		STC31xx_WriteByte(STC311x_REG_MODE,0x18);  /*   set GG_RUN=1, mixed mode, alm enabled */
		if (BattData.GG_Mode == CC_MODE)
			STC31xx_WriteByte(STC311x_REG_MODE,0x38);  /*   force CC mode */
		else
			STC31xx_WriteByte(STC311x_REG_MODE,0x58);  /*   force VM mode */
	}

	return(0);
}
#endif

#if defined(STC3117_AGING_FEATURE) || defined(STC3117_AGING_VOLTAGE_FEATURE)
static int STC311x_SaveCCCnf(void)
{
	int reg_mode;

	/* mode register*/
	reg_mode = BattData.STC_Status & 0xff;

	reg_mode &= ~STC311x_GG_RUN;  /*   set GG_RUN=0 before changing algo parameters */
	STC31xx_WriteByte(STC311x_REG_MODE, reg_mode);

	STC31xx_ReadByte(STC311x_REG_ID);

	STC31xx_WriteWord(STC311x_REG_CC_CNF,GG_Ram.reg.CC_cnf);

	if (BattData.Vmode) {
		STC31xx_WriteByte(STC311x_REG_MODE,0x19);  /*   set GG_RUN=1, voltage mode, alm enabled */
	} else {
		STC31xx_WriteByte(STC311x_REG_MODE,0x18);  /*   set GG_RUN=1, mixed mode, alm enabled */
		if (BattData.GG_Mode == CC_MODE)
			STC31xx_WriteByte(STC311x_REG_MODE,0x38);  /*   force CC mode */
		else
			STC31xx_WriteByte(STC311x_REG_MODE,0x58);  /*   force VM mode */
	}

	return(0);
}
#endif /* STC3117_AGING_FEATURE || STC3117_AGING_VOLTAGE_FEATURE */

static int STC311x_SaveVMCnf(void)
{
	int reg_mode;

	/* mode register*/
	reg_mode = BattData.STC_Status & 0xff;

	reg_mode &= ~STC311x_GG_RUN;  /*   set GG_RUN=0 before changing algo parameters */
	STC31xx_WriteByte(STC311x_REG_MODE, reg_mode);

	STC31xx_ReadByte(STC311x_REG_ID);

	STC31xx_WriteWord(STC311x_REG_VM_CNF,GG_Ram.reg.VM_cnf);

	if (BattData.Vmode) {
		STC31xx_WriteByte(STC311x_REG_MODE,0x19);  /*   set GG_RUN=1, voltage mode, alm enabled */
	} else {
		STC31xx_WriteByte(STC311x_REG_MODE,0x18);  /*   set GG_RUN=1, mixed mode, alm enabled */
		if (BattData.GG_Mode == CC_MODE)
			STC31xx_WriteByte(STC311x_REG_MODE,0x38);  /*   force CC mode */
		else
			STC31xx_WriteByte(STC311x_REG_MODE,0x58);  /*   force VM mode */
	}

	return(0);
}


/*******************************************************************************
* Function Name  : STC311x_ReadBatteryData
* Description    :  utility function to read the battery data from STC311x
*                  to be called every 5s or so
* Input          : ref to BattData structure
* Return         : error status (OK, !OK)
*******************************************************************************/
static int STC311x_ReadBatteryData(STC311x_BattDataTypeDef *BattData)
{
	unsigned char data[16];
	int res;
	int value;

	res = STC311x_Status();
	if (res < 0)
		return(res);  /* return if I2C error or STC3117 not responding */

	/* STC311x status */
	BattData->STC_Status = res;
	if (BattData->STC_Status & M_GGVM)
		BattData->GG_Mode = VM_MODE;   /* VM active */
	else
		BattData->GG_Mode = CC_MODE;   /* CC active */

	/* read STC3117 registers 0 to 14 */
	res = STC31xx_Read(15, 0, data);

	if (res < 0)
		return(res);  /* read failed */

	/* fill the battery status data */
	/* SOC */
	value = (data[3]<<8) + data[2];
	BattData->HRSOC = value;     /* result in 1/512% */

	/* conversion counter */
	value = (data[5]<<8) + data[4];
	BattData->ConvCounter = value;

	/* current */
	value = (data[7]<<8) + data[6];
	value &= 0x3fff;   /* mask unused bits */
	if (value >= 0x2000)
		value -= 0x4000;  /* convert to signed value */
	BattData->Current = conv(value, BattData->CurrentFactor);  /* result in mA */
	BattData->Current += OFFSET_CURRENT;  /* result in mA */

	/* voltage */
	value = (data[9]<<8) + data[8];
	value &= 0x0fff; /* mask unused bits */
	if (value >= 0x0800)
		value -= 0x1000;  /* convert to signed value */
	value = conv(value,VoltageFactor);  /* result in mV */
	BattData->Voltage = value;  /* result in mV */

	/* temperature */
	value = data[10];
	if (value >= 0x80)
		value -= 0x100;  /* convert to signed value */
	BattData->Temperature = value * 10;  /* result in 0.1 degreeC */

	/* Avg current */
	value = (data[12]<<8) + data[11];
	if (value >= 0x8000)
		value -= 0x10000;  /* convert to signed value */
	if (BattData->Vmode == 0) {
		value = conv(value, BattData->CurrentFactor);
		value = value / 4;  /* divide by 4  */
	}
	else {
		value = conv(value, BattData->CRateFactor);
	}
	BattData->AvgCurrent = value;  /* result in mA */

	/* OCV */
	value = (data[14]<<8) + data[13];
	value &= 0x3fff; /* mask unused bits */
	if (value >= 0x02000)
		value -= 0x4000;  /* convert to signed value */
	value = conv(value,VoltageFactor);
	value = (value+2) / 4;  /* divide by 4 with rounding */
	BattData->OCV = value;  /* result in mV */

	/* read STC3117 registers CC & VM adj */
	res = STC31xx_Read(4, STC311x_REG_CC_ADJ, data);
	if (res < 0)
		return(res);  /* read failed */

	/* CC & VM adjustment counters */
	value = (data[1]<<8) + data[0];
	if (value >= 0x8000)
		value -= 0x10000;  /* convert to signed value */
	BattData->CC_adj = value; /* in 1/512% */
	value = (data[3]<<8) + data[2];
	if (value >= 0x8000)
		value -= 0x10000;  /* convert to signed value */
	BattData->VM_adj = value; /* in 1/512% */

	/* relax counter */
	res = STC31xx_Read(1, STC311x_REG_CMONIT_COUNT, data);
	if (res<0)
		return(res);  /* read failed */
	BattData->RelaxTimer = data[0];

	return(OK);
}

/*******************************************************************************
* Function Name  : STC311x_ReadRamData
* Description    : utility function to read the RAM data from STC311x
* Input          : ref to RAM data array
* Return         : error status (OK, !OK)
*******************************************************************************/
static int STC311x_ReadRamData(unsigned char *RamData)
{
	return(STC31xx_Read(RAM_SIZE, STC311x_REG_RAM, RamData));
}


/*******************************************************************************
* Function Name  : STC311x_WriteRamData
* Description    : utility function to write the RAM data into STC311x
* Input          : ref to RAM data array
* Return         : error status (OK, !OK)
*******************************************************************************/
static int STC311x_WriteRamData(unsigned char *RamData)
{
	return(STC31xx_Write(RAM_SIZE, STC311x_REG_RAM, RamData));
}

/*******************************************************************************
* Function Name  : Interpolate
* Description    : interpolate a Y value from a X value and X, Y tables (n points)
* Input          : x
* Return         : y
*******************************************************************************/
static int interpolate(int x, int n, int const *tabx, int const *taby )
{
	int index;
	int y;

	if (x >= tabx[0])
		y = taby[0];
	else if (x <= tabx[n-1])
		y = taby[n-1];
	else {
		/*  find interval */
		for (index= 1;index<n;index++)
			if (x > tabx[index]) break;
		/*  interpolate */
		y = (taby[index-1] - taby[index]) * (x - tabx[index]) * 2 / (tabx[index-1] - tabx[index]);
		y = (y+1) / 2;
		y += taby[index];
	}
	return y;
}

/*******************************************************************************
* Function Name  : calcCRC8
* Description    : calculate the CRC8
* Input          : data: pointer to byte array, n: number of vytes
* Return         : CRC calue
*******************************************************************************/
static int calcCRC8(unsigned char *data, int n)
{
	int crc = 0;   /* initial value */
	int i, j;

	for (i=0;i<n;i++) {
		crc ^= data[i];
		for (j=0;j<8;j++) {
			crc <<= 1;
			if (crc & 0x100)
				crc ^= 7;
		}
	}
	return(crc & 255);
}


/*******************************************************************************
* Function Name  : UpdateRamCrc
* Description    : calculate the RAM CRC
* Input          : none
* Return         : CRC value
*******************************************************************************/
static int UpdateRamCrc(void)
{
	int res;

	res = calcCRC8(GG_Ram.db,RAM_SIZE-1);
	GG_Ram.db[RAM_SIZE-1] = res;   /* last byte holds the CRC */
	return(res);
}

/*******************************************************************************
* Function Name  : Init_RAM
* Description    : Init the STC311x RAM registers with valid test word and CRC
* Input          : none
* Return         : none
*******************************************************************************/
static void Init_RAM(void)
{
	int index;

	for (index=0;index<RAM_SIZE;index++)
		GG_Ram.db[index] = 0;
	GG_Ram.reg.TstWord = RAM_TSTWORD;  /* id. to check RAM integrity */
	GG_Ram.reg.CC_cnf = BattData.CC_cnf;
	GG_Ram.reg.VM_cnf = BattData.VM_cnf;
	/* update the crc */
	UpdateRamCrc();
}

/* compensate SOC with temperature, SOC in 0.1% units */
static int CompensateSOC(int value, int temp)
{
	int r, v;

	r = 0;
#ifdef TEMPCOMP_SOC
	r = interpolate(temp/10,NTEMP,TempTable,BattData.CapacityDerating);  /* for APP_TYP_CURRENT */
#endif
	v = (long) (value-r) * MAX_SOC * 2 / (MAX_SOC-r);   /* compensate */
	v = (v+1)/2;  /* rounding */
	if (v < 0) v = 0;
	if (v > MAX_SOC) v = MAX_SOC;

	return(v);
}

/*******************************************************************************
* Function Name  : MM_FSM
* Description    : process the Gas Gauge state machine in mixed mode
* Input          : BattData
* Return         :
* Affect         : Global Gas Gauge data
*******************************************************************************/
static void MM_FSM(void)
{
	switch (BattData.BattState) {
		case BATT_CHARGING:
			if (BattData.AvgCurrent < CHG_MIN_CURRENT)
				BattData.BattState = BATT_ENDCHARG;        /* end of charge */
			break;
		case BATT_ENDCHARG:  /* end of charge state. check if fully charged or charge interrupted */
			if ( BattData.Current > CHG_MIN_CURRENT )
				BattData.BattState = BATT_CHARGING;
			else if (BattData.AvgCurrent < CHG_END_CURRENT )
				BattData.BattState = BATT_IDLE;     /* charge interrupted */
			else if ( (BattData.Current > CHG_END_CURRENT ) && ( BattData.Voltage > BATT_CHG_VOLTAGE ) )
				BattData.BattState = BATT_FULCHARG;  /* end of charge */
			break;
		case BATT_FULCHARG:  /* full charge state. wait for actual end of charge current */
			if ( (BattData.Current > CHG_MIN_CURRENT))
				BattData.BattState = BATT_CHARGING;  /* charge again */
			else if ( BattData.AvgCurrent < CHG_END_CURRENT ) {
				if ( BattData.AvgVoltage > BATT_CHG_VOLTAGE ) {
					/* end of charge detected */
					STC311x_SetSOC(MAX_HRSOC);
					BattData.SOC=MAX_SOC;  /* 100% */
				}
				BattData.BattState = BATT_IDLE;     /* end of charge cycle */
			}
			break;
		case BATT_IDLE:  /* no charging, no discharging */
			if (BattData.Current > CHG_END_CURRENT) {
				BattData.BattState = BATT_CHARGING; /* charging again */
			}
			else if (BattData.Current < APP_MIN_CURRENT)
				BattData.BattState = BATT_DISCHARG; /* discharging again */
			break;
		case BATT_DISCHARG:
			if (BattData.Current > APP_MIN_CURRENT)
				BattData.BattState = BATT_IDLE;
			else if (BattData.AvgVoltage < BATT_MIN_VOLTAGE)
				BattData.BattState = BATT_LOWBATT;
			break;
		case BATT_LOWBATT:  /* battery nearly empty... */
			if ( BattData.AvgVoltage > (BATT_MIN_VOLTAGE+50) )
				BattData.BattState = BATT_IDLE;   /* idle */
			else
				break;
		default:
			BattData.BattState = BATT_IDLE;   /* idle */
	} /* end switch */
}

static void CompensateVM(int temp)
{
	int r;

#ifdef TEMPCOMP_SOC
	r=interpolate(temp/10,NTEMP,TempTable,BattData.VM_TempTable);
	GG_Ram.reg.VM_cnf = (BattData.VM_cnf * r) / 100;
	STC311x_SaveVMCnf();  /* save new VM cnf values to STC311x */
#endif
}

/*******************************************************************************
* Function Name  : VM_FSM
* Description    : process the Gas Gauge machine in voltage mode
* Input          : BattData
* Return         :
* Affect         : Global Gas Gauge data
*******************************************************************************/
static void VM_FSM(void)
{
#define DELTA_TEMP 30   /* 3 degreeC */

	/* in voltage mode, monitor temperature to compensate voltage mode gain */

	if ( ( BattData.AvgTemperature > (BattData.LastTemperature+DELTA_TEMP)) ||
	   ( BattData.AvgTemperature < (BattData.LastTemperature-DELTA_TEMP)) ) {
		BattData.LastTemperature = BattData.AvgTemperature;
		CompensateVM(BattData.AvgTemperature);
	}
}

#if defined(STC3117_AGING_VOLTAGE_FEATURE)
static void CompensateVolCCCnf(int cc_cnf_offset)
{
	pr_err("[Alan] 1. BattData.CC_cnf=%d\n", BattData.CC_cnf);
	pr_err("[Alan] 1. GG_Ram.reg.CC_cnf=%d\n", GG_Ram.reg.CC_cnf);
	pr_err("[Alan] aging trigger, update the cc_cnf %d + (%d)\n", GG_Ram.reg.CC_cnf, cc_cnf_offset);
	GG_Ram.reg.CC_cnf += cc_cnf_offset;
	STC311x_SaveCCCnf();  /* save new CC cnf values to STC311x */
	pr_err("[Alan] 2. BattData.CC_cnf=%d\n", BattData.CC_cnf);
	pr_err("[Alan] 2. GG_Ram.reg.CC_cnf=%d\n", GG_Ram.reg.CC_cnf);
}
#endif /* STC3117_AGING_VOLTAGE_FEATURE */

#if defined(STC3117_AGING_FEATURE)
static void CompensateCCCnf(int battery_capacity_aging_level)
{
	int aging_cc_cnf = 0;
	pr_err("[Alan] 1. BattData.CC_cnf=%d\n", BattData.CC_cnf);
	pr_err("[Alan] 1. GG_Ram.reg.CC_cnf=%d\n", GG_Ram.reg.CC_cnf);
	aging_cc_cnf = (BattData.CC_cnf * battery_capacity_aging_level) / 100;
	//GG_Ram.reg.CC_cnf = (BattData.CC_cnf * battery_capacity_aging_level) / 100;
	if (GG_Ram.reg.CC_cnf != aging_cc_cnf) {
		pr_err("[Alan] aging trigger, update the cc_cnf from %d to %d\n", GG_Ram.reg.CC_cnf, aging_cc_cnf);
		GG_Ram.reg.CC_cnf = aging_cc_cnf;
		STC311x_SaveCCCnf();  /* save new CC cnf values to STC311x */
	} else {
		pr_err("[Alan] cc_cnf is the same value, no need to update\n");
	}
	pr_err("[Alan] 2. BattData.CC_cnf=%d\n", BattData.CC_cnf);
	pr_err("[Alan] 2. GG_Ram.reg.CC_cnf=%d\n", GG_Ram.reg.CC_cnf);
}
#endif /* STC3117_AGING_FEATURE */

/*******************************************************************************
* Function Name  : Reset_FSM_GG
* Description    : reset the gas gauge state machine and flags
* Input          : None
* Return         : None
*******************************************************************************/
static void Reset_FSM_GG(void)
{
	BattData.BattState = BATT_IDLE;
}

/* -------------------- Algo functions ------------------------------------------- */

/* Disable SOC_correction because accurecy issue */
/* #define OG2 */

void SOC_correction (GasGauge_DataTypeDef *GG)
{
#ifdef OG2
	int Var1 = 0;
	int Var2,Var3,Var4;
	int SOCopt;


	#define CURRENT_TH  (GG->Cnom/10)
	#define GAIN 10
	#define A_Var3 500
	#define VAR1MAX 64
	#define VAR2MAX 128
	#define VAR4MAX 128

	if (BattData.SOC>800)  Var3 = 600;
	else if (BattData.SOC>500) Var3 = 400;
	else if (BattData.SOC>250) Var3 = 200;
	else if (BattData.SOC>100) Var3 = 300;
	else Var3 = 400;

	Var1 = 256*BattData.AvgCurrent*A_Var3/Var3/CURRENT_TH;
	Var1 = 32768 * GAIN / (256+Var1*Var1/256) / 10;
	Var1 = (Var1+1)/2;
	if (Var1 == 0) Var1 = 1;
	if (Var1 >= VAR1MAX) Var1 = VAR1MAX - 1;
	GG->Var1 = Var1;

	Var4 = BattData.CC_adj - BattData.VM_adj;
	if (BattData.GG_Mode == CC_MODE)
		SOCopt = BattData.HRSOC + Var1 * Var4 / 64;
	else
		SOCopt = BattData.HRSOC - BattData.CC_adj + Var1 * Var4 / 64;

	Var2 = BattData.Nropt;
	if ( (BattData.AvgCurrent < -CURRENT_TH) || (BattData.AvgCurrent > CURRENT_TH) ) {
		if (Var2<VAR2MAX)  Var2++;
		BattData.Ropt = BattData.Ropt + ( 1000 * (BattData.Voltage-BattData.OCV) / BattData.AvgCurrent - BattData.Ropt / Var2);
		BattData.Nropt = Var2;
	}
	if (Var2>0)
		GG->Ropt = BattData.Ropt / Var2;
	else
		GG->Ropt = 0;  // not available

	if (SOCopt <= 0 )
		SOCopt = 0;
	if (SOCopt >= MAX_HRSOC)
		SOCopt = MAX_HRSOC;
	BattData.SOC = (SOCopt*10+256)/512;
	if ( (Var4<(-VAR4MAX)) || (Var4>=VAR4MAX) ) {
		// rewrite SOCopt into STC311x and clear acc registers
		STC311x_SetSOC(SOCopt);
	}
#endif
}

/* --------------------------------------------------------------------------------------------- */


/* -------------------- firmware interface functions ------------------------------------------- */

/*******************************************************************************
* Function Name  : GasGauge_Start
* Description    : Start the Gas Gauge system
* Input          : algo parameters in GG structure
* Return         : 0 is ok, -1 if STC310x not found or I2C error
* Affect         : global STC310x data and gas gauge variables
*******************************************************************************/
int GasGauge_Start(GasGauge_DataTypeDef *GG)
{
	int res, i;

	BattData.Cnom = GG->Cnom;
	BattData.Rsense = GG->Rsense;
	BattData.Rint = GG->Rint;
	BattData.Vmode = GG->Vmode;
	BattData.CC_cnf = GG->CC_cnf;
	BattData.VM_cnf = GG->VM_cnf;
	BattData.Alm_SOC = GG-> Alm_SOC;
	BattData.Alm_Vbat = GG->Alm_Vbat;
	BattData.RelaxThreshold = GG->RelaxCurrent;

	/* Init averaging */
	BattData.AvgVoltage = 0;
	BattData.AvgCurrent = 0;
	BattData.AvgTemperature = 0;
	BattData.AvgSOC = 0;  /* in 0.1% unit  */
	BattData.AccVoltage = 0;
	BattData.AccCurrent = 0;
	BattData.AccTemperature = 0;
	BattData.AccSOC = 0;

	// BATD
	BattData.BattOnline = 1;

	/* LastSOC init */
	BattData.LastSOC = -1;

	if (BattData.Rsense == 0) BattData.Rsense = 10;  /* default value in case, to avoid divide by 0 */
	BattData.CurrentFactor = 24084 / BattData.Rsense;    /* LSB=5.88uV/R= ~24084/R/4096 - convert to mA  */
	BattData.CRateFactor = 36 * BattData.Cnom;        /* LSB=0.008789.Cnom= 36*Cnom/4096 - convert to mA  */

	if (BattData.CC_cnf == 0) BattData.CC_cnf = 395;  /* default values */
	if (BattData.VM_cnf == 0) BattData.VM_cnf = 321;

	for (i=0;i<NTEMP;i++)
		BattData.CapacityDerating[i] = GG->CapDerating[i];
	for (i=0;i<OCVTAB_SIZE;i++) {
		BattData.OCVValue[i] = GG->OCVValue[i];
		//BattData.SOCValue[i] = GG->SOCValue[i];
	}
	for (i=0;i<NTEMP;i++)
		BattData.VM_TempTable[i] = DefVMTempTable[i];

	BattData.Ropt = 0;
	BattData.Nropt = 0;

	/* check RAM valid */
	STC311x_ReadRamData(GG_Ram.db);

	if ( (GG_Ram.reg.TstWord != RAM_TSTWORD) || (calcCRC8(GG_Ram.db,RAM_SIZE) != 0) ) {
		/* RAM invalid */
		Init_RAM();
		res=STC311x_Startup();  /* return -1 if I2C error or STC3117 not present */
	}
	else {
		/* check STC3117 status */
		if ((STC311x_Status() & M_RST) != 0 ) {
			res=STC311x_Startup();  /* return -1 if I2C error or STC3117 not present */
		}
		else {
			res=STC311x_Restore(); /* recover from last SOC */
		}
	}

	GG_Ram.reg.GG_Status = GG_INIT;
	/* update the crc */
	UpdateRamCrc();
	STC311x_WriteRamData(GG_Ram.db);

	Reset_FSM_GG();

	return(res);    /* return -1 if I2C error or STC3117 not present */
}

/*******************************************************************************
Restart sequence:
Usage:
  call GasGaugeReset()
  powerdown everything
  wait 500ms
  call GasGaugeStart(GG)
  continue
*******************************************************************************/


/*******************************************************************************
* Function Name  : GasGauge_Reset
* Description    : Reset the Gas Gauge system
* Input          : None
* Return         : 0 is ok, -1 if I2C error
*******************************************************************************/
void GasGauge_Reset(void)
{
	GG_Ram.reg.TstWord = 0;  /* reset RAM */
	GG_Ram.reg.GG_Status = 0;
	STC311x_WriteRamData(GG_Ram.db);

	STC311x_Reset();
}


/*******************************************************************************
* Function Name  : GasGauge_Stop
* Description    : Stop the Gas Gauge system
* Input          : None
* Return         : 0 is ok, -1 if I2C error
*******************************************************************************/
int GasGauge_Stop(void)
{
	int res;

	STC311x_ReadRamData(GG_Ram.db);
	GG_Ram.reg.GG_Status = GG_POWERDN;
	/* update the crc */
	UpdateRamCrc();
	STC311x_WriteRamData(GG_Ram.db);

	res=STC311x_Powerdown();
	if (res != 0) return (-1);  /* error */

	return(0);
}

#ifdef CONFIG_ENABLE_STC311X_DUMPREG
/* Reg info:
 * data[0]:	Mode reg
 * data[1]:	Control reg
 * data[2-3]:	SOC reg
 * data[4-5]:	Counter reg
 * data[6-7]:	Current reg
 * data[8-9]:	Voltage reg
 * data[10]:	Temperature reg
 * data[11-12]:	Avg. Temperature reg
 * data[13-14]: OCV reg
 * data[22]:	CMONIT count
 * data[23]:	CMONIT max
 * data[27-28]:	CC_ADJ
 * data[29-30]: VM_ADJ
 */
#define get_val(x)			(((*x) << 8) | *(x - 1))
static void show_cfg_regs_debug(STC311x_BattDataTypeDef *BattData)
{
	unsigned char data[32];
	int res;
	int value;

	res = STC311x_Status();
	if (res < 0) {
		/* return if I2C error or STC3117 not responding */
		pr_err("I2C error\n");
		return;
	}

	/* read STC3117 registers 0 to 14 */
	res = STC31xx_Read(31, 0, data);
	if (res < 0) {
		/* return if STC3117 not responding */
		pr_err("Read regs failed, res=%d\n", res);
		return;
	}
	pr_debug("REG[00] MODE = 0x%x\n", data[0]);
	pr_debug("REG[01] CTRL = 0x%x, run_mode = %s\n", data[1],
			(data[1] & STC311x_VMODE ? VM_MODE : CC_MODE) ? "VM_MODE" : "CC_MODE");

	/* SOC */
	pr_debug("REG[02-03] SoC = %d, %d\n", get_val(&data[3]), DIV_ROUND_CLOSEST(get_val(&data[3]), 512));

	/* Counter */
	pr_debug("REG[04-05] COUNTER = %d\n", get_val(&data[5]));


	/* current */
	value = get_val(&data[7]);
	value &= 0x3fff;   /* mask unused bits */
	if (value >= 0x2000) value -= 0x4000;  /* convert to signed value */
	pr_debug("REG[06-07] CURRENT = %d mA\n", conv(value, BattData->CurrentFactor));

	/* voltage */
	value = get_val(&data[9]);
	value &= 0x0fff; /* mask unused bits */
	if (value >= 0x0800) value -= 0x1000;  /* convert to signed value */
	value = conv(value,VoltageFactor);  /* result in mV */
	pr_debug("REG[08-09] VOLTAGE = %d mV\n", value);

	/* temperature */
	value = data[10];
	if (value >= 0x80) value -= 0x100;  /* convert to signed value */
	pr_debug("REG[10] TEMP = %d degC\n", value);

	/* Avg current */
	value = get_val(&data[12]);
	if (value >= 0x8000) value -= 0x10000;  /* convert to signed value */
	if (BattData->Vmode == 0) {
		value = conv(value, BattData->CurrentFactor);
		value = value / 4;  /* divide by 4  */
	}
	else {
		value = conv(value, BattData->CRateFactor);
	}
	pr_debug("REG[11-12] AVG CURRENT = %d mA\n", value);

	/* OCV */
	value = get_val(&data[14]);
	value &= 0x3fff; /* mask unused bits */
	if (value >= 0x02000) value -= 0x4000;  /* convert to signed value */
	value = conv(value,VoltageFactor);
	value = (value+2) / 4;  /* divide by 4 with rounding */
	pr_debug("REG[13-14] OCV = %d mV\n", value);

	/* CC_CNF */
	pr_debug("REG[15-16] CC_CNF = %d\n", get_val(&data[16]));

	/* VM_CNF */
	pr_debug("REG[17-18] VM_CNF = %d\n", get_val(&data[18]));

	/* Current threshold */
	pr_debug("REG[21] CURRENT_THRES = %d\n", data[21]);

	/* CMONIT count */
	//chip->cmonit_max = reg[1];
	pr_debug("REG[22] CMONIT_COUNT = %d\n", data[22]);

	/* CMONIT max */
	//chip->cmonit_max = reg[1];
	pr_debug("REG[23] CMONIT_MAX = %d\n", data[23]);

	/* cc & vm adjustment counters */
	value = get_val(&data[28]);
	if (value >= 0x8000) value -= 0x10000;  /* convert to signed value */
	pr_debug("REG[27-28] CC_ADJ = %d\n", value);

	value = get_val(&data[30]);
	if (value >= 0x8000) value -= 0x10000;  /* convert to signed value */
	pr_debug("REG[29-30] VM_ADJ = %d\n", value);

}

static void show_soc_ocvtab_regs_debug(void)
{
	int rc, i;
	int ocv_mv;

	pr_debug("============SOC OCV tab ============\n");
	for (i = 0 ; i < OCVTAB_SIZE; i++) {
		ocv_mv = STC31xx_ReadWord(STC311x_REG_OCVTAB + (i * 2));
		rc = STC31xx_ReadByte(STC311x_REG_SOCTAB + i);
		ocv_mv &= 0x3fff; /* mask unused bits */
		if (ocv_mv >= 0x02000) ocv_mv -= 0x4000;  /* convert to signed value */
		ocv_mv = conv(ocv_mv, VoltageFactor);
		ocv_mv = (ocv_mv + 2) / 4;  /* divide by 4 with rounding */

		pr_debug("0x%02x = 0x%02x(%3d%%), 0x%02x ocv=%hu mV\n",
			STC311x_REG_SOCTAB + i, rc, rc / 2,
			STC311x_REG_OCVTAB + (i * 2), ocv_mv);
	}

	return;
}

static void show_ram_regs_debug(void)
{
	int rc;
	u8 addr;

	pr_debug("============ RAM registers ============\n");
	for (addr = STC311x_REG_RAM; addr < STC311x_REG_RAM + RAM_SIZE; addr++) {
		rc = STC31xx_ReadByte(addr);
		pr_debug("0x%02x = 0x%02x\n", addr, rc);
	}

	return;
}
#endif /* CONFIG_ENABLE_STC311X_DUMPREG */

#if defined(STC3117_AGING_VOLTAGE_FEATURE)
static void voltage_aging_compensation(int SOC, int avg_current) {

	int level = 0;
	int aging_comparsion_array_num = 0;

	pr_debug("Voltage aging compensation, avg_current=%d\n", avg_current);
	if (avg_current >= -100 && avg_current < 0) {
		level = 0;
	} else if (avg_current >= -150 && avg_current < -100) {
		level = 1;
	} else if (avg_current >= -200 && avg_current < -150) {
		level = 2;
	} else if (avg_current >= -250 && avg_current < -200) {
		level = 3;
	} else {
		pr_err("Other case, no need to aging\n");
		return;
	}

	aging_comparsion_array_num = sizeof(aging_comparsion_tbl) / sizeof(aging_comparsion_tbl[0]);
	pr_debug("Level %d aging compensation\n", level);
	if ((level < 0) | (level >= aging_comparsion_array_num)) {
		pr_err("Aging level out of range\n");
		return;
	}

	if (SOC > aging_comparsion_tbl[level]+20) {
		CompensateVolCCCnf(-1);
	} else if (SOC < aging_comparsion_tbl[level]-20) {
		CompensateVolCCCnf(1);
	} else {
		pr_err("Voltage aging in range, no need to do compensation\n");
		return;
	}
}
#endif /* STC3117_AGING_VOLTAGE_FEATURE */

int Dynamic_Early_Empty(int SOC, int voltage, int current_vol, int avg_current) {

	int rc = 0;
	int level = 0;
	int deec_3_array_num = 0;
	int deec_1_array_num = 0;

	pr_debug("Dynamic early empty compensation, SOC=%d, voltage=%d, avg_current=%d\n", SOC, voltage, avg_current);

	if (avg_current >= -15 && avg_current < 0 && voltage < deec_7_voltage_lvl[0]) {
		level = 0;
	} else if (avg_current >= -30 && avg_current < -15 && voltage < deec_7_voltage_lvl[1]) {
		level = 1;
	} else if (avg_current >= -50 && avg_current < -30 && voltage < deec_7_voltage_lvl[2]) {
		level = 2;
	} else if (avg_current >= -100 && avg_current < -50 && voltage < deec_7_voltage_lvl[3]) {
		level = 3;
	} else if (avg_current >= -150 && avg_current < -100 && voltage < deec_7_voltage_lvl[4]) {
		level = 4;
	} else if (avg_current >= -200 && avg_current < -150 && voltage < deec_7_voltage_lvl[5]) {
		level = 5;
	} else if (avg_current >= -250 && avg_current < -200 && voltage < deec_7_voltage_lvl[6]) {
		level = 6;
	} else if (avg_current >= -300 && avg_current < -250 && voltage < deec_7_voltage_lvl[7]) {
		level = 7;
	} else if (avg_current >= -325 && avg_current < -300 && voltage < deec_7_voltage_lvl[8]) {
		level = 8;
	} else if (avg_current >= -375 && avg_current < -325 && voltage < deec_7_voltage_lvl[9]) {
		level = 9;
	} else if (avg_current >= -425 && avg_current < -375 && voltage < deec_7_voltage_lvl[10]) {
		level = 10;
	} else if (avg_current >= -475 && avg_current < -425 && voltage < deec_7_voltage_lvl[11]) {
		level = 11;
	} else if (avg_current >= -525 && avg_current < -475 && voltage < deec_7_voltage_lvl[12]) {
		level = 12;
	} else if (avg_current >= -575 && avg_current < -525 && voltage < deec_7_voltage_lvl[13]) {
		level = 13;
	} else if (avg_current >= -625 && avg_current < -575 && voltage < deec_7_voltage_lvl[14]) {
		level = 14;
	} else if (avg_current >= -675 && avg_current < -625 && voltage < deec_7_voltage_lvl[15]) {
		level = 15;
	} else if (avg_current >= -725 && avg_current < -675 && voltage < deec_7_voltage_lvl[16]) {
		level = 16;
	} else if (avg_current >= -775 && avg_current < -725 && voltage < deec_7_voltage_lvl[17]) {
		level = 17;
	} else if (avg_current >= -825 && avg_current < -775 && voltage < deec_7_voltage_lvl[18]) {
		level = 18;
	} else if (avg_current >= -875 && avg_current < -825 && voltage < deec_7_voltage_lvl[19]) {
		level = 19;
	} else if (avg_current >= -925 && avg_current < -875 && voltage < deec_7_voltage_lvl[20]) {
		level = 20;
	} else if (avg_current >= -975 && avg_current < -925 && voltage < deec_7_voltage_lvl[21]) {
		level = 21;
	} else if (avg_current >= -1025 && avg_current < -975 && voltage < deec_7_voltage_lvl[22]) {
		level = 22;
	} else if (avg_current >= -1075 && avg_current < -1025 && voltage < deec_7_voltage_lvl[23]) {
		level = 23;
	} else if (avg_current >= -1125 && avg_current < -1075 && voltage < deec_7_voltage_lvl[24]) {
		level = 24;
	} else if (avg_current >= -1175 && avg_current < -1125 && voltage < deec_7_voltage_lvl[25]) {
		level = 25;
	} else if (avg_current < -1175 && voltage < deec_7_voltage_lvl[26]) {
		level = 26;
	} else {
		pr_err("Don't do dynamic early empty compensation\n");
		rc = SOC;
		return rc;
	}

	pr_debug("Case %d compensation\n", level);

	// Dynamic early empty range check
	deec_3_array_num = sizeof(deec_3_voltage_lvl) / sizeof(deec_3_voltage_lvl[0]);
	deec_1_array_num = sizeof(deec_1_voltage_lvl) / sizeof(deec_1_voltage_lvl[0]);
	if ((level < 0) | (level >= deec_3_array_num) | (level >= deec_1_array_num)) {
		pr_err("Level out of range\n");
		return SOC;
	}

	if (voltage > deec_3_voltage_lvl[level]) {
		if (SOC < SECOND_EEC_SOC) {
			pr_err("SOC less 3 percentage, keep current SOC\n");
			return SOC;
		}
		pr_debug("Case %d-1 compensation\n", level);
		rc = SECOND_EEC_SOC + (SOC - SECOND_EEC_SOC) * (voltage - deec_3_voltage_lvl[level]) / (deec_7_voltage_lvl[level] - deec_3_voltage_lvl[level]);
	} else if (voltage > deec_1_voltage_lvl[level] && voltage <= deec_3_voltage_lvl[level]) {
		pr_debug("Case %d-2 compensation\n", level);
		rc = THIRD_EEC_SOC + (SECOND_EEC_SOC - THIRD_EEC_SOC) * (voltage - deec_1_voltage_lvl[level]) / (deec_3_voltage_lvl[level] - deec_1_voltage_lvl[level]);
	} else {
		pr_debug("Case %d-3 compensation\n", level);
		rc = THIRD_EEC_SOC;
	}

	/* if current voltage higher than average voltage, means transfer to light loading.  *
	 * Meanwhile the SOC drop exceed 5% is abnormal case because the Avg vol and current *
	 * decouple trend.                                                                   */
	if (current_vol > (voltage + 20) && (SOC - rc) > 50) {
		pr_err("DEEC result exceed 5 percent and current voltage(%d) great than avg voltage(%d) 20mV up, then bypass this DEEC data. SOC=%d rc=%d\n",
			current_vol, voltage, SOC, rc);
		rc = SOC;
	}

	/* Use 3 secs voltage offset to bypass the heavy loading. */
	if (level >= 3 && current_vol < voltage - three_secs_voltage_filter_tbl[level] ) {
		pr_err("Current voltage(%d) less than avg voltage(%d) (%d)mV up, then hold real SOC. SOC=%d rc=%d\n",
			current_vol, voltage, three_secs_voltage_filter_tbl[level], SOC, rc);
		rc = SOC;
	}

	return rc;
}

/*******************************************************************************
* Function Name  : GasGauge_Task
* Description    : Periodic Gas Gauge task, to be called e.g. every 5 sec.
* Input          : pointer to gas gauge data structure
* Return         : 1 if data available, 0 if no data, -1 if error
* Affect         : global STC310x data and gas gauge variables
*******************************************************************************/
int GasGauge_Task(GasGauge_DataTypeDef *GG)
{
	int res, value;
	BattData.Cnom = GG->Cnom;
	BattData.Rsense = GG->Rsense;
	BattData.Vmode = GG->Vmode;
	BattData.Rint = GG->Rint;
	BattData.CC_cnf = GG->CC_cnf;
	BattData.VM_cnf = GG->VM_cnf;
	BattData.Alm_SOC = GG-> Alm_SOC;
	BattData.Alm_Vbat = GG->Alm_Vbat;
	BattData.RelaxThreshold = GG->RelaxCurrent;

	res=STC311x_ReadBatteryData(&BattData);  /* read battery data into global variables */
	if (res != 0) return(-1); /* abort in case of I2C failure */

#ifdef CONFIG_ENABLE_STC311X_DUMPREG
	pr_debug("===== Before task =====\n");
	show_cfg_regs_debug(&BattData);
	show_soc_ocvtab_regs_debug();
	show_ram_regs_debug();
#endif /* CONFIG_ENABLE_STC311X_DUMPREG */

	/* check if RAM data is ok (battery has not been changed) */
	STC311x_ReadRamData(GG_Ram.db);
	if ( (GG_Ram.reg.TstWord!= RAM_TSTWORD) || (calcCRC8(GG_Ram.db,RAM_SIZE)!=0) ) {
		/* if RAM non ok, reset it and set init state */
		Init_RAM();
		GG_Ram.reg.GG_Status = GG_INIT;
	}

	/* Check battery presence */
	if ((BattData.STC_Status & M_BATFAIL) != 0) {
		BattData.BattOnline = 0;
	}
	/* check STC3117 status */
#ifdef BATD_UC8
	/* check STC3117 status */
	if ((BattData.STC_Status & (M_BATFAIL | M_UVLOD)) != 0) {
		/* BATD or UVLO detected */
		if(BattData.ConvCounter > 0) {
			GG->Voltage=BattData.Voltage;
			GG->SOC=(BattData.HRSOC*10+256)/512;
			pr_err("BATD or UVLO, voltage:%d, SOC:%d\n", GG->Voltage, GG->SOC);
		}

		/* BATD or UVLO detected */
		GasGauge_Reset();

		return (-1);
	}
#endif

	if ((BattData.STC_Status & M_RUN) == 0) {
		/* if not running, restore STC3117 */
		STC311x_Restore();
		GG_Ram.reg.GG_Status = GG_INIT;
	}

	BattData.SOC = (BattData.HRSOC*10+256)/512;  /* in 0.1% unit  */

	//Force an external temperature
	if(GG->ForceExternalTemperature == 1)
		BattData.Temperature = GG->ExternalTemperature;

	/* check INIT state */
	if (GG_Ram.reg.GG_Status == GG_INIT) {
		/* INIT state, wait for current & temperature value available: */
		if (BattData.ConvCounter>VCOUNT) {
			/* update VM_cnf */
			CompensateVM(BattData.Temperature);
			BattData.LastTemperature=BattData.Temperature;

			/* Init averaging */
			BattData.AvgVoltage = BattData.Voltage;
			BattData.AvgCurrent = BattData.Current;
			BattData.AvgTemperature = BattData.Temperature;
			BattData.AvgSOC = CompensateSOC(BattData.SOC,BattData.Temperature);  /* in 0.1% unit  */
			BattData.AccVoltage = BattData.AvgVoltage*AVGFILTER;
			BattData.AccCurrent = BattData.AvgCurrent*AVGFILTER;
			BattData.AccTemperature = BattData.AvgTemperature*AVGFILTER;
			BattData.AccSOC = BattData.AvgSOC*AVGFILTER;

			GG_Ram.reg.GG_Status = GG_RUNNING;
		}
	}


	if (GG_Ram.reg.GG_Status != GG_RUNNING) {
		GG->SOC = CompensateSOC(BattData.SOC,250);
		GG->Voltage=BattData.Voltage;
		GG->OCV = BattData.OCV;
		GG->Current=0;
		GG->RemTime = -1;   /* means no estimated time available */
		GG->Temperature=250;
	} else {
		//Check battery presence
		if ((BattData.STC_Status & M_BATFAIL) == 0) {
			BattData.BattOnline = 1;
		}

		SOC_correction (GG);

#if defined(STC3117_AGING_FEATURE)
		CompensateCCCnf(battery_capacity_aging_level);
#endif /* STC3117_AGING_FEATURE */

		/* SOC derating with temperature */
		BattData.SOC = CompensateSOC(BattData.SOC,BattData.Temperature);

		//early empty compensation
		value=BattData.AvgVoltage;
		if (BattData.Voltage < value) value = BattData.Voltage;
#if defined(STC3117_AGING_VOLTAGE_FEATURE)
		pr_debug("[Alan] aging voltage enter check:%d, aging_trigger_flag:%d, GG_Ram.reg.CC_cnf=%d\n", value, aging_trigger_flag, GG_Ram.reg.CC_cnf);
		if (value <= (AGING_CHECK_VOLTAGE + 5) && value >= (AGING_CHECK_VOLTAGE - 5)) {
			pr_err("[Alan] aging enter check:%d\n", aging_trigger_flag);
			if (aging_trigger_flag) {
				//do aging comarsion
				voltage_aging_compensation(BattData.AvgCurrent, BattData.SOC);
				//if (BattData.AvgCurrent < 0 && BattData.AvgCurrent >= -50)
				aging_trigger_flag = false;
			}

		}
#endif /* STC3117_AGING_VOLTAGE_FEATURE */
		if (value < (APP_MIN_VOLTAGE + 160)) {
			// Voltage drop below 3000 mV, then 0% and shutdown
			if (value < APP_MIN_VOLTAGE_EMPTY) {
				BattData.SOC=0;
				//hardcode HRSOC to gauge reg.
				STC311x_SetSOC(0);
				BattData.LastSOC = BattData.SOC;
			} else {
				//Legacy early empty compensation
				//BattData.SOC = BattData.SOC * (value - APP_MIN_VOLTAGE) / 100;

				/* Use current loading choose voltage baseline */
				BattData.SOC = Dynamic_Early_Empty(BattData.SOC, value, BattData.Voltage, BattData.AvgCurrent);

				//Avoid SOC rebounce
				if (BattData.LastSOC == -1 || BattData.SOC < BattData.LastSOC) {
					BattData.LastSOC = BattData.SOC;
				} else {
					pr_err("SoC rebound occur, BattData.SOC=%d, BattData.LastSOC=%d\n",
						BattData.SOC, BattData.LastSOC);
					BattData.SOC = BattData.LastSOC;
				}
			}
		} else {
			if (BattData.LastSOC != -1) {
				pr_err("Recovery BattData.LastSOC to -1.\n");
				BattData.LastSOC = -1;
			}
		}

		BattData.AccVoltage += (BattData.Voltage - BattData.AvgVoltage);
		BattData.AccCurrent += (BattData.Current - BattData.AvgCurrent);
		BattData.AccTemperature += (BattData.Temperature - BattData.AvgTemperature);
		BattData.AccSOC +=  (BattData.SOC - BattData.AvgSOC);

		BattData.AvgVoltage = (BattData.AccVoltage+AVGFILTER/2)/AVGFILTER;
		BattData.AvgTemperature = (BattData.AccTemperature+AVGFILTER/2)/AVGFILTER;
		BattData.AvgSOC = (BattData.AccSOC+AVGFILTER/2)/AVGFILTER;

		/* ---------- process the Gas Gauge algorithm -------- */

		if (BattData.Vmode)
			VM_FSM();  /* in voltage mode */
		else
			MM_FSM();  /* in mixed mode */

#ifdef DEBUG_SOC
		pr_err("HRSOC=%d, SOC=%d, chg_full_flag=%d, avg_curr=%d\n", BattData.HRSOC, BattData.SOC, chg_full_flag, BattData.AvgCurrent);
#endif
		if (BattData.Vmode==0) {
			// Lately fully compensation
			// toDO: 98_to_100_no_current.txt, no charging and soc goes to 100 even hrsoc is
			// [  736.722530] STC311x: GasGauge_Task: SMB348: HRSOC=50448, SOC=1000, chg_full_flag=0, avg=5
			if (force_full_flag) {
				BattData.SOC = MAX_SOC;
				STC311x_SetSOC(MAX_HRSOC);
				force_full_flag = false;
#if defined(STC3117_AGING_VOLTAGE_FEATURE)
				pr_debug("[Alan] Full Charge, aging_trigger_flag set true\n");
				aging_trigger_flag = true;
#endif /* STC3117_AGING_VOLTAGE_FEATURE */
#ifdef DEBUG_SOC
				pr_err("Lately fully_100: HRSOC=%d, SOC=%d, chg_full_flag=%d\n", BattData.HRSOC, BattData.SOC, chg_full_flag);
#endif
			} else if (BattData.AvgCurrent > 50 && BattData.SOC >= 990 && BattData.SOC < 999) {
				BattData.SOC = 990;
				STC311x_SetSOC(99*512);
#ifdef DEBUG_SOC
				pr_err("Lately fully_99: HRSOC=%d, SOC=%d, chg_full_flag=%d\n", BattData.HRSOC, BattData.SOC, chg_full_flag);
#endif
			}
			// Lately empty compensation
			if (BattData.AvgCurrent < 0 && BattData.SOC < 10 && BattData.Voltage > (APP_MIN_VOLTAGE_EMPTY)) {
				BattData.SOC = 10;
				STC311x_SetSOC(1*512);
			}
#if defined(STC3117_AGING_VOLTAGE_FEATURE)
			if (BattData.AvgCurrent > CHG_NOT_CHARGE && BattData.SOC <= 980) {
				pr_debug("[Alan] Charging now, reset aging_trigger_flag\n");
				aging_trigger_flag = false;
			}
#endif /* STC3117_AGING_VOLTAGE_FEATURE */
		}

		if (BattData.HRSOC > MAX_HRSOC) {
			BattData.SOC = MAX_SOC;
			STC311x_SetSOC(MAX_HRSOC);
		}
#ifdef DEBUG_SOC
		pr_err("report HRSOC=%d, SOC=%d\n", BattData.HRSOC, BattData.SOC);
#endif
		/* -------- APPLICATION RESULTS ------------ */

		/* fill gas gauge data with battery data */
		GG->Voltage=BattData.Voltage;
		GG->Current=BattData.Current;
		GG->Temperature=BattData.Temperature;
		GG->SOC = BattData.SOC;
		GG->OCV = BattData.OCV;

		GG->AvgVoltage = BattData.AvgVoltage;
		GG->AvgCurrent = BattData.AvgCurrent;
		GG->AvgTemperature = BattData.AvgTemperature;
		GG->AvgSOC = BattData.AvgSOC;

		if (BattData.Vmode) {
			/* no current value in voltage mode */
			GG->Current = 0;
			GG->AvgCurrent = 0;
		}

		GG->ChargeValue = (long) BattData.Cnom * BattData.AvgSOC / MAX_SOC;
		if (GG->AvgCurrent<APP_MIN_CURRENT) {
			GG->State=BATT_DISCHARG;
			value = GG->ChargeValue * 60 / (-GG->AvgCurrent);  /* in minutes */

			if (value<0) value=0;
			GG->RemTime = value;
		} else {
			GG->RemTime = -1;   /* means no estimated time available */
			if (GG->AvgCurrent>CHG_END_CURRENT)
				GG->State=BATT_CHARGING;
			else
				GG->State=BATT_IDLE;
		}
	}

	/* save SOC */
	GG_Ram.reg.HRSOC = BattData.HRSOC;
	GG_Ram.reg.SOC = (GG->SOC+5)/10;    /* trace SOC in % */
	UpdateRamCrc();
	STC311x_WriteRamData(GG_Ram.db);

#ifdef CONFIG_ENABLE_STC311X_DUMPREG
	pr_debug("===== After task =====\n");
	show_cfg_regs_debug(&BattData);
	show_soc_ocvtab_regs_debug();
	show_ram_regs_debug();
#endif /* CONFIG_ENABLE_STC311X_DUMPREG */

	if (GG_Ram.reg.GG_Status==GG_RUNNING)
		return(1);
	else
		return(0);  /* only SOC, OCV and voltage are valid */
}

/*******************************************************************************
* Function Name  : STC31xx_SetPowerSavingMode
* Description    :  Set the power saving mode
* Input          : None
* Return         : error status (OK, !OK)
*******************************************************************************/
int STC31xx_SetPowerSavingMode(void)
{
	int res;

	/* Read the mode register*/
	res = STC31xx_ReadByte(STC311x_REG_MODE);

	/* Set the VMODE bit to 1 */
	res = STC31xx_WriteByte(STC311x_REG_MODE, (res | STC311x_VMODE));
	if (res != OK) return (res);

	return (OK);
}

/*******************************************************************************
* Function Name  : STC31xx_StopPowerSavingMode
* Description    :  Stop the power saving mode
* Input          : None
* Return         : error status (OK, !OK)
*******************************************************************************/
int STC31xx_StopPowerSavingMode(void)
{
	int res;

	/* Read the mode register*/
	res = STC31xx_ReadByte(STC311x_REG_MODE);

	/* Set the VMODE bit to 0 */
	res = STC31xx_WriteByte(STC311x_REG_MODE, (res & ~STC311x_VMODE));
	if (res != OK) return (res);

	return (OK);
}

/*******************************************************************************
* Function Name  : STC31xx_AlarmSet
* Description    :  Set the alarm function and set the alarm threshold
* Input          : None
* Return         : error status (OK, !OK)
*******************************************************************************/
int STC31xx_AlarmSet(void)
{
	int res;

	/* Read the mode register*/
	res = STC31xx_ReadByte(STC311x_REG_MODE);

	/* Set the ALM_ENA bit to 1 */
	res = STC31xx_WriteByte(STC311x_REG_MODE, (res | STC311x_ALM_ENA));
	if (res != OK) return (res);

	return (OK);
}


/*******************************************************************************
* Function Name  : STC31xx_AlarmStop
* Description    :  Stop the alarm function
* Input          : None
* Return         : error status (OK, !OK)
*******************************************************************************/
int STC31xx_AlarmStop(void)
{
	int res;

	/* Read the mode register*/
	res = STC31xx_ReadByte(STC311x_REG_MODE);

	/* Set the ALM_ENA bit to 0 */
	res = STC31xx_WriteByte(STC311x_REG_MODE, (res & ~STC311x_ALM_ENA));
	if (res != OK) return (res);

	return (OK);
}

/*******************************************************************************
* Function Name  : STC31xx_AlarmGet
* Description    : Return the ALM status
* Input          : None
* Return         : ALM status 00 : no alarm
*                             01 : SOC alarm
*                             10 : Voltage alarm
*                             11 : SOC and voltage alarm
*******************************************************************************/
int STC31xx_AlarmGet(void)
{
	int res;

	/* Read the mode register*/
	res = STC31xx_ReadByte(STC311x_REG_CTRL);
	res = res >> 5;

	return (res);
}

/*******************************************************************************
* Function Name  : STC31xx_AlarmClear
* Description    :  Clear the alarm signal
* Input          : None
* Return         : error status (OK, !OK)
*******************************************************************************/
int STC31xx_AlarmClear(void)
{
	int res;

	/* clear ALM bits*/
	res = STC31xx_WriteByte(STC311x_REG_CTRL, 0x01);
	if (res != OK) return (res);

	return (res);
}

/*******************************************************************************
* Function Name  : STC31xx_AlarmSetVoltageThreshold
* Description    : Set the alarm threshold
* Input          : int voltage threshold
* Return         : error status (OK, !OK)
*******************************************************************************/
int STC31xx_AlarmSetVoltageThreshold(int VoltThresh)
{
	int res;
	int value;

	BattData.Alm_Vbat = VoltThresh;

	value= ((BattData.Alm_Vbat << 9) / VoltageFactor); /* LSB=8*2.44mV */
	res = STC31xx_WriteByte(STC311x_REG_ALARM_VOLTAGE, value);
	if (res != OK) return (res);

	return (OK);
}

/*******************************************************************************
* Function Name  : STC31xx_AlarmSetSOCThreshold
* Description    : Set the alarm threshold
* Input          : int voltage threshold
* Return         : error status (OK, !OK)
*******************************************************************************/
int STC31xx_AlarmSetSOCThreshold(int SOCThresh)
{
	int res;

	BattData.Alm_SOC = SOCThresh;
	res = STC31xx_WriteByte(STC311x_REG_ALARM_SOC, BattData.Alm_SOC * 2);
	if (res != OK) return (res);

	return (OK);
}

/*******************************************************************************
* Function Name  : STC31xx_RelaxTmrSet
* Description    :  Set the current threshold register to the passed value in mA
* Input          : int current threshold
* Return         : error status (OK, !OK)
*******************************************************************************/
int STC31xx_RelaxTmrSet(int CurrentThreshold)
{
	int res, value;

	BattData.RelaxThreshold = CurrentThreshold;
	if (BattData.CurrentFactor != 0) {
		value= ((BattData.RelaxThreshold << 9) / BattData.CurrentFactor);   /* LSB=8*5.88uV/Rsense */
		value = value & 0x7f;
		res = STC31xx_WriteByte(STC311x_REG_CURRENT_THRES,value);
		if (res != OK) return (res);
	}

	return (OK);
}

/*******************************************************************************
* Function Name  : STC31xx_ForceCC
* Description    :  Force the CC mode for CC eval
* Input          :
* Return         : error status (OK, !OK)
*******************************************************************************/
int STC31xx_ForceCC(void)
{
	STC311x_ForceCC();

	return (OK);
}

#if 0
/*******************************************************************************
* Function Name  : STC311x_ForceCD_high
* Description    :  Force the CD pin to high level (charger disable)
* Input          :
* Return         :
*******************************************************************************/
static void STC311x_ForceCD_high(void)
{
	int value;

	value = STC31xx_ReadByte(STC311x_REG_MODE);
	STC31xx_WriteByte(STC311x_REG_MODE,value | STC311x_FORCE_CD);   /*   force CD high */
}

/*******************************************************************************
* Function Name  : STC311x_ForceCD_low
* Description    :  Force the CD pin to low level (charger enable)
* Input          :
* Return         :
*******************************************************************************/
static void STC311x_ForceCD_low(void)
{
	int value;

	value = STC31xx_ReadByte(STC311x_REG_MODE);
	STC31xx_WriteByte(STC311x_REG_MODE,value & (~STC311x_FORCE_CD));   /*   force CD low */
}
#endif
/* -------------------------------------------------------------------------- */


/* -------------------------------------------------------------- */
static void stc311x_work(struct work_struct *work)
{
	struct stc311x_chip *chip;
	GasGauge_DataTypeDef GasGaugeData;
	int res,Loop;

	/* Initial GasGaugeData structure */
	memset(&GasGaugeData, 0, sizeof(GasGauge_DataTypeDef));

	chip = container_of(work, struct stc311x_chip, work.work);

	sav_client = chip->client;

	if (chip->pdata) {
		GasGaugeData.Vmode = chip->pdata->Vmode;       /* 1=Voltage mode, 0=mixed mode */
		GasGaugeData.Alm_SOC = chip->pdata->Alm_SOC;     /* SOC alm level %*/
		GasGaugeData.Alm_Vbat = chip->pdata->Alm_Vbat;    /* Vbat alm level mV*/
		GasGaugeData.CC_cnf = chip->pdata->CC_cnf;      /* nominal CC_cnf */
		GasGaugeData.VM_cnf = chip->pdata->VM_cnf;      /* nominal VM cnf */
		GasGaugeData.Rint = chip->pdata->Rint;			/* nominal Rint */
		GasGaugeData.Cnom = chip->pdata->Cnom;        /* nominal capacity in mAh */
		GasGaugeData.Rsense = chip->pdata->Rsense;      /* sense resistor mOhms*/
		GasGaugeData.RelaxCurrent = chip->pdata->RelaxCurrent; /* current for relaxation in mA (< C/20) */
		GasGaugeData.Adaptive = chip->pdata->Adaptive;     /* 1=Adaptive mode enabled, 0=Adaptive mode disabled */
		/* capacity derating in 0.1%, for temp = 60, 40, 25, 10,   0, -10 degreeC */
		for(Loop=0;Loop<NTEMP;Loop++)
			GasGaugeData.CapDerating[Loop] = chip->pdata->CapDerating[Loop];
		/* OCV curve adjustment */
		for(Loop=0;Loop<16;Loop++)
			GasGaugeData.OCVValue[Loop] = chip->pdata->OCVValue[Loop];
		GasGaugeData.ExternalTemperature = chip->pdata->ExternalTemperature(); /*External temperature fonction, return degreeC*/
		GasGaugeData.ForceExternalTemperature = chip->pdata->ForceExternalTemperature; /* 1=External temperature, 0=STC3117 temperature */
	}

	res = GasGauge_Task(&GasGaugeData);  /* process gas gauge algorithm, returns results */
	if (res > 0) {
		/* results available */
		chip->batt_soc = (GasGaugeData.SOC+5)/10;
		if ((chip->batt_soc != chip->batt_soc_last) && (chip->batt_soc <= 3)) {
			pr_err("Battery soc is %d, notify power_supply\n", chip->batt_soc);
			power_supply_changed(&chip->battery);
		}

#if 0
		/* This code is try to send power supply change to avoid watch deep sleep	*/
		/* so that the GasGauge_Task() late to keep capacity on 99%.			*/
		if ((chip->batt_soc == 99) && (GasGaugeData.AvgCurrent > CHG_NOT_CHARGE)) {
			pr_err("Battery soc is %d, notify power_supply\n", chip->batt_soc);
			power_supply_changed(&chip->battery);
		}
#endif
#ifdef DEBUG_SOC
		pr_err("last_soc=%d, soc=%d, volt=%d, avg_volt=%d\n", chip->batt_soc_last, chip->batt_soc, GasGaugeData.Voltage, BattData.AvgVoltage);
#endif
		if ((GasGaugeData.AvgCurrent < CHG_NOT_CHARGE) && chip->batt_soc > chip->batt_soc_last && GasGaugeData.Voltage < BATT_CHG_VOLTAGE) {
			chip->batt_soc = chip->batt_soc_last;
		} else {
#if defined(STC3117_AGING_FEATURE)
			pr_err("Before aging calculate, aging_counter=%d\n", aging_counter);
			if ((GasGaugeData.AvgCurrent > CHG_NOT_CHARGE && chip->batt_soc > chip->batt_soc_last)) {
				aging_counter += (chip->batt_soc - chip->batt_soc_last);//counter++
			}
			pr_err("after aging calculate, aging_counter=%d\n", aging_counter);
			battery_capacity_aging_level = 100 - ((aging_counter / 100) * 20 / 500);
			pr_err("battery_capacity_aging_level=%d\n", battery_capacity_aging_level);
#endif /* STC3117_AGING_FEATURE */
			chip->batt_soc_last = chip->batt_soc;
		}

		chip->batt_voltage = GasGaugeData.Voltage;
		chip->batt_current = GasGaugeData.Current;
#if defined(STC3117_AGING_FEATURE)
		chip->batt_charge_cycle = aging_counter / 100;
#endif /* STC3117_AGING_FEATURE */
		chip->batt_temp = GasGaugeData.Temperature;
	} else if(res == -1) {
		chip->batt_voltage = GasGaugeData.Voltage;
		chip->batt_soc = (GasGaugeData.SOC+5)/10;
	}

	stc311x_get_status(sav_client);
	stc311x_get_online(sav_client);

	schedule_delayed_work(&chip->work, STC311x_DELAY);
}


static enum power_supply_property stc311x_battery_props[] = {
	POWER_SUPPLY_PROP_STATUS,
	POWER_SUPPLY_PROP_ONLINE,
#if defined(STC3117_AGING_FEATURE)
	POWER_SUPPLY_PROP_CYCLE_COUNT,
#endif /* STC3117_AGING_FEATURE */
	POWER_SUPPLY_PROP_VOLTAGE_NOW,
	POWER_SUPPLY_PROP_CURRENT_NOW,
	POWER_SUPPLY_PROP_CAPACITY,
	POWER_SUPPLY_PROP_TEMP,
};

int null_fn(void)
{
	return 0;                // for discharging status
}

int Temperature_fn(void)
{
	return (25);
}

static int stc3317_parse_dt(struct stc311x_chip *chip, struct stc311x_platform_data	*pdata)
{
	int rc = -1;
	struct device_node *node = chip->client->dev.of_node;

	pr_err("%s: stc3317_parse_dt()\n", __func__);

	if (!node) {
		pr_err("%s: No DT data Failing Probe\n", __func__);
		return -EINVAL;
	}
#if 0
	rc = of_property_read_u32(node, "stc,battery_online", (int *)pdata->battery_online);
	if (rc < 0) pr_debug("read of stc,battery_online failure, rc = %d\n", rc);
	//pr_err ("%s: battery_online=0x%x\n", (int *)pdata->battery_online, __func__);

	rc = of_property_read_u32(node, "stc,charger_online", (int *)pdata->charger_online);
	if (rc < 0) pr_debug("read of stc,charger_online failure, rc = %d\n", rc);
	//pr_err ("%s: charger_online=0x%x\n", (int *)pdata->charger_online, __func__);

	rc = of_property_read_u32(node, "stc,charger_enable", (int *)pdata->charger_enable);
	if (rc < 0) pr_debug("read of stc,charger_enable failure, rc = %d\n", rc);
	//pr_err ("%s: charger_enable=0x%x\n", (int *)pdata->charger_enable, __func__);

	rc = of_property_read_u32(node, "stc,power_supply_register", (int *)pdata->power_supply_register);
	if (rc < 0) pr_debug("read of stc,power_supply_register failure, rc = %d\n", rc);
	//pr_err ("%s: power_supply_register=%d\n", (int *)pdata->power_supply_register, __func__);

	rc = of_property_read_u32(node, "stc,power_supply_unregister", (int *)pdata->power_supply_unregister);
	if (rc < 0) pr_debug("read of stc,power_supply_unregister failure, rc = %d\n", rc);
	//pr_err ("%s: power_supply_unregister=%d\n", pdata->power_supply_unregister, __func__);
#endif
	pdata->battery_online          = NULL;
	pdata->charger_online          = null_fn;
	pdata->charger_enable          = null_fn;
	pdata->power_supply_register   = NULL;
	pdata->power_supply_unregister = NULL;

	rc = of_property_read_u32(node, "stc,Vmode", &(pdata->Vmode));
	if (rc < 0) pr_debug("read of stc,Vmode failure, rc = %d\n", rc);
	pr_err ("%s: Vmode=%d\n", __func__, pdata->Vmode);

	rc = of_property_read_u32(node, "stc,Alm_SOC", &(pdata->Alm_SOC));
	if (rc < 0) pr_debug("read of stc,Alm_SOC failure, rc = %d\n", rc);
	pr_err ("%s: Alm_SOC=%d\n", __func__, pdata->Alm_SOC);

	rc = of_property_read_u32(node, "stc,Alm_Vbat", &(pdata->Alm_Vbat));
	if (rc < 0) pr_debug("read of stc,Alm_Vbat failure, rc = %d\n", rc);
	pr_err ("%s: Alm_Vbat=%d\n", __func__, pdata->Alm_Vbat);

	rc = of_property_read_u32(node, "stc,CC_cnf", &(pdata->CC_cnf));
	if (rc < 0) pr_debug("read of stc,CC_cnf failure, rc = %d\n", rc);
	pr_err ("%s: CC_cnf=%d\n", __func__, pdata->CC_cnf);

	rc = of_property_read_u32(node, "stc,VM_cnf", &(pdata->VM_cnf));
	if (rc < 0) pr_debug("read of stc,VM_cnf failure, rc = %d\n", rc);
	pr_err ("%s: VM_cnf=%d\n", __func__, pdata->VM_cnf);

	rc = of_property_read_u32(node, "stc,Rint", &(pdata->Rint));
	if (rc < 0) pr_debug("read of stc,Rint failure, rc = %d\n", rc);
	pr_err ("%s: Rint=%d\n", __func__, pdata->Rint);

	rc = of_property_read_u32(node, "stc,Cnom", &(pdata->Cnom));
	if (rc < 0) pr_debug("read of stc,Cnom failure, rc = %d\n", rc);
	pr_err ("%s: Cnom=%d\n", __func__, pdata->Cnom);

	rc = of_property_read_u32(node, "stc,Rsense", &(pdata->Rsense));
	if (rc < 0) pr_debug("read of stc,Rsense failure, rc = %d\n", rc);
	pr_err ("%s: Rsense=%d\n", __func__, pdata->Rsense);

	rc = of_property_read_u32(node, "stc,RelaxCurrent", &(pdata->RelaxCurrent));
	if (rc < 0) pr_debug("read of stc,RelaxCurrent failure, rc = %d\n", rc);
	pr_err ("%s: RelaxCurrent=%d\n", __func__, pdata->RelaxCurrent);

	rc = of_property_read_u32(node, "stc,Adaptive", &(pdata->Adaptive));
	if (rc < 0) pr_debug("read of stc,Adaptive failure, rc = %d\n", rc);
	pr_err ("%s: Adaptive=%d\n", __func__, pdata->Adaptive);

	rc = of_property_read_u32_array(node, "stc,CapDerating", pdata->CapDerating, 7);
	if (rc < 0) pr_debug("read of stc,CapDerating failure, rc = %d\n", rc);
	pr_err ("%s: CapDerating[0]=%d, [6]=%d\n", __func__, pdata->CapDerating[0], pdata->CapDerating[6]);

#if 0
	rc = of_property_read_u32_array(node, "stc,SOCValue", pdata->SOCValue, 16);
	if (rc < 0) pr_debug("read of stc,SOCValue failure, rc = %d\n", rc);
	pr_err ("%s: SOCValue[0]=%d, [15]=%d\n", __func__, pdata->SOCValue[0], pdata->SOCValue[15]);
#endif

	rc = of_property_read_u32_array(node, "stc,OCVValue", pdata->OCVValue, 16);
	if (rc < 0) pr_debug("read of stc,OCVValue failure, rc = %d\n", rc);
	pr_err ("%s: OCVValue[0]=%d, [15]=%d\n", __func__, pdata->OCVValue[0], pdata->OCVValue[15]);

	//rc = of_property_read_u32(node, "stc,ExternalTemperature", (int *)pdata->ExternalTemperature);
	//if (rc < 0) pr_debug("read of stc,ExternalTemperature failure, rc = %d\n", rc);
	//pr_err ("%s: ExternalTemperature=%d\n", __func__, pdata->ExternalTemperature);
	pdata->ExternalTemperature = Temperature_fn;

	rc = of_property_read_u32(node, "stc,ForceExternalTemperature", &(pdata->ForceExternalTemperature));
	if (rc < 0) pr_debug("read of stc,ForceExternalTemperature failure, rc = %d\n", rc);
	pr_err ("%s: ForceExternalTemperature=%d\n", __func__, pdata->ForceExternalTemperature);

	pr_err("%s: end of dt parsing\n", __func__);
	return 0;
}

static int stc311x_probe(struct i2c_client *client,
				const struct i2c_device_id *id)
{
	struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
	struct stc311x_chip *chip;
	int ret,res,Loop;

	GasGauge_DataTypeDef GasGaugeData;

	/* Initial GasGaugeData structure */
	memset(&GasGaugeData, 0, sizeof(GasGauge_DataTypeDef));

	/*First check the functionality supported by the host*/
	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_READ_I2C_BLOCK))
		return -EIO;
	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WRITE_I2C_BLOCK))
		return -EIO;

	/*OK. For now, we presume we have a valid client. We now create the
	client structure*/
	chip = kzalloc(sizeof(struct stc311x_chip), GFP_KERNEL);
	if (!chip) {
		printk("Out of memory to create client structure for stc311x\n");
		return -ENOMEM;  /*Out of memory*/
	}

	printk("\n\nstc311x probe started\n\n");

	/* The common I2C client data is placed right specific data. */
	chip->client = client;
#if 0  // Avery: populate devices parameters via device tree
	chip->pdata = client->dev.platform_data;
#endif
	chip->pdata = kzalloc(sizeof(struct stc311x_platform_data), GFP_KERNEL);
	ret = stc3317_parse_dt(chip, chip->pdata);
	if (ret < 0) {
		pr_err("%s: Couldn't to parse STC3317 DT, ret = %d\n", __func__, ret);
		return ret;
	}

	i2c_set_clientdata(client, chip);

	chip->battery.name		= "bms";
	chip->battery.type		= POWER_SUPPLY_TYPE_BMS;
	chip->battery.get_property	= stc311x_get_property;
	chip->battery.properties	= stc311x_battery_props;
	chip->battery.num_properties	= ARRAY_SIZE(stc311x_battery_props);

	if (chip->pdata && chip->pdata->power_supply_register)
		ret = chip->pdata->power_supply_register(&client->dev, &chip->battery);
	else
		ret = power_supply_register(&client->dev, &chip->battery);

	if (ret) {
		//dev_err(&client->dev, "failed: power supply register\n");

		kfree(chip);
		return ret;
	}

	dev_info(&client->dev, "power supply register,%d\n",ret);

	stc311x_get_version(client);

	/* init gas gauge system */
	sav_client = chip->client;

	if (chip->pdata) {
		GasGaugeData.Vmode = chip->pdata->Vmode;       /* 1=Voltage mode, 0=mixed mode */
		GasGaugeData.Alm_SOC = chip->pdata->Alm_SOC;     /* SOC alm level %*/
		GasGaugeData.Alm_Vbat = chip->pdata->Alm_Vbat;    /* Vbat alm level mV*/
		GasGaugeData.CC_cnf = chip->pdata->CC_cnf;      /* nominal CC_cnf */
		GasGaugeData.VM_cnf = chip->pdata->VM_cnf;      /* nominal VM cnf */
		GasGaugeData.Rint = chip->pdata->Rint;			/* nominal Rint */
		GasGaugeData.Cnom = chip->pdata->Cnom;        /* nominal capacity in mAh */
		GasGaugeData.Rsense = chip->pdata->Rsense;      /* sense resistor mOhms*/
		GasGaugeData.RelaxCurrent = chip->pdata->RelaxCurrent; /* current for relaxation in mA (< C/20) */
		GasGaugeData.Adaptive = chip->pdata->Adaptive;     /* 1=Adaptive mode enabled, 0=Adaptive mode disabled */
		/* capacity derating in 0.1%, for temp = 60, 40, 25, 10,   0, -10 degreeC */
		for(Loop=0;Loop<NTEMP;Loop++)
			GasGaugeData.CapDerating[Loop] = chip->pdata->CapDerating[Loop];
		/* OCV curve adjustment */
		for(Loop=0;Loop<16;Loop++)
			GasGaugeData.OCVValue[Loop] = chip->pdata->OCVValue[Loop];
		GasGaugeData.ExternalTemperature = chip->pdata->ExternalTemperature(); /*External temperature fonction, return degreeC*/
		GasGaugeData.ForceExternalTemperature = chip->pdata->ForceExternalTemperature; /* 1=External temperature, 0=STC3117 temperature */
	}

	GasGauge_Start(&GasGaugeData);
	msleep(200);
	res = GasGauge_Task(&GasGaugeData);  /* process gas gauge algorithm, returns results */
	if (res > 0) {
		/* results available */
		chip->batt_soc = (GasGaugeData.SOC+5)/10;
		chip->batt_voltage = GasGaugeData.Voltage;
		chip->batt_current = GasGaugeData.Current;
	} else if(res == 0) {
		/* SOC and Voltage  available */
		chip->batt_soc = (GasGaugeData.SOC+5)/10;
		chip->batt_voltage = GasGaugeData.Voltage;
		chip->batt_current = 0;
	} else if(res == -1) {
		chip->batt_voltage = GasGaugeData.Voltage;
		chip->batt_soc = (GasGaugeData.SOC+5)/10;
	}

	chip->batt_soc_last = chip->batt_soc;

	INIT_DEFERRABLE_WORK(&chip->work, stc311x_work);

	create_debugfs_entries(chip);
	schedule_delayed_work(&chip->work, STC311x_DELAY);
	//The specified delay depends of every platform and Linux kernel. It has to be checked physically during the driver integration
	//a delay of about 5 seconds is correct but 30 seconds is enough compare to the battery SOC evolution speed

	pr_info("stc3117-204 FG successfully probed\n");
	return 0;
}

static int stc311x_remove(struct i2c_client *client)
{
	struct stc311x_chip *chip = i2c_get_clientdata(client);

	/* stop gas gauge system */
	sav_client = chip->client;
	GasGauge_Stop();

	if (chip->pdata && chip->pdata->power_supply_unregister)
		chip->pdata->power_supply_unregister(&chip->battery);
	else
		power_supply_unregister(&chip->battery);
	cancel_delayed_work(&chip->work);
	kfree(chip);

	return 0;
}

#ifdef CONFIG_PM

static int stc311x_suspend(struct i2c_client *client,
		pm_message_t state)
{
	struct stc311x_chip *chip = i2c_get_clientdata(client);

	cancel_delayed_work(&chip->work);
	return 0;
}

static int stc311x_resume(struct i2c_client *client)
{
	struct stc311x_chip *chip = i2c_get_clientdata(client);

	schedule_delayed_work(&chip->work, 0);
	return 0;
}

#else

#define stc311x_suspend NULL
#define stc311x_resume NULL

#endif /* CONFIG_PM */

static const struct of_device_id stc3317_match[] = {
	{ .compatible = "STC,stc3117-fg",  },
	{ },
};

/* Every chip have a unique id */
static const struct i2c_device_id stc311x_id[] = {
	{ "stc3117-204", 0 },
	{ }
};

/* Every chip have a unique id and we need to register this ID using MODULE_DEVICE_TABLE*/
MODULE_DEVICE_TABLE(i2c, stc311x_id);

static struct i2c_driver stc311x_i2c_driver = {
	.driver	= {
		.name	= "stc3117-204",
		.owner	= THIS_MODULE,
		.of_match_table = of_match_ptr(stc3317_match),
	},
	.probe		= stc311x_probe,
	.remove		= stc311x_remove,
	.suspend	= stc311x_suspend,
	.resume		= stc311x_resume,
	.id_table	= stc311x_id,
};

/*To register this I2C chip driver, the function i2c_add_driver should be called
with a pointer to the struct i2c_driver*/
static int __init stc311x_init(void)
{
	return i2c_add_driver(&stc311x_i2c_driver);
}
module_init(stc311x_init);

/*To unregister the I2C chip driver, the i2c_del_driver function should be called
with the same pointer to the struct i2c_driver*/
static void __exit stc311x_exit(void)
{
	i2c_del_driver(&stc311x_i2c_driver);
}
module_exit(stc311x_exit);

MODULE_AUTHOR("STMICROELECTRONICS");
MODULE_DESCRIPTION("STC311x Fuel Gauge");
MODULE_LICENSE("GPL");