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

Commit 8bb5b25a authored by qctecmdr Service's avatar qctecmdr Service Committed by Gerrit - the friendly Code Review server
Browse files

Merge "drm/msm/hdcp: send type on minimum encryption level change"

parents d8a23cb5 f00ab632

drivers/gpu/drm/msm/dp/dp_hdcp2p2.c

+7 −3
Original line number Diff line number Diff line
@@ -315,20 +315,24 @@ static int dp_hdcp2p2_reauthenticate(void *input) 
}



static void dp_hdcp2p2_min_level_change(void *client_ctx,

		int min_enc_level)

		u8 min_enc_level)

{

	struct dp_hdcp2p2_ctrl *ctrl = (struct dp_hdcp2p2_ctrl *)client_ctx;

	struct sde_hdcp_2x_wakeup_data cdata = {

		HDCP_2X_CMD_QUERY_STREAM_TYPE};

		HDCP_2X_CMD_MIN_ENC_LEVEL};



	if (!ctrl) {

		pr_err("invalid input\n");

		return;

	}



	pr_debug("enc level changed %d\n", min_enc_level);

	if (!dp_hdcp2p2_is_valid_state(ctrl)) {

		pr_err("invalid state\n");

		return;

	}



	cdata.context = ctrl->lib_ctx;

	cdata.min_enc_level = min_enc_level;

	dp_hdcp2p2_wakeup_lib(ctrl, &cdata);

}

drivers/gpu/drm/msm/sde_hdcp_2x.c

