drivers/gpu/drm/amd/display/modules/hdcp/hdcp2_transition.c

   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
  28 enum 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
 369 enum 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 }