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 #define MIN(a, b) ((a) < (b) ? (a) : (b)) 29 #define HDCP_I2C_ADDR 0x3a /* 0x74 >> 1*/ 30 #define KSV_READ_SIZE 0xf /* 0x6803b - 0x6802c */ 31 #define HDCP_MAX_AUX_TRANSACTION_SIZE 16 32 33 #define DP_CP_IRQ (1 << 2) 34 35 enum mod_hdcp_ddc_message_id { 36 MOD_HDCP_MESSAGE_ID_INVALID = -1, 37 38 /* HDCP 1.4 */ 39 40 MOD_HDCP_MESSAGE_ID_READ_BKSV = 0, 41 MOD_HDCP_MESSAGE_ID_READ_RI_R0, 42 MOD_HDCP_MESSAGE_ID_WRITE_AKSV, 43 MOD_HDCP_MESSAGE_ID_WRITE_AINFO, 44 MOD_HDCP_MESSAGE_ID_WRITE_AN, 45 MOD_HDCP_MESSAGE_ID_READ_VH_X, 46 MOD_HDCP_MESSAGE_ID_READ_VH_0, 47 MOD_HDCP_MESSAGE_ID_READ_VH_1, 48 MOD_HDCP_MESSAGE_ID_READ_VH_2, 49 MOD_HDCP_MESSAGE_ID_READ_VH_3, 50 MOD_HDCP_MESSAGE_ID_READ_VH_4, 51 MOD_HDCP_MESSAGE_ID_READ_BCAPS, 52 MOD_HDCP_MESSAGE_ID_READ_BSTATUS, 53 MOD_HDCP_MESSAGE_ID_READ_KSV_FIFO, 54 MOD_HDCP_MESSAGE_ID_READ_BINFO, 55 56 /* HDCP 2.2 */ 57 58 MOD_HDCP_MESSAGE_ID_HDCP2VERSION, 59 MOD_HDCP_MESSAGE_ID_RX_CAPS, 60 MOD_HDCP_MESSAGE_ID_WRITE_AKE_INIT, 61 MOD_HDCP_MESSAGE_ID_READ_AKE_SEND_CERT, 62 MOD_HDCP_MESSAGE_ID_WRITE_AKE_NO_STORED_KM, 63 MOD_HDCP_MESSAGE_ID_WRITE_AKE_STORED_KM, 64 MOD_HDCP_MESSAGE_ID_READ_AKE_SEND_H_PRIME, 65 MOD_HDCP_MESSAGE_ID_READ_AKE_SEND_PAIRING_INFO, 66 MOD_HDCP_MESSAGE_ID_WRITE_LC_INIT, 67 MOD_HDCP_MESSAGE_ID_READ_LC_SEND_L_PRIME, 68 MOD_HDCP_MESSAGE_ID_WRITE_SKE_SEND_EKS, 69 MOD_HDCP_MESSAGE_ID_READ_REPEATER_AUTH_SEND_RECEIVERID_LIST, 70 MOD_HDCP_MESSAGE_ID_READ_REPEATER_AUTH_SEND_RECEIVERID_LIST_PART2, 71 MOD_HDCP_MESSAGE_ID_WRITE_REPEATER_AUTH_SEND_ACK, 72 MOD_HDCP_MESSAGE_ID_WRITE_REPEATER_AUTH_STREAM_MANAGE, 73 MOD_HDCP_MESSAGE_ID_READ_REPEATER_AUTH_STREAM_READY, 74 MOD_HDCP_MESSAGE_ID_READ_RXSTATUS, 75 MOD_HDCP_MESSAGE_ID_WRITE_CONTENT_STREAM_TYPE, 76 77 MOD_HDCP_MESSAGE_ID_MAX 78 }; 79 80 static const uint8_t hdcp_i2c_offsets[] = { 81 [MOD_HDCP_MESSAGE_ID_READ_BKSV] = 0x0, 82 [MOD_HDCP_MESSAGE_ID_READ_RI_R0] = 0x8, 83 [MOD_HDCP_MESSAGE_ID_WRITE_AKSV] = 0x10, 84 [MOD_HDCP_MESSAGE_ID_WRITE_AINFO] = 0x15, 85 [MOD_HDCP_MESSAGE_ID_WRITE_AN] = 0x18, 86 [MOD_HDCP_MESSAGE_ID_READ_VH_X] = 0x20, 87 [MOD_HDCP_MESSAGE_ID_READ_VH_0] = 0x20, 88 [MOD_HDCP_MESSAGE_ID_READ_VH_1] = 0x24, 89 [MOD_HDCP_MESSAGE_ID_READ_VH_2] = 0x28, 90 [MOD_HDCP_MESSAGE_ID_READ_VH_3] = 0x2C, 91 [MOD_HDCP_MESSAGE_ID_READ_VH_4] = 0x30, 92 [MOD_HDCP_MESSAGE_ID_READ_BCAPS] = 0x40, 93 [MOD_HDCP_MESSAGE_ID_READ_BSTATUS] = 0x41, 94 [MOD_HDCP_MESSAGE_ID_READ_KSV_FIFO] = 0x43, 95 [MOD_HDCP_MESSAGE_ID_READ_BINFO] = 0xFF, 96 [MOD_HDCP_MESSAGE_ID_HDCP2VERSION] = 0x50, 97 [MOD_HDCP_MESSAGE_ID_WRITE_AKE_INIT] = 0x60, 98 [MOD_HDCP_MESSAGE_ID_READ_AKE_SEND_CERT] = 0x80, 99 [MOD_HDCP_MESSAGE_ID_WRITE_AKE_NO_STORED_KM] = 0x60, 100 [MOD_HDCP_MESSAGE_ID_WRITE_AKE_STORED_KM] = 0x60, 101 [MOD_HDCP_MESSAGE_ID_READ_AKE_SEND_H_PRIME] = 0x80, 102 [MOD_HDCP_MESSAGE_ID_READ_AKE_SEND_PAIRING_INFO] = 0x80, 103 [MOD_HDCP_MESSAGE_ID_WRITE_LC_INIT] = 0x60, 104 [MOD_HDCP_MESSAGE_ID_READ_LC_SEND_L_PRIME] = 0x80, 105 [MOD_HDCP_MESSAGE_ID_WRITE_SKE_SEND_EKS] = 0x60, 106 [MOD_HDCP_MESSAGE_ID_READ_REPEATER_AUTH_SEND_RECEIVERID_LIST] = 0x80, 107 [MOD_HDCP_MESSAGE_ID_READ_REPEATER_AUTH_SEND_RECEIVERID_LIST_PART2] = 0x80, 108 [MOD_HDCP_MESSAGE_ID_WRITE_REPEATER_AUTH_SEND_ACK] = 0x60, 109 [MOD_HDCP_MESSAGE_ID_WRITE_REPEATER_AUTH_STREAM_MANAGE] = 0x60, 110 [MOD_HDCP_MESSAGE_ID_READ_REPEATER_AUTH_STREAM_READY] = 0x80, 111 [MOD_HDCP_MESSAGE_ID_READ_RXSTATUS] = 0x70, 112 [MOD_HDCP_MESSAGE_ID_WRITE_CONTENT_STREAM_TYPE] = 0x0 113 }; 114 115 static const uint32_t hdcp_dpcd_addrs[] = { 116 [MOD_HDCP_MESSAGE_ID_READ_BKSV] = 0x68000, 117 [MOD_HDCP_MESSAGE_ID_READ_RI_R0] = 0x68005, 118 [MOD_HDCP_MESSAGE_ID_WRITE_AKSV] = 0x68007, 119 [MOD_HDCP_MESSAGE_ID_WRITE_AINFO] = 0x6803B, 120 [MOD_HDCP_MESSAGE_ID_WRITE_AN] = 0x6800c, 121 [MOD_HDCP_MESSAGE_ID_READ_VH_X] = 0x68014, 122 [MOD_HDCP_MESSAGE_ID_READ_VH_0] = 0x68014, 123 [MOD_HDCP_MESSAGE_ID_READ_VH_1] = 0x68018, 124 [MOD_HDCP_MESSAGE_ID_READ_VH_2] = 0x6801c, 125 [MOD_HDCP_MESSAGE_ID_READ_VH_3] = 0x68020, 126 [MOD_HDCP_MESSAGE_ID_READ_VH_4] = 0x68024, 127 [MOD_HDCP_MESSAGE_ID_READ_BCAPS] = 0x68028, 128 [MOD_HDCP_MESSAGE_ID_READ_BSTATUS] = 0x68029, 129 [MOD_HDCP_MESSAGE_ID_READ_KSV_FIFO] = 0x6802c, 130 [MOD_HDCP_MESSAGE_ID_READ_BINFO] = 0x6802a, 131 [MOD_HDCP_MESSAGE_ID_RX_CAPS] = 0x6921d, 132 [MOD_HDCP_MESSAGE_ID_WRITE_AKE_INIT] = 0x69000, 133 [MOD_HDCP_MESSAGE_ID_READ_AKE_SEND_CERT] = 0x6900b, 134 [MOD_HDCP_MESSAGE_ID_WRITE_AKE_NO_STORED_KM] = 0x69220, 135 [MOD_HDCP_MESSAGE_ID_WRITE_AKE_STORED_KM] = 0x692a0, 136 [MOD_HDCP_MESSAGE_ID_READ_AKE_SEND_H_PRIME] = 0x692c0, 137 [MOD_HDCP_MESSAGE_ID_READ_AKE_SEND_PAIRING_INFO] = 0x692e0, 138 [MOD_HDCP_MESSAGE_ID_WRITE_LC_INIT] = 0x692f0, 139 [MOD_HDCP_MESSAGE_ID_READ_LC_SEND_L_PRIME] = 0x692f8, 140 [MOD_HDCP_MESSAGE_ID_WRITE_SKE_SEND_EKS] = 0x69318, 141 [MOD_HDCP_MESSAGE_ID_READ_REPEATER_AUTH_SEND_RECEIVERID_LIST] = 0x69330, 142 [MOD_HDCP_MESSAGE_ID_READ_REPEATER_AUTH_SEND_RECEIVERID_LIST_PART2] = 0x69340, 143 [MOD_HDCP_MESSAGE_ID_WRITE_REPEATER_AUTH_SEND_ACK] = 0x693e0, 144 [MOD_HDCP_MESSAGE_ID_WRITE_REPEATER_AUTH_STREAM_MANAGE] = 0x693f0, 145 [MOD_HDCP_MESSAGE_ID_READ_REPEATER_AUTH_STREAM_READY] = 0x69473, 146 [MOD_HDCP_MESSAGE_ID_READ_RXSTATUS] = 0x69493, 147 [MOD_HDCP_MESSAGE_ID_WRITE_CONTENT_STREAM_TYPE] = 0x69494 148 }; 149 150 static enum mod_hdcp_status read(struct mod_hdcp *hdcp, 151 enum mod_hdcp_ddc_message_id msg_id, 152 uint8_t *buf, 153 uint32_t buf_len) 154 { 155 bool success = true; 156 uint32_t cur_size = 0; 157 uint32_t data_offset = 0; 158 159 if (is_dp_hdcp(hdcp)) { 160 while (buf_len > 0) { 161 cur_size = MIN(buf_len, HDCP_MAX_AUX_TRANSACTION_SIZE); 162 success = hdcp->config.ddc.funcs.read_dpcd(hdcp->config.ddc.handle, 163 hdcp_dpcd_addrs[msg_id] + data_offset, 164 buf + data_offset, 165 cur_size); 166 167 if (!success) 168 break; 169 170 buf_len -= cur_size; 171 data_offset += cur_size; 172 } 173 } else { 174 success = hdcp->config.ddc.funcs.read_i2c( 175 hdcp->config.ddc.handle, 176 HDCP_I2C_ADDR, 177 hdcp_i2c_offsets[msg_id], 178 buf, 179 (uint32_t)buf_len); 180 } 181 182 return success ? MOD_HDCP_STATUS_SUCCESS : MOD_HDCP_STATUS_DDC_FAILURE; 183 } 184 185 static enum mod_hdcp_status read_repeatedly(struct mod_hdcp *hdcp, 186 enum mod_hdcp_ddc_message_id msg_id, 187 uint8_t *buf, 188 uint32_t buf_len, 189 uint8_t read_size) 190 { 191 enum mod_hdcp_status status = MOD_HDCP_STATUS_DDC_FAILURE; 192 uint32_t cur_size = 0; 193 uint32_t data_offset = 0; 194 195 while (buf_len > 0) { 196 cur_size = MIN(buf_len, read_size); 197 status = read(hdcp, msg_id, buf + data_offset, cur_size); 198 199 if (status != MOD_HDCP_STATUS_SUCCESS) 200 break; 201 202 buf_len -= cur_size; 203 data_offset += cur_size; 204 } 205 206 return status; 207 } 208 209 static enum mod_hdcp_status write(struct mod_hdcp *hdcp, 210 enum mod_hdcp_ddc_message_id msg_id, 211 uint8_t *buf, 212 uint32_t buf_len) 213 { 214 bool success = true; 215 uint32_t cur_size = 0; 216 uint32_t data_offset = 0; 217 218 if (is_dp_hdcp(hdcp)) { 219 while (buf_len > 0) { 220 cur_size = MIN(buf_len, HDCP_MAX_AUX_TRANSACTION_SIZE); 221 success = hdcp->config.ddc.funcs.write_dpcd( 222 hdcp->config.ddc.handle, 223 hdcp_dpcd_addrs[msg_id] + data_offset, 224 buf + data_offset, 225 cur_size); 226 227 if (!success) 228 break; 229 230 buf_len -= cur_size; 231 data_offset += cur_size; 232 } 233 } else { 234 hdcp->buf[0] = hdcp_i2c_offsets[msg_id]; 235 memmove(&hdcp->buf[1], buf, buf_len); 236 success = hdcp->config.ddc.funcs.write_i2c( 237 hdcp->config.ddc.handle, 238 HDCP_I2C_ADDR, 239 hdcp->buf, 240 (uint32_t)(buf_len+1)); 241 } 242 243 return success ? MOD_HDCP_STATUS_SUCCESS : MOD_HDCP_STATUS_DDC_FAILURE; 244 } 245 246 enum mod_hdcp_status mod_hdcp_read_bksv(struct mod_hdcp *hdcp) 247 { 248 return read(hdcp, MOD_HDCP_MESSAGE_ID_READ_BKSV, 249 hdcp->auth.msg.hdcp1.bksv, 250 sizeof(hdcp->auth.msg.hdcp1.bksv)); 251 } 252 253 enum mod_hdcp_status mod_hdcp_read_bcaps(struct mod_hdcp *hdcp) 254 { 255 return read(hdcp, MOD_HDCP_MESSAGE_ID_READ_BCAPS, 256 &hdcp->auth.msg.hdcp1.bcaps, 257 sizeof(hdcp->auth.msg.hdcp1.bcaps)); 258 } 259 260 enum mod_hdcp_status mod_hdcp_read_bstatus(struct mod_hdcp *hdcp) 261 { 262 enum mod_hdcp_status status; 263 264 if (is_dp_hdcp(hdcp)) 265 status = read(hdcp, MOD_HDCP_MESSAGE_ID_READ_BSTATUS, 266 (uint8_t *)&hdcp->auth.msg.hdcp1.bstatus, 267 1); 268 else 269 status = read(hdcp, MOD_HDCP_MESSAGE_ID_READ_BSTATUS, 270 (uint8_t *)&hdcp->auth.msg.hdcp1.bstatus, 271 sizeof(hdcp->auth.msg.hdcp1.bstatus)); 272 return status; 273 } 274 275 enum mod_hdcp_status mod_hdcp_read_r0p(struct mod_hdcp *hdcp) 276 { 277 return read(hdcp, MOD_HDCP_MESSAGE_ID_READ_RI_R0, 278 (uint8_t *)&hdcp->auth.msg.hdcp1.r0p, 279 sizeof(hdcp->auth.msg.hdcp1.r0p)); 280 } 281 282 /* special case, reading repeatedly at the same address, don't use read() */ 283 enum mod_hdcp_status mod_hdcp_read_ksvlist(struct mod_hdcp *hdcp) 284 { 285 enum mod_hdcp_status status; 286 287 if (is_dp_hdcp(hdcp)) 288 status = read_repeatedly(hdcp, MOD_HDCP_MESSAGE_ID_READ_KSV_FIFO, 289 hdcp->auth.msg.hdcp1.ksvlist, 290 hdcp->auth.msg.hdcp1.ksvlist_size, 291 KSV_READ_SIZE); 292 else 293 status = read(hdcp, MOD_HDCP_MESSAGE_ID_READ_KSV_FIFO, 294 (uint8_t *)&hdcp->auth.msg.hdcp1.ksvlist, 295 hdcp->auth.msg.hdcp1.ksvlist_size); 296 return status; 297 } 298 299 enum mod_hdcp_status mod_hdcp_read_vp(struct mod_hdcp *hdcp) 300 { 301 enum mod_hdcp_status status; 302 303 status = read(hdcp, MOD_HDCP_MESSAGE_ID_READ_VH_0, 304 &hdcp->auth.msg.hdcp1.vp[0], 4); 305 if (status != MOD_HDCP_STATUS_SUCCESS) 306 goto out; 307 308 status = read(hdcp, MOD_HDCP_MESSAGE_ID_READ_VH_1, 309 &hdcp->auth.msg.hdcp1.vp[4], 4); 310 if (status != MOD_HDCP_STATUS_SUCCESS) 311 goto out; 312 313 status = read(hdcp, MOD_HDCP_MESSAGE_ID_READ_VH_2, 314 &hdcp->auth.msg.hdcp1.vp[8], 4); 315 if (status != MOD_HDCP_STATUS_SUCCESS) 316 goto out; 317 318 status = read(hdcp, MOD_HDCP_MESSAGE_ID_READ_VH_3, 319 &hdcp->auth.msg.hdcp1.vp[12], 4); 320 if (status != MOD_HDCP_STATUS_SUCCESS) 321 goto out; 322 323 status = read(hdcp, MOD_HDCP_MESSAGE_ID_READ_VH_4, 324 &hdcp->auth.msg.hdcp1.vp[16], 4); 325 out: 326 return status; 327 } 328 329 enum mod_hdcp_status mod_hdcp_read_binfo(struct mod_hdcp *hdcp) 330 { 331 enum mod_hdcp_status status; 332 333 if (is_dp_hdcp(hdcp)) 334 status = read(hdcp, MOD_HDCP_MESSAGE_ID_READ_BINFO, 335 (uint8_t *)&hdcp->auth.msg.hdcp1.binfo_dp, 336 sizeof(hdcp->auth.msg.hdcp1.binfo_dp)); 337 else 338 status = MOD_HDCP_STATUS_INVALID_OPERATION; 339 340 return status; 341 } 342 343 enum mod_hdcp_status mod_hdcp_write_aksv(struct mod_hdcp *hdcp) 344 { 345 return write(hdcp, MOD_HDCP_MESSAGE_ID_WRITE_AKSV, 346 hdcp->auth.msg.hdcp1.aksv, 347 sizeof(hdcp->auth.msg.hdcp1.aksv)); 348 } 349 350 enum mod_hdcp_status mod_hdcp_write_ainfo(struct mod_hdcp *hdcp) 351 { 352 return write(hdcp, MOD_HDCP_MESSAGE_ID_WRITE_AINFO, 353 &hdcp->auth.msg.hdcp1.ainfo, 354 sizeof(hdcp->auth.msg.hdcp1.ainfo)); 355 } 356 357 enum mod_hdcp_status mod_hdcp_write_an(struct mod_hdcp *hdcp) 358 { 359 return write(hdcp, MOD_HDCP_MESSAGE_ID_WRITE_AN, 360 hdcp->auth.msg.hdcp1.an, 361 sizeof(hdcp->auth.msg.hdcp1.an)); 362 } 363 364 enum mod_hdcp_status mod_hdcp_read_hdcp2version(struct mod_hdcp *hdcp) 365 { 366 enum mod_hdcp_status status; 367 368 if (is_dp_hdcp(hdcp)) 369 status = MOD_HDCP_STATUS_INVALID_OPERATION; 370 else 371 status = read(hdcp, MOD_HDCP_MESSAGE_ID_HDCP2VERSION, 372 &hdcp->auth.msg.hdcp2.hdcp2version_hdmi, 373 sizeof(hdcp->auth.msg.hdcp2.hdcp2version_hdmi)); 374 375 return status; 376 } 377 378 enum mod_hdcp_status mod_hdcp_read_rxcaps(struct mod_hdcp *hdcp) 379 { 380 enum mod_hdcp_status status; 381 382 if (!is_dp_hdcp(hdcp)) 383 status = MOD_HDCP_STATUS_INVALID_OPERATION; 384 else 385 status = read(hdcp, MOD_HDCP_MESSAGE_ID_RX_CAPS, 386 hdcp->auth.msg.hdcp2.rxcaps_dp, 387 sizeof(hdcp->auth.msg.hdcp2.rxcaps_dp)); 388 389 return status; 390 } 391 392 enum mod_hdcp_status mod_hdcp_read_rxstatus(struct mod_hdcp *hdcp) 393 { 394 enum mod_hdcp_status status; 395 396 if (is_dp_hdcp(hdcp)) { 397 status = read(hdcp, MOD_HDCP_MESSAGE_ID_READ_RXSTATUS, 398 &hdcp->auth.msg.hdcp2.rxstatus_dp, 399 1); 400 } else { 401 status = read(hdcp, MOD_HDCP_MESSAGE_ID_READ_RXSTATUS, 402 (uint8_t *)&hdcp->auth.msg.hdcp2.rxstatus, 403 sizeof(hdcp->auth.msg.hdcp2.rxstatus)); 404 } 405 return status; 406 } 407 408 enum mod_hdcp_status mod_hdcp_read_ake_cert(struct mod_hdcp *hdcp) 409 { 410 enum mod_hdcp_status status; 411 412 if (is_dp_hdcp(hdcp)) { 413 hdcp->auth.msg.hdcp2.ake_cert[0] = HDCP_2_2_AKE_SEND_CERT; 414 status = read(hdcp, MOD_HDCP_MESSAGE_ID_READ_AKE_SEND_CERT, 415 hdcp->auth.msg.hdcp2.ake_cert+1, 416 sizeof(hdcp->auth.msg.hdcp2.ake_cert)-1); 417 418 } else { 419 status = read(hdcp, MOD_HDCP_MESSAGE_ID_READ_AKE_SEND_CERT, 420 hdcp->auth.msg.hdcp2.ake_cert, 421 sizeof(hdcp->auth.msg.hdcp2.ake_cert)); 422 } 423 return status; 424 } 425 426 enum mod_hdcp_status mod_hdcp_read_h_prime(struct mod_hdcp *hdcp) 427 { 428 enum mod_hdcp_status status; 429 430 if (is_dp_hdcp(hdcp)) { 431 hdcp->auth.msg.hdcp2.ake_h_prime[0] = HDCP_2_2_AKE_SEND_HPRIME; 432 status = read(hdcp, MOD_HDCP_MESSAGE_ID_READ_AKE_SEND_H_PRIME, 433 hdcp->auth.msg.hdcp2.ake_h_prime+1, 434 sizeof(hdcp->auth.msg.hdcp2.ake_h_prime)-1); 435 436 } else { 437 status = read(hdcp, MOD_HDCP_MESSAGE_ID_READ_AKE_SEND_H_PRIME, 438 hdcp->auth.msg.hdcp2.ake_h_prime, 439 sizeof(hdcp->auth.msg.hdcp2.ake_h_prime)); 440 } 441 return status; 442 } 443 444 enum mod_hdcp_status mod_hdcp_read_pairing_info(struct mod_hdcp *hdcp) 445 { 446 enum mod_hdcp_status status; 447 448 if (is_dp_hdcp(hdcp)) { 449 hdcp->auth.msg.hdcp2.ake_pairing_info[0] = HDCP_2_2_AKE_SEND_PAIRING_INFO; 450 status = read(hdcp, MOD_HDCP_MESSAGE_ID_READ_AKE_SEND_PAIRING_INFO, 451 hdcp->auth.msg.hdcp2.ake_pairing_info+1, 452 sizeof(hdcp->auth.msg.hdcp2.ake_pairing_info)-1); 453 454 } else { 455 status = read(hdcp, MOD_HDCP_MESSAGE_ID_READ_AKE_SEND_PAIRING_INFO, 456 hdcp->auth.msg.hdcp2.ake_pairing_info, 457 sizeof(hdcp->auth.msg.hdcp2.ake_pairing_info)); 458 } 459 return status; 460 } 461 462 enum mod_hdcp_status mod_hdcp_read_l_prime(struct mod_hdcp *hdcp) 463 { 464 enum mod_hdcp_status status; 465 466 if (is_dp_hdcp(hdcp)) { 467 hdcp->auth.msg.hdcp2.lc_l_prime[0] = HDCP_2_2_LC_SEND_LPRIME; 468 status = read(hdcp, MOD_HDCP_MESSAGE_ID_READ_LC_SEND_L_PRIME, 469 hdcp->auth.msg.hdcp2.lc_l_prime+1, 470 sizeof(hdcp->auth.msg.hdcp2.lc_l_prime)-1); 471 472 } else { 473 status = read(hdcp, MOD_HDCP_MESSAGE_ID_READ_LC_SEND_L_PRIME, 474 hdcp->auth.msg.hdcp2.lc_l_prime, 475 sizeof(hdcp->auth.msg.hdcp2.lc_l_prime)); 476 } 477 return status; 478 } 479 480 enum mod_hdcp_status mod_hdcp_read_rx_id_list(struct mod_hdcp *hdcp) 481 { 482 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS; 483 484 if (is_dp_hdcp(hdcp)) { 485 uint32_t device_count = 0; 486 uint32_t rx_id_list_size = 0; 487 uint32_t bytes_read = 0; 488 489 hdcp->auth.msg.hdcp2.rx_id_list[0] = HDCP_2_2_REP_SEND_RECVID_LIST; 490 status = read(hdcp, MOD_HDCP_MESSAGE_ID_READ_REPEATER_AUTH_SEND_RECEIVERID_LIST, 491 hdcp->auth.msg.hdcp2.rx_id_list+1, 492 HDCP_MAX_AUX_TRANSACTION_SIZE); 493 if (status == MOD_HDCP_STATUS_SUCCESS) { 494 bytes_read = HDCP_MAX_AUX_TRANSACTION_SIZE; 495 device_count = HDCP_2_2_DEV_COUNT_LO(hdcp->auth.msg.hdcp2.rx_id_list[2]) + 496 (HDCP_2_2_DEV_COUNT_HI(hdcp->auth.msg.hdcp2.rx_id_list[1]) << 4); 497 rx_id_list_size = MIN((21 + 5 * device_count), 498 (sizeof(hdcp->auth.msg.hdcp2.rx_id_list) - 1)); 499 status = read(hdcp, MOD_HDCP_MESSAGE_ID_READ_REPEATER_AUTH_SEND_RECEIVERID_LIST_PART2, 500 hdcp->auth.msg.hdcp2.rx_id_list + 1 + bytes_read, 501 (rx_id_list_size - 1) / HDCP_MAX_AUX_TRANSACTION_SIZE * HDCP_MAX_AUX_TRANSACTION_SIZE); 502 } 503 } else { 504 status = read(hdcp, MOD_HDCP_MESSAGE_ID_READ_REPEATER_AUTH_SEND_RECEIVERID_LIST, 505 hdcp->auth.msg.hdcp2.rx_id_list, 506 hdcp->auth.msg.hdcp2.rx_id_list_size); 507 } 508 return status; 509 } 510 511 enum mod_hdcp_status mod_hdcp_read_stream_ready(struct mod_hdcp *hdcp) 512 { 513 enum mod_hdcp_status status; 514 515 if (is_dp_hdcp(hdcp)) { 516 hdcp->auth.msg.hdcp2.repeater_auth_stream_ready[0] = HDCP_2_2_REP_STREAM_READY; 517 status = read(hdcp, MOD_HDCP_MESSAGE_ID_READ_REPEATER_AUTH_STREAM_READY, 518 hdcp->auth.msg.hdcp2.repeater_auth_stream_ready+1, 519 sizeof(hdcp->auth.msg.hdcp2.repeater_auth_stream_ready)-1); 520 521 } else { 522 status = read(hdcp, MOD_HDCP_MESSAGE_ID_READ_REPEATER_AUTH_STREAM_READY, 523 hdcp->auth.msg.hdcp2.repeater_auth_stream_ready, 524 sizeof(hdcp->auth.msg.hdcp2.repeater_auth_stream_ready)); 525 } 526 return status; 527 } 528 529 enum mod_hdcp_status mod_hdcp_write_ake_init(struct mod_hdcp *hdcp) 530 { 531 enum mod_hdcp_status status; 532 533 if (is_dp_hdcp(hdcp)) 534 status = write(hdcp, MOD_HDCP_MESSAGE_ID_WRITE_AKE_INIT, 535 hdcp->auth.msg.hdcp2.ake_init+1, 536 sizeof(hdcp->auth.msg.hdcp2.ake_init)-1); 537 else 538 status = write(hdcp, MOD_HDCP_MESSAGE_ID_WRITE_AKE_INIT, 539 hdcp->auth.msg.hdcp2.ake_init, 540 sizeof(hdcp->auth.msg.hdcp2.ake_init)); 541 return status; 542 } 543 544 enum mod_hdcp_status mod_hdcp_write_no_stored_km(struct mod_hdcp *hdcp) 545 { 546 enum mod_hdcp_status status; 547 548 if (is_dp_hdcp(hdcp)) 549 status = write(hdcp, MOD_HDCP_MESSAGE_ID_WRITE_AKE_NO_STORED_KM, 550 hdcp->auth.msg.hdcp2.ake_no_stored_km+1, 551 sizeof(hdcp->auth.msg.hdcp2.ake_no_stored_km)-1); 552 else 553 status = write(hdcp, MOD_HDCP_MESSAGE_ID_WRITE_AKE_NO_STORED_KM, 554 hdcp->auth.msg.hdcp2.ake_no_stored_km, 555 sizeof(hdcp->auth.msg.hdcp2.ake_no_stored_km)); 556 return status; 557 } 558 559 enum mod_hdcp_status mod_hdcp_write_stored_km(struct mod_hdcp *hdcp) 560 { 561 enum mod_hdcp_status status; 562 563 if (is_dp_hdcp(hdcp)) 564 status = write(hdcp, MOD_HDCP_MESSAGE_ID_WRITE_AKE_STORED_KM, 565 hdcp->auth.msg.hdcp2.ake_stored_km+1, 566 sizeof(hdcp->auth.msg.hdcp2.ake_stored_km)-1); 567 else 568 status = write(hdcp, MOD_HDCP_MESSAGE_ID_WRITE_AKE_STORED_KM, 569 hdcp->auth.msg.hdcp2.ake_stored_km, 570 sizeof(hdcp->auth.msg.hdcp2.ake_stored_km)); 571 return status; 572 } 573 574 enum mod_hdcp_status mod_hdcp_write_lc_init(struct mod_hdcp *hdcp) 575 { 576 enum mod_hdcp_status status; 577 578 if (is_dp_hdcp(hdcp)) 579 status = write(hdcp, MOD_HDCP_MESSAGE_ID_WRITE_LC_INIT, 580 hdcp->auth.msg.hdcp2.lc_init+1, 581 sizeof(hdcp->auth.msg.hdcp2.lc_init)-1); 582 else 583 status = write(hdcp, MOD_HDCP_MESSAGE_ID_WRITE_LC_INIT, 584 hdcp->auth.msg.hdcp2.lc_init, 585 sizeof(hdcp->auth.msg.hdcp2.lc_init)); 586 return status; 587 } 588 589 enum mod_hdcp_status mod_hdcp_write_eks(struct mod_hdcp *hdcp) 590 { 591 enum mod_hdcp_status status; 592 593 if (is_dp_hdcp(hdcp)) 594 status = write(hdcp, 595 MOD_HDCP_MESSAGE_ID_WRITE_SKE_SEND_EKS, 596 hdcp->auth.msg.hdcp2.ske_eks+1, 597 sizeof(hdcp->auth.msg.hdcp2.ske_eks)-1); 598 else 599 status = write(hdcp, 600 MOD_HDCP_MESSAGE_ID_WRITE_SKE_SEND_EKS, 601 hdcp->auth.msg.hdcp2.ske_eks, 602 sizeof(hdcp->auth.msg.hdcp2.ske_eks)); 603 return status; 604 } 605 606 enum mod_hdcp_status mod_hdcp_write_repeater_auth_ack(struct mod_hdcp *hdcp) 607 { 608 enum mod_hdcp_status status; 609 610 if (is_dp_hdcp(hdcp)) 611 status = write(hdcp, MOD_HDCP_MESSAGE_ID_WRITE_REPEATER_AUTH_SEND_ACK, 612 hdcp->auth.msg.hdcp2.repeater_auth_ack+1, 613 sizeof(hdcp->auth.msg.hdcp2.repeater_auth_ack)-1); 614 else 615 status = write(hdcp, MOD_HDCP_MESSAGE_ID_WRITE_REPEATER_AUTH_SEND_ACK, 616 hdcp->auth.msg.hdcp2.repeater_auth_ack, 617 sizeof(hdcp->auth.msg.hdcp2.repeater_auth_ack)); 618 return status; 619 } 620 621 enum mod_hdcp_status mod_hdcp_write_stream_manage(struct mod_hdcp *hdcp) 622 { 623 enum mod_hdcp_status status; 624 625 if (is_dp_hdcp(hdcp)) 626 status = write(hdcp, 627 MOD_HDCP_MESSAGE_ID_WRITE_REPEATER_AUTH_STREAM_MANAGE, 628 hdcp->auth.msg.hdcp2.repeater_auth_stream_manage+1, 629 hdcp->auth.msg.hdcp2.stream_manage_size-1); 630 else 631 status = write(hdcp, 632 MOD_HDCP_MESSAGE_ID_WRITE_REPEATER_AUTH_STREAM_MANAGE, 633 hdcp->auth.msg.hdcp2.repeater_auth_stream_manage, 634 hdcp->auth.msg.hdcp2.stream_manage_size); 635 return status; 636 } 637 638 enum mod_hdcp_status mod_hdcp_write_content_type(struct mod_hdcp *hdcp) 639 { 640 enum mod_hdcp_status status; 641 642 if (is_dp_hdcp(hdcp)) 643 status = write(hdcp, MOD_HDCP_MESSAGE_ID_WRITE_CONTENT_STREAM_TYPE, 644 hdcp->auth.msg.hdcp2.content_stream_type_dp+1, 645 sizeof(hdcp->auth.msg.hdcp2.content_stream_type_dp)-1); 646 else 647 status = MOD_HDCP_STATUS_INVALID_OPERATION; 648 return status; 649 } 650 651 enum mod_hdcp_status mod_hdcp_clear_cp_irq_status(struct mod_hdcp *hdcp) 652 { 653 uint8_t clear_cp_irq_bit = DP_CP_IRQ; 654 uint32_t size = 1; 655 656 if (is_dp_hdcp(hdcp)) { 657 uint32_t cp_irq_addrs = (hdcp->connection.link.dp.rev >= 0x14) 658 ? DP_DEVICE_SERVICE_IRQ_VECTOR_ESI0:DP_DEVICE_SERVICE_IRQ_VECTOR; 659 return hdcp->config.ddc.funcs.write_dpcd(hdcp->config.ddc.handle, cp_irq_addrs, 660 &clear_cp_irq_bit, size) ? MOD_HDCP_STATUS_SUCCESS : MOD_HDCP_STATUS_DDC_FAILURE; 661 } 662 663 return MOD_HDCP_STATUS_INVALID_OPERATION; 664 } 665