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