static int is_lv_done_before(const char * pVol)
{
DIR *autok_data_dir;
struct dirent *autok_file;
char *filename;
static char sname[AUTOK_S_BUF_LEN] = "";
if(strlen(sname) > 0){
if(is_file_valid(sname) > 0){
META_LOG("[AUTOK]Cache LV Done");
return true;
}
else {
META_LOG("[AUTOK]Cache LV not done");
memset(sname, 0, AUTOK_S_BUF_LEN);
return false;
}
}
autok_data_dir = opendir(AUTOK_RES_PATH);
while((autok_file = readdir(autok_data_dir)) != NULL) {
filename = autok_file->d_name;
if(strstr(filename, "autok")!= NULL &&
strstr(filename, pVol)!=NULL &&
strstr(filename, "_log")==NULL){
memset(sname, 0, AUTOK_S_BUF_LEN);
snprintf(sname, AUTOK_S_BUF_LEN, "%s/%s", AUTOK_RES_PATH, filename);
META_LOG("[AUTOK]Non-Cached LV check exist");
return true;
}
}
closedir(autok_data_dir);
return false;
}
bool Filter::is_valid( const Path& p ) const
{
if ( is_directory( p ) && !is_symlink( p ) )
{
return is_folder_valid( p );
}
return is_file_valid( p );
}
static FileInfo *load_data(char *filename)
{
FILE *fp;
char line[LINE_SIZE];
char d[TIME_STR_SIZE], a[TIME_STR_SIZE];
int m;
bool read_error = false, data_error = false;
FileInfo *fi = NULL; /* NULL so first realloc is just like malloc() */
size_t l;
if (!is_file_valid(filename))
exit(EXIT_FAILURE);
if ((fp = fopen(filename, "r")) == NULL) {
fprintf(stderr, "failed to open %s\n", filename);
exit(EXIT_FAILURE);
}
for (l = 0;fgets(line, sizeof(line), fp) != NULL; l++)
{
if (!(fi = realloc(fi, sizeof(FileInfo) + (sizeof(int (*)[2])) * (l + 1)))) {
fprintf(stderr, "realloc: %s:%d\n", __FILE__, __LINE__);
exit(EXIT_FAILURE);
}
sscanf(line, "%s %s", d, a);
if ((m = to_minutes(d)) == -1) {
DATA_ERROR(filename, l + 1, d);
break;
}
fi->data[l][0] = m;
if ((m = to_minutes(a)) == -1) {
DATA_ERROR(filename, l + 1, a);
break;
}
fi->data[l][1] = m;
}
fi->size = l;
if (!feof(fp) || ferror(fp)) {
if (!data_error) {
perror(FILE_PATH);
read_error = true;
errno = 0;
}
}
if (fclose(fp) == EOF || read_error || data_error) {
if (!data_error && !read_error)
perror(filename);
free(fi);
exit(EXIT_FAILURE);
}
return fi;
}
int do_host_autok(int id)
{
int i, j;
int param_count;
int vol_count;
//std::list<unsigned int> undo_vol_list;
struct autok_predata predata;
unsigned int *param_list;
unsigned int *vol_list;
struct autok_predata full_data;
std::list<struct res_data*> res_list;
std::list<struct res_data*>::iterator it_res;
struct res_data *p_res;
char devnode[BUF_LEN]="";
char resnode[BUF_LEN]="";
char data_node[BUF_LEN]="";
int need_to_recover = 0;
param_count = get_param_count();
printf("Param_count:%d\n", param_count);
if(get_nvram_param_count(id)!=param_count){
system("rm -rf /data/autok_*");
system("rm -rf /data/nvram/APCFG/APRDCL/SDIO");
close_nvram();
init_autok_nvram();
need_to_recover = 1;
}
//duplicate nvram data partition
//if(!is_nvram_mode()){
for(i=0; i<VCORE_NO; i++){
//char nvram_node[BUF_LEN]="";
//snprintf(nvram_node, BUF_LEN, "%s/%s_%d_%d", AUTOK_NVRAM_PATH, RESULT_FILE_PREFIX, id, g_autok_vcore[i]);
snprintf(data_node, BUF_LEN, "%s/%s_%d_%d", AUTOK_RES_PATH, RESULT_FILE_PREFIX, id, g_autok_vcore[i]);
// Check environment
// 1. nvram data partition should exist
// 2. autok parameter in data partion should not exist
// 3. param_count should be the same
if(is_nvram_data_exist(id, g_autok_vcore[i])>0 && is_file_valid(data_node)<=0){
//data_copy(nvram_node, data_node);
int data_length;
char *data_buf;
read_from_nvram(id, g_autok_vcore[i], (unsigned char**)&data_buf, &data_length);
if(write_to_file(data_node, data_buf, data_length)<0){
free(data_buf);
return -1;
}
free(data_buf);
printf("duplicata from [%s] to [%s]\n", AUTOK_NVRAM_PATH, data_node);
}
}
//}
//check autok folder
for(i=0; i<VCORE_NO; i++){
// [FIXME] Normal mode & factory mode should store to different path
snprintf(resnode, BUF_LEN, "%s/%s_%d_%d", AUTOK_RES_PATH, RESULT_FILE_PREFIX, id, g_autok_vcore[i]);
printf("1-0 done\n");
//if(!is_nvram_mode()){
//std::string res_str(resnode);
p_res = (struct res_data*)malloc(sizeof(struct res_data));
p_res->id = id;
p_res->voltage = g_autok_vcore[i];
strcpy(p_res->filepath, resnode);
res_list.push_back(p_res);
//}
/*else {
snprintf(resnode, BUF_LEN, "%s/%s_%d_%d", AUTOK_RES_PATH, RESULT_FILE_PREFIX, id, g_autok_vcore[i]);
write_file_to_nvram(resnode, id);
}*/
struct timespec tstart={0,0}, tend={0,0};
printf("1-1 done\n");
if(is_file_valid(resnode)<=0){
//undo_vol_list.push_back(g_autok_vcore[i]);
set_stage1_voltage(id, g_autok_vcore[i]);
set_stage1_done(id, 0);
printf("[%s] set done to 0\n", resnode);
// prepare zero data to drive autok algorithm
param_list = (unsigned int*)malloc(sizeof(unsigned int)*param_count);
for(j=0; j<param_count; j++){
param_list[j] = 0;
}
vol_count = 1;
vol_list = (unsigned int*)malloc(sizeof(unsigned int)*vol_count);
vol_list[0] = g_autok_vcore[i];
pack_param(&predata, vol_list, vol_count, param_list, param_count);
clock_gettime(CLOCK_MONOTONIC, &tstart);
set_stage1_params(id, &predata);
printf("operation col_count[%d] vcore[%d] param_count[%d]\n", vol_count, vol_list[0], param_count);
release_predata(&predata);
printf("release col_count[%d] param_count[%d]\n", vol_count, param_count);
// Wait for autok stage1 for a specific voltage done
// [FIXME] can switch to uevent?
while(1){
if(get_stage1_done(id))
break;
usleep(10*1000);
}
clock_gettime(CLOCK_MONOTONIC, &tend);
printf("autok once %.5f seconds\n",((double)tend.tv_sec + 1.0e-9*tend.tv_nsec) - ((double)tstart.tv_sec + 1.0e-9*tstart.tv_nsec));
set_debug(0);
snprintf(devnode, BUF_LEN, "%s/%d/%s", STAGE1_DEVNODE, id, "PARAMS");
if(!is_nvram_mode()){
printf("[NON_NV]From dev[%s] to res[%s]\n", devnode, resnode);
from_dev_to_data(devnode, resnode);
// For recover different version param_count
if(need_to_recover){
write_dev_to_nvram(devnode, id);
}
} else {
printf("[NV]From dev[%s] to nvram\n", devnode);
from_dev_to_data(devnode, resnode);
write_dev_to_nvram(devnode, id);
}
}
printf("1-2 done\n");
}
// Set stage2 data to apply autok parameter
//if(!is_nvram_mode()){
// Merge Phase
full_data.vol_count = VCORE_NO;
full_data.param_count = param_count;
full_data.vol_list = (unsigned int*)malloc(sizeof(unsigned int)*VCORE_NO);
full_data.ai_data = (U_AUTOK_INTERFACE_DATA**)malloc(sizeof(U_AUTOK_INTERFACE_DATA*)*VCORE_NO);
i = 0;
for(it_res=res_list.begin(); it_res!=res_list.end(); ++it_res){
full_data.ai_data[i] = (U_AUTOK_INTERFACE_DATA*)malloc(sizeof(U_AUTOK_INTERFACE_DATA)*param_count);
struct res_data *p_temp_res = *it_res;
predata = get_param((char*)p_temp_res->filepath);
full_data.vol_list[i] = p_temp_res->voltage;
memcpy(full_data.ai_data[i], predata.ai_data[0], sizeof(U_AUTOK_INTERFACE_DATA)*param_count);
release_predata(&predata);
free(p_temp_res);
i++;
}
printf("1-3 done\n");
set_stage2(id, &full_data);
release_predata(&full_data);
printf("1-4 done\n");
/*}else{
set_ready(id);
}*/
return 0;
}