2 * Copyright 2018 Advanced Micro Devices, Inc.
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:
11 * The above copyright notice and this permission notice shall be included in
12 * all copies or substantial portions of the Software.
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.
26 #define MAX_NUM_DISPLAYS 24
34 static void hdcp2_message_init(struct mod_hdcp *hdcp,
35 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *in)
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;
48 static enum mod_hdcp_status mod_hdcp_remove_display_from_topology_v2(
49 struct mod_hdcp *hdcp, uint8_t index)
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;
57 dtm_cmd = (struct ta_dtm_shared_memory *)psp->dtm_context.dtm_shared_buf;
59 if (!display || !is_display_active(display))
60 return MOD_HDCP_STATUS_DISPLAY_NOT_FOUND;
62 mutex_lock(&psp->dtm_context.mutex);
64 memset(dtm_cmd, 0, sizeof(struct ta_dtm_shared_memory));
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;
71 psp_dtm_invoke(psp, dtm_cmd->cmd_id);
73 if (dtm_cmd->dtm_status != TA_DTM_STATUS__SUCCESS) {
74 status = MOD_HDCP_STATUS_UPDATE_TOPOLOGY_FAILURE;
76 display->state = MOD_HDCP_DISPLAY_ACTIVE;
77 HDCP_TOP_REMOVE_DISPLAY_TRACE(hdcp, display->index);
80 mutex_unlock(&psp->dtm_context.mutex);
84 static enum mod_hdcp_status mod_hdcp_remove_display_from_topology_v3(
85 struct mod_hdcp *hdcp, uint8_t index)
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;
93 dtm_cmd = (struct ta_dtm_shared_memory *)psp->dtm_context.dtm_shared_buf;
95 if (!display || !is_display_active(display))
96 return MOD_HDCP_STATUS_DISPLAY_NOT_FOUND;
98 mutex_lock(&psp->dtm_context.mutex);
100 memset(dtm_cmd, 0, sizeof(struct ta_dtm_shared_memory));
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;
107 psp_dtm_invoke(psp, dtm_cmd->cmd_id);
109 if (dtm_cmd->dtm_status != TA_DTM_STATUS__SUCCESS) {
110 status = mod_hdcp_remove_display_from_topology_v2(hdcp, index);
111 if (status != MOD_HDCP_STATUS_SUCCESS)
112 display->state = MOD_HDCP_DISPLAY_INACTIVE;
114 display->state = MOD_HDCP_DISPLAY_ACTIVE;
115 HDCP_TOP_REMOVE_DISPLAY_TRACE(hdcp, display->index);
118 mutex_unlock(&psp->dtm_context.mutex);
123 enum mod_hdcp_status mod_hdcp_remove_display_from_topology(
124 struct mod_hdcp *hdcp, uint8_t index)
126 enum mod_hdcp_status status = MOD_HDCP_STATUS_UPDATE_TOPOLOGY_FAILURE;
128 if (hdcp->config.psp.caps.dtm_v3_supported)
129 status = mod_hdcp_remove_display_from_topology_v3(hdcp, index);
131 status = mod_hdcp_remove_display_from_topology_v2(hdcp, index);
136 static enum mod_hdcp_status mod_hdcp_add_display_to_topology_v2(
137 struct mod_hdcp *hdcp, struct mod_hdcp_display *display)
139 struct psp_context *psp = hdcp->config.psp.handle;
140 struct ta_dtm_shared_memory *dtm_cmd;
141 struct mod_hdcp_link *link = &hdcp->connection.link;
142 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
144 if (!psp->dtm_context.dtm_initialized) {
145 DRM_INFO("Failed to add display topology, DTM TA is not initialized.");
146 display->state = MOD_HDCP_DISPLAY_INACTIVE;
147 return MOD_HDCP_STATUS_FAILURE;
150 dtm_cmd = (struct ta_dtm_shared_memory *)psp->dtm_context.dtm_shared_buf;
152 mutex_lock(&psp->dtm_context.mutex);
153 memset(dtm_cmd, 0, sizeof(struct ta_dtm_shared_memory));
155 dtm_cmd->cmd_id = TA_DTM_COMMAND__TOPOLOGY_UPDATE_V2;
156 dtm_cmd->dtm_in_message.topology_update_v2.display_handle = display->index;
157 dtm_cmd->dtm_in_message.topology_update_v2.is_active = 1;
158 dtm_cmd->dtm_in_message.topology_update_v2.controller = display->controller;
159 dtm_cmd->dtm_in_message.topology_update_v2.ddc_line = link->ddc_line;
160 dtm_cmd->dtm_in_message.topology_update_v2.dig_be = link->dig_be;
161 dtm_cmd->dtm_in_message.topology_update_v2.dig_fe = display->dig_fe;
162 if (is_dp_hdcp(hdcp))
163 dtm_cmd->dtm_in_message.topology_update_v2.is_assr = link->dp.assr_enabled;
165 dtm_cmd->dtm_in_message.topology_update_v2.dp_mst_vcid = display->vc_id;
166 dtm_cmd->dtm_in_message.topology_update_v2.max_hdcp_supported_version =
167 TA_DTM_HDCP_VERSION_MAX_SUPPORTED__2_2;
168 dtm_cmd->dtm_status = TA_DTM_STATUS__GENERIC_FAILURE;
170 psp_dtm_invoke(psp, dtm_cmd->cmd_id);
172 if (dtm_cmd->dtm_status != TA_DTM_STATUS__SUCCESS) {
173 display->state = MOD_HDCP_DISPLAY_INACTIVE;
174 status = MOD_HDCP_STATUS_UPDATE_TOPOLOGY_FAILURE;
176 HDCP_TOP_ADD_DISPLAY_TRACE(hdcp, display->index);
179 mutex_unlock(&psp->dtm_context.mutex);
183 static enum mod_hdcp_status mod_hdcp_add_display_to_topology_v3(
184 struct mod_hdcp *hdcp, struct mod_hdcp_display *display)
186 struct psp_context *psp = hdcp->config.psp.handle;
187 struct ta_dtm_shared_memory *dtm_cmd;
188 struct mod_hdcp_link *link = &hdcp->connection.link;
189 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
191 if (!psp->dtm_context.dtm_initialized) {
192 DRM_INFO("Failed to add display topology, DTM TA is not initialized.");
193 display->state = MOD_HDCP_DISPLAY_INACTIVE;
194 return MOD_HDCP_STATUS_FAILURE;
197 dtm_cmd = (struct ta_dtm_shared_memory *)psp->dtm_context.dtm_shared_buf;
199 mutex_lock(&psp->dtm_context.mutex);
200 memset(dtm_cmd, 0, sizeof(struct ta_dtm_shared_memory));
202 dtm_cmd->cmd_id = TA_DTM_COMMAND__TOPOLOGY_UPDATE_V3;
203 dtm_cmd->dtm_in_message.topology_update_v3.display_handle = display->index;
204 dtm_cmd->dtm_in_message.topology_update_v3.is_active = 1;
205 dtm_cmd->dtm_in_message.topology_update_v3.controller = display->controller;
206 dtm_cmd->dtm_in_message.topology_update_v3.ddc_line = link->ddc_line;
207 dtm_cmd->dtm_in_message.topology_update_v3.link_enc = link->link_enc_idx;
208 dtm_cmd->dtm_in_message.topology_update_v3.stream_enc = display->stream_enc_idx;
209 if (is_dp_hdcp(hdcp))
210 dtm_cmd->dtm_in_message.topology_update_v3.is_assr = link->dp.assr_enabled;
212 dtm_cmd->dtm_in_message.topology_update_v3.dp_mst_vcid = display->vc_id;
213 dtm_cmd->dtm_in_message.topology_update_v3.max_hdcp_supported_version =
214 TA_DTM_HDCP_VERSION_MAX_SUPPORTED__2_3;
215 dtm_cmd->dtm_in_message.topology_update_v3.encoder_type = TA_DTM_ENCODER_TYPE__DIG;
216 dtm_cmd->dtm_status = TA_DTM_STATUS__GENERIC_FAILURE;
217 dtm_cmd->dtm_in_message.topology_update_v3.phy_id = link->phy_idx;
218 dtm_cmd->dtm_in_message.topology_update_v3.link_hdcp_cap = link->hdcp_supported_informational;
220 psp_dtm_invoke(psp, dtm_cmd->cmd_id);
222 if (dtm_cmd->dtm_status != TA_DTM_STATUS__SUCCESS) {
223 status = mod_hdcp_add_display_to_topology_v2(hdcp, display);
224 if (status != MOD_HDCP_STATUS_SUCCESS)
225 display->state = MOD_HDCP_DISPLAY_INACTIVE;
227 HDCP_TOP_ADD_DISPLAY_TRACE(hdcp, display->index);
230 mutex_unlock(&psp->dtm_context.mutex);
235 enum mod_hdcp_status mod_hdcp_add_display_to_topology(struct mod_hdcp *hdcp,
236 struct mod_hdcp_display *display)
238 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
240 if (hdcp->config.psp.caps.dtm_v3_supported)
241 status = mod_hdcp_add_display_to_topology_v3(hdcp, display);
243 status = mod_hdcp_add_display_to_topology_v2(hdcp, display);
248 enum mod_hdcp_status mod_hdcp_hdcp1_create_session(struct mod_hdcp *hdcp)
251 struct psp_context *psp = hdcp->config.psp.handle;
252 struct mod_hdcp_display *display = get_first_active_display(hdcp);
253 struct ta_hdcp_shared_memory *hdcp_cmd;
254 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
256 if (!psp->hdcp_context.hdcp_initialized) {
257 DRM_ERROR("Failed to create hdcp session. HDCP TA is not initialized.");
258 return MOD_HDCP_STATUS_FAILURE;
261 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf;
263 mutex_lock(&psp->hdcp_context.mutex);
264 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
266 hdcp_cmd->in_msg.hdcp1_create_session.display_handle = display->index;
267 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP1_CREATE_SESSION;
269 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
271 hdcp->auth.id = hdcp_cmd->out_msg.hdcp1_create_session.session_handle;
273 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) {
274 status = MOD_HDCP_STATUS_HDCP1_CREATE_SESSION_FAILURE;
276 hdcp->auth.msg.hdcp1.ainfo = hdcp_cmd->out_msg.hdcp1_create_session.ainfo_primary;
277 memcpy(hdcp->auth.msg.hdcp1.aksv, hdcp_cmd->out_msg.hdcp1_create_session.aksv_primary,
278 sizeof(hdcp->auth.msg.hdcp1.aksv));
279 memcpy(hdcp->auth.msg.hdcp1.an, hdcp_cmd->out_msg.hdcp1_create_session.an_primary,
280 sizeof(hdcp->auth.msg.hdcp1.an));
283 mutex_unlock(&psp->hdcp_context.mutex);
287 enum mod_hdcp_status mod_hdcp_hdcp1_destroy_session(struct mod_hdcp *hdcp)
290 struct psp_context *psp = hdcp->config.psp.handle;
291 struct ta_hdcp_shared_memory *hdcp_cmd;
293 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
295 mutex_lock(&psp->hdcp_context.mutex);
296 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf;
297 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
299 hdcp_cmd->in_msg.hdcp1_destroy_session.session_handle = hdcp->auth.id;
300 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP1_DESTROY_SESSION;
302 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
304 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) {
305 status = MOD_HDCP_STATUS_HDCP1_DESTROY_SESSION_FAILURE;
307 HDCP_TOP_HDCP1_DESTROY_SESSION_TRACE(hdcp);
308 for (i = 0; i < MAX_NUM_OF_DISPLAYS; i++)
309 if (is_display_encryption_enabled(&hdcp->displays[i])) {
310 hdcp->displays[i].state =
311 MOD_HDCP_DISPLAY_ACTIVE;
312 HDCP_HDCP1_DISABLED_TRACE(
313 hdcp, hdcp->displays[i].index);
317 mutex_unlock(&psp->hdcp_context.mutex);
321 enum mod_hdcp_status mod_hdcp_hdcp1_validate_rx(struct mod_hdcp *hdcp)
323 struct psp_context *psp = hdcp->config.psp.handle;
324 struct ta_hdcp_shared_memory *hdcp_cmd;
325 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
327 mutex_lock(&psp->hdcp_context.mutex);
328 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf;
329 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
331 hdcp_cmd->in_msg.hdcp1_first_part_authentication.session_handle = hdcp->auth.id;
333 memcpy(hdcp_cmd->in_msg.hdcp1_first_part_authentication.bksv_primary, hdcp->auth.msg.hdcp1.bksv,
334 TA_HDCP__HDCP1_KSV_SIZE);
336 hdcp_cmd->in_msg.hdcp1_first_part_authentication.r0_prime_primary = hdcp->auth.msg.hdcp1.r0p;
337 hdcp_cmd->in_msg.hdcp1_first_part_authentication.bcaps = hdcp->auth.msg.hdcp1.bcaps;
338 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP1_FIRST_PART_AUTHENTICATION;
340 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
342 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) {
343 status = MOD_HDCP_STATUS_HDCP1_VALIDATE_RX_FAILURE;
344 } else if (hdcp_cmd->out_msg.hdcp1_first_part_authentication.authentication_status ==
345 TA_HDCP_AUTHENTICATION_STATUS__HDCP1_FIRST_PART_COMPLETE) {
346 /* needs second part of authentication */
347 hdcp->connection.is_repeater = 1;
348 } else if (hdcp_cmd->out_msg.hdcp1_first_part_authentication.authentication_status ==
349 TA_HDCP_AUTHENTICATION_STATUS__HDCP1_AUTHENTICATED) {
350 hdcp->connection.is_repeater = 0;
351 } else if (hdcp_cmd->out_msg.hdcp1_first_part_authentication.authentication_status ==
352 TA_HDCP_AUTHENTICATION_STATUS__HDCP1_KSV_REVOKED) {
353 hdcp->connection.is_hdcp1_revoked = 1;
354 status = MOD_HDCP_STATUS_HDCP1_BKSV_REVOKED;
356 status = MOD_HDCP_STATUS_HDCP1_VALIDATE_RX_FAILURE;
358 mutex_unlock(&psp->hdcp_context.mutex);
362 enum mod_hdcp_status mod_hdcp_hdcp1_enable_encryption(struct mod_hdcp *hdcp)
364 struct psp_context *psp = hdcp->config.psp.handle;
365 struct ta_hdcp_shared_memory *hdcp_cmd;
366 struct mod_hdcp_display *display = get_first_active_display(hdcp);
367 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
369 mutex_lock(&psp->hdcp_context.mutex);
370 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf;
371 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
373 hdcp_cmd->in_msg.hdcp1_enable_encryption.session_handle = hdcp->auth.id;
374 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP1_ENABLE_ENCRYPTION;
376 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
378 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) {
379 status = MOD_HDCP_STATUS_HDCP1_ENABLE_ENCRYPTION_FAILURE;
380 } else if (!is_dp_mst_hdcp(hdcp)) {
381 display->state = MOD_HDCP_DISPLAY_ENCRYPTION_ENABLED;
382 HDCP_HDCP1_ENABLED_TRACE(hdcp, display->index);
385 mutex_unlock(&psp->hdcp_context.mutex);
389 enum mod_hdcp_status mod_hdcp_hdcp1_validate_ksvlist_vp(struct mod_hdcp *hdcp)
391 struct psp_context *psp = hdcp->config.psp.handle;
392 struct ta_hdcp_shared_memory *hdcp_cmd;
393 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
395 mutex_lock(&psp->hdcp_context.mutex);
396 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf;
397 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
399 hdcp_cmd->in_msg.hdcp1_second_part_authentication.session_handle = hdcp->auth.id;
401 hdcp_cmd->in_msg.hdcp1_second_part_authentication.ksv_list_size = hdcp->auth.msg.hdcp1.ksvlist_size;
402 memcpy(hdcp_cmd->in_msg.hdcp1_second_part_authentication.ksv_list, hdcp->auth.msg.hdcp1.ksvlist,
403 hdcp->auth.msg.hdcp1.ksvlist_size);
405 memcpy(hdcp_cmd->in_msg.hdcp1_second_part_authentication.v_prime, hdcp->auth.msg.hdcp1.vp,
406 sizeof(hdcp->auth.msg.hdcp1.vp));
408 hdcp_cmd->in_msg.hdcp1_second_part_authentication.bstatus_binfo =
409 is_dp_hdcp(hdcp) ? hdcp->auth.msg.hdcp1.binfo_dp : hdcp->auth.msg.hdcp1.bstatus;
410 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP1_SECOND_PART_AUTHENTICATION;
412 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
414 if (hdcp_cmd->hdcp_status == TA_HDCP_STATUS__SUCCESS &&
415 hdcp_cmd->out_msg.hdcp1_second_part_authentication.authentication_status ==
416 TA_HDCP_AUTHENTICATION_STATUS__HDCP1_AUTHENTICATED) {
417 status = MOD_HDCP_STATUS_SUCCESS;
418 } else if (hdcp_cmd->out_msg.hdcp1_second_part_authentication.authentication_status ==
419 TA_HDCP_AUTHENTICATION_STATUS__HDCP1_KSV_REVOKED) {
420 hdcp->connection.is_hdcp1_revoked = 1;
421 status = MOD_HDCP_STATUS_HDCP1_KSV_LIST_REVOKED;
423 status = MOD_HDCP_STATUS_HDCP1_VALIDATE_KSV_LIST_FAILURE;
426 mutex_unlock(&psp->hdcp_context.mutex);
430 enum mod_hdcp_status mod_hdcp_hdcp1_enable_dp_stream_encryption(struct mod_hdcp *hdcp)
433 struct psp_context *psp = hdcp->config.psp.handle;
434 struct ta_hdcp_shared_memory *hdcp_cmd;
436 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
438 mutex_lock(&psp->hdcp_context.mutex);
439 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf;
441 for (i = 0; i < MAX_NUM_OF_DISPLAYS; i++) {
443 if (hdcp->displays[i].adjust.disable || hdcp->displays[i].state != MOD_HDCP_DISPLAY_ACTIVE)
446 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
448 hdcp_cmd->in_msg.hdcp1_enable_dp_stream_encryption.session_handle = hdcp->auth.id;
449 hdcp_cmd->in_msg.hdcp1_enable_dp_stream_encryption.display_handle = hdcp->displays[i].index;
450 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP1_ENABLE_DP_STREAM_ENCRYPTION;
452 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
454 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) {
455 status = MOD_HDCP_STATUS_HDCP1_ENABLE_STREAM_ENCRYPTION_FAILURE;
459 hdcp->displays[i].state = MOD_HDCP_DISPLAY_ENCRYPTION_ENABLED;
460 HDCP_HDCP1_ENABLED_TRACE(hdcp, hdcp->displays[i].index);
463 mutex_unlock(&psp->hdcp_context.mutex);
467 enum mod_hdcp_status mod_hdcp_hdcp1_link_maintenance(struct mod_hdcp *hdcp)
469 struct psp_context *psp = hdcp->config.psp.handle;
470 struct ta_hdcp_shared_memory *hdcp_cmd;
471 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
473 mutex_lock(&psp->hdcp_context.mutex);
474 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf;
476 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
478 hdcp_cmd->in_msg.hdcp1_get_encryption_status.session_handle = hdcp->auth.id;
480 hdcp_cmd->out_msg.hdcp1_get_encryption_status.protection_level = 0;
481 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP1_GET_ENCRYPTION_STATUS;
483 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
485 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS ||
486 hdcp_cmd->out_msg.hdcp1_get_encryption_status.protection_level != 1)
487 status = MOD_HDCP_STATUS_HDCP1_LINK_MAINTENANCE_FAILURE;
489 mutex_unlock(&psp->hdcp_context.mutex);
493 enum mod_hdcp_status mod_hdcp_hdcp2_create_session(struct mod_hdcp *hdcp)
495 struct psp_context *psp = hdcp->config.psp.handle;
496 struct ta_hdcp_shared_memory *hdcp_cmd;
497 struct mod_hdcp_display *display = get_first_active_display(hdcp);
498 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
501 if (!psp->hdcp_context.hdcp_initialized) {
502 DRM_ERROR("Failed to create hdcp session, HDCP TA is not initialized");
503 return MOD_HDCP_STATUS_FAILURE;
507 return MOD_HDCP_STATUS_DISPLAY_NOT_FOUND;
509 mutex_lock(&psp->hdcp_context.mutex);
511 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf;
512 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
514 hdcp_cmd->in_msg.hdcp2_create_session_v2.display_handle = display->index;
516 if (hdcp->connection.link.adjust.hdcp2.force_type == MOD_HDCP_FORCE_TYPE_0)
517 hdcp_cmd->in_msg.hdcp2_create_session_v2.negotiate_content_type =
518 TA_HDCP2_CONTENT_TYPE_NEGOTIATION_TYPE__FORCE_TYPE0;
519 else if (hdcp->connection.link.adjust.hdcp2.force_type == MOD_HDCP_FORCE_TYPE_1)
520 hdcp_cmd->in_msg.hdcp2_create_session_v2.negotiate_content_type =
521 TA_HDCP2_CONTENT_TYPE_NEGOTIATION_TYPE__FORCE_TYPE1;
522 else if (hdcp->connection.link.adjust.hdcp2.force_type == MOD_HDCP_FORCE_TYPE_MAX)
523 hdcp_cmd->in_msg.hdcp2_create_session_v2.negotiate_content_type =
524 TA_HDCP2_CONTENT_TYPE_NEGOTIATION_TYPE__MAX_SUPPORTED;
526 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_CREATE_SESSION_V2;
528 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
531 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS)
532 status = MOD_HDCP_STATUS_HDCP2_CREATE_SESSION_FAILURE;
534 hdcp->auth.id = hdcp_cmd->out_msg.hdcp2_create_session_v2.session_handle;
536 mutex_unlock(&psp->hdcp_context.mutex);
540 enum mod_hdcp_status mod_hdcp_hdcp2_destroy_session(struct mod_hdcp *hdcp)
542 struct psp_context *psp = hdcp->config.psp.handle;
543 struct ta_hdcp_shared_memory *hdcp_cmd;
545 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
547 mutex_lock(&psp->hdcp_context.mutex);
548 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf;
549 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
551 hdcp_cmd->in_msg.hdcp2_destroy_session.session_handle = hdcp->auth.id;
552 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_DESTROY_SESSION;
554 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
556 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) {
557 status = MOD_HDCP_STATUS_HDCP2_DESTROY_SESSION_FAILURE;
559 HDCP_TOP_HDCP2_DESTROY_SESSION_TRACE(hdcp);
560 for (i = 0; i < MAX_NUM_OF_DISPLAYS; i++)
561 if (is_display_encryption_enabled(&hdcp->displays[i])) {
562 hdcp->displays[i].state =
563 MOD_HDCP_DISPLAY_ACTIVE;
564 HDCP_HDCP2_DISABLED_TRACE(
565 hdcp, hdcp->displays[i].index);
569 mutex_unlock(&psp->hdcp_context.mutex);
573 enum mod_hdcp_status mod_hdcp_hdcp2_prepare_ake_init(struct mod_hdcp *hdcp)
575 struct psp_context *psp = hdcp->config.psp.handle;
576 struct ta_hdcp_shared_memory *hdcp_cmd;
577 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in;
578 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_output_v2 *msg_out;
579 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
581 mutex_lock(&psp->hdcp_context.mutex);
582 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf;
583 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
585 msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2;
586 msg_out = &hdcp_cmd->out_msg.hdcp2_prepare_process_authentication_message_v2;
588 hdcp2_message_init(hdcp, msg_in);
590 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_PREPARE_PROCESS_AUTHENTICATION_MSG_V2;
591 msg_in->prepare.msg1_id = TA_HDCP_HDCP2_MSG_ID__AKE_INIT;
593 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
595 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS)
596 status = MOD_HDCP_STATUS_HDCP2_PREP_AKE_INIT_FAILURE;
598 memcpy(&hdcp->auth.msg.hdcp2.ake_init[0], &msg_out->prepare.transmitter_message[0],
599 sizeof(hdcp->auth.msg.hdcp2.ake_init));
601 mutex_unlock(&psp->hdcp_context.mutex);
605 enum mod_hdcp_status mod_hdcp_hdcp2_validate_ake_cert(struct mod_hdcp *hdcp)
607 struct psp_context *psp = hdcp->config.psp.handle;
608 struct ta_hdcp_shared_memory *hdcp_cmd;
609 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in;
610 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_output_v2 *msg_out;
611 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
613 mutex_lock(&psp->hdcp_context.mutex);
614 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf;
615 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
617 msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2;
618 msg_out = &hdcp_cmd->out_msg.hdcp2_prepare_process_authentication_message_v2;
620 hdcp2_message_init(hdcp, msg_in);
622 msg_in->process.msg1_desc.msg_id = TA_HDCP_HDCP2_MSG_ID__AKE_SEND_CERT;
623 msg_in->process.msg1_desc.msg_size = TA_HDCP_HDCP2_MSG_ID_MAX_SIZE__AKE_SEND_CERT;
625 memcpy(&msg_in->process.receiver_message[0], hdcp->auth.msg.hdcp2.ake_cert,
626 sizeof(hdcp->auth.msg.hdcp2.ake_cert));
628 msg_in->prepare.msg1_id = TA_HDCP_HDCP2_MSG_ID__AKE_NO_STORED_KM;
629 msg_in->prepare.msg2_id = TA_HDCP_HDCP2_MSG_ID__AKE_STORED_KM;
631 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_PREPARE_PROCESS_AUTHENTICATION_MSG_V2;
633 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
635 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) {
636 status = MOD_HDCP_STATUS_HDCP2_VALIDATE_AKE_CERT_FAILURE;
638 memcpy(hdcp->auth.msg.hdcp2.ake_no_stored_km,
639 &msg_out->prepare.transmitter_message[0],
640 sizeof(hdcp->auth.msg.hdcp2.ake_no_stored_km));
642 memcpy(hdcp->auth.msg.hdcp2.ake_stored_km,
643 &msg_out->prepare.transmitter_message[sizeof(hdcp->auth.msg.hdcp2.ake_no_stored_km)],
644 sizeof(hdcp->auth.msg.hdcp2.ake_stored_km));
646 if (msg_out->process.msg1_status ==
647 TA_HDCP2_MSG_AUTHENTICATION_STATUS__SUCCESS) {
648 hdcp->connection.is_km_stored =
649 msg_out->process.is_km_stored ? 1 : 0;
650 hdcp->connection.is_repeater =
651 msg_out->process.is_repeater ? 1 : 0;
652 status = MOD_HDCP_STATUS_SUCCESS;
653 } else if (msg_out->process.msg1_status ==
654 TA_HDCP2_MSG_AUTHENTICATION_STATUS__RECEIVERID_REVOKED) {
655 hdcp->connection.is_hdcp2_revoked = 1;
656 status = MOD_HDCP_STATUS_HDCP2_AKE_CERT_REVOKED;
658 status = MOD_HDCP_STATUS_HDCP2_VALIDATE_AKE_CERT_FAILURE;
661 mutex_unlock(&psp->hdcp_context.mutex);
665 enum mod_hdcp_status mod_hdcp_hdcp2_validate_h_prime(struct mod_hdcp *hdcp)
667 struct psp_context *psp = hdcp->config.psp.handle;
668 struct ta_hdcp_shared_memory *hdcp_cmd;
669 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in;
670 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_output_v2 *msg_out;
671 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
673 mutex_lock(&psp->hdcp_context.mutex);
674 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf;
675 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
677 msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2;
678 msg_out = &hdcp_cmd->out_msg.hdcp2_prepare_process_authentication_message_v2;
680 hdcp2_message_init(hdcp, msg_in);
682 msg_in->process.msg1_desc.msg_id = TA_HDCP_HDCP2_MSG_ID__AKE_SEND_H_PRIME;
683 msg_in->process.msg1_desc.msg_size = TA_HDCP_HDCP2_MSG_ID_MAX_SIZE__AKE_SEND_H_PRIME;
685 memcpy(&msg_in->process.receiver_message[0], hdcp->auth.msg.hdcp2.ake_h_prime,
686 sizeof(hdcp->auth.msg.hdcp2.ake_h_prime));
688 if (!hdcp->connection.is_km_stored) {
689 msg_in->process.msg2_desc.msg_id = TA_HDCP_HDCP2_MSG_ID__AKE_SEND_PAIRING_INFO;
690 msg_in->process.msg2_desc.msg_size = TA_HDCP_HDCP2_MSG_ID_MAX_SIZE__AKE_SEND_PAIRING_INFO;
691 memcpy(&msg_in->process.receiver_message[sizeof(hdcp->auth.msg.hdcp2.ake_h_prime)],
692 hdcp->auth.msg.hdcp2.ake_pairing_info, sizeof(hdcp->auth.msg.hdcp2.ake_pairing_info));
695 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_PREPARE_PROCESS_AUTHENTICATION_MSG_V2;
697 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
699 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS)
700 status = MOD_HDCP_STATUS_HDCP2_VALIDATE_H_PRIME_FAILURE;
701 else if (msg_out->process.msg1_status != TA_HDCP2_MSG_AUTHENTICATION_STATUS__SUCCESS)
702 status = MOD_HDCP_STATUS_HDCP2_VALIDATE_H_PRIME_FAILURE;
703 else if (!hdcp->connection.is_km_stored &&
704 msg_out->process.msg2_status != TA_HDCP2_MSG_AUTHENTICATION_STATUS__SUCCESS)
705 status = MOD_HDCP_STATUS_HDCP2_VALIDATE_PAIRING_INFO_FAILURE;
707 mutex_unlock(&psp->hdcp_context.mutex);
711 enum mod_hdcp_status mod_hdcp_hdcp2_prepare_lc_init(struct mod_hdcp *hdcp)
713 struct psp_context *psp = hdcp->config.psp.handle;
714 struct ta_hdcp_shared_memory *hdcp_cmd;
715 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in;
716 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_output_v2 *msg_out;
717 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
719 mutex_lock(&psp->hdcp_context.mutex);
720 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf;
721 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
723 msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2;
724 msg_out = &hdcp_cmd->out_msg.hdcp2_prepare_process_authentication_message_v2;
726 hdcp2_message_init(hdcp, msg_in);
728 msg_in->prepare.msg1_id = TA_HDCP_HDCP2_MSG_ID__LC_INIT;
730 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_PREPARE_PROCESS_AUTHENTICATION_MSG_V2;
732 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
734 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS)
735 status = MOD_HDCP_STATUS_HDCP2_PREP_LC_INIT_FAILURE;
737 memcpy(hdcp->auth.msg.hdcp2.lc_init, &msg_out->prepare.transmitter_message[0],
738 sizeof(hdcp->auth.msg.hdcp2.lc_init));
740 mutex_unlock(&psp->hdcp_context.mutex);
744 enum mod_hdcp_status mod_hdcp_hdcp2_validate_l_prime(struct mod_hdcp *hdcp)
746 struct psp_context *psp = hdcp->config.psp.handle;
747 struct ta_hdcp_shared_memory *hdcp_cmd;
748 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in;
749 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_output_v2 *msg_out;
750 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
752 mutex_lock(&psp->hdcp_context.mutex);
753 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf;
754 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
756 msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2;
757 msg_out = &hdcp_cmd->out_msg.hdcp2_prepare_process_authentication_message_v2;
759 hdcp2_message_init(hdcp, msg_in);
761 msg_in->process.msg1_desc.msg_id = TA_HDCP_HDCP2_MSG_ID__LC_SEND_L_PRIME;
762 msg_in->process.msg1_desc.msg_size = TA_HDCP_HDCP2_MSG_ID_MAX_SIZE__LC_SEND_L_PRIME;
764 memcpy(&msg_in->process.receiver_message[0], hdcp->auth.msg.hdcp2.lc_l_prime,
765 sizeof(hdcp->auth.msg.hdcp2.lc_l_prime));
767 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_PREPARE_PROCESS_AUTHENTICATION_MSG_V2;
769 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
771 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS ||
772 msg_out->process.msg1_status != TA_HDCP2_MSG_AUTHENTICATION_STATUS__SUCCESS)
773 status = MOD_HDCP_STATUS_HDCP2_VALIDATE_L_PRIME_FAILURE;
775 mutex_unlock(&psp->hdcp_context.mutex);
779 enum mod_hdcp_status mod_hdcp_hdcp2_prepare_eks(struct mod_hdcp *hdcp)
781 struct psp_context *psp = hdcp->config.psp.handle;
782 struct ta_hdcp_shared_memory *hdcp_cmd;
783 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in;
784 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_output_v2 *msg_out;
785 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
787 mutex_lock(&psp->hdcp_context.mutex);
788 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf;
789 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
791 msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2;
792 msg_out = &hdcp_cmd->out_msg.hdcp2_prepare_process_authentication_message_v2;
794 hdcp2_message_init(hdcp, msg_in);
796 msg_in->prepare.msg1_id = TA_HDCP_HDCP2_MSG_ID__SKE_SEND_EKS;
798 if (is_dp_hdcp(hdcp))
799 msg_in->prepare.msg2_id = TA_HDCP_HDCP2_MSG_ID__SIGNAL_CONTENT_STREAM_TYPE_DP;
801 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_PREPARE_PROCESS_AUTHENTICATION_MSG_V2;
802 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
804 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) {
805 status = MOD_HDCP_STATUS_HDCP2_PREP_EKS_FAILURE;
807 memcpy(hdcp->auth.msg.hdcp2.ske_eks,
808 &msg_out->prepare.transmitter_message[0],
809 sizeof(hdcp->auth.msg.hdcp2.ske_eks));
810 msg_out->prepare.msg1_desc.msg_size =
811 sizeof(hdcp->auth.msg.hdcp2.ske_eks);
813 if (is_dp_hdcp(hdcp)) {
814 memcpy(hdcp->auth.msg.hdcp2.content_stream_type_dp,
815 &msg_out->prepare.transmitter_message[sizeof(hdcp->auth.msg.hdcp2.ske_eks)],
816 sizeof(hdcp->auth.msg.hdcp2.content_stream_type_dp));
819 mutex_unlock(&psp->hdcp_context.mutex);
824 enum mod_hdcp_status mod_hdcp_hdcp2_enable_encryption(struct mod_hdcp *hdcp)
826 struct psp_context *psp = hdcp->config.psp.handle;
827 struct ta_hdcp_shared_memory *hdcp_cmd;
828 struct mod_hdcp_display *display = get_first_active_display(hdcp);
829 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
832 return MOD_HDCP_STATUS_DISPLAY_NOT_FOUND;
834 mutex_lock(&psp->hdcp_context.mutex);
836 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf;
837 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
839 hdcp_cmd->in_msg.hdcp2_set_encryption.session_handle = hdcp->auth.id;
841 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_SET_ENCRYPTION;
842 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
844 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) {
845 status = MOD_HDCP_STATUS_HDCP2_ENABLE_ENCRYPTION_FAILURE;
846 } else if (!is_dp_mst_hdcp(hdcp)) {
847 display->state = MOD_HDCP_DISPLAY_ENCRYPTION_ENABLED;
848 HDCP_HDCP2_ENABLED_TRACE(hdcp, display->index);
851 mutex_unlock(&psp->hdcp_context.mutex);
855 enum mod_hdcp_status mod_hdcp_hdcp2_validate_rx_id_list(struct mod_hdcp *hdcp)
857 struct psp_context *psp = hdcp->config.psp.handle;
858 struct ta_hdcp_shared_memory *hdcp_cmd;
859 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in;
860 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_output_v2 *msg_out;
861 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
863 mutex_lock(&psp->hdcp_context.mutex);
865 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf;
866 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
868 msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2;
869 msg_out = &hdcp_cmd->out_msg.hdcp2_prepare_process_authentication_message_v2;
871 hdcp2_message_init(hdcp, msg_in);
873 msg_in->process.msg1_desc.msg_id = TA_HDCP_HDCP2_MSG_ID__REPEATERAUTH_SEND_RECEIVERID_LIST;
874 msg_in->process.msg1_desc.msg_size = sizeof(hdcp->auth.msg.hdcp2.rx_id_list);
875 memcpy(&msg_in->process.receiver_message[0], hdcp->auth.msg.hdcp2.rx_id_list,
876 sizeof(hdcp->auth.msg.hdcp2.rx_id_list));
878 msg_in->prepare.msg1_id = TA_HDCP_HDCP2_MSG_ID__REPEATERAUTH_SEND_ACK;
880 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_PREPARE_PROCESS_AUTHENTICATION_MSG_V2;
882 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
884 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) {
885 status = MOD_HDCP_STATUS_HDCP2_VALIDATE_RX_ID_LIST_FAILURE;
887 memcpy(hdcp->auth.msg.hdcp2.repeater_auth_ack,
888 &msg_out->prepare.transmitter_message[0],
889 sizeof(hdcp->auth.msg.hdcp2.repeater_auth_ack));
891 if (msg_out->process.msg1_status ==
892 TA_HDCP2_MSG_AUTHENTICATION_STATUS__SUCCESS) {
893 hdcp->connection.is_km_stored = msg_out->process.is_km_stored ? 1 : 0;
894 hdcp->connection.is_repeater = msg_out->process.is_repeater ? 1 : 0;
895 status = MOD_HDCP_STATUS_SUCCESS;
896 } else if (msg_out->process.msg1_status ==
897 TA_HDCP2_MSG_AUTHENTICATION_STATUS__RECEIVERID_REVOKED) {
898 hdcp->connection.is_hdcp2_revoked = 1;
899 status = MOD_HDCP_STATUS_HDCP2_RX_ID_LIST_REVOKED;
901 status = MOD_HDCP_STATUS_HDCP2_VALIDATE_RX_ID_LIST_FAILURE;
904 mutex_unlock(&psp->hdcp_context.mutex);
908 enum mod_hdcp_status mod_hdcp_hdcp2_enable_dp_stream_encryption(struct mod_hdcp *hdcp)
910 struct psp_context *psp = hdcp->config.psp.handle;
911 struct ta_hdcp_shared_memory *hdcp_cmd;
912 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in;
914 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
916 mutex_lock(&psp->hdcp_context.mutex);
917 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf;
918 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
920 msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2;
922 hdcp2_message_init(hdcp, msg_in);
925 for (i = 0; i < MAX_NUM_OF_DISPLAYS; i++) {
926 if (hdcp->displays[i].adjust.disable || hdcp->displays[i].state != MOD_HDCP_DISPLAY_ACTIVE)
929 hdcp_cmd->in_msg.hdcp2_enable_dp_stream_encryption.display_handle = hdcp->displays[i].index;
930 hdcp_cmd->in_msg.hdcp2_enable_dp_stream_encryption.session_handle = hdcp->auth.id;
932 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_ENABLE_DP_STREAM_ENCRYPTION;
933 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
935 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS)
938 hdcp->displays[i].state = MOD_HDCP_DISPLAY_ENCRYPTION_ENABLED;
939 HDCP_HDCP2_ENABLED_TRACE(hdcp, hdcp->displays[i].index);
942 if (hdcp_cmd->hdcp_status == TA_HDCP_STATUS__SUCCESS)
943 status = MOD_HDCP_STATUS_SUCCESS;
945 status = MOD_HDCP_STATUS_HDCP2_ENABLE_STREAM_ENCRYPTION_FAILURE;
947 mutex_unlock(&psp->hdcp_context.mutex);
951 enum mod_hdcp_status mod_hdcp_hdcp2_prepare_stream_management(struct mod_hdcp *hdcp)
954 struct psp_context *psp = hdcp->config.psp.handle;
955 struct ta_hdcp_shared_memory *hdcp_cmd;
956 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in;
957 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_output_v2 *msg_out;
958 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
960 mutex_lock(&psp->hdcp_context.mutex);
961 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf;
962 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
964 msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2;
965 msg_out = &hdcp_cmd->out_msg.hdcp2_prepare_process_authentication_message_v2;
967 hdcp2_message_init(hdcp, msg_in);
969 msg_in->prepare.msg1_id = TA_HDCP_HDCP2_MSG_ID__REPEATERAUTH_STREAM_MANAGE;
972 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_PREPARE_PROCESS_AUTHENTICATION_MSG_V2;
973 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
975 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) {
976 status = MOD_HDCP_STATUS_HDCP2_PREPARE_STREAM_MANAGEMENT_FAILURE;
978 hdcp->auth.msg.hdcp2.stream_manage_size = msg_out->prepare.msg1_desc.msg_size;
980 memcpy(hdcp->auth.msg.hdcp2.repeater_auth_stream_manage,
981 &msg_out->prepare.transmitter_message[0],
982 sizeof(hdcp->auth.msg.hdcp2.repeater_auth_stream_manage));
984 mutex_unlock(&psp->hdcp_context.mutex);
988 enum mod_hdcp_status mod_hdcp_hdcp2_validate_stream_ready(struct mod_hdcp *hdcp)
990 struct psp_context *psp = hdcp->config.psp.handle;
991 struct ta_hdcp_shared_memory *hdcp_cmd;
992 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in;
993 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_output_v2 *msg_out;
994 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
996 mutex_lock(&psp->hdcp_context.mutex);
997 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf;
998 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
1000 msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2;
1001 msg_out = &hdcp_cmd->out_msg.hdcp2_prepare_process_authentication_message_v2;
1003 hdcp2_message_init(hdcp, msg_in);
1005 msg_in->process.msg1_desc.msg_id = TA_HDCP_HDCP2_MSG_ID__REPEATERAUTH_STREAM_READY;
1007 msg_in->process.msg1_desc.msg_size = sizeof(hdcp->auth.msg.hdcp2.repeater_auth_stream_ready);
1009 memcpy(&msg_in->process.receiver_message[0], hdcp->auth.msg.hdcp2.repeater_auth_stream_ready,
1010 sizeof(hdcp->auth.msg.hdcp2.repeater_auth_stream_ready));
1012 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_PREPARE_PROCESS_AUTHENTICATION_MSG_V2;
1013 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
1015 if (hdcp_cmd->hdcp_status == TA_HDCP_STATUS__SUCCESS &&
1016 msg_out->process.msg1_status == TA_HDCP2_MSG_AUTHENTICATION_STATUS__SUCCESS)
1017 status = MOD_HDCP_STATUS_SUCCESS;
1019 status = MOD_HDCP_STATUS_HDCP2_VALIDATE_STREAM_READY_FAILURE;
1021 mutex_unlock(&psp->hdcp_context.mutex);
1025 bool mod_hdcp_is_link_encryption_enabled(struct mod_hdcp *hdcp)
1031 void mod_hdcp_save_current_encryption_states(struct mod_hdcp *hdcp)