1 /* $NetBSD: amdgpu_hdcp1_execution.c,v 1.3 2021/12/19 12:02:39 riastradh Exp $ */
2
3 /*
4 * Copyright 2019 Advanced Micro Devices, Inc.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the "Software"),
8 * to deal in the Software without restriction, including without limitation
9 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
10 * and/or sell copies of the Software, and to permit persons to whom the
11 * Software is furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
20 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
21 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
22 * OTHER DEALINGS IN THE SOFTWARE.
23 *
24 * Authors: AMD
25 *
26 */
27
28 #include <sys/cdefs.h>
29 __KERNEL_RCSID(0, "$NetBSD: amdgpu_hdcp1_execution.c,v 1.3 2021/12/19 12:02:39 riastradh Exp $");
30
31 #include "hdcp.h"
32
validate_bksv(struct mod_hdcp * hdcp)33 static inline enum mod_hdcp_status validate_bksv(struct mod_hdcp *hdcp)
34 {
35 uint64_t n = 0;
36 uint8_t count = 0;
37
38 memcpy(&n, hdcp->auth.msg.hdcp1.bksv, sizeof(uint64_t));
39
40 while (n) {
41 count++;
42 n &= (n - 1);
43 }
44 return (count == 20) ? MOD_HDCP_STATUS_SUCCESS :
45 MOD_HDCP_STATUS_HDCP1_INVALID_BKSV;
46 }
47
check_ksv_ready(struct mod_hdcp * hdcp)48 static inline enum mod_hdcp_status check_ksv_ready(struct mod_hdcp *hdcp)
49 {
50 if (is_dp_hdcp(hdcp))
51 return (hdcp->auth.msg.hdcp1.bstatus & DP_BSTATUS_READY) ?
52 MOD_HDCP_STATUS_SUCCESS :
53 MOD_HDCP_STATUS_HDCP1_KSV_LIST_NOT_READY;
54 return (hdcp->auth.msg.hdcp1.bcaps & DRM_HDCP_DDC_BCAPS_KSV_FIFO_READY) ?
55 MOD_HDCP_STATUS_SUCCESS :
56 MOD_HDCP_STATUS_HDCP1_KSV_LIST_NOT_READY;
57 }
58
check_hdcp_capable_dp(struct mod_hdcp * hdcp)59 static inline enum mod_hdcp_status check_hdcp_capable_dp(struct mod_hdcp *hdcp)
60 {
61 return (hdcp->auth.msg.hdcp1.bcaps & DP_BCAPS_HDCP_CAPABLE) ?
62 MOD_HDCP_STATUS_SUCCESS :
63 MOD_HDCP_STATUS_HDCP1_NOT_CAPABLE;
64 }
65
check_r0p_available_dp(struct mod_hdcp * hdcp)66 static inline enum mod_hdcp_status check_r0p_available_dp(struct mod_hdcp *hdcp)
67 {
68 enum mod_hdcp_status status;
69 if (is_dp_hdcp(hdcp)) {
70 status = (hdcp->auth.msg.hdcp1.bstatus &
71 DP_BSTATUS_R0_PRIME_READY) ?
72 MOD_HDCP_STATUS_SUCCESS :
73 MOD_HDCP_STATUS_HDCP1_R0_PRIME_PENDING;
74 } else {
75 status = MOD_HDCP_STATUS_INVALID_OPERATION;
76 }
77 return status;
78 }
79
check_link_integrity_dp(struct mod_hdcp * hdcp)80 static inline enum mod_hdcp_status check_link_integrity_dp(
81 struct mod_hdcp *hdcp)
82 {
83 return (hdcp->auth.msg.hdcp1.bstatus &
84 DP_BSTATUS_LINK_FAILURE) ?
85 MOD_HDCP_STATUS_HDCP1_LINK_INTEGRITY_FAILURE :
86 MOD_HDCP_STATUS_SUCCESS;
87 }
88
check_no_reauthentication_request_dp(struct mod_hdcp * hdcp)89 static inline enum mod_hdcp_status check_no_reauthentication_request_dp(
90 struct mod_hdcp *hdcp)
91 {
92 return (hdcp->auth.msg.hdcp1.bstatus & DP_BSTATUS_REAUTH_REQ) ?
93 MOD_HDCP_STATUS_HDCP1_REAUTH_REQUEST_ISSUED :
94 MOD_HDCP_STATUS_SUCCESS;
95 }
96
check_no_max_cascade(struct mod_hdcp * hdcp)97 static inline enum mod_hdcp_status check_no_max_cascade(struct mod_hdcp *hdcp)
98 {
99 enum mod_hdcp_status status;
100
101 if (is_dp_hdcp(hdcp))
102 status = DRM_HDCP_MAX_CASCADE_EXCEEDED(hdcp->auth.msg.hdcp1.binfo_dp >> 8)
103 ? MOD_HDCP_STATUS_HDCP1_MAX_CASCADE_EXCEEDED_FAILURE
104 : MOD_HDCP_STATUS_SUCCESS;
105 else
106 status = DRM_HDCP_MAX_CASCADE_EXCEEDED(hdcp->auth.msg.hdcp1.bstatus >> 8)
107 ? MOD_HDCP_STATUS_HDCP1_MAX_CASCADE_EXCEEDED_FAILURE
108 : MOD_HDCP_STATUS_SUCCESS;
109 return status;
110 }
111
check_no_max_devs(struct mod_hdcp * hdcp)112 static inline enum mod_hdcp_status check_no_max_devs(struct mod_hdcp *hdcp)
113 {
114 enum mod_hdcp_status status;
115
116 if (is_dp_hdcp(hdcp))
117 status = DRM_HDCP_MAX_DEVICE_EXCEEDED(hdcp->auth.msg.hdcp1.binfo_dp) ?
118 MOD_HDCP_STATUS_HDCP1_MAX_DEVS_EXCEEDED_FAILURE :
119 MOD_HDCP_STATUS_SUCCESS;
120 else
121 status = DRM_HDCP_MAX_DEVICE_EXCEEDED(hdcp->auth.msg.hdcp1.bstatus) ?
122 MOD_HDCP_STATUS_HDCP1_MAX_DEVS_EXCEEDED_FAILURE :
123 MOD_HDCP_STATUS_SUCCESS;
124 return status;
125 }
126
get_device_count(struct mod_hdcp * hdcp)127 static inline uint8_t get_device_count(struct mod_hdcp *hdcp)
128 {
129 return is_dp_hdcp(hdcp) ?
130 DRM_HDCP_NUM_DOWNSTREAM(hdcp->auth.msg.hdcp1.binfo_dp) :
131 DRM_HDCP_NUM_DOWNSTREAM(hdcp->auth.msg.hdcp1.bstatus);
132 }
133
check_device_count(struct mod_hdcp * hdcp)134 static inline enum mod_hdcp_status check_device_count(struct mod_hdcp *hdcp)
135 {
136 /* device count must be greater than or equal to tracked hdcp displays */
137 return (get_device_count(hdcp) < get_added_display_count(hdcp)) ?
138 MOD_HDCP_STATUS_HDCP1_DEVICE_COUNT_MISMATCH_FAILURE :
139 MOD_HDCP_STATUS_SUCCESS;
140 }
141
wait_for_active_rx(struct mod_hdcp * hdcp,struct mod_hdcp_event_context * event_ctx,struct mod_hdcp_transition_input_hdcp1 * input)142 static enum mod_hdcp_status wait_for_active_rx(struct mod_hdcp *hdcp,
143 struct mod_hdcp_event_context *event_ctx,
144 struct mod_hdcp_transition_input_hdcp1 *input)
145 {
146 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
147
148 if (event_ctx->event != MOD_HDCP_EVENT_CALLBACK) {
149 event_ctx->unexpected_event = 1;
150 goto out;
151 }
152
153 if (!mod_hdcp_execute_and_set(mod_hdcp_read_bksv,
154 &input->bksv_read, &status,
155 hdcp, "bksv_read"))
156 goto out;
157 if (!mod_hdcp_execute_and_set(mod_hdcp_read_bcaps,
158 &input->bcaps_read, &status,
159 hdcp, "bcaps_read"))
160 goto out;
161 out:
162 return status;
163 }
164
exchange_ksvs(struct mod_hdcp * hdcp,struct mod_hdcp_event_context * event_ctx,struct mod_hdcp_transition_input_hdcp1 * input)165 static enum mod_hdcp_status exchange_ksvs(struct mod_hdcp *hdcp,
166 struct mod_hdcp_event_context *event_ctx,
167 struct mod_hdcp_transition_input_hdcp1 *input)
168 {
169 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
170
171 if (event_ctx->event != MOD_HDCP_EVENT_CALLBACK) {
172 event_ctx->unexpected_event = 1;
173 goto out;
174 }
175
176 if (!mod_hdcp_execute_and_set(mod_hdcp_add_display_topology,
177 &input->add_topology, &status,
178 hdcp, "add_topology"))
179 goto out;
180 if (!mod_hdcp_execute_and_set(mod_hdcp_hdcp1_create_session,
181 &input->create_session, &status,
182 hdcp, "create_session"))
183 goto out;
184 if (!mod_hdcp_execute_and_set(mod_hdcp_write_an,
185 &input->an_write, &status,
186 hdcp, "an_write"))
187 goto out;
188 if (!mod_hdcp_execute_and_set(mod_hdcp_write_aksv,
189 &input->aksv_write, &status,
190 hdcp, "aksv_write"))
191 goto out;
192 if (!mod_hdcp_execute_and_set(mod_hdcp_read_bksv,
193 &input->bksv_read, &status,
194 hdcp, "bksv_read"))
195 goto out;
196 if (!mod_hdcp_execute_and_set(validate_bksv,
197 &input->bksv_validation, &status,
198 hdcp, "bksv_validation"))
199 goto out;
200 if (hdcp->auth.msg.hdcp1.ainfo) {
201 if (!mod_hdcp_execute_and_set(mod_hdcp_write_ainfo,
202 &input->ainfo_write, &status,
203 hdcp, "ainfo_write"))
204 goto out;
205 }
206 out:
207 return status;
208 }
209
computations_validate_rx_test_for_repeater(struct mod_hdcp * hdcp,struct mod_hdcp_event_context * event_ctx,struct mod_hdcp_transition_input_hdcp1 * input)210 static enum mod_hdcp_status computations_validate_rx_test_for_repeater(
211 struct mod_hdcp *hdcp,
212 struct mod_hdcp_event_context *event_ctx,
213 struct mod_hdcp_transition_input_hdcp1 *input)
214 {
215 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
216
217 if (event_ctx->event != MOD_HDCP_EVENT_CALLBACK) {
218 event_ctx->unexpected_event = 1;
219 goto out;
220 }
221
222 if (!mod_hdcp_execute_and_set(mod_hdcp_read_r0p,
223 &input->r0p_read, &status,
224 hdcp, "r0p_read"))
225 goto out;
226 if (!mod_hdcp_execute_and_set(mod_hdcp_hdcp1_validate_rx,
227 &input->rx_validation, &status,
228 hdcp, "rx_validation"))
229 goto out;
230 if (hdcp->connection.is_repeater) {
231 if (!hdcp->connection.link.adjust.hdcp1.postpone_encryption)
232 if (!mod_hdcp_execute_and_set(
233 mod_hdcp_hdcp1_enable_encryption,
234 &input->encryption, &status,
235 hdcp, "encryption"))
236 goto out;
237 } else {
238 if (!mod_hdcp_execute_and_set(mod_hdcp_hdcp1_enable_encryption,
239 &input->encryption, &status,
240 hdcp, "encryption"))
241 goto out;
242 if (is_dp_mst_hdcp(hdcp))
243 if (!mod_hdcp_execute_and_set(
244 mod_hdcp_hdcp1_enable_dp_stream_encryption,
245 &input->stream_encryption_dp, &status,
246 hdcp, "stream_encryption_dp"))
247 goto out;
248 }
249 out:
250 return status;
251 }
252
authenticated(struct mod_hdcp * hdcp,struct mod_hdcp_event_context * event_ctx,struct mod_hdcp_transition_input_hdcp1 * input)253 static enum mod_hdcp_status authenticated(struct mod_hdcp *hdcp,
254 struct mod_hdcp_event_context *event_ctx,
255 struct mod_hdcp_transition_input_hdcp1 *input)
256 {
257 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
258
259 if (event_ctx->event != MOD_HDCP_EVENT_CALLBACK) {
260 event_ctx->unexpected_event = 1;
261 goto out;
262 }
263
264 if (!mod_hdcp_execute_and_set(mod_hdcp_hdcp1_link_maintenance,
265 &input->link_maintenance, &status,
266 hdcp, "link_maintenance"))
267 goto out;
268 out:
269 return status;
270 }
271
wait_for_ready(struct mod_hdcp * hdcp,struct mod_hdcp_event_context * event_ctx,struct mod_hdcp_transition_input_hdcp1 * input)272 static enum mod_hdcp_status wait_for_ready(struct mod_hdcp *hdcp,
273 struct mod_hdcp_event_context *event_ctx,
274 struct mod_hdcp_transition_input_hdcp1 *input)
275 {
276 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
277
278 if (event_ctx->event != MOD_HDCP_EVENT_CALLBACK &&
279 event_ctx->event != MOD_HDCP_EVENT_CPIRQ &&
280 event_ctx->event != MOD_HDCP_EVENT_WATCHDOG_TIMEOUT) {
281 event_ctx->unexpected_event = 1;
282 goto out;
283 }
284
285 if (is_dp_hdcp(hdcp)) {
286 if (!mod_hdcp_execute_and_set(mod_hdcp_read_bstatus,
287 &input->bstatus_read, &status,
288 hdcp, "bstatus_read"))
289 goto out;
290 if (!mod_hdcp_execute_and_set(check_link_integrity_dp,
291 &input->link_integrity_check, &status,
292 hdcp, "link_integrity_check"))
293 goto out;
294 if (!mod_hdcp_execute_and_set(check_no_reauthentication_request_dp,
295 &input->reauth_request_check, &status,
296 hdcp, "reauth_request_check"))
297 goto out;
298 } else {
299 if (!mod_hdcp_execute_and_set(mod_hdcp_read_bcaps,
300 &input->bcaps_read, &status,
301 hdcp, "bcaps_read"))
302 goto out;
303 }
304 if (!mod_hdcp_execute_and_set(check_ksv_ready,
305 &input->ready_check, &status,
306 hdcp, "ready_check"))
307 goto out;
308 out:
309 return status;
310 }
311
read_ksv_list(struct mod_hdcp * hdcp,struct mod_hdcp_event_context * event_ctx,struct mod_hdcp_transition_input_hdcp1 * input)312 static enum mod_hdcp_status read_ksv_list(struct mod_hdcp *hdcp,
313 struct mod_hdcp_event_context *event_ctx,
314 struct mod_hdcp_transition_input_hdcp1 *input)
315 {
316 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
317 uint8_t device_count;
318
319 if (event_ctx->event != MOD_HDCP_EVENT_CALLBACK) {
320 event_ctx->unexpected_event = 1;
321 goto out;
322 }
323
324 if (is_dp_hdcp(hdcp)) {
325 if (!mod_hdcp_execute_and_set(mod_hdcp_read_binfo,
326 &input->binfo_read_dp, &status,
327 hdcp, "binfo_read_dp"))
328 goto out;
329 } else {
330 if (!mod_hdcp_execute_and_set(mod_hdcp_read_bstatus,
331 &input->bstatus_read, &status,
332 hdcp, "bstatus_read"))
333 goto out;
334 }
335 if (!mod_hdcp_execute_and_set(check_no_max_cascade,
336 &input->max_cascade_check, &status,
337 hdcp, "max_cascade_check"))
338 goto out;
339 if (!mod_hdcp_execute_and_set(check_no_max_devs,
340 &input->max_devs_check, &status,
341 hdcp, "max_devs_check"))
342 goto out;
343 if (!mod_hdcp_execute_and_set(check_device_count,
344 &input->device_count_check, &status,
345 hdcp, "device_count_check"))
346 goto out;
347 device_count = get_device_count(hdcp);
348 hdcp->auth.msg.hdcp1.ksvlist_size = device_count*5;
349 if (!mod_hdcp_execute_and_set(mod_hdcp_read_ksvlist,
350 &input->ksvlist_read, &status,
351 hdcp, "ksvlist_read"))
352 goto out;
353 if (!mod_hdcp_execute_and_set(mod_hdcp_read_vp,
354 &input->vp_read, &status,
355 hdcp, "vp_read"))
356 goto out;
357 if (!mod_hdcp_execute_and_set(mod_hdcp_hdcp1_validate_ksvlist_vp,
358 &input->ksvlist_vp_validation, &status,
359 hdcp, "ksvlist_vp_validation"))
360 goto out;
361 if (input->encryption != PASS)
362 if (!mod_hdcp_execute_and_set(mod_hdcp_hdcp1_enable_encryption,
363 &input->encryption, &status,
364 hdcp, "encryption"))
365 goto out;
366 if (is_dp_mst_hdcp(hdcp))
367 if (!mod_hdcp_execute_and_set(
368 mod_hdcp_hdcp1_enable_dp_stream_encryption,
369 &input->stream_encryption_dp, &status,
370 hdcp, "stream_encryption_dp"))
371 goto out;
372 out:
373 return status;
374 }
375
determine_rx_hdcp_capable_dp(struct mod_hdcp * hdcp,struct mod_hdcp_event_context * event_ctx,struct mod_hdcp_transition_input_hdcp1 * input)376 static enum mod_hdcp_status determine_rx_hdcp_capable_dp(struct mod_hdcp *hdcp,
377 struct mod_hdcp_event_context *event_ctx,
378 struct mod_hdcp_transition_input_hdcp1 *input)
379 {
380 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
381
382 if (event_ctx->event != MOD_HDCP_EVENT_CALLBACK) {
383 event_ctx->unexpected_event = 1;
384 goto out;
385 }
386
387 if (!mod_hdcp_execute_and_set(mod_hdcp_read_bcaps,
388 &input->bcaps_read, &status,
389 hdcp, "bcaps_read"))
390 goto out;
391 if (!mod_hdcp_execute_and_set(check_hdcp_capable_dp,
392 &input->hdcp_capable_dp, &status,
393 hdcp, "hdcp_capable_dp"))
394 goto out;
395 out:
396 return status;
397 }
398
wait_for_r0_prime_dp(struct mod_hdcp * hdcp,struct mod_hdcp_event_context * event_ctx,struct mod_hdcp_transition_input_hdcp1 * input)399 static enum mod_hdcp_status wait_for_r0_prime_dp(struct mod_hdcp *hdcp,
400 struct mod_hdcp_event_context *event_ctx,
401 struct mod_hdcp_transition_input_hdcp1 *input)
402 {
403 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
404
405 if (event_ctx->event != MOD_HDCP_EVENT_CPIRQ &&
406 event_ctx->event != MOD_HDCP_EVENT_WATCHDOG_TIMEOUT) {
407 event_ctx->unexpected_event = 1;
408 goto out;
409 }
410
411 if (!mod_hdcp_execute_and_set(mod_hdcp_read_bstatus,
412 &input->bstatus_read, &status,
413 hdcp, "bstatus_read"))
414 goto out;
415 if (!mod_hdcp_execute_and_set(check_r0p_available_dp,
416 &input->r0p_available_dp, &status,
417 hdcp, "r0p_available_dp"))
418 goto out;
419 out:
420 return status;
421 }
422
authenticated_dp(struct mod_hdcp * hdcp,struct mod_hdcp_event_context * event_ctx,struct mod_hdcp_transition_input_hdcp1 * input)423 static enum mod_hdcp_status authenticated_dp(struct mod_hdcp *hdcp,
424 struct mod_hdcp_event_context *event_ctx,
425 struct mod_hdcp_transition_input_hdcp1 *input)
426 {
427 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
428
429 if (event_ctx->event != MOD_HDCP_EVENT_CPIRQ) {
430 event_ctx->unexpected_event = 1;
431 goto out;
432 }
433
434 if (!mod_hdcp_execute_and_set(mod_hdcp_read_bstatus,
435 &input->bstatus_read, &status,
436 hdcp, "bstatus_read"))
437 goto out;
438 if (!mod_hdcp_execute_and_set(check_link_integrity_dp,
439 &input->link_integrity_check, &status,
440 hdcp, "link_integrity_check"))
441 goto out;
442 if (!mod_hdcp_execute_and_set(check_no_reauthentication_request_dp,
443 &input->reauth_request_check, &status,
444 hdcp, "reauth_request_check"))
445 goto out;
446 out:
447 return status;
448 }
449
mod_hdcp_execute_and_set(mod_hdcp_action func,uint8_t * flag,enum mod_hdcp_status * status,struct mod_hdcp * hdcp,const char * str)450 uint8_t mod_hdcp_execute_and_set(
451 mod_hdcp_action func, uint8_t *flag,
452 enum mod_hdcp_status *status, struct mod_hdcp *hdcp, const char *str)
453 {
454 *status = func(hdcp);
455 if (*status == MOD_HDCP_STATUS_SUCCESS && *flag != PASS) {
456 HDCP_INPUT_PASS_TRACE(hdcp, str);
457 *flag = PASS;
458 } else if (*status != MOD_HDCP_STATUS_SUCCESS && *flag != FAIL) {
459 HDCP_INPUT_FAIL_TRACE(hdcp, str);
460 *flag = FAIL;
461 }
462 return (*status == MOD_HDCP_STATUS_SUCCESS);
463 }
464
mod_hdcp_hdcp1_execution(struct mod_hdcp * hdcp,struct mod_hdcp_event_context * event_ctx,struct mod_hdcp_transition_input_hdcp1 * input)465 enum mod_hdcp_status mod_hdcp_hdcp1_execution(struct mod_hdcp *hdcp,
466 struct mod_hdcp_event_context *event_ctx,
467 struct mod_hdcp_transition_input_hdcp1 *input)
468 {
469 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
470
471 switch (current_state(hdcp)) {
472 case H1_A0_WAIT_FOR_ACTIVE_RX:
473 status = wait_for_active_rx(hdcp, event_ctx, input);
474 break;
475 case H1_A1_EXCHANGE_KSVS:
476 status = exchange_ksvs(hdcp, event_ctx, input);
477 break;
478 case H1_A2_COMPUTATIONS_A3_VALIDATE_RX_A6_TEST_FOR_REPEATER:
479 status = computations_validate_rx_test_for_repeater(hdcp,
480 event_ctx, input);
481 break;
482 case H1_A45_AUTHENTICATED:
483 status = authenticated(hdcp, event_ctx, input);
484 break;
485 case H1_A8_WAIT_FOR_READY:
486 status = wait_for_ready(hdcp, event_ctx, input);
487 break;
488 case H1_A9_READ_KSV_LIST:
489 status = read_ksv_list(hdcp, event_ctx, input);
490 break;
491 default:
492 status = MOD_HDCP_STATUS_INVALID_STATE;
493 break;
494 }
495
496 return status;
497 }
498
mod_hdcp_hdcp1_dp_execution(struct mod_hdcp * hdcp,struct mod_hdcp_event_context * event_ctx,struct mod_hdcp_transition_input_hdcp1 * input)499 extern enum mod_hdcp_status mod_hdcp_hdcp1_dp_execution(struct mod_hdcp *hdcp,
500 struct mod_hdcp_event_context *event_ctx,
501 struct mod_hdcp_transition_input_hdcp1 *input)
502 {
503 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
504
505 switch (current_state(hdcp)) {
506 case D1_A0_DETERMINE_RX_HDCP_CAPABLE:
507 status = determine_rx_hdcp_capable_dp(hdcp, event_ctx, input);
508 break;
509 case D1_A1_EXCHANGE_KSVS:
510 status = exchange_ksvs(hdcp, event_ctx, input);
511 break;
512 case D1_A23_WAIT_FOR_R0_PRIME:
513 status = wait_for_r0_prime_dp(hdcp, event_ctx, input);
514 break;
515 case D1_A2_COMPUTATIONS_A3_VALIDATE_RX_A5_TEST_FOR_REPEATER:
516 status = computations_validate_rx_test_for_repeater(
517 hdcp, event_ctx, input);
518 break;
519 case D1_A4_AUTHENTICATED:
520 status = authenticated_dp(hdcp, event_ctx, input);
521 break;
522 case D1_A6_WAIT_FOR_READY:
523 status = wait_for_ready(hdcp, event_ctx, input);
524 break;
525 case D1_A7_READ_KSV_LIST:
526 status = read_ksv_list(hdcp, event_ctx, input);
527 break;
528 default:
529 status = MOD_HDCP_STATUS_INVALID_STATE;
530 break;
531 }
532
533 return status;
534 }
535