/** * @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; } }