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#include "hdcp.h"
27
28enum mod_hdcp_status mod_hdcp_hdcp2_transition(struct mod_hdcp *hdcp,
29		struct mod_hdcp_event_context *event_ctx,
30		struct mod_hdcp_transition_input_hdcp2 *input,
31		struct mod_hdcp_output *output)
32{
33	enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
34	struct mod_hdcp_connection *conn = &hdcp->connection;
35	struct mod_hdcp_link_adjustment *adjust = &hdcp->connection.link.adjust;
36
37	switch (current_state(hdcp)) {
38	case H2_A0_KNOWN_HDCP2_CAPABLE_RX:
39		if (input->hdcp2version_read != PASS ||
40				input->hdcp2_capable_check != PASS) {
41			adjust->hdcp2.disable = 1;
42			callback_in_ms(0, output);
43			set_state_id(hdcp, output, HDCP_INITIALIZED);
44		} else {
45			callback_in_ms(0, output);
46			set_state_id(hdcp, output, H2_A1_SEND_AKE_INIT);
47		}
48		break;
49	case H2_A1_SEND_AKE_INIT:
50		if (input->create_session != PASS ||
51				input->ake_init_prepare != PASS) {
52			/* out of sync with psp state */
53			adjust->hdcp2.disable = 1;
54			fail_and_restart_in_ms(0, &status, output);
55			break;
56		} else if (input->ake_init_write != PASS) {
57			fail_and_restart_in_ms(0, &status, output);
58			break;
59		}
60		set_watchdog_in_ms(hdcp, 100, output);
61		callback_in_ms(0, output);
62		set_state_id(hdcp, output, H2_A1_VALIDATE_AKE_CERT);
63		break;
64	case H2_A1_VALIDATE_AKE_CERT:
65		if (input->ake_cert_available != PASS) {
66			if (event_ctx->event ==
67					MOD_HDCP_EVENT_WATCHDOG_TIMEOUT) {
68				/* 1A-08: consider ake timeout a failure */
69				/* some hdmi receivers are not ready for HDCP
70				 * immediately after video becomes active,
71				 * delay 1s before retry on first HDCP message
72				 * timeout.
73				 */
74				fail_and_restart_in_ms(1000, &status, output);
75			} else {
76				/* continue ake cert polling*/
77				callback_in_ms(10, output);
78				increment_stay_counter(hdcp);
79			}
80			break;
81		} else if (input->ake_cert_read != PASS ||
82				input->ake_cert_validation != PASS) {
83			/*
84			 * 1A-09: consider invalid ake cert a failure
85			 * 1A-10: consider receiver id listed in SRM a failure
86			 */
87			fail_and_restart_in_ms(0, &status, output);
88			break;
89		}
90		if (conn->is_km_stored &&
91				!adjust->hdcp2.force_no_stored_km) {
92			callback_in_ms(0, output);
93			set_state_id(hdcp, output, H2_A1_SEND_STORED_KM);
94		} else {
95			callback_in_ms(0, output);
96			set_state_id(hdcp, output, H2_A1_SEND_NO_STORED_KM);
97		}
98		break;
99	case H2_A1_SEND_NO_STORED_KM:
100		if (input->no_stored_km_write != PASS) {
101			fail_and_restart_in_ms(0, &status, output);
102			break;
103		}
104		if (adjust->hdcp2.increase_h_prime_timeout)
105			set_watchdog_in_ms(hdcp, 2000, output);
106		else
107			set_watchdog_in_ms(hdcp, 1000, output);
108		callback_in_ms(0, output);
109		set_state_id(hdcp, output, H2_A1_READ_H_PRIME);
110		break;
111	case H2_A1_READ_H_PRIME:
112		if (input->h_prime_available != PASS) {
113			if (event_ctx->event ==
114					MOD_HDCP_EVENT_WATCHDOG_TIMEOUT) {
115				/* 1A-11-3: consider h' timeout a failure */
116				fail_and_restart_in_ms(1000, &status, output);
117			} else {
118				/* continue h' polling */
119				callback_in_ms(100, output);
120				increment_stay_counter(hdcp);
121			}
122			break;
123		} else if (input->h_prime_read != PASS) {
124			fail_and_restart_in_ms(0, &status, output);
125			break;
126		}
127		set_watchdog_in_ms(hdcp, 200, output);
128		callback_in_ms(0, output);
129		set_state_id(hdcp, output, H2_A1_READ_PAIRING_INFO_AND_VALIDATE_H_PRIME);
130		break;
131	case H2_A1_READ_PAIRING_INFO_AND_VALIDATE_H_PRIME:
132		if (input->pairing_available != PASS) {
133			if (event_ctx->event ==
134					MOD_HDCP_EVENT_WATCHDOG_TIMEOUT) {
135				/* 1A-12: consider pairing info timeout
136				 * a failure
137				 */
138				fail_and_restart_in_ms(0, &status, output);
139			} else {
140				/* continue pairing info polling */
141				callback_in_ms(20, output);
142				increment_stay_counter(hdcp);
143			}
144			break;
145		} else if (input->pairing_info_read != PASS ||
146				input->h_prime_validation != PASS) {
147			/* 1A-11-1: consider invalid h' a failure */
148			fail_and_restart_in_ms(0, &status, output);
149			break;
150		}
151		callback_in_ms(0, output);
152		set_state_id(hdcp, output, H2_A2_LOCALITY_CHECK);
153		break;
154	case H2_A1_SEND_STORED_KM:
155		if (input->stored_km_write != PASS) {
156			fail_and_restart_in_ms(0, &status, output);
157			break;
158		}
159		set_watchdog_in_ms(hdcp, 200, output);
160		callback_in_ms(0, output);
161		set_state_id(hdcp, output, H2_A1_VALIDATE_H_PRIME);
162		break;
163	case H2_A1_VALIDATE_H_PRIME:
164		if (input->h_prime_available != PASS) {
165			if (event_ctx->event ==
166					MOD_HDCP_EVENT_WATCHDOG_TIMEOUT) {
167				/* 1A-11-2: consider h' timeout a failure */
168				fail_and_restart_in_ms(1000, &status, output);
169			} else {
170				/* continue h' polling */
171				callback_in_ms(20, output);
172				increment_stay_counter(hdcp);
173			}
174			break;
175		} else if (input->h_prime_read != PASS) {
176			fail_and_restart_in_ms(0, &status, output);
177			break;
178		} else if (input->h_prime_validation != PASS) {
179			/* 1A-11-1: consider invalid h' a failure */
180			adjust->hdcp2.force_no_stored_km = 1;
181			fail_and_restart_in_ms(0, &status, output);
182			break;
183		}
184		callback_in_ms(0, output);
185		set_state_id(hdcp, output, H2_A2_LOCALITY_CHECK);
186		break;
187	case H2_A2_LOCALITY_CHECK:
188		if (hdcp->state.stay_count > 10 ||
189				input->lc_init_prepare != PASS ||
190				input->lc_init_write != PASS ||
191				input->l_prime_available_poll != PASS ||
192				input->l_prime_read != PASS) {
193			/*
194			 * 1A-05: consider disconnection after LC init a failure
195			 * 1A-13-1: consider invalid l' a failure
196			 * 1A-13-2: consider l' timeout a failure
197			 */
198			fail_and_restart_in_ms(0, &status, output);
199			break;
200		} else if (input->l_prime_validation != PASS) {
201			callback_in_ms(0, output);
202			increment_stay_counter(hdcp);
203			break;
204		}
205		callback_in_ms(0, output);
206		set_state_id(hdcp, output, H2_A3_EXCHANGE_KS_AND_TEST_FOR_REPEATER);
207		break;
208	case H2_A3_EXCHANGE_KS_AND_TEST_FOR_REPEATER:
209		if (input->eks_prepare != PASS ||
210				input->eks_write != PASS) {
211			fail_and_restart_in_ms(0, &status, output);
212			break;
213		}
214		if (conn->is_repeater) {
215			set_watchdog_in_ms(hdcp, 3000, output);
216			callback_in_ms(0, output);
217			set_state_id(hdcp, output, H2_A6_WAIT_FOR_RX_ID_LIST);
218		} else {
219			/* some CTS equipment requires a delay GREATER than
220			 * 200 ms, so delay 210 ms instead of 200 ms
221			 */
222			callback_in_ms(210, output);
223			set_state_id(hdcp, output, H2_ENABLE_ENCRYPTION);
224		}
225		break;
226	case H2_ENABLE_ENCRYPTION:
227		if (input->rxstatus_read != PASS ||
228				input->reauth_request_check != PASS) {
229			/*
230			 * 1A-07: restart hdcp on REAUTH_REQ
231			 * 1B-08: restart hdcp on REAUTH_REQ
232			 */
233			fail_and_restart_in_ms(0, &status, output);
234			break;
235		} else if (event_ctx->rx_id_list_ready && conn->is_repeater) {
236			callback_in_ms(0, output);
237			set_state_id(hdcp, output, H2_A78_VERIFY_RX_ID_LIST_AND_SEND_ACK);
238			break;
239		} else if (input->enable_encryption != PASS) {
240			fail_and_restart_in_ms(0, &status, output);
241			break;
242		}
243		callback_in_ms(0, output);
244		set_state_id(hdcp, output, H2_A5_AUTHENTICATED);
245		set_auth_complete(hdcp, output);
246		break;
247	case H2_A5_AUTHENTICATED:
248		if (input->rxstatus_read == FAIL ||
249				input->reauth_request_check == FAIL) {
250			fail_and_restart_in_ms(0, &status, output);
251			break;
252		} else if (event_ctx->rx_id_list_ready && conn->is_repeater) {
253			callback_in_ms(0, output);
254			set_state_id(hdcp, output, H2_A78_VERIFY_RX_ID_LIST_AND_SEND_ACK);
255			break;
256		}
257		callback_in_ms(500, output);
258		increment_stay_counter(hdcp);
259		break;
260	case H2_A6_WAIT_FOR_RX_ID_LIST:
261		if (input->rxstatus_read != PASS ||
262				input->reauth_request_check != PASS) {
263			fail_and_restart_in_ms(0, &status, output);
264			break;
265		} else if (!event_ctx->rx_id_list_ready) {
266			if (event_ctx->event == MOD_HDCP_EVENT_WATCHDOG_TIMEOUT) {
267				/* 1B-02: consider rx id list timeout a failure */
268				/* some CTS equipment's actual timeout
269				 * measurement is slightly greater than 3000 ms.
270				 * Delay 100 ms to ensure it is fully timeout
271				 * before re-authentication.
272				 */
273				fail_and_restart_in_ms(100, &status, output);
274			} else {
275				callback_in_ms(300, output);
276				increment_stay_counter(hdcp);
277			}
278			break;
279		}
280		callback_in_ms(0, output);
281		set_state_id(hdcp, output, H2_A78_VERIFY_RX_ID_LIST_AND_SEND_ACK);
282		break;
283	case H2_A78_VERIFY_RX_ID_LIST_AND_SEND_ACK:
284		if (input->rxstatus_read != PASS ||
285				input->reauth_request_check != PASS ||
286				input->rx_id_list_read != PASS ||
287				input->device_count_check != PASS ||
288				input->rx_id_list_validation != PASS ||
289				input->repeater_auth_ack_write != PASS) {
290			/* 1B-03: consider invalid v' a failure
291			 * 1B-04: consider MAX_DEVS_EXCEEDED a failure
292			 * 1B-05: consider MAX_CASCADE_EXCEEDED a failure
293			 * 1B-06: consider invalid seq_num_V a failure
294			 * 1B-09: consider seq_num_V rollover a failure
295			 */
296			fail_and_restart_in_ms(0, &status, output);
297			break;
298		}
299		callback_in_ms(0, output);
300		set_state_id(hdcp, output, H2_A9_SEND_STREAM_MANAGEMENT);
301		break;
302	case H2_A9_SEND_STREAM_MANAGEMENT:
303		if (input->rxstatus_read != PASS ||
304				input->reauth_request_check != PASS) {
305			fail_and_restart_in_ms(0, &status, output);
306			break;
307		} else if (event_ctx->rx_id_list_ready && conn->is_repeater) {
308			callback_in_ms(0, output);
309			set_state_id(hdcp, output, H2_A78_VERIFY_RX_ID_LIST_AND_SEND_ACK);
310			break;
311		} else if (input->prepare_stream_manage != PASS ||
312				input->stream_manage_write != PASS) {
313			fail_and_restart_in_ms(0, &status, output);
314			break;
315		}
316		set_watchdog_in_ms(hdcp, 100, output);
317		callback_in_ms(0, output);
318		set_state_id(hdcp, output, H2_A9_VALIDATE_STREAM_READY);
319		break;
320	case H2_A9_VALIDATE_STREAM_READY:
321		if (input->rxstatus_read != PASS ||
322				input->reauth_request_check != PASS) {
323			fail_and_restart_in_ms(0, &status, output);
324			break;
325		} else if (event_ctx->rx_id_list_ready && conn->is_repeater) {
326			callback_in_ms(0, output);
327			set_state_id(hdcp, output, H2_A78_VERIFY_RX_ID_LIST_AND_SEND_ACK);
328			break;
329		} else if (input->stream_ready_available != PASS) {
330			if (event_ctx->event == MOD_HDCP_EVENT_WATCHDOG_TIMEOUT) {
331				/* 1B-10-2: restart content stream management on
332				 * stream ready timeout
333				 */
334				hdcp->auth.count.stream_management_retry_count++;
335				callback_in_ms(0, output);
336				set_state_id(hdcp, output, H2_A9_SEND_STREAM_MANAGEMENT);
337			} else {
338				callback_in_ms(10, output);
339				increment_stay_counter(hdcp);
340			}
341			break;
342		} else if (input->stream_ready_read != PASS ||
343				input->stream_ready_validation != PASS) {
344			/*
345			 * 1B-10-1: restart content stream management
346			 * on invalid M'
347			 */
348			if (hdcp->auth.count.stream_management_retry_count > 10) {
349				fail_and_restart_in_ms(0, &status, output);
350			} else {
351				hdcp->auth.count.stream_management_retry_count++;
352				callback_in_ms(0, output);
353				set_state_id(hdcp, output, H2_A9_SEND_STREAM_MANAGEMENT);
354			}
355			break;
356		}
357		callback_in_ms(200, output);
358		set_state_id(hdcp, output, H2_ENABLE_ENCRYPTION);
359		break;
360	default:
361		status = MOD_HDCP_STATUS_INVALID_STATE;
362		fail_and_restart_in_ms(0, &status, output);
363		break;
364	}
365
366	return status;
367}
368
369enum mod_hdcp_status mod_hdcp_hdcp2_dp_transition(struct mod_hdcp *hdcp,
370		struct mod_hdcp_event_context *event_ctx,
371		struct mod_hdcp_transition_input_hdcp2 *input,
372		struct mod_hdcp_output *output)
373{
374	enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
375	struct mod_hdcp_connection *conn = &hdcp->connection;
376	struct mod_hdcp_link_adjustment *adjust = &hdcp->connection.link.adjust;
377
378	switch (current_state(hdcp)) {
379	case D2_A0_DETERMINE_RX_HDCP_CAPABLE:
380		if (input->rx_caps_read_dp != PASS ||
381				input->hdcp2_capable_check != PASS) {
382			adjust->hdcp2.disable = 1;
383			callback_in_ms(0, output);
384			set_state_id(hdcp, output, HDCP_INITIALIZED);
385		} else {
386			callback_in_ms(0, output);
387			set_state_id(hdcp, output, D2_A1_SEND_AKE_INIT);
388		}
389		break;
390	case D2_A1_SEND_AKE_INIT:
391		if (input->create_session != PASS ||
392				input->ake_init_prepare != PASS) {
393			/* out of sync with psp state */
394			adjust->hdcp2.disable = 1;
395			fail_and_restart_in_ms(0, &status, output);
396			break;
397		} else if (input->ake_init_write != PASS) {
398			/* possibly display not ready */
399			fail_and_restart_in_ms(0, &status, output);
400			break;
401		}
402		callback_in_ms(100, output);
403		set_state_id(hdcp, output, D2_A1_VALIDATE_AKE_CERT);
404		break;
405	case D2_A1_VALIDATE_AKE_CERT:
406		if (input->ake_cert_read != PASS ||
407				input->ake_cert_validation != PASS) {
408			/*
409			 * 1A-08: consider invalid ake cert a failure
410			 * 1A-09: consider receiver id listed in SRM a failure
411			 */
412			fail_and_restart_in_ms(0, &status, output);
413			break;
414		}
415		if (conn->is_km_stored &&
416				!adjust->hdcp2.force_no_stored_km) {
417			callback_in_ms(0, output);
418			set_state_id(hdcp, output, D2_A1_SEND_STORED_KM);
419		} else {
420			callback_in_ms(0, output);
421			set_state_id(hdcp, output, D2_A1_SEND_NO_STORED_KM);
422		}
423		break;
424	case D2_A1_SEND_NO_STORED_KM:
425		if (input->no_stored_km_write != PASS) {
426			fail_and_restart_in_ms(0, &status, output);
427			break;
428		}
429		if (adjust->hdcp2.increase_h_prime_timeout)
430			set_watchdog_in_ms(hdcp, 2000, output);
431		else
432			set_watchdog_in_ms(hdcp, 1000, output);
433		set_state_id(hdcp, output, D2_A1_READ_H_PRIME);
434		break;
435	case D2_A1_READ_H_PRIME:
436		if (input->h_prime_available != PASS) {
437			if (event_ctx->event ==
438					MOD_HDCP_EVENT_WATCHDOG_TIMEOUT)
439				/* 1A-10-3: consider h' timeout a failure */
440				fail_and_restart_in_ms(1000, &status, output);
441			else
442				increment_stay_counter(hdcp);
443			break;
444		} else if (input->h_prime_read != PASS) {
445			fail_and_restart_in_ms(0, &status, output);
446			break;
447		}
448		set_watchdog_in_ms(hdcp, 200, output);
449		set_state_id(hdcp, output, D2_A1_READ_PAIRING_INFO_AND_VALIDATE_H_PRIME);
450		break;
451	case D2_A1_READ_PAIRING_INFO_AND_VALIDATE_H_PRIME:
452		if (input->pairing_available != PASS) {
453			if (event_ctx->event ==
454					MOD_HDCP_EVENT_WATCHDOG_TIMEOUT)
455				/*
456				 * 1A-11: consider pairing info timeout
457				 * a failure
458				 */
459				fail_and_restart_in_ms(0, &status, output);
460			else
461				increment_stay_counter(hdcp);
462			break;
463		} else if (input->pairing_info_read != PASS ||
464				input->h_prime_validation != PASS) {
465			/* 1A-10-1: consider invalid h' a failure */
466			fail_and_restart_in_ms(0, &status, output);
467			break;
468		}
469		callback_in_ms(0, output);
470		set_state_id(hdcp, output, D2_A2_LOCALITY_CHECK);
471		break;
472	case D2_A1_SEND_STORED_KM:
473		if (input->stored_km_write != PASS) {
474			fail_and_restart_in_ms(0, &status, output);
475			break;
476		}
477		set_watchdog_in_ms(hdcp, 200, output);
478		set_state_id(hdcp, output, D2_A1_VALIDATE_H_PRIME);
479		break;
480	case D2_A1_VALIDATE_H_PRIME:
481		if (input->h_prime_available != PASS) {
482			if (event_ctx->event ==
483					MOD_HDCP_EVENT_WATCHDOG_TIMEOUT)
484				/* 1A-10-2: consider h' timeout a failure */
485				fail_and_restart_in_ms(1000, &status, output);
486			else
487				increment_stay_counter(hdcp);
488			break;
489		} else if (input->h_prime_read != PASS) {
490			fail_and_restart_in_ms(0, &status, output);
491			break;
492		} else if (input->h_prime_validation != PASS) {
493			/* 1A-10-1: consider invalid h' a failure */
494			adjust->hdcp2.force_no_stored_km = 1;
495			fail_and_restart_in_ms(0, &status, output);
496			break;
497		}
498		callback_in_ms(0, output);
499		set_state_id(hdcp, output, D2_A2_LOCALITY_CHECK);
500		break;
501	case D2_A2_LOCALITY_CHECK:
502		if (hdcp->state.stay_count > 10 ||
503				input->lc_init_prepare != PASS ||
504				input->lc_init_write != PASS ||
505				input->l_prime_read != PASS) {
506			/* 1A-12: consider invalid l' a failure */
507			fail_and_restart_in_ms(0, &status, output);
508			break;
509		} else if (input->l_prime_validation != PASS) {
510			callback_in_ms(0, output);
511			increment_stay_counter(hdcp);
512			break;
513		}
514		callback_in_ms(0, output);
515		set_state_id(hdcp, output, D2_A34_EXCHANGE_KS_AND_TEST_FOR_REPEATER);
516		break;
517	case D2_A34_EXCHANGE_KS_AND_TEST_FOR_REPEATER:
518		if (input->eks_prepare != PASS ||
519				input->eks_write != PASS) {
520			fail_and_restart_in_ms(0, &status, output);
521			break;
522		}
523		if (conn->is_repeater) {
524			set_watchdog_in_ms(hdcp, 3000, output);
525			set_state_id(hdcp, output, D2_A6_WAIT_FOR_RX_ID_LIST);
526		} else {
527			callback_in_ms(0, output);
528			set_state_id(hdcp, output, D2_SEND_CONTENT_STREAM_TYPE);
529		}
530		break;
531	case D2_SEND_CONTENT_STREAM_TYPE:
532		if (input->rxstatus_read != PASS ||
533				input->reauth_request_check != PASS ||
534				input->link_integrity_check_dp != PASS ||
535				input->content_stream_type_write != PASS) {
536			fail_and_restart_in_ms(0, &status, output);
537			break;
538		}
539		callback_in_ms(210, output);
540		set_state_id(hdcp, output, D2_ENABLE_ENCRYPTION);
541		break;
542	case D2_ENABLE_ENCRYPTION:
543		if (input->rxstatus_read != PASS ||
544				input->reauth_request_check != PASS ||
545				input->link_integrity_check_dp != PASS) {
546			/*
547			 * 1A-07: restart hdcp on REAUTH_REQ
548			 * 1B-08: restart hdcp on REAUTH_REQ
549			 */
550			fail_and_restart_in_ms(0, &status, output);
551			break;
552		} else if (event_ctx->rx_id_list_ready && conn->is_repeater) {
553			callback_in_ms(0, output);
554			set_state_id(hdcp, output, D2_A78_VERIFY_RX_ID_LIST_AND_SEND_ACK);
555			break;
556		} else if (input->enable_encryption != PASS ||
557				(is_dp_mst_hdcp(hdcp) && input->stream_encryption_dp != PASS)) {
558			fail_and_restart_in_ms(0, &status, output);
559			break;
560		}
561		set_state_id(hdcp, output, D2_A5_AUTHENTICATED);
562		set_auth_complete(hdcp, output);
563		break;
564	case D2_A5_AUTHENTICATED:
565		if (input->rxstatus_read == FAIL ||
566				input->reauth_request_check == FAIL) {
567			fail_and_restart_in_ms(100, &status, output);
568			break;
569		} else if (input->link_integrity_check_dp == FAIL) {
570			if (hdcp->connection.hdcp2_retry_count >= 1)
571				adjust->hdcp2.force_type = MOD_HDCP_FORCE_TYPE_0;
572			fail_and_restart_in_ms(0, &status, output);
573			break;
574		} else if (event_ctx->rx_id_list_ready && conn->is_repeater) {
575			callback_in_ms(0, output);
576			set_state_id(hdcp, output, D2_A78_VERIFY_RX_ID_LIST_AND_SEND_ACK);
577			break;
578		}
579		increment_stay_counter(hdcp);
580		break;
581	case D2_A6_WAIT_FOR_RX_ID_LIST:
582		if (input->rxstatus_read != PASS ||
583				input->reauth_request_check != PASS ||
584				input->link_integrity_check_dp != PASS) {
585			fail_and_restart_in_ms(0, &status, output);
586			break;
587		} else if (!event_ctx->rx_id_list_ready) {
588			if (event_ctx->event == MOD_HDCP_EVENT_WATCHDOG_TIMEOUT)
589				/* 1B-02: consider rx id list timeout a failure */
590				fail_and_restart_in_ms(0, &status, output);
591			else
592				increment_stay_counter(hdcp);
593			break;
594		}
595		callback_in_ms(0, output);
596		set_state_id(hdcp, output, D2_A78_VERIFY_RX_ID_LIST_AND_SEND_ACK);
597		break;
598	case D2_A78_VERIFY_RX_ID_LIST_AND_SEND_ACK:
599		if (input->rxstatus_read != PASS ||
600				input->reauth_request_check != PASS ||
601				input->link_integrity_check_dp != PASS ||
602				input->rx_id_list_read != PASS ||
603				input->device_count_check != PASS ||
604				input->rx_id_list_validation != PASS ||
605				input->repeater_auth_ack_write != PASS) {
606			/*
607			 * 1B-03: consider invalid v' a failure
608			 * 1B-04: consider MAX_DEVS_EXCEEDED a failure
609			 * 1B-05: consider MAX_CASCADE_EXCEEDED a failure
610			 * 1B-06: consider invalid seq_num_V a failure
611			 * 1B-09: consider seq_num_V rollover a failure
612			 */
613			fail_and_restart_in_ms(0, &status, output);
614			break;
615		}
616		callback_in_ms(0, output);
617		set_state_id(hdcp, output, D2_A9_SEND_STREAM_MANAGEMENT);
618		break;
619	case D2_A9_SEND_STREAM_MANAGEMENT:
620		if (input->rxstatus_read != PASS ||
621				input->reauth_request_check != PASS ||
622				input->link_integrity_check_dp != PASS) {
623			fail_and_restart_in_ms(0, &status, output);
624			break;
625		} else if (event_ctx->rx_id_list_ready) {
626			callback_in_ms(0, output);
627			set_state_id(hdcp, output, D2_A78_VERIFY_RX_ID_LIST_AND_SEND_ACK);
628			break;
629		} else if (input->prepare_stream_manage != PASS ||
630				input->stream_manage_write != PASS) {
631			if (event_ctx->event == MOD_HDCP_EVENT_CALLBACK)
632				fail_and_restart_in_ms(0, &status, output);
633			else
634				increment_stay_counter(hdcp);
635			break;
636		}
637		callback_in_ms(100, output);
638		set_state_id(hdcp, output, D2_A9_VALIDATE_STREAM_READY);
639		break;
640	case D2_A9_VALIDATE_STREAM_READY:
641		if (input->rxstatus_read != PASS ||
642				input->reauth_request_check != PASS ||
643				input->link_integrity_check_dp != PASS) {
644			fail_and_restart_in_ms(0, &status, output);
645			break;
646		} else if (event_ctx->rx_id_list_ready) {
647			callback_in_ms(0, output);
648			set_state_id(hdcp, output, D2_A78_VERIFY_RX_ID_LIST_AND_SEND_ACK);
649			break;
650		} else if (input->stream_ready_read != PASS ||
651				input->stream_ready_validation != PASS) {
652			/*
653			 * 1B-10-1: restart content stream management
654			 * on invalid M'
655			 * 1B-10-2: consider stream ready timeout a failure
656			 */
657			if (hdcp->auth.count.stream_management_retry_count > 10) {
658				fail_and_restart_in_ms(0, &status, output);
659			} else if (event_ctx->event == MOD_HDCP_EVENT_CALLBACK) {
660				hdcp->auth.count.stream_management_retry_count++;
661				callback_in_ms(0, output);
662				set_state_id(hdcp, output, D2_A9_SEND_STREAM_MANAGEMENT);
663			} else {
664				increment_stay_counter(hdcp);
665			}
666			break;
667		}
668		callback_in_ms(200, output);
669		set_state_id(hdcp, output, D2_ENABLE_ENCRYPTION);
670		break;
671	default:
672		status = MOD_HDCP_STATUS_INVALID_STATE;
673		fail_and_restart_in_ms(0, &status, output);
674		break;
675	}
676	return status;
677}
678