예제 #1
0
파일: ddp_manager.c 프로젝트: SelfImp/m75
int  dpmgr_path_deinit(disp_path_handle dp_handle, int encmdq)
{
    int i=0;
    int module_name ;
    ASSERT(dp_handle != NULL);
    ddp_path_handle handle = (ddp_path_handle)dp_handle;
    int * modules = ddp_get_scenario_list(handle->scenario);
    int module_num = ddp_get_module_num(handle->scenario);
    cmdqRecHandle cmdqHandle = encmdq ? handle->cmdqhandle : NULL;
    DISP_LOG_I("path deinit on scenario %s\n",ddp_get_scenario_name(handle->scenario));
    ddp_mutex_Interrupt_disable(handle->hwmutexid,cmdqHandle);
    ddp_mutex_clear(handle->hwmutexid,cmdqHandle);
    ddp_disconnect_path(handle->scenario, cmdqHandle);
    for( i=0; i< module_num;i++)
    {
        module_name = modules[i];
        if(ddp_modules_driver[module_name] != 0)
        {
            if(ddp_modules_driver[module_name]->deinit!= 0)
            {
                DISP_LOG_I("scenario %s deinit module  %s\n",ddp_get_scenario_name(handle->scenario),
                    ddp_get_module_name(module_name));
                ddp_modules_driver[module_name]->deinit(module_name, cmdqHandle);
            }
            if(ddp_modules_driver[module_name]->set_listener!= 0)
            {
                ddp_modules_driver[module_name]->set_listener(module_name,NULL);
            }
        }
    }
    handle->power_sate = 0;
    //close top clock when last path init
    path_top_clock_off();
    return 0;
}
예제 #2
0
파일: ddp_manager.c 프로젝트: SelfImp/m75
disp_path_handle dpmgr_create_path(DDP_SCENARIO_ENUM scenario, cmdqRecHandle cmdq_handle)
{
    int i =0;
    int module_name ;
    ddp_path_handle path_handle = NULL;
    int * modules = ddp_get_scenario_list(scenario);
    int module_num = ddp_get_module_num(scenario);
    DDP_MANAGER_CONTEXT * content = _get_context();
    path_handle = kzalloc(sizeof(uint8_t*) * sizeof(ddp_path_handle_t), GFP_KERNEL);
    if (NULL != path_handle)
    {
        path_handle->cmdqhandle = cmdq_handle;
        path_handle->scenario = scenario;
        path_handle->hwmutexid = acquire_mutex(scenario);
        assign_default_irqs_table(scenario,path_handle->irq_event_map);
        DISP_LOG_I("create handle 0x%x on scenario %s\n",path_handle,ddp_get_scenario_name(scenario));
        for( i=0; i< module_num;i++)
        {
            module_name = modules[i];
            DISP_LOG_I(" scenario %s include module %s\n",ddp_get_scenario_name(scenario),ddp_get_module_name(module_name));
            content->module_usage_table[module_name]++;
            content->module_path_table[module_name] = path_handle;
        }
        content->handle_cnt ++;
        content->handle_pool[path_handle->hwmutexid] = path_handle;
    }
    else
    {
        DISP_LOG_E("Fail to create handle on scenario %s\n",ddp_get_scenario_name(scenario));
    }
    return path_handle;
}
예제 #3
0
파일: ddp_manager.c 프로젝트: SelfImp/m75
int dpmgr_path_reset(disp_path_handle dp_handle, int encmdq)
{
    int i=0;
    int ret = 0;
    int error = 0;
    int module_name ;
    ASSERT(dp_handle != NULL);
    ddp_path_handle handle = (ddp_path_handle)dp_handle;
    int * modules = ddp_get_scenario_list(handle->scenario);
    int module_num = ddp_get_module_num(handle->scenario);
    cmdqRecHandle cmdqHandle = encmdq ? handle->cmdqhandle : NULL;
    DISP_LOG_I("path reset on scenario %s\n",ddp_get_scenario_name(handle->scenario));
    /* first reset mutex */
    ddp_mutex_reset(handle->hwmutexid,cmdqHandle);

    for( i=0; i< module_num;i++)
    {
        module_name = modules[i];
        if(ddp_modules_driver[module_name] != 0)
        {
            if(ddp_modules_driver[module_name]->reset != 0)
            {
                DISP_LOG_I("scenario %s  reset module %s \n",ddp_get_scenario_name(handle->scenario),
                    ddp_get_module_name(module_name));
                ret = ddp_modules_driver[module_name]->reset(module_name, cmdqHandle);
                if(ret != 0)
                {
                    error++;
                }
            }
        }
    }
    return error > 0? -1: 0;
}
예제 #4
0
파일: ddp_manager.c 프로젝트: SelfImp/m75
int dpmgr_path_ioctl(disp_path_handle dp_handle, void * cmdq_handle, DDP_IOCTL_NAME ioctl_cmd, unsigned long *params)
{
	int i=0;
	int ret  = 0;
	int module_name ;
	ASSERT(dp_handle != NULL);
	ddp_path_handle handle = (ddp_path_handle)dp_handle;
	int * modules = ddp_get_scenario_list(handle->scenario);
	int module_num = ddp_get_module_num(handle->scenario);
	DISP_LOG_I("path IOCTL on scenario %s\n",ddp_get_scenario_name(handle->scenario));
	for( i=module_num-1; i >= 0  ;i--)
	{
	    module_name = modules[i];
	    if(ddp_modules_driver[module_name] != 0)
	    {
	        if(ddp_modules_driver[module_name]->ioctl!= 0)
	        {
	            printk("scenario %s, module %s ioctl\n",ddp_get_scenario_name(handle->scenario),
	                ddp_get_module_name(module_name));
	           ret += ddp_modules_driver[module_name]->ioctl(module_name, cmdq_handle, (unsigned int)ioctl_cmd, params);
	        }
	    }
	}
	return ret;
}
예제 #5
0
파일: ddp_manager.c 프로젝트: SelfImp/m75
int dpmgr_wait_event_timeout(disp_path_handle dp_handle, DISP_PATH_EVENT event, int timeout)
{
    int ret = -1;
    ASSERT(dp_handle != NULL);
    ddp_path_handle handle = (ddp_path_handle)dp_handle;
    DPMGR_WQ_HANDLE *wq_handle = & handle->wq_list[event];
    if(wq_handle->init)
    {
        DISP_LOG_V("wait event %s on scenario %s\n", path_event_name(event),ddp_get_scenario_name(handle->scenario));
        unsigned long long cur_time = sched_clock();
        ret = wait_event_interruptible_timeout(wq_handle->wq, cur_time < wq_handle->data,timeout);
        if(ret == 0)
        {
            DISP_LOG_E("wait %s timeout on scenario %s\n", path_event_name(event),ddp_get_scenario_name(handle->scenario));
        }
        else if(ret < 0)
        {
            DISP_LOG_E("wait %s interrupt by other timeleft %d on scenario %s\n", path_event_name(event),ret,ddp_get_scenario_name(handle->scenario));
        }
        else
        {
            DISP_LOG_V("received event %s timeleft %d on scenario %s\n", path_event_name(event), ret,ddp_get_scenario_name(handle->scenario));
        }
        return ret;
    }
    DISP_LOG_E("wait event %s not initialized on scenario %s\n", path_event_name(event),ddp_get_scenario_name(handle->scenario));
    return ret;
}
예제 #6
0
파일: ddp_manager.c 프로젝트: SelfImp/m75
int dpmgr_path_config(disp_path_handle dp_handle, disp_ddp_path_config * config, void * cmdq_handle)
{
    int i=0;
    int module_name ;
    ASSERT(dp_handle != NULL);
    ddp_path_handle handle = (ddp_path_handle)dp_handle;
    int * modules =  ddp_get_scenario_list(handle->scenario);
    int module_num = ddp_get_module_num(handle->scenario);
    DISP_LOG_V("path config ovl %d, rdma %d, wdma %d, dst %d on handle 0x%x scenario %s \n",
                config->ovl_dirty,
                config->rdma_dirty,
                config->wdma_dirty,
                config->dst_dirty,
                handle,
                ddp_get_scenario_name(handle->scenario));
	memcpy(&handle->last_config, config, sizeof(disp_ddp_path_config));
    for( i=0; i< module_num;i++)
    {
        module_name = modules[i];
        if(ddp_modules_driver[module_name] != 0)
        {
            if(ddp_modules_driver[module_name]->config!= 0)
            {
                DISP_LOG_V("scenario %s  config module %s \n",ddp_get_scenario_name(handle->scenario),
                   ddp_get_module_name(module_name));
                ddp_modules_driver[module_name]->config(module_name, config, cmdq_handle);
            }
        }
    }
    return 0;
}
예제 #7
0
파일: ddp_manager.c 프로젝트: SelfImp/m75
int dpmgr_path_stop(disp_path_handle dp_handle, int encmdq)
{

    int i=0;
    int module_name ;
    ASSERT(dp_handle != NULL);
    ddp_path_handle handle = (ddp_path_handle)dp_handle;
    int * modules = ddp_get_scenario_list(handle->scenario);
    int module_num = ddp_get_module_num(handle->scenario);
    cmdqRecHandle cmdqHandle = encmdq ? handle->cmdqhandle : NULL;
    DISP_LOG_V("path stop on scenario %s\n",ddp_get_scenario_name(handle->scenario));
    for( i=module_num-1; i>=0;i--)
    {
        module_name = modules[i];
        if(ddp_modules_driver[module_name] != 0)
        {
            if(ddp_modules_driver[module_name]->stop!= 0)
            {
                DISP_LOG_V("scenario %s  stop module %s \n",ddp_get_scenario_name(handle->scenario),
                    ddp_get_module_name(module_name));
                ddp_modules_driver[module_name]->stop(module_name, cmdqHandle);
            }
        }
    }
    return 0;
}
예제 #8
0
파일: ddp_manager.c 프로젝트: SelfImp/m75
int dpmgr_check_status(disp_path_handle dp_handle)
{
    int i =0;
    int module_name ;
    ASSERT(dp_handle != NULL);
    ddp_path_handle handle = (ddp_path_handle)dp_handle;
    int * modules = ddp_get_scenario_list(handle->scenario);
    int module_num = ddp_get_module_num(handle->scenario);
    DISP_LOG_I("check status on scenario %s\n",
                ddp_get_scenario_name(handle->scenario));
    ddp_check_path(handle->scenario);
    ddp_check_mutex(handle->hwmutexid,handle->scenario,
                    handle->mode);
    for( i=0; i< module_num;i++)
    {
        module_name = modules[i];
		if(ddp_modules_driver[module_name] != 0 && ddp_modules_driver[module_name]->dump_info!= 0)
        {
            ddp_modules_driver[module_name]->dump_info(module_name, 1);
        }
        else
        {
           ddp_dump_analysis(module_name);
           ddp_dump_reg(module_name);
        }
    }
    ddp_dump_analysis(DISP_MODULE_CONFIG);
    ddp_dump_reg(DISP_MODULE_CONFIG);

    ddp_dump_analysis(DISP_MODULE_MUTEX);
    ddp_dump_reg(DISP_MODULE_MUTEX);
    return 0;
}
예제 #9
0
파일: ddp_manager.c 프로젝트: SelfImp/m75
int dpmgr_destroy_path(disp_path_handle dp_handle)
{
    int i =0;
    int module_name ;
    ASSERT(dp_handle != NULL);
    ddp_path_handle handle = (ddp_path_handle)dp_handle;
    int * modules = ddp_get_scenario_list(handle->scenario);
    int module_num = ddp_get_module_num(handle->scenario);
    DDP_MANAGER_CONTEXT * content = _get_context();
    DISP_LOG_I("destroy path handle 0x%x on scenario %s\n",handle,ddp_get_scenario_name(handle->scenario));
    if(handle != NULL)
    {
         release_mutex(handle->hwmutexid);
         ddp_disconnect_path(handle->scenario,handle->cmdqhandle);
         for( i=0; i< module_num;i++)
         {
             module_name = modules[i];
             content->module_usage_table[module_name]--;
             content->module_path_table[module_name] = NULL;
         }
         content->handle_cnt --;
         ASSERT(content->handle_cnt >=0);
         content->handle_pool[handle->hwmutexid] = NULL;
         kfree(handle);
    }
    return 0;
}
예제 #10
0
void ddp_check_mutex(int mutex_id, DDP_SCENARIO_ENUM scenario, DDP_MODE mode)
{
     DDPDBG("check mutex %d on scenario %s\n",mutex_id, 
             ddp_get_scenario_name(scenario));
     ddp_check_mutex_l(mutex_id,module_list_scenario[scenario],mode);
     return ;
}
예제 #11
0
파일: ddp_manager.c 프로젝트: SelfImp/m75
int dpmgr_path_power_on(disp_path_handle dp_handle, CMDQ_SWITCH encmdq)
{
    int i=0;
    int module_name ;
    ASSERT(dp_handle != NULL);
    ddp_path_handle handle = (ddp_path_handle)dp_handle;
    int * modules = ddp_get_scenario_list(handle->scenario);
    int module_num = ddp_get_module_num(handle->scenario);
    DISP_LOG_I("path power on scenario %s\n",ddp_get_scenario_name(handle->scenario));
    path_top_clock_on();
    for( i=0; i< module_num;i++)
    {
        module_name = modules[i];
        if(ddp_modules_driver[module_name] != 0)
        {
            if(ddp_modules_driver[module_name]->power_on!= 0)
            {
                DISP_LOG_I("%s power on\n",ddp_get_module_name(module_name));
                ddp_modules_driver[module_name]->power_on(module_name, encmdq?handle->cmdqhandle:NULL); // now just 0;
            }
        }
    }
   //modules on this path will resume power on;
    handle->power_sate = 1;
    return 0;
}
예제 #12
0
파일: ddp_manager.c 프로젝트: SelfImp/m75
int dpmgr_path_trigger(disp_path_handle dp_handle, void *trigger_loop_handle, int encmdq)
{
    ASSERT(dp_handle != NULL);
    ddp_path_handle handle = (ddp_path_handle)dp_handle;
    DISP_LOG_V("dpmgr_path_trigger on scenario %s\n",ddp_get_scenario_name(handle->scenario));
    cmdqRecHandle cmdqHandle = encmdq ? handle->cmdqhandle : NULL;
    int i=0;
    int * modules = ddp_get_scenario_list(handle->scenario);
    int module_num = ddp_get_module_num(handle->scenario);
    int module_name ;
    ddp_mutex_enable(handle->hwmutexid,handle->scenario,trigger_loop_handle);
    for( i=0; i< module_num;i++)
    {
        module_name = modules[i];
        if(ddp_modules_driver[module_name] != 0)
        {
            if(ddp_modules_driver[module_name]->trigger!= 0)
            {
                DISP_LOG_V("%s trigger\n",ddp_get_module_name(module_name));
                ddp_modules_driver[module_name]->trigger(module_name, trigger_loop_handle);
            }
        }
    }
    return 0;
}
예제 #13
0
파일: ddp_manager.c 프로젝트: SelfImp/m75
int dpmgr_path_is_busy(disp_path_handle dp_handle)
{
    int i=0;
    int module_name ;
    ASSERT(dp_handle != NULL);
    ddp_path_handle handle = (ddp_path_handle)dp_handle;
    int * modules = ddp_get_scenario_list(handle->scenario);
    int module_num = ddp_get_module_num(handle->scenario);
    DISP_LOG_V("path check busy on scenario %s\n",ddp_get_scenario_name(handle->scenario));
    for( i=module_num-1; i>=0;i--)
    {
        module_name = modules[i];
        if(ddp_modules_driver[module_name] != 0)
        {
            if(ddp_modules_driver[module_name]->is_busy!= 0)
            {
                if(ddp_modules_driver[module_name]->is_busy(module_name))
                {
                    DISP_LOG_V("%s is busy\n", ddp_get_module_name(module_name));
                    return 1;
                }
            }
        }
    }
return 0;
}
예제 #14
0
파일: ddp_path.c 프로젝트: SelfImp/m75
void ddp_disconnect_path(DDP_SCENARIO_ENUM scenario,void * handle)
{
    DDPDBG("path disconnect on scenario %s\n", ddp_get_scenario_name(scenario));

    if(scenario == DDP_SCENARIO_PRIMARY_ALL)
    {
        ddp_disconnect_path_l(module_list_scenario[DDP_SCENARIO_PRIMARY_DISP], handle);
        ddp_disconnect_path_l(module_list_scenario[DDP_SCENARIO_PRIMARY_OVL_MEMOUT], handle);
    }
    else if(scenario == DDP_SCENARIO_SUB_ALL)
    {
        ddp_disconnect_path_l(module_list_scenario[DDP_SCENARIO_SUB_DISP], handle);
        ddp_disconnect_path_l(module_list_scenario[DDP_SCENARIO_SUB_OVL_MEMOUT], handle);
    }
    else if(scenario == DDP_SCENARIO_RDMA0_DUAL_DISP)
    {
        ddp_set_dst_module(scenario,DISP_MODULE_DSI0);
        ddp_disconnect_path_l(module_list_scenario[scenario], handle);
        ddp_set_dst_module(scenario,DISP_MODULE_DSI1);
        ddp_disconnect_path_l(module_list_scenario[scenario], handle);
        ddp_set_dst_module(scenario,DISP_MODULE_DSIDUAL);
    }    
    else
    {
        ddp_disconnect_path_l(module_list_scenario[scenario], handle);
    }
    return ;
}
예제 #15
0
파일: ddp_manager.c 프로젝트: SelfImp/m75
int dpmgr_path_flush(disp_path_handle dp_handle,int encmdq)
{
   ASSERT(dp_handle != NULL);
   ddp_path_handle handle = (ddp_path_handle)dp_handle;
   cmdqRecHandle cmdqHandle = encmdq ? handle->cmdqhandle : NULL;
   DISP_LOG_I("path flush on scenario %s\n",ddp_get_scenario_name(handle->scenario));
   return ddp_mutex_enable(handle->hwmutexid,handle->scenario,cmdqHandle);
}
예제 #16
0
파일: ddp_manager.c 프로젝트: SelfImp/m75
int  dpmgr_path_init(disp_path_handle dp_handle, int encmdq)
{
    int i=0;
    int module_name ;
    ASSERT(dp_handle != NULL);
    ddp_path_handle handle = (ddp_path_handle)dp_handle;
    int * modules = ddp_get_scenario_list(handle->scenario);
    int module_num = ddp_get_module_num(handle->scenario);
    cmdqRecHandle cmdqHandle = encmdq ? handle->cmdqhandle : NULL;
    DISP_LOG_I("path init on scenario %s\n",ddp_get_scenario_name(handle->scenario));
    //open top clock
    path_top_clock_on();
    //seting mutex
    ddp_mutex_set(handle->hwmutexid, handle->scenario, handle->mode, cmdqHandle);

	if(handle->hwmutexid != 0)
	{
		ddp_mutex_Interrupt_enable(handle->hwmutexid, cmdqHandle);
	}
	
    //connect path;
    ddp_connect_path(handle->scenario,cmdqHandle);

    // each module init
    for( i=0; i< module_num;i++)
    {
        module_name = modules[i];
        if(ddp_modules_driver[module_name] != 0)
        {
            if(ddp_modules_driver[module_name]->init!= 0)
            {
                 DISP_LOG_I("scenario %s init module  %s\n",ddp_get_scenario_name(handle->scenario),
                    ddp_get_module_name(module_name));
                 ddp_modules_driver[module_name]->init(module_name, cmdqHandle);
            }
            if(ddp_modules_driver[module_name]->set_listener!= 0)
            {
                ddp_modules_driver[module_name]->set_listener(module_name,dpmgr_module_notify);
            }
        }
    }
    //after init this path will power on;
    handle->power_sate = 1;
    return 0;
}
예제 #17
0
파일: ddp_manager.c 프로젝트: SelfImp/m75
int dpmgr_path_set_dst_module(disp_path_handle dp_handle,DISP_MODULE_ENUM dst_module)
{
    ASSERT(dp_handle != NULL);
    ddp_path_handle handle = (ddp_path_handle)dp_handle;
    ASSERT((handle->scenario >= 0  && handle->scenario < DDP_SCENARIO_MAX));
    DISP_LOG_I("set dst module on scenario %s, module %s\n",
          ddp_get_scenario_name(handle->scenario),ddp_get_module_name(dst_module));
    return ddp_set_dst_module(handle->scenario, dst_module);
}
예제 #18
0
파일: ddp_manager.c 프로젝트: SelfImp/m75
int dpmgr_path_set_video_mode(disp_path_handle dp_handle, int is_vdo_mode)
{
    ddp_path_handle handle = NULL;
    ASSERT(dp_handle != NULL);
    handle = (ddp_path_handle)dp_handle;
    handle->mode = is_vdo_mode ?  DDP_VIDEO_MODE : DDP_CMD_MODE;
    DISP_LOG_I("set scenario %s mode: %s\n",ddp_get_scenario_name(handle->scenario),
               is_vdo_mode ? "Video_Mode":"Cmd_Mode");
    return 0;
}
예제 #19
0
파일: ddp_manager.c 프로젝트: SelfImp/m75
int dpmgr_disable_event(disp_path_handle dp_handle, DISP_PATH_EVENT event)
{
    ASSERT(dp_handle != NULL);
    ddp_path_handle handle = (ddp_path_handle)dp_handle;
    DISP_LOG_I("disable event %s on scenario %s \n",path_event_name(event),ddp_get_scenario_name(handle->scenario));
	DPMGR_WQ_HANDLE *wq_handle = &handle->wq_list[event];
    wq_handle->init = 0;
    wq_handle->data= 0;
    return 0;
}
예제 #20
0
static void ddp_print_scenario(DDP_SCENARIO_ENUM scenario)
{
    int i =0;
    char path[512]={'\0'};
    int num = ddp_get_module_num(scenario);
    for(i=0; i< num; i++)
    {
        strcat(path,ddp_get_module_name(module_list_scenario[scenario][i]));
    }
    DDPMSG("scenario %s have modules: %s\n",ddp_get_scenario_name(scenario),path);
}
예제 #21
0
파일: ddp_manager.c 프로젝트: SelfImp/m75
int dpmgr_path_disconnect(disp_path_handle dp_handle, int encmdq)
{
    ASSERT(dp_handle != NULL);
    ddp_path_handle handle = (ddp_path_handle)dp_handle;
    cmdqRecHandle cmdqHandle = encmdq ? handle->cmdqhandle : NULL;
    DISP_LOG_I("dpmgr_path_disconnect on scenario %s\n",ddp_get_scenario_name(handle->scenario));
    ddp_mutex_clear(handle->hwmutexid,cmdqHandle);
    ddp_mutex_Interrupt_disable(handle->hwmutexid,cmdqHandle);
    ddp_disconnect_path(handle->scenario, cmdqHandle);
    return 0;
}
예제 #22
0
파일: ddp_path.c 프로젝트: djun/m463
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;
}
예제 #23
0
파일: ddp_manager.c 프로젝트: SelfImp/m75
int dpmgr_signal_event(disp_path_handle dp_handle, DISP_PATH_EVENT event)
{
    ASSERT(dp_handle != NULL);
    ddp_path_handle handle = (ddp_path_handle)dp_handle;
    DPMGR_WQ_HANDLE *wq_handle = &handle->wq_list[event];
    if(handle->wq_list[event].init)
    {
        wq_handle->data = sched_clock();
        DISP_LOG_V("wake up evnet %s on scenario %s\n", path_event_name(event),ddp_get_scenario_name(handle->scenario));
        wake_up_interruptible(&(handle->wq_list[event].wq));
    }
    return 0;
}
예제 #24
0
static int  ddp_find_module_index(DDP_SCENARIO_ENUM ddp_scenario, DISP_MODULE_ENUM module)
{
    int i=0;
    for(i=0; i< DDP_ENING_NUM; i++)
    {
        if(module_list_scenario[ddp_scenario][i] == module)
        {
            return i;
        }
    }
    DDPDBG("find module: can not find module %s on scenario %s\n",ddp_get_module_name(module), 
            ddp_get_scenario_name(ddp_scenario));
    return -1;
}
예제 #25
0
파일: ddp_manager.c 프로젝트: SelfImp/m75
int dpmgr_path_connect(disp_path_handle dp_handle, int encmdq)
{
    ASSERT(dp_handle != NULL);
    ddp_path_handle handle = (ddp_path_handle)dp_handle;
    cmdqRecHandle cmdqHandle = encmdq ? handle->cmdqhandle : NULL;
    DISP_LOG_I("dpmgr_path_connect on scenario %s\n",ddp_get_scenario_name(handle->scenario));

    ddp_connect_path(handle->scenario,cmdqHandle);
    ddp_mutex_set(handle->hwmutexid,
                         handle->scenario,
                         handle->mode,
                         cmdqHandle);
	if(handle->hwmutexid != 0)
	{
		ddp_mutex_Interrupt_enable(handle->hwmutexid,cmdqHandle);
	}
    return 0;
}
예제 #26
0
파일: ddp_manager.c 프로젝트: SelfImp/m75
int dpmgr_enable_event(disp_path_handle dp_handle, DISP_PATH_EVENT event)
{
    ASSERT(dp_handle != NULL);
    ddp_path_handle handle = (ddp_path_handle)dp_handle;
	DPMGR_WQ_HANDLE *wq_handle = &handle->wq_list[event];
    DISP_LOG_I("enable event %s on scenario %s, irtbit 0x%x\n",
         path_event_name(event),
         ddp_get_scenario_name(handle->scenario),
         handle->irq_event_map[event].irq_bit);
    if(!wq_handle->init)
    {
    	init_waitqueue_head(&(wq_handle->wq));
        wq_handle->init = 1;
        wq_handle->data= 0;
        wq_handle->event = event;
    }
    return 0;
}
예제 #27
0
void ddp_connect_path(DDP_SCENARIO_ENUM scenario, void * handle)
{
    DDPDBG("path connect on scenario %s\n", ddp_get_scenario_name(scenario));
    if(scenario == DDP_SCENARIO_PRIMARY_ALL)
    {
        ddp_connect_path_l(module_list_scenario[DDP_SCENARIO_PRIMARY_DISP], handle);
        ddp_connect_path_l(module_list_scenario[DDP_SCENARIO_PRIMARY_OVL_MEMOUT],handle);
    }
    else if(scenario == DDP_SCENARIO_SUB_ALL)
    {
        ddp_connect_path_l(module_list_scenario[DDP_SCENARIO_SUB_DISP], handle);
        ddp_connect_path_l(module_list_scenario[DDP_SCENARIO_SUB_OVL_MEMOUT], handle);
    }
    else
    {
        ddp_connect_path_l(module_list_scenario[scenario], handle);
    }
   return ;
}
예제 #28
0
void ddp_check_path(DDP_SCENARIO_ENUM scenario)
{
    DDPDBG("path check path on scenario %s\n", ddp_get_scenario_name(scenario));

    if(scenario == DDP_SCENARIO_PRIMARY_ALL)
    {
        ddp_check_path_l(module_list_scenario[DDP_SCENARIO_PRIMARY_DISP]);
        ddp_check_path_l(module_list_scenario[DDP_SCENARIO_PRIMARY_OVL_MEMOUT]);
    }
    else if(scenario == DDP_SCENARIO_SUB_ALL)
    {
        ddp_check_path_l(module_list_scenario[DDP_SCENARIO_SUB_DISP]);
        ddp_check_path_l(module_list_scenario[DDP_SCENARIO_SUB_OVL_MEMOUT]);
    }
    else
    {
        ddp_check_path_l(module_list_scenario[scenario]);
    }
    return ;
}
예제 #29
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;
}
예제 #30
0
파일: ddp_manager.c 프로젝트: SelfImp/m75
static int acquire_mutex(DDP_SCENARIO_ENUM scenario)
{
///: primay use mutex 0
    int mutex_id =0 ;
    DDP_MANAGER_CONTEXT * content = _get_context();
    int mutex_idx_free = content->mutex_idx;
    ASSERT(scenario >= 0  && scenario < DDP_SCENARIO_MAX);
    while(mutex_idx_free)
    {
        if(mutex_idx_free & 0x1)
        {
            content->mutex_idx &= (~(0x1<<mutex_id));
            mutex_id += DISP_MUTEX_DDP_FIRST;
            break;
        }
        mutex_idx_free>>=1;
        ++mutex_id;
    }
    ASSERT(mutex_id < (DISP_MUTEX_DDP_FIRST+DISP_MUTEX_DDP_COUNT));
    DISP_LOG_I("scenario %s acquire mutex %d , left mutex 0x%x!\n",
           ddp_get_scenario_name(scenario), mutex_id, content->mutex_idx);
    return mutex_id;
}