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

   1 /*
   2  * Copyright 2019 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 static void push_error_status(struct mod_hdcp *hdcp,
  29                 enum mod_hdcp_status status)
  30 {
  31         struct mod_hdcp_trace *trace = &hdcp->connection.trace;
  32
  33         if (trace->error_count < MAX_NUM_OF_ERROR_TRACE) {
  34                 trace->errors[trace->error_count].status = status;
  35                 trace->errors[trace->error_count].state_id = hdcp->state.id;
  36                 trace->error_count++;
  37                 HDCP_ERROR_TRACE(hdcp, status);
  38         }
  39
  40         if (is_hdcp1(hdcp)) {
  41                 hdcp->connection.hdcp1_retry_count++;
  42         } else if (is_hdcp2(hdcp)) {
  43                 hdcp->connection.hdcp2_retry_count++;
  44         }
  45 }
  46
  47 static uint8_t is_cp_desired_hdcp1(struct mod_hdcp *hdcp)
  48 {
  49         int i, is_auth_needed = 0;
  50
  51         /* if all displays on the link don't need authentication,
  52          * hdcp is not desired
  53          */
  54         for (i = 0; i < MAX_NUM_OF_DISPLAYS; i++) {
  55                 if (hdcp->displays[i].state != MOD_HDCP_DISPLAY_INACTIVE &&
  56                                 hdcp->displays[i].adjust.disable != MOD_HDCP_DISPLAY_DISABLE_AUTHENTICATION) {
  57                         is_auth_needed = 1;
  58                         break;
  59                 }
  60         }
  61
  62         return (hdcp->connection.hdcp1_retry_count < MAX_NUM_OF_ATTEMPTS) &&
  63                         is_auth_needed &&
  64                         !hdcp->connection.link.adjust.hdcp1.disable &&
  65                         !hdcp->connection.is_hdcp1_revoked;
  66 }
  67
  68 static uint8_t is_cp_desired_hdcp2(struct mod_hdcp *hdcp)
  69 {
  70         int i, is_auth_needed = 0;
  71
  72         /* if all displays on the link don't need authentication,
  73          * hdcp is not desired
  74          */
  75         for (i = 0; i < MAX_NUM_OF_DISPLAYS; i++) {
  76                 if (hdcp->displays[i].state != MOD_HDCP_DISPLAY_INACTIVE &&
  77                                 hdcp->displays[i].adjust.disable != MOD_HDCP_DISPLAY_DISABLE_AUTHENTICATION) {
  78                         is_auth_needed = 1;
  79                         break;
  80                 }
  81         }
  82
  83         return (hdcp->connection.hdcp2_retry_count < MAX_NUM_OF_ATTEMPTS) &&
  84                         is_auth_needed &&
  85                         !hdcp->connection.link.adjust.hdcp2.disable &&
  86                         !hdcp->connection.is_hdcp2_revoked;
  87 }
  88
  89 static enum mod_hdcp_status execution(struct mod_hdcp *hdcp,
  90                 struct mod_hdcp_event_context *event_ctx,
  91                 union mod_hdcp_transition_input *input)
  92 {
  93         enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
  94
  95         if (is_in_initialized_state(hdcp)) {
  96                 if (event_ctx->event != MOD_HDCP_EVENT_CALLBACK) {
  97                         event_ctx->unexpected_event = 1;
  98                         goto out;
  99                 }
 100                 /* initialize transition input */
 101                 memset(input, 0, sizeof(union mod_hdcp_transition_input));
 102         } else if (is_in_cp_not_desired_state(hdcp)) {
 103                 if (event_ctx->event != MOD_HDCP_EVENT_CALLBACK) {
 104                         event_ctx->unexpected_event = 1;
 105                         goto out;
 106                 }
 107         } else if (is_in_hdcp1_states(hdcp)) {
 108                 status = mod_hdcp_hdcp1_execution(hdcp, event_ctx, &input->hdcp1);
 109         } else if (is_in_hdcp1_dp_states(hdcp)) {
 110                 status = mod_hdcp_hdcp1_dp_execution(hdcp,
 111                                 event_ctx, &input->hdcp1);
 112         } else if (is_in_hdcp2_states(hdcp)) {
 113                 status = mod_hdcp_hdcp2_execution(hdcp, event_ctx, &input->hdcp2);
 114         } else if (is_in_hdcp2_dp_states(hdcp)) {
 115                 status = mod_hdcp_hdcp2_dp_execution(hdcp,
 116                                 event_ctx, &input->hdcp2);
 117         } else {
 118                 event_ctx->unexpected_event = 1;
 119                 goto out;
 120         }
 121 out:
 122         return status;
 123 }
 124
 125 static enum mod_hdcp_status transition(struct mod_hdcp *hdcp,
 126                 struct mod_hdcp_event_context *event_ctx,
 127                 union mod_hdcp_transition_input *input,
 128                 struct mod_hdcp_output *output)
 129 {
 130         enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
 131
 132         if (event_ctx->unexpected_event)
 133                 goto out;
 134
 135         if (is_in_initialized_state(hdcp)) {
 136                 if (is_dp_hdcp(hdcp))
 137                         if (is_cp_desired_hdcp2(hdcp)) {
 138                                 callback_in_ms(0, output);
 139                                 set_state_id(hdcp, output, D2_A0_DETERMINE_RX_HDCP_CAPABLE);
 140                         } else if (is_cp_desired_hdcp1(hdcp)) {
 141                                 callback_in_ms(0, output);
 142                                 set_state_id(hdcp, output, D1_A0_DETERMINE_RX_HDCP_CAPABLE);
 143                         } else {
 144                                 callback_in_ms(0, output);
 145                                 set_state_id(hdcp, output, HDCP_CP_NOT_DESIRED);
 146                         }
 147                 else if (is_hdmi_dvi_sl_hdcp(hdcp))
 148                         if (is_cp_desired_hdcp2(hdcp)) {
 149                                 callback_in_ms(0, output);
 150                                 set_state_id(hdcp, output, H2_A0_KNOWN_HDCP2_CAPABLE_RX);
 151                         } else if (is_cp_desired_hdcp1(hdcp)) {
 152                                 callback_in_ms(0, output);
 153                                 set_state_id(hdcp, output, H1_A0_WAIT_FOR_ACTIVE_RX);
 154                         } else {
 155                                 callback_in_ms(0, output);
 156                                 set_state_id(hdcp, output, HDCP_CP_NOT_DESIRED);
 157                         }
 158                 else {
 159                         callback_in_ms(0, output);
 160                         set_state_id(hdcp, output, HDCP_CP_NOT_DESIRED);
 161                 }
 162         } else if (is_in_cp_not_desired_state(hdcp)) {
 163                 increment_stay_counter(hdcp);
 164         } else if (is_in_hdcp1_states(hdcp)) {
 165                 status = mod_hdcp_hdcp1_transition(hdcp,
 166                                 event_ctx, &input->hdcp1, output);
 167         } else if (is_in_hdcp1_dp_states(hdcp)) {
 168                 status = mod_hdcp_hdcp1_dp_transition(hdcp,
 169                                 event_ctx, &input->hdcp1, output);
 170         } else if (is_in_hdcp2_states(hdcp)) {
 171                 status = mod_hdcp_hdcp2_transition(hdcp,
 172                                 event_ctx, &input->hdcp2, output);
 173         } else if (is_in_hdcp2_dp_states(hdcp)) {
 174                 status = mod_hdcp_hdcp2_dp_transition(hdcp,
 175                                 event_ctx, &input->hdcp2, output);
 176         } else {
 177                 status = MOD_HDCP_STATUS_INVALID_STATE;
 178         }
 179 out:
 180         return status;
 181 }
 182
 183 static enum mod_hdcp_status reset_authentication(struct mod_hdcp *hdcp,
 184                 struct mod_hdcp_output *output)
 185 {
 186         enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
 187
 188         if (is_hdcp1(hdcp)) {
 189                 if (hdcp->auth.trans_input.hdcp1.create_session != UNKNOWN) {
 190                         /* TODO - update psp to unify create session failure
 191                          * recovery between hdcp1 and 2.
 192                          */
 193                         mod_hdcp_hdcp1_destroy_session(hdcp);
 194
 195                 }
 196
 197                 HDCP_TOP_RESET_AUTH_TRACE(hdcp);
 198                 memset(&hdcp->auth, 0, sizeof(struct mod_hdcp_authentication));
 199                 memset(&hdcp->state, 0, sizeof(struct mod_hdcp_state));
 200                 set_state_id(hdcp, output, HDCP_INITIALIZED);
 201         } else if (is_hdcp2(hdcp)) {
 202                 if (hdcp->auth.trans_input.hdcp2.create_session == PASS) {
 203                         status = mod_hdcp_hdcp2_destroy_session(hdcp);
 204                         if (status != MOD_HDCP_STATUS_SUCCESS) {
 205                                 output->callback_needed = 0;
 206                                 output->watchdog_timer_needed = 0;
 207                                 goto out;
 208                         }
 209                 }
 210
 211                 HDCP_TOP_RESET_AUTH_TRACE(hdcp);
 212                 memset(&hdcp->auth, 0, sizeof(struct mod_hdcp_authentication));
 213                 memset(&hdcp->state, 0, sizeof(struct mod_hdcp_state));
 214                 set_state_id(hdcp, output, HDCP_INITIALIZED);
 215         } else if (is_in_cp_not_desired_state(hdcp)) {
 216                 HDCP_TOP_RESET_AUTH_TRACE(hdcp);
 217                 memset(&hdcp->auth, 0, sizeof(struct mod_hdcp_authentication));
 218                 memset(&hdcp->state, 0, sizeof(struct mod_hdcp_state));
 219                 set_state_id(hdcp, output, HDCP_INITIALIZED);
 220         }
 221
 222 out:
 223         /* stop callback and watchdog requests from previous authentication*/
 224         output->watchdog_timer_stop = 1;
 225         output->callback_stop = 1;
 226         return status;
 227 }
 228
 229 static enum mod_hdcp_status reset_connection(struct mod_hdcp *hdcp,
 230                 struct mod_hdcp_output *output)
 231 {
 232         enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
 233
 234         memset(output, 0, sizeof(struct mod_hdcp_output));
 235
 236         status = reset_authentication(hdcp, output);
 237         if (status != MOD_HDCP_STATUS_SUCCESS)
 238                 goto out;
 239
 240         if (current_state(hdcp) != HDCP_UNINITIALIZED) {
 241                 HDCP_TOP_RESET_CONN_TRACE(hdcp);
 242                 set_state_id(hdcp, output, HDCP_UNINITIALIZED);
 243         }
 244         memset(&hdcp->connection, 0, sizeof(hdcp->connection));
 245 out:
 246         return status;
 247 }
 248
 249 /*
 250  * Implementation of functions in mod_hdcp.h
 251  */
 252 size_t mod_hdcp_get_memory_size(void)
 253 {
 254         return sizeof(struct mod_hdcp);
 255 }
 256
 257 enum mod_hdcp_status mod_hdcp_setup(struct mod_hdcp *hdcp,
 258                 struct mod_hdcp_config *config)
 259 {
 260         struct mod_hdcp_output output;
 261         enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
 262
 263         memset(hdcp, 0, sizeof(struct mod_hdcp));
 264         memset(&output, 0, sizeof(output));
 265         hdcp->config = *config;
 266         HDCP_TOP_INTERFACE_TRACE(hdcp);
 267         status = reset_connection(hdcp, &output);
 268         if (status != MOD_HDCP_STATUS_SUCCESS)
 269                 push_error_status(hdcp, status);
 270         return status;
 271 }
 272
 273 enum mod_hdcp_status mod_hdcp_teardown(struct mod_hdcp *hdcp)
 274 {
 275         enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
 276         struct mod_hdcp_output output;
 277
 278         HDCP_TOP_INTERFACE_TRACE(hdcp);
 279         memset(&output, 0,  sizeof(output));
 280         status = reset_connection(hdcp, &output);
 281         if (status == MOD_HDCP_STATUS_SUCCESS)
 282                 memset(hdcp, 0, sizeof(struct mod_hdcp));
 283         else
 284                 push_error_status(hdcp, status);
 285         return status;
 286 }
 287
 288 enum mod_hdcp_status mod_hdcp_add_display(struct mod_hdcp *hdcp,
 289                 struct mod_hdcp_link *link, struct mod_hdcp_display *display,
 290                 struct mod_hdcp_output *output)
 291 {
 292         enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
 293         struct mod_hdcp_display *display_container = NULL;
 294
 295         HDCP_TOP_INTERFACE_TRACE_WITH_INDEX(hdcp, display->index);
 296         memset(output, 0, sizeof(struct mod_hdcp_output));
 297
 298         /* skip inactive display */
 299         if (display->state != MOD_HDCP_DISPLAY_ACTIVE) {
 300                 status = MOD_HDCP_STATUS_SUCCESS;
 301                 goto out;
 302         }
 303
 304         /* check existing display container */
 305         if (get_active_display_at_index(hdcp, display->index)) {
 306                 status = MOD_HDCP_STATUS_SUCCESS;
 307                 goto out;
 308         }
 309
 310         /* find an empty display container */
 311         display_container = get_empty_display_container(hdcp);
 312         if (!display_container) {
 313                 status = MOD_HDCP_STATUS_DISPLAY_OUT_OF_BOUND;
 314                 goto out;
 315         }
 316
 317         /* save current encryption states to restore after next authentication */
 318         mod_hdcp_save_current_encryption_states(hdcp);
 319
 320         /* reset existing authentication status */
 321         status = reset_authentication(hdcp, output);
 322         if (status != MOD_HDCP_STATUS_SUCCESS)
 323                 goto out;
 324
 325         /* reset retry counters */
 326         reset_retry_counts(hdcp);
 327
 328         /* reset error trace */
 329         memset(&hdcp->connection.trace, 0, sizeof(hdcp->connection.trace));
 330
 331         /* add display to connection */
 332         hdcp->connection.link = *link;
 333         *display_container = *display;
 334         status = mod_hdcp_add_display_to_topology(hdcp, display_container);
 335
 336         if (status != MOD_HDCP_STATUS_SUCCESS)
 337                 goto out;
 338
 339         /* request authentication */
 340         if (current_state(hdcp) != HDCP_INITIALIZED)
 341                 set_state_id(hdcp, output, HDCP_INITIALIZED);
 342         callback_in_ms(hdcp->connection.link.adjust.auth_delay * 1000, output);
 343 out:
 344         if (status != MOD_HDCP_STATUS_SUCCESS)
 345                 push_error_status(hdcp, status);
 346
 347         return status;
 348 }
 349
 350 enum mod_hdcp_status mod_hdcp_remove_display(struct mod_hdcp *hdcp,
 351                 uint8_t index, struct mod_hdcp_output *output)
 352 {
 353         enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
 354         struct mod_hdcp_display *display = NULL;
 355
 356         HDCP_TOP_INTERFACE_TRACE_WITH_INDEX(hdcp, index);
 357         memset(output, 0, sizeof(struct mod_hdcp_output));
 358
 359         /* find display in connection */
 360         display = get_active_display_at_index(hdcp, index);
 361         if (!display) {
 362                 status = MOD_HDCP_STATUS_SUCCESS;
 363                 goto out;
 364         }
 365
 366         /* save current encryption states to restore after next authentication */
 367         mod_hdcp_save_current_encryption_states(hdcp);
 368
 369         /* stop current authentication */
 370         status = reset_authentication(hdcp, output);
 371         if (status != MOD_HDCP_STATUS_SUCCESS)
 372                 goto out;
 373
 374         /* clear retry counters */
 375         reset_retry_counts(hdcp);
 376
 377         /* reset error trace */
 378         memset(&hdcp->connection.trace, 0, sizeof(hdcp->connection.trace));
 379
 380         /* remove display */
 381         status = mod_hdcp_remove_display_from_topology(hdcp, index);
 382         if (status != MOD_HDCP_STATUS_SUCCESS)
 383                 goto out;
 384         memset(display, 0, sizeof(struct mod_hdcp_display));
 385
 386         /* request authentication when connection is not reset */
 387         if (current_state(hdcp) != HDCP_UNINITIALIZED)
 388                 callback_in_ms(hdcp->connection.link.adjust.auth_delay * 1000,
 389                                 output);
 390 out:
 391         if (status != MOD_HDCP_STATUS_SUCCESS)
 392                 push_error_status(hdcp, status);
 393         return status;
 394 }
 395
 396 enum mod_hdcp_status mod_hdcp_query_display(struct mod_hdcp *hdcp,
 397                 uint8_t index, struct mod_hdcp_display_query *query)
 398 {
 399         enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
 400         struct mod_hdcp_display *display = NULL;
 401
 402         /* find display in connection */
 403         display = get_active_display_at_index(hdcp, index);
 404         if (!display) {
 405                 status = MOD_HDCP_STATUS_DISPLAY_NOT_FOUND;
 406                 goto out;
 407         }
 408
 409         /* populate query */
 410         query->link = &hdcp->connection.link;
 411         query->display = display;
 412         query->trace = &hdcp->connection.trace;
 413         query->encryption_status = MOD_HDCP_ENCRYPTION_STATUS_HDCP_OFF;
 414
 415         if (is_display_encryption_enabled(display)) {
 416                 if (is_hdcp1(hdcp)) {
 417                         query->encryption_status = MOD_HDCP_ENCRYPTION_STATUS_HDCP1_ON;
 418                 } else if (is_hdcp2(hdcp)) {
 419                         if (query->link->adjust.hdcp2.force_type == MOD_HDCP_FORCE_TYPE_0)
 420                                 query->encryption_status = MOD_HDCP_ENCRYPTION_STATUS_HDCP2_TYPE0_ON;
 421                         else if (query->link->adjust.hdcp2.force_type == MOD_HDCP_FORCE_TYPE_1)
 422                                 query->encryption_status = MOD_HDCP_ENCRYPTION_STATUS_HDCP2_TYPE1_ON;
 423                         else
 424                                 query->encryption_status = MOD_HDCP_ENCRYPTION_STATUS_HDCP2_ON;
 425                 }
 426         } else {
 427                 query->encryption_status = MOD_HDCP_ENCRYPTION_STATUS_HDCP_OFF;
 428         }
 429
 430 out:
 431         return status;
 432 }
 433
 434 enum mod_hdcp_status mod_hdcp_reset_connection(struct mod_hdcp *hdcp,
 435                 struct mod_hdcp_output *output)
 436 {
 437         enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
 438
 439         HDCP_TOP_INTERFACE_TRACE(hdcp);
 440         status = reset_connection(hdcp, output);
 441         if (status != MOD_HDCP_STATUS_SUCCESS)
 442                 push_error_status(hdcp, status);
 443
 444         return status;
 445 }
 446
 447 enum mod_hdcp_status mod_hdcp_process_event(struct mod_hdcp *hdcp,
 448                 enum mod_hdcp_event event, struct mod_hdcp_output *output)
 449 {
 450         enum mod_hdcp_status exec_status, trans_status, reset_status, status;
 451         struct mod_hdcp_event_context event_ctx;
 452
 453         HDCP_EVENT_TRACE(hdcp, event);
 454         memset(output, 0, sizeof(struct mod_hdcp_output));
 455         memset(&event_ctx, 0, sizeof(struct mod_hdcp_event_context));
 456         event_ctx.event = event;
 457
 458         /* execute and transition */
 459         exec_status = execution(hdcp, &event_ctx, &hdcp->auth.trans_input);
 460         trans_status = transition(
 461                         hdcp, &event_ctx, &hdcp->auth.trans_input, output);
 462         if (trans_status == MOD_HDCP_STATUS_SUCCESS) {
 463                 status = MOD_HDCP_STATUS_SUCCESS;
 464         } else if (exec_status == MOD_HDCP_STATUS_SUCCESS) {
 465                 status = MOD_HDCP_STATUS_INTERNAL_POLICY_FAILURE;
 466                 push_error_status(hdcp, status);
 467         } else {
 468                 status = exec_status;
 469                 push_error_status(hdcp, status);
 470         }
 471
 472         /* reset authentication if needed */
 473         if (trans_status == MOD_HDCP_STATUS_RESET_NEEDED) {
 474                 HDCP_FULL_DDC_TRACE(hdcp);
 475                 reset_status = reset_authentication(hdcp, output);
 476                 if (reset_status != MOD_HDCP_STATUS_SUCCESS)
 477                         push_error_status(hdcp, reset_status);
 478         }
 479
 480         /* Clear CP_IRQ status if needed */
 481         if (event_ctx.event == MOD_HDCP_EVENT_CPIRQ) {
 482                 status = mod_hdcp_clear_cp_irq_status(hdcp);
 483                 if (status != MOD_HDCP_STATUS_SUCCESS)
 484                         push_error_status(hdcp, status);
 485         }
 486
 487         return status;
 488 }
 489
 490 enum mod_hdcp_operation_mode mod_hdcp_signal_type_to_operation_mode(
 491                 enum signal_type signal)
 492 {
 493         enum mod_hdcp_operation_mode mode = MOD_HDCP_MODE_OFF;
 494
 495         switch (signal) {
 496         case SIGNAL_TYPE_DVI_SINGLE_LINK:
 497         case SIGNAL_TYPE_HDMI_TYPE_A:
 498                 mode = MOD_HDCP_MODE_DEFAULT;
 499                 break;
 500         case SIGNAL_TYPE_EDP:
 501         case SIGNAL_TYPE_DISPLAY_PORT:
 502         case SIGNAL_TYPE_DISPLAY_PORT_MST:
 503                 mode = MOD_HDCP_MODE_DP;
 504                 break;
 505         default:
 506                 break;
 507         }
 508
 509         return mode;
 510 }