/**
* @brief CreateBackupBuffer
*
* Create buffer for backup file operation
*
* @para data address of BackupDataType
* @return NULL
*/
void CreateBackupBuffer(BackupDataType *data)
{
/// [AT-PM] : Count total size to be written to file ; 07/12/2013
data->backupBufferSize = data->capData->tableSize;
data->backupBufferSize = data->backupBufferSize + sizeof(data->sysData->rmFromIC);
data->backupBufferSize = data->backupBufferSize + sizeof(data->sysData->fccFromIC);
data->backupBufferSize = data->backupBufferSize + sizeof(data->sysData->timeTagFromIC);
data->backupBufferSize = data->backupBufferSize + sizeof(data->sysData->tableUpdateIdxFromIC);
data->backupBufferSize = data->backupBufferSize + sizeof(data->sysData->deltaCapFromIC);
data->backupBufferSize = data->backupBufferSize + sizeof(data->sysData->adc1ConvTime);
data->backupBufferSize = data->backupBufferSize + sizeof(data->sysData->rsocFromIC);
data->backupBufferSize = data->backupBufferSize + sizeof(data->sysData->cycleCount);
data->backupBufferSize = data->backupBufferSize + sizeof(data->sysData->ccOffset);
data->backupBufferSize = data->backupBufferSize + sizeof(data->sysData->predictRsoc);
data->backupBufferSize = data->backupBufferSize + sizeof(data->sysData->standbyDsgRatio);
data->backupBufferSize = data->backupBufferSize + sizeof(data->backupVolt1);
data->backupBufferSize = data->backupBufferSize + sizeof(data->backupVolt2);
data->backupBufferSize = data->backupBufferSize + sizeof(data->capData->preDsgCharge);
data->backupBufferSize = data->backupBufferSize + CELL_PARAMETER_STRING_LENGTH;
data->backupBufferSize = data->backupBufferSize + CELL_PARAMETER_STRING_LENGTH;
data->backupBufferSize = data->backupBufferSize + sizeof(_backup_u32_); ///< [AT-PM] : Used for driver version ; 11/07/2013
UG31_LOGN("[%s]: Total %d bytes need to be created for written to file.\n", __func__, data->backupBufferSize);
/// [AT-PM] : Set memory buffer ; 07/12/2013
if(data->backupBufferSize > MAX_BACKUP_BUFFER_SIZE)
{
UG31_LOGE("[%s]: Exceed maximum backup buffer size\n", __func__);
data->backupBufferSize = MAX_BACKUP_BUFFER_SIZE;
}
upi_memset(data->backupBuffer, 0, (_upi_u32_)data->backupBufferSize);
}
/**
* ug31xx_save_config_data - save config data
* @name : Power Supply name
* @data : config data input pointer
* @len : length of config data
*
*/
int ug31xx_save_config_data(const char *name, u8 *data, int len)
{
int mip_offset, ret;
int i;
pr_info("%s:\n", __func__);
/* write the fuel gauge config data to umip */
mip_offset = BATT_UG31_FG_TBL_BODY + BATT_UG31_RESERVED;
//mip_offset = UMIP_REF_FG_TBL + BATT_FG_TBL_BODY;
ret = intel_scu_ipc_write_umip(data, len, mip_offset);
if (ret) {
UG31_LOGE("%s: * umip write failed *\n", name);
}
#ifdef BATT_DATA_DEBUG
else
{
for (i=0; i<len; i++)
printk("0x%02X ", *(data + i));
printk("\n");
}
#endif
return ret;
}
/**
* @brief UpiRestoreData
*
* Restore data from system to IC routine
*
* @para data address of BackupDataType
* @return BACKUP_BOOL_TRUE if success
*/
_backup_bool_ UpiRestoreData(BackupDataType *data)
{
_backup_bool_ rtn;
_backup_u32_ driverVer;
SystemDataType *orgSysData;
_backup_s32_ tmp32;
/// [AT-PM] : Create buffer ; 02/21/2013
#ifndef UG31XX_SHELL_ALGORITHM
orgSysData = &CheckBackupFile_orgSysData;
#else ///< else of UG31XX_SHELL_ALGORITHM
orgSysData = (SystemDataType *)upi_malloc(sizeof(SystemDataType));
#endif ///< end of UG31XX_SHELL_ALGORITHM
upi_memcpy(orgSysData, ptrSysData, sizeof(SystemDataType));
/// [AT-PM] : Get data from file ; 02/21/2013
#if defined (uG31xx_OS_WINDOWS)
rtn = read_backup_file(data->backupFileName, data->backupBuffer, data->backupBufferSize);
#else ///< else of defined (uG31xx_OS_WINDOWS)
rtn = read_backup_file(ptrBackupFileName, data->backupBuffer, data->backupBufferSize);
#endif ///< end of defined (uG31xx_OS_WINDOWS)
if(rtn == _UPI_FALSE_)
{
UG31_LOGE("[%s]: Read data from backup file fail.\n", __func__);
#ifdef UG31XX_SHELL_ALGORITHM
upi_free(orgSysData);
#endif ///< end of UG31XX_SHELL_ALGORITHM
return (BACKUP_BOOL_FALSE);
}
driverVer = ConvertData(data);
UG31_LOGI("[%s]: Driver version = %d\n", __func__, (int)driverVer);
/// [AT-PM] : Keep following information ; 01/22/2014
ptrSysData->timeTagFromIC = orgSysData->timeTagFromIC;
ptrSysData->tableUpdateIdxFromIC = orgSysData->tableUpdateIdxFromIC;
/// [AT-PM] : Check abnormal condition ; 01/22/2014
if((data->backupVolt1 != 0) && (data->backupVolt2 != 0))
{
tmp32 = (_backup_s32_)data->backupVolt1;
tmp32 = tmp32 - data->backupVolt2;
if((tmp32 < RESTORE_ABNORMAL_VOLT_RANGE_UPBND) && (tmp32 > RESTORE_ABNORMAL_VOLT_RANGE_LWBND))
{
ptrSysData->rmFromIC = orgSysData->rmFromIC;
ptrSysData->fccFromIC = orgSysData->fccFromIC;
ptrSysData->rsocFromIC = orgSysData->rsocFromIC;
}
}
#ifdef UG31XX_SHELL_ALGORITHM
upi_free(orgSysData);
#endif ///< end of UG31XX_SHELL_ALGORITHM
return (BACKUP_BOOL_TRUE);
}
int ug31xx_read_backup_tag(const char *name, u8 *data)
{
int mip_offset, ret;
pr_debug("%s:\n", __func__);
mip_offset = BATT_UG31_FG_TBL_BODY;
ret = intel_scu_ipc_read_mip(data, 1, mip_offset, 0);
if (ret)
UG31_LOGE("%s: * umip read failed *\n", name);
return ret;
}
int ug31xx_write_backup_tag(const char *name, u8 *data)
{
int mip_offset, ret;
pr_warn("%s:\n", __func__);
mip_offset = BATT_UG31_FG_TBL_BODY;
ret = intel_scu_ipc_write_umip(data, 1, mip_offset);
if (ret)
UG31_LOGE("%s: * umip write failed *\n", name);
return ret;
}
_upi_bool_ ReadGGBXFileToCellDataAndInitSetting(SystemDataType *obj)
{
_sys_u8_ *p_start = _UPI_NULL_;
_sys_u8_ *p_end = _UPI_NULL_;
_sys_u16_ sum16=0;
_sys_s32_ i=0;
/*
* check GGBX_FILE tag
*/
if(obj->ggbXBuf->ggb_tag != GGBX_FILE_TAG)
{
UG31_LOGE("[%s] GGBX file tag not correct. tag: %08X\n", __func__, obj->ggbXBuf->ggb_tag);
return (_UPI_FALSE_);
}
/*
* check GGBX_FILE checksum
*/
p_start = (_sys_u8_ *)obj->ggbXBuf + sizeof(GGBX_FILE_HEADER);
p_end = p_start + obj->ggbXBuf->length - 1;
for (; p_start <= p_end; p_start++)
{
sum16 += *p_start;
}
/* check done. prepare copy data */
memset(obj->ggbCellTable, 0x00, sizeof(CELL_TABLE));
memset(obj->ggbParameter, 0x00, sizeof(CELL_PARAMETER));
p_start = (_sys_u8_ *)obj->ggbXBuf + sizeof(GGBX_FILE_HEADER);
for (i=0; i<obj->ggbXBuf->num_ggb; i++)
{
/* TODO: boundary checking */
/* TODO: select right ggb content by sku */
memcpy(obj->ggbParameter, p_start, sizeof(CELL_PARAMETER));
memcpy(obj->ggbCellTable, p_start + sizeof(CELL_PARAMETER), sizeof(CELL_TABLE));
p_start += (sizeof(CELL_PARAMETER) + sizeof(CELL_TABLE));
}
return (_UPI_TRUE_);
}
void read_file(struct file *fp, _upi_u8_ *data, _upi_u8_ size)
{
mm_segment_t oldFS;
loff_t pos;
_upi_s32_ rtn;
_upi_u8_ idx;
oldFS = get_fs();
set_fs(get_ds());
pos = 0;
idx = 0;
rtn = 1;
UG31_LOGN("[%s]: Read file ->", __func__);
while(idx < size)
{
rtn = (_upi_s32_)vfs_read(fp, (char *)(&data[idx]), 1, &pos);
ug31_printk(LOG_LEVEL_NOTICE, " %02x", data[idx]);
idx = idx + 1;
if(rtn != 1)
{
break;
}
}
ug31_printk(LOG_LEVEL_NOTICE, "\n");
if(rtn != 1)
{
UG31_LOGE("[%s]: Read file fail.\n", __func__);
}
else
{
UG31_LOGN("[%s]: Read %d (%d) bytes from file\n", __func__, idx, size);
}
set_fs(oldFS);
}
extern _upi_bool_ write_backup_file(char *filename, _upi_u8_ *data, _upi_u32_ size)
#endif ///< end of uG31xx_OS_WINDOWS
{
#ifndef uG31xx_BOOT_LOADER
#ifndef CONFIG_ASUS_ENGINEER_MODE
#ifdef UG31XX_USE_SHELL_AP_FOR_FILE_OP
struct subprocess_info *sub_info;
char *argv[] = {shell_ap_name, "BACKUP_FILE", "WRITE", filename, NULL};
char *env[] = {NULL};
int rtn;
sub_info = NULL;
sub_info = call_usermodehelper_setup(argv[0], argv, env, GFP_ATOMIC);
if(sub_info == NULL)
{
return (_UPI_FALSE_);
}
UG31_LOGN("[%s]: call_usermodehelper_setup() done (%d - %d - %d)\n", __func__, (int)sub_info, (int)data, (int)size);
rtn = call_usermodehelper_exec(sub_info, UMH_WAIT_PROC);
UG31_LOGN("[%s]: call_usermodehelper_exec() = %d\n", __func__, rtn);
return ((rtn == 0) ? _UPI_TRUE_ : _UPI_FALSE_);
#else ///< else of UG31XX_USE_SHELL_AP_FOR_FILE_OP
#ifdef UG31XX_USE_DAEMON_AP_FOR_FILE_OP
if(get_file_op_status() & UG31XX_KERNEL_FILE_FINISH)
{
clear_file_op_status_bit(UG31XX_KERNEL_FILE_EXIST);
clear_file_op_status_bit(UG31XX_KERNEL_FILE_READ);
set_file_op_status_bit(UG31XX_KERNEL_FILE_WRITE);
return (_UPI_FALSE_);
}
if(get_file_op_status() & UG31XX_USER_FILE_WRITE)
{
clear_file_op_status_bit(UG31XX_KERNEL_FILE_EXIST);
clear_file_op_status_bit(UG31XX_KERNEL_FILE_WRITE);
set_file_op_status_bit(UG31XX_KERNEL_FILE_READ);
set_file_op_status_bit(UG31XX_KERNEL_FILE_FINISH);
return (_UPI_TRUE_);
}
clear_file_op_status_bit(UG31XX_KERNEL_FILE_EXIST);
clear_file_op_status_bit(UG31XX_KERNEL_FILE_READ);
set_file_op_status_bit(UG31XX_KERNEL_FILE_WRITE);
set_file_op_status_bit(UG31XX_KERNEL_FILE_FINISH);
return (_UPI_FALSE_);
#else ///< else of UG31XX_USE_DAEMON_AP_FOR_FILE_OP
struct file *fp;
_upi_u8_ retry;
retry = 3;
while(retry)
{
fp = filp_open(filename, O_CREAT | O_RDWR, 0644);
if(!is_err(fp))
{
break;
}
retry = retry - 1;
}
if(retry == 0)
{
return (_UPI_FALSE_);
}
/// [AT-PM] : Write data to file ; 02/21/2013
write_file(fp, data, size);
filp_close(fp, _UPI_NULL_);
#endif ///< end of UG31XX_USE_DAEMON_AP_FOR_FILE_OP
#endif ///< end of UG31XX_USE_SHELL_AP_FOR_FILE_OP
#else
int backup_tag = BACKUP_BATTERY_KEY;
if (ug31xx_save_config_data("ug31xx", data, size)) {
UG31_LOGE("[%s]: fail to write Intel UMIP data\n", __func__);
return (_UPI_FALSE_);
}
return (_UPI_TRUE_);
#endif
#endif ///< end of uG31xx_BOOT_LOADER
return (_UPI_TRUE_);
}
/**
* @brief UpiPrintBackupVersion
*
* Print backup module version
*
* @return NULL
*/
void UpiPrintBackupVersion(void)
{
UG31_LOGE("[%s]: %s\n", __func__,
BACKUP_VERSION);
}
/**
* @brief UpiBackupData
*
* Backup data from IC to system routine
*
* @para data address of BackupDataType
* @return _UPI_NULL_
*/
void UpiBackupData(BackupDataType *data)
{
_backup_bool_ rtnBool;
_backup_u8_ rtnU8;
#ifndef UG31XX_BACKUP_FILE_ENABLE
rtnBool = _UPI_TRUE_;
data->backupFileSts = BACKUP_FILE_STS_COMPARE;
#endif ///< end of UG31XX_BACKUP_FILE_ENABLE
switch(data->backupFileSts)
{
case BACKUP_FILE_STS_CHECKING:
/// [AT-PM] : Check backup file existed or not ; 02/21/2013
rtnBool = is_file_exist(data->backupFileName);
UG31_LOGN("[%s]: is_file_exist() = %d.\n", __func__, rtnBool);
if(rtnBool == BACKUP_BOOL_TRUE)
{
data->backupFileSts = BACKUP_FILE_STS_EXIST;
data->backupFileRetryCnt = 0;
}
else
{
data->backupFileRetryCnt = data->backupFileRetryCnt + 1;
UG31_LOGN("[%s]: Check backup file retry count = %d\n", __func__, data->backupFileRetryCnt);
if(data->backupFileRetryCnt > RETRY_CHECKING_THRESHOLD)
{
data->backupFileSts = BACKUP_FILE_STS_NOT_EXIST;
UG31_LOGE("[%s]: Backup file is not exist.\n", __func__);
}
}
break;
case BACKUP_FILE_STS_NOT_EXIST:
/// [AT-PM] : Create backup file ; 02/21/2013
PrepareData(data);
rtnBool = create_backup_file(data->backupFileName, data->backupBuffer, data->backupBufferSize);
UG31_LOGN("[%s]: create_backup_file() = %d.\n", __func__, rtnBool);
if(rtnBool == BACKUP_BOOL_TRUE)
{
data->backupFileSts = BACKUP_FILE_STS_EXIST;
data->icDataAvailable = BACKUP_BOOL_TRUE;
}
else
{
UG31_LOGE("[%s]: Create backup file fail.\n", __func__);
}
break;
case BACKUP_FILE_STS_EXIST:
data->backupFileSts = BACKUP_FILE_STS_COMPARE;
case BACKUP_FILE_STS_COMPARE:
if(data->icDataAvailable == BACKUP_BOOL_TRUE)
{
/// [AT-PM] : Check content of file is consist with IC or not ; 02/21/2013
rtnU8 = CheckBackupFile(data);
UG31_LOGN("[%s]: CheckBackupFile() = %d.\n", __func__, rtnU8);
if(rtnU8 == CHECK_BACKUP_FILE_STS_VERSION_MISMATCH)
{
data->backupFileSts = BACKUP_FILE_STS_UPDATE_BY_VERSION;
}
else if(rtnU8 == CHECK_BACKUP_FILE_STS_NEED_UPDATE)
{
data->backupFileSts = BACKUP_FILE_STS_UPDATE;
}
else if(rtnU8 == CHECK_BACKUP_FILE_STS_PASS)
{
data->backupFileSts = BACKUP_FILE_STS_COMPARE;
}
else
{
data->backupFileSts = BACKUP_FILE_STS_UPDATE;
}
}
else
{
data->backupFileSts = BACKUP_FILE_STS_CHECKING;
}
break;
case BACKUP_FILE_STS_UPDATE:
case BACKUP_FILE_STS_UPDATE_BY_VERSION:
if(data->icDataAvailable == BACKUP_BOOL_TRUE)
{
rtnU8 = UpdateBackupFile(data);
UG31_LOGN("[%s]: UpdateBackupFile() = %d.\n", __func__, rtnU8);
if(rtnU8 == CHECK_BACKUP_FILE_STS_PASS)
{
if(data->backupFileSts == BACKUP_FILE_STS_UPDATE_BY_VERSION)
{
data->backupFileSts = BACKUP_FILE_STS_VERSION_MISMATCH;
}
else
{
data->backupFileSts = BACKUP_FILE_STS_COMPARE;
}
}
}
else
{
data->backupFileSts = BACKUP_FILE_STS_CHECKING;
}
break;
default:
/// [AT-PM] : Un-known state ; 02/21/2013
data->backupFileSts = BACKUP_FILE_STS_NOT_EXIST;
break;
}
}
