Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 42fc6090 authored by Krishna Manikandan's avatar Krishna Manikandan Committed by Gerrit - the friendly Code Review server
Browse files

msm: mdss: Add support for handling secure buffer use-cases in MDP3 



Support for secure usecase for MDP3 is added. Ensure a
NULL buffer commit in case of video mode panels
during secure to non secure and vice versa transition.

Change-Id: I80669d8b6940c742b6624d9af9efc820d6063e10
Signed-off-by: default avatarKrishna Manikandan <mkrishn@codeaurora.org>
parent 2d02df76

drivers/video/msm/mdss/mdp3.c

+6 −1
Original line number Diff line number Diff line
@@ -47,6 +47,7 @@ 
#include <linux/qcom_iommu.h>

#include <linux/msm_iommu_domains.h>

#include <linux/vmalloc.h>

#include <soc/qcom/scm.h>



#include <linux/msm_dma_iommu_mapping.h>
@@ -2956,7 +2957,7 @@ int mdp3_panel_get_intf_status(u32 disp_num, u32 intf_type) 


static int mdp3_probe(struct platform_device *pdev)

{

	int rc;

	int rc, scm_ret = 0;

	static struct msm_mdp_interface mdp3_interface = {

	.init_fnc = mdp3_init,

	.fb_mem_get_iommu_domain = mdp3_fb_mem_get_iommu_domain,
@@ -3083,6 +3084,10 @@ static int mdp3_probe(struct platform_device *pdev) 


	__mdp3_set_supported_formats();



	rc = scm_restore_sec_cfg(SEC_DEVICE_MDP3, 0, &scm_ret);

	if (rc)

		pr_err("Restore secure cfg failed\n");



	mdp3_res->mdss_util->mdp_probe_done = true;

	pr_debug("%s: END\n", __func__);

drivers/video/msm/mdss/mdp3.h

+7 −0
Original line number Diff line number Diff line
@@ -31,6 +31,7 @@ 
#define MDP_CORE_CLK_RATE_SVS	160000000

#define MDP_CORE_CLK_RATE_SUPER_SVS	200000000

#define MDP_CORE_CLK_RATE_MAX	307200000

#define SEC_DEVICE_MDP3         1



#define CLK_FUDGE_NUM		12

#define CLK_FUDGE_DEN		10
@@ -96,6 +97,12 @@ enum { 
	DI_MAX,

};



enum mdp3_sd_transition {

	NO_TRANSITION,

	NONSECURE_TO_SECURE,

	SECURE_TO_NONSECURE,

};



struct mdp3_bus_handle_map {

	struct msm_bus_vectors *bus_vector;

	struct msm_bus_paths *usecases;

drivers/video/msm/mdss/mdp3_ctrl.c

+157 −8
Original line number Diff line number Diff line
@@ -25,6 +25,7 @@ 
#include <linux/sw_sync.h>

#include <linux/iommu.h>

#include <linux/msm_ion.h>

#include <soc/qcom/scm.h>



#include "mdp3_ctrl.h"

#include "mdp3.h"
@@ -33,6 +34,7 @@ 
#include "mdss_spi_panel.h"



#define VSYNC_EXPIRE_TICK	4

#define MEM_PROTECT_SD_CTRL	0xF



static void mdp3_ctrl_pan_display(struct msm_fb_data_type *mfd);

static int mdp3_overlay_unset(struct msm_fb_data_type *mfd, int ndx);
@@ -397,12 +399,46 @@ void mdp3_vsync_timer_func(unsigned long arg) 
	}

}



int config_secure_display(struct mdp3_session_data *mdp3_session)

{

	struct sd_ctrl_req {

		unsigned int enable;

	} __attribute__ ((__packed__)) request;

	unsigned int resp = -1;

	int ret = 0;

	struct scm_desc desc;



	if (mdp3_session->transition_state == NONSECURE_TO_SECURE)

		atomic_inc(&mdp3_session->secure_display);

	else if (mdp3_session->transition_state == SECURE_TO_NONSECURE)

		atomic_dec(&mdp3_session->secure_display);



	request.enable = atomic_read(&mdp3_session->secure_display);

	desc.args[0] = request.enable;

	desc.arginfo = SCM_ARGS(1);



	if (!is_scm_armv8()) {

		ret = scm_call(SCM_SVC_MP, MEM_PROTECT_SD_CTRL,

			&request, sizeof(request), &resp, sizeof(resp));

	} else {

		ret = scm_call2(SCM_SIP_FNID(SCM_SVC_MP,

				MEM_PROTECT_SD_CTRL), &desc);

		resp = desc.ret[0];

	}



	pr_debug("scm_call MEM_PROTECT_SD_CTRL(%u): ret=%di resp =%d\n",

			request.enable, ret, resp);



	return resp;

}



static int mdp3_ctrl_async_blit_req(struct msm_fb_data_type *mfd,

	void __user *p)

{

	struct mdp_async_blit_req_list req_list_header;

	int rc, count;

	void __user *p_req;

	struct mdp3_session_data *session;



	if (copy_from_user(&req_list_header, p, sizeof(req_list_header)))

		return -EFAULT;
@@ -410,6 +446,23 @@ static int mdp3_ctrl_async_blit_req(struct msm_fb_data_type *mfd, 
	count = req_list_header.count;

	if (count < 0 || count > MAX_BLIT_REQ)

		return -EINVAL;



	if (!mfd || !mfd->mdp.private1)

		return -EINVAL;



	session = (struct mdp3_session_data *)mfd->mdp.private1;



	if (atomic_read(&session->secure_display) &&

		(mdp3_ctrl_get_intf_type(mfd) ==

			MDP3_DMA_OUTPUT_SEL_DSI_VIDEO)) {

		rc = wait_for_completion_timeout(&session->secure_completion,

			msecs_to_jiffies(84));

		if (rc) {

			pr_err("Timed out waiting for completion of secure display\n");

			return rc;

		}

	}



	rc = mdp3_ppp_parse_req(p_req, &req_list_header, 1);

	if (!rc)

		rc = copy_to_user(p, &req_list_header, sizeof(req_list_header));
@@ -895,6 +948,7 @@ static int mdp3_ctrl_on(struct msm_fb_data_type *mfd) 
	int rc = 0;

	struct mdp3_session_data *mdp3_session;

	struct mdss_panel_data *panel;

	int scm_ret = 0;



	pr_debug("mdp3_ctrl_on\n");

	mdp3_session = (struct mdp3_session_data *)mfd->mdp.private1;
@@ -940,6 +994,10 @@ static int mdp3_ctrl_on(struct msm_fb_data_type *mfd) 
		goto end;

	}



	rc = scm_restore_sec_cfg(SEC_DEVICE_MDP3, 0, &scm_ret);

	if (rc)

		pr_err("Restoring secure cfg failed\n");



	/*

	* Get a reference to the runtime pm device.

	* If idle pc feature is enabled, it will be released
@@ -1505,7 +1563,8 @@ static int mdp3_ctrl_display_commit_kickoff(struct msm_fb_data_type *mfd, 
	struct mdss_panel_data *panel;

	int frame_rate = DEFAULT_FRAME_RATE;

	int stride;



	bool null_commit = false;

	bool is_panel_type_cmd = false;



	if (!mfd || !mfd->mdp.private1)

		return -EINVAL;
@@ -1520,7 +1579,34 @@ static int mdp3_ctrl_display_commit_kickoff(struct msm_fb_data_type *mfd, 


	if (mdp3_bufq_count(&mdp3_session->bufq_in) == 0) {

		pr_debug("no buffer in queue yet\n");

		return -EPERM;

		null_commit = true;

	}



	if (null_commit && mdp3_ctrl_get_intf_type(mfd) ==

			MDP3_DMA_OUTPUT_SEL_DSI_VIDEO) {

		mutex_lock(&mdp3_session->lock);

		reinit_completion(&mdp3_session->secure_completion);

		mdp3_ctrl_reset_countdown(mdp3_session, mfd);

		mdp3_ctrl_clk_enable(mfd, 1);

		rc = mdp3_session->dma->handle_null_commit(mdp3_session->dma,

				mdp3_session->intf);



		if (atomic_read(&mdp3_session->secure_display)) {

			mdp3_session->transition_state = SECURE_TO_NONSECURE;

			rc = config_secure_display(mdp3_session);

			if (rc)

				pr_err("Configuring secure display failed\n");

		}

		complete_all(&mdp3_session->secure_completion);

		mdp3_ctrl_notify(mdp3_session, MDP_NOTIFY_FRAME_DONE);

		if (mdp3_bufq_count(&mdp3_session->bufq_out) > 0) {

			data = mdp3_bufq_pop(&mdp3_session->bufq_out);

			if (data)

				mdp3_put_img(data, MDP3_CLIENT_DMA_P);

		}

		mdp3_session->vsync_before_commit = 0;

		mutex_unlock(&mdp3_session->lock);

		return 0;

	}



	if (panel_info->partial_update_enabled &&
@@ -1562,6 +1648,10 @@ static int mdp3_ctrl_display_commit_kickoff(struct msm_fb_data_type *mfd, 
		return -EPERM;

	}

	MDSS_XLOG(0x111);



	if (mfd->panel.type == MIPI_CMD_PANEL || client == MDP3_CLIENT_SPI)

		is_panel_type_cmd = true;



	mdp3_ctrl_notify(mdp3_session, MDP_NOTIFY_FRAME_BEGIN);

	data = mdp3_bufq_pop(&mdp3_session->bufq_in);

	if (data) {
@@ -1577,20 +1667,76 @@ static int mdp3_ctrl_display_commit_kickoff(struct msm_fb_data_type *mfd, 
			rc = mdss_spi_panel_kickoff(mdp3_session->panel,

				(void *)(int)data->addr, (int)data->len,

					stride);

		} else if (mdp3_session->dma->update_src_cfg &&

			goto frame_done;

		} else if (mdp3_session->dma->output_config.out_sel ==

					MDP3_DMA_OUTPUT_SEL_DSI_CMD) {

			rc = mdp3_session->dma->wait_for_dma(mdp3_session->dma,

					mdp3_session->intf);

			if (!rc && !mdp3_session->first_commit) {

				pr_err("dma done timedout\n");

				mutex_unlock(&mdp3_session->lock);

				return -ETIMEDOUT;

			}

		}



		/* For command mode panels, the secure display should be enabled

		 * only after the previous dma done is completed

		 */



		if (mdp3_session->transition_state != NO_TRANSITION) {

			rc = config_secure_display(mdp3_session);

			if (rc) {

				pr_err("Configuring secure display failed\n");

				mutex_unlock(&mdp3_session->lock);

				return -EINVAL;

			}

		}

		if (is_panel_type_cmd) {

			rc = mdp3_iommu_enable(client);

			if (rc) {

				pr_err("failed to enable iommu\n");

				mdp3_put_img(data, client);

				mutex_unlock(&mdp3_session->lock);

				return rc;

			}

		}



		rc = mdp3_map_layer(data, MDP3_CLIENT_DMA_P);

		if (data->len < mdp3_session->dma->source_config.stride *

				mdp3_session->dma->source_config.height) {

			pr_err("buf size(0x%lx) is smaller than dma config(0x%x)\n",

				data->len,

				(mdp3_session->dma->source_config.stride *

				mdp3_session->dma->source_config.height));



			mdp3_put_img(data, client);

			if (is_panel_type_cmd)

				mdp3_iommu_disable(client);

			mutex_unlock(&mdp3_session->lock);

			return -EINVAL;

		}



		if (is_panel_type_cmd)

			mdp3_iommu_disable(client);



		if (mdp3_session->dma->update_src_cfg &&

				panel_info->partial_update_enabled) {

			panel->panel_info.roi.x = mdp3_session->dma->roi.x;

			panel->panel_info.roi.y = mdp3_session->dma->roi.y;

			panel->panel_info.roi.w = mdp3_session->dma->roi.w;

			panel->panel_info.roi.h = mdp3_session->dma->roi.h;

			rc = mdp3_session->dma->update(mdp3_session->dma,

					(void *)(int)data->addr,

					mdp3_session->intf, (void *)panel);

				(void *)(int)data->addr, mdp3_session->intf,

				(void *)panel,

				atomic_read(&mdp3_session->secure_display));

		} else {

			rc = mdp3_session->dma->update(mdp3_session->dma,

					(void *)(int)data->addr,

					mdp3_session->intf, NULL);

				(void *)(int)data->addr, mdp3_session->intf,

				NULL,

				atomic_read(&mdp3_session->secure_display));

		}



