Merge "msm: mdss: Force PP block to match FB device during ioctl" (db28177e) · Commits · e / devices / android_kernel_xiaomi_markw

drivers/video/msm/mdss/mdss_mdp.h

+16 −8

Original line number	Diff line number	Diff line
		@@ -1138,18 +1138,26 @@ void mdss_hw_init(struct mdss_data_type *mdata);

		int mdss_mdp_mfd_valid_dspp(struct msm_fb_data_type *mfd);

		int mdss_mdp_pa_config(struct mdp_pa_cfg_data config, u32 copyback);
		int mdss_mdp_pa_v2_config(struct mdp_pa_v2_cfg_data config, u32 copyback);
		int mdss_mdp_pcc_config(struct mdp_pcc_cfg_data cfg_ptr, u32 copyback);
		int mdss_mdp_igc_lut_config(struct mdp_igc_lut_data config, u32 copyback,
		int mdss_mdp_pa_config(struct msm_fb_data_type *mfd,
		struct mdp_pa_cfg_data config, u32 copyback);
		int mdss_mdp_pa_v2_config(struct msm_fb_data_type *mfd,
		struct mdp_pa_v2_cfg_data config, u32 copyback);
		int mdss_mdp_pcc_config(struct msm_fb_data_type *mfd,
		struct mdp_pcc_cfg_data cfg_ptr, u32 copyback);
		int mdss_mdp_igc_lut_config(struct msm_fb_data_type *mfd,
		struct mdp_igc_lut_data config, u32 copyback,
		u32 copy_from_kernel);
		int mdss_mdp_argc_config(struct mdp_pgc_lut_data config, u32 copyback);
		int mdss_mdp_hist_lut_config(struct mdp_hist_lut_data config, u32 copyback);
		int mdss_mdp_argc_config(struct msm_fb_data_type *mfd,
		struct mdp_pgc_lut_data config, u32 copyback);
		int mdss_mdp_hist_lut_config(struct msm_fb_data_type *mfd,
		struct mdp_hist_lut_data config, u32 copyback);
		int mdss_mdp_pp_default_overlay_config(struct msm_fb_data_type *mfd,
		struct mdss_panel_data *pdata);
		int mdss_mdp_dither_config(struct mdp_dither_cfg_data config, u32 copyback,
		int mdss_mdp_dither_config(struct msm_fb_data_type *mfd,
		struct mdp_dither_cfg_data config, u32 copyback,
		int copy_from_kernel);
		int mdss_mdp_gamut_config(struct mdp_gamut_cfg_data config, u32 copyback);
		int mdss_mdp_gamut_config(struct msm_fb_data_type *mfd,
		struct mdp_gamut_cfg_data config, u32 copyback);

		int mdss_mdp_hist_intr_req(struct mdss_intr *intr, u32 bits, bool en);
		int mdss_mdp_hist_intr_setup(struct mdss_intr *intr, int state);

drivers/video/msm/mdss/mdss_mdp_overlay.c

+8 −13

Original line number	Diff line number	Diff line
		@@ -3587,44 +3587,39 @@ static int mdss_mdp_pp_ioctl(struct msm_fb_data_type *mfd,
		mdp_pp.op != mdp_op_calib_dcm_state))
		return -EPERM;

		if (!mdss_mdp_mfd_valid_dspp(mfd)) {
		pr_err("invalid display num %d for PP config\n", mfd->index);
		return -EPERM;
		}

		switch (mdp_pp.op) {
		case mdp_op_pa_cfg:
		ret = mdss_mdp_pa_config(&mdp_pp.data.pa_cfg_data,
		ret = mdss_mdp_pa_config(mfd, &mdp_pp.data.pa_cfg_data,
		&copyback);
		break;

		case mdp_op_pa_v2_cfg:
		ret = mdss_mdp_pa_v2_config(&mdp_pp.data.pa_v2_cfg_data,
		ret = mdss_mdp_pa_v2_config(mfd, &mdp_pp.data.pa_v2_cfg_data,
		&copyback);
		break;

		case mdp_op_pcc_cfg:
		ret = mdss_mdp_pcc_config(&mdp_pp.data.pcc_cfg_data,
		ret = mdss_mdp_pcc_config(mfd, &mdp_pp.data.pcc_cfg_data,
		&copyback);
		break;

		case mdp_op_lut_cfg:
		switch (mdp_pp.data.lut_cfg_data.lut_type) {
		case mdp_lut_igc:
		ret = mdss_mdp_igc_lut_config(
		ret = mdss_mdp_igc_lut_config(mfd,
		(struct mdp_igc_lut_data *)
		&mdp_pp.data.lut_cfg_data.data,
		&copyback, copy_from_kernel);
		break;

		case mdp_lut_pgc:
		ret = mdss_mdp_argc_config(
		ret = mdss_mdp_argc_config(mfd,
		&mdp_pp.data.lut_cfg_data.data.pgc_lut_data,
		&copyback);
		break;

		case mdp_lut_hist:
		ret = mdss_mdp_hist_lut_config(
		ret = mdss_mdp_hist_lut_config(mfd,
		(struct mdp_hist_lut_data *)
		&mdp_pp.data.lut_cfg_data.data, &copyback);
		break;
		@@ -3635,13 +3630,13 @@ static int mdss_mdp_pp_ioctl(struct msm_fb_data_type *mfd,
		}
		break;
		case mdp_op_dither_cfg:
		ret = mdss_mdp_dither_config(
		ret = mdss_mdp_dither_config(mfd,
		&mdp_pp.data.dither_cfg_data,
		&copyback,
		false);
		break;
		case mdp_op_gamut_cfg:
		ret = mdss_mdp_gamut_config(
		ret = mdss_mdp_gamut_config(mfd,
		&mdp_pp.data.gamut_cfg_data,
		&copyback);
		break;

drivers/video/msm/mdss/mdss_mdp_pp.c

+105 −35

Original line number	Diff line number	Diff line
		@@ -396,6 +396,8 @@ static int mdss_mdp_panel_default_dither_config(struct msm_fb_data_type *mfd,
		u32 panel_bpp);
		static int mdss_mdp_limited_lut_igc_config(struct msm_fb_data_type *mfd);
		static int pp_ad_shutdown_cleanup(struct msm_fb_data_type *mfd);
		static inline int pp_validate_dspp_mfd_block(struct msm_fb_data_type *mfd,
		int block);

		static u32 last_sts, last_state;

		@@ -2546,7 +2548,8 @@ static int pp_get_dspp_num(u32 disp_num, u32 *dspp_num)
		return 0;
		}

		int mdss_mdp_pa_config(struct mdp_pa_cfg_data *config,
		int mdss_mdp_pa_config(struct msm_fb_data_type *mfd,
		struct mdp_pa_cfg_data *config,
		u32 *copyback)
		{
		int ret = 0;
		@@ -2557,9 +2560,13 @@ int mdss_mdp_pa_config(struct mdp_pa_cfg_data *config,
		if (mdata->mdp_rev >= MDSS_MDP_HW_REV_103)
		return -EINVAL;

		if ((config->block < MDP_LOGICAL_BLOCK_DISP_0) \|\|
		(config->block >= MDP_BLOCK_MAX))
		return -EINVAL;
		ret = pp_validate_dspp_mfd_block(mfd, config->block);
		if (ret) {
		pr_err("Invalid block %d mfd index %d, ret %d\n",
		config->block,
		(mfd ? mfd->index : -1), ret);
		return ret;
		}

		mutex_lock(&mdss_pp_mutex);
		disp_num = config->block - MDP_LOGICAL_BLOCK_DISP_0;
		@@ -2593,7 +2600,8 @@ pa_config_exit:
		return ret;
		}

		int mdss_mdp_pa_v2_config(struct mdp_pa_v2_cfg_data *config,
		int mdss_mdp_pa_v2_config(struct msm_fb_data_type *mfd,
		struct mdp_pa_v2_cfg_data *config,
		u32 *copyback)
		{
		int ret = 0;
		@@ -2607,9 +2615,13 @@ int mdss_mdp_pa_v2_config(struct mdp_pa_v2_cfg_data *config,
		if (mdata->mdp_rev < MDSS_MDP_HW_REV_103)
		return -EINVAL;

		if ((config->block < MDP_LOGICAL_BLOCK_DISP_0) \|\|
		(config->block >= MDP_BLOCK_MAX))
		return -EINVAL;
		ret = pp_validate_dspp_mfd_block(mfd, config->block);
		if (ret) {
		pr_err("Invalid block %d mfd index %d, ret %d\n",
		config->block,
		(mfd ? mfd->index : -1), ret);
		return ret;
		}

		if (pp_ops[PA].pp_set_config)
		flags = config->flags;
		@@ -2924,7 +2936,8 @@ static void pp_update_pcc_regs(char __iomem *addr,
		writel_relaxed(cfg_ptr->b.rgb_1, addr + 8);
		}

		int mdss_mdp_pcc_config(struct mdp_pcc_cfg_data *config,
		int mdss_mdp_pcc_config(struct msm_fb_data_type *mfd,
		struct mdp_pcc_cfg_data *config,
		u32 *copyback)
		{
		int ret = 0;
		@@ -2933,9 +2946,13 @@ int mdss_mdp_pcc_config(struct mdp_pcc_cfg_data *config,
		struct mdss_data_type *mdata = mdss_mdp_get_mdata();
		struct mdp_pp_cache_res res_cache;

		if ((config->block < MDP_LOGICAL_BLOCK_DISP_0) \|\|
		(config->block >= MDP_BLOCK_MAX))
		return -EINVAL;
		ret = pp_validate_dspp_mfd_block(mfd, config->block);
		if (ret) {
		pr_err("Invalid block %d mfd index %d, ret %d\n",
		config->block,
		(mfd ? mfd->index : -1), ret);
		return ret;
		}

		if ((config->ops & MDSS_PP_SPLIT_MASK) == MDSS_PP_SPLIT_MASK) {
		pr_warn("Can't set both split bits\n");
		@@ -3132,12 +3149,13 @@ static int mdss_mdp_limited_lut_igc_config(struct msm_fb_data_type *mfd)
		break;
		}

		ret = mdss_mdp_igc_lut_config(&config, &copyback,
		ret = mdss_mdp_igc_lut_config(mfd, &config, &copyback,
		copy_from_kernel);
		return ret;
		}

		int mdss_mdp_igc_lut_config(struct mdp_igc_lut_data *config,
		int mdss_mdp_igc_lut_config(struct msm_fb_data_type *mfd,
		struct mdp_igc_lut_data *config,
		u32 *copyback, u32 copy_from_kernel)
		{
		int ret = 0;
		@@ -3147,10 +3165,13 @@ int mdss_mdp_igc_lut_config(struct mdp_igc_lut_data *config,
		struct mdp_pp_cache_res res_cache;
		struct mdss_data_type *mdata = mdss_mdp_get_mdata();

		if ((config->block < MDP_LOGICAL_BLOCK_DISP_0) \|\|
		(config->block >= MDP_BLOCK_MAX))
		return -EINVAL;

		ret = pp_validate_dspp_mfd_block(mfd, config->block);
		if (ret) {
		pr_err("Invalid block %d mfd index %d, ret %d\n",
		config->block,
		(mfd ? mfd->index : -1), ret);
		return ret;
		}

		if ((config->ops & MDSS_PP_SPLIT_MASK) == MDSS_PP_SPLIT_MASK) {
		pr_warn("Can't set both split bits\n");
		@@ -3414,7 +3435,8 @@ static void pp_update_hist_lut(char __iomem *addr,
		writel_relaxed(1, addr + 16);
		}

		int mdss_mdp_argc_config(struct mdp_pgc_lut_data *config,
		int mdss_mdp_argc_config(struct msm_fb_data_type *mfd,
		struct mdp_pgc_lut_data *config,
		u32 *copyback)
		{
		int ret = 0;
		@@ -3435,7 +3457,12 @@ int mdss_mdp_argc_config(struct mdp_pgc_lut_data *config,
		return -EINVAL;
		}

		mutex_lock(&mdss_pp_mutex);
		if ((PP_BLOCK(config->block) - MDP_LOGICAL_BLOCK_DISP_0) !=
		mfd->index) {
		pr_err("PP block %d does not match corresponding mfd index %d\n",
		config->block, mfd->index);
		return -EINVAL;
		}

		disp_num = PP_BLOCK(config->block) - MDP_LOGICAL_BLOCK_DISP_0;
		ret = pp_get_dspp_num(disp_num, &dspp_num);
		@@ -3462,8 +3489,9 @@ int mdss_mdp_argc_config(struct mdp_pgc_lut_data *config,
		break;
		}

		tbl_size = GC_LUT_SEGMENTS * sizeof(struct mdp_ar_gc_lut_data);
		mutex_lock(&mdss_pp_mutex);

		tbl_size = GC_LUT_SEGMENTS * sizeof(struct mdp_ar_gc_lut_data);
		if (config->flags & MDP_PP_OPS_READ) {
		mdss_mdp_clk_ctrl(MDP_BLOCK_POWER_ON);
		if (pp_ops[GC].pp_get_config) {
		@@ -3584,7 +3612,8 @@ argc_config_exit:
		mutex_unlock(&mdss_pp_mutex);
		return ret;
		}
		int mdss_mdp_hist_lut_config(struct mdp_hist_lut_data *config,
		int mdss_mdp_hist_lut_config(struct msm_fb_data_type *mfd,
		struct mdp_hist_lut_data *config,
		u32 *copyback)
		{
		int i, ret = 0;
		@@ -3592,9 +3621,13 @@ int mdss_mdp_hist_lut_config(struct mdp_hist_lut_data *config,
		char __iomem hist_addr = NULL, base_addr = NULL;
		struct mdp_pp_cache_res res_cache;

		if ((PP_BLOCK(config->block) < MDP_LOGICAL_BLOCK_DISP_0) \|\|
		(PP_BLOCK(config->block) >= MDP_BLOCK_MAX))
		return -EINVAL;
		ret = pp_validate_dspp_mfd_block(mfd, PP_BLOCK(config->block));
		if (ret) {
		pr_err("Invalid block %d mfd index %d, ret %d\n",
		PP_BLOCK(config->block),
		(mfd ? mfd->index : -1), ret);
		return ret;
		}

		mutex_lock(&mdss_pp_mutex);
		disp_num = PP_BLOCK(config->block) - MDP_LOGICAL_BLOCK_DISP_0;
		@@ -3717,23 +3750,29 @@ static int mdss_mdp_panel_default_dither_config(struct msm_fb_data_type *mfd,
		dither.cfg_payload = NULL;
		break;
		}
		ret = mdss_mdp_dither_config(&dither, NULL, true);
		ret = mdss_mdp_dither_config(mfd, &dither, NULL, true);
		if (ret)
		pr_err("dither config failed, ret %d\n", ret);

		return ret;
		}

		int mdss_mdp_dither_config(struct mdp_dither_cfg_data *config,
		int mdss_mdp_dither_config(struct msm_fb_data_type *mfd,
		struct mdp_dither_cfg_data *config,
		u32 *copyback,
		int copy_from_kernel)
		{
		u32 disp_num;
		int ret = 0;

		if ((config->block < MDP_LOGICAL_BLOCK_DISP_0) \|\|
		(config->block >= MDP_BLOCK_MAX))
		return -EINVAL;
		ret = pp_validate_dspp_mfd_block(mfd, config->block);
		if (ret) {
		pr_err("Invalid block %d mfd index %d, ret %d\n",
		config->block,
		(mfd ? mfd->index : -1), ret);
		return ret;
		}

		if (config->flags & MDP_PP_OPS_READ) {
		pr_err("Dither read is not supported\n");
		return -EOPNOTSUPP;
		@@ -3789,7 +3828,8 @@ static int pp_gm_has_invalid_lut_size(struct mdp_gamut_cfg_data *config)
		}


		int mdss_mdp_gamut_config(struct mdp_gamut_cfg_data *config,
		int mdss_mdp_gamut_config(struct msm_fb_data_type *mfd,
		struct mdp_gamut_cfg_data *config,
		u32 *copyback)
		{
		int i, j, ret = 0;
		@@ -3803,9 +3843,13 @@ int mdss_mdp_gamut_config(struct mdp_gamut_cfg_data *config,
		char __iomem *addr;
		u32 data = (3 << 20);

		if ((config->block < MDP_LOGICAL_BLOCK_DISP_0) \|\|
		(config->block >= MDP_BLOCK_MAX))
		return -EINVAL;
		ret = pp_validate_dspp_mfd_block(mfd, config->block);
		if (ret) {
		pr_err("Invalid block %d mfd index %d, ret %d\n",
		config->block,
		(mfd ? mfd->index : -1), ret);
		return ret;
		}

		if ((config->flags & MDSS_PP_SPLIT_MASK) == MDSS_PP_SPLIT_MASK) {
		pr_warn("Can't set both split bits\n");
		@@ -6549,3 +6593,29 @@ static int pp_ad_shutdown_cleanup(struct msm_fb_data_type *mfd)
		cancel_work_sync(&ad->calc_work);
		return ret;
		}

		static inline int pp_validate_dspp_mfd_block(struct msm_fb_data_type *mfd,
		int block)
		{
		if (!mfd)
		return -EINVAL;

		if (!mdss_mdp_mfd_valid_dspp(mfd)) {
		pr_err("invalid display num %d for PP config\n", mfd->index);
		return -EPERM;
		}

		if ((block < MDP_LOGICAL_BLOCK_DISP_0) \|\|
		(block >= MDP_BLOCK_MAX)) {
		pr_err("invalid block %d\n", block);
		return -EINVAL;
		}

		if ((block - MDP_LOGICAL_BLOCK_DISP_0) != mfd->index) {
		pr_err("PP block %d does not match corresponding mfd index %d\n",
		block, mfd->index);
		return -EINVAL;
		}

		return 0;
		}