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