frame_done:

		/* This is for the previous frame */

		if (rc < 0) {

			mdp3_ctrl_notify(mdp3_session,
@@ -1746,7 +1892,8 @@ static void mdp3_ctrl_pan_display(struct msm_fb_data_type *mfd) 
		}

		rc = mdp3_session->dma->update(mdp3_session->dma,

				(void *)(int)(mfd->iova + offset),

				mdp3_session->intf, NULL);

				mdp3_session->intf, NULL,

				atomic_read(&mdp3_session->secure_display));

		/* This is for the previous frame */

		if (rc < 0) {

			mdp3_ctrl_notify(mdp3_session,
@@ -3058,6 +3205,7 @@ int mdp3_ctrl_init(struct msm_fb_data_type *mfd) 
	mdp3_session->histo_status = 0;

	mdp3_session->lut_sel = 0;

	BLOCKING_INIT_NOTIFIER_HEAD(&mdp3_session->notifier_head);

	atomic_set(&mdp3_session->secure_display, 0);



	init_timer(&mdp3_session->vsync_timer);

	mdp3_session->vsync_timer.function = mdp3_vsync_timer_func;
@@ -3065,6 +3213,7 @@ int mdp3_ctrl_init(struct msm_fb_data_type *mfd) 
	mdp3_session->vsync_period = 1000 / frame_rate;

	mfd->mdp.private1 = mdp3_session;

	init_completion(&mdp3_session->dma_completion);

	init_completion(&mdp3_session->secure_completion);

	if (intf_type != MDP3_DMA_OUTPUT_SEL_DSI_VIDEO ||

		intf_type != MDP3_DMA_OUTPUT_SEL_SPI_CMD)

		mdp3_session->wait_for_dma_done = mdp3_wait_for_dma_done;

drivers/video/msm/mdss/mdp3_ctrl.h

+5 −1
Original line number Diff line number Diff line
@@ -76,12 +76,16 @@ struct mdp3_session_data { 


	bool dma_active;

	struct completion dma_completion;

	struct completion secure_completion;



	int (*wait_for_dma_done)(struct mdp3_session_data *session);



	/* For retire fence */

	struct sw_sync_timeline *vsync_timeline;

	int retire_cnt;

	struct work_struct retire_work;

	atomic_t secure_display;

	int transition_state;

};



void mdp3_bufq_deinit(struct mdp3_buffer_queue *bufq, int client);
@@ -92,6 +96,6 @@ int mdp3_ctrl_get_source_format(u32 imgType); 
int mdp3_ctrl_get_pack_pattern(u32 imgType);

int mdp3_ctrl_reset(struct msm_fb_data_type *mfd);

int mdp3_get_ion_client(struct msm_fb_data_type *mfd);



int config_secure_display(struct mdp3_session_data *mdp3_session);



#endif /* MDP3_CTRL_H */

drivers/video/msm/mdss/mdp3_dma.c

+110 −25
Original line number Diff line number Diff line
@@ -17,6 +17,7 @@ 
#include "mdp3_dma.h"

#include "mdp3_hwio.h"

#include "mdss_debug.h"

#include "mdp3_ctrl.h"



#define DMA_STOP_POLL_SLEEP_US 1000

#define DMA_STOP_POLL_TIMEOUT_US 200000
@@ -351,7 +352,7 @@ static int mdp3_dmap_config(struct mdp3_dma *dma, 
	return 0;

}



static void mdp3_dmap_config_source(struct mdp3_dma *dma)

static void mdp3_dmap_config_source(struct mdp3_dma *dma, bool enable_secure)

{

	struct mdp3_dma_source *source_config = &dma->source_config;

	u32 dma_p_cfg_reg, dma_p_size;
@@ -364,6 +365,11 @@ static void mdp3_dmap_config_source(struct mdp3_dma *dma) 


	dma_p_size = dma->roi.w | (dma->roi.h << 16);



	if (enable_secure)

		dma_p_cfg_reg |= BIT(21);

	else

		dma_p_cfg_reg &= ~BIT(21);



	MDP3_REG_WRITE(MDP3_REG_DMA_P_CONFIG, dma_p_cfg_reg);

	MDP3_REG_WRITE(MDP3_REG_DMA_P_SIZE, dma_p_size);

	MDP3_REG_WRITE(MDP3_REG_DMA_P_IBUF_Y_STRIDE, source_config->stride);
@@ -406,7 +412,7 @@ static int mdp3_dmas_config(struct mdp3_dma *dma, 
	return 0;

}



static void mdp3_dmas_config_source(struct mdp3_dma *dma)

static void mdp3_dmas_config_source(struct mdp3_dma *dma, bool enable_secure)

{

	struct mdp3_dma_source *source_config = &dma->source_config;

	u32 dma_s_cfg_reg, dma_s_size;
@@ -654,46 +660,119 @@ int dma_bpp(int format) 
	return bpp;

}



static int mdp3_dmap_update(struct mdp3_dma *dma, void *buf,

				struct mdp3_intf *intf, void *data)

static int mdp3_handle_null_commit(struct mdp3_dma *dma, struct mdp3_intf *intf)

{

	int rc = 0;

	int retry_count = 2;

	unsigned long flag;

	int cb_type = MDP3_DMA_CALLBACK_TYPE_VSYNC;

	struct mdss_panel_data *panel;



	if (!dma->source_config.format && !dma->source_config.stride) {

		pr_debug("Null commit already handled\n");

		return 0;

	}



	/*

	 * Size and stride are set to 0 to ensure that DMA pipe does not

	 * fetch anything whenever we get a null commit. The values will be

	 * reconfigured to the correct values in the next commit.

	 */



	MDP3_REG_WRITE(MDP3_REG_DMA_P_SIZE, 0);

	MDP3_REG_WRITE(MDP3_REG_DMA_P_IBUF_Y_STRIDE, 0);



	spin_lock_irqsave(&dma->dma_lock, flag);

	dma->source_config.format = 0;

	dma->source_config.stride = 0;

	mdp3_irq_disable(MDP3_INTR_LCDC_UNDERFLOW);

	MDP3_REG_WRITE(MDP3_REG_DSI_VIDEO_UNDERFLOW_CTL, 0x80000000);



	if (!intf->active) {

		pr_debug("%s start interface\n", __func__);

		intf->start(intf);

	}



	/*

	 * Make sure that all the configurations required for

	 * null commit is done before waiting for the vsync.

	 */

	mb();

	dma->vsync_status = MDP3_REG_READ(MDP3_REG_INTR_STATUS) &

		(1 << MDP3_INTR_LCDC_START_OF_FRAME);

	init_completion(&dma->vsync_comp);

	spin_unlock_irqrestore(&dma->dma_lock, flag);

	mdp3_dma_callback_enable(dma, cb_type);



retry_vsync:

	pr_debug("wait for vsync_comp started\n");

	rc = wait_for_completion_timeout(&dma->vsync_comp,

			KOFF_TIMEOUT);

	if (rc <= 0 && --retry_count) {

		int vsync = MDP3_REG_READ(MDP3_REG_INTR_STATUS) &

				(1 << MDP3_INTR_LCDC_START_OF_FRAME);

		if (!vsync) {

			pr_err("%s trying again count = %d\n",

				__func__, retry_count);

			goto retry_vsync;

		}

		rc = -1;

	}

	pr_debug("wait for vsync_comp done\n");



return rc;



}



static int mdp3_wait_for_dma_comp(struct mdp3_dma *dma, struct mdp3_intf *intf)

{

	int vsync_status;

	int rc = 0;

	int retry_count = 2;



	ATRACE_BEGIN(__func__);

	pr_debug("mdp3_dmap_update\n");



	MDSS_XLOG(XLOG_FUNC_ENTRY, __LINE__);

	if (dma->output_config.out_sel == MDP3_DMA_OUTPUT_SEL_DSI_CMD) {

		cb_type = MDP3_DMA_CALLBACK_TYPE_DMA_DONE;

	if (intf->active) {

		ATRACE_BEGIN("mdp3_wait_for_dma_comp");

retry_dma_done:

		rc = wait_for_completion_timeout(&dma->dma_comp,

			KOFF_TIMEOUT);

		if (rc <= 0 && --retry_count) {

				int  vsync_status;



			vsync_status = (1 << MDP3_INTR_DMA_P_DONE) &

					MDP3_REG_READ(MDP3_REG_INTR_STATUS);

			if (!vsync_status) {

				pr_err("%s: cmd timeout retry cnt %d\n",

					__func__, retry_count);

				goto retry_dma_done;

			} else {

				rc = 1;

			}

				rc = -1;

		}

		ATRACE_END("mdp3_wait_for_dma_comp");

	}

	return rc;

}



static int mdp3_dmap_update(struct mdp3_dma *dma, void *buf,

				struct mdp3_intf *intf, void *data, bool secure)

{

	unsigned long flag;

	int cb_type = MDP3_DMA_CALLBACK_TYPE_VSYNC;

	struct mdss_panel_data *panel;

	int rc = 0;

	int retry_count = 2;

	int vsync = 0;



	ATRACE_BEGIN(__func__);

	pr_debug("mdp3_dmap_update\n");



	MDSS_XLOG(XLOG_FUNC_ENTRY, __LINE__);

	if (dma->output_config.out_sel == MDP3_DMA_OUTPUT_SEL_DSI_CMD) {

		cb_type = MDP3_DMA_CALLBACK_TYPE_DMA_DONE;

	}



	if (dma->update_src_cfg) {

		if (dma->output_config.out_sel ==

			MDP3_DMA_OUTPUT_SEL_DSI_VIDEO && intf->active)

			pr_err("configuring dma source while it is active\n");

		dma->dma_config_source(dma);

		dma->dma_config_source(dma, secure);

		if (data) {

			panel = (struct mdss_panel_data *)data;

			if (panel->event_handler) {
@@ -737,7 +816,7 @@ retry_vsync: 
		rc = wait_for_completion_timeout(&dma->vsync_comp,

			KOFF_TIMEOUT);

		if (rc <= 0 && --retry_count) {

			int vsync = MDP3_REG_READ(MDP3_REG_INTR_STATUS) &

			vsync = MDP3_REG_READ(MDP3_REG_INTR_STATUS) &

					(1 << MDP3_INTR_LCDC_START_OF_FRAME);



			if (!vsync) {
@@ -748,6 +827,9 @@ retry_vsync: 
			rc = -1;

		}

		ATRACE_END("mdp3_wait_for_vsync_comp");



		if (!mdp3_res->irq_ref_count[MDP3_INTR_LCDC_UNDERFLOW])

			mdp3_irq_enable(MDP3_INTR_LCDC_UNDERFLOW);

	}

	pr_debug("$%s wait for vsync_comp out\n", __func__);

	ATRACE_END(__func__);
@@ -755,7 +837,7 @@ retry_vsync: 
}



static int mdp3_dmas_update(struct mdp3_dma *dma, void *buf,

				struct mdp3_intf *intf, void *data)

				struct mdp3_intf *intf, void *data, bool secure)

{

	unsigned long flag;

	int cb_type = MDP3_DMA_CALLBACK_TYPE_VSYNC;
@@ -1082,6 +1164,8 @@ int mdp3_dma_init(struct mdp3_dma *dma) 
		dma->config_histo = mdp3_dmap_histo_config;

		dma->config_lut = mdp3_dmap_lut_config;

		dma->update = mdp3_dmap_update;

		dma->handle_null_commit = mdp3_handle_null_commit;

		dma->wait_for_dma = mdp3_wait_for_dma_comp;

		dma->update_cursor = mdp3_dmap_cursor_update;

		dma->get_histo = mdp3_dmap_histo_get;

		dma->histo_op = mdp3_dmap_histo_op;
@@ -1100,6 +1184,7 @@ int mdp3_dma_init(struct mdp3_dma *dma) 
		dma->config_ccs = NULL;

		dma->config_histo = NULL;

		dma->config_lut = NULL;

		dma->handle_null_commit = NULL;

		dma->update = mdp3_dmas_update;

		dma->update_cursor = NULL;

		dma->get_histo = NULL;