hdcp_psp.c

   1/*
   2 * Copyright 2018 Advanced Micro Devices, Inc.
   3 *
   4 * Permission is hereby granted, free of charge, to any person obtaining a
   5 * copy of this software and associated documentation files (the "Software"),
   6 * to deal in the Software without restriction, including without limitation
   7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8 * and/or sell copies of the Software, and to permit persons to whom the
   9 * Software is furnished to do so, subject to the following conditions:
  10 *
  11 * The above copyright notice and this permission notice shall be included in
  12 * all copies or substantial portions of the Software.
  13 *
  14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  17 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
  18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  20 * OTHER DEALINGS IN THE SOFTWARE.
  21 *
  22 * Authors: AMD
  23 *
  24 */
  25
  26#define MAX_NUM_DISPLAYS 24
  27
  28
  29#include "hdcp.h"
  30
  31#include "amdgpu.h"
  32#include "hdcp_psp.h"
  33
  34static void hdcp2_message_init(struct mod_hdcp *hdcp,
  35			       struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *in)
  36{
  37	in->session_handle = hdcp->auth.id;
  38	in->prepare.msg1_id = TA_HDCP_HDCP2_MSG_ID__NULL_MESSAGE;
  39	in->prepare.msg2_id = TA_HDCP_HDCP2_MSG_ID__NULL_MESSAGE;
  40	in->process.msg1_desc.msg_id = TA_HDCP_HDCP2_MSG_ID__NULL_MESSAGE;
  41	in->process.msg1_desc.msg_size = 0;
  42	in->process.msg2_desc.msg_id = TA_HDCP_HDCP2_MSG_ID__NULL_MESSAGE;
  43	in->process.msg2_desc.msg_size = 0;
  44	in->process.msg3_desc.msg_id = TA_HDCP_HDCP2_MSG_ID__NULL_MESSAGE;
  45	in->process.msg3_desc.msg_size = 0;
  46}
  47
  48static enum mod_hdcp_status remove_display_from_topology_v2(
  49		struct mod_hdcp *hdcp, uint8_t index)
  50{
  51	struct psp_context *psp = hdcp->config.psp.handle;
  52	struct ta_dtm_shared_memory *dtm_cmd;
  53	struct mod_hdcp_display *display =
  54			get_active_display_at_index(hdcp, index);
  55	enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
  56
  57	dtm_cmd = (struct ta_dtm_shared_memory *)psp->dtm_context.context.mem_context.shared_buf;
  58
  59	if (!display || !is_display_active(display))
  60		return MOD_HDCP_STATUS_DISPLAY_NOT_FOUND;
  61
  62	mutex_lock(&psp->dtm_context.mutex);
  63
  64	memset(dtm_cmd, 0, sizeof(struct ta_dtm_shared_memory));
  65
  66	dtm_cmd->cmd_id = TA_DTM_COMMAND__TOPOLOGY_UPDATE_V2;
  67	dtm_cmd->dtm_in_message.topology_update_v2.display_handle = display->index;
  68	dtm_cmd->dtm_in_message.topology_update_v2.is_active = 0;
  69	dtm_cmd->dtm_status = TA_DTM_STATUS__GENERIC_FAILURE;
  70
  71	psp_dtm_invoke(psp, dtm_cmd->cmd_id);
  72
  73	if (dtm_cmd->dtm_status != TA_DTM_STATUS__SUCCESS) {
  74		status = MOD_HDCP_STATUS_UPDATE_TOPOLOGY_FAILURE;
  75	} else {
  76		display->state = MOD_HDCP_DISPLAY_ACTIVE;
  77		HDCP_TOP_REMOVE_DISPLAY_TRACE(hdcp, display->index);
  78	}
  79
  80	mutex_unlock(&psp->dtm_context.mutex);
  81	return status;
  82}
  83
  84static enum mod_hdcp_status remove_display_from_topology_v3(
  85		struct mod_hdcp *hdcp, uint8_t index)
  86{
  87	struct psp_context *psp = hdcp->config.psp.handle;
  88	struct ta_dtm_shared_memory *dtm_cmd;
  89	struct mod_hdcp_display *display =
  90		get_active_display_at_index(hdcp, index);
  91	enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
  92
  93	dtm_cmd = (struct ta_dtm_shared_memory *)psp->dtm_context.context.mem_context.shared_buf;
  94
  95	if (!display || !is_display_active(display))
  96		return MOD_HDCP_STATUS_DISPLAY_NOT_FOUND;
  97
  98	mutex_lock(&psp->dtm_context.mutex);
  99
 100	memset(dtm_cmd, 0, sizeof(struct ta_dtm_shared_memory));
 101
 102	dtm_cmd->cmd_id = TA_DTM_COMMAND__TOPOLOGY_UPDATE_V3;
 103	dtm_cmd->dtm_in_message.topology_update_v3.display_handle = display->index;
 104	dtm_cmd->dtm_in_message.topology_update_v3.is_active = 0;
 105	dtm_cmd->dtm_status = TA_DTM_STATUS__GENERIC_FAILURE;
 106
 107	psp_dtm_invoke(psp, dtm_cmd->cmd_id);
 108	mutex_unlock(&psp->dtm_context.mutex);
 109
 110	if (dtm_cmd->dtm_status != TA_DTM_STATUS__SUCCESS) {
 111		status = remove_display_from_topology_v2(hdcp, index);
 112		if (status != MOD_HDCP_STATUS_SUCCESS)
 113			display->state = MOD_HDCP_DISPLAY_INACTIVE;
 114	} else {
 115		display->state = MOD_HDCP_DISPLAY_ACTIVE;
 116		HDCP_TOP_REMOVE_DISPLAY_TRACE(hdcp, display->index);
 117	}
 118
 119	return status;
 120}
 121
 122static enum mod_hdcp_status add_display_to_topology_v2(
 123		struct mod_hdcp *hdcp, struct mod_hdcp_display *display)
 124{
 125	struct psp_context *psp = hdcp->config.psp.handle;
 126	struct ta_dtm_shared_memory *dtm_cmd;
 127	struct mod_hdcp_link *link = &hdcp->connection.link;
 128	enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
 129
 130	if (!psp->dtm_context.context.initialized) {
 131		DRM_INFO("Failed to add display topology, DTM TA is not initialized.");
 132		display->state = MOD_HDCP_DISPLAY_INACTIVE;
 133		return MOD_HDCP_STATUS_FAILURE;
 134	}
 135
 136	dtm_cmd = (struct ta_dtm_shared_memory *)psp->dtm_context.context.mem_context.shared_buf;
 137
 138	mutex_lock(&psp->dtm_context.mutex);
 139	memset(dtm_cmd, 0, sizeof(struct ta_dtm_shared_memory));
 140
 141	dtm_cmd->cmd_id = TA_DTM_COMMAND__TOPOLOGY_UPDATE_V2;
 142	dtm_cmd->dtm_in_message.topology_update_v2.display_handle = display->index;
 143	dtm_cmd->dtm_in_message.topology_update_v2.is_active = 1;
 144	dtm_cmd->dtm_in_message.topology_update_v2.controller = display->controller;
 145	dtm_cmd->dtm_in_message.topology_update_v2.ddc_line = link->ddc_line;
 146	dtm_cmd->dtm_in_message.topology_update_v2.dig_be = link->dig_be;
 147	dtm_cmd->dtm_in_message.topology_update_v2.dig_fe = display->dig_fe;
 148	if (is_dp_hdcp(hdcp))
 149		dtm_cmd->dtm_in_message.topology_update_v2.is_assr = link->dp.assr_enabled;
 150
 151	dtm_cmd->dtm_in_message.topology_update_v2.dp_mst_vcid = display->vc_id;
 152	dtm_cmd->dtm_in_message.topology_update_v2.max_hdcp_supported_version =
 153			TA_DTM_HDCP_VERSION_MAX_SUPPORTED__2_2;
 154	dtm_cmd->dtm_status = TA_DTM_STATUS__GENERIC_FAILURE;
 155
 156	psp_dtm_invoke(psp, dtm_cmd->cmd_id);
 157
 158	if (dtm_cmd->dtm_status != TA_DTM_STATUS__SUCCESS) {
 159		display->state = MOD_HDCP_DISPLAY_INACTIVE;
 160		status = MOD_HDCP_STATUS_UPDATE_TOPOLOGY_FAILURE;
 161	} else {
 162		HDCP_TOP_ADD_DISPLAY_TRACE(hdcp, display->index);
 163	}
 164
 165	mutex_unlock(&psp->dtm_context.mutex);
 166	return status;
 167}
 168
 169static enum mod_hdcp_status add_display_to_topology_v3(
 170		struct mod_hdcp *hdcp, struct mod_hdcp_display *display)
 171{
 172	struct psp_context *psp = hdcp->config.psp.handle;
 173	struct ta_dtm_shared_memory *dtm_cmd;
 174	struct mod_hdcp_link *link = &hdcp->connection.link;
 175	enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
 176
 177	if (!psp->dtm_context.context.initialized) {
 178		DRM_INFO("Failed to add display topology, DTM TA is not initialized.");
 179		display->state = MOD_HDCP_DISPLAY_INACTIVE;
 180		return MOD_HDCP_STATUS_FAILURE;
 181	}
 182
 183	dtm_cmd = (struct ta_dtm_shared_memory *)psp->dtm_context.context.mem_context.shared_buf;
 184
 185	mutex_lock(&psp->dtm_context.mutex);
 186	memset(dtm_cmd, 0, sizeof(struct ta_dtm_shared_memory));
 187
 188	dtm_cmd->cmd_id = TA_DTM_COMMAND__TOPOLOGY_UPDATE_V3;
 189	dtm_cmd->dtm_in_message.topology_update_v3.display_handle = display->index;
 190	dtm_cmd->dtm_in_message.topology_update_v3.is_active = 1;
 191	dtm_cmd->dtm_in_message.topology_update_v3.controller = display->controller;
 192	dtm_cmd->dtm_in_message.topology_update_v3.ddc_line = link->ddc_line;
 193	dtm_cmd->dtm_in_message.topology_update_v3.link_enc = link->link_enc_idx;
 194	dtm_cmd->dtm_in_message.topology_update_v3.stream_enc = display->stream_enc_idx;
 195	if (is_dp_hdcp(hdcp))
 196		dtm_cmd->dtm_in_message.topology_update_v3.is_assr = link->dp.assr_enabled;
 197
 198	dtm_cmd->dtm_in_message.topology_update_v3.dp_mst_vcid = display->vc_id;
 199	dtm_cmd->dtm_in_message.topology_update_v3.max_hdcp_supported_version =
 200			TA_DTM_HDCP_VERSION_MAX_SUPPORTED__2_3;
 201	dtm_cmd->dtm_in_message.topology_update_v3.encoder_type = TA_DTM_ENCODER_TYPE__DIG;
 202	dtm_cmd->dtm_status = TA_DTM_STATUS__GENERIC_FAILURE;
 203	dtm_cmd->dtm_in_message.topology_update_v3.phy_id = link->phy_idx;
 204	dtm_cmd->dtm_in_message.topology_update_v3.link_hdcp_cap = link->hdcp_supported_informational;
 205	dtm_cmd->dtm_in_message.topology_update_v3.dio_output_type = link->dp.usb4_enabled ?
 206			TA_DTM_DIO_OUTPUT_TYPE__DPIA :
 207			TA_DTM_DIO_OUTPUT_TYPE__DIRECT;
 208	dtm_cmd->dtm_in_message.topology_update_v3.dio_output_id = link->dio_output_id;
 209
 210	psp_dtm_invoke(psp, dtm_cmd->cmd_id);
 211	mutex_unlock(&psp->dtm_context.mutex);
 212
 213	if (dtm_cmd->dtm_status != TA_DTM_STATUS__SUCCESS) {
 214		status = add_display_to_topology_v2(hdcp, display);
 215		if (status != MOD_HDCP_STATUS_SUCCESS)
 216			display->state = MOD_HDCP_DISPLAY_INACTIVE;
 217	} else {
 218		HDCP_TOP_ADD_DISPLAY_TRACE(hdcp, display->index);
 219	}
 220
 221	return status;
 222}
 223
 224enum mod_hdcp_status mod_hdcp_remove_display_from_topology(
 225		struct mod_hdcp *hdcp, uint8_t index)
 226{
 227	enum mod_hdcp_status status = MOD_HDCP_STATUS_UPDATE_TOPOLOGY_FAILURE;
 228
 229	if (hdcp->config.psp.caps.dtm_v3_supported)
 230		status = remove_display_from_topology_v3(hdcp, index);
 231	else
 232		status = remove_display_from_topology_v2(hdcp, index);
 233
 234	return status;
 235}
 236
 237enum mod_hdcp_status mod_hdcp_add_display_to_topology(struct mod_hdcp *hdcp,
 238					       struct mod_hdcp_display *display)
 239{
 240	enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
 241
 242	if (hdcp->config.psp.caps.dtm_v3_supported)
 243		status = add_display_to_topology_v3(hdcp, display);
 244	else
 245		status = add_display_to_topology_v2(hdcp, display);
 246
 247	return status;
 248}
 249
 250enum mod_hdcp_status mod_hdcp_hdcp1_create_session(struct mod_hdcp *hdcp)
 251{
 252
 253	struct psp_context *psp = hdcp->config.psp.handle;
 254	struct mod_hdcp_display *display = get_first_active_display(hdcp);
 255	struct ta_hdcp_shared_memory *hdcp_cmd;
 256	enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
 257
 258	if (!psp->hdcp_context.context.initialized) {
 259		DRM_ERROR("Failed to create hdcp session. HDCP TA is not initialized.");
 260		return MOD_HDCP_STATUS_FAILURE;
 261	}
 262
 263	if (!display)
 264		return MOD_HDCP_STATUS_DISPLAY_NOT_FOUND;
 265
 266	hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.shared_buf;
 267
 268	mutex_lock(&psp->hdcp_context.mutex);
 269	memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
 270
 271	hdcp_cmd->in_msg.hdcp1_create_session.display_handle = display->index;
 272	hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP1_CREATE_SESSION;
 273
 274	psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
 275
 276	hdcp->auth.id = hdcp_cmd->out_msg.hdcp1_create_session.session_handle;
 277
 278	if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) {
 279		status = MOD_HDCP_STATUS_HDCP1_CREATE_SESSION_FAILURE;
 280	} else {
 281		hdcp->auth.msg.hdcp1.ainfo = hdcp_cmd->out_msg.hdcp1_create_session.ainfo_primary;
 282		memcpy(hdcp->auth.msg.hdcp1.aksv, hdcp_cmd->out_msg.hdcp1_create_session.aksv_primary,
 283		       sizeof(hdcp->auth.msg.hdcp1.aksv));
 284		memcpy(hdcp->auth.msg.hdcp1.an, hdcp_cmd->out_msg.hdcp1_create_session.an_primary,
 285		       sizeof(hdcp->auth.msg.hdcp1.an));
 286	}
 287
 288	mutex_unlock(&psp->hdcp_context.mutex);
 289	return status;
 290}
 291
 292enum mod_hdcp_status mod_hdcp_hdcp1_destroy_session(struct mod_hdcp *hdcp)
 293{
 294
 295	struct psp_context *psp = hdcp->config.psp.handle;
 296	struct ta_hdcp_shared_memory *hdcp_cmd;
 297	uint8_t i = 0;
 298	enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
 299
 300	mutex_lock(&psp->hdcp_context.mutex);
 301	hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.shared_buf;
 302	memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
 303
 304	hdcp_cmd->in_msg.hdcp1_destroy_session.session_handle = hdcp->auth.id;
 305	hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP1_DESTROY_SESSION;
 306
 307	psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
 308
 309	if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) {
 310		status = MOD_HDCP_STATUS_HDCP1_DESTROY_SESSION_FAILURE;
 311	} else {
 312		HDCP_TOP_HDCP1_DESTROY_SESSION_TRACE(hdcp);
 313		for (i = 0; i < MAX_NUM_OF_DISPLAYS; i++)
 314			if (is_display_encryption_enabled(&hdcp->displays[i])) {
 315				hdcp->displays[i].state =
 316							MOD_HDCP_DISPLAY_ACTIVE;
 317				HDCP_HDCP1_DISABLED_TRACE(
 318					hdcp, hdcp->displays[i].index);
 319			}
 320	}
 321
 322	mutex_unlock(&psp->hdcp_context.mutex);
 323	return status;
 324}
 325
 326enum mod_hdcp_status mod_hdcp_hdcp1_validate_rx(struct mod_hdcp *hdcp)
 327{
 328	struct psp_context *psp = hdcp->config.psp.handle;
 329	struct ta_hdcp_shared_memory *hdcp_cmd;
 330	enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
 331
 332	mutex_lock(&psp->hdcp_context.mutex);
 333	hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.shared_buf;
 334	memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
 335
 336	hdcp_cmd->in_msg.hdcp1_first_part_authentication.session_handle = hdcp->auth.id;
 337
 338	memcpy(hdcp_cmd->in_msg.hdcp1_first_part_authentication.bksv_primary, hdcp->auth.msg.hdcp1.bksv,
 339		TA_HDCP__HDCP1_KSV_SIZE);
 340
 341	hdcp_cmd->in_msg.hdcp1_first_part_authentication.r0_prime_primary = hdcp->auth.msg.hdcp1.r0p;
 342	hdcp_cmd->in_msg.hdcp1_first_part_authentication.bcaps = hdcp->auth.msg.hdcp1.bcaps;
 343	hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP1_FIRST_PART_AUTHENTICATION;
 344
 345	psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
 346
 347	if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) {
 348		status = MOD_HDCP_STATUS_HDCP1_VALIDATE_RX_FAILURE;
 349	} else if (hdcp_cmd->out_msg.hdcp1_first_part_authentication.authentication_status ==
 350	    TA_HDCP_AUTHENTICATION_STATUS__HDCP1_FIRST_PART_COMPLETE) {
 351		/* needs second part of authentication */
 352		hdcp->connection.is_repeater = 1;
 353	} else if (hdcp_cmd->out_msg.hdcp1_first_part_authentication.authentication_status ==
 354		   TA_HDCP_AUTHENTICATION_STATUS__HDCP1_AUTHENTICATED) {
 355		hdcp->connection.is_repeater = 0;
 356	} else if (hdcp_cmd->out_msg.hdcp1_first_part_authentication.authentication_status ==
 357		   TA_HDCP_AUTHENTICATION_STATUS__HDCP1_KSV_REVOKED) {
 358		hdcp->connection.is_hdcp1_revoked = 1;
 359		status = MOD_HDCP_STATUS_HDCP1_BKSV_REVOKED;
 360	} else
 361		status = MOD_HDCP_STATUS_HDCP1_VALIDATE_RX_FAILURE;
 362
 363	mutex_unlock(&psp->hdcp_context.mutex);
 364	return status;
 365}
 366
 367enum mod_hdcp_status mod_hdcp_hdcp1_enable_encryption(struct mod_hdcp *hdcp)
 368{
 369	struct psp_context *psp = hdcp->config.psp.handle;
 370	struct ta_hdcp_shared_memory *hdcp_cmd;
 371	struct mod_hdcp_display *display = get_first_active_display(hdcp);
 372	enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
 373
 374	if (!display)
 375		return MOD_HDCP_STATUS_DISPLAY_NOT_FOUND;
 376
 377	mutex_lock(&psp->hdcp_context.mutex);
 378	hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.shared_buf;
 379	memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
 380
 381	hdcp_cmd->in_msg.hdcp1_enable_encryption.session_handle = hdcp->auth.id;
 382	hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP1_ENABLE_ENCRYPTION;
 383
 384	psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
 385
 386	if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) {
 387		status = MOD_HDCP_STATUS_HDCP1_ENABLE_ENCRYPTION_FAILURE;
 388	} else if (!is_dp_mst_hdcp(hdcp)) {
 389		display->state = MOD_HDCP_DISPLAY_ENCRYPTION_ENABLED;
 390		HDCP_HDCP1_ENABLED_TRACE(hdcp, display->index);
 391	}
 392
 393	mutex_unlock(&psp->hdcp_context.mutex);
 394	return status;
 395}
 396
 397enum mod_hdcp_status mod_hdcp_hdcp1_validate_ksvlist_vp(struct mod_hdcp *hdcp)
 398{
 399	struct psp_context *psp = hdcp->config.psp.handle;
 400	struct ta_hdcp_shared_memory *hdcp_cmd;
 401	enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
 402
 403	mutex_lock(&psp->hdcp_context.mutex);
 404	hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.shared_buf;
 405	memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
 406
 407	hdcp_cmd->in_msg.hdcp1_second_part_authentication.session_handle = hdcp->auth.id;
 408
 409	hdcp_cmd->in_msg.hdcp1_second_part_authentication.ksv_list_size = hdcp->auth.msg.hdcp1.ksvlist_size;
 410	memcpy(hdcp_cmd->in_msg.hdcp1_second_part_authentication.ksv_list, hdcp->auth.msg.hdcp1.ksvlist,
 411	       hdcp->auth.msg.hdcp1.ksvlist_size);
 412
 413	memcpy(hdcp_cmd->in_msg.hdcp1_second_part_authentication.v_prime, hdcp->auth.msg.hdcp1.vp,
 414	       sizeof(hdcp->auth.msg.hdcp1.vp));
 415
 416	hdcp_cmd->in_msg.hdcp1_second_part_authentication.bstatus_binfo =
 417		is_dp_hdcp(hdcp) ? hdcp->auth.msg.hdcp1.binfo_dp : hdcp->auth.msg.hdcp1.bstatus;
 418	hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP1_SECOND_PART_AUTHENTICATION;
 419
 420	psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
 421
 422	if (hdcp_cmd->hdcp_status == TA_HDCP_STATUS__SUCCESS &&
 423	    hdcp_cmd->out_msg.hdcp1_second_part_authentication.authentication_status ==
 424		    TA_HDCP_AUTHENTICATION_STATUS__HDCP1_AUTHENTICATED) {
 425		status = MOD_HDCP_STATUS_SUCCESS;
 426	} else if (hdcp_cmd->out_msg.hdcp1_second_part_authentication.authentication_status ==
 427		   TA_HDCP_AUTHENTICATION_STATUS__HDCP1_KSV_REVOKED) {
 428		hdcp->connection.is_hdcp1_revoked = 1;
 429		status = MOD_HDCP_STATUS_HDCP1_KSV_LIST_REVOKED;
 430	} else {
 431		status = MOD_HDCP_STATUS_HDCP1_VALIDATE_KSV_LIST_FAILURE;
 432	}
 433
 434	mutex_unlock(&psp->hdcp_context.mutex);
 435	return status;
 436}
 437
 438enum mod_hdcp_status mod_hdcp_hdcp1_enable_dp_stream_encryption(struct mod_hdcp *hdcp)
 439{
 440
 441	struct psp_context *psp = hdcp->config.psp.handle;
 442	struct ta_hdcp_shared_memory *hdcp_cmd;
 443	int i = 0;
 444	enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
 445
 446	mutex_lock(&psp->hdcp_context.mutex);
 447	hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.shared_buf;
 448
 449	for (i = 0; i < MAX_NUM_OF_DISPLAYS; i++) {
 450
 451		if (hdcp->displays[i].adjust.disable || hdcp->displays[i].state != MOD_HDCP_DISPLAY_ACTIVE)
 452			continue;
 453
 454		memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
 455
 456		hdcp_cmd->in_msg.hdcp1_enable_dp_stream_encryption.session_handle = hdcp->auth.id;
 457		hdcp_cmd->in_msg.hdcp1_enable_dp_stream_encryption.display_handle = hdcp->displays[i].index;
 458		hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP1_ENABLE_DP_STREAM_ENCRYPTION;
 459
 460		psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
 461
 462		if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) {
 463			status = MOD_HDCP_STATUS_HDCP1_ENABLE_STREAM_ENCRYPTION_FAILURE;
 464			break;
 465		}
 466
 467		hdcp->displays[i].state = MOD_HDCP_DISPLAY_ENCRYPTION_ENABLED;
 468		HDCP_HDCP1_ENABLED_TRACE(hdcp, hdcp->displays[i].index);
 469	}
 470
 471	mutex_unlock(&psp->hdcp_context.mutex);
 472	return status;
 473}
 474
 475enum mod_hdcp_status mod_hdcp_hdcp1_link_maintenance(struct mod_hdcp *hdcp)
 476{
 477	struct psp_context *psp = hdcp->config.psp.handle;
 478	struct ta_hdcp_shared_memory *hdcp_cmd;
 479	enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
 480
 481	mutex_lock(&psp->hdcp_context.mutex);
 482	hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.shared_buf;
 483
 484	memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
 485
 486	hdcp_cmd->in_msg.hdcp1_get_encryption_status.session_handle = hdcp->auth.id;
 487
 488	hdcp_cmd->out_msg.hdcp1_get_encryption_status.protection_level = 0;
 489	hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP1_GET_ENCRYPTION_STATUS;
 490
 491	psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
 492
 493	if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS ||
 494			hdcp_cmd->out_msg.hdcp1_get_encryption_status.protection_level != 1)
 495		status = MOD_HDCP_STATUS_HDCP1_LINK_MAINTENANCE_FAILURE;
 496
 497	mutex_unlock(&psp->hdcp_context.mutex);
 498	return status;
 499}
 500
 501enum mod_hdcp_status mod_hdcp_hdcp2_create_session(struct mod_hdcp *hdcp)
 502{
 503	struct psp_context *psp = hdcp->config.psp.handle;
 504	struct ta_hdcp_shared_memory *hdcp_cmd;
 505	struct mod_hdcp_display *display = get_first_active_display(hdcp);
 506	enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
 507
 508
 509	if (!psp->hdcp_context.context.initialized) {
 510		DRM_ERROR("Failed to create hdcp session, HDCP TA is not initialized");
 511		return MOD_HDCP_STATUS_FAILURE;
 512	}
 513
 514	if (!display)
 515		return MOD_HDCP_STATUS_DISPLAY_NOT_FOUND;
 516
 517	mutex_lock(&psp->hdcp_context.mutex);
 518
 519	hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.shared_buf;
 520	memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
 521
 522	hdcp_cmd->in_msg.hdcp2_create_session_v2.display_handle = display->index;
 523
 524	if (hdcp->connection.link.adjust.hdcp2.force_type == MOD_HDCP_FORCE_TYPE_0)
 525		hdcp_cmd->in_msg.hdcp2_create_session_v2.negotiate_content_type =
 526			TA_HDCP2_CONTENT_TYPE_NEGOTIATION_TYPE__FORCE_TYPE0;
 527	else if (hdcp->connection.link.adjust.hdcp2.force_type == MOD_HDCP_FORCE_TYPE_1)
 528		hdcp_cmd->in_msg.hdcp2_create_session_v2.negotiate_content_type =
 529			TA_HDCP2_CONTENT_TYPE_NEGOTIATION_TYPE__FORCE_TYPE1;
 530	else if (hdcp->connection.link.adjust.hdcp2.force_type == MOD_HDCP_FORCE_TYPE_MAX)
 531		hdcp_cmd->in_msg.hdcp2_create_session_v2.negotiate_content_type =
 532			TA_HDCP2_CONTENT_TYPE_NEGOTIATION_TYPE__MAX_SUPPORTED;
 533
 534	hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_CREATE_SESSION_V2;
 535
 536	psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
 537
 538
 539	if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS)
 540		status = MOD_HDCP_STATUS_HDCP2_CREATE_SESSION_FAILURE;
 541	else
 542		hdcp->auth.id = hdcp_cmd->out_msg.hdcp2_create_session_v2.session_handle;
 543
 544	mutex_unlock(&psp->hdcp_context.mutex);
 545	return status;
 546}
 547
 548enum mod_hdcp_status mod_hdcp_hdcp2_destroy_session(struct mod_hdcp *hdcp)
 549{
 550	struct psp_context *psp = hdcp->config.psp.handle;
 551	struct ta_hdcp_shared_memory *hdcp_cmd;
 552	uint8_t i = 0;
 553	enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
 554
 555	mutex_lock(&psp->hdcp_context.mutex);
 556	hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.shared_buf;
 557	memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
 558
 559	hdcp_cmd->in_msg.hdcp2_destroy_session.session_handle = hdcp->auth.id;
 560	hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_DESTROY_SESSION;
 561
 562	psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
 563
 564	if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) {
 565		status = MOD_HDCP_STATUS_HDCP2_DESTROY_SESSION_FAILURE;
 566	} else {
 567		HDCP_TOP_HDCP2_DESTROY_SESSION_TRACE(hdcp);
 568		for (i = 0; i < MAX_NUM_OF_DISPLAYS; i++)
 569			if (is_display_encryption_enabled(&hdcp->displays[i])) {
 570				hdcp->displays[i].state =
 571							MOD_HDCP_DISPLAY_ACTIVE;
 572				HDCP_HDCP2_DISABLED_TRACE(
 573					hdcp, hdcp->displays[i].index);
 574			}
 575	}
 576
 577	mutex_unlock(&psp->hdcp_context.mutex);
 578	return status;
 579}
 580
 581enum mod_hdcp_status mod_hdcp_hdcp2_prepare_ake_init(struct mod_hdcp *hdcp)
 582{
 583	struct psp_context *psp = hdcp->config.psp.handle;
 584	struct ta_hdcp_shared_memory *hdcp_cmd;
 585	struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in;
 586	struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_output_v2 *msg_out;
 587	enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
 588
 589	mutex_lock(&psp->hdcp_context.mutex);
 590	hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.shared_buf;
 591	memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
 592
 593	msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2;
 594	msg_out = &hdcp_cmd->out_msg.hdcp2_prepare_process_authentication_message_v2;
 595
 596	hdcp2_message_init(hdcp, msg_in);
 597
 598	hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_PREPARE_PROCESS_AUTHENTICATION_MSG_V2;
 599	msg_in->prepare.msg1_id = TA_HDCP_HDCP2_MSG_ID__AKE_INIT;
 600
 601	psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
 602
 603	if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS)
 604		status = MOD_HDCP_STATUS_HDCP2_PREP_AKE_INIT_FAILURE;
 605	else
 606		memcpy(&hdcp->auth.msg.hdcp2.ake_init[0], &msg_out->prepare.transmitter_message[0],
 607		       sizeof(hdcp->auth.msg.hdcp2.ake_init));
 608
 609	mutex_unlock(&psp->hdcp_context.mutex);
 610	return status;
 611}
 612
 613enum mod_hdcp_status mod_hdcp_hdcp2_validate_ake_cert(struct mod_hdcp *hdcp)
 614{
 615	struct psp_context *psp = hdcp->config.psp.handle;
 616	struct ta_hdcp_shared_memory *hdcp_cmd;
 617	struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in;
 618	struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_output_v2 *msg_out;
 619	enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
 620
 621	mutex_lock(&psp->hdcp_context.mutex);
 622	hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.shared_buf;
 623	memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
 624
 625	msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2;
 626	msg_out = &hdcp_cmd->out_msg.hdcp2_prepare_process_authentication_message_v2;
 627
 628	hdcp2_message_init(hdcp, msg_in);
 629
 630	msg_in->process.msg1_desc.msg_id = TA_HDCP_HDCP2_MSG_ID__AKE_SEND_CERT;
 631	msg_in->process.msg1_desc.msg_size = TA_HDCP_HDCP2_MSG_ID_MAX_SIZE__AKE_SEND_CERT;
 632
 633	memcpy(&msg_in->process.receiver_message[0], hdcp->auth.msg.hdcp2.ake_cert,
 634	       sizeof(hdcp->auth.msg.hdcp2.ake_cert));
 635
 636	msg_in->prepare.msg1_id = TA_HDCP_HDCP2_MSG_ID__AKE_NO_STORED_KM;
 637	msg_in->prepare.msg2_id = TA_HDCP_HDCP2_MSG_ID__AKE_STORED_KM;
 638
 639	hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_PREPARE_PROCESS_AUTHENTICATION_MSG_V2;
 640
 641	psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
 642
 643	if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) {
 644		status = MOD_HDCP_STATUS_HDCP2_VALIDATE_AKE_CERT_FAILURE;
 645	} else {
 646		memcpy(hdcp->auth.msg.hdcp2.ake_no_stored_km,
 647		       &msg_out->prepare.transmitter_message[0],
 648		       sizeof(hdcp->auth.msg.hdcp2.ake_no_stored_km));
 649
 650		memcpy(hdcp->auth.msg.hdcp2.ake_stored_km,
 651		       &msg_out->prepare.transmitter_message[sizeof(hdcp->auth.msg.hdcp2.ake_no_stored_km)],
 652		       sizeof(hdcp->auth.msg.hdcp2.ake_stored_km));
 653
 654		if (msg_out->process.msg1_status ==
 655		    TA_HDCP2_MSG_AUTHENTICATION_STATUS__SUCCESS) {
 656			hdcp->connection.is_km_stored =
 657				msg_out->process.is_km_stored ? 1 : 0;
 658			hdcp->connection.is_repeater =
 659				msg_out->process.is_repeater ? 1 : 0;
 660			status = MOD_HDCP_STATUS_SUCCESS;
 661		} else if (msg_out->process.msg1_status ==
 662			   TA_HDCP2_MSG_AUTHENTICATION_STATUS__RECEIVERID_REVOKED) {
 663			hdcp->connection.is_hdcp2_revoked = 1;
 664			status = MOD_HDCP_STATUS_HDCP2_AKE_CERT_REVOKED;
 665		}  else {
 666			status = MOD_HDCP_STATUS_HDCP2_VALIDATE_AKE_CERT_FAILURE;
 667		}
 668	}
 669	mutex_unlock(&psp->hdcp_context.mutex);
 670	return status;
 671}
 672
 673enum mod_hdcp_status mod_hdcp_hdcp2_validate_h_prime(struct mod_hdcp *hdcp)
 674{
 675	struct psp_context *psp = hdcp->config.psp.handle;
 676	struct ta_hdcp_shared_memory *hdcp_cmd;
 677	struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in;
 678	struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_output_v2 *msg_out;
 679	enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
 680
 681	mutex_lock(&psp->hdcp_context.mutex);
 682	hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.shared_buf;
 683	memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
 684
 685	msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2;
 686	msg_out = &hdcp_cmd->out_msg.hdcp2_prepare_process_authentication_message_v2;
 687
 688	hdcp2_message_init(hdcp, msg_in);
 689
 690	msg_in->process.msg1_desc.msg_id = TA_HDCP_HDCP2_MSG_ID__AKE_SEND_H_PRIME;
 691	msg_in->process.msg1_desc.msg_size = TA_HDCP_HDCP2_MSG_ID_MAX_SIZE__AKE_SEND_H_PRIME;
 692
 693	memcpy(&msg_in->process.receiver_message[0], hdcp->auth.msg.hdcp2.ake_h_prime,
 694	       sizeof(hdcp->auth.msg.hdcp2.ake_h_prime));
 695
 696	if (!hdcp->connection.is_km_stored) {
 697		msg_in->process.msg2_desc.msg_id = TA_HDCP_HDCP2_MSG_ID__AKE_SEND_PAIRING_INFO;
 698		msg_in->process.msg2_desc.msg_size = TA_HDCP_HDCP2_MSG_ID_MAX_SIZE__AKE_SEND_PAIRING_INFO;
 699		memcpy(&msg_in->process.receiver_message[sizeof(hdcp->auth.msg.hdcp2.ake_h_prime)],
 700		       hdcp->auth.msg.hdcp2.ake_pairing_info, sizeof(hdcp->auth.msg.hdcp2.ake_pairing_info));
 701	}
 702
 703	hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_PREPARE_PROCESS_AUTHENTICATION_MSG_V2;
 704
 705	psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
 706
 707	if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS)
 708		status = MOD_HDCP_STATUS_HDCP2_VALIDATE_H_PRIME_FAILURE;
 709	else if (msg_out->process.msg1_status != TA_HDCP2_MSG_AUTHENTICATION_STATUS__SUCCESS)
 710		status = MOD_HDCP_STATUS_HDCP2_VALIDATE_H_PRIME_FAILURE;
 711	else if (!hdcp->connection.is_km_stored &&
 712		   msg_out->process.msg2_status != TA_HDCP2_MSG_AUTHENTICATION_STATUS__SUCCESS)
 713		status = MOD_HDCP_STATUS_HDCP2_VALIDATE_PAIRING_INFO_FAILURE;
 714
 715	mutex_unlock(&psp->hdcp_context.mutex);
 716	return status;
 717}
 718
 719enum mod_hdcp_status mod_hdcp_hdcp2_prepare_lc_init(struct mod_hdcp *hdcp)
 720{
 721	struct psp_context *psp = hdcp->config.psp.handle;
 722	struct ta_hdcp_shared_memory *hdcp_cmd;
 723	struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in;
 724	struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_output_v2 *msg_out;
 725	enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
 726
 727	mutex_lock(&psp->hdcp_context.mutex);
 728	hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.shared_buf;
 729	memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
 730
 731	msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2;
 732	msg_out = &hdcp_cmd->out_msg.hdcp2_prepare_process_authentication_message_v2;
 733
 734	hdcp2_message_init(hdcp, msg_in);
 735
 736	msg_in->prepare.msg1_id = TA_HDCP_HDCP2_MSG_ID__LC_INIT;
 737
 738	hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_PREPARE_PROCESS_AUTHENTICATION_MSG_V2;
 739
 740	psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
 741
 742	if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS)
 743		status = MOD_HDCP_STATUS_HDCP2_PREP_LC_INIT_FAILURE;
 744	else
 745		memcpy(hdcp->auth.msg.hdcp2.lc_init, &msg_out->prepare.transmitter_message[0],
 746		       sizeof(hdcp->auth.msg.hdcp2.lc_init));
 747
 748	mutex_unlock(&psp->hdcp_context.mutex);
 749	return status;
 750}
 751
 752enum mod_hdcp_status mod_hdcp_hdcp2_validate_l_prime(struct mod_hdcp *hdcp)
 753{
 754	struct psp_context *psp = hdcp->config.psp.handle;
 755	struct ta_hdcp_shared_memory *hdcp_cmd;
 756	struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in;
 757	struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_output_v2 *msg_out;
 758	enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
 759
 760	mutex_lock(&psp->hdcp_context.mutex);
 761	hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.shared_buf;
 762	memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
 763
 764	msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2;
 765	msg_out = &hdcp_cmd->out_msg.hdcp2_prepare_process_authentication_message_v2;
 766
 767	hdcp2_message_init(hdcp, msg_in);
 768
 769	msg_in->process.msg1_desc.msg_id = TA_HDCP_HDCP2_MSG_ID__LC_SEND_L_PRIME;
 770	msg_in->process.msg1_desc.msg_size = TA_HDCP_HDCP2_MSG_ID_MAX_SIZE__LC_SEND_L_PRIME;
 771
 772	memcpy(&msg_in->process.receiver_message[0], hdcp->auth.msg.hdcp2.lc_l_prime,
 773	       sizeof(hdcp->auth.msg.hdcp2.lc_l_prime));
 774
 775	hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_PREPARE_PROCESS_AUTHENTICATION_MSG_V2;
 776
 777	psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
 778
 779	if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS ||
 780			msg_out->process.msg1_status != TA_HDCP2_MSG_AUTHENTICATION_STATUS__SUCCESS)
 781		status = MOD_HDCP_STATUS_HDCP2_VALIDATE_L_PRIME_FAILURE;
 782
 783	mutex_unlock(&psp->hdcp_context.mutex);
 784	return status;
 785}
 786
 787enum mod_hdcp_status mod_hdcp_hdcp2_prepare_eks(struct mod_hdcp *hdcp)
 788{
 789	struct psp_context *psp = hdcp->config.psp.handle;
 790	struct ta_hdcp_shared_memory *hdcp_cmd;
 791	struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in;
 792	struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_output_v2 *msg_out;
 793	enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
 794
 795	mutex_lock(&psp->hdcp_context.mutex);
 796	hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.shared_buf;
 797	memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
 798
 799	msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2;
 800	msg_out = &hdcp_cmd->out_msg.hdcp2_prepare_process_authentication_message_v2;
 801
 802	hdcp2_message_init(hdcp, msg_in);
 803
 804	msg_in->prepare.msg1_id = TA_HDCP_HDCP2_MSG_ID__SKE_SEND_EKS;
 805
 806	if (is_dp_hdcp(hdcp))
 807		msg_in->prepare.msg2_id = TA_HDCP_HDCP2_MSG_ID__SIGNAL_CONTENT_STREAM_TYPE_DP;
 808
 809	hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_PREPARE_PROCESS_AUTHENTICATION_MSG_V2;
 810	psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
 811
 812	if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) {
 813		status = MOD_HDCP_STATUS_HDCP2_PREP_EKS_FAILURE;
 814	} else {
 815		memcpy(hdcp->auth.msg.hdcp2.ske_eks,
 816		       &msg_out->prepare.transmitter_message[0],
 817		       sizeof(hdcp->auth.msg.hdcp2.ske_eks));
 818		msg_out->prepare.msg1_desc.msg_size =
 819			sizeof(hdcp->auth.msg.hdcp2.ske_eks);
 820
 821		if (is_dp_hdcp(hdcp)) {
 822			memcpy(hdcp->auth.msg.hdcp2.content_stream_type_dp,
 823			       &msg_out->prepare.transmitter_message[sizeof(hdcp->auth.msg.hdcp2.ske_eks)],
 824			       sizeof(hdcp->auth.msg.hdcp2.content_stream_type_dp));
 825		}
 826	}
 827	mutex_unlock(&psp->hdcp_context.mutex);
 828
 829	return status;
 830}
 831
 832enum mod_hdcp_status mod_hdcp_hdcp2_enable_encryption(struct mod_hdcp *hdcp)
 833{
 834	struct psp_context *psp = hdcp->config.psp.handle;
 835	struct ta_hdcp_shared_memory *hdcp_cmd;
 836	struct mod_hdcp_display *display = get_first_active_display(hdcp);
 837	enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
 838
 839	if (!display)
 840		return MOD_HDCP_STATUS_DISPLAY_NOT_FOUND;
 841
 842	mutex_lock(&psp->hdcp_context.mutex);
 843
 844	hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.shared_buf;
 845	memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
 846
 847	hdcp_cmd->in_msg.hdcp2_set_encryption.session_handle = hdcp->auth.id;
 848
 849	hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_SET_ENCRYPTION;
 850	psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
 851
 852	if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) {
 853		status = MOD_HDCP_STATUS_HDCP2_ENABLE_ENCRYPTION_FAILURE;
 854	} else if (!is_dp_mst_hdcp(hdcp)) {
 855		display->state = MOD_HDCP_DISPLAY_ENCRYPTION_ENABLED;
 856		HDCP_HDCP2_ENABLED_TRACE(hdcp, display->index);
 857	}
 858
 859	mutex_unlock(&psp->hdcp_context.mutex);
 860	return status;
 861}
 862
 863enum mod_hdcp_status mod_hdcp_hdcp2_validate_rx_id_list(struct mod_hdcp *hdcp)
 864{
 865	struct psp_context *psp = hdcp->config.psp.handle;
 866	struct ta_hdcp_shared_memory *hdcp_cmd;
 867	struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in;
 868	struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_output_v2 *msg_out;
 869	enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
 870
 871	mutex_lock(&psp->hdcp_context.mutex);
 872
 873	hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.shared_buf;
 874	memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
 875
 876	msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2;
 877	msg_out = &hdcp_cmd->out_msg.hdcp2_prepare_process_authentication_message_v2;
 878
 879	hdcp2_message_init(hdcp, msg_in);
 880
 881	msg_in->process.msg1_desc.msg_id = TA_HDCP_HDCP2_MSG_ID__REPEATERAUTH_SEND_RECEIVERID_LIST;
 882	msg_in->process.msg1_desc.msg_size = sizeof(hdcp->auth.msg.hdcp2.rx_id_list);
 883	memcpy(&msg_in->process.receiver_message[0], hdcp->auth.msg.hdcp2.rx_id_list,
 884	       sizeof(hdcp->auth.msg.hdcp2.rx_id_list));
 885
 886	msg_in->prepare.msg1_id = TA_HDCP_HDCP2_MSG_ID__REPEATERAUTH_SEND_ACK;
 887
 888	hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_PREPARE_PROCESS_AUTHENTICATION_MSG_V2;
 889
 890	psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
 891
 892	if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) {
 893		status = MOD_HDCP_STATUS_HDCP2_VALIDATE_RX_ID_LIST_FAILURE;
 894	} else {
 895		memcpy(hdcp->auth.msg.hdcp2.repeater_auth_ack,
 896		       &msg_out->prepare.transmitter_message[0],
 897		       sizeof(hdcp->auth.msg.hdcp2.repeater_auth_ack));
 898
 899		if (msg_out->process.msg1_status ==
 900		    TA_HDCP2_MSG_AUTHENTICATION_STATUS__SUCCESS) {
 901			hdcp->connection.is_km_stored = msg_out->process.is_km_stored ? 1 : 0;
 902			hdcp->connection.is_repeater = msg_out->process.is_repeater ? 1 : 0;
 903			status = MOD_HDCP_STATUS_SUCCESS;
 904		} else if (msg_out->process.msg1_status ==
 905			   TA_HDCP2_MSG_AUTHENTICATION_STATUS__RECEIVERID_REVOKED) {
 906			hdcp->connection.is_hdcp2_revoked = 1;
 907			status = MOD_HDCP_STATUS_HDCP2_RX_ID_LIST_REVOKED;
 908		} else {
 909			status = MOD_HDCP_STATUS_HDCP2_VALIDATE_RX_ID_LIST_FAILURE;
 910		}
 911	}
 912	mutex_unlock(&psp->hdcp_context.mutex);
 913	return status;
 914}
 915
 916enum mod_hdcp_status mod_hdcp_hdcp2_enable_dp_stream_encryption(struct mod_hdcp *hdcp)
 917{
 918	struct psp_context *psp = hdcp->config.psp.handle;
 919	struct ta_hdcp_shared_memory *hdcp_cmd;
 920	struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in;
 921	uint8_t i;
 922	enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
 923
 924	mutex_lock(&psp->hdcp_context.mutex);
 925	hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.shared_buf;
 926	memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
 927
 928	msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2;
 929
 930	hdcp2_message_init(hdcp, msg_in);
 931
 932
 933	for (i = 0; i < MAX_NUM_OF_DISPLAYS; i++) {
 934		if (hdcp->displays[i].adjust.disable || hdcp->displays[i].state != MOD_HDCP_DISPLAY_ACTIVE)
 935			continue;
 936
 937		hdcp_cmd->in_msg.hdcp2_enable_dp_stream_encryption.display_handle = hdcp->displays[i].index;
 938		hdcp_cmd->in_msg.hdcp2_enable_dp_stream_encryption.session_handle = hdcp->auth.id;
 939
 940		hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_ENABLE_DP_STREAM_ENCRYPTION;
 941		psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
 942
 943		if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS)
 944			break;
 945
 946		hdcp->displays[i].state = MOD_HDCP_DISPLAY_ENCRYPTION_ENABLED;
 947		HDCP_HDCP2_ENABLED_TRACE(hdcp, hdcp->displays[i].index);
 948	}
 949
 950	if (hdcp_cmd->hdcp_status == TA_HDCP_STATUS__SUCCESS)
 951		status = MOD_HDCP_STATUS_SUCCESS;
 952	else
 953		status = MOD_HDCP_STATUS_HDCP2_ENABLE_STREAM_ENCRYPTION_FAILURE;
 954
 955	mutex_unlock(&psp->hdcp_context.mutex);
 956	return status;
 957}
 958
 959enum mod_hdcp_status mod_hdcp_hdcp2_prepare_stream_management(struct mod_hdcp *hdcp)
 960{
 961
 962	struct psp_context *psp = hdcp->config.psp.handle;
 963	struct ta_hdcp_shared_memory *hdcp_cmd;
 964	struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in;
 965	struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_output_v2 *msg_out;
 966	enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
 967
 968	mutex_lock(&psp->hdcp_context.mutex);
 969	hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.shared_buf;
 970	memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
 971
 972	msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2;
 973	msg_out = &hdcp_cmd->out_msg.hdcp2_prepare_process_authentication_message_v2;
 974
 975	hdcp2_message_init(hdcp, msg_in);
 976
 977	msg_in->prepare.msg1_id = TA_HDCP_HDCP2_MSG_ID__REPEATERAUTH_STREAM_MANAGE;
 978
 979
 980	hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_PREPARE_PROCESS_AUTHENTICATION_MSG_V2;
 981	psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
 982
 983	if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) {
 984		status = MOD_HDCP_STATUS_HDCP2_PREPARE_STREAM_MANAGEMENT_FAILURE;
 985	} else {
 986		hdcp->auth.msg.hdcp2.stream_manage_size = msg_out->prepare.msg1_desc.msg_size;
 987
 988		memcpy(hdcp->auth.msg.hdcp2.repeater_auth_stream_manage,
 989		       &msg_out->prepare.transmitter_message[0],
 990		       sizeof(hdcp->auth.msg.hdcp2.repeater_auth_stream_manage));
 991	}
 992	mutex_unlock(&psp->hdcp_context.mutex);
 993	return status;
 994}
 995
 996enum mod_hdcp_status mod_hdcp_hdcp2_validate_stream_ready(struct mod_hdcp *hdcp)
 997{
 998	struct psp_context *psp = hdcp->config.psp.handle;
 999	struct ta_hdcp_shared_memory *hdcp_cmd;
1000	struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in;
1001	struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_output_v2 *msg_out;
1002	enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
1003
1004	mutex_lock(&psp->hdcp_context.mutex);
1005	hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.shared_buf;
1006	memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
1007
1008	msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2;
1009	msg_out = &hdcp_cmd->out_msg.hdcp2_prepare_process_authentication_message_v2;
1010
1011	hdcp2_message_init(hdcp, msg_in);
1012
1013	msg_in->process.msg1_desc.msg_id = TA_HDCP_HDCP2_MSG_ID__REPEATERAUTH_STREAM_READY;
1014
1015	msg_in->process.msg1_desc.msg_size = sizeof(hdcp->auth.msg.hdcp2.repeater_auth_stream_ready);
1016
1017	memcpy(&msg_in->process.receiver_message[0], hdcp->auth.msg.hdcp2.repeater_auth_stream_ready,
1018	       sizeof(hdcp->auth.msg.hdcp2.repeater_auth_stream_ready));
1019
1020	hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_PREPARE_PROCESS_AUTHENTICATION_MSG_V2;
1021	psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
1022
1023	if (hdcp_cmd->hdcp_status == TA_HDCP_STATUS__SUCCESS &&
1024	    msg_out->process.msg1_status == TA_HDCP2_MSG_AUTHENTICATION_STATUS__SUCCESS)
1025		status = MOD_HDCP_STATUS_SUCCESS;
1026	else
1027		status = MOD_HDCP_STATUS_HDCP2_VALIDATE_STREAM_READY_FAILURE;
1028
1029	mutex_unlock(&psp->hdcp_context.mutex);
1030	return status;
1031}