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
hdcp2_message_init(struct mod_hdcp * hdcp,struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 * in)34 static 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
remove_display_from_topology_v2(struct mod_hdcp * hdcp,uint8_t index)48 static 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
remove_display_from_topology_v3(struct mod_hdcp * hdcp,uint8_t index)84 static 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
add_display_to_topology_v2(struct mod_hdcp * hdcp,struct mod_hdcp_display * display)122 static 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
add_display_to_topology_v3(struct mod_hdcp * hdcp,struct mod_hdcp_display * display)169 static 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
mod_hdcp_remove_display_from_topology(struct mod_hdcp * hdcp,uint8_t index)224 enum 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
mod_hdcp_add_display_to_topology(struct mod_hdcp * hdcp,struct mod_hdcp_display * display)237 enum 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
mod_hdcp_hdcp1_create_session(struct mod_hdcp * hdcp)250 enum 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
mod_hdcp_hdcp1_destroy_session(struct mod_hdcp * hdcp)289 enum 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
mod_hdcp_hdcp1_validate_rx(struct mod_hdcp * hdcp)323 enum 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
mod_hdcp_hdcp1_enable_encryption(struct mod_hdcp * hdcp)364 enum 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 if (!display)
372 return MOD_HDCP_STATUS_DISPLAY_NOT_FOUND;
373
374 mutex_lock(&psp->hdcp_context.mutex);
375 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.shared_buf;
376 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
377
378 hdcp_cmd->in_msg.hdcp1_enable_encryption.session_handle = hdcp->auth.id;
379 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP1_ENABLE_ENCRYPTION;
380
381 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
382
383 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) {
384 status = MOD_HDCP_STATUS_HDCP1_ENABLE_ENCRYPTION_FAILURE;
385 } else if (!is_dp_mst_hdcp(hdcp)) {
386 display->state = MOD_HDCP_DISPLAY_ENCRYPTION_ENABLED;
387 HDCP_HDCP1_ENABLED_TRACE(hdcp, display->index);
388 }
389
390 mutex_unlock(&psp->hdcp_context.mutex);
391 return status;
392 }
393
mod_hdcp_hdcp1_validate_ksvlist_vp(struct mod_hdcp * hdcp)394 enum mod_hdcp_status mod_hdcp_hdcp1_validate_ksvlist_vp(struct mod_hdcp *hdcp)
395 {
396 struct psp_context *psp = hdcp->config.psp.handle;
397 struct ta_hdcp_shared_memory *hdcp_cmd;
398 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
399
400 mutex_lock(&psp->hdcp_context.mutex);
401 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.shared_buf;
402 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
403
404 hdcp_cmd->in_msg.hdcp1_second_part_authentication.session_handle = hdcp->auth.id;
405
406 hdcp_cmd->in_msg.hdcp1_second_part_authentication.ksv_list_size = hdcp->auth.msg.hdcp1.ksvlist_size;
407 memcpy(hdcp_cmd->in_msg.hdcp1_second_part_authentication.ksv_list, hdcp->auth.msg.hdcp1.ksvlist,
408 hdcp->auth.msg.hdcp1.ksvlist_size);
409
410 memcpy(hdcp_cmd->in_msg.hdcp1_second_part_authentication.v_prime, hdcp->auth.msg.hdcp1.vp,
411 sizeof(hdcp->auth.msg.hdcp1.vp));
412
413 hdcp_cmd->in_msg.hdcp1_second_part_authentication.bstatus_binfo =
414 is_dp_hdcp(hdcp) ? hdcp->auth.msg.hdcp1.binfo_dp : hdcp->auth.msg.hdcp1.bstatus;
415 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP1_SECOND_PART_AUTHENTICATION;
416
417 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
418
419 if (hdcp_cmd->hdcp_status == TA_HDCP_STATUS__SUCCESS &&
420 hdcp_cmd->out_msg.hdcp1_second_part_authentication.authentication_status ==
421 TA_HDCP_AUTHENTICATION_STATUS__HDCP1_AUTHENTICATED) {
422 status = MOD_HDCP_STATUS_SUCCESS;
423 } else if (hdcp_cmd->out_msg.hdcp1_second_part_authentication.authentication_status ==
424 TA_HDCP_AUTHENTICATION_STATUS__HDCP1_KSV_REVOKED) {
425 hdcp->connection.is_hdcp1_revoked = 1;
426 status = MOD_HDCP_STATUS_HDCP1_KSV_LIST_REVOKED;
427 } else {
428 status = MOD_HDCP_STATUS_HDCP1_VALIDATE_KSV_LIST_FAILURE;
429 }
430
431 mutex_unlock(&psp->hdcp_context.mutex);
432 return status;
433 }
434
mod_hdcp_hdcp1_enable_dp_stream_encryption(struct mod_hdcp * hdcp)435 enum mod_hdcp_status mod_hdcp_hdcp1_enable_dp_stream_encryption(struct mod_hdcp *hdcp)
436 {
437
438 struct psp_context *psp = hdcp->config.psp.handle;
439 struct ta_hdcp_shared_memory *hdcp_cmd;
440 int i = 0;
441 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
442
443 mutex_lock(&psp->hdcp_context.mutex);
444 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.shared_buf;
445
446 for (i = 0; i < MAX_NUM_OF_DISPLAYS; i++) {
447
448 if (hdcp->displays[i].adjust.disable || hdcp->displays[i].state != MOD_HDCP_DISPLAY_ACTIVE)
449 continue;
450
451 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
452
453 hdcp_cmd->in_msg.hdcp1_enable_dp_stream_encryption.session_handle = hdcp->auth.id;
454 hdcp_cmd->in_msg.hdcp1_enable_dp_stream_encryption.display_handle = hdcp->displays[i].index;
455 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP1_ENABLE_DP_STREAM_ENCRYPTION;
456
457 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
458
459 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) {
460 status = MOD_HDCP_STATUS_HDCP1_ENABLE_STREAM_ENCRYPTION_FAILURE;
461 break;
462 }
463
464 hdcp->displays[i].state = MOD_HDCP_DISPLAY_ENCRYPTION_ENABLED;
465 HDCP_HDCP1_ENABLED_TRACE(hdcp, hdcp->displays[i].index);
466 }
467
468 mutex_unlock(&psp->hdcp_context.mutex);
469 return status;
470 }
471
mod_hdcp_hdcp1_link_maintenance(struct mod_hdcp * hdcp)472 enum mod_hdcp_status mod_hdcp_hdcp1_link_maintenance(struct mod_hdcp *hdcp)
473 {
474 struct psp_context *psp = hdcp->config.psp.handle;
475 struct ta_hdcp_shared_memory *hdcp_cmd;
476 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
477
478 mutex_lock(&psp->hdcp_context.mutex);
479 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.shared_buf;
480
481 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
482
483 hdcp_cmd->in_msg.hdcp1_get_encryption_status.session_handle = hdcp->auth.id;
484
485 hdcp_cmd->out_msg.hdcp1_get_encryption_status.protection_level = 0;
486 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP1_GET_ENCRYPTION_STATUS;
487
488 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
489
490 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS ||
491 hdcp_cmd->out_msg.hdcp1_get_encryption_status.protection_level != 1)
492 status = MOD_HDCP_STATUS_HDCP1_LINK_MAINTENANCE_FAILURE;
493
494 mutex_unlock(&psp->hdcp_context.mutex);
495 return status;
496 }
497
mod_hdcp_hdcp2_create_session(struct mod_hdcp * hdcp)498 enum mod_hdcp_status mod_hdcp_hdcp2_create_session(struct mod_hdcp *hdcp)
499 {
500 struct psp_context *psp = hdcp->config.psp.handle;
501 struct ta_hdcp_shared_memory *hdcp_cmd;
502 struct mod_hdcp_display *display = get_first_active_display(hdcp);
503 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
504
505
506 if (!psp->hdcp_context.context.initialized) {
507 DRM_ERROR("Failed to create hdcp session, HDCP TA is not initialized");
508 return MOD_HDCP_STATUS_FAILURE;
509 }
510
511 if (!display)
512 return MOD_HDCP_STATUS_DISPLAY_NOT_FOUND;
513
514 mutex_lock(&psp->hdcp_context.mutex);
515
516 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.shared_buf;
517 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
518
519 if (!display)
520 return MOD_HDCP_STATUS_DISPLAY_NOT_FOUND;
521
522 hdcp_cmd->in_msg.hdcp2_create_session_v2.display_handle = display->index;
523
524 if (hdcp->connection.link.adjust.hdcp2.force_type == MOD_HDCP_FORCE_TYPE_0)
525 hdcp_cmd->in_msg.hdcp2_create_session_v2.negotiate_content_type =
526 TA_HDCP2_CONTENT_TYPE_NEGOTIATION_TYPE__FORCE_TYPE0;
527 else if (hdcp->connection.link.adjust.hdcp2.force_type == MOD_HDCP_FORCE_TYPE_1)
528 hdcp_cmd->in_msg.hdcp2_create_session_v2.negotiate_content_type =
529 TA_HDCP2_CONTENT_TYPE_NEGOTIATION_TYPE__FORCE_TYPE1;
530 else if (hdcp->connection.link.adjust.hdcp2.force_type == MOD_HDCP_FORCE_TYPE_MAX)
531 hdcp_cmd->in_msg.hdcp2_create_session_v2.negotiate_content_type =
532 TA_HDCP2_CONTENT_TYPE_NEGOTIATION_TYPE__MAX_SUPPORTED;
533
534 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_CREATE_SESSION_V2;
535
536 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
537
538
539 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS)
540 status = MOD_HDCP_STATUS_HDCP2_CREATE_SESSION_FAILURE;
541 else
542 hdcp->auth.id = hdcp_cmd->out_msg.hdcp2_create_session_v2.session_handle;
543
544 mutex_unlock(&psp->hdcp_context.mutex);
545 return status;
546 }
547
mod_hdcp_hdcp2_destroy_session(struct mod_hdcp * hdcp)548 enum mod_hdcp_status mod_hdcp_hdcp2_destroy_session(struct mod_hdcp *hdcp)
549 {
550 struct psp_context *psp = hdcp->config.psp.handle;
551 struct ta_hdcp_shared_memory *hdcp_cmd;
552 uint8_t i = 0;
553 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
554
555 mutex_lock(&psp->hdcp_context.mutex);
556 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.shared_buf;
557 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
558
559 hdcp_cmd->in_msg.hdcp2_destroy_session.session_handle = hdcp->auth.id;
560 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_DESTROY_SESSION;
561
562 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
563
564 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) {
565 status = MOD_HDCP_STATUS_HDCP2_DESTROY_SESSION_FAILURE;
566 } else {
567 HDCP_TOP_HDCP2_DESTROY_SESSION_TRACE(hdcp);
568 for (i = 0; i < MAX_NUM_OF_DISPLAYS; i++)
569 if (is_display_encryption_enabled(&hdcp->displays[i])) {
570 hdcp->displays[i].state =
571 MOD_HDCP_DISPLAY_ACTIVE;
572 HDCP_HDCP2_DISABLED_TRACE(
573 hdcp, hdcp->displays[i].index);
574 }
575 }
576
577 mutex_unlock(&psp->hdcp_context.mutex);
578 return status;
579 }
580
mod_hdcp_hdcp2_prepare_ake_init(struct mod_hdcp * hdcp)581 enum mod_hdcp_status mod_hdcp_hdcp2_prepare_ake_init(struct mod_hdcp *hdcp)
582 {
583 struct psp_context *psp = hdcp->config.psp.handle;
584 struct ta_hdcp_shared_memory *hdcp_cmd;
585 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in;
586 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_output_v2 *msg_out;
587 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
588
589 mutex_lock(&psp->hdcp_context.mutex);
590 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.shared_buf;
591 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
592
593 msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2;
594 msg_out = &hdcp_cmd->out_msg.hdcp2_prepare_process_authentication_message_v2;
595
596 hdcp2_message_init(hdcp, msg_in);
597
598 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_PREPARE_PROCESS_AUTHENTICATION_MSG_V2;
599 msg_in->prepare.msg1_id = TA_HDCP_HDCP2_MSG_ID__AKE_INIT;
600
601 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
602
603 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS)
604 status = MOD_HDCP_STATUS_HDCP2_PREP_AKE_INIT_FAILURE;
605 else
606 memcpy(&hdcp->auth.msg.hdcp2.ake_init[0], &msg_out->prepare.transmitter_message[0],
607 sizeof(hdcp->auth.msg.hdcp2.ake_init));
608
609 mutex_unlock(&psp->hdcp_context.mutex);
610 return status;
611 }
612
mod_hdcp_hdcp2_validate_ake_cert(struct mod_hdcp * hdcp)613 enum mod_hdcp_status mod_hdcp_hdcp2_validate_ake_cert(struct mod_hdcp *hdcp)
614 {
615 struct psp_context *psp = hdcp->config.psp.handle;
616 struct ta_hdcp_shared_memory *hdcp_cmd;
617 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in;
618 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_output_v2 *msg_out;
619 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
620
621 mutex_lock(&psp->hdcp_context.mutex);
622 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.shared_buf;
623 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
624
625 msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2;
626 msg_out = &hdcp_cmd->out_msg.hdcp2_prepare_process_authentication_message_v2;
627
628 hdcp2_message_init(hdcp, msg_in);
629
630 msg_in->process.msg1_desc.msg_id = TA_HDCP_HDCP2_MSG_ID__AKE_SEND_CERT;
631 msg_in->process.msg1_desc.msg_size = TA_HDCP_HDCP2_MSG_ID_MAX_SIZE__AKE_SEND_CERT;
632
633 memcpy(&msg_in->process.receiver_message[0], hdcp->auth.msg.hdcp2.ake_cert,
634 sizeof(hdcp->auth.msg.hdcp2.ake_cert));
635
636 msg_in->prepare.msg1_id = TA_HDCP_HDCP2_MSG_ID__AKE_NO_STORED_KM;
637 msg_in->prepare.msg2_id = TA_HDCP_HDCP2_MSG_ID__AKE_STORED_KM;
638
639 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_PREPARE_PROCESS_AUTHENTICATION_MSG_V2;
640
641 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
642
643 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) {
644 status = MOD_HDCP_STATUS_HDCP2_VALIDATE_AKE_CERT_FAILURE;
645 } else {
646 memcpy(hdcp->auth.msg.hdcp2.ake_no_stored_km,
647 &msg_out->prepare.transmitter_message[0],
648 sizeof(hdcp->auth.msg.hdcp2.ake_no_stored_km));
649
650 memcpy(hdcp->auth.msg.hdcp2.ake_stored_km,
651 &msg_out->prepare.transmitter_message[sizeof(hdcp->auth.msg.hdcp2.ake_no_stored_km)],
652 sizeof(hdcp->auth.msg.hdcp2.ake_stored_km));
653
654 if (msg_out->process.msg1_status ==
655 TA_HDCP2_MSG_AUTHENTICATION_STATUS__SUCCESS) {
656 hdcp->connection.is_km_stored =
657 msg_out->process.is_km_stored ? 1 : 0;
658 hdcp->connection.is_repeater =
659 msg_out->process.is_repeater ? 1 : 0;
660 status = MOD_HDCP_STATUS_SUCCESS;
661 } else if (msg_out->process.msg1_status ==
662 TA_HDCP2_MSG_AUTHENTICATION_STATUS__RECEIVERID_REVOKED) {
663 hdcp->connection.is_hdcp2_revoked = 1;
664 status = MOD_HDCP_STATUS_HDCP2_AKE_CERT_REVOKED;
665 } else {
666 status = MOD_HDCP_STATUS_HDCP2_VALIDATE_AKE_CERT_FAILURE;
667 }
668 }
669 mutex_unlock(&psp->hdcp_context.mutex);
670 return status;
671 }
672
mod_hdcp_hdcp2_validate_h_prime(struct mod_hdcp * hdcp)673 enum mod_hdcp_status mod_hdcp_hdcp2_validate_h_prime(struct mod_hdcp *hdcp)
674 {
675 struct psp_context *psp = hdcp->config.psp.handle;
676 struct ta_hdcp_shared_memory *hdcp_cmd;
677 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in;
678 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_output_v2 *msg_out;
679 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
680
681 mutex_lock(&psp->hdcp_context.mutex);
682 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.shared_buf;
683 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
684
685 msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2;
686 msg_out = &hdcp_cmd->out_msg.hdcp2_prepare_process_authentication_message_v2;
687
688 hdcp2_message_init(hdcp, msg_in);
689
690 msg_in->process.msg1_desc.msg_id = TA_HDCP_HDCP2_MSG_ID__AKE_SEND_H_PRIME;
691 msg_in->process.msg1_desc.msg_size = TA_HDCP_HDCP2_MSG_ID_MAX_SIZE__AKE_SEND_H_PRIME;
692
693 memcpy(&msg_in->process.receiver_message[0], hdcp->auth.msg.hdcp2.ake_h_prime,
694 sizeof(hdcp->auth.msg.hdcp2.ake_h_prime));
695
696 if (!hdcp->connection.is_km_stored) {
697 msg_in->process.msg2_desc.msg_id = TA_HDCP_HDCP2_MSG_ID__AKE_SEND_PAIRING_INFO;
698 msg_in->process.msg2_desc.msg_size = TA_HDCP_HDCP2_MSG_ID_MAX_SIZE__AKE_SEND_PAIRING_INFO;
699 memcpy(&msg_in->process.receiver_message[sizeof(hdcp->auth.msg.hdcp2.ake_h_prime)],
700 hdcp->auth.msg.hdcp2.ake_pairing_info, sizeof(hdcp->auth.msg.hdcp2.ake_pairing_info));
701 }
702
703 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_PREPARE_PROCESS_AUTHENTICATION_MSG_V2;
704
705 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
706
707 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS)
708 status = MOD_HDCP_STATUS_HDCP2_VALIDATE_H_PRIME_FAILURE;
709 else if (msg_out->process.msg1_status != TA_HDCP2_MSG_AUTHENTICATION_STATUS__SUCCESS)
710 status = MOD_HDCP_STATUS_HDCP2_VALIDATE_H_PRIME_FAILURE;
711 else if (!hdcp->connection.is_km_stored &&
712 msg_out->process.msg2_status != TA_HDCP2_MSG_AUTHENTICATION_STATUS__SUCCESS)
713 status = MOD_HDCP_STATUS_HDCP2_VALIDATE_PAIRING_INFO_FAILURE;
714
715 mutex_unlock(&psp->hdcp_context.mutex);
716 return status;
717 }
718
mod_hdcp_hdcp2_prepare_lc_init(struct mod_hdcp * hdcp)719 enum mod_hdcp_status mod_hdcp_hdcp2_prepare_lc_init(struct mod_hdcp *hdcp)
720 {
721 struct psp_context *psp = hdcp->config.psp.handle;
722 struct ta_hdcp_shared_memory *hdcp_cmd;
723 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in;
724 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_output_v2 *msg_out;
725 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
726
727 mutex_lock(&psp->hdcp_context.mutex);
728 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.shared_buf;
729 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
730
731 msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2;
732 msg_out = &hdcp_cmd->out_msg.hdcp2_prepare_process_authentication_message_v2;
733
734 hdcp2_message_init(hdcp, msg_in);
735
736 msg_in->prepare.msg1_id = TA_HDCP_HDCP2_MSG_ID__LC_INIT;
737
738 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_PREPARE_PROCESS_AUTHENTICATION_MSG_V2;
739
740 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
741
742 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS)
743 status = MOD_HDCP_STATUS_HDCP2_PREP_LC_INIT_FAILURE;
744 else
745 memcpy(hdcp->auth.msg.hdcp2.lc_init, &msg_out->prepare.transmitter_message[0],
746 sizeof(hdcp->auth.msg.hdcp2.lc_init));
747
748 mutex_unlock(&psp->hdcp_context.mutex);
749 return status;
750 }
751
mod_hdcp_hdcp2_validate_l_prime(struct mod_hdcp * hdcp)752 enum mod_hdcp_status mod_hdcp_hdcp2_validate_l_prime(struct mod_hdcp *hdcp)
753 {
754 struct psp_context *psp = hdcp->config.psp.handle;
755 struct ta_hdcp_shared_memory *hdcp_cmd;
756 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in;
757 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_output_v2 *msg_out;
758 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
759
760 mutex_lock(&psp->hdcp_context.mutex);
761 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.shared_buf;
762 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
763
764 msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2;
765 msg_out = &hdcp_cmd->out_msg.hdcp2_prepare_process_authentication_message_v2;
766
767 hdcp2_message_init(hdcp, msg_in);
768
769 msg_in->process.msg1_desc.msg_id = TA_HDCP_HDCP2_MSG_ID__LC_SEND_L_PRIME;
770 msg_in->process.msg1_desc.msg_size = TA_HDCP_HDCP2_MSG_ID_MAX_SIZE__LC_SEND_L_PRIME;
771
772 memcpy(&msg_in->process.receiver_message[0], hdcp->auth.msg.hdcp2.lc_l_prime,
773 sizeof(hdcp->auth.msg.hdcp2.lc_l_prime));
774
775 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_PREPARE_PROCESS_AUTHENTICATION_MSG_V2;
776
777 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
778
779 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS ||
780 msg_out->process.msg1_status != TA_HDCP2_MSG_AUTHENTICATION_STATUS__SUCCESS)
781 status = MOD_HDCP_STATUS_HDCP2_VALIDATE_L_PRIME_FAILURE;
782
783 mutex_unlock(&psp->hdcp_context.mutex);
784 return status;
785 }
786
mod_hdcp_hdcp2_prepare_eks(struct mod_hdcp * hdcp)787 enum mod_hdcp_status mod_hdcp_hdcp2_prepare_eks(struct mod_hdcp *hdcp)
788 {
789 struct psp_context *psp = hdcp->config.psp.handle;
790 struct ta_hdcp_shared_memory *hdcp_cmd;
791 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in;
792 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_output_v2 *msg_out;
793 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
794
795 mutex_lock(&psp->hdcp_context.mutex);
796 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.shared_buf;
797 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
798
799 msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2;
800 msg_out = &hdcp_cmd->out_msg.hdcp2_prepare_process_authentication_message_v2;
801
802 hdcp2_message_init(hdcp, msg_in);
803
804 msg_in->prepare.msg1_id = TA_HDCP_HDCP2_MSG_ID__SKE_SEND_EKS;
805
806 if (is_dp_hdcp(hdcp))
807 msg_in->prepare.msg2_id = TA_HDCP_HDCP2_MSG_ID__SIGNAL_CONTENT_STREAM_TYPE_DP;
808
809 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_PREPARE_PROCESS_AUTHENTICATION_MSG_V2;
810 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
811
812 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) {
813 status = MOD_HDCP_STATUS_HDCP2_PREP_EKS_FAILURE;
814 } else {
815 memcpy(hdcp->auth.msg.hdcp2.ske_eks,
816 &msg_out->prepare.transmitter_message[0],
817 sizeof(hdcp->auth.msg.hdcp2.ske_eks));
818 msg_out->prepare.msg1_desc.msg_size =
819 sizeof(hdcp->auth.msg.hdcp2.ske_eks);
820
821 if (is_dp_hdcp(hdcp)) {
822 memcpy(hdcp->auth.msg.hdcp2.content_stream_type_dp,
823 &msg_out->prepare.transmitter_message[sizeof(hdcp->auth.msg.hdcp2.ske_eks)],
824 sizeof(hdcp->auth.msg.hdcp2.content_stream_type_dp));
825 }
826 }
827 mutex_unlock(&psp->hdcp_context.mutex);
828
829 return status;
830 }
831
mod_hdcp_hdcp2_enable_encryption(struct mod_hdcp * hdcp)832 enum mod_hdcp_status mod_hdcp_hdcp2_enable_encryption(struct mod_hdcp *hdcp)
833 {
834 struct psp_context *psp = hdcp->config.psp.handle;
835 struct ta_hdcp_shared_memory *hdcp_cmd;
836 struct mod_hdcp_display *display = get_first_active_display(hdcp);
837 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
838
839 if (!display)
840 return MOD_HDCP_STATUS_DISPLAY_NOT_FOUND;
841
842 mutex_lock(&psp->hdcp_context.mutex);
843
844 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.shared_buf;
845 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
846
847 hdcp_cmd->in_msg.hdcp2_set_encryption.session_handle = hdcp->auth.id;
848
849 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_SET_ENCRYPTION;
850 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
851
852 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) {
853 status = MOD_HDCP_STATUS_HDCP2_ENABLE_ENCRYPTION_FAILURE;
854 } else if (!is_dp_mst_hdcp(hdcp)) {
855 display->state = MOD_HDCP_DISPLAY_ENCRYPTION_ENABLED;
856 HDCP_HDCP2_ENABLED_TRACE(hdcp, display->index);
857 }
858
859 mutex_unlock(&psp->hdcp_context.mutex);
860 return status;
861 }
862
mod_hdcp_hdcp2_validate_rx_id_list(struct mod_hdcp * hdcp)863 enum mod_hdcp_status mod_hdcp_hdcp2_validate_rx_id_list(struct mod_hdcp *hdcp)
864 {
865 struct psp_context *psp = hdcp->config.psp.handle;
866 struct ta_hdcp_shared_memory *hdcp_cmd;
867 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in;
868 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_output_v2 *msg_out;
869 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
870
871 mutex_lock(&psp->hdcp_context.mutex);
872
873 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.shared_buf;
874 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
875
876 msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2;
877 msg_out = &hdcp_cmd->out_msg.hdcp2_prepare_process_authentication_message_v2;
878
879 hdcp2_message_init(hdcp, msg_in);
880
881 msg_in->process.msg1_desc.msg_id = TA_HDCP_HDCP2_MSG_ID__REPEATERAUTH_SEND_RECEIVERID_LIST;
882 msg_in->process.msg1_desc.msg_size = sizeof(hdcp->auth.msg.hdcp2.rx_id_list);
883 memcpy(&msg_in->process.receiver_message[0], hdcp->auth.msg.hdcp2.rx_id_list,
884 sizeof(hdcp->auth.msg.hdcp2.rx_id_list));
885
886 msg_in->prepare.msg1_id = TA_HDCP_HDCP2_MSG_ID__REPEATERAUTH_SEND_ACK;
887
888 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_PREPARE_PROCESS_AUTHENTICATION_MSG_V2;
889
890 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
891
892 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) {
893 status = MOD_HDCP_STATUS_HDCP2_VALIDATE_RX_ID_LIST_FAILURE;
894 } else {
895 memcpy(hdcp->auth.msg.hdcp2.repeater_auth_ack,
896 &msg_out->prepare.transmitter_message[0],
897 sizeof(hdcp->auth.msg.hdcp2.repeater_auth_ack));
898
899 if (msg_out->process.msg1_status ==
900 TA_HDCP2_MSG_AUTHENTICATION_STATUS__SUCCESS) {
901 hdcp->connection.is_km_stored = msg_out->process.is_km_stored ? 1 : 0;
902 hdcp->connection.is_repeater = msg_out->process.is_repeater ? 1 : 0;
903 status = MOD_HDCP_STATUS_SUCCESS;
904 } else if (msg_out->process.msg1_status ==
905 TA_HDCP2_MSG_AUTHENTICATION_STATUS__RECEIVERID_REVOKED) {
906 hdcp->connection.is_hdcp2_revoked = 1;
907 status = MOD_HDCP_STATUS_HDCP2_RX_ID_LIST_REVOKED;
908 } else {
909 status = MOD_HDCP_STATUS_HDCP2_VALIDATE_RX_ID_LIST_FAILURE;
910 }
911 }
912 mutex_unlock(&psp->hdcp_context.mutex);
913 return status;
914 }
915
mod_hdcp_hdcp2_enable_dp_stream_encryption(struct mod_hdcp * hdcp)916 enum mod_hdcp_status mod_hdcp_hdcp2_enable_dp_stream_encryption(struct mod_hdcp *hdcp)
917 {
918 struct psp_context *psp = hdcp->config.psp.handle;
919 struct ta_hdcp_shared_memory *hdcp_cmd;
920 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in;
921 uint8_t i;
922 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
923
924 mutex_lock(&psp->hdcp_context.mutex);
925 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.shared_buf;
926 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
927
928 msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2;
929
930 hdcp2_message_init(hdcp, msg_in);
931
932
933 for (i = 0; i < MAX_NUM_OF_DISPLAYS; i++) {
934 if (hdcp->displays[i].adjust.disable || hdcp->displays[i].state != MOD_HDCP_DISPLAY_ACTIVE)
935 continue;
936
937 hdcp_cmd->in_msg.hdcp2_enable_dp_stream_encryption.display_handle = hdcp->displays[i].index;
938 hdcp_cmd->in_msg.hdcp2_enable_dp_stream_encryption.session_handle = hdcp->auth.id;
939
940 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_ENABLE_DP_STREAM_ENCRYPTION;
941 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
942
943 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS)
944 break;
945
946 hdcp->displays[i].state = MOD_HDCP_DISPLAY_ENCRYPTION_ENABLED;
947 HDCP_HDCP2_ENABLED_TRACE(hdcp, hdcp->displays[i].index);
948 }
949
950 if (hdcp_cmd->hdcp_status == TA_HDCP_STATUS__SUCCESS)
951 status = MOD_HDCP_STATUS_SUCCESS;
952 else
953 status = MOD_HDCP_STATUS_HDCP2_ENABLE_STREAM_ENCRYPTION_FAILURE;
954
955 mutex_unlock(&psp->hdcp_context.mutex);
956 return status;
957 }
958
mod_hdcp_hdcp2_prepare_stream_management(struct mod_hdcp * hdcp)959 enum mod_hdcp_status mod_hdcp_hdcp2_prepare_stream_management(struct mod_hdcp *hdcp)
960 {
961
962 struct psp_context *psp = hdcp->config.psp.handle;
963 struct ta_hdcp_shared_memory *hdcp_cmd;
964 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in;
965 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_output_v2 *msg_out;
966 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
967
968 mutex_lock(&psp->hdcp_context.mutex);
969 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.shared_buf;
970 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
971
972 msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2;
973 msg_out = &hdcp_cmd->out_msg.hdcp2_prepare_process_authentication_message_v2;
974
975 hdcp2_message_init(hdcp, msg_in);
976
977 msg_in->prepare.msg1_id = TA_HDCP_HDCP2_MSG_ID__REPEATERAUTH_STREAM_MANAGE;
978
979
980 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_PREPARE_PROCESS_AUTHENTICATION_MSG_V2;
981 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
982
983 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) {
984 status = MOD_HDCP_STATUS_HDCP2_PREPARE_STREAM_MANAGEMENT_FAILURE;
985 } else {
986 hdcp->auth.msg.hdcp2.stream_manage_size = msg_out->prepare.msg1_desc.msg_size;
987
988 memcpy(hdcp->auth.msg.hdcp2.repeater_auth_stream_manage,
989 &msg_out->prepare.transmitter_message[0],
990 sizeof(hdcp->auth.msg.hdcp2.repeater_auth_stream_manage));
991 }
992 mutex_unlock(&psp->hdcp_context.mutex);
993 return status;
994 }
995
mod_hdcp_hdcp2_validate_stream_ready(struct mod_hdcp * hdcp)996 enum mod_hdcp_status mod_hdcp_hdcp2_validate_stream_ready(struct mod_hdcp *hdcp)
997 {
998 struct psp_context *psp = hdcp->config.psp.handle;
999 struct ta_hdcp_shared_memory *hdcp_cmd;
1000 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in;
1001 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_output_v2 *msg_out;
1002 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
1003
1004 mutex_lock(&psp->hdcp_context.mutex);
1005 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.shared_buf;
1006 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
1007
1008 msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2;
1009 msg_out = &hdcp_cmd->out_msg.hdcp2_prepare_process_authentication_message_v2;
1010
1011 hdcp2_message_init(hdcp, msg_in);
1012
1013 msg_in->process.msg1_desc.msg_id = TA_HDCP_HDCP2_MSG_ID__REPEATERAUTH_STREAM_READY;
1014
1015 msg_in->process.msg1_desc.msg_size = sizeof(hdcp->auth.msg.hdcp2.repeater_auth_stream_ready);
1016
1017 memcpy(&msg_in->process.receiver_message[0], hdcp->auth.msg.hdcp2.repeater_auth_stream_ready,
1018 sizeof(hdcp->auth.msg.hdcp2.repeater_auth_stream_ready));
1019
1020 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_PREPARE_PROCESS_AUTHENTICATION_MSG_V2;
1021 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
1022
1023 if (hdcp_cmd->hdcp_status == TA_HDCP_STATUS__SUCCESS &&
1024 msg_out->process.msg1_status == TA_HDCP2_MSG_AUTHENTICATION_STATUS__SUCCESS)
1025 status = MOD_HDCP_STATUS_SUCCESS;
1026 else
1027 status = MOD_HDCP_STATUS_HDCP2_VALIDATE_STREAM_READY_FAILURE;
1028
1029 mutex_unlock(&psp->hdcp_context.mutex);
1030 return status;
1031 }
1032