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, tries = 3; 407 u32 i; 408 409 for (i = 0; i < tries; i++) { 410 if (content_type == DRM_MODE_HDCP_CONTENT_TYPE0 || 411 content_type == DRM_MODE_HDCP_CONTENT_TYPE1) { 412 ret = cdns_mhdp_hdcp_auth(mhdp, HDCP_TX_2); 413 if (!ret) 414 return 0; 415 _cdns_mhdp_hdcp_disable(mhdp); 416 } 417 418 if (content_type == DRM_MODE_HDCP_CONTENT_TYPE0) { 419 ret = cdns_mhdp_hdcp_auth(mhdp, HDCP_TX_1); 420 if (!ret) 421 return 0; 422 _cdns_mhdp_hdcp_disable(mhdp); 423 } 424 } 425 426 dev_err(mhdp->dev, "HDCP authentication failed (%d tries/%d)\n", 427 tries, ret); 428 429 return ret; 430 } 431 432 static int cdns_mhdp_hdcp_check_link(struct cdns_mhdp_device *mhdp) 433 { 434 u16 hdcp_port_status; 435 int ret = 0; 436 437 mutex_lock(&mhdp->hdcp.mutex); 438 if (mhdp->hdcp.value == DRM_MODE_CONTENT_PROTECTION_UNDESIRED) 439 goto out; 440 441 ret = cdns_mhdp_hdcp_get_status(mhdp, &hdcp_port_status); 442 if (!ret && hdcp_port_status & HDCP_PORT_STS_AUTH) 443 goto out; 444 445 dev_err(mhdp->dev, 446 "[%s:%d] HDCP link failed, retrying authentication\n", 447 mhdp->connector.name, mhdp->connector.base.id); 448 449 ret = _cdns_mhdp_hdcp_disable(mhdp); 450 if (ret) { 451 mhdp->hdcp.value = DRM_MODE_CONTENT_PROTECTION_DESIRED; 452 schedule_work(&mhdp->hdcp.prop_work); 453 goto out; 454 } 455 456 ret = _cdns_mhdp_hdcp_enable(mhdp, mhdp->hdcp.hdcp_content_type); 457 if (ret) { 458 mhdp->hdcp.value = DRM_MODE_CONTENT_PROTECTION_DESIRED; 459 schedule_work(&mhdp->hdcp.prop_work); 460 } 461 out: 462 mutex_unlock(&mhdp->hdcp.mutex); 463 return ret; 464 } 465 466 static void cdns_mhdp_hdcp_check_work(struct work_struct *work) 467 { 468 struct delayed_work *d_work = to_delayed_work(work); 469 struct cdns_mhdp_hdcp *hdcp = container_of(d_work, 470 struct cdns_mhdp_hdcp, 471 check_work); 472 struct cdns_mhdp_device *mhdp = container_of(hdcp, 473 struct cdns_mhdp_device, 474 hdcp); 475 476 if (!cdns_mhdp_hdcp_check_link(mhdp)) 477 schedule_delayed_work(&hdcp->check_work, 478 DRM_HDCP_CHECK_PERIOD_MS); 479 } 480 481 static void cdns_mhdp_hdcp_prop_work(struct work_struct *work) 482 { 483 struct cdns_mhdp_hdcp *hdcp = container_of(work, 484 struct cdns_mhdp_hdcp, 485 prop_work); 486 struct cdns_mhdp_device *mhdp = container_of(hdcp, 487 struct cdns_mhdp_device, 488 hdcp); 489 struct drm_device *dev = mhdp->connector.dev; 490 struct drm_connector_state *state; 491 492 drm_modeset_lock(&dev->mode_config.connection_mutex, NULL); 493 mutex_lock(&mhdp->hdcp.mutex); 494 if (mhdp->hdcp.value != DRM_MODE_CONTENT_PROTECTION_UNDESIRED) { 495 state = mhdp->connector.state; 496 state->content_protection = mhdp->hdcp.value; 497 } 498 mutex_unlock(&mhdp->hdcp.mutex); 499 drm_modeset_unlock(&dev->mode_config.connection_mutex); 500 } 501 502 int cdns_mhdp_hdcp_set_lc(struct cdns_mhdp_device *mhdp, u8 *val) 503 { 504 int ret; 505 506 mutex_lock(&mhdp->mbox_mutex); 507 ret = cdns_mhdp_secure_mailbox_send(mhdp, MB_MODULE_ID_HDCP_GENERAL, 508 HDCP_GENERAL_SET_LC_128, 509 16, val); 510 mutex_unlock(&mhdp->mbox_mutex); 511 512 return ret; 513 } 514 515 int 516 cdns_mhdp_hdcp_set_public_key_param(struct cdns_mhdp_device *mhdp, 517 struct cdns_hdcp_tx_public_key_param *val) 518 { 519 int ret; 520 521 mutex_lock(&mhdp->mbox_mutex); 522 ret = cdns_mhdp_secure_mailbox_send(mhdp, MB_MODULE_ID_HDCP_TX, 523 HDCP2X_TX_SET_PUBLIC_KEY_PARAMS, 524 sizeof(*val), (u8 *)val); 525 mutex_unlock(&mhdp->mbox_mutex); 526 527 return ret; 528 } 529 530 int cdns_mhdp_hdcp_enable(struct cdns_mhdp_device *mhdp, u8 content_type) 531 { 532 int ret; 533 534 mutex_lock(&mhdp->hdcp.mutex); 535 ret = _cdns_mhdp_hdcp_enable(mhdp, content_type); 536 if (ret) 537 goto out; 538 539 mhdp->hdcp.hdcp_content_type = content_type; 540 mhdp->hdcp.value = DRM_MODE_CONTENT_PROTECTION_ENABLED; 541 schedule_work(&mhdp->hdcp.prop_work); 542 schedule_delayed_work(&mhdp->hdcp.check_work, 543 DRM_HDCP_CHECK_PERIOD_MS); 544 out: 545 mutex_unlock(&mhdp->hdcp.mutex); 546 return ret; 547 } 548 549 int cdns_mhdp_hdcp_disable(struct cdns_mhdp_device *mhdp) 550 { 551 int ret = 0; 552 553 mutex_lock(&mhdp->hdcp.mutex); 554 if (mhdp->hdcp.value != DRM_MODE_CONTENT_PROTECTION_UNDESIRED) { 555 mhdp->hdcp.value = DRM_MODE_CONTENT_PROTECTION_UNDESIRED; 556 schedule_work(&mhdp->hdcp.prop_work); 557 ret = _cdns_mhdp_hdcp_disable(mhdp); 558 } 559 mutex_unlock(&mhdp->hdcp.mutex); 560 cancel_delayed_work_sync(&mhdp->hdcp.check_work); 561 562 return ret; 563 } 564 565 void cdns_mhdp_hdcp_init(struct cdns_mhdp_device *mhdp) 566 { 567 INIT_DELAYED_WORK(&mhdp->hdcp.check_work, cdns_mhdp_hdcp_check_work); 568 INIT_WORK(&mhdp->hdcp.prop_work, cdns_mhdp_hdcp_prop_work); 569 mutex_init(&mhdp->hdcp.mutex); 570 } 571