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 if (!display)
264 return MOD_HDCP_STATUS_DISPLAY_NOT_FOUND;
265
266 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.shared_buf;
267
268 mutex_lock(&psp->hdcp_context.mutex);
269 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
270
271 hdcp_cmd->in_msg.hdcp1_create_session.display_handle = display->index;
272 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP1_CREATE_SESSION;
273
274 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
275
276 hdcp->auth.id = hdcp_cmd->out_msg.hdcp1_create_session.session_handle;
277
278 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) {
279 status = MOD_HDCP_STATUS_HDCP1_CREATE_SESSION_FAILURE;
280 } else {
281 hdcp->auth.msg.hdcp1.ainfo = hdcp_cmd->out_msg.hdcp1_create_session.ainfo_primary;
282 memcpy(hdcp->auth.msg.hdcp1.aksv, hdcp_cmd->out_msg.hdcp1_create_session.aksv_primary,
283 sizeof(hdcp->auth.msg.hdcp1.aksv));
284 memcpy(hdcp->auth.msg.hdcp1.an, hdcp_cmd->out_msg.hdcp1_create_session.an_primary,
285 sizeof(hdcp->auth.msg.hdcp1.an));
286 }
287
288 mutex_unlock(&psp->hdcp_context.mutex);
289 return status;
290 }
291
mod_hdcp_hdcp1_destroy_session(struct mod_hdcp * hdcp)292 enum mod_hdcp_status mod_hdcp_hdcp1_destroy_session(struct mod_hdcp *hdcp)
293 {
294
295 struct psp_context *psp = hdcp->config.psp.handle;
296 struct ta_hdcp_shared_memory *hdcp_cmd;
297 uint8_t i = 0;
298 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
299
300 mutex_lock(&psp->hdcp_context.mutex);
301 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.shared_buf;
302 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
303
304 hdcp_cmd->in_msg.hdcp1_destroy_session.session_handle = hdcp->auth.id;
305 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP1_DESTROY_SESSION;
306
307 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
308
309 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) {
310 status = MOD_HDCP_STATUS_HDCP1_DESTROY_SESSION_FAILURE;
311 } else {
312 HDCP_TOP_HDCP1_DESTROY_SESSION_TRACE(hdcp);
313 for (i = 0; i < MAX_NUM_OF_DISPLAYS; i++)
314 if (is_display_encryption_enabled(&hdcp->displays[i])) {
315 hdcp->displays[i].state =
316 MOD_HDCP_DISPLAY_ACTIVE;
317 HDCP_HDCP1_DISABLED_TRACE(
318 hdcp, hdcp->displays[i].index);
319 }
320 }
321
322 mutex_unlock(&psp->hdcp_context.mutex);
323 return status;
324 }
325
mod_hdcp_hdcp1_validate_rx(struct mod_hdcp * hdcp)326 enum mod_hdcp_status mod_hdcp_hdcp1_validate_rx(struct mod_hdcp *hdcp)
327 {
328 struct psp_context *psp = hdcp->config.psp.handle;
329 struct ta_hdcp_shared_memory *hdcp_cmd;
330 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
331
332 mutex_lock(&psp->hdcp_context.mutex);
333 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.shared_buf;
334 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
335
336 hdcp_cmd->in_msg.hdcp1_first_part_authentication.session_handle = hdcp->auth.id;
337
338 memcpy(hdcp_cmd->in_msg.hdcp1_first_part_authentication.bksv_primary, hdcp->auth.msg.hdcp1.bksv,
339 TA_HDCP__HDCP1_KSV_SIZE);
340
341 hdcp_cmd->in_msg.hdcp1_first_part_authentication.r0_prime_primary = hdcp->auth.msg.hdcp1.r0p;
342 hdcp_cmd->in_msg.hdcp1_first_part_authentication.bcaps = hdcp->auth.msg.hdcp1.bcaps;
343 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP1_FIRST_PART_AUTHENTICATION;
344
345 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
346
347 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) {
348 status = MOD_HDCP_STATUS_HDCP1_VALIDATE_RX_FAILURE;
349 } else if (hdcp_cmd->out_msg.hdcp1_first_part_authentication.authentication_status ==
350 TA_HDCP_AUTHENTICATION_STATUS__HDCP1_FIRST_PART_COMPLETE) {
351 /* needs second part of authentication */
352 hdcp->connection.is_repeater = 1;
353 } else if (hdcp_cmd->out_msg.hdcp1_first_part_authentication.authentication_status ==
354 TA_HDCP_AUTHENTICATION_STATUS__HDCP1_AUTHENTICATED) {
355 hdcp->connection.is_repeater = 0;
356 } else if (hdcp_cmd->out_msg.hdcp1_first_part_authentication.authentication_status ==
357 TA_HDCP_AUTHENTICATION_STATUS__HDCP1_KSV_REVOKED) {
358 hdcp->connection.is_hdcp1_revoked = 1;
359 status = MOD_HDCP_STATUS_HDCP1_BKSV_REVOKED;
360 } else
361 status = MOD_HDCP_STATUS_HDCP1_VALIDATE_RX_FAILURE;
362
363 mutex_unlock(&psp->hdcp_context.mutex);
364 return status;
365 }
366
mod_hdcp_hdcp1_enable_encryption(struct mod_hdcp * hdcp)367 enum mod_hdcp_status mod_hdcp_hdcp1_enable_encryption(struct mod_hdcp *hdcp)
368 {
369 struct psp_context *psp = hdcp->config.psp.handle;
370 struct ta_hdcp_shared_memory *hdcp_cmd;
371 struct mod_hdcp_display *display = get_first_active_display(hdcp);
372 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
373
374 if (!display)
375 return MOD_HDCP_STATUS_DISPLAY_NOT_FOUND;
376
377 mutex_lock(&psp->hdcp_context.mutex);
378 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.shared_buf;
379 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
380
381 hdcp_cmd->in_msg.hdcp1_enable_encryption.session_handle = hdcp->auth.id;
382 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP1_ENABLE_ENCRYPTION;
383
384 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
385
386 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) {
387 status = MOD_HDCP_STATUS_HDCP1_ENABLE_ENCRYPTION_FAILURE;
388 } else if (!is_dp_mst_hdcp(hdcp)) {
389 display->state = MOD_HDCP_DISPLAY_ENCRYPTION_ENABLED;
390 HDCP_HDCP1_ENABLED_TRACE(hdcp, display->index);
391 }
392
393 mutex_unlock(&psp->hdcp_context.mutex);
394 return status;
395 }
396
mod_hdcp_hdcp1_validate_ksvlist_vp(struct mod_hdcp * hdcp)397 enum mod_hdcp_status mod_hdcp_hdcp1_validate_ksvlist_vp(struct mod_hdcp *hdcp)
398 {
399 struct psp_context *psp = hdcp->config.psp.handle;
400 struct ta_hdcp_shared_memory *hdcp_cmd;
401 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
402
403 mutex_lock(&psp->hdcp_context.mutex);
404 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.shared_buf;
405 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
406
407 hdcp_cmd->in_msg.hdcp1_second_part_authentication.session_handle = hdcp->auth.id;
408
409 hdcp_cmd->in_msg.hdcp1_second_part_authentication.ksv_list_size = hdcp->auth.msg.hdcp1.ksvlist_size;
410 memcpy(hdcp_cmd->in_msg.hdcp1_second_part_authentication.ksv_list, hdcp->auth.msg.hdcp1.ksvlist,
411 hdcp->auth.msg.hdcp1.ksvlist_size);
412
413 memcpy(hdcp_cmd->in_msg.hdcp1_second_part_authentication.v_prime, hdcp->auth.msg.hdcp1.vp,
414 sizeof(hdcp->auth.msg.hdcp1.vp));
415
416 hdcp_cmd->in_msg.hdcp1_second_part_authentication.bstatus_binfo =
417 is_dp_hdcp(hdcp) ? hdcp->auth.msg.hdcp1.binfo_dp : hdcp->auth.msg.hdcp1.bstatus;
418 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP1_SECOND_PART_AUTHENTICATION;
419
420 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
421
422 if (hdcp_cmd->hdcp_status == TA_HDCP_STATUS__SUCCESS &&
423 hdcp_cmd->out_msg.hdcp1_second_part_authentication.authentication_status ==
424 TA_HDCP_AUTHENTICATION_STATUS__HDCP1_AUTHENTICATED) {
425 status = MOD_HDCP_STATUS_SUCCESS;
426 } else if (hdcp_cmd->out_msg.hdcp1_second_part_authentication.authentication_status ==
427 TA_HDCP_AUTHENTICATION_STATUS__HDCP1_KSV_REVOKED) {
428 hdcp->connection.is_hdcp1_revoked = 1;
429 status = MOD_HDCP_STATUS_HDCP1_KSV_LIST_REVOKED;
430 } else {
431 status = MOD_HDCP_STATUS_HDCP1_VALIDATE_KSV_LIST_FAILURE;
432 }
433
434 mutex_unlock(&psp->hdcp_context.mutex);
435 return status;
436 }
437
mod_hdcp_hdcp1_enable_dp_stream_encryption(struct mod_hdcp * hdcp)438 enum mod_hdcp_status mod_hdcp_hdcp1_enable_dp_stream_encryption(struct mod_hdcp *hdcp)
439 {
440
441 struct psp_context *psp = hdcp->config.psp.handle;
442 struct ta_hdcp_shared_memory *hdcp_cmd;
443 int i = 0;
444 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
445
446 mutex_lock(&psp->hdcp_context.mutex);
447 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.shared_buf;
448
449 for (i = 0; i < MAX_NUM_OF_DISPLAYS; i++) {
450
451 if (hdcp->displays[i].adjust.disable || hdcp->displays[i].state != MOD_HDCP_DISPLAY_ACTIVE)
452 continue;
453
454 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
455
456 hdcp_cmd->in_msg.hdcp1_enable_dp_stream_encryption.session_handle = hdcp->auth.id;
457 hdcp_cmd->in_msg.hdcp1_enable_dp_stream_encryption.display_handle = hdcp->displays[i].index;
458 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP1_ENABLE_DP_STREAM_ENCRYPTION;
459
460 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
461
462 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) {
463 status = MOD_HDCP_STATUS_HDCP1_ENABLE_STREAM_ENCRYPTION_FAILURE;
464 break;
465 }
466
467 hdcp->displays[i].state = MOD_HDCP_DISPLAY_ENCRYPTION_ENABLED;
468 HDCP_HDCP1_ENABLED_TRACE(hdcp, hdcp->displays[i].index);
469 }
470
471 mutex_unlock(&psp->hdcp_context.mutex);
472 return status;
473 }
474
mod_hdcp_hdcp1_link_maintenance(struct mod_hdcp * hdcp)475 enum mod_hdcp_status mod_hdcp_hdcp1_link_maintenance(struct mod_hdcp *hdcp)
476 {
477 struct psp_context *psp = hdcp->config.psp.handle;
478 struct ta_hdcp_shared_memory *hdcp_cmd;
479 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
480
481 mutex_lock(&psp->hdcp_context.mutex);
482 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.shared_buf;
483
484 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
485
486 hdcp_cmd->in_msg.hdcp1_get_encryption_status.session_handle = hdcp->auth.id;
487
488 hdcp_cmd->out_msg.hdcp1_get_encryption_status.protection_level = 0;
489 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP1_GET_ENCRYPTION_STATUS;
490
491 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
492
493 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS ||
494 hdcp_cmd->out_msg.hdcp1_get_encryption_status.protection_level != 1)
495 status = MOD_HDCP_STATUS_HDCP1_LINK_MAINTENANCE_FAILURE;
496
497 mutex_unlock(&psp->hdcp_context.mutex);
498 return status;
499 }
500
mod_hdcp_hdcp2_create_session(struct mod_hdcp * hdcp)501 enum mod_hdcp_status mod_hdcp_hdcp2_create_session(struct mod_hdcp *hdcp)
502 {
503 struct psp_context *psp = hdcp->config.psp.handle;
504 struct ta_hdcp_shared_memory *hdcp_cmd;
505 struct mod_hdcp_display *display = get_first_active_display(hdcp);
506 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
507
508
509 if (!psp->hdcp_context.context.initialized) {
510 DRM_ERROR("Failed to create hdcp session, HDCP TA is not initialized");
511 return MOD_HDCP_STATUS_FAILURE;
512 }
513
514 if (!display)
515 return MOD_HDCP_STATUS_DISPLAY_NOT_FOUND;
516
517 mutex_lock(&psp->hdcp_context.mutex);
518
519 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.shared_buf;
520 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
521
522 hdcp_cmd->in_msg.hdcp2_create_session_v2.display_handle = display->index;
523
524 if (hdcp->connection.link.adjust.hdcp2.force_type == MOD_HDCP_FORCE_TYPE_0)
525 hdcp_cmd->in_msg.hdcp2_create_session_v2.negotiate_content_type =
526 TA_HDCP2_CONTENT_TYPE_NEGOTIATION_TYPE__FORCE_TYPE0;
527 else if (hdcp->connection.link.adjust.hdcp2.force_type == MOD_HDCP_FORCE_TYPE_1)
528 hdcp_cmd->in_msg.hdcp2_create_session_v2.negotiate_content_type =
529 TA_HDCP2_CONTENT_TYPE_NEGOTIATION_TYPE__FORCE_TYPE1;
530 else if (hdcp->connection.link.adjust.hdcp2.force_type == MOD_HDCP_FORCE_TYPE_MAX)
531 hdcp_cmd->in_msg.hdcp2_create_session_v2.negotiate_content_type =
532 TA_HDCP2_CONTENT_TYPE_NEGOTIATION_TYPE__MAX_SUPPORTED;
533
534 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_CREATE_SESSION_V2;
535
536 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
537
538
539 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS)
540 status = MOD_HDCP_STATUS_HDCP2_CREATE_SESSION_FAILURE;
541 else
542 hdcp->auth.id = hdcp_cmd->out_msg.hdcp2_create_session_v2.session_handle;
543
544 mutex_unlock(&psp->hdcp_context.mutex);
545 return status;
546 }
547
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