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