Commit a19de9db authored by Srinivasan Shanmugam's avatar Srinivasan Shanmugam Committed by Alex Deucher
Browse files

drm/amd/display: Clean up style problems in amdgpu_dm_hdcp.c 



Conform to Linux kernel coding style.

And promote sysfs entry for set/get srm to kdoc.

Suggested-by: default avatarRodrigo Siqueira <Rodrigo.Siqueira@amd.com>
Cc: Rodrigo Siqueira <Rodrigo.Siqueira@amd.com>
Cc: Aurabindo Pillai <aurabindo.pillai@amd.com>
Signed-off-by: default avatarSrinivasan Shanmugam <srinivasan.shanmugam@amd.com>
Reviewed-by: default avatarAurabindo Pillai <aurabindo.pillai@amd.com>
Signed-off-by: default avatarAlex Deucher <alexander.deucher@amd.com>
parent 5b29369b

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_hdcp.c

+89 −96
Original line number Diff line number Diff line
@@ -39,10 +39,10 @@ 
static bool

lp_write_i2c(void *handle, uint32_t address, const uint8_t *data, uint32_t size)

{



	struct dc_link *link = handle;

	struct i2c_payload i2c_payloads[] = {{true, address, size, (void *)data} };

	struct i2c_command cmd = {i2c_payloads, 1, I2C_COMMAND_ENGINE_HW, link->dc->caps.i2c_speed_in_khz};

	struct i2c_command cmd = {i2c_payloads, 1, I2C_COMMAND_ENGINE_HW,

				  link->dc->caps.i2c_speed_in_khz};



	return dm_helpers_submit_i2c(link->ctx, link, &cmd);

}
@@ -52,8 +52,10 @@ lp_read_i2c(void *handle, uint32_t address, uint8_t offset, uint8_t *data, uint3 
{

	struct dc_link *link = handle;



	struct i2c_payload i2c_payloads[] = {{true, address, 1, &offset}, {false, address, size, data} };

	struct i2c_command cmd = {i2c_payloads, 2, I2C_COMMAND_ENGINE_HW, link->dc->caps.i2c_speed_in_khz};

	struct i2c_payload i2c_payloads[] = {{true, address, 1, &offset},

					     {false, address, size, data} };

	struct i2c_command cmd = {i2c_payloads, 2, I2C_COMMAND_ENGINE_HW,

				  link->dc->caps.i2c_speed_in_khz};



	return dm_helpers_submit_i2c(link->ctx, link, &cmd);

}
@@ -76,7 +78,6 @@ lp_read_dpcd(void *handle, uint32_t address, uint8_t *data, uint32_t size) 


static uint8_t *psp_get_srm(struct psp_context *psp, uint32_t *srm_version, uint32_t *srm_size)

{



	struct ta_hdcp_shared_memory *hdcp_cmd;



	if (!psp->hdcp_context.context.initialized) {
@@ -96,13 +97,12 @@ static uint8_t *psp_get_srm(struct psp_context *psp, uint32_t *srm_version, uint 
	*srm_version = hdcp_cmd->out_msg.hdcp_get_srm.srm_version;

	*srm_size = hdcp_cmd->out_msg.hdcp_get_srm.srm_buf_size;





	return hdcp_cmd->out_msg.hdcp_get_srm.srm_buf;

}



static int psp_set_srm(struct psp_context *psp, uint8_t *srm, uint32_t srm_size, uint32_t *srm_version)

static int psp_set_srm(struct psp_context *psp,

		       u8 *srm, uint32_t srm_size, uint32_t *srm_version)

{



	struct ta_hdcp_shared_memory *hdcp_cmd;



	if (!psp->hdcp_context.context.initialized) {
@@ -119,7 +119,8 @@ static int psp_set_srm(struct psp_context *psp, uint8_t *srm, uint32_t srm_size, 


	psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);



	if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS || hdcp_cmd->out_msg.hdcp_set_srm.valid_signature != 1 ||

	if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS ||

	    hdcp_cmd->out_msg.hdcp_set_srm.valid_signature != 1 ||

	    hdcp_cmd->out_msg.hdcp_set_srm.srm_version == PSP_SRM_VERSION_MAX)

		return -EINVAL;
@@ -150,7 +151,6 @@ static void process_output(struct hdcp_workqueue *hdcp_work) 


static void link_lock(struct hdcp_workqueue *work, bool lock)

{



	int i = 0;



	for (i = 0; i < work->max_link; i++) {
@@ -160,10 +160,11 @@ static void link_lock(struct hdcp_workqueue *work, bool lock) 
			mutex_unlock(&work[i].mutex);

	}

}



void hdcp_update_display(struct hdcp_workqueue *hdcp_work,

			 unsigned int link_index,

			 struct amdgpu_dm_connector *aconnector,

			 uint8_t content_type,

			 u8 content_type,

			 bool enable_encryption)

{

	struct hdcp_workqueue *hdcp_w = &hdcp_work[link_index];
@@ -178,18 +179,19 @@ void hdcp_update_display(struct hdcp_workqueue *hdcp_work, 
	query.display = NULL;

	mod_hdcp_query_display(&hdcp_w->hdcp, aconnector->base.index, &query);



	if (query.display != NULL) {

	if (query.display) {

		memcpy(display, query.display, sizeof(struct mod_hdcp_display));

		mod_hdcp_remove_display(&hdcp_w->hdcp, aconnector->base.index, &hdcp_w->output);



		hdcp_w->link.adjust.hdcp2.force_type = MOD_HDCP_FORCE_TYPE_0;



		if (enable_encryption) {

			/* Explicitly set the saved SRM as sysfs call will be after we already enabled hdcp

			 * (s3 resume case)

			/* Explicitly set the saved SRM as sysfs call will be after

			 * we already enabled hdcp (s3 resume case)

			 */

			if (hdcp_work->srm_size > 0)

				psp_set_srm(hdcp_work->hdcp.config.psp.handle, hdcp_work->srm, hdcp_work->srm_size,

				psp_set_srm(hdcp_work->hdcp.config.psp.handle, hdcp_work->srm,

					    hdcp_work->srm_size,

					    &hdcp_work->srm_version);



			display->adjust.disable = MOD_HDCP_DISPLAY_NOT_DISABLE;
@@ -238,7 +240,8 @@ static void hdcp_remove_display(struct hdcp_workqueue *hdcp_work, 
		conn_state->content_protection = DRM_MODE_CONTENT_PROTECTION_DESIRED;



		DRM_DEBUG_DRIVER("[HDCP_DM] display %d, CP 2 -> 1, type %u, DPMS %u\n",

			 aconnector->base.index, conn_state->hdcp_content_type, aconnector->base.dpms);

				 aconnector->base.index, conn_state->hdcp_content_type,

				 aconnector->base.dpms);

	}



	mod_hdcp_remove_display(&hdcp_w->hdcp, aconnector->base.index, &hdcp_w->output);
@@ -246,6 +249,7 @@ static void hdcp_remove_display(struct hdcp_workqueue *hdcp_work, 
	process_output(hdcp_w);

	mutex_unlock(&hdcp_w->mutex);

}



void hdcp_reset_display(struct hdcp_workqueue *hdcp_work, unsigned int link_index)

{

	struct hdcp_workqueue *hdcp_w = &hdcp_work[link_index];
@@ -274,9 +278,6 @@ void hdcp_handle_cpirq(struct hdcp_workqueue *hdcp_work, unsigned int link_index 
	schedule_work(&hdcp_w->cpirq_work);

}









static void event_callback(struct work_struct *work)

{

	struct hdcp_workqueue *hdcp_work;
@@ -294,13 +295,12 @@ static void event_callback(struct work_struct *work) 
	process_output(hdcp_work);



	mutex_unlock(&hdcp_work->mutex);





}



static void event_property_update(struct work_struct *work)

{

	struct hdcp_workqueue *hdcp_work = container_of(work, struct hdcp_workqueue, property_update_work);

	struct hdcp_workqueue *hdcp_work = container_of(work, struct hdcp_workqueue,

							property_update_work);

	struct amdgpu_dm_connector *aconnector = NULL;

	struct drm_device *dev;

	long ret;
@@ -334,11 +334,10 @@ static void event_property_update(struct work_struct *work) 
		mutex_lock(&hdcp_work->mutex);



		if (conn_state->commit) {

			ret = wait_for_completion_interruptible_timeout(

				&conn_state->commit->hw_done, 10 * HZ);

			ret = wait_for_completion_interruptible_timeout(&conn_state->commit->hw_done,

									10 * HZ);

			if (ret == 0) {

				DRM_ERROR(

					"HDCP state unknown! Setting it to DESIRED");

				DRM_ERROR("HDCP state unknown! Setting it to DESIRED\n");

				hdcp_work->encryption_status[conn_index] =

					MOD_HDCP_ENCRYPTION_STATUS_HDCP_OFF;

			}
@@ -349,24 +348,20 @@ static void event_property_update(struct work_struct *work) 
				DRM_MODE_HDCP_CONTENT_TYPE0 &&

				hdcp_work->encryption_status[conn_index] <=

				MOD_HDCP_ENCRYPTION_STATUS_HDCP2_TYPE0_ON) {



				DRM_DEBUG_DRIVER("[HDCP_DM] DRM_MODE_CONTENT_PROTECTION_ENABLED\n");

				drm_hdcp_update_content_protection(

					connector,

				drm_hdcp_update_content_protection(connector,

								   DRM_MODE_CONTENT_PROTECTION_ENABLED);

			} else if (conn_state->hdcp_content_type ==

					DRM_MODE_HDCP_CONTENT_TYPE1 &&

					hdcp_work->encryption_status[conn_index] ==

					MOD_HDCP_ENCRYPTION_STATUS_HDCP2_TYPE1_ON) {

				drm_hdcp_update_content_protection(

					connector,

				drm_hdcp_update_content_protection(connector,

								   DRM_MODE_CONTENT_PROTECTION_ENABLED);

			}

		} else {

			DRM_DEBUG_DRIVER("[HDCP_DM] DRM_MODE_CONTENT_PROTECTION_DESIRED\n");

			drm_hdcp_update_content_protection(

				connector, DRM_MODE_CONTENT_PROTECTION_DESIRED);



			drm_hdcp_update_content_protection(connector,

							   DRM_MODE_CONTENT_PROTECTION_DESIRED);

		}

		mutex_unlock(&hdcp_work->mutex);

		drm_modeset_unlock(&dev->mode_config.connection_mutex);
@@ -410,7 +405,8 @@ static void event_property_validate(struct work_struct *work) 
		if (query.encryption_status !=

		    hdcp_work->encryption_status[conn_index]) {

			DRM_DEBUG_DRIVER("[HDCP_DM] encryption_status change from %x to %x\n",

				hdcp_work->encryption_status[conn_index], query.encryption_status);

					 hdcp_work->encryption_status[conn_index],

					 query.encryption_status);



			hdcp_work->encryption_status[conn_index] =

				query.encryption_status;
@@ -443,7 +439,6 @@ static void event_watchdog_timer(struct work_struct *work) 
	process_output(hdcp_work);



	mutex_unlock(&hdcp_work->mutex);



}



static void event_cpirq(struct work_struct *work)
@@ -459,10 +454,8 @@ static void event_cpirq(struct work_struct *work) 
	process_output(hdcp_work);



	mutex_unlock(&hdcp_work->mutex);



}





void hdcp_destroy(struct kobject *kobj, struct hdcp_workqueue *hdcp_work)

{

	int i = 0;
@@ -478,10 +471,8 @@ void hdcp_destroy(struct kobject *kobj, struct hdcp_workqueue *hdcp_work) 
	kfree(hdcp_work);

}





static bool enable_assr(void *handle, struct dc_link *link)

{



	struct hdcp_workqueue *hdcp_work = handle;

	struct mod_hdcp hdcp = hdcp_work->hdcp;

	struct psp_context *psp = hdcp.config.psp.handle;
@@ -499,7 +490,8 @@ static bool enable_assr(void *handle, struct dc_link *link) 
	memset(dtm_cmd, 0, sizeof(struct ta_dtm_shared_memory));



	dtm_cmd->cmd_id = TA_DTM_COMMAND__TOPOLOGY_ASSR_ENABLE;

	dtm_cmd->dtm_in_message.topology_assr_enable.display_topology_dig_be_index = link->link_enc_hw_inst;

	dtm_cmd->dtm_in_message.topology_assr_enable.display_topology_dig_be_index =

		link->link_enc_hw_inst;

	dtm_cmd->dtm_status = TA_DTM_STATUS__GENERIC_FAILURE;



	psp_dtm_invoke(psp, dtm_cmd->cmd_id);
@@ -541,7 +533,7 @@ static void update_config(void *handle, struct cp_psp_stream_config *config) 
	else if (aconnector->dc_em_sink)

		sink = aconnector->dc_em_sink;



	if (sink != NULL)

	if (sink)

		link->mode = mod_hdcp_signal_type_to_operation_mode(sink->sink_signal);



	display->controller = CONTROLLER_ID_D0 + config->otg_inst;
@@ -567,16 +559,20 @@ static void update_config(void *handle, struct cp_psp_stream_config *config) 
	conn_state = aconnector->base.state;



	DRM_DEBUG_DRIVER("[HDCP_DM] display %d, CP %d, type %d\n", aconnector->base.index,

			(!!aconnector->base.state) ? aconnector->base.state->content_protection : -1,

			(!!aconnector->base.state) ? aconnector->base.state->hdcp_content_type : -1);

			 (!!aconnector->base.state) ?

			 aconnector->base.state->content_protection : -1,

			 (!!aconnector->base.state) ?

			 aconnector->base.state->hdcp_content_type : -1);



	if (conn_state)

		hdcp_update_display(hdcp_work, link_index, aconnector,

				    conn_state->hdcp_content_type, false);

}





/* NOTE: From the usermodes prospective you only need to call write *ONCE*, the kernel

/**

 * DOC: Add sysfs interface for set/get srm

 *

 * NOTE: From the usermodes prospective you only need to call write *ONCE*, the kernel

 *      will automatically call once or twice depending on the size

 *

 * call: "cat file > /sys/class/drm/card0/device/hdcp_srm" from usermode no matter what the size is
@@ -587,8 +583,8 @@ static void update_config(void *handle, struct cp_psp_stream_config *config) 
 * sysfs interface doesn't tell us the size we will get so we are sending partial SRMs to psp and on

 * the last call we will send the full SRM. PSP will fail on every call before the last.

 *

 * This means we don't know if the SRM is good until the last call. And because of this limitation we

 * cannot throw errors early as it will stop the kernel from writing to sysfs

 * This means we don't know if the SRM is good until the last call. And because of this

 * limitation we cannot throw errors early as it will stop the kernel from writing to sysfs

 *

 * Example 1:

 *	Good SRM size = 5096
@@ -621,11 +617,12 @@ static void update_config(void *handle, struct cp_psp_stream_config *config) 
 *	-if we try to "1. SET" a newer version and PSP rejects it. That means the format is

 *	incorrect/corrupted and we should correct our SRM by getting it from PSP

 */

static ssize_t srm_data_write(struct file *filp, struct kobject *kobj, struct bin_attribute *bin_attr, char *buffer,

static ssize_t srm_data_write(struct file *filp, struct kobject *kobj,

			      struct bin_attribute *bin_attr, char *buffer,

			      loff_t pos, size_t count)

{

	struct hdcp_workqueue *work;

	uint32_t srm_version = 0;

	u32 srm_version = 0;



	work = container_of(bin_attr, struct hdcp_workqueue, attr);

	link_lock(work, true);
@@ -639,19 +636,19 @@ static ssize_t srm_data_write(struct file *filp, struct kobject *kobj, struct bi 
		work->srm_version = srm_version;

	}





	link_lock(work, false);



	return count;

}



static ssize_t srm_data_read(struct file *filp, struct kobject *kobj, struct bin_attribute *bin_attr, char *buffer,

static ssize_t srm_data_read(struct file *filp, struct kobject *kobj,

			     struct bin_attribute *bin_attr, char *buffer,

			     loff_t pos, size_t count)

{

	struct hdcp_workqueue *work;

	uint8_t *srm = NULL;

	uint32_t srm_version;

	uint32_t srm_size;

	u8 *srm = NULL;

	u32 srm_version;

	u32 srm_size;

	size_t ret = count;



	work = container_of(bin_attr, struct hdcp_workqueue, attr);
@@ -688,8 +685,8 @@ static ssize_t srm_data_read(struct file *filp, struct kobject *kobj, struct bin 
 *	needs to use HDCP, the version in PSP should be SRM(ver 2). So SRM should be persistent

 *	across boot/reboots/suspend/resume/shutdown

 *

 * Currently when the system goes down (suspend/shutdown) the SRM is cleared from PSP. For HDCP we need

 * to make the SRM persistent.

 * Currently when the system goes down (suspend/shutdown) the SRM is cleared from PSP. For HDCP

 * we need to make the SRM persistent.

 *

 * -PSP owns the checking of SRM but doesn't have the ability to store it in a non-volatile memory.

 * -The kernel cannot write to the file systems.
@@ -709,10 +706,9 @@ static const struct bin_attribute data_attr = { 
	.read = srm_data_read,

};





struct hdcp_workqueue *hdcp_create_workqueue(struct amdgpu_device *adev, struct cp_psp *cp_psp, struct dc *dc)

struct hdcp_workqueue *hdcp_create_workqueue(struct amdgpu_device *adev,

					     struct cp_psp *cp_psp, struct dc *dc)

{



	int max_caps = dc->caps.max_links;

	struct hdcp_workqueue *hdcp_work;

	int i = 0;
@@ -721,14 +717,16 @@ struct hdcp_workqueue *hdcp_create_workqueue(struct amdgpu_device *adev, struct 
	if (ZERO_OR_NULL_PTR(hdcp_work))

		return NULL;



	hdcp_work->srm = kcalloc(PSP_HDCP_SRM_FIRST_GEN_MAX_SIZE, sizeof(*hdcp_work->srm), GFP_KERNEL);

	hdcp_work->srm = kcalloc(PSP_HDCP_SRM_FIRST_GEN_MAX_SIZE,

				 sizeof(*hdcp_work->srm), GFP_KERNEL);



	if (hdcp_work->srm == NULL)

	if (!hdcp_work->srm)

		goto fail_alloc_context;



	hdcp_work->srm_temp = kcalloc(PSP_HDCP_SRM_FIRST_GEN_MAX_SIZE, sizeof(*hdcp_work->srm_temp), GFP_KERNEL);

	hdcp_work->srm_temp = kcalloc(PSP_HDCP_SRM_FIRST_GEN_MAX_SIZE,

				      sizeof(*hdcp_work->srm_temp), GFP_KERNEL);



	if (hdcp_work->srm_temp == NULL)

	if (!hdcp_work->srm_temp)

		goto fail_alloc_context;



	hdcp_work->max_link = max_caps;
@@ -781,10 +779,5 @@ struct hdcp_workqueue *hdcp_create_workqueue(struct amdgpu_device *adev, struct 
	kfree(hdcp_work);



	return NULL;







}