drivers/gpu/drm/bridge/cadence/cdns-mhdp8546-hdcp.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Cadence MHDP8546 DP bridge driver.
   4  *
   5  * Copyright (C) 2020 Cadence Design Systems, Inc.
   6  *
   7  */
   8
   9 #include <linux/io.h>
  10 #include <linux/iopoll.h>
  11
  12 #include <asm/unaligned.h>
  13
  14 #include <drm/display/drm_hdcp_helper.h>
  15
  16 #include "cdns-mhdp8546-hdcp.h"
  17
  18 static int cdns_mhdp_secure_mailbox_read(struct cdns_mhdp_device *mhdp)
  19 {
  20         int ret, empty;
  21
  22         WARN_ON(!mutex_is_locked(&mhdp->mbox_mutex));
  23
  24         ret = readx_poll_timeout(readl, mhdp->sapb_regs + CDNS_MAILBOX_EMPTY,
  25                                  empty, !empty, MAILBOX_RETRY_US,
  26                                  MAILBOX_TIMEOUT_US);
  27         if (ret < 0)
  28                 return ret;
  29
  30         return readl(mhdp->sapb_regs + CDNS_MAILBOX_RX_DATA) & 0xff;
  31 }
  32
  33 static int cdns_mhdp_secure_mailbox_write(struct cdns_mhdp_device *mhdp,
  34                                           u8 val)
  35 {
  36         int ret, full;
  37
  38         WARN_ON(!mutex_is_locked(&mhdp->mbox_mutex));
  39
  40         ret = readx_poll_timeout(readl, mhdp->sapb_regs + CDNS_MAILBOX_FULL,
  41                                  full, !full, MAILBOX_RETRY_US,
  42                                  MAILBOX_TIMEOUT_US);
  43         if (ret < 0)
  44                 return ret;
  45
  46         writel(val, mhdp->sapb_regs + CDNS_MAILBOX_TX_DATA);
  47
  48         return 0;
  49 }
  50
  51 static int cdns_mhdp_secure_mailbox_recv_header(struct cdns_mhdp_device *mhdp,
  52                                                 u8 module_id,
  53                                                 u8 opcode,
  54                                                 u16 req_size)
  55 {
  56         u32 mbox_size, i;
  57         u8 header[4];
  58         int ret;
  59
  60         /* read the header of the message */
  61         for (i = 0; i < sizeof(header); i++) {
  62                 ret = cdns_mhdp_secure_mailbox_read(mhdp);
  63                 if (ret < 0)
  64                         return ret;
  65
  66                 header[i] = ret;
  67         }
  68
  69         mbox_size = get_unaligned_be16(header + 2);
  70
  71         if (opcode != header[0] || module_id != header[1] ||
  72             (opcode != HDCP_TRAN_IS_REC_ID_VALID && req_size != mbox_size)) {
  73                 for (i = 0; i < mbox_size; i++)
  74                         if (cdns_mhdp_secure_mailbox_read(mhdp) < 0)
  75                                 break;
  76                 return -EINVAL;
  77         }
  78
  79         return 0;
  80 }
  81
  82 static int cdns_mhdp_secure_mailbox_recv_data(struct cdns_mhdp_device *mhdp,
  83                                               u8 *buff, u16 buff_size)
  84 {
  85         int ret;
  86         u32 i;
  87
  88         for (i = 0; i < buff_size; i++) {
  89                 ret = cdns_mhdp_secure_mailbox_read(mhdp);
  90                 if (ret < 0)
  91                         return ret;
  92
  93                 buff[i] = ret;
  94         }
  95
  96         return 0;
  97 }
  98
  99 static int cdns_mhdp_secure_mailbox_send(struct cdns_mhdp_device *mhdp,
 100                                          u8 module_id,
 101                                          u8 opcode,
 102                                          u16 size,
 103                                          u8 *message)
 104 {
 105         u8 header[4];
 106         int ret;
 107         u32 i;
 108
 109         header[0] = opcode;
 110         header[1] = module_id;
 111         put_unaligned_be16(size, header + 2);
 112
 113         for (i = 0; i < sizeof(header); i++) {
 114                 ret = cdns_mhdp_secure_mailbox_write(mhdp, header[i]);
 115                 if (ret)
 116                         return ret;
 117         }
 118
 119         for (i = 0; i < size; i++) {
 120                 ret = cdns_mhdp_secure_mailbox_write(mhdp, message[i]);
 121                 if (ret)
 122                         return ret;
 123         }
 124
 125         return 0;
 126 }
 127
 128 static int cdns_mhdp_hdcp_get_status(struct cdns_mhdp_device *mhdp,
 129                                      u16 *hdcp_port_status)
 130 {
 131         u8 hdcp_status[HDCP_STATUS_SIZE];
 132         int ret;
 133
 134         mutex_lock(&mhdp->mbox_mutex);
 135         ret = cdns_mhdp_secure_mailbox_send(mhdp, MB_MODULE_ID_HDCP_TX,
 136                                             HDCP_TRAN_STATUS_CHANGE, 0, NULL);
 137         if (ret)
 138                 goto err_get_hdcp_status;
 139
 140         ret = cdns_mhdp_secure_mailbox_recv_header(mhdp, MB_MODULE_ID_HDCP_TX,
 141                                                    HDCP_TRAN_STATUS_CHANGE,
 142                                                    sizeof(hdcp_status));
 143         if (ret)
 144                 goto err_get_hdcp_status;
 145
 146         ret = cdns_mhdp_secure_mailbox_recv_data(mhdp, hdcp_status,
 147                                                  sizeof(hdcp_status));
 148         if (ret)
 149                 goto err_get_hdcp_status;
 150
 151         *hdcp_port_status = ((u16)(hdcp_status[0] << 8) | hdcp_status[1]);
 152
 153 err_get_hdcp_status:
 154         mutex_unlock(&mhdp->mbox_mutex);
 155
 156         return ret;
 157 }
 158
 159 static u8 cdns_mhdp_hdcp_handle_status(struct cdns_mhdp_device *mhdp,
 160                                        u16 status)
 161 {
 162         u8 err = GET_HDCP_PORT_STS_LAST_ERR(status);
 163
 164         if (err)
 165                 dev_dbg(mhdp->dev, "HDCP Error = %d", err);
 166
 167         return err;
 168 }
 169
 170 static int cdns_mhdp_hdcp_rx_id_valid_response(struct cdns_mhdp_device *mhdp,
 171                                                u8 valid)
 172 {
 173         int ret;
 174
 175         mutex_lock(&mhdp->mbox_mutex);
 176         ret = cdns_mhdp_secure_mailbox_send(mhdp, MB_MODULE_ID_HDCP_TX,
 177                                             HDCP_TRAN_RESPOND_RECEIVER_ID_VALID,
 178                                             1, &valid);
 179         mutex_unlock(&mhdp->mbox_mutex);
 180
 181         return ret;
 182 }
 183
 184 static int cdns_mhdp_hdcp_rx_id_valid(struct cdns_mhdp_device *mhdp,
 185                                       u8 *recv_num, u8 *hdcp_rx_id)
 186 {
 187         u8 rec_id_hdr[2];
 188         u8 status;
 189         int ret;
 190
 191         mutex_lock(&mhdp->mbox_mutex);
 192         ret = cdns_mhdp_secure_mailbox_send(mhdp, MB_MODULE_ID_HDCP_TX,
 193                                             HDCP_TRAN_IS_REC_ID_VALID, 0, NULL);
 194         if (ret)
 195                 goto err_rx_id_valid;
 196
 197         ret = cdns_mhdp_secure_mailbox_recv_header(mhdp, MB_MODULE_ID_HDCP_TX,
 198                                                    HDCP_TRAN_IS_REC_ID_VALID,
 199                                                    sizeof(status));
 200         if (ret)
 201                 goto err_rx_id_valid;
 202
 203         ret = cdns_mhdp_secure_mailbox_recv_data(mhdp, rec_id_hdr, 2);
 204         if (ret)
 205                 goto err_rx_id_valid;
 206
 207         *recv_num = rec_id_hdr[0];
 208
 209         ret = cdns_mhdp_secure_mailbox_recv_data(mhdp, hdcp_rx_id, 5 * *recv_num);
 210
 211 err_rx_id_valid:
 212         mutex_unlock(&mhdp->mbox_mutex);
 213
 214         return ret;
 215 }
 216
 217 static int cdns_mhdp_hdcp_km_stored_resp(struct cdns_mhdp_device *mhdp,
 218                                          u32 size, u8 *km)
 219 {
 220         int ret;
 221
 222         mutex_lock(&mhdp->mbox_mutex);
 223         ret = cdns_mhdp_secure_mailbox_send(mhdp, MB_MODULE_ID_HDCP_TX,
 224                                             HDCP2X_TX_RESPOND_KM, size, km);
 225         mutex_unlock(&mhdp->mbox_mutex);
 226
 227         return ret;
 228 }
 229
 230 static int cdns_mhdp_hdcp_tx_is_km_stored(struct cdns_mhdp_device *mhdp,
 231                                           u8 *resp, u32 size)
 232 {
 233         int ret;
 234
 235         mutex_lock(&mhdp->mbox_mutex);
 236         ret = cdns_mhdp_secure_mailbox_send(mhdp, MB_MODULE_ID_HDCP_TX,
 237                                             HDCP2X_TX_IS_KM_STORED, 0, NULL);
 238         if (ret)
 239                 goto err_is_km_stored;
 240
 241         ret = cdns_mhdp_secure_mailbox_recv_header(mhdp, MB_MODULE_ID_HDCP_TX,
 242                                                    HDCP2X_TX_IS_KM_STORED,
 243                                                    size);
 244         if (ret)
 245                 goto err_is_km_stored;
 246
 247         ret = cdns_mhdp_secure_mailbox_recv_data(mhdp, resp, size);
 248 err_is_km_stored:
 249         mutex_unlock(&mhdp->mbox_mutex);
 250
 251         return ret;
 252 }
 253
 254 static int cdns_mhdp_hdcp_tx_config(struct cdns_mhdp_device *mhdp,
 255                                     u8 hdcp_cfg)
 256 {
 257         int ret;
 258
 259         mutex_lock(&mhdp->mbox_mutex);
 260         ret = cdns_mhdp_secure_mailbox_send(mhdp, MB_MODULE_ID_HDCP_TX,
 261                                             HDCP_TRAN_CONFIGURATION, 1, &hdcp_cfg);
 262         mutex_unlock(&mhdp->mbox_mutex);
 263
 264         return ret;
 265 }
 266
 267 static int cdns_mhdp_hdcp_set_config(struct cdns_mhdp_device *mhdp,
 268                                      u8 hdcp_config, bool enable)
 269 {
 270         u16 hdcp_port_status;
 271         u32 ret_event;
 272         u8 hdcp_cfg;
 273         int ret;
 274
 275         hdcp_cfg = hdcp_config | (enable ? 0x04 : 0) |
 276                    (HDCP_CONTENT_TYPE_0 << 3);
 277         cdns_mhdp_hdcp_tx_config(mhdp, hdcp_cfg);
 278         ret_event = cdns_mhdp_wait_for_sw_event(mhdp, CDNS_HDCP_TX_STATUS);
 279         if (!ret_event)
 280                 return -1;
 281
 282         ret = cdns_mhdp_hdcp_get_status(mhdp, &hdcp_port_status);
 283         if (ret || cdns_mhdp_hdcp_handle_status(mhdp, hdcp_port_status))
 284                 return -1;
 285
 286         return 0;
 287 }
 288
 289 static int cdns_mhdp_hdcp_auth_check(struct cdns_mhdp_device *mhdp)
 290 {
 291         u16 hdcp_port_status;
 292         u32 ret_event;
 293         int ret;
 294
 295         ret_event = cdns_mhdp_wait_for_sw_event(mhdp, CDNS_HDCP_TX_STATUS);
 296         if (!ret_event)
 297                 return -1;
 298
 299         ret = cdns_mhdp_hdcp_get_status(mhdp, &hdcp_port_status);
 300         if (ret || cdns_mhdp_hdcp_handle_status(mhdp, hdcp_port_status))
 301                 return -1;
 302
 303         if (hdcp_port_status & 1) {
 304                 dev_dbg(mhdp->dev, "Authentication completed successfully!\n");
 305                 return 0;
 306         }
 307
 308         dev_dbg(mhdp->dev, "Authentication failed\n");
 309
 310         return -1;
 311 }
 312
 313 static int cdns_mhdp_hdcp_check_receviers(struct cdns_mhdp_device *mhdp)
 314 {
 315         u8 hdcp_rec_id[HDCP_MAX_RECEIVERS][HDCP_RECEIVER_ID_SIZE_BYTES];
 316         u8 hdcp_num_rec;
 317         u32 ret_event;
 318
 319         ret_event = cdns_mhdp_wait_for_sw_event(mhdp,
 320                                                 CDNS_HDCP_TX_IS_RCVR_ID_VALID);
 321         if (!ret_event)
 322                 return -1;
 323
 324         hdcp_num_rec = 0;
 325         memset(&hdcp_rec_id, 0, sizeof(hdcp_rec_id));
 326         cdns_mhdp_hdcp_rx_id_valid(mhdp, &hdcp_num_rec, (u8 *)hdcp_rec_id);
 327         cdns_mhdp_hdcp_rx_id_valid_response(mhdp, 1);
 328
 329         return 0;
 330 }
 331
 332 static int cdns_mhdp_hdcp_auth_22(struct cdns_mhdp_device *mhdp)
 333 {
 334         u8 resp[HDCP_STATUS_SIZE];
 335         u16 hdcp_port_status;
 336         u32 ret_event;
 337         int ret;
 338
 339         dev_dbg(mhdp->dev, "HDCP: Start 2.2 Authentication\n");
 340         ret_event = cdns_mhdp_wait_for_sw_event(mhdp,
 341                                                 CDNS_HDCP2_TX_IS_KM_STORED);
 342         if (!ret_event)
 343                 return -1;
 344
 345         if (ret_event & CDNS_HDCP_TX_STATUS) {
 346                 mhdp->sw_events &= ~CDNS_HDCP_TX_STATUS;
 347                 ret = cdns_mhdp_hdcp_get_status(mhdp, &hdcp_port_status);
 348                 if (ret || cdns_mhdp_hdcp_handle_status(mhdp, hdcp_port_status))
 349                         return -1;
 350         }
 351
 352         cdns_mhdp_hdcp_tx_is_km_stored(mhdp, resp, sizeof(resp));
 353         cdns_mhdp_hdcp_km_stored_resp(mhdp, 0, NULL);
 354
 355         if (cdns_mhdp_hdcp_check_receviers(mhdp))
 356                 return -1;
 357
 358         return 0;
 359 }
 360
 361 static inline int cdns_mhdp_hdcp_auth_14(struct cdns_mhdp_device *mhdp)
 362 {
 363         dev_dbg(mhdp->dev, "HDCP: Starting 1.4 Authentication\n");
 364         return cdns_mhdp_hdcp_check_receviers(mhdp);
 365 }
 366
 367 static int cdns_mhdp_hdcp_auth(struct cdns_mhdp_device *mhdp,
 368                                u8 hdcp_config)
 369 {
 370         int ret;
 371
 372         ret = cdns_mhdp_hdcp_set_config(mhdp, hdcp_config, true);
 373         if (ret)
 374                 goto auth_failed;
 375
 376         if (hdcp_config == HDCP_TX_1)
 377                 ret = cdns_mhdp_hdcp_auth_14(mhdp);
 378         else
 379                 ret = cdns_mhdp_hdcp_auth_22(mhdp);
 380
 381         if (ret)
 382                 goto auth_failed;
 383
 384         ret = cdns_mhdp_hdcp_auth_check(mhdp);
 385         if (ret)
 386                 ret = cdns_mhdp_hdcp_auth_check(mhdp);
 387
 388 auth_failed:
 389         return ret;
 390 }
 391
 392 static int _cdns_mhdp_hdcp_disable(struct cdns_mhdp_device *mhdp)
 393 {
 394         int ret;
 395
 396         dev_dbg(mhdp->dev, "[%s:%d] HDCP is being disabled...\n",
 397                 mhdp->connector.name, mhdp->connector.base.id);
 398
 399         ret = cdns_mhdp_hdcp_set_config(mhdp, 0, false);
 400
 401         return ret;
 402 }
 403
 404 static int _cdns_mhdp_hdcp_enable(struct cdns_mhdp_device *mhdp, u8 content_type)
 405 {
 406         int ret = -EINVAL;
 407         int tries = 3;
 408         u32 i;
 409
 410         for (i = 0; i < tries; i++) {
 411                 if (content_type == DRM_MODE_HDCP_CONTENT_TYPE0 ||
 412                     content_type == DRM_MODE_HDCP_CONTENT_TYPE1) {
 413                         ret = cdns_mhdp_hdcp_auth(mhdp, HDCP_TX_2);
 414                         if (!ret)
 415                                 return 0;
 416                         _cdns_mhdp_hdcp_disable(mhdp);
 417                 }
 418
 419                 if (content_type == DRM_MODE_HDCP_CONTENT_TYPE0) {
 420                         ret = cdns_mhdp_hdcp_auth(mhdp, HDCP_TX_1);
 421                         if (!ret)
 422                                 return 0;
 423                         _cdns_mhdp_hdcp_disable(mhdp);
 424                 }
 425         }
 426
 427         dev_err(mhdp->dev, "HDCP authentication failed (%d tries/%d)\n",
 428                 tries, ret);
 429
 430         return ret;
 431 }
 432
 433 static int cdns_mhdp_hdcp_check_link(struct cdns_mhdp_device *mhdp)
 434 {
 435         u16 hdcp_port_status;
 436         int ret = 0;
 437
 438         mutex_lock(&mhdp->hdcp.mutex);
 439         if (mhdp->hdcp.value == DRM_MODE_CONTENT_PROTECTION_UNDESIRED)
 440                 goto out;
 441
 442         ret = cdns_mhdp_hdcp_get_status(mhdp, &hdcp_port_status);
 443         if (!ret && hdcp_port_status & HDCP_PORT_STS_AUTH)
 444                 goto out;
 445
 446         dev_err(mhdp->dev,
 447                 "[%s:%d] HDCP link failed, retrying authentication\n",
 448                 mhdp->connector.name, mhdp->connector.base.id);
 449
 450         ret = _cdns_mhdp_hdcp_disable(mhdp);
 451         if (ret) {
 452                 mhdp->hdcp.value = DRM_MODE_CONTENT_PROTECTION_DESIRED;
 453                 schedule_work(&mhdp->hdcp.prop_work);
 454                 goto out;
 455         }
 456
 457         ret = _cdns_mhdp_hdcp_enable(mhdp, mhdp->hdcp.hdcp_content_type);
 458         if (ret) {
 459                 mhdp->hdcp.value = DRM_MODE_CONTENT_PROTECTION_DESIRED;
 460                 schedule_work(&mhdp->hdcp.prop_work);
 461         }
 462 out:
 463         mutex_unlock(&mhdp->hdcp.mutex);
 464         return ret;
 465 }
 466
 467 static void cdns_mhdp_hdcp_check_work(struct work_struct *work)
 468 {
 469         struct delayed_work *d_work = to_delayed_work(work);
 470         struct cdns_mhdp_hdcp *hdcp = container_of(d_work,
 471                                                    struct cdns_mhdp_hdcp,
 472                                                    check_work);
 473         struct cdns_mhdp_device *mhdp = container_of(hdcp,
 474                                                      struct cdns_mhdp_device,
 475                                                      hdcp);
 476
 477         if (!cdns_mhdp_hdcp_check_link(mhdp))
 478                 schedule_delayed_work(&hdcp->check_work,
 479                                       DRM_HDCP_CHECK_PERIOD_MS);
 480 }
 481
 482 static void cdns_mhdp_hdcp_prop_work(struct work_struct *work)
 483 {
 484         struct cdns_mhdp_hdcp *hdcp = container_of(work,
 485                                                    struct cdns_mhdp_hdcp,
 486                                                    prop_work);
 487         struct cdns_mhdp_device *mhdp = container_of(hdcp,
 488                                                      struct cdns_mhdp_device,
 489                                                      hdcp);
 490         struct drm_device *dev = mhdp->connector.dev;
 491         struct drm_connector_state *state;
 492
 493         drm_modeset_lock(&dev->mode_config.connection_mutex, NULL);
 494         mutex_lock(&mhdp->hdcp.mutex);
 495         if (mhdp->hdcp.value != DRM_MODE_CONTENT_PROTECTION_UNDESIRED) {
 496                 state = mhdp->connector.state;
 497                 state->content_protection = mhdp->hdcp.value;
 498         }
 499         mutex_unlock(&mhdp->hdcp.mutex);
 500         drm_modeset_unlock(&dev->mode_config.connection_mutex);
 501 }
 502
 503 int cdns_mhdp_hdcp_set_lc(struct cdns_mhdp_device *mhdp, u8 *val)
 504 {
 505         int ret;
 506
 507         mutex_lock(&mhdp->mbox_mutex);
 508         ret = cdns_mhdp_secure_mailbox_send(mhdp, MB_MODULE_ID_HDCP_GENERAL,
 509                                             HDCP_GENERAL_SET_LC_128,
 510                                             16, val);
 511         mutex_unlock(&mhdp->mbox_mutex);
 512
 513         return ret;
 514 }
 515
 516 int
 517 cdns_mhdp_hdcp_set_public_key_param(struct cdns_mhdp_device *mhdp,
 518                                     struct cdns_hdcp_tx_public_key_param *val)
 519 {
 520         int ret;
 521
 522         mutex_lock(&mhdp->mbox_mutex);
 523         ret = cdns_mhdp_secure_mailbox_send(mhdp, MB_MODULE_ID_HDCP_TX,
 524                                             HDCP2X_TX_SET_PUBLIC_KEY_PARAMS,
 525                                             sizeof(*val), (u8 *)val);
 526         mutex_unlock(&mhdp->mbox_mutex);
 527
 528         return ret;
 529 }
 530
 531 int cdns_mhdp_hdcp_enable(struct cdns_mhdp_device *mhdp, u8 content_type)
 532 {
 533         int ret;
 534
 535         mutex_lock(&mhdp->hdcp.mutex);
 536         ret = _cdns_mhdp_hdcp_enable(mhdp, content_type);
 537         if (ret)
 538                 goto out;
 539
 540         mhdp->hdcp.hdcp_content_type = content_type;
 541         mhdp->hdcp.value = DRM_MODE_CONTENT_PROTECTION_ENABLED;
 542         schedule_work(&mhdp->hdcp.prop_work);
 543         schedule_delayed_work(&mhdp->hdcp.check_work,
 544                               DRM_HDCP_CHECK_PERIOD_MS);
 545 out:
 546         mutex_unlock(&mhdp->hdcp.mutex);
 547         return ret;
 548 }
 549
 550 int cdns_mhdp_hdcp_disable(struct cdns_mhdp_device *mhdp)
 551 {
 552         int ret = 0;
 553
 554         mutex_lock(&mhdp->hdcp.mutex);
 555         if (mhdp->hdcp.value != DRM_MODE_CONTENT_PROTECTION_UNDESIRED) {
 556                 mhdp->hdcp.value = DRM_MODE_CONTENT_PROTECTION_UNDESIRED;
 557                 schedule_work(&mhdp->hdcp.prop_work);
 558                 ret = _cdns_mhdp_hdcp_disable(mhdp);
 559         }
 560         mutex_unlock(&mhdp->hdcp.mutex);
 561         cancel_delayed_work_sync(&mhdp->hdcp.check_work);
 562
 563         return ret;
 564 }
 565
 566 void cdns_mhdp_hdcp_init(struct cdns_mhdp_device *mhdp)
 567 {
 568         INIT_DELAYED_WORK(&mhdp->hdcp.check_work, cdns_mhdp_hdcp_check_work);
 569         INIT_WORK(&mhdp->hdcp.prop_work, cdns_mhdp_hdcp_prop_work);
 570         mutex_init(&mhdp->hdcp.mutex);
 571 }