diff options
Diffstat (limited to 'drivers/power/wmt_battery/gauge/ug31xx/uG31xx_API_Backup.c')
| -rwxr-xr-x | drivers/power/wmt_battery/gauge/ug31xx/uG31xx_API_Backup.c | 601 |
1 files changed, 601 insertions, 0 deletions
diff --git a/drivers/power/wmt_battery/gauge/ug31xx/uG31xx_API_Backup.c b/drivers/power/wmt_battery/gauge/ug31xx/uG31xx_API_Backup.c new file mode 100755 index 00000000..90a82633 --- /dev/null +++ b/drivers/power/wmt_battery/gauge/ug31xx/uG31xx_API_Backup.c @@ -0,0 +1,601 @@ +/**
+ * @filename uG31xx_API_Backup.cpp
+ *
+ * Backup data on uG31xx to a file in system
+ *
+ * @author AllenTeng <allen_teng@upi-semi.com>
+ */
+
+#include "stdafx.h" //windows need this??
+#include "uG31xx_API.h"
+
+#define UG31XX_BACKUP_FILE_ENABLE
+
+#ifdef uG31xx_OS_WINDOWS
+
+typedef char mm_segment_t;
+typedef char loff_t;
+
+typedef struct file
+{
+ FILE *fp;
+} fileType;
+
+#define O_RDONLY (1<<0)
+#define O_WRONLY (1<<1)
+#define O_RDWR (3<<0)
+#define O_CREAT (1<<2)
+#define O_APPEND (1<<3)
+
+static struct file BackupFile;
+
+/**
+ * @brief filp_open
+ *
+ * Open file
+ *
+ * @para path address of file
+ * @para cntl FILE_CNTL parameter
+ * @para misc dummy parameter
+ * @return address of BackupFile
+ */
+struct file * filp_open(const wchar_t *path, int cntl, int misc)
+{
+ if(BackupFile.fp != _UPI_NULL_)
+ {
+ fclose(BackupFile.fp);
+ }
+ BackupFile.fp = _UPI_NULL_;
+
+ switch(cntl & O_RDWR)
+ {
+ case O_RDONLY:
+ _wfopen_s(&BackupFile.fp, path, _T("rb, ccs=UTF-8"));
+ break;
+ case O_WRONLY:
+ _wfopen_s(&BackupFile.fp, path, _T("wb, ccs=UTF-8"));
+ break;
+ case O_RDWR:
+ _wfopen_s(&BackupFile.fp, path, _T("r+b, ccs=UTF-8"));
+ break;
+ default:
+ _wfopen_s(&BackupFile.fp, path, _T("rb, ccs=UTF-8"));
+ break;
+ }
+ return (&BackupFile);
+}
+
+/**
+ * @brief filp_close
+ *
+ * Close file
+ *
+ * @para fp address of struct file
+ * @para misc dummy value
+ * @return _UPI_NULL_
+ */
+void filp_close(struct file *fp, int misc)
+{
+ if(fp->fp != _UPI_NULL_)
+ {
+ fclose(fp->fp);
+ }
+}
+
+/**
+ * @brief vfs_write
+ *
+ * Write data to binary file
+ *
+ * @para fp address of struct file
+ * @para data address of data to be written
+ * @para size size to be written
+ * @para pos start position in the file
+ * @return size be written
+ */
+size_t vfs_write(struct file *fp, char *data, int size, loff_t *pos)
+{
+ return (fwrite(data, sizeof(char), size, fp->fp));
+}
+
+/**
+ * @brief vfs_read
+ *
+ * Read data from binary file
+ *
+ * @para fp address of struct file
+ * @para data address of data to be read
+ * @para size size to be read
+ * @para pos start position in the file
+ * @return size be read
+ */
+size_t vfs_read(struct file *fp, char *data, int size, loff_t *pos)
+{
+ return (fread(data, sizeof(char), size, fp->fp));
+}
+
+/**
+ * @brief IS_ERR
+ *
+ * Check file is opened or not
+ *
+ * @para fp address of struct file
+ * @return _UPI_TRUE_ if file is opened
+ */
+_upi_bool_ IS_ERR(struct file *fp)
+{
+ return ((fp->fp == _UPI_NULL_) ? _UPI_TRUE_ : _UPI_FALSE_);
+}
+
+/**
+ * @brief get_fs
+ *
+ * Dummy function
+ *
+ * @return 0
+ */
+mm_segment_t get_fs(void)
+{
+ return (0);
+}
+
+/**
+ * @brief set_fs
+ *
+ * Dummy function
+ *
+ * @para value mm_segment_t value
+ * @return _UPI_NULL_
+ */
+void set_fs(mm_segment_t value)
+{
+}
+
+/**
+ * @brief get_ds
+ *
+ * Dummy function
+ *
+ * @return 0
+ */
+mm_segment_t get_ds(void)
+{
+ return (0);
+}
+
+#endif ///< end of uG31xx_OS_WINDOWS
+
+/**
+ * @brief ISFileExist
+ *
+ * Check file existed or not
+ *
+ * @para data address of BackupDataType
+ * @return BACKUP_BOOL_TRUE if file existed
+ */
+_backup_bool_ ISFileExist(BackupDataType *data)
+{
+ struct file *fp;
+
+ fp = filp_open(data->backupFileName, O_RDONLY, 0);
+ if(IS_ERR(fp))
+ {
+ UG31_LOGI("[%s]: Backup file is not existed\n", __func__);
+ return (BACKUP_BOOL_FALSE);
+ }
+ UG31_LOGI("[%s]: Backup file is existed\n", __func__);
+ filp_close(fp, _UPI_NULL_);
+ return (BACKUP_BOOL_TRUE);
+}
+
+/**
+ * @brief WriteFile
+ *
+ * Write data to file
+ *
+ * @para data address of BackupDataType
+ * @para fp address of struct fp
+ */
+void WriteFile(BackupDataType *data, struct file *fp)
+{
+ mm_segment_t oldFS;
+ loff_t pos;
+ size_t size;
+
+ oldFS = get_fs();
+ set_fs(get_ds());
+
+ pos = 0;
+ size = vfs_write(fp, (char *)data->capData->encriptTable, sizeof(data->capData->encriptTable), &pos);
+ UG31_LOGI("[%s]: Write table %d bytes\n", __func__, size);
+ size = vfs_write(fp, (char *)(&data->sysData->rmFromIC), sizeof(data->sysData->rmFromIC), &pos);
+ UG31_LOGI("[%s]: Write RM (%d) %d bytes\n", __func__, data->sysData->rmFromIC, size);
+ size = vfs_write(fp, (char *)(&data->sysData->fccFromIC), sizeof(data->sysData->fccFromIC), &pos);
+ UG31_LOGI("[%s]: Write FCC (%d) %d bytes\n", __func__, data->sysData->fccFromIC, size);
+ size = vfs_write(fp, (char *)(&data->sysData->timeTagFromIC), sizeof(data->sysData->timeTagFromIC), &pos);
+ UG31_LOGI("[%s]: Write Time Tag (%d) %d bytes\n", __func__, data->sysData->timeTagFromIC, size);
+ size = vfs_write(fp, (char *)(&data->sysData->tableUpdateIdxFromIC), sizeof(data->sysData->tableUpdateIdxFromIC), &pos);
+ UG31_LOGI("[%s]: Write Table Update Index (%d) %d bytes\n", __func__, data->sysData->tableUpdateIdxFromIC, size);
+ size = vfs_write(fp, (char *)(&data->sysData->deltaCapFromIC), sizeof(data->sysData->deltaCapFromIC), &pos);
+ UG31_LOGI("[%s]: Write Delta Capacity (%d) %d bytes\n", __func__, data->sysData->deltaCapFromIC, size);
+ size = vfs_write(fp, (char *)(&data->sysData->adc1ConvTime), sizeof(data->sysData->adc1ConvTime), &pos);
+ UG31_LOGI("[%s]: Write ADC1 Conversion Time (%d) %d bytes\n", __func__, data->sysData->adc1ConvTime, size);
+ size = vfs_write(fp, (char *)(&data->sysData->rsocFromIC), sizeof(data->sysData->rsocFromIC), &pos);
+ UG31_LOGI("[%s]: Write RSOC (%d) %d bytes\n", __func__, data->sysData->rsocFromIC, size);
+ size = vfs_write(fp, (char *)(&data->targetFileVer), sizeof(_backup_u32_), &pos);
+ UG31_LOGI("[%s]: Write version (%d) %d bytes\n", __func__, data->targetFileVer, size);
+
+ set_fs(oldFS);
+}
+
+/**
+ * @brief CreateBackupFile
+ *
+ * Create backup file in system
+ *
+ * @para data address of BackupDataType
+ * @return BACKUP_BOOL_TRUE if success
+ */
+_backup_bool_ CreateBackupFile(BackupDataType *data)
+{
+ struct file *fp;
+
+ fp = filp_open(data->backupFileName, O_CREAT | O_RDWR, 0);
+ if(IS_ERR(fp))
+ {
+ UG31_LOGI("[%s]: Create backup file fail\n", __func__);
+ return (BACKUP_BOOL_FALSE);
+ }
+
+ /// [AT-PM] : Write data to file ; 02/21/2013
+ WriteFile(data, fp);
+
+ filp_close(fp, _UPI_NULL_);
+ return (BACKUP_BOOL_TRUE);
+}
+
+/**
+ * @brief ReadFile
+ *
+ * Read data from file
+ *
+ * @para data address of BackupDataType
+ * @para fp address of struct fp
+ */
+void ReadFile(BackupDataType *data, struct file *fp)
+{
+ mm_segment_t oldFS;
+ loff_t pos;
+ size_t size;
+
+ oldFS = get_fs();
+ set_fs(get_ds());
+
+ pos = 0;
+ size = vfs_read(fp, (char *)&data->capData->encriptTable, sizeof(data->capData->encriptTable), &pos);
+ UG31_LOGI("[%s]: Read table %d bytes\n", __func__, size);
+ size = vfs_read(fp, (char *)(&data->sysData->rmFromIC), sizeof(data->sysData->rmFromIC), &pos);
+ UG31_LOGI("[%s]: Read RM (%d) %d bytes\n", __func__, data->sysData->rmFromIC, size);
+ size = vfs_read(fp, (char *)(&data->sysData->fccFromIC), sizeof(data->sysData->fccFromIC), &pos);
+ UG31_LOGI("[%s]: Read FCC (%d) %d bytes\n", __func__, data->sysData->fccFromIC, size);
+ size = vfs_read(fp, (char *)(&data->sysData->timeTagFromIC), sizeof(data->sysData->timeTagFromIC), &pos);
+ UG31_LOGI("[%s]: Read Time Tag (%d) %d bytes\n", __func__, data->sysData->timeTagFromIC, size);
+ size = vfs_read(fp, (char *)(&data->sysData->tableUpdateIdxFromIC), sizeof(data->sysData->tableUpdateIdxFromIC), &pos);
+ UG31_LOGI("[%s]: Read Table Update Index (%d) %d bytes\n", __func__, data->sysData->tableUpdateIdxFromIC, size);
+ size = vfs_read(fp, (char *)(&data->sysData->deltaCapFromIC), sizeof(data->sysData->deltaCapFromIC), &pos);
+ UG31_LOGI("[%s]: Read Delta Capacity (%d) %d bytes\n", __func__, data->sysData->deltaCapFromIC, size);
+ size = vfs_read(fp, (char *)(&data->sysData->adc1ConvTime), sizeof(data->sysData->adc1ConvTime), &pos);
+ UG31_LOGI("[%s]: Read ADC1 Conversion Time (%d) %d bytes\n", __func__, data->sysData->adc1ConvTime, size);
+ size = vfs_read(fp, (char *)(&data->sysData->rsocFromIC), sizeof(data->sysData->rsocFromIC), &pos);
+ UG31_LOGI("[%s]: Read RSOC (%d) %d bytes\n", __func__, data->sysData->rsocFromIC, size);
+ size = vfs_read(fp, (char *)(&data->backupFileVer), sizeof(_backup_u32_), &pos);
+ UG31_LOGI("[%s]: Read version (%d) %d bytes\n", __func__, data->backupFileVer, size);
+
+ set_fs(oldFS);
+}
+
+/**
+ * @brief CheckBackupFile
+ *
+ * Check backup file is consisted with IC or not
+ *
+ * @para data address of BackupDataType
+ * @return BACKUP_BOOL_TRUE if success
+ */
+_backup_bool_ CheckBackupFile(BackupDataType *data)
+{
+ struct file *fp;
+ CapacityDataType *bufCapData;
+ SystemDataType *bufSysData;
+
+ fp = filp_open(data->backupFileName, O_RDWR, 0);
+ if(IS_ERR(fp))
+ {
+ UG31_LOGI("[%s]: Open backup file fail\n", __func__);
+ return (BACKUP_BOOL_FALSE);
+ }
+
+ /// [AT-PM] : Create buffer ; 02/21/2013
+ #if defined(uG31xx_OS_ANDROID)
+ #ifdef uG31xx_BOOT_LOADER
+ bufCapData = (CapacityDataType *)malloc(sizeof(CapacityDataType));
+ bufSysData = (SystemDataType *)malloc(sizeof(SystemDataType));
+ #else ///< else of uG31xx_BOOT_LOADER
+ bufCapData = (CapacityDataType *)kmalloc(sizeof(CapacityDataType), GFP_KERNEL);
+ bufSysData = (SystemDataType *)kmalloc(sizeof(SystemDataType), GFP_KERNEL);
+ #endif ///< end of uG31xx_BOOT_LOADER
+ #else ///< else of defined(uG31xx_OS_ANDROID)
+ bufCapData = (CapacityDataType *)malloc(sizeof(CapacityDataType));
+ bufSysData = (SystemDataType *)malloc(sizeof(SystemDataType));
+ #endif ///< end of defined(uG31xx_OS_ANDROID)
+ memcpy(bufCapData, data->capData, sizeof(CapacityDataType));
+ memcpy(bufSysData, data->sysData, sizeof(SystemDataType));
+
+ /// [AT-PM] : Get data from file ; 02/21/2013
+ ReadFile(data, fp);
+
+ /// [AT-PM] : Following information is not checked ; 02/21/2013
+ data->sysData->rmFromIC = bufSysData->rmFromIC;
+ data->sysData->timeTagFromIC = bufSysData->timeTagFromIC;
+ data->sysData->deltaCapFromIC = bufSysData->deltaCapFromIC;
+ data->sysData->adc1ConvTime = bufSysData->adc1ConvTime;
+
+ /// [AT-PM] : Check data ; 02/21/2013
+ if((memcmp(bufCapData, data->capData, sizeof(CapacityDataType)) != 0) ||
+ (memcmp(bufSysData, data->sysData, sizeof(SystemDataType)) != 0) ||
+ (data->backupFileVer != data->targetFileVer))
+ {
+ UG31_LOGI("[%s]: Backup file needs to be updated\n", __func__);
+ /// [AT-PM] : Write data to file ; 02/21/2013
+ memcpy(data->capData, bufCapData, sizeof(CapacityDataType));
+ memcpy(data->sysData, bufSysData, sizeof(SystemDataType));
+ WriteFile(data, fp);
+ }
+
+ filp_close(fp, _UPI_NULL_);
+
+ #if defined(uG31xx_OS_ANDROID)
+ #ifdef uG31xx_BOOT_LOADER
+ free(bufCapData);
+ free(bufSysData);
+ #else ///< else of uG31xx_BOOT_LOADER
+ kfree(bufCapData);
+ kfree(bufSysData);
+ #endif ///< end of uG31xx_BOOT_LOADER
+ #else ///< else of defined(uG31xx_OS_ANDROID)
+ free(bufCapData);
+ free(bufSysData);
+ #endif ///< end of defined(uG31xx_OS_ANDROID)
+ return (BACKUP_BOOL_TRUE);
+}
+
+/**
+ * @brief WriteSuspendBackupData
+ *
+ * Write suspend backup data to file
+ *
+ * @para data address of BackupDataType
+ * @return BACKUP_BOOL_TRUE if success
+ */
+_backup_bool_ WriteSuspendBackupData(BackupDataType *data)
+{
+ struct file *fp;
+ _backup_u8_ idx;
+ mm_segment_t oldFS;
+ loff_t pos;
+ size_t size;
+ _backup_u8_ *buf;
+
+ /// [AT-PM] : Check backup file content ; 10/12/2013
+ fp = filp_open("/sdcard/upi_table", O_RDWR, 0);
+ if(!IS_ERR(fp))
+ {
+ oldFS = get_fs();
+ set_fs(get_ds());
+
+ idx = 0;
+ pos = 0;
+ buf = (_backup_u8_ *)kmalloc(sizeof(BackupSuspendDataType), GFP_KERNEL);
+ while(idx < BACKUP_MAX_LOG_SUSPEND_DATA)
+ {
+ size = vfs_read(fp, (char *)buf, sizeof(BackupSuspendDataType), &pos);
+
+ if(memcmp((char *)buf, (char *)data->logData[idx], sizeof(BackupSuspendDataType)) != 0)
+ {
+ UG31_LOGI("[%s]: Need to write suspend data to file (%d)\n", __func__, idx);
+ break;
+ }
+
+ idx = idx + 1;
+ }
+ kfree(buf);
+
+ set_fs(oldFS);
+
+ filp_close(fp, _UPI_NULL_);
+
+ if(idx >= BACKUP_MAX_LOG_SUSPEND_DATA)
+ {
+ UG31_LOGI("[%s]: No need to update suspend data.\n", __func__, idx);
+ return (BACKUP_BOOL_TRUE);
+ }
+ }
+
+ fp = filp_open("/sdcard/upi_table", O_CREAT | O_RDWR, 0);
+ if(IS_ERR(fp))
+ {
+ UG31_LOGI("[%s]: Open backup file fail\n", __func__);
+ return (BACKUP_BOOL_FALSE);
+ }
+
+ oldFS = get_fs();
+ set_fs(get_ds());
+
+ idx = 0;
+ pos = 0;
+ while(idx < BACKUP_MAX_LOG_SUSPEND_DATA)
+ {
+ size = vfs_write(fp, (char *)data->logData[idx], sizeof(BackupSuspendDataType), &pos);
+ UG31_LOGI("[%s]: Write suspend data %d with %d bytes\n", __func__, idx, size);
+
+ idx = idx + 1;
+ }
+
+ set_fs(oldFS);
+
+ filp_close(fp, _UPI_NULL_);
+ return (BACKUP_BOOL_TRUE);
+}
+
+/// =============================================
+/// Extern Function Region
+/// =============================================
+
+#define RETRY_CHECKING_THRESHOLD (CONST_CONVERSION_COUNT_THRESHOLD)
+
+/**
+ * @brief UpiBackupData
+ *
+ * Backup data from IC to system routine
+ *
+ * @para data address of BackupDataType
+ * @return _UPI_NULL_
+ */
+void UpiBackupData(BackupDataType *data)
+{
+ _backup_bool_ rtnBool;
+
+ #ifndef UG31XX_BACKUP_FILE_ENABLE
+ rtnBool = _UPI_TRUE_;
+ data->backupFileSts = BACKUP_FILE_STS_EXIST;
+ #endif ///< end of UG31XX_BACKUP_FILE_ENABLE
+
+ #if defined(uG31xx_OS_ANDROID)
+ #ifdef uG31xx_BOOT_LOADER
+ data->backupFileName = (char *)malloc(strlen(BACKUP_FILE_PATH));
+ #else ///< else of uG31xx_BOOT_LOADER
+ data->backupFileName = (char *)kmalloc(strlen(BACKUP_FILE_PATH), GFP_KERNEL);
+ #endif ///< end of uG31xx_BOOT_LOADER
+ sprintf(data->backupFileName, "%s", BACKUP_FILE_PATH);
+ #else ///< else of defined(uG31xx_OS_ANDROID)
+ data->backupFileName = data->sysData->backupFileName;
+ #endif ///< end of defined(uG31xx_OS_ANDROID)
+
+ switch(data->backupFileSts)
+ {
+ case BACKUP_FILE_STS_CHECKING:
+ /// [AT-PM] : Check backup file existed or not ; 02/21/2013
+ rtnBool = ISFileExist(data);
+ if(rtnBool == BACKUP_BOOL_TRUE)
+ {
+ #ifdef BACKUP_FILE_STS_NOT_EXIST
+ data->backupFileSts = BACKUP_FILE_STS_NOT_EXIST;
+ #else ///< else of BACKUP_FILE_STS_NOT_EXIST
+ data->backupFileSts = BACKUP_FILE_STS_EXIST;
+ #endif ///< end of BACKUP_FILE_STS_NOT_EXIST
+ }
+ else
+ {
+ if(data->measData->lastCounter > RETRY_CHECKING_THRESHOLD)
+ {
+ data->backupFileSts = BACKUP_FILE_STS_NOT_EXIST;
+ }
+ }
+ break;
+ case BACKUP_FILE_STS_NOT_EXIST:
+ /// [AT-PM] : Create backup file ; 02/21/2013
+ rtnBool = CreateBackupFile(data);
+ if(rtnBool == BACKUP_BOOL_TRUE)
+ {
+ data->backupFileSts = BACKUP_FILE_STS_EXIST;
+ }
+ break;
+ case BACKUP_FILE_STS_EXIST:
+ rtnBool = CheckBackupFile(data);
+ if(rtnBool != BACKUP_BOOL_TRUE)
+ {
+ data->backupFileSts = BACKUP_FILE_STS_NOT_EXIST;
+ }
+ else
+ {
+ data->backupFileSts = BACKUP_FILE_STS_COMPARE;
+ }
+ break;
+ 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
+ rtnBool = CheckBackupFile(data);
+ if(rtnBool != BACKUP_BOOL_TRUE)
+ {
+ data->backupFileSts = BACKUP_FILE_STS_NOT_EXIST;
+ }
+ rtnBool = WriteSuspendBackupData(data);
+ if(rtnBool != BACKUP_BOOL_TRUE)
+ {
+ data->backupFileSts = BACKUP_FILE_STS_NOT_EXIST;
+ }
+ }
+ 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;
+ }
+
+ #if defined(uG31xx_OS_ANDROID)
+ #ifdef uG31xx_BOOT_LOADER
+ free(data->backupFileName);
+ #else ///< else of uG31xx_BOOT_LOADER
+ kfree(data->backupFileName);
+ #endif ///< end of uG31xx_BOOT_LOADER
+ #endif ///< end of defined(uG31xx_OS_ANDROID)
+
+ UG31_LOGI("[%s]: Backp file status = %d\n", __func__, data->backupFileSts);
+}
+
+/**
+ * @brief UpiUpdateSuspendData
+ *
+ * Update data for suspend backup
+ *
+ * @para data address of BackupDataType
+ * @para is_resume UPI_TRUE if called in resume
+ * @return NULL
+ */
+void UpiUpdateSuspendData(BackupDataType *data, _backup_bool_ is_resume)
+{
+ if(is_resume == _UPI_TRUE_)
+ {
+ data->logData[data->backupDataIdx]->afterCapData = *(data->capData);
+ data->logData[data->backupDataIdx]->afterMeasData = *(data->measData);
+ UG31_LOGI("[%s]: Backup resume data to buffer %d\n", __func__, data->backupDataIdx);
+
+ data->backupDataIdx = data->backupDataIdx + 1;
+ if(data->backupDataIdx >= BACKUP_MAX_LOG_SUSPEND_DATA)
+ {
+ data->backupDataIdx = BACKUP_MAX_LOG_SUSPEND_DATA;
+ }
+ }
+ else
+ {
+ if((data->backupDataIdx >= BACKUP_MAX_LOG_SUSPEND_DATA) && (is_resume == _UPI_FALSE_))
+ {
+ data->backupDataIdx = 0;
+ while(data->backupDataIdx < (BACKUP_MAX_LOG_SUSPEND_DATA - 1))
+ {
+ memcpy(data->logData[data->backupDataIdx], data->logData[data->backupDataIdx + 1], sizeof(BackupSuspendDataType));
+ data->backupDataIdx = data->backupDataIdx + 1;
+ }
+ }
+
+ data->logData[data->backupDataIdx]->beforeCapData = *(data->capData);
+ data->logData[data->backupDataIdx]->beforeMeasData = *(data->measData);
+ UG31_LOGI("[%s]: Backup suspend data to buffer %d\n", __func__, data->backupDataIdx);
+ }
+}
+
|