+72 −1
Original line number Diff line number Diff line
@@ -73,6 +73,7 @@ struct sde_hdcp_2x_ctrl { 
	int last_msg;

	atomic_t hdcp_off;

	enum sde_hdcp_2x_device_type device_type;

	u8 min_enc_level;



	struct task_struct *thread;

	struct completion response_completion;
@@ -85,6 +86,7 @@ struct sde_hdcp_2x_ctrl { 
	struct kthread_work wk_clean;

	struct kthread_work wk_stream;

	struct kthread_work wk_wait;

	struct kthread_work wk_send_type;

};



static const char *sde_hdcp_2x_message_name(int msg_id)
@@ -230,6 +232,8 @@ static int sde_hdcp_2x_get_next_message(struct sde_hdcp_2x_ctrl *hdcp, 
		if (!hdcp->repeater_flag)

			return SKE_SEND_TYPE_ID;

	case SKE_SEND_TYPE_ID:

		if (!hdcp->repeater_flag)

			return SKE_SEND_TYPE_ID;

	case REP_STREAM_READY:

	case REP_SEND_ACK:

		if (!hdcp->repeater_flag)
@@ -397,6 +401,61 @@ static void sde_hdcp_2x_cleanup_work(struct kthread_work *work) 
	sde_hdcp_2x_clean(hdcp);

}



static u8 sde_hdcp_2x_stream_type(u8 min_enc_level)

{

	u8 stream_type = 0;

	u8 const hdcp_min_enc_level_0 = 0, hdcp_min_enc_level_1 = 1,

	   hdcp_min_enc_level_2 = 2;

	u8 const stream_type_0 = 0, stream_type_1 = 1;



	switch (min_enc_level) {

	case hdcp_min_enc_level_0:

	case hdcp_min_enc_level_1:

		stream_type = stream_type_0;

		break;

	case hdcp_min_enc_level_2:

		stream_type = stream_type_1;

		break;

	default:

		stream_type = stream_type_0;

		break;

	}



	pr_debug("min_enc_level = %u, type = %u", min_enc_level, stream_type);



	return stream_type;

}



static void sde_hdcp_2x_send_type(struct sde_hdcp_2x_ctrl *hdcp)

{

	if (atomic_read(&hdcp->hdcp_off)) {

		pr_debug("invalid state, hdcp off\n");

		return;

	}



	if (hdcp->repeater_flag) {

		pr_debug("invalid state, not receiver\n");

		return;

	}



	hdcp->app_data.response.data[0] = SKE_SEND_TYPE_ID;

	hdcp->app_data.response.data[1] =

		sde_hdcp_2x_stream_type(hdcp->min_enc_level);

	hdcp->app_data.response.length = 1;

	hdcp->app_data.timeout = 100;



	if (!atomic_read(&hdcp->hdcp_off))

		sde_hdcp_2x_send_message(hdcp);

}



static void sde_hdcp_2x_send_type_work(struct kthread_work *work)

{

	struct sde_hdcp_2x_ctrl *hdcp =

		container_of(work, struct sde_hdcp_2x_ctrl, wk_send_type);



	sde_hdcp_2x_send_type(hdcp);

}



static void sde_hdcp_2x_stream(struct sde_hdcp_2x_ctrl *hdcp)

{

	int rc = 0;
@@ -476,7 +535,9 @@ static void sde_hdcp_2x_msg_sent(struct sde_hdcp_2x_ctrl *hdcp) 
					HDCP_TRANSPORT_CMD_LINK_POLL, &cdata);

		} else {

			hdcp->app_data.response.data[0] = SKE_SEND_TYPE_ID;

			hdcp->app_data.response.length = 2;

			hdcp->app_data.response.data[1] =

				sde_hdcp_2x_stream_type(hdcp->min_enc_level);

			hdcp->app_data.response.length = 1;

			hdcp->app_data.timeout = 100;



			sde_hdcp_2x_send_message(hdcp);
@@ -795,6 +856,15 @@ static int sde_hdcp_2x_wakeup(struct sde_hdcp_2x_wakeup_data *data) 
		HDCP_2X_EXECUTE(timeout);

		break;

	case HDCP_2X_CMD_QUERY_STREAM_TYPE:

		HDCP_2X_EXECUTE(stream);

		break;

	case HDCP_2X_CMD_MIN_ENC_LEVEL:

		hdcp->min_enc_level = data->min_enc_level;

		if (!hdcp->repeater_flag) {

			HDCP_2X_EXECUTE(send_type);

			break;

		}



		HDCP_2X_EXECUTE(stream);

		break;

	default:
@@ -861,6 +931,7 @@ int sde_hdcp_2x_register(struct sde_hdcp_2x_register_data *data) 
	kthread_init_work(&hdcp->wk_clean,     sde_hdcp_2x_cleanup_work);

	kthread_init_work(&hdcp->wk_stream,    sde_hdcp_2x_query_stream_work);

	kthread_init_work(&hdcp->wk_wait, sde_hdcp_2x_wait_for_response_work);

	kthread_init_work(&hdcp->wk_send_type,    sde_hdcp_2x_send_type_work);



	init_completion(&hdcp->response_completion);

drivers/gpu/drm/msm/sde_hdcp_2x.h

+3 −0
Original line number Diff line number Diff line
@@ -32,6 +32,7 @@ 
 * @HDCP_2X_CMD_MSG_RECV_TIMEOUT:  receiving message from sink timed out

 * @HDCP_2X_CMD_QUERY_STREAM_TYPE: start content stream processing

 * @HDCP_2X_CMD_LINK_FAILED:       link failure notification

 * @HDCP_2X_CMD_MIN_ENC_LEVEL:     trigger minimum encryption level change

 */

enum sde_hdcp_2x_wakeup_cmd {

	HDCP_2X_CMD_INVALID,
@@ -45,6 +46,7 @@ enum sde_hdcp_2x_wakeup_cmd { 
	HDCP_2X_CMD_MSG_RECV_TIMEOUT,

	HDCP_2X_CMD_QUERY_STREAM_TYPE,

	HDCP_2X_CMD_LINK_FAILED,

	HDCP_2X_CMD_MIN_ENC_LEVEL,

};



/**
@@ -85,6 +87,7 @@ struct sde_hdcp_2x_wakeup_data { 
	void *context;

	uint32_t total_message_length;

	uint32_t timeout;

	u8 min_enc_level;

};



/**

drivers/misc/msm_hdcp.c

+3 −3
Original line number Diff line number Diff line
@@ -38,11 +38,11 @@ struct msm_hdcp { 
	struct HDCP_V2V1_MSG_TOPOLOGY cached_tp;

	u32 tp_msgid;

	void *client_ctx;

	void (*cb)(void *ctx, int data);

	void (*cb)(void *ctx, u8 data);

};



void msm_hdcp_register_cb(struct device *dev, void *ctx,

		void (*cb)(void *ctx, int data))

		void (*cb)(void *ctx, u8 data))

{

	struct msm_hdcp *hdcp = NULL;
@@ -278,7 +278,7 @@ static int msm_hdcp_probe(struct platform_device *pdev) 
	}



	hdcp->device = device_create(hdcp->class, NULL,

		hdcp->dev_num, NULL, DRIVER_NAME);

		hdcp->dev_num, hdcp, DRIVER_NAME);

	if (IS_ERR(hdcp->device)) {

		ret = PTR_ERR(hdcp->device);

		pr_err("device_create failed %d\n", ret);

include/linux/msm_hdcp.h

+1 −1
Original line number Diff line number Diff line
@@ -19,7 +19,7 @@ void msm_hdcp_notify_topology(struct device *dev); 
void msm_hdcp_cache_repeater_topology(struct device *dev,

			struct HDCP_V2V1_MSG_TOPOLOGY *tp);

void msm_hdcp_register_cb(struct device *dev, void *ctx,

	void (*cb)(void *ctx, int data));

	void (*cb)(void *ctx, u8 data));



#endif /* __MSM_HDCP_H */