static void ddp_check_mutex_l(int mutex_id, int* module_list, DDP_MODE ddp_mode)
{
int i=0;
kal_uint32 real_value = 0;
kal_uint32 expect_value = 0;
kal_uint32 real_sof = 0;
MUTEX_SOF expect_sof = SOF_SINGLE;
int module_num = ddp_get_module_num_l(module_list);
if(mutex_id < DISP_MUTEX_DDP_FIRST || mutex_id > DISP_MUTEX_DDP_LAST)
{
DDPDUMP("error:check mutex fail:exceed mutex max (0 ~ %d)\n",DISP_MUTEX_DDP_LAST);
return;
}
real_value = DISP_REG_GET(DISP_REG_CONFIG_MUTEX_MOD(mutex_id));
for(i = 0 ; i < module_num ; i++)
{
if(module_mutex_map[module_list[i]].bit != -1)
expect_value |= (1 << module_mutex_map[module_list[i]].bit);
}
if( expect_value != real_value )
{
DDPDUMP("error:mutex %d error: expect 0x%x, real 0x%x\n",mutex_id,expect_value,real_value);
}
real_sof = DISP_REG_GET(DISP_REG_CONFIG_MUTEX_SOF(mutex_id));
expect_sof = ddp_get_mutex_sof(module_list[module_num-1],ddp_mode);
if((kal_uint32)expect_sof != real_sof)
{
DDPDUMP("error:mutex %d sof error: expect %s, real %s\n", mutex_id,
ddp_get_mutex_sof_name(expect_sof),
ddp_get_mutex_sof_name((MUTEX_SOF)real_sof));
}
}
DISP_MODULE_ENUM ddp_get_dst_module(DDP_SCENARIO_ENUM ddp_scenario)
{
DISP_MODULE_ENUM module_name = DISP_MODULE_UNKNOWN;
int module_num = ddp_get_module_num_l(module_list_scenario[ddp_scenario])-1;
if(module_num >=0 )
module_name = module_list_scenario[ddp_scenario][module_num];
//DDPMSG("ddp_get_dst_module, scneario=%s, dst_module=%s\n",
// ddp_get_scenario_name(ddp_scenario),
// ddp_get_module_name(module_name));
return module_name;
}
static void ddp_disconnect_path_l(int *module_list,void * handle)
{
unsigned int i, j, k;
int step = 0;
unsigned int mout = 0;
unsigned int reg_mout = 0;
unsigned int mout_idx = 0;
unsigned int module_num = ddp_get_module_num_l(module_list);
DDPDBG("disconnect_path: %s to %s\n",ddp_get_module_name(module_list[0]),
ddp_get_module_name(module_list[module_num-1]));
for(i = 0 ; i < module_num - 1 ; i++)
{
for(j = 0 ; j < DDP_MOUT_NUM ; j++)
{
if(module_list[i] == mout_map[j].id)
{
//find next module which can be connected
step = i+1;
while(module_can_connect[module_list[step]].bit==0 && step<module_num)
{
step++;
}
ASSERT(step<module_num);
for(k = 0 ; k < 5 ; k++)
{
if(mout_map[j].out_id_bit_map[k].m == -1)
break;
if(mout_map[j].out_id_bit_map[k].m == module_list[step])
{
mout |= mout_map[j].out_id_bit_map[k].v;
reg_mout |= mout;
mout_idx = j;
DDPDBG("disconnect mout %s to %s \n", ddp_get_module_name(module_list[i]),
ddp_get_module_name(module_list[step]));
break;
}
}
//update mout_value
mout_map[j].reg_val &= ~mout;
mout = 0;
}
}
if(reg_mout)
{
DISP_REG_SET(handle,mout_map[mout_idx].reg, mout_map[mout_idx].reg_val);
reg_mout = 0;
mout_idx = 0;
}
}
}
static int ddp_mutex_set_l(int mutex_id, int* module_list, DDP_MODE ddp_mode, void * handle)
{
int i=0;
kal_uint32 value = 0;
int module_num = ddp_get_module_num_l(module_list);
MUTEX_SOF mode = ddp_get_mutex_sof(module_list[module_num-1],ddp_mode);
if(mutex_id < DISP_MUTEX_DDP_FIRST || mutex_id > DISP_MUTEX_DDP_LAST)
{
DDPERR("exceed mutex max (0 ~ %d)\n",DISP_MUTEX_DDP_LAST);
return -1;
}
for(i = 0 ; i < module_num ; i++)
{
if(module_mutex_map[module_list[i]].bit != -1)
{
DDPDBG("module %s added to mutex %d\n",ddp_get_module_name(module_list[i]),mutex_id);
value |= (1 << module_mutex_map[module_list[i]].bit);
}
else
{
DDPDBG("module %s not added to mutex %d\n",ddp_get_module_name(module_list[i]),mutex_id);
}
}
DISP_REG_SET(handle,DISP_REG_CONFIG_MUTEX_MOD(mutex_id),value);
DISP_REG_SET(handle,DISP_REG_CONFIG_MUTEX_SOF(mutex_id),mode);
// for primary config thread, save more time for register config
if(gEnableMutexRisingEdge==1 && primary_display_is_video_mode()==1 && mutex_id==0)
{
DISP_REG_SET_FIELD(handle, SOF_FLD_MUTEX0_SOF_TIMING, DISP_REG_CONFIG_MUTEX0_SOF, 1);
}
if(gEnableSWTrigger==1 && primary_display_is_video_mode()==1 && mutex_id==0)
{
// set OVL0/OVL1 to separate mutex
DISP_REG_SET(handle,DISP_REG_CONFIG_MUTEX_MOD(DISP_OVL_SEPARATE_MUTEX_ID),value&((1 << module_mutex_map[DISP_MODULE_OVL0].bit)|(1 << module_mutex_map[DISP_MODULE_OVL1].bit)));
DISP_REG_SET(handle,DISP_REG_CONFIG_MUTEX_SOF(DISP_OVL_SEPARATE_MUTEX_ID), SOF_SINGLE);
// move OVL0/OVL1 out from primary path
DISP_REG_SET(handle,DISP_REG_CONFIG_MUTEX_MOD(mutex_id),value&(~((1 << module_mutex_map[DISP_MODULE_OVL0].bit)|(1 << module_mutex_map[DISP_MODULE_OVL1].bit))));
}
DDPDBG("mutex %d value=0x%x, sof=%s\n",mutex_id, value, ddp_get_mutex_sof_name(mode));
return 0;
}
// set display interface when kernel init
int ddp_set_dst_module(DDP_SCENARIO_ENUM scenario, DISP_MODULE_ENUM dst_module)
{
int i = 0;
DDPMSG("ddp_set_dst_module, scenario=%s, dst_module=%s \n",
ddp_get_scenario_name(scenario), ddp_get_module_name(dst_module));
if (ddp_find_module_index(scenario,dst_module) > 0) {
DDPDBG("%s is already on path\n",ddp_get_module_name(dst_module));
return 0;
}
i = ddp_get_module_num_l(module_list_scenario[scenario])-1;
ASSERT(i>=0);
if (dst_module == DISP_MODULE_DSIDUAL) {
if (i < (DDP_ENING_NUM -1)) {
module_list_scenario[scenario][i++] = DISP_MODULE_SPLIT1;
}else{
DDPERR("set dst module over up bound\n");
return -1;
}
}
else
{
if(ddp_get_dst_module(scenario)==DISP_MODULE_DSIDUAL)
{
if (i >= 1) {
module_list_scenario[scenario][i--] = -1;
}else{
DDPERR("set dst module over low bound\n");
return -1;
}
}
}
module_list_scenario[scenario][i] = dst_module;
if (scenario == DDP_SCENARIO_PRIMARY_ALL) {
ddp_set_dst_module(DDP_SCENARIO_PRIMARY_DISP,dst_module);
}else if(scenario==DDP_SCENARIO_SUB_ALL) {
ddp_set_dst_module(DDP_SCENARIO_SUB_DISP,dst_module);
}
ddp_print_scenario(scenario);
return 0;
}
// id: mutex ID, 0~5
static int ddp_mutex_set_l(int mutex_id, int* module_list, DDP_MODE ddp_mode, void * handle)
{
int i=0;
kal_uint32 value = 0;
int module_num = ddp_get_module_num_l(module_list);
MUTEX_SOF mode = ddp_get_mutex_sof(module_list[module_num-1],ddp_mode);
if(mutex_id < DISP_MUTEX_DDP_FIRST || mutex_id > DISP_MUTEX_DDP_LAST)
{
DDPERR("exceed mutex max (0 ~ %d)\n",DISP_MUTEX_DDP_LAST);
return -1;
}
for(i = 0 ; i < module_num ; i++)
{
if(module_mutex_map[module_list[i]].bit != -1)
DDPDBG("module %s added to mutex %d\n",ddp_get_module_name(module_list[i]),mutex_id);
value |= (1 << module_mutex_map[module_list[i]].bit);
}
DISP_REG_SET(handle,DISP_REG_CONFIG_MUTEX_MOD(mutex_id),value);
DISP_REG_SET(handle,DISP_REG_CONFIG_MUTEX_SOF(mutex_id),mode);
DDPDBG("mutex %d value=0x%x, sof=%s\n",mutex_id, value, ddp_get_mutex_sof_name(mode));
return 0;
}
int ddp_get_module_num(DDP_SCENARIO_ENUM scenario)
{
return ddp_get_module_num_l(module_list_scenario[scenario]);
}
static void ddp_check_path_l(int *module_list)
{
unsigned int i, j, k;
int step = 0;
int valid =0;
unsigned int mout;
unsigned int path_error = 0;
unsigned int module_num = ddp_get_module_num_l(module_list);
DDPDUMP("check_path: %s to %s\n",ddp_get_module_name(module_list[0])
,ddp_get_module_name(module_list[module_num-1]));
// check mout
for(i = 0 ; i < module_num - 1 ; i++)
{
for(j = 0 ; j < DDP_MOUT_NUM ; j++)
{
if(module_list[i] == mout_map[j].id)
{
mout = 0;
//find next module which can be connected
step = i+1;
while(module_can_connect[module_list[step]].bit==0 && step<module_num)
{
step++;
}
ASSERT(step<module_num);
for(k = 0 ; k < 5 ; k++)
{
if(mout_map[j].out_id_bit_map[k].m == -1)
break;
if(mout_map[j].out_id_bit_map[k].m == module_list[step])
{
mout |= mout_map[j].out_id_bit_map[k].v;
valid =1;
break;
}
}
if(valid)
{
valid =0;
if((DISP_REG_GET(mout_map[j].reg) & mout)==0)
{
path_error += 1;
DDPDUMP("error:%s mout, expect=0x%x, real=0x%x \n",
ddp_get_module_name(module_list[i]),
mout,
DISP_REG_GET(mout_map[j].reg));
}
else if(DISP_REG_GET(mout_map[j].reg) != mout)
{
DDPDUMP("warning: %s mout expect=0x%x, real=0x%x \n",
ddp_get_module_name(module_list[i]),
mout,
DISP_REG_GET(mout_map[j].reg));
}
}
break;
}
}
}
// check out select
for(i = 0 ; i < module_num - 1 ; i++)
{
for(j = 0 ; j < DDP_SEL_OUT_NUM ; j++)
{
if(module_list[i] == sel_out_map[j].id)
{
//find next module which can be connected
step = i+1;
while(module_can_connect[module_list[step]].bit==0 && step<module_num)
{
step++;
}
ASSERT(step<module_num);
for(k = 0 ; k < 4 ; k++)
{
if(sel_out_map[j].id_bit_map[k] == -1)
break;
if(sel_out_map[j].id_bit_map[k] == module_list[step])
{
if(DISP_REG_GET(sel_out_map[j].reg) != k)
{
path_error += 1;
DDPDUMP("error:out_s %s not connect to %s, expect=0x%x, real=0x%x \n",
ddp_get_module_name(module_list[i]),ddp_get_module_name(module_list[step]),
k,
DISP_REG_GET(sel_out_map[j].reg));
}
break;
}
}
}
}
}
// check input select
for(i = 1 ; i < module_num ; i++)
{
for(j = 0 ; j < DDP_SEL_IN_NUM ; j++)
{
if(module_list[i] == sel_in_map[j].id)
{
//find next module which can be connected
step = i-1;
while(module_can_connect[module_list[step]].bit==0 && step>0)
{
step--;
}
ASSERT(step>=0);
for(k = 0 ; k < 4 ; k++)
{
if(sel_in_map[j].id_bit_map[k] == -1)
break;
if(sel_in_map[j].id_bit_map[k] == module_list[step])
{
if(DISP_REG_GET(sel_in_map[j].reg) != k)
{
path_error += 1;
DDPDUMP("error:in_s %s not connect to %s, expect=0x%x, real=0x%x \n",
ddp_get_module_name(module_list[step]),ddp_get_module_name(module_list[i]),
k,
DISP_REG_GET(sel_in_map[j].reg));
}
break;
}
}
}
}
}
if(path_error == 0)
{
DDPDUMP("path: %s to %s is connected\n",ddp_get_module_name(module_list[0]),
ddp_get_module_name(module_list[module_num - 1]));
}
else
{
DDPDUMP("path: %s to %s not connected!!!\n",ddp_get_module_name(module_list[0]),
ddp_get_module_name(module_list[module_num - 1]));
}
}
// config mout/msel to creat a compelte path
static void ddp_connect_path_l(int *module_list, void * handle)
{
unsigned int i, j, k;
int step=0;
unsigned int mout=0;
unsigned int reg_mout = 0;
unsigned int mout_idx = 0;
unsigned int module_num = ddp_get_module_num_l(module_list);
DDPDBG("connect_path: %s to %s\n",ddp_get_module_name(module_list[0]),
ddp_get_module_name(module_list[module_num-1]));
// connect mout
for(i = 0 ; i < module_num - 1 ; i++)
{
for(j = 0 ; j < DDP_MOUT_NUM ; j++)
{
if(module_list[i] == mout_map[j].id)
{
//find next module which can be connected
step = i+1;
while(module_can_connect[module_list[step]].bit==0 && step<module_num)
{
step++;
}
ASSERT(step<module_num);
mout = mout_map[j].reg_val;
for(k = 0 ; k < 5 ; k++)
{
if(mout_map[j].out_id_bit_map[k].m == -1)
break;
if(mout_map[j].out_id_bit_map[k].m == module_list[step])
{
mout |= mout_map[j].out_id_bit_map[k].v;
reg_mout |= mout;
mout_idx = j;
DDPDBG("connect mout %s to %s value 0x%x\n", ddp_get_module_name(module_list[i]),
ddp_get_module_name(module_list[step]),reg_mout);
break;
}
}
mout_map[j].reg_val = mout;
mout = 0;
}
}
if(reg_mout)
{
DISP_REG_SET(handle,mout_map[mout_idx].reg, reg_mout);
reg_mout = 0;
mout_idx = 0;
}
}
// connect out select
for(i = 0 ; i < module_num - 1 ; i++)
{
for(j = 0 ; j < DDP_SEL_OUT_NUM ; j++)
{
if(module_list[i] == sel_out_map[j].id)
{
step = i+1;
//find next module which can be connected
while(module_can_connect[module_list[step]].bit==0 && step<module_num)
{
step++;
}
ASSERT(step<module_num);
for(k = 0 ; k < 4 ; k++)
{
if(sel_out_map[j].id_bit_map[k] == -1)
break;
if(sel_out_map[j].id_bit_map[k] == module_list[step])
{
DDPDBG("connect out_s %s to %s, bits=0x%x\n", ddp_get_module_name(module_list[i]),
ddp_get_module_name(module_list[step]), k);
DISP_REG_SET(handle,sel_out_map[j].reg, (kal_uint16)k);
break;
}
}
}
}
}
// connect input select
for(i = 1 ; i < module_num ; i++)
{
for(j = 0 ; j < DDP_SEL_IN_NUM ; j++)
{
if(module_list[i] == sel_in_map[j].id)
{
step = i-1;
//find next module which can be connected
while(module_can_connect[module_list[step]].bit==0 && step>0)
{
step--;
}
ASSERT(step>=0);
for(k = 0 ; k < 4 ; k++)
{
if(sel_in_map[j].id_bit_map[k] == -1)
break;
if(sel_in_map[j].id_bit_map[k] == module_list[step])
{
DDPDBG("connect in_s %s to %s, bits=0x%x\n", ddp_get_module_name(module_list[step]),
ddp_get_module_name(module_list[i]), k);
DISP_REG_SET(handle,sel_in_map[j].reg, (kal_uint16)k);
break;
}
}
}
}
}
}
