323 lines
10 KiB
C
323 lines
10 KiB
C
/*
|
|
* Copyright 2019 Advanced Micro Devices, Inc.
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
* copy of this software and associated documentation files (the "Software"),
|
|
* to deal in the Software without restriction, including without limitation
|
|
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
* and/or sell copies of the Software, and to permit persons to whom the
|
|
* Software is furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in
|
|
* all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
* THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
|
|
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
|
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|
* OTHER DEALINGS IN THE SOFTWARE.
|
|
*
|
|
* Authors: AMD
|
|
*
|
|
*/
|
|
|
|
#include "hdcp.h"
|
|
|
|
enum mod_hdcp_status mod_hdcp_hdcp1_transition(struct mod_hdcp *hdcp,
|
|
struct mod_hdcp_event_context *event_ctx,
|
|
struct mod_hdcp_transition_input_hdcp1 *input,
|
|
struct mod_hdcp_output *output)
|
|
{
|
|
enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
|
|
struct mod_hdcp_connection *conn = &hdcp->connection;
|
|
struct mod_hdcp_link_adjustment *adjust = &hdcp->connection.link.adjust;
|
|
|
|
switch (current_state(hdcp)) {
|
|
case H1_A0_WAIT_FOR_ACTIVE_RX:
|
|
if (input->bksv_read != PASS || input->bcaps_read != PASS) {
|
|
/* 1A-04: repeatedly attempts on port access failure */
|
|
callback_in_ms(500, output);
|
|
increment_stay_counter(hdcp);
|
|
break;
|
|
}
|
|
callback_in_ms(0, output);
|
|
set_state_id(hdcp, output, H1_A1_EXCHANGE_KSVS);
|
|
break;
|
|
case H1_A1_EXCHANGE_KSVS:
|
|
if (input->create_session != PASS) {
|
|
/* out of sync with psp state */
|
|
adjust->hdcp1.disable = 1;
|
|
fail_and_restart_in_ms(0, &status, output);
|
|
break;
|
|
} else if (input->an_write != PASS ||
|
|
input->aksv_write != PASS ||
|
|
input->bksv_read != PASS ||
|
|
input->bksv_validation != PASS ||
|
|
input->ainfo_write == FAIL) {
|
|
/* 1A-05: consider invalid bksv a failure */
|
|
fail_and_restart_in_ms(0, &status, output);
|
|
break;
|
|
}
|
|
callback_in_ms(300, output);
|
|
set_state_id(hdcp, output,
|
|
H1_A2_COMPUTATIONS_A3_VALIDATE_RX_A6_TEST_FOR_REPEATER);
|
|
break;
|
|
case H1_A2_COMPUTATIONS_A3_VALIDATE_RX_A6_TEST_FOR_REPEATER:
|
|
if (input->bcaps_read != PASS ||
|
|
input->r0p_read != PASS) {
|
|
fail_and_restart_in_ms(0, &status, output);
|
|
break;
|
|
} else if (input->rx_validation != PASS) {
|
|
/* 1A-06: consider invalid r0' a failure */
|
|
/* 1A-08: consider bksv listed in SRM a failure */
|
|
/*
|
|
* some slow RX will fail rx validation when it is
|
|
* not ready. give it more time to react before retry.
|
|
*/
|
|
fail_and_restart_in_ms(1000, &status, output);
|
|
break;
|
|
} else if (!conn->is_repeater && input->encryption != PASS) {
|
|
fail_and_restart_in_ms(0, &status, output);
|
|
break;
|
|
}
|
|
if (conn->is_repeater) {
|
|
callback_in_ms(0, output);
|
|
set_watchdog_in_ms(hdcp, 5000, output);
|
|
set_state_id(hdcp, output, H1_A8_WAIT_FOR_READY);
|
|
} else {
|
|
callback_in_ms(0, output);
|
|
set_state_id(hdcp, output, H1_A45_AUTHENTICATED);
|
|
set_auth_complete(hdcp, output);
|
|
}
|
|
break;
|
|
case H1_A45_AUTHENTICATED:
|
|
if (input->link_maintenance == FAIL) {
|
|
/* 1A-07: consider invalid ri' a failure */
|
|
/* 1A-07a: consider read ri' not returned a failure */
|
|
fail_and_restart_in_ms(0, &status, output);
|
|
break;
|
|
}
|
|
callback_in_ms(500, output);
|
|
increment_stay_counter(hdcp);
|
|
break;
|
|
case H1_A8_WAIT_FOR_READY:
|
|
if (input->ready_check != PASS) {
|
|
if (event_ctx->event ==
|
|
MOD_HDCP_EVENT_WATCHDOG_TIMEOUT) {
|
|
/* 1B-03: fail hdcp on ksv list READY timeout */
|
|
/* prevent black screen in next attempt */
|
|
adjust->hdcp1.postpone_encryption = 1;
|
|
fail_and_restart_in_ms(0, &status, output);
|
|
} else {
|
|
/* continue ksv list READY polling*/
|
|
callback_in_ms(500, output);
|
|
increment_stay_counter(hdcp);
|
|
}
|
|
break;
|
|
}
|
|
callback_in_ms(0, output);
|
|
set_state_id(hdcp, output, H1_A9_READ_KSV_LIST);
|
|
break;
|
|
case H1_A9_READ_KSV_LIST:
|
|
if (input->bstatus_read != PASS ||
|
|
input->max_cascade_check != PASS ||
|
|
input->max_devs_check != PASS ||
|
|
input->device_count_check != PASS ||
|
|
input->ksvlist_read != PASS ||
|
|
input->vp_read != PASS ||
|
|
input->ksvlist_vp_validation != PASS ||
|
|
input->encryption != PASS) {
|
|
/* 1B-06: consider MAX_CASCADE_EXCEEDED a failure */
|
|
/* 1B-05: consider MAX_DEVS_EXCEEDED a failure */
|
|
/* 1B-04: consider invalid v' a failure */
|
|
fail_and_restart_in_ms(0, &status, output);
|
|
break;
|
|
}
|
|
callback_in_ms(0, output);
|
|
set_state_id(hdcp, output, H1_A45_AUTHENTICATED);
|
|
set_auth_complete(hdcp, output);
|
|
break;
|
|
default:
|
|
status = MOD_HDCP_STATUS_INVALID_STATE;
|
|
fail_and_restart_in_ms(0, &status, output);
|
|
break;
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
enum mod_hdcp_status mod_hdcp_hdcp1_dp_transition(struct mod_hdcp *hdcp,
|
|
struct mod_hdcp_event_context *event_ctx,
|
|
struct mod_hdcp_transition_input_hdcp1 *input,
|
|
struct mod_hdcp_output *output)
|
|
{
|
|
enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
|
|
struct mod_hdcp_connection *conn = &hdcp->connection;
|
|
struct mod_hdcp_link_adjustment *adjust = &hdcp->connection.link.adjust;
|
|
|
|
switch (current_state(hdcp)) {
|
|
case D1_A0_DETERMINE_RX_HDCP_CAPABLE:
|
|
if (input->bcaps_read != PASS) {
|
|
/* 1A-04: no authentication on bcaps read failure */
|
|
fail_and_restart_in_ms(0, &status, output);
|
|
break;
|
|
} else if (input->hdcp_capable_dp != PASS) {
|
|
adjust->hdcp1.disable = 1;
|
|
fail_and_restart_in_ms(0, &status, output);
|
|
break;
|
|
}
|
|
callback_in_ms(0, output);
|
|
set_state_id(hdcp, output, D1_A1_EXCHANGE_KSVS);
|
|
break;
|
|
case D1_A1_EXCHANGE_KSVS:
|
|
if (input->create_session != PASS) {
|
|
/* out of sync with psp state */
|
|
adjust->hdcp1.disable = 1;
|
|
fail_and_restart_in_ms(0, &status, output);
|
|
break;
|
|
} else if (input->an_write != PASS ||
|
|
input->aksv_write != PASS ||
|
|
input->bksv_read != PASS ||
|
|
input->bksv_validation != PASS ||
|
|
input->ainfo_write == FAIL) {
|
|
/* 1A-05: consider invalid bksv a failure */
|
|
fail_and_restart_in_ms(0, &status, output);
|
|
break;
|
|
}
|
|
set_watchdog_in_ms(hdcp, 100, output);
|
|
set_state_id(hdcp, output, D1_A23_WAIT_FOR_R0_PRIME);
|
|
break;
|
|
case D1_A23_WAIT_FOR_R0_PRIME:
|
|
if (input->bstatus_read != PASS) {
|
|
fail_and_restart_in_ms(0, &status, output);
|
|
break;
|
|
} else if (input->r0p_available_dp != PASS) {
|
|
if (event_ctx->event == MOD_HDCP_EVENT_WATCHDOG_TIMEOUT)
|
|
fail_and_restart_in_ms(0, &status, output);
|
|
else
|
|
increment_stay_counter(hdcp);
|
|
break;
|
|
}
|
|
callback_in_ms(0, output);
|
|
set_state_id(hdcp, output, D1_A2_COMPUTATIONS_A3_VALIDATE_RX_A5_TEST_FOR_REPEATER);
|
|
break;
|
|
case D1_A2_COMPUTATIONS_A3_VALIDATE_RX_A5_TEST_FOR_REPEATER:
|
|
if (input->r0p_read != PASS) {
|
|
fail_and_restart_in_ms(0, &status, output);
|
|
break;
|
|
} else if (input->rx_validation != PASS) {
|
|
if (hdcp->state.stay_count < 2 &&
|
|
!hdcp->connection.is_hdcp1_revoked) {
|
|
/* allow 2 additional retries */
|
|
callback_in_ms(0, output);
|
|
increment_stay_counter(hdcp);
|
|
} else {
|
|
/*
|
|
* 1A-06: consider invalid r0' a failure
|
|
* after 3 attempts.
|
|
* 1A-08: consider bksv listed in SRM a failure
|
|
*/
|
|
/*
|
|
* some slow RX will fail rx validation when it is
|
|
* not ready. give it more time to react before retry.
|
|
*/
|
|
fail_and_restart_in_ms(1000, &status, output);
|
|
}
|
|
break;
|
|
} else if ((!conn->is_repeater && input->encryption != PASS) ||
|
|
(!conn->is_repeater && is_dp_mst_hdcp(hdcp) && input->stream_encryption_dp != PASS)) {
|
|
fail_and_restart_in_ms(0, &status, output);
|
|
break;
|
|
} else if (conn->hdcp1_retry_count < conn->link.adjust.hdcp1.min_auth_retries_wa) {
|
|
fail_and_restart_in_ms(200, &status, output);
|
|
break;
|
|
}
|
|
if (conn->is_repeater) {
|
|
set_watchdog_in_ms(hdcp, 5000, output);
|
|
set_state_id(hdcp, output, D1_A6_WAIT_FOR_READY);
|
|
} else {
|
|
set_state_id(hdcp, output, D1_A4_AUTHENTICATED);
|
|
set_auth_complete(hdcp, output);
|
|
}
|
|
break;
|
|
case D1_A4_AUTHENTICATED:
|
|
if (input->link_integrity_check == FAIL ||
|
|
input->reauth_request_check == FAIL) {
|
|
/* 1A-07: restart hdcp on a link integrity failure */
|
|
fail_and_restart_in_ms(0, &status, output);
|
|
break;
|
|
}
|
|
break;
|
|
case D1_A6_WAIT_FOR_READY:
|
|
if (input->link_integrity_check == FAIL ||
|
|
input->reauth_request_check == FAIL) {
|
|
fail_and_restart_in_ms(0, &status, output);
|
|
break;
|
|
} else if (input->ready_check != PASS) {
|
|
if (event_ctx->event ==
|
|
MOD_HDCP_EVENT_WATCHDOG_TIMEOUT) {
|
|
/* 1B-04: fail hdcp on ksv list READY timeout */
|
|
/* prevent black screen in next attempt */
|
|
adjust->hdcp1.postpone_encryption = 1;
|
|
fail_and_restart_in_ms(0, &status, output);
|
|
} else {
|
|
increment_stay_counter(hdcp);
|
|
}
|
|
break;
|
|
}
|
|
callback_in_ms(0, output);
|
|
set_state_id(hdcp, output, D1_A7_READ_KSV_LIST);
|
|
break;
|
|
case D1_A7_READ_KSV_LIST:
|
|
if (input->binfo_read_dp != PASS ||
|
|
input->max_cascade_check != PASS ||
|
|
input->max_devs_check != PASS) {
|
|
/* 1B-06: consider MAX_DEVS_EXCEEDED a failure */
|
|
/* 1B-07: consider MAX_CASCADE_EXCEEDED a failure */
|
|
fail_and_restart_in_ms(0, &status, output);
|
|
break;
|
|
} else if (input->device_count_check != PASS) {
|
|
/*
|
|
* some slow dongle doesn't update
|
|
* device count as soon as downstream is connected.
|
|
* give it more time to react.
|
|
*/
|
|
adjust->hdcp1.postpone_encryption = 1;
|
|
fail_and_restart_in_ms(1000, &status, output);
|
|
break;
|
|
} else if (input->ksvlist_read != PASS ||
|
|
input->vp_read != PASS) {
|
|
fail_and_restart_in_ms(0, &status, output);
|
|
break;
|
|
} else if (input->ksvlist_vp_validation != PASS) {
|
|
if (hdcp->state.stay_count < 2 &&
|
|
!hdcp->connection.is_hdcp1_revoked) {
|
|
/* allow 2 additional retries */
|
|
callback_in_ms(0, output);
|
|
increment_stay_counter(hdcp);
|
|
} else {
|
|
/*
|
|
* 1B-05: consider invalid v' a failure
|
|
* after 3 attempts.
|
|
*/
|
|
fail_and_restart_in_ms(0, &status, output);
|
|
}
|
|
break;
|
|
} else if (input->encryption != PASS ||
|
|
(is_dp_mst_hdcp(hdcp) && input->stream_encryption_dp != PASS)) {
|
|
fail_and_restart_in_ms(0, &status, output);
|
|
break;
|
|
}
|
|
set_state_id(hdcp, output, D1_A4_AUTHENTICATED);
|
|
set_auth_complete(hdcp, output);
|
|
break;
|
|
default:
|
|
fail_and_restart_in_ms(0, &status, output);
|
|
break;
|
|
}
|
|
|
|
return status;
|
|
}
|