Merge "msm: mdss: Add default dither programming from CTL init" (85c81424) · Commits · e / devices / android_kernel_xiaomi_markw

drivers/video/msm/mdss/mdss_mdp.h

+4 −1

Original line number	Diff line number	Diff line
		@@ -1110,7 +1110,10 @@ int mdss_mdp_igc_lut_config(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_dither_config(struct mdp_dither_cfg_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 copy_from_kernel);
		int mdss_mdp_gamut_config(struct mdp_gamut_cfg_data config, u32 copyback);

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

drivers/video/msm/mdss/mdss_mdp_ctl.c

+0 −10

Original line number	Diff line number	Diff line
		@@ -2804,11 +2804,6 @@ struct mdss_mdp_ctl mdss_mdp_ctl_init(struct mdss_panel_data pdata,
		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:
		if (ctl->intf_type == MDSS_INTF_DSI)
		@@ -2816,17 +2811,12 @@ struct mdss_mdp_ctl mdss_mdp_ctl_init(struct mdss_panel_data pdata,
		MDSS_MDP_PANEL_FORMAT_PACK_ALIGN_MSB;
		else
		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);
		}

		return ctl;

drivers/video/msm/mdss/mdss_mdp_overlay.c

+9 −1

Original line number	Diff line number	Diff line
		@@ -3571,7 +3571,8 @@ static int mdss_mdp_pp_ioctl(struct msm_fb_data_type *mfd,
		case mdp_op_dither_cfg:
		ret = mdss_mdp_dither_config(
		&mdp_pp.data.dither_cfg_data,
		&copyback);
		&copyback,
		false);
		break;
		case mdp_op_gamut_cfg:
		ret = mdss_mdp_gamut_config(
		@@ -4278,6 +4279,13 @@ static struct mdss_mdp_ctl *__mdss_mdp_overlay_ctl_init(
		}
		}

		rc = mdss_mdp_pp_default_overlay_config(mfd, pdata);
		if (rc) {
		pr_err("Unable to set default postprocessing configs for fb%d\n",
		mfd->index);
		rc = 0;
		}

		error:
		if (rc)
		return ERR_PTR(rc);

drivers/video/msm/mdss/mdss_mdp_pp.c

+77 −2

Original line number	Diff line number	Diff line
		@@ -343,6 +343,7 @@ static int pp_update_pcc_pipe_setup(struct mdss_mdp_pipe *pipe, u32 location);
		static void mdss_mdp_hist_irq_set_mask(u32 irq);
		static void mdss_mdp_hist_irq_clear_mask(u32 irq);
		static void mdss_mdp_hist_intr_notify(u32 disp);
		static int mdss_mdp_panel_default_dither_config(u32 panel_bpp, u32 disp_num);

		static u32 last_sts, last_state;

		@@ -2381,6 +2382,25 @@ int mdss_mdp_pp_overlay_init(struct msm_fb_data_type *mfd)
		return 0;
		}

		int mdss_mdp_pp_default_overlay_config(struct msm_fb_data_type *mfd,
		struct mdss_panel_data *pdata)
		{
		int ret = 0;

		if (!mfd \|\| !pdata) {
		pr_err("Invalid parameters mfd %p pdata %p\n", mfd, pdata);
		return -EINVAL;
		}

		ret = mdss_mdp_panel_default_dither_config(pdata->panel_info.bpp,
		mfd->index);
		if (ret)
		pr_err("Unable to configure default dither on fb%d\n",
		mfd->index);

		return ret;
		}

		static int pp_ad_calc_bl(struct msm_fb_data_type mfd, int bl_in, int bl_out,
		bool *bl_out_notify)
		{
		@@ -3568,8 +3588,62 @@ enhist_config_exit:
		return ret;
		}

		static int mdss_mdp_panel_default_dither_config(u32 panel_bpp, u32 disp_num)
		{
		int ret = 0;
		struct mdp_dither_cfg_data dither = {
		.block = disp_num + MDP_LOGICAL_BLOCK_DISP_0,
		.flags = MDP_PP_OPS_DISABLE,
		};
		struct mdp_pp_feature_version dither_version = {
		.pp_feature = DITHER,
		};
		struct mdp_dither_data_v1_7 dither_data;

		dither.block = disp_num + MDP_LOGICAL_BLOCK_DISP_0;
		dither.flags = MDP_PP_OPS_DISABLE;

		ret = mdss_mdp_pp_get_version(&dither_version);
		if (ret) {
		pr_err("failed to get default dither version, ret %d\n",
		ret);
		return ret;
		}
		dither.version = dither_version.version_info;

		switch (panel_bpp) {
		case 18:
		dither.flags = MDP_PP_OPS_ENABLE \| MDP_PP_OPS_WRITE;
		switch (dither.version) {
		case mdp_dither_v1_7:
		dither_data.g_y_depth = 2;
		dither_data.r_cr_depth = 2;
		dither_data.b_cb_depth = 2;
		dither.cfg_payload = &dither_data;
		break;
		case mdp_pp_legacy:
		default:
		dither.g_y_depth = 2;
		dither.r_cr_depth = 2;
		dither.b_cb_depth = 2;
		dither.cfg_payload = NULL;
		break;
		}
		break;
		default:
		dither.cfg_payload = NULL;
		break;
		}
		ret = mdss_mdp_dither_config(&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,
		u32 *copyback)
		u32 *copyback,
		int copy_from_kernel)
		{
		u32 disp_num;
		int ret = 0;
		@@ -3591,7 +3665,8 @@ int mdss_mdp_dither_config(struct mdp_dither_cfg_data *config,
		disp_num = config->block - MDP_LOGICAL_BLOCK_DISP_0;
		if (pp_ops[DITHER].pp_set_config) {
		pr_debug("version of dither is %d\n", config->version);
		ret = pp_dither_cache_params(config, mdss_pp_res);
		ret = pp_dither_cache_params(config, mdss_pp_res,
		copy_from_kernel);
		if (ret) {
		pr_err("dither config failed version %d ret %d\n",
		config->version, ret);

drivers/video/msm/mdss/mdss_mdp_pp_cache_config.c

+31 −19

Original line number	Diff line number	Diff line
		@@ -254,7 +254,8 @@ int pp_hist_lut_cache_params(struct mdp_hist_lut_data *config,
		}

		int pp_dither_cache_params_v1_7(struct mdp_dither_cfg_data *config,
		struct mdss_pp_res_type *mdss_pp_res)
		struct mdss_pp_res_type *mdss_pp_res,
		int copy_from_kernel)
		{
		u32 disp_num;
		int ret = 0;
		@@ -285,36 +286,46 @@ int pp_dither_cache_params_v1_7(struct mdp_dither_cfg_data *config,

		if (config->flags & MDP_PP_OPS_READ) {
		pr_err("read op is not supported\n");
		return -EINVAL;
		} else {
		return -ENOTSUPP;
		}

		disp_num = config->block - MDP_LOGICAL_BLOCK_DISP_0;
		mdss_pp_res->dither_disp_cfg[disp_num] = *config;

		if (config->flags & MDP_PP_OPS_DISABLE) {
		pr_debug("disable dither\n");
		ret = 0;
		goto dither_config_exit;
		}

		if (!(config->flags & MDP_PP_OPS_WRITE)) {
		pr_debug("op for dither %d\n", config->flags);
		goto dither_config_exit;
		}

		v17_cache_data = &res_cache->dither_v17_data[disp_num];
		mdss_pp_res->dither_disp_cfg[disp_num].cfg_payload =
		(void *)v17_cache_data;
		if (copy_from_kernel) {
		memcpy(v17_cache_data, config->cfg_payload,
		sizeof(struct mdp_dither_data_v1_7));
		} else {
		if (copy_from_user(&v17_usr_config, config->cfg_payload,
		sizeof(v17_usr_config))) {
		pr_err("failed to copy v17 dither\n");
		ret = -EFAULT;
		goto dither_config_exit;
		}
		if ((config->flags & MDP_PP_OPS_DISABLE)) {
		pr_debug("disable dither");
		ret = 0;
		goto dither_config_exit;
		}
		if (!(config->flags & MDP_PP_OPS_WRITE)) {
		pr_debug("op for dither %d\n", config->flags);
		goto dither_config_exit;
		}
		memcpy(v17_cache_data, &v17_usr_config, sizeof(v17_usr_config));
		}

		dither_config_exit:
		return ret;
		}

		int pp_dither_cache_params(struct mdp_dither_cfg_data *config,
		struct mdss_pp_res_type *mdss_pp_res)
		struct mdss_pp_res_type *mdss_pp_res,
		int copy_from_kernel)
		{
		int ret = 0;
		if (!config \|\| !mdss_pp_res) {
		@@ -324,7 +335,8 @@ int pp_dither_cache_params(struct mdp_dither_cfg_data *config,
		}
		switch (config->version) {
		case mdp_dither_v1_7:
		ret = pp_dither_cache_params_v1_7(config, mdss_pp_res);
		ret = pp_dither_cache_params_v1_7(config, mdss_pp_res,
		copy_from_kernel);
		break;
		default:
		pr_err("unsupported dither version %d\n",