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