diff --git a/drivers/video/fbdev/msm/dsi_status_6g.c b/drivers/video/fbdev/msm/dsi_status_6g.c index 32807ccba58c..5b1125876833 100644 --- a/drivers/video/fbdev/msm/dsi_status_6g.c +++ b/drivers/video/fbdev/msm/dsi_status_6g.c @@ -172,8 +172,8 @@ void mdss_check_dsi_ctrl_status(struct work_struct *work, uint32_t interval) * display reset not to be proper. Hence, wait for DMA_P done * for command mode panels before triggering BTA. */ - if (ctl->wait_pingpong) - ctl->wait_pingpong(ctl, NULL); + if (ctl->ops.wait_pingpong) + ctl->ops.wait_pingpong(ctl, NULL); pr_debug("%s: DSI ctrl wait for ping pong done\n", __func__); diff --git a/drivers/video/fbdev/msm/mdss_mdp.h b/drivers/video/fbdev/msm/mdss_mdp.h index ee8693fc6d73..fa04ed447766 100644 --- a/drivers/video/fbdev/msm/mdss_mdp.h +++ b/drivers/video/fbdev/msm/mdss_mdp.h @@ -218,6 +218,23 @@ struct mdss_mdp_writeback { struct kref kref; }; +struct mdss_mdp_ctl_intfs_ops { + int (*start_fnc)(struct mdss_mdp_ctl *ctl); + int (*stop_fnc)(struct mdss_mdp_ctl *ctl, int panel_power_state); + int (*prepare_fnc)(struct mdss_mdp_ctl *ctl, void *arg); + int (*display_fnc)(struct mdss_mdp_ctl *ctl, void *arg); + int (*wait_fnc)(struct mdss_mdp_ctl *ctl, void *arg); + int (*wait_pingpong)(struct mdss_mdp_ctl *ctl, void *arg); + u32 (*read_line_cnt_fnc)(struct mdss_mdp_ctl *); + int (*add_vsync_handler)(struct mdss_mdp_ctl *, + struct mdss_mdp_vsync_handler *); + int (*remove_vsync_handler)(struct mdss_mdp_ctl *, + struct mdss_mdp_vsync_handler *); + int (*config_fps_fnc)(struct mdss_mdp_ctl *ctl, + struct mdss_mdp_ctl *sctl, int new_fps); + int (*restore_fnc)(struct mdss_mdp_ctl *ctl); +}; + struct mdss_mdp_ctl { u32 num; char __iomem *base; @@ -288,20 +305,7 @@ struct mdss_mdp_ctl { struct mdss_mdp_writeback *wb; - int (*start_fnc) (struct mdss_mdp_ctl *ctl); - int (*stop_fnc) (struct mdss_mdp_ctl *ctl, int panel_power_state); - int (*prepare_fnc) (struct mdss_mdp_ctl *ctl, void *arg); - int (*display_fnc) (struct mdss_mdp_ctl *ctl, void *arg); - int (*wait_fnc) (struct mdss_mdp_ctl *ctl, void *arg); - int (*wait_pingpong) (struct mdss_mdp_ctl *ctl, void *arg); - u32 (*read_line_cnt_fnc) (struct mdss_mdp_ctl *); - int (*add_vsync_handler) (struct mdss_mdp_ctl *, - struct mdss_mdp_vsync_handler *); - int (*remove_vsync_handler) (struct mdss_mdp_ctl *, - struct mdss_mdp_vsync_handler *); - int (*config_fps_fnc) (struct mdss_mdp_ctl *ctl, - struct mdss_mdp_ctl *sctl, int new_fps); - int (*restore_fnc) (struct mdss_mdp_ctl *ctl); + struct mdss_mdp_ctl_intfs_ops ops; }; struct mdss_mdp_mixer { diff --git a/drivers/video/fbdev/msm/mdss_mdp_ctl.c b/drivers/video/fbdev/msm/mdss_mdp_ctl.c index da4bc4254608..32cbc3dbf1a3 100644 --- a/drivers/video/fbdev/msm/mdss_mdp_ctl.c +++ b/drivers/video/fbdev/msm/mdss_mdp_ctl.c @@ -1741,16 +1741,7 @@ int mdss_mdp_ctl_free(struct mdss_mdp_ctl *ctl) ctl->intf_type = MDSS_MDP_NO_INTF; ctl->is_secure = false; ctl->power_state = MDSS_PANEL_POWER_OFF; - ctl->start_fnc = NULL; - ctl->stop_fnc = NULL; - ctl->prepare_fnc = NULL; - ctl->display_fnc = NULL; - ctl->wait_fnc = NULL; - ctl->read_line_cnt_fnc = NULL; - ctl->add_vsync_handler = NULL; - ctl->remove_vsync_handler = NULL; - ctl->config_fps_fnc = NULL; - ctl->panel_data = NULL; + memset(&ctl->ops, 0, sizeof(ctl->ops)); mutex_unlock(&mdss_mdp_ctl_lock); return 0; @@ -1941,14 +1932,14 @@ struct mdss_mdp_mixer *mdss_mdp_block_mixer_alloc(void) ctl->mixer_left = mixer; - ctl->start_fnc = mdss_mdp_writeback_start; + ctl->ops.start_fnc = mdss_mdp_writeback_start; ctl->power_state = MDSS_PANEL_POWER_ON; ctl->wb_type = MDSS_MDP_WB_CTL_TYPE_BLOCK; mixer->ctl = ctl; ctl->wb = wb; - if (ctl->start_fnc) - ctl->start_fnc(ctl); + if (ctl->ops.start_fnc) + ctl->ops.start_fnc(ctl); return mixer; error: @@ -1976,8 +1967,8 @@ int mdss_mdp_block_mixer_destroy(struct mdss_mdp_mixer *mixer) pr_debug("destroy ctl=%d mixer=%d\n", ctl->num, mixer->num); - if (ctl->stop_fnc) - ctl->stop_fnc(ctl, MDSS_PANEL_POWER_OFF); + if (ctl->ops.stop_fnc) + ctl->ops.stop_fnc(ctl, MDSS_PANEL_POWER_OFF); mdss_mdp_ctl_free(ctl); @@ -2250,7 +2241,7 @@ struct mdss_mdp_ctl *mdss_mdp_ctl_init(struct mdss_panel_data *pdata, ctl->intf_num = MDSS_MDP_INTF0; ctl->intf_type = MDSS_INTF_EDP; ctl->opmode = MDSS_MDP_CTL_OP_VIDEO_MODE; - ctl->start_fnc = mdss_mdp_video_start; + ctl->ops.start_fnc = mdss_mdp_video_start; break; case MIPI_VIDEO_PANEL: ctl->is_video_mode = true; @@ -2262,7 +2253,7 @@ struct mdss_mdp_ctl *mdss_mdp_ctl_init(struct mdss_panel_data *pdata, MDSS_MDP_INTF2; ctl->intf_type = MDSS_INTF_DSI; ctl->opmode = MDSS_MDP_CTL_OP_VIDEO_MODE; - ctl->start_fnc = mdss_mdp_video_start; + ctl->ops.start_fnc = mdss_mdp_video_start; break; case MIPI_CMD_PANEL: if (pdata->panel_info.pdest == DISPLAY_1) @@ -2273,21 +2264,21 @@ struct mdss_mdp_ctl *mdss_mdp_ctl_init(struct mdss_panel_data *pdata, MDSS_MDP_INTF2; ctl->intf_type = MDSS_INTF_DSI; ctl->opmode = MDSS_MDP_CTL_OP_CMD_MODE; - ctl->start_fnc = mdss_mdp_cmd_start; + ctl->ops.start_fnc = mdss_mdp_cmd_start; break; case DTV_PANEL: ctl->is_video_mode = true; ctl->intf_num = MDSS_MDP_INTF3; ctl->intf_type = MDSS_INTF_HDMI; ctl->opmode = MDSS_MDP_CTL_OP_VIDEO_MODE; - ctl->start_fnc = mdss_mdp_video_start; + ctl->ops.start_fnc = mdss_mdp_video_start; ret = mdss_mdp_limited_lut_igc_config(ctl); if (ret) pr_err("Unable to config IGC LUT data\n"); break; case WRITEBACK_PANEL: ctl->intf_num = MDSS_MDP_NO_INTF; - ctl->start_fnc = mdss_mdp_writeback_start; + ctl->ops.start_fnc = mdss_mdp_writeback_start; break; default: pr_err("unsupported panel type (%d)\n", pdata->panel_info.type); @@ -2550,8 +2541,8 @@ void mdss_mdp_ctl_restore(void) mdss_mdp_ctl_restore_sub(sctl); mdss_mdp_ctl_split_display_enable(1, ctl, sctl); } - if (ctl->restore_fnc) - ctl->restore_fnc(ctl); + if (ctl->ops.restore_fnc) + ctl->ops.restore_fnc(ctl); } mdss_mdp_clk_ctrl(MDP_BLOCK_POWER_OFF); } @@ -2571,8 +2562,8 @@ static int mdss_mdp_ctl_start_sub(struct mdss_mdp_ctl *ctl, bool handoff) * (2) continuous splash finished. */ if (handoff || !ctl->panel_data->panel_info.cont_splash_enabled) { - if (ctl->start_fnc) - ret = ctl->start_fnc(ctl); + if (ctl->ops.start_fnc) + ret = ctl->ops.start_fnc(ctl); else pr_warn("no start function for ctl=%d type=%d\n", ctl->num, @@ -2716,8 +2707,8 @@ int mdss_mdp_ctl_stop(struct mdss_mdp_ctl *ctl, int power_state) mdss_mdp_hist_intr_setup(&mdata->hist_intr, MDSS_IRQ_SUSPEND); - if (ctl->stop_fnc) { - ret = ctl->stop_fnc(ctl, power_state); + if (ctl->ops.stop_fnc) { + ret = ctl->ops.stop_fnc(ctl, power_state); if (ctl->panel_data->panel_info.fbc.enabled) mdss_mdp_ctl_fbc_enable(0, ctl->mixer_left, &ctl->panel_data->panel_info); @@ -2725,8 +2716,8 @@ int mdss_mdp_ctl_stop(struct mdss_mdp_ctl *ctl, int power_state) pr_warn("no stop func for ctl=%d\n", ctl->num); } - if (sctl && sctl->stop_fnc) { - ret = sctl->stop_fnc(sctl, power_state); + if (sctl && sctl->ops.stop_fnc) { + ret = sctl->ops.stop_fnc(sctl, power_state); if (ctl->panel_data->panel_info.fbc.enabled) mdss_mdp_ctl_fbc_enable(0, sctl->mixer_left, &sctl->panel_data->panel_info); @@ -3421,8 +3412,8 @@ int mdss_mdp_ctl_update_fps(struct mdss_mdp_ctl *ctl, int fps) sctl = mdss_mdp_get_split_ctl(ctl); - if (ctl->config_fps_fnc) - ret = ctl->config_fps_fnc(ctl, sctl, fps); + if (ctl->ops.config_fps_fnc) + ret = ctl->ops.config_fps_fnc(ctl, sctl, fps); return ret; } @@ -3436,7 +3427,7 @@ int mdss_mdp_display_wakeup_time(struct mdss_mdp_ctl *ctl, u32 time_of_line, time_to_vsync; ktime_t current_time = ktime_get(); - if (!ctl->read_line_cnt_fnc) + if (!ctl->ops.read_line_cnt_fnc) return -ENOSYS; pinfo = &ctl->panel_data->panel_info; @@ -3467,7 +3458,7 @@ int mdss_mdp_display_wakeup_time(struct mdss_mdp_ctl *ctl, if (!time_of_line) return -EINVAL; - current_line = ctl->read_line_cnt_fnc(ctl); + current_line = ctl->ops.read_line_cnt_fnc(ctl); total_line = pinfo->lcdc.v_back_porch + pinfo->lcdc.v_front_porch + @@ -3513,8 +3504,8 @@ int mdss_mdp_display_wait4comp(struct mdss_mdp_ctl *ctl) } ATRACE_BEGIN("wait_fnc"); - if (ctl->wait_fnc) - ret = ctl->wait_fnc(ctl, NULL); + if (ctl->ops.wait_fnc) + ret = ctl->ops.wait_fnc(ctl, NULL); ATRACE_END("wait_fnc"); trace_mdp_commit(ctl); @@ -3551,21 +3542,21 @@ int mdss_mdp_display_wait4pingpong(struct mdss_mdp_ctl *ctl, bool use_lock) return ret; } - if (!mdss_mdp_ctl_is_power_on(ctl) || !ctl->wait_pingpong) { + if (!mdss_mdp_ctl_is_power_on(ctl) || !ctl->ops.wait_pingpong) { if (use_lock) mutex_unlock(&ctl->lock); return 0; } ATRACE_BEGIN("wait_pingpong"); - ctl->wait_pingpong(ctl, NULL); + ctl->ops.wait_pingpong(ctl, NULL); ATRACE_END("wait_pingpong"); sctl = mdss_mdp_get_split_ctl(ctl); - if (sctl && sctl->wait_pingpong) { + if (sctl && sctl->ops.wait_pingpong) { ATRACE_BEGIN("wait_pingpong sctl"); - sctl->wait_pingpong(sctl, NULL); + sctl->ops.wait_pingpong(sctl, NULL); ATRACE_END("wait_pingpong sctl"); } @@ -3624,8 +3615,8 @@ int mdss_mdp_display_commit(struct mdss_mdp_ctl *ctl, void *arg, (ctl->mixer_left && ctl->mixer_left->params_changed) || (ctl->mixer_right && ctl->mixer_right->params_changed)) { ATRACE_BEGIN("prepare_fnc"); - if (ctl->prepare_fnc) - ret = ctl->prepare_fnc(ctl, arg); + if (ctl->ops.prepare_fnc) + ret = ctl->ops.prepare_fnc(ctl, arg); ATRACE_END("prepare_fnc"); if (ret) { pr_err("error preparing display\n"); @@ -3694,7 +3685,7 @@ int mdss_mdp_display_commit(struct mdss_mdp_ctl *ctl, void *arg, mdss_mdp_ctl_notify(ctl, MDP_NOTIFY_FRAME_READY); ATRACE_END("frame_ready"); - if (ctl->wait_pingpong && !mdata->serialize_wait4pp) + if (ctl->ops.wait_pingpong && !mdata->serialize_wait4pp) mdss_mdp_display_wait4pingpong(ctl, false); if (commit_cb) @@ -3721,11 +3712,11 @@ int mdss_mdp_display_commit(struct mdss_mdp_ctl *ctl, void *arg, * Seperate kickoff on DSI1 is needed only when we have * ONLY right half updating on a dual DSI panel */ - if (sctl->display_fnc) - ret = sctl->display_fnc(sctl, arg); /* DSI1 kickoff */ + if (sctl->ops.display_fnc) + ret = sctl->ops.display_fnc(sctl, arg); } else { - if (ctl->display_fnc) - ret = ctl->display_fnc(ctl, arg); /* DSI0 kickoff */ + if (ctl->ops.display_fnc) + ret = ctl->ops.display_fnc(ctl, arg); /* DSI0 kickoff */ } if (sctl) diff --git a/drivers/video/fbdev/msm/mdss_mdp_intf_cmd.c b/drivers/video/fbdev/msm/mdss_mdp_intf_cmd.c index d9dff5dacc5d..fafe032e5c62 100644 --- a/drivers/video/fbdev/msm/mdss_mdp_intf_cmd.c +++ b/drivers/video/fbdev/msm/mdss_mdp_intf_cmd.c @@ -1216,11 +1216,11 @@ panel_events: pr_debug("%s: turn off panel\n", __func__); ctl->priv_data = NULL; - ctl->stop_fnc = NULL; - ctl->display_fnc = NULL; - ctl->wait_pingpong = NULL; - ctl->add_vsync_handler = NULL; - ctl->remove_vsync_handler = NULL; + ctl->ops.stop_fnc = NULL; + ctl->ops.display_fnc = NULL; + ctl->ops.wait_pingpong = NULL; + ctl->ops.add_vsync_handler = NULL; + ctl->ops.remove_vsync_handler = NULL; end: if (!IS_ERR_VALUE(ret)) @@ -1342,13 +1342,13 @@ int mdss_mdp_cmd_start(struct mdss_mdp_ctl *ctl) return ret; } - ctl->stop_fnc = mdss_mdp_cmd_stop; - ctl->display_fnc = mdss_mdp_cmd_kickoff; - ctl->wait_pingpong = mdss_mdp_cmd_wait4pingpong; - ctl->add_vsync_handler = mdss_mdp_cmd_add_vsync_handler; - ctl->remove_vsync_handler = mdss_mdp_cmd_remove_vsync_handler; - ctl->read_line_cnt_fnc = mdss_mdp_cmd_line_count; - ctl->restore_fnc = mdss_mdp_cmd_restore; + ctl->ops.stop_fnc = mdss_mdp_cmd_stop; + ctl->ops.display_fnc = mdss_mdp_cmd_kickoff; + ctl->ops.wait_pingpong = mdss_mdp_cmd_wait4pingpong; + ctl->ops.add_vsync_handler = mdss_mdp_cmd_add_vsync_handler; + ctl->ops.remove_vsync_handler = mdss_mdp_cmd_remove_vsync_handler; + ctl->ops.read_line_cnt_fnc = mdss_mdp_cmd_line_count; + ctl->ops.restore_fnc = mdss_mdp_cmd_restore; pr_debug("%s:-\n", __func__); return 0; diff --git a/drivers/video/fbdev/msm/mdss_mdp_intf_video.c b/drivers/video/fbdev/msm/mdss_mdp_intf_video.c index 5cf55f70fe40..d3e0c0d48a67 100644 --- a/drivers/video/fbdev/msm/mdss_mdp_intf_video.c +++ b/drivers/video/fbdev/msm/mdss_mdp_intf_video.c @@ -638,13 +638,13 @@ static void recover_underrun_work(struct work_struct *work) struct mdss_mdp_ctl *ctl = container_of(work, typeof(*ctl), recover_work); - if (!ctl || !ctl->add_vsync_handler) { + if (!ctl || !ctl->ops.add_vsync_handler) { pr_err("ctl or vsync handler is NULL\n"); return; } mdss_mdp_clk_ctrl(MDP_BLOCK_POWER_ON); - ctl->add_vsync_handler(ctl, &ctl->recover_underrun_handler); + ctl->ops.add_vsync_handler(ctl, &ctl->recover_underrun_handler); mdss_mdp_clk_ctrl(MDP_BLOCK_POWER_OFF); } @@ -1361,13 +1361,13 @@ int mdss_mdp_video_start(struct mdss_mdp_ctl *ctl) return ret; } - ctl->stop_fnc = mdss_mdp_video_stop; - ctl->display_fnc = mdss_mdp_video_display; - ctl->wait_fnc = mdss_mdp_video_wait4comp; - ctl->read_line_cnt_fnc = mdss_mdp_video_line_count; - ctl->add_vsync_handler = mdss_mdp_video_add_vsync_handler; - ctl->remove_vsync_handler = mdss_mdp_video_remove_vsync_handler; - ctl->config_fps_fnc = mdss_mdp_video_config_fps; + ctl->ops.stop_fnc = mdss_mdp_video_stop; + ctl->ops.display_fnc = mdss_mdp_video_display; + ctl->ops.wait_fnc = mdss_mdp_video_wait4comp; + ctl->ops.read_line_cnt_fnc = mdss_mdp_video_line_count; + ctl->ops.add_vsync_handler = mdss_mdp_video_add_vsync_handler; + ctl->ops.remove_vsync_handler = mdss_mdp_video_remove_vsync_handler; + ctl->ops.config_fps_fnc = mdss_mdp_video_config_fps; return 0; } diff --git a/drivers/video/fbdev/msm/mdss_mdp_intf_writeback.c b/drivers/video/fbdev/msm/mdss_mdp_intf_writeback.c index 3bf82ff13ae4..f55bb9fc2f09 100644 --- a/drivers/video/fbdev/msm/mdss_mdp_intf_writeback.c +++ b/drivers/video/fbdev/msm/mdss_mdp_intf_writeback.c @@ -847,9 +847,9 @@ int mdss_mdp_writeback_start(struct mdss_mdp_ctl *ctl) INIT_LIST_HEAD(&ctx->vsync_handlers); if (ctx->type == MDSS_MDP_WRITEBACK_TYPE_ROTATOR) - ctl->prepare_fnc = mdss_mdp_writeback_prepare_rot; + ctl->ops.prepare_fnc = mdss_mdp_writeback_prepare_rot; else { /* wfd or line mode */ - ctl->prepare_fnc = mdss_mdp_writeback_prepare_wfd; + ctl->ops.prepare_fnc = mdss_mdp_writeback_prepare_wfd; /* WB2 Intr Enable is BIT(2) in MDSS 1.8.0 */ if (ctl->mdata->mdp_rev == MDSS_MDP_HW_REV_108) { @@ -857,11 +857,11 @@ int mdss_mdp_writeback_start(struct mdss_mdp_ctl *ctl) ctx->intf_num = 2; } } - ctl->stop_fnc = mdss_mdp_writeback_stop; - ctl->display_fnc = mdss_mdp_writeback_display; - ctl->wait_fnc = mdss_mdp_wb_wait4comp; - ctl->add_vsync_handler = mdss_mdp_wb_add_vsync_handler; - ctl->remove_vsync_handler = mdss_mdp_wb_remove_vsync_handler; + ctl->ops.stop_fnc = mdss_mdp_writeback_stop; + ctl->ops.display_fnc = mdss_mdp_writeback_display; + ctl->ops.wait_fnc = mdss_mdp_wb_wait4comp; + ctl->ops.add_vsync_handler = mdss_mdp_wb_add_vsync_handler; + ctl->ops.remove_vsync_handler = mdss_mdp_wb_remove_vsync_handler; ctx->is_vbif_nrt = mdss_mdp_is_vbif_nrt(ctl->mdata->mdp_rev); diff --git a/drivers/video/fbdev/msm/mdss_mdp_layer.c b/drivers/video/fbdev/msm/mdss_mdp_layer.c index 2a31123bb8eb..0558e8b7a9e1 100644 --- a/drivers/video/fbdev/msm/mdss_mdp_layer.c +++ b/drivers/video/fbdev/msm/mdss_mdp_layer.c @@ -547,7 +547,7 @@ static struct sync_fence *__create_fence(struct msm_fb_data_type *mfd, mdp5_data = mfd_to_mdp5_data(mfd); ctl = mdp5_data->ctl; - if (!ctl->add_vsync_handler) { + if (!ctl->ops.add_vsync_handler) { pr_err("fb%d vsync pending first update\n", mfd->index); return ERR_PTR(-EOPNOTSUPP); } diff --git a/drivers/video/fbdev/msm/mdss_mdp_overlay.c b/drivers/video/fbdev/msm/mdss_mdp_overlay.c index 7b0279e104d4..7d71cbda85ff 100644 --- a/drivers/video/fbdev/msm/mdss_mdp_overlay.c +++ b/drivers/video/fbdev/msm/mdss_mdp_overlay.c @@ -1652,7 +1652,7 @@ int mdss_mdp_overlay_kickoff(struct msm_fb_data_type *mfd, mdss_mdp_set_roi(ctl, &temp_data); } - if (ctl->wait_pingpong && mdp5_data->mdata->serialize_wait4pp) + if (ctl->ops.wait_pingpong && mdp5_data->mdata->serialize_wait4pp) mdss_mdp_display_wait4pingpong(ctl, true); /* @@ -2220,13 +2220,13 @@ static void remove_underrun_vsync_handler(struct work_struct *work) struct mdss_mdp_ctl *ctl = container_of(work, typeof(*ctl), remove_underrun_handler); - if (!ctl || !ctl->remove_vsync_handler) { + if (!ctl || !ctl->ops.remove_vsync_handler) { pr_err("ctl or vsync handler is NULL\n"); return; } mdss_mdp_clk_ctrl(MDP_BLOCK_POWER_ON); - rc = ctl->remove_vsync_handler(ctl, + rc = ctl->ops.remove_vsync_handler(ctl, &ctl->recover_underrun_handler); mdss_mdp_clk_ctrl(MDP_BLOCK_POWER_OFF); } @@ -2280,7 +2280,7 @@ int mdss_mdp_overlay_vsync_ctrl(struct msm_fb_data_type *mfd, int en) if (!ctl) return -ENODEV; - if (!ctl->add_vsync_handler || !ctl->remove_vsync_handler) + if (!ctl->ops.add_vsync_handler || !ctl->ops.remove_vsync_handler) return -EOPNOTSUPP; if (!ctl->panel_data->panel_info.cont_splash_enabled && !mdss_mdp_ctl_is_power_on(ctl)) { @@ -2293,9 +2293,9 @@ int mdss_mdp_overlay_vsync_ctrl(struct msm_fb_data_type *mfd, int en) mdss_mdp_clk_ctrl(MDP_BLOCK_POWER_ON); if (en) - rc = ctl->add_vsync_handler(ctl, &ctl->vsync_handler); + rc = ctl->ops.add_vsync_handler(ctl, &ctl->vsync_handler); else - rc = ctl->remove_vsync_handler(ctl, &ctl->vsync_handler); + rc = ctl->ops.remove_vsync_handler(ctl, &ctl->vsync_handler); mdss_mdp_clk_ctrl(MDP_BLOCK_POWER_OFF); return rc; @@ -4341,7 +4341,7 @@ static void __vsync_retire_work_handler(struct work_struct *work) if (!mdp5_data->ctl || !mdp5_data->ctl->mfd) return; - if (!mdp5_data->ctl->remove_vsync_handler) + if (!mdp5_data->ctl->ops.remove_vsync_handler) return; __vsync_retire_signal(mdp5_data->ctl->mfd, 1); @@ -4358,7 +4358,7 @@ static void __vsync_retire_signal(struct msm_fb_data_type *mfd, int val) mdp5_data->retire_cnt -= min(val, mdp5_data->retire_cnt); if (mdp5_data->retire_cnt == 0) { mdss_mdp_clk_ctrl(MDP_BLOCK_POWER_ON); - mdp5_data->ctl->remove_vsync_handler(mdp5_data->ctl, + mdp5_data->ctl->ops.remove_vsync_handler(mdp5_data->ctl, &mdp5_data->vsync_retire_handler); mdss_mdp_clk_ctrl(MDP_BLOCK_POWER_OFF); } @@ -4381,7 +4381,7 @@ __vsync_retire_get_fence(struct msm_sync_pt_data *sync_pt_data) return ERR_PTR(-ENODEV); ctl = mdp5_data->ctl; - if (!ctl->add_vsync_handler) + if (!ctl->ops.add_vsync_handler) return ERR_PTR(-EOPNOTSUPP); if (!mdss_mdp_ctl_is_power_on(ctl)) { @@ -4407,7 +4407,7 @@ static int __vsync_set_vsync_handler(struct msm_fb_data_type *mfd) mdp5_data->vsync_retire_handler.enabled) return 0; - if (!ctl->add_vsync_handler) + if (!ctl->ops.add_vsync_handler) return -EOPNOTSUPP; if (!mdss_mdp_ctl_is_power_on(ctl)) { @@ -4415,7 +4415,7 @@ static int __vsync_set_vsync_handler(struct msm_fb_data_type *mfd) return -EPERM; } - rc = ctl->add_vsync_handler(ctl, + rc = ctl->ops.add_vsync_handler(ctl, &mdp5_data->vsync_retire_handler); return rc; } diff --git a/drivers/video/fbdev/msm/mdss_mdp_pp.c b/drivers/video/fbdev/msm/mdss_mdp_pp.c index ff2d7a097d43..58c0fcbbb14a 100644 --- a/drivers/video/fbdev/msm/mdss_mdp_pp.c +++ b/drivers/video/fbdev/msm/mdss_mdp_pp.c @@ -2120,7 +2120,7 @@ int mdss_mdp_pp_resume(struct mdss_mdp_ctl *ctl, u32 dspp_num) pp_ad_input_write(&mdata->ad_off[dspp_num], ad); } if ((PP_AD_STATE_VSYNC & ad->state) && ad->calc_itr) - ctl->add_vsync_handler(ctl, &ad->handle); + ctl->ops.add_vsync_handler(ctl, &ad->handle); mutex_unlock(&ad->lock); } @@ -5464,11 +5464,11 @@ static int mdss_mdp_ad_setup(struct msm_fb_data_type *mfd) ad->sts &= ~PP_AD_STS_DIRTY_VSYNC; if (!(PP_AD_STATE_VSYNC & ad->state) && ad->calc_itr && (ad->state & PP_AD_STATE_RUN)) { - ctl->add_vsync_handler(ctl, &ad->handle); + ctl->ops.add_vsync_handler(ctl, &ad->handle); ad->state |= PP_AD_STATE_VSYNC; } else if ((PP_AD_STATE_VSYNC & ad->state) && (!ad->calc_itr || !(PP_AD_STATE_RUN & ad->state))) { - ctl->remove_vsync_handler(ctl, &ad->handle); + ctl->ops.remove_vsync_handler(ctl, &ad->handle); ad->state &= ~PP_AD_STATE_VSYNC; } } @@ -5548,7 +5548,7 @@ static void pp_ad_calc_worker(struct work_struct *work) if (!ad->calc_itr) { ad->state &= ~PP_AD_STATE_VSYNC; - ctl->remove_vsync_handler(ctl, &ad->handle); + ctl->ops.remove_vsync_handler(ctl, &ad->handle); } mutex_unlock(&ad->lock); /* dspp3 doesn't have ad attached to it so following is safe */ diff --git a/drivers/video/fbdev/msm/mdss_mdp_wfd.c b/drivers/video/fbdev/msm/mdss_mdp_wfd.c index a8e727a3701a..fc29c813afd5 100644 --- a/drivers/video/fbdev/msm/mdss_mdp_wfd.c +++ b/drivers/video/fbdev/msm/mdss_mdp_wfd.c @@ -83,8 +83,8 @@ void mdss_mdp_wfd_destroy(struct mdss_mdp_wfd *wfd) if (!ctl) return; - if (ctl->stop_fnc) - ctl->stop_fnc(ctl, 0); + if (ctl->ops.stop_fnc) + ctl->ops.stop_fnc(ctl, 0); if (ctl->wb) mdss_mdp_wb_free(ctl->wb); @@ -199,8 +199,8 @@ int mdss_mdp_wfd_setup(struct mdss_mdp_wfd *wfd, mixer->roi = (struct mdss_rect) {0, 0, mixer->width, mixer->height}; mixer->ctl = ctl; - if (ctl->start_fnc) { - ret = ctl->start_fnc(ctl); + if (ctl->ops.start_fnc) { + ret = ctl->ops.start_fnc(ctl); if (ret) { pr_err("wfd start failed %d\n", ret); goto wfd_setup_error; diff --git a/drivers/video/fbdev/msm/mdss_rotator.c b/drivers/video/fbdev/msm/mdss_rotator.c index b36ed2409682..d4221bd723a7 100644 --- a/drivers/video/fbdev/msm/mdss_rotator.c +++ b/drivers/video/fbdev/msm/mdss_rotator.c @@ -358,13 +358,13 @@ static struct mdss_rot_hw_resource *mdss_rotator_hw_alloc( goto error; } - hw->ctl->start_fnc = mdss_mdp_writeback_start; + hw->ctl->ops.start_fnc = mdss_mdp_writeback_start; hw->ctl->power_state = MDSS_PANEL_POWER_ON; hw->ctl->wb_type = MDSS_MDP_WB_CTL_TYPE_BLOCK; - if (hw->ctl->start_fnc) - ret = hw->ctl->start_fnc(hw->ctl); + if (hw->ctl->ops.start_fnc) + ret = hw->ctl->ops.start_fnc(hw->ctl); if (ret) goto error; @@ -389,8 +389,8 @@ error: if (!IS_ERR_OR_NULL(hw->pipe)) mdss_mdp_pipe_destroy(hw->pipe); if (!IS_ERR_OR_NULL(hw->ctl)) { - if (hw->ctl->stop_fnc) - hw->ctl->stop_fnc(hw->ctl, MDSS_PANEL_POWER_OFF); + if (hw->ctl->ops.stop_fnc) + hw->ctl->ops.stop_fnc(hw->ctl, MDSS_PANEL_POWER_OFF); mdss_mdp_ctl_free(hw->ctl); } devm_kfree(&mgr->pdev->dev, hw); @@ -411,8 +411,8 @@ static void mdss_rotator_free_hw(struct mdss_rot_mgr *mgr, ctl = mdss_mdp_ctl_mixer_switch(mixer->ctl, MDSS_MDP_WB_CTL_TYPE_BLOCK); if (ctl) { - if (ctl->stop_fnc) - ctl->stop_fnc(ctl, MDSS_PANEL_POWER_OFF); + if (ctl->ops.stop_fnc) + ctl->ops.stop_fnc(ctl, MDSS_PANEL_POWER_OFF); mdss_mdp_ctl_free(ctl); }