drivers/gpu/drm/amd/display/modules/hdcp/hdcp_ddc.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 #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 }