int mdss_mdp_cmd_kickoff(struct mdss_mdp_ctl *ctl, void *arg) { struct mdss_mdp_cmd_ctx *ctx; unsigned long flags; int rc; ctx = (struct mdss_mdp_cmd_ctx *) ctl->priv_data; if (!ctx) { pr_err("invalid ctx\n"); return -ENODEV; } if (ctx->panel_on == 0) { rc = mdss_mdp_ctl_intf_event(ctl, MDSS_EVENT_UNBLANK, NULL); WARN(rc, "intf %d unblank error (%d)\n", ctl->intf_num, rc); ctx->panel_on++; rc = mdss_mdp_ctl_intf_event(ctl, MDSS_EVENT_PANEL_ON, NULL); WARN(rc, "intf %d panel on error (%d)\n", ctl->intf_num, rc); } mdss_mdp_cmd_clk_on(ctx); /* * tx dcs command if had any */ mdss_mdp_ctl_intf_event(ctl, MDSS_EVENT_DSI_CMDLIST_KOFF, NULL); INIT_COMPLETION(ctx->pp_comp); mdss_mdp_irq_enable(MDSS_MDP_IRQ_PING_PONG_COMP, ctx->pp_num); mdss_mdp_ctl_write(ctl, MDSS_MDP_REG_CTL_START, 1); spin_lock_irqsave(&ctx->clk_lock, flags); ctx->koff_cnt++; spin_unlock_irqrestore(&ctx->clk_lock, flags); mb(); return 0; }
int mdss_mdp_display_commit(struct mdss_mdp_ctl *ctl, void *arg) { int mixer1_changed, mixer2_changed; int ret = 0; int perf_update = MDSS_MDP_PERF_UPDATE_SKIP; u32 update_flags = 0; if (!ctl) { pr_err("display function not set\n"); return -ENODEV; } pr_debug("commit ctl=%d play_cnt=%d\n", ctl->num, ctl->play_cnt); ret = mutex_lock_interruptible(&ctl->lock); if (ret) return ret; if (!ctl->power_on) { mutex_unlock(&ctl->lock); return 0; } mixer1_changed = (ctl->mixer_left && ctl->mixer_left->params_changed); mixer2_changed = (ctl->mixer_right && ctl->mixer_right->params_changed); mdss_mdp_clk_ctrl(MDP_BLOCK_POWER_ON, false); if (mixer1_changed || mixer2_changed) { perf_update = mdss_mdp_ctl_perf_update(ctl, &update_flags); if (ctl->prepare_fnc) ret = ctl->prepare_fnc(ctl, arg); if (ret) { pr_err("error preparing display\n"); goto done; } if (perf_update == MDSS_MDP_PERF_UPDATE_EARLY) mdss_mdp_ctl_perf_commit(update_flags); if (mixer1_changed) mdss_mdp_mixer_update(ctl->mixer_left); if (mixer2_changed) mdss_mdp_mixer_update(ctl->mixer_right); mdss_mdp_ctl_write(ctl, MDSS_MDP_REG_CTL_TOP, ctl->opmode); ctl->flush_bits |= BIT(17); /* CTL */ } /* postprocessing setup, including dspp */ mdss_mdp_pp_setup(ctl); mdss_mdp_ctl_write(ctl, MDSS_MDP_REG_CTL_FLUSH, ctl->flush_bits); wmb(); ctl->flush_bits = 0; if (ctl->display_fnc) ret = ctl->display_fnc(ctl, arg); /* kickoff */ if (ret) pr_warn("error displaying frame\n"); ctl->play_cnt++; if (perf_update == MDSS_MDP_PERF_UPDATE_LATE) mdss_mdp_ctl_perf_commit(update_flags); done: mdss_mdp_clk_ctrl(MDP_BLOCK_POWER_OFF, false); mutex_unlock(&ctl->lock); return ret; }
static int mdss_mdp_ctl_init(struct msm_fb_data_type *mfd) { struct mdss_mdp_ctl *ctl; struct mdss_panel_data *pdata; u32 width, height; int ret = 0; if (!mfd) return -ENODEV; pdata = dev_get_platdata(&mfd->pdev->dev); if (!pdata) { pr_err("no panel connected for fb%d\n", mfd->index); return -ENODEV; } width = pdata->panel_info.xres; height = pdata->panel_info.yres; if (width > (2 * MAX_MIXER_WIDTH)) { pr_err("unsupported resolution\n"); return -EINVAL; } if (!mfd->ctl) { ctl = mdss_mdp_ctl_alloc(); if (!ctl) { pr_err("unable to allocate ctl\n"); return -ENOMEM; } ctl->mfd = mfd; mfd->ctl = ctl; ctl->panel_data = pdata; } else { ctl = mfd->ctl; } ctl->width = width; ctl->height = height; if (!ctl->mixer_left) { ctl->mixer_left = mdss_mdp_mixer_alloc(MDSS_MDP_MIXER_TYPE_INTF); if (!ctl->mixer_left) { pr_err("unable to allocate layer mixer\n"); ret = -ENOMEM; goto ctl_init_fail; } } if (width > MAX_MIXER_WIDTH) width /= 2; ctl->mixer_left->width = width; ctl->mixer_left->height = height; ctl->mixer_left->ctl = ctl; if (width < ctl->width) { if (ctl->mixer_right == NULL) { ctl->mixer_right = mdss_mdp_mixer_alloc(MDSS_MDP_MIXER_TYPE_INTF); if (!ctl->mixer_right) { pr_err("unable to allocate right mixer\n"); ret = -ENOMEM; goto ctl_init_fail; } } ctl->mixer_right->width = width; ctl->mixer_right->height = height; ctl->mixer_right->ctl = ctl; } else if (ctl->mixer_right) { mdss_mdp_mixer_free(ctl->mixer_right); } switch (pdata->panel_info.type) { case EDP_PANEL: 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; break; case MIPI_VIDEO_PANEL: if (pdata->panel_info.pdest == DISPLAY_1) ctl->intf_num = MDSS_MDP_INTF1; else ctl->intf_num = MDSS_MDP_INTF2; ctl->intf_type = MDSS_INTF_DSI; ctl->opmode = MDSS_MDP_CTL_OP_VIDEO_MODE; ctl->start_fnc = mdss_mdp_video_start; break; case DTV_PANEL: 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; break; case WRITEBACK_PANEL: ctl->intf_num = MDSS_MDP_NO_INTF; ctl->opmode = MDSS_MDP_CTL_OP_WFD_MODE; ctl->start_fnc = mdss_mdp_writeback_start; break; default: pr_err("unsupported panel type (%d)\n", pdata->panel_info.type); ret = -EINVAL; goto ctl_init_fail; } ctl->opmode |= (ctl->intf_num << 4); if (ctl->intf_num == MDSS_MDP_NO_INTF) { ctl->dst_format = pdata->panel_info.out_format; } else { struct mdp_dither_cfg_data dither = { .block = mfd->index + MDP_LOGICAL_BLOCK_DISP_0, .flags = MDP_PP_OPS_DISABLE, }; switch (pdata->panel_info.bpp) { case 18: ctl->dst_format = MDSS_MDP_PANEL_FORMAT_RGB666; dither.flags = MDP_PP_OPS_ENABLE | MDP_PP_OPS_WRITE; dither.g_y_depth = 2; dither.r_cr_depth = 2; dither.b_cb_depth = 2; break; case 24: default: ctl->dst_format = MDSS_MDP_PANEL_FORMAT_RGB888; break; } mdss_mdp_dither_config(&dither, NULL); } if (ctl->mixer_right) { ctl->opmode |= MDSS_MDP_CTL_OP_PACK_3D_ENABLE | MDSS_MDP_CTL_OP_PACK_3D_H_ROW_INT; } ctl_init_fail: if (IS_ERR_VALUE(ret)) { if (ctl->mixer_left) mdss_mdp_mixer_free(ctl->mixer_left); if (ctl->mixer_right) mdss_mdp_mixer_free(ctl->mixer_right); mdss_mdp_ctl_free(ctl); mfd->ctl = NULL; } return ret; } static int mdss_mdp_ctl_destroy(struct msm_fb_data_type *mfd) { struct mdss_mdp_ctl *ctl; if (!mfd || !mfd->ctl) return -ENODEV; ctl = mfd->ctl; mfd->ctl = NULL; if (ctl->mixer_left) mdss_mdp_mixer_free(ctl->mixer_left); if (ctl->mixer_right) mdss_mdp_mixer_free(ctl->mixer_right); mdss_mdp_ctl_free(ctl); return 0; } int mdss_mdp_ctl_intf_event(struct mdss_mdp_ctl *ctl, int event, void *arg) { struct mdss_panel_data *pdata; if (!ctl || !ctl->panel_data) return -ENODEV; pdata = ctl->panel_data; pr_debug("sending ctl=%d event=%d\n", ctl->num, event); if (pdata->event_handler) return pdata->event_handler(pdata, event, arg); return 0; } int mdss_mdp_ctl_on(struct msm_fb_data_type *mfd) { struct mdss_mdp_ctl *ctl; struct mdss_mdp_mixer *mixer; u32 outsize, temp, off; int ret = 0; if (!mfd) return -ENODEV; if (mfd->key != MFD_KEY) return -EINVAL; if (mdss_mdp_ctl_init(mfd)) { pr_err("unable to initialize ctl\n"); return -ENODEV; } ctl = mfd->ctl; if (ctl->power_on) { WARN(1, "already on!\n"); return 0; } mutex_lock(&ctl->lock); ctl->power_on = true; ctl->bus_ab_quota = 0; ctl->bus_ib_quota = 0; ctl->clk_rate = 0; mdss_mdp_clk_ctrl(MDP_BLOCK_POWER_ON, false); ret = mdss_mdp_ctl_intf_event(ctl, MDSS_EVENT_RESET, NULL); if (ret) { pr_err("panel power on failed ctl=%d\n", ctl->num); goto start_fail; } if (ctl->start_fnc) ret = ctl->start_fnc(ctl); else pr_warn("no start function for ctl=%d type=%d\n", ctl->num, ctl->panel_data->panel_info.type); if (ret) { pr_err("unable to start intf\n"); goto start_fail; } pr_debug("ctl_num=%d\n", ctl->num); mixer = ctl->mixer_left; mixer->params_changed++; temp = MDSS_MDP_REG_READ(MDSS_MDP_REG_DISP_INTF_SEL); temp |= (ctl->intf_type << ((ctl->intf_num - MDSS_MDP_INTF0) * 8)); MDSS_MDP_REG_WRITE(MDSS_MDP_REG_DISP_INTF_SEL, temp); if (ctl->intf_num != MDSS_MDP_NO_INTF) { off = MDSS_MDP_REG_INTF_OFFSET(ctl->intf_num); MDSS_MDP_REG_WRITE(off + MDSS_MDP_REG_INTF_PANEL_FORMAT, ctl->dst_format); } outsize = (mixer->height << 16) | mixer->width; off = MDSS_MDP_REG_LM_OFFSET(mixer->num); MDSS_MDP_REG_WRITE(off + MDSS_MDP_REG_LM_OUT_SIZE, outsize); if (ctl->mixer_right) { mixer = ctl->mixer_right; mixer->params_changed++; outsize = (mixer->height << 16) | mixer->width; off = MDSS_MDP_REG_LM_OFFSET(mixer->num); MDSS_MDP_REG_WRITE(off + MDSS_MDP_REG_LM_OUT_SIZE, outsize); mdss_mdp_ctl_write(ctl, MDSS_MDP_REG_CTL_PACK_3D, 0); } start_fail: mdss_mdp_clk_ctrl(MDP_BLOCK_POWER_OFF, false); mutex_unlock(&ctl->lock); if (ret) mdss_mdp_ctl_destroy(mfd); return ret; } int mdss_mdp_ctl_off(struct msm_fb_data_type *mfd) { struct mdss_mdp_ctl *ctl; int ret = 0; if (!mfd) return -ENODEV; if (mfd->key != MFD_KEY) return -EINVAL; if (!mfd->ctl) { pr_err("ctl not initialized\n"); return -ENODEV; } ctl = mfd->ctl; if (!ctl->power_on) { WARN(1, "already off!\n"); return 0; } pr_debug("ctl_num=%d\n", mfd->ctl->num); mutex_lock(&ctl->lock); mdss_mdp_clk_ctrl(MDP_BLOCK_POWER_ON, false); if (ctl->stop_fnc) ret = ctl->stop_fnc(ctl); else pr_warn("no stop func for ctl=%d\n", ctl->num); if (ret) { pr_warn("error powering off intf ctl=%d\n", ctl->num); } else { ctl->power_on = false; ctl->play_cnt = 0; ctl->clk_rate = 0; mdss_mdp_ctl_perf_commit(MDSS_MDP_PERF_UPDATE_ALL); } mdss_mdp_clk_ctrl(MDP_BLOCK_POWER_OFF, false); mutex_unlock(&ctl->lock); if (!ret && !mfd->ref_cnt) { ret = mdss_mdp_ctl_intf_event(ctl, MDSS_EVENT_CLOSE, NULL); WARN(ret, "unable to close intf %d\n", ctl->intf_num); mdss_mdp_ctl_destroy(mfd); } return ret; } static int mdss_mdp_mixer_setup(struct mdss_mdp_ctl *ctl, struct mdss_mdp_mixer *mixer) { struct mdss_mdp_pipe *pipe; u32 off, blend_op, blend_stage; u32 mixercfg = 0, blend_color_out = 0, bgalpha = 0; int stage; if (!mixer) return -ENODEV; pr_debug("setup mixer=%d\n", mixer->num); pipe = mixer->stage_pipe[MDSS_MDP_STAGE_BASE]; if (pipe == NULL) { mixercfg = MDSS_MDP_LM_BORDER_COLOR; } else { mixercfg = 1 << (3 * pipe->num); if (pipe->src_fmt->alpha_enable) bgalpha = 1; } for (stage = MDSS_MDP_STAGE_0; stage < MDSS_MDP_MAX_STAGE; stage++) { pipe = mixer->stage_pipe[stage]; if (pipe == NULL) continue; if (stage != pipe->mixer_stage) { mixer->stage_pipe[stage] = NULL; continue; } blend_stage = stage - MDSS_MDP_STAGE_0; off = MDSS_MDP_REG_LM_OFFSET(mixer->num) + MDSS_MDP_REG_LM_BLEND_OFFSET(blend_stage); if (pipe->is_fg) { bgalpha = 0; mixercfg = MDSS_MDP_LM_BORDER_COLOR; blend_op = (MDSS_MDP_BLEND_FG_ALPHA_FG_CONST | MDSS_MDP_BLEND_BG_ALPHA_BG_CONST); /* keep fg alpha */ blend_color_out |= 1 << (blend_stage + 1); pr_debug("pnum=%d stg=%d alpha=IS_FG\n", pipe->num, stage); } else if (pipe->src_fmt->alpha_enable) { bgalpha = 0; blend_op = (MDSS_MDP_BLEND_BG_ALPHA_FG_PIXEL | MDSS_MDP_BLEND_BG_INV_ALPHA); /* keep fg alpha */ blend_color_out |= 1 << (blend_stage + 1); pr_debug("pnum=%d stg=%d alpha=FG PIXEL\n", pipe->num, stage); } else if (bgalpha) { blend_op = (MDSS_MDP_BLEND_BG_ALPHA_BG_PIXEL | MDSS_MDP_BLEND_FG_ALPHA_BG_PIXEL | MDSS_MDP_BLEND_FG_INV_ALPHA); /* keep bg alpha */ pr_debug("pnum=%d stg=%d alpha=BG_PIXEL\n", pipe->num, stage); } else { blend_op = (MDSS_MDP_BLEND_FG_ALPHA_FG_CONST | MDSS_MDP_BLEND_BG_ALPHA_BG_CONST); pr_debug("pnum=%d stg=%d alpha=CONST\n", pipe->num, stage); } mixercfg |= stage << (3 * pipe->num); MDSS_MDP_REG_WRITE(off + MDSS_MDP_REG_LM_OP_MODE, blend_op); MDSS_MDP_REG_WRITE(off + MDSS_MDP_REG_LM_BLEND_FG_ALPHA, pipe->alpha); MDSS_MDP_REG_WRITE(off + MDSS_MDP_REG_LM_BLEND_BG_ALPHA, 0xFF - pipe->alpha); } if (mixer->cursor_enabled) mixercfg |= MDSS_MDP_LM_CURSOR_OUT; pr_debug("mixer=%d mixer_cfg=%x\n", mixer->num, mixercfg); ctl->flush_bits |= BIT(6) << mixer->num; /* LAYER_MIXER */ off = MDSS_MDP_REG_LM_OFFSET(mixer->num); MDSS_MDP_REG_WRITE(off + MDSS_MDP_REG_LM_OP_MODE, blend_color_out); mdss_mdp_ctl_write(ctl, MDSS_MDP_REG_CTL_LAYER(mixer->num), mixercfg); return 0; } struct mdss_mdp_mixer *mdss_mdp_mixer_get(struct mdss_mdp_ctl *ctl, int mux) { struct mdss_mdp_mixer *mixer = NULL; if (!ctl) return NULL; switch (mux) { case MDSS_MDP_MIXER_MUX_DEFAULT: case MDSS_MDP_MIXER_MUX_LEFT: mixer = ctl->mixer_left; break; case MDSS_MDP_MIXER_MUX_RIGHT: mixer = ctl->mixer_right; break; } return mixer; } struct mdss_mdp_pipe *mdss_mdp_mixer_stage_pipe(struct mdss_mdp_ctl *ctl, int mux, int stage) { struct mdss_mdp_pipe *pipe = NULL; struct mdss_mdp_mixer *mixer; if (!ctl) return NULL; if (mutex_lock_interruptible(&ctl->lock)) return NULL; mixer = mdss_mdp_mixer_get(ctl, mux); if (mixer) pipe = mixer->stage_pipe[stage]; mutex_unlock(&ctl->lock); return pipe; } int mdss_mdp_mixer_pipe_update(struct mdss_mdp_pipe *pipe, int params_changed) { struct mdss_mdp_ctl *ctl; struct mdss_mdp_mixer *mixer; if (!pipe) return -EINVAL; mixer = pipe->mixer; if (!mixer) return -EINVAL; ctl = mixer->ctl; if (!ctl) return -EINVAL; if (pipe->mixer_stage >= MDSS_MDP_MAX_STAGE) { pr_err("invalid mixer stage\n"); return -EINVAL; } pr_debug("pnum=%x mixer=%d stage=%d\n", pipe->num, mixer->num, pipe->mixer_stage); if (mutex_lock_interruptible(&ctl->lock)) return -EINTR; if (params_changed) { mixer->params_changed++; mixer->stage_pipe[pipe->mixer_stage] = pipe; } if (pipe->type == MDSS_MDP_PIPE_TYPE_DMA) ctl->flush_bits |= BIT(pipe->num) << 5; else /* RGB/VIG pipe */ ctl->flush_bits |= BIT(pipe->num); mutex_unlock(&ctl->lock); return 0; } int mdss_mdp_mixer_pipe_unstage(struct mdss_mdp_pipe *pipe) { struct mdss_mdp_ctl *ctl; struct mdss_mdp_mixer *mixer; if (!pipe) return -EINVAL; mixer = pipe->mixer; if (!mixer) return -EINVAL; ctl = mixer->ctl; if (!ctl) return -EINVAL; pr_debug("unstage pnum=%d stage=%d mixer=%d\n", pipe->num, pipe->mixer_stage, mixer->num); if (mutex_lock_interruptible(&ctl->lock)) return -EINTR; mixer->params_changed++; mixer->stage_pipe[pipe->mixer_stage] = NULL; mutex_unlock(&ctl->lock); return 0; } static int mdss_mdp_mixer_update(struct mdss_mdp_mixer *mixer) { mixer->params_changed = 0; /* skip mixer setup for rotator */ if (!mixer->rotator_mode) mdss_mdp_mixer_setup(mixer->ctl, mixer); return 0; }