int iKXPlugin::get_all_params(kxparam_t *values) // at least [count]
{
int ret=0;
for(int i=0;i<get_param_count();i++)
ret+=get_param(i,&values[i]);
return ret;
}
const Dictionary& ShaderQuery::get_param_info(const size_t param_index) const
{
assert(param_index < get_param_count());
if (!impl->m_param_info[param_index])
{
impl->m_param_info[param_index] =
Impl::param_to_dict(*impl->m_query.getparam(param_index));
}
return impl->m_param_info[param_index].get();
}
int iKXPlugin::get_user_interface()
{
if(get_param_count()>0)
{
// for FXBus it get_param_count() returns 0
if(
strcmp(get_plugin_description(IKX_PLUGIN_GUID),"631d8de5-11bc-4c3d-a0d2-f079977fd184")==0 || // prolog
strcmp(get_plugin_description(IKX_PLUGIN_GUID),"313149FA-24FB-4f08-9C22-EB38B651BA58")==0 || // xrouting
strcmp(get_plugin_description(IKX_PLUGIN_GUID),"ceffc302-ea28-44df-873f-d3df1ba31736")==0 // epilog
)
return IKXPLUGIN_NONE;
return IKXPLUGIN_SIMPLE;
}
else
return IKXPLUGIN_NONE;
}
int iKXPlugin::export_presets(const char *file_name)
{
unlink(file_name);
int cnt=get_param_count();
kSettings cfg;
kSettings exp_file(NULL,file_name);
char full_key[127+KX_MAX_STRING];
sprintf(full_key,"Plugins\\%s",get_plugin_description(IKX_PLUGIN_GUID));
exp_file.write_abs("kXPreset","Size",cnt);
exp_file.write_abs("kXPreset","Version",PRESET_VERSION);
exp_file.write_abs("kXPreset","GUID",get_plugin_description(IKX_PLUGIN_GUID));
int ndx=0;
while(1)
{
char key_name[KX_MAX_STRING+256];
kxparam_t value[256];
if(cfg.enum_abs(ndx,full_key,key_name,sizeof(key_name),(TCHAR *)value,sizeof(value))==0)
{
char key[KX_MAX_STRING+10];
sprintf(key,"%d.name",ndx);
exp_file.write_abs(get_plugin_description(IKX_PLUGIN_GUID),key,key_name);
sprintf(key,"%d.data",ndx);
exp_file.write_bin_abs(get_plugin_description(IKX_PLUGIN_GUID),key,value,cnt*sizeof(kxparam_t));
}
else
{
break;
}
ndx++;
}
return 0;
}
int iKXPlugin::save_preset(const char *new_name)
{
kSettings cfg;
char full_key[127+KX_MAX_STRING];
sprintf(full_key,"Plugins\\%s",get_plugin_description(IKX_PLUGIN_GUID));
kxparam_t *data=0;
int cnt=get_param_count();
data=(kxparam_t *)malloc(cnt*sizeof(kxparam_t));
if(data)
{
get_all_params(data);
cfg.write_bin_abs(full_key,new_name,data,cnt*sizeof(kxparam_t));
free(data);
}
else return -1;
return 0;
}
inline ndt::type resolve(const ndt::type *src_tp) const
{
if (resolve_dst_type != NULL) {
ndt::type result;
resolve_dst_type(this, result, src_tp, true);
return result;
} else {
intptr_t param_count = get_param_count();
const ndt::type *param_types = get_param_types();
std::map<nd::string, ndt::type> typevars;
for (intptr_t i = 0; i != param_count; ++i) {
if (!ndt::pattern_match(src_tp[i].value_type(), param_types[i],
typevars)) {
std::stringstream ss;
ss << "parameter " << (i + 1) << " to arrfunc does not match, ";
ss << "expected " << param_types[i] << ", received " << src_tp[i];
throw std::invalid_argument(ss.str());
}
}
// TODO:
// return ndt::substitute_type_vars(get_return_type(), typevars);
return get_return_type();
}
}
int run_internal(int term, char* cmd_line)
{
char cmd[MAX_COMMAND_LEN];
char params[MAX_COMMAND_LEN];
int index;
memset(cmd, '\0', MAX_COMMAND_LEN);
memset(params, '\0', MAX_COMMAND_LEN);
if(!strword(1, cmd_line, len(cmd_line)+1, cmd, MAX_COMMAND_LEN))
{
return 0;
}
index = first_index_of(cmd_line, ' ', len(cmd));
if(index != -1)
substr(cmd_line, index, -1, params);
else
params[0] = '\0';
trim(params);
argc[term] = get_param_count(params);
if(argc[term] > 0)
{
args[term] = (char**)malloc(argc[term] * sizeof(char*));
get_parameters(params, argc[term], args[term]);
}
else
{
args[term] = NULL;
}
if(streq(cmd, "cd"))
{
if(streq(params, ""))
{
term_color_print(term, "Wrong parameters.\n\n", 7);
term_color_print(term, "Usage: cd path.\n\n", 7);
}
else
{
change_dir(term, params);
}
free_params(term);
return TRUE;
}
else if(streq(cmd, "set"))
{
// allows setting, listing or removing global and console variables
set_cmd(term, args[term], argc[term]);
free_params(term);
return TRUE;
}
else if(streq(cmd, "jobs"))
{
// allows setting, listing or removing global and console variables
jobs(term, args[term], argc[term]);
free_params(term);
return TRUE;
}
else if(streq(cmd, "kill"))
{
// allows setting, listing or removing global and console variables
kill(term, args[term], argc[term]);
free_params(term);
return TRUE;
}
else if(streq(cmd, "clear"))
{
term_clean(term);
free_params(term);
return TRUE;
}
else if(streq(cmd, "initofs")) // this command should dissapear in a future
{
init_ofs(term, args[term], argc[term]);
free_params(term);
return TRUE;
}
else if(streq(cmd, "mkdir"))
{
mkdir_cmd(term, args[term], argc[term]);
free_params(term);
return TRUE;
}
else if(streq(cmd, "rm"))
{
rm_cmd(term, args[term], argc[term]);
free_params(term);
return TRUE;
}
else if(streq(cmd, "ls"))
{
ls(term, args[term], argc[term]);
free_params(term);
return TRUE;
}
else if(streq(cmd, "mkdevice"))
{
mkdevice_cmd(term, args[term], argc[term]);
free_params(term);
return TRUE;
}
else if(streq(cmd, "ofsformat"))
{
ofsformat(term, args[term], argc[term]);
free_params(term);
return TRUE;
}
/*else if(streq(cmd, "cat"))
{
cat(term, args[term], argc[term]);
free_params(term);
return TRUE;
}*/
else if(streq(cmd, "write"))
{
write(term, args[term], argc[term]);
free_params(term);
return TRUE;
}
else if(streq(cmd, "mount"))
{
mount_cmd(term, args[term], argc[term]);
free_params(term);
return TRUE;
}
else if(streq(cmd, "umount"))
{
umount_cmd(term, args[term], argc[term]);
free_params(term);
return TRUE;
}
else if(streq(cmd, "chattr"))
{
chattr_cmd(term, args[term], argc[term]);
free_params(term);
return TRUE;
}
else if(streq(cmd, "ln"))
{
mklink_cmd(term, args[term], argc[term]);
free_params(term);
return TRUE;
}
else if(streq(cmd, "contest"))
{
contest(term, args[term], argc[term]);
free_params(term);
return TRUE;
}
else if(streq(cmd, "atactst"))
{
atactst(term, args[term], argc[term]);
free_params(term);
return TRUE;
}
else if(streq(cmd, "dyntst"))
{
dyntst(term, args[term], argc[term]);
free_params(term);
return TRUE;
}
free_params(term);
return FALSE;
}
int iKXPlugin::populate_presets(HMENU mnu)
{
// built-in presets first...
int need_sep=0;
int to_ret=-1;
try
{
const kxparam_t *t=get_plugin_presets();
if(t)
{
int num=get_param_count();
int ndx=0;
while(1)
{
char *name=(char *)t[0];
if(name==0)
break;
AppendMenu(mnu,MFT_STRING,IKXPLUGIN_PRESETS_BUILTIN+ndx,name);
to_ret=1;
need_sep=1;
ndx++;
t+=(num+1);
}
}
}
catch(...)
{
debug("Incorrect plugin: %d [pointer from populate_presets()]\n",__LINE__);
}
int ndx=0;
kSettings cfg;
char full_key[127+KX_MAX_STRING];
sprintf(full_key,"Plugins\\%s",get_plugin_description(IKX_PLUGIN_GUID));
while(1)
{
char key_name[KX_MAX_STRING+256];
char value[MAX_PATH];
if(cfg.enum_abs(ndx,full_key,key_name,sizeof(key_name),value,sizeof(value))==0)
{
if(key_name[0]!='#')
{
if(need_sep)
{
AppendMenu(mnu,MFT_SEPARATOR,0,"");
need_sep=0;
}
AppendMenu(mnu,MFT_STRING,IKXPLUGIN_PRESETS_CUSTOM+ndx,key_name);
to_ret=0;
}
}
else
{
break;
}
ndx++;
}
return to_ret;
}
int iKXPlugin::populate_presets(kMenu *mnu)
{
// built-in presets first...
int need_sep=0;
int to_ret=-1;
try
{
const kxparam_t *t=get_plugin_presets();
if(t)
{
int num=get_param_count();
int ndx=0;
while(1)
{
const char *name=(char *)t[0];
if(name==0)
break;
mnu->add(name,IKXPLUGIN_PRESETS_BUILTIN+ndx);
to_ret=1;
need_sep=1;
ndx++;
t+=(num+1);
}
}
}
catch(...)
{
debug("Incorrect plugin: %d [pointer from populate_presets()]\n",__LINE__);
}
int ndx=0;
kSettings cfg;
char full_key[127+KX_MAX_STRING];
sprintf(full_key,"Plugins\\%s",get_plugin_description(IKX_PLUGIN_GUID));
char *value;
value=(char *)malloc((get_param_count()+1)*sizeof(kxparam_t));
while(1)
{
char key_name[KX_MAX_STRING+256];
if(cfg.enum_abs(ndx,full_key,key_name,sizeof(key_name),value,(get_param_count()+1)*sizeof(kxparam_t))==0)
{
if(key_name[0]!='#')
{
if(need_sep)
{
mnu->separator();
need_sep=0;
}
mnu->add(key_name,IKXPLUGIN_PRESETS_CUSTOM+ndx);
to_ret=0;
}
}
else
{
break;
}
ndx++;
}
free(value);
return to_ret;
}
int iKXPlugin::import_presets(const char *file_name)
{
int ori_cnt=get_param_count();
dword cnt=0;
kSettings cfg;
kSettings exp_file(NULL,file_name);
exp_file.read_abs("kXPreset","Version",&cnt);
if(cnt<PRESET_VERSION)
{
debug("kxapi: invalid preset version: %d %d\n",cnt,PRESET_VERSION);
return -3;
}
char tmp_guid[KX_MAX_STRING];
exp_file.read_abs("kXPreset","GUID",tmp_guid,sizeof(tmp_guid));
if(strncmp(tmp_guid,get_plugin_description(IKX_PLUGIN_GUID),KX_MAX_STRING)!=0)
{
debug("kxapi: invalid preset GUID\n");
return -2;
}
exp_file.read_abs("kXPreset","Size",&cnt);
if((int)cnt!=ori_cnt)
{
debug("kxapi: invalid preset size [%d.%d]\n",cnt,ori_cnt);
return -1;
}
int ndx=0;
char full_key[127+KX_MAX_STRING];
sprintf(full_key,"Plugins\\%s",get_plugin_description(IKX_PLUGIN_GUID));
while(1)
{
char key[KX_MAX_STRING+256];
char key_name[KX_MAX_STRING+128];
kxparam_t value[256];
sprintf(key,"%d.name",ndx);
if(exp_file.read_abs(get_plugin_description(IKX_PLUGIN_GUID),key,key_name,sizeof(key_name))==0)
{
sprintf(key,"%d.data",ndx);
int sz=sizeof(value);
if(exp_file.read_bin_abs(get_plugin_description(IKX_PLUGIN_GUID),key,value,&sz)==0)
{
if(sz==(int)(cnt*sizeof(kxparam_t)))
cfg.write_bin_abs(full_key,key_name,value,cnt*sizeof(kxparam_t));
}
}
else
{
break;
}
ndx++;
}
return 0;
}
int iKXPlugin::get_current_preset(char *ret_name)
{
int found=0;
kxparam_t *data=0;
int cnt=get_param_count();
if(cnt)
data=(kxparam_t *)malloc(cnt*sizeof(kxparam_t));
if(data)
{
get_all_params(data);
kSettings cfg;
char full_key[127+KX_MAX_STRING];
sprintf(full_key,"Plugins\\%s",get_plugin_description(IKX_PLUGIN_GUID));
int ndx=0;
while(1)
{
char key_name[KX_MAX_STRING+256];
kxparam_t value[256];
if(cfg.enum_abs(ndx,full_key,key_name,sizeof(key_name),(TCHAR *)value,sizeof(value))==0)
{
if(memcmp(value,data,cnt*sizeof(kxparam_t))==0)
{
strncpy(ret_name,key_name,KX_MAX_STRING);
found=1;
goto OK;
}
}
else
{
break;
}
ndx++;
}
// second, check built-in presets
try
{
const kxparam_t *t=get_plugin_presets();
if(t)
{
int num=get_param_count();
while(1)
{
char *name=(char *)t[0];
if(name==0)
break;
if(memcmp(data,&t[1],num*sizeof(kxparam_t))==0)
{
strncpy(ret_name,name,KX_MAX_STRING);
found=1;
goto OK;
}
t+=(num+1);
}
}
}
catch(...)
{
debug("Incorrect plugin: %d [pointer from get_current_preset()]\n",__LINE__);
}
OK:
free(data);
}
return found?0:-1;
}
int iKXPlugin::apply_preset(int ndx)
{
int success=0;
if(ndx>=IKXPLUGIN_PRESETS_CUSTOM && ndx<=IKXPLUGIN_PRESETS_CUSTOM+IKXPLUGIN_MAX_PRESETS)
{
kSettings cfg;
char full_key[127+KX_MAX_STRING];
sprintf(full_key,"Plugins\\%s",get_plugin_description(IKX_PLUGIN_GUID));
char key_name[KX_MAX_STRING+256];
try
{
dword cnt=get_param_count();
kxparam_t *value=(kxparam_t *)malloc((cnt+1)*sizeof(kxparam_t));
if(value)
{
// add two 'guard bytes' (due to kSettings.enum_abs limitations...)
value[cnt-1]=0x12345678;
value[cnt]=0x87654321;
if(cfg.enum_abs(ndx-IKXPLUGIN_PRESETS_CUSTOM,full_key,key_name,sizeof(key_name),
(char *)value,cnt*sizeof(kxparam_t))==0)
{
if(value[cnt-1]!=0x12345678 && value[cnt]==0x87654321)
{
set_all_params(value);
success=1;
}
else
{
cfg.delete_value_abs(full_key,key_name);
debug("kxapi: presets: invalid preset [%d; %s; %s]\n",ndx,key_name,full_key);
}
}
free(value);
}
else
debug("kxapi: presets: not enough memory [%d]\n",cnt);
}
catch(...)
{
debug("kxapi: presets: exception when trying to apply preset\n");
};
}
if(ndx>=IKXPLUGIN_PRESETS_BUILTIN)
{
// check built-in presets
try
{
const kxparam_t *t=get_plugin_presets();
if(t)
{
int num=get_param_count();
set_all_params((kxparam_t *)&t[(num+1)*(ndx-IKXPLUGIN_PRESETS_BUILTIN)+1]);
success=1;
}
}
catch(...)
{
debug("Incorrect plugin: %d [pointer from get_plugin_presets()] -- apply preset()\n",__LINE__);
}
}
if(success)
return 0;
else
return -1;
}
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;
}
