drivers/gpu/drm/i915/display/intel_hdcp_gsc.c

   1 // SPDX-License-Identifier: MIT
   2 /*
   3  * Copyright 2023, Intel Corporation.
   4  */
   5
   6 #include <drm/i915_hdcp_interface.h>
   7
   8 #include "gem/i915_gem_region.h"
   9 #include "gt/intel_gt.h"
  10 #include "gt/uc/intel_gsc_uc_heci_cmd_submit.h"
  11 #include "i915_drv.h"
  12 #include "i915_utils.h"
  13 #include "intel_hdcp_gsc.h"
  14
  15 bool intel_hdcp_gsc_cs_required(struct drm_i915_private *i915)
  16 {
  17         return DISPLAY_VER(i915) >= 14;
  18 }
  19
  20 static int
  21 gsc_hdcp_initiate_session(struct device *dev, struct hdcp_port_data *data,
  22                           struct hdcp2_ake_init *ake_data)
  23 {
  24         struct wired_cmd_initiate_hdcp2_session_in session_init_in = { { 0 } };
  25         struct wired_cmd_initiate_hdcp2_session_out
  26                                                 session_init_out = { { 0 } };
  27         struct drm_i915_private *i915;
  28         ssize_t byte;
  29
  30         if (!dev || !data || !ake_data)
  31                 return -EINVAL;
  32
  33         i915 = kdev_to_i915(dev);
  34         if (!i915) {
  35                 dev_err(dev, "DRM not initialized, aborting HDCP.\n");
  36                 return -ENODEV;
  37         }
  38
  39         session_init_in.header.api_version = HDCP_API_VERSION;
  40         session_init_in.header.command_id = WIRED_INITIATE_HDCP2_SESSION;
  41         session_init_in.header.status = FW_HDCP_STATUS_SUCCESS;
  42         session_init_in.header.buffer_len =
  43                                 WIRED_CMD_BUF_LEN_INITIATE_HDCP2_SESSION_IN;
  44
  45         session_init_in.port.integrated_port_type = data->port_type;
  46         session_init_in.port.physical_port = (u8)data->hdcp_ddi;
  47         session_init_in.port.attached_transcoder = (u8)data->hdcp_transcoder;
  48         session_init_in.protocol = data->protocol;
  49
  50         byte = intel_hdcp_gsc_msg_send(i915, (u8 *)&session_init_in,
  51                                        sizeof(session_init_in),
  52                                        (u8 *)&session_init_out,
  53                                        sizeof(session_init_out));
  54         if (byte < 0) {
  55                 drm_dbg_kms(&i915->drm, "intel_hdcp_gsc_msg_send failed. %zd\n", byte);
  56                 return byte;
  57         }
  58
  59         if (session_init_out.header.status != FW_HDCP_STATUS_SUCCESS) {
  60                 drm_dbg_kms(&i915->drm, "FW cmd 0x%08X Failed. Status: 0x%X\n",
  61                             WIRED_INITIATE_HDCP2_SESSION,
  62                             session_init_out.header.status);
  63                 return -EIO;
  64         }
  65
  66         ake_data->msg_id = HDCP_2_2_AKE_INIT;
  67         ake_data->tx_caps = session_init_out.tx_caps;
  68         memcpy(ake_data->r_tx, session_init_out.r_tx, HDCP_2_2_RTX_LEN);
  69
  70         return 0;
  71 }
  72
  73 static int
  74 gsc_hdcp_verify_receiver_cert_prepare_km(struct device *dev,
  75                                          struct hdcp_port_data *data,
  76                                          struct hdcp2_ake_send_cert *rx_cert,
  77                                          bool *km_stored,
  78                                          struct hdcp2_ake_no_stored_km
  79                                                                 *ek_pub_km,
  80                                          size_t *msg_sz)
  81 {
  82         struct wired_cmd_verify_receiver_cert_in verify_rxcert_in = { { 0 } };
  83         struct wired_cmd_verify_receiver_cert_out verify_rxcert_out = { { 0 } };
  84         struct drm_i915_private *i915;
  85         ssize_t byte;
  86
  87         if (!dev || !data || !rx_cert || !km_stored || !ek_pub_km || !msg_sz)
  88                 return -EINVAL;
  89
  90         i915 = kdev_to_i915(dev);
  91         if (!i915) {
  92                 dev_err(dev, "DRM not initialized, aborting HDCP.\n");
  93                 return -ENODEV;
  94         }
  95
  96         verify_rxcert_in.header.api_version = HDCP_API_VERSION;
  97         verify_rxcert_in.header.command_id = WIRED_VERIFY_RECEIVER_CERT;
  98         verify_rxcert_in.header.status = FW_HDCP_STATUS_SUCCESS;
  99         verify_rxcert_in.header.buffer_len =
 100                                 WIRED_CMD_BUF_LEN_VERIFY_RECEIVER_CERT_IN;
 101
 102         verify_rxcert_in.port.integrated_port_type = data->port_type;
 103         verify_rxcert_in.port.physical_port = (u8)data->hdcp_ddi;
 104         verify_rxcert_in.port.attached_transcoder = (u8)data->hdcp_transcoder;
 105
 106         verify_rxcert_in.cert_rx = rx_cert->cert_rx;
 107         memcpy(verify_rxcert_in.r_rx, &rx_cert->r_rx, HDCP_2_2_RRX_LEN);
 108         memcpy(verify_rxcert_in.rx_caps, rx_cert->rx_caps, HDCP_2_2_RXCAPS_LEN);
 109
 110         byte = intel_hdcp_gsc_msg_send(i915, (u8 *)&verify_rxcert_in,
 111                                        sizeof(verify_rxcert_in),
 112                                        (u8 *)&verify_rxcert_out,
 113                                        sizeof(verify_rxcert_out));
 114         if (byte < 0) {
 115                 drm_dbg_kms(&i915->drm, "intel_hdcp_gsc_msg_send failed: %zd\n", byte);
 116                 return byte;
 117         }
 118
 119         if (verify_rxcert_out.header.status != FW_HDCP_STATUS_SUCCESS) {
 120                 drm_dbg_kms(&i915->drm, "FW cmd 0x%08X Failed. Status: 0x%X\n",
 121                             WIRED_VERIFY_RECEIVER_CERT,
 122                             verify_rxcert_out.header.status);
 123                 return -EIO;
 124         }
 125
 126         *km_stored = !!verify_rxcert_out.km_stored;
 127         if (verify_rxcert_out.km_stored) {
 128                 ek_pub_km->msg_id = HDCP_2_2_AKE_STORED_KM;
 129                 *msg_sz = sizeof(struct hdcp2_ake_stored_km);
 130         } else {
 131                 ek_pub_km->msg_id = HDCP_2_2_AKE_NO_STORED_KM;
 132                 *msg_sz = sizeof(struct hdcp2_ake_no_stored_km);
 133         }
 134
 135         memcpy(ek_pub_km->e_kpub_km, &verify_rxcert_out.ekm_buff,
 136                sizeof(verify_rxcert_out.ekm_buff));
 137
 138         return 0;
 139 }
 140
 141 static int
 142 gsc_hdcp_verify_hprime(struct device *dev, struct hdcp_port_data *data,
 143                        struct hdcp2_ake_send_hprime *rx_hprime)
 144 {
 145         struct wired_cmd_ake_send_hprime_in send_hprime_in = { { 0 } };
 146         struct wired_cmd_ake_send_hprime_out send_hprime_out = { { 0 } };
 147         struct drm_i915_private *i915;
 148         ssize_t byte;
 149
 150         if (!dev || !data || !rx_hprime)
 151                 return -EINVAL;
 152
 153         i915 = kdev_to_i915(dev);
 154         if (!i915) {
 155                 dev_err(dev, "DRM not initialized, aborting HDCP.\n");
 156                 return -ENODEV;
 157         }
 158
 159         send_hprime_in.header.api_version = HDCP_API_VERSION;
 160         send_hprime_in.header.command_id = WIRED_AKE_SEND_HPRIME;
 161         send_hprime_in.header.status = FW_HDCP_STATUS_SUCCESS;
 162         send_hprime_in.header.buffer_len = WIRED_CMD_BUF_LEN_AKE_SEND_HPRIME_IN;
 163
 164         send_hprime_in.port.integrated_port_type = data->port_type;
 165         send_hprime_in.port.physical_port = (u8)data->hdcp_ddi;
 166         send_hprime_in.port.attached_transcoder = (u8)data->hdcp_transcoder;
 167
 168         memcpy(send_hprime_in.h_prime, rx_hprime->h_prime,
 169                HDCP_2_2_H_PRIME_LEN);
 170
 171         byte = intel_hdcp_gsc_msg_send(i915, (u8 *)&send_hprime_in,
 172                                        sizeof(send_hprime_in),
 173                                        (u8 *)&send_hprime_out,
 174                                        sizeof(send_hprime_out));
 175         if (byte < 0) {
 176                 drm_dbg_kms(&i915->drm, "intel_hdcp_gsc_msg_send failed. %zd\n", byte);
 177                 return byte;
 178         }
 179
 180         if (send_hprime_out.header.status != FW_HDCP_STATUS_SUCCESS) {
 181                 drm_dbg_kms(&i915->drm, "FW cmd 0x%08X Failed. Status: 0x%X\n",
 182                             WIRED_AKE_SEND_HPRIME, send_hprime_out.header.status);
 183                 return -EIO;
 184         }
 185
 186         return 0;
 187 }
 188
 189 static int
 190 gsc_hdcp_store_pairing_info(struct device *dev, struct hdcp_port_data *data,
 191                             struct hdcp2_ake_send_pairing_info *pairing_info)
 192 {
 193         struct wired_cmd_ake_send_pairing_info_in pairing_info_in = { { 0 } };
 194         struct wired_cmd_ake_send_pairing_info_out pairing_info_out = { { 0 } };
 195         struct drm_i915_private *i915;
 196         ssize_t byte;
 197
 198         if (!dev || !data || !pairing_info)
 199                 return -EINVAL;
 200
 201         i915 = kdev_to_i915(dev);
 202         if (!i915) {
 203                 dev_err(dev, "DRM not initialized, aborting HDCP.\n");
 204                 return -ENODEV;
 205         }
 206
 207         pairing_info_in.header.api_version = HDCP_API_VERSION;
 208         pairing_info_in.header.command_id = WIRED_AKE_SEND_PAIRING_INFO;
 209         pairing_info_in.header.status = FW_HDCP_STATUS_SUCCESS;
 210         pairing_info_in.header.buffer_len =
 211                                         WIRED_CMD_BUF_LEN_SEND_PAIRING_INFO_IN;
 212
 213         pairing_info_in.port.integrated_port_type = data->port_type;
 214         pairing_info_in.port.physical_port = (u8)data->hdcp_ddi;
 215         pairing_info_in.port.attached_transcoder = (u8)data->hdcp_transcoder;
 216
 217         memcpy(pairing_info_in.e_kh_km, pairing_info->e_kh_km,
 218                HDCP_2_2_E_KH_KM_LEN);
 219
 220         byte = intel_hdcp_gsc_msg_send(i915, (u8 *)&pairing_info_in,
 221                                        sizeof(pairing_info_in),
 222                                        (u8 *)&pairing_info_out,
 223                                        sizeof(pairing_info_out));
 224         if (byte < 0) {
 225                 drm_dbg_kms(&i915->drm, "intel_hdcp_gsc_msg_send failed. %zd\n", byte);
 226                 return byte;
 227         }
 228
 229         if (pairing_info_out.header.status != FW_HDCP_STATUS_SUCCESS) {
 230                 drm_dbg_kms(&i915->drm, "FW cmd 0x%08X failed. Status: 0x%X\n",
 231                             WIRED_AKE_SEND_PAIRING_INFO,
 232                             pairing_info_out.header.status);
 233                 return -EIO;
 234         }
 235
 236         return 0;
 237 }
 238
 239 static int
 240 gsc_hdcp_initiate_locality_check(struct device *dev,
 241                                  struct hdcp_port_data *data,
 242                                  struct hdcp2_lc_init *lc_init_data)
 243 {
 244         struct wired_cmd_init_locality_check_in lc_init_in = { { 0 } };
 245         struct wired_cmd_init_locality_check_out lc_init_out = { { 0 } };
 246         struct drm_i915_private *i915;
 247         ssize_t byte;
 248
 249         if (!dev || !data || !lc_init_data)
 250                 return -EINVAL;
 251
 252         i915 = kdev_to_i915(dev);
 253         if (!i915) {
 254                 dev_err(dev, "DRM not initialized, aborting HDCP.\n");
 255                 return -ENODEV;
 256         }
 257
 258         lc_init_in.header.api_version = HDCP_API_VERSION;
 259         lc_init_in.header.command_id = WIRED_INIT_LOCALITY_CHECK;
 260         lc_init_in.header.status = FW_HDCP_STATUS_SUCCESS;
 261         lc_init_in.header.buffer_len = WIRED_CMD_BUF_LEN_INIT_LOCALITY_CHECK_IN;
 262
 263         lc_init_in.port.integrated_port_type = data->port_type;
 264         lc_init_in.port.physical_port = (u8)data->hdcp_ddi;
 265         lc_init_in.port.attached_transcoder = (u8)data->hdcp_transcoder;
 266
 267         byte = intel_hdcp_gsc_msg_send(i915, (u8 *)&lc_init_in, sizeof(lc_init_in),
 268                                        (u8 *)&lc_init_out, sizeof(lc_init_out));
 269         if (byte < 0) {
 270                 drm_dbg_kms(&i915->drm, "intel_hdcp_gsc_msg_send failed. %zd\n", byte);
 271                 return byte;
 272         }
 273
 274         if (lc_init_out.header.status != FW_HDCP_STATUS_SUCCESS) {
 275                 drm_dbg_kms(&i915->drm, "FW cmd 0x%08X Failed. status: 0x%X\n",
 276                             WIRED_INIT_LOCALITY_CHECK, lc_init_out.header.status);
 277                 return -EIO;
 278         }
 279
 280         lc_init_data->msg_id = HDCP_2_2_LC_INIT;
 281         memcpy(lc_init_data->r_n, lc_init_out.r_n, HDCP_2_2_RN_LEN);
 282
 283         return 0;
 284 }
 285
 286 static int
 287 gsc_hdcp_verify_lprime(struct device *dev, struct hdcp_port_data *data,
 288                        struct hdcp2_lc_send_lprime *rx_lprime)
 289 {
 290         struct wired_cmd_validate_locality_in verify_lprime_in = { { 0 } };
 291         struct wired_cmd_validate_locality_out verify_lprime_out = { { 0 } };
 292         struct drm_i915_private *i915;
 293         ssize_t byte;
 294
 295         if (!dev || !data || !rx_lprime)
 296                 return -EINVAL;
 297
 298         i915 = kdev_to_i915(dev);
 299         if (!i915) {
 300                 dev_err(dev, "DRM not initialized, aborting HDCP.\n");
 301                 return -ENODEV;
 302         }
 303
 304         verify_lprime_in.header.api_version = HDCP_API_VERSION;
 305         verify_lprime_in.header.command_id = WIRED_VALIDATE_LOCALITY;
 306         verify_lprime_in.header.status = FW_HDCP_STATUS_SUCCESS;
 307         verify_lprime_in.header.buffer_len =
 308                                         WIRED_CMD_BUF_LEN_VALIDATE_LOCALITY_IN;
 309
 310         verify_lprime_in.port.integrated_port_type = data->port_type;
 311         verify_lprime_in.port.physical_port = (u8)data->hdcp_ddi;
 312         verify_lprime_in.port.attached_transcoder = (u8)data->hdcp_transcoder;
 313
 314         memcpy(verify_lprime_in.l_prime, rx_lprime->l_prime,
 315                HDCP_2_2_L_PRIME_LEN);
 316
 317         byte = intel_hdcp_gsc_msg_send(i915, (u8 *)&verify_lprime_in,
 318                                        sizeof(verify_lprime_in),
 319                                        (u8 *)&verify_lprime_out,
 320                                        sizeof(verify_lprime_out));
 321         if (byte < 0) {
 322                 drm_dbg_kms(&i915->drm, "intel_hdcp_gsc_msg_send failed. %zd\n", byte);
 323                 return byte;
 324         }
 325
 326         if (verify_lprime_out.header.status != FW_HDCP_STATUS_SUCCESS) {
 327                 drm_dbg_kms(&i915->drm, "FW cmd 0x%08X failed. status: 0x%X\n",
 328                             WIRED_VALIDATE_LOCALITY,
 329                             verify_lprime_out.header.status);
 330                 return -EIO;
 331         }
 332
 333         return 0;
 334 }
 335
 336 static int gsc_hdcp_get_session_key(struct device *dev,
 337                                     struct hdcp_port_data *data,
 338                                     struct hdcp2_ske_send_eks *ske_data)
 339 {
 340         struct wired_cmd_get_session_key_in get_skey_in = { { 0 } };
 341         struct wired_cmd_get_session_key_out get_skey_out = { { 0 } };
 342         struct drm_i915_private *i915;
 343         ssize_t byte;
 344
 345         if (!dev || !data || !ske_data)
 346                 return -EINVAL;
 347
 348         i915 = kdev_to_i915(dev);
 349         if (!i915) {
 350                 dev_err(dev, "DRM not initialized, aborting HDCP.\n");
 351                 return -ENODEV;
 352         }
 353
 354         get_skey_in.header.api_version = HDCP_API_VERSION;
 355         get_skey_in.header.command_id = WIRED_GET_SESSION_KEY;
 356         get_skey_in.header.status = FW_HDCP_STATUS_SUCCESS;
 357         get_skey_in.header.buffer_len = WIRED_CMD_BUF_LEN_GET_SESSION_KEY_IN;
 358
 359         get_skey_in.port.integrated_port_type = data->port_type;
 360         get_skey_in.port.physical_port = (u8)data->hdcp_ddi;
 361         get_skey_in.port.attached_transcoder = (u8)data->hdcp_transcoder;
 362
 363         byte = intel_hdcp_gsc_msg_send(i915, (u8 *)&get_skey_in, sizeof(get_skey_in),
 364                                        (u8 *)&get_skey_out, sizeof(get_skey_out));
 365         if (byte < 0) {
 366                 drm_dbg_kms(&i915->drm, "intel_hdcp_gsc_msg_send failed. %zd\n", byte);
 367                 return byte;
 368         }
 369
 370         if (get_skey_out.header.status != FW_HDCP_STATUS_SUCCESS) {
 371                 drm_dbg_kms(&i915->drm, "FW cmd 0x%08X failed. status: 0x%X\n",
 372                             WIRED_GET_SESSION_KEY, get_skey_out.header.status);
 373                 return -EIO;
 374         }
 375
 376         ske_data->msg_id = HDCP_2_2_SKE_SEND_EKS;
 377         memcpy(ske_data->e_dkey_ks, get_skey_out.e_dkey_ks,
 378                HDCP_2_2_E_DKEY_KS_LEN);
 379         memcpy(ske_data->riv, get_skey_out.r_iv, HDCP_2_2_RIV_LEN);
 380
 381         return 0;
 382 }
 383
 384 static int
 385 gsc_hdcp_repeater_check_flow_prepare_ack(struct device *dev,
 386                                          struct hdcp_port_data *data,
 387                                          struct hdcp2_rep_send_receiverid_list
 388                                                         *rep_topology,
 389                                          struct hdcp2_rep_send_ack
 390                                                         *rep_send_ack)
 391 {
 392         struct wired_cmd_verify_repeater_in verify_repeater_in = { { 0 } };
 393         struct wired_cmd_verify_repeater_out verify_repeater_out = { { 0 } };
 394         struct drm_i915_private *i915;
 395         ssize_t byte;
 396
 397         if (!dev || !rep_topology || !rep_send_ack || !data)
 398                 return -EINVAL;
 399
 400         i915 = kdev_to_i915(dev);
 401         if (!i915) {
 402                 dev_err(dev, "DRM not initialized, aborting HDCP.\n");
 403                 return -ENODEV;
 404         }
 405
 406         verify_repeater_in.header.api_version = HDCP_API_VERSION;
 407         verify_repeater_in.header.command_id = WIRED_VERIFY_REPEATER;
 408         verify_repeater_in.header.status = FW_HDCP_STATUS_SUCCESS;
 409         verify_repeater_in.header.buffer_len =
 410                                         WIRED_CMD_BUF_LEN_VERIFY_REPEATER_IN;
 411
 412         verify_repeater_in.port.integrated_port_type = data->port_type;
 413         verify_repeater_in.port.physical_port = (u8)data->hdcp_ddi;
 414         verify_repeater_in.port.attached_transcoder = (u8)data->hdcp_transcoder;
 415
 416         memcpy(verify_repeater_in.rx_info, rep_topology->rx_info,
 417                HDCP_2_2_RXINFO_LEN);
 418         memcpy(verify_repeater_in.seq_num_v, rep_topology->seq_num_v,
 419                HDCP_2_2_SEQ_NUM_LEN);
 420         memcpy(verify_repeater_in.v_prime, rep_topology->v_prime,
 421                HDCP_2_2_V_PRIME_HALF_LEN);
 422         memcpy(verify_repeater_in.receiver_ids, rep_topology->receiver_ids,
 423                HDCP_2_2_RECEIVER_IDS_MAX_LEN);
 424
 425         byte = intel_hdcp_gsc_msg_send(i915, (u8 *)&verify_repeater_in,
 426                                        sizeof(verify_repeater_in),
 427                                        (u8 *)&verify_repeater_out,
 428                                        sizeof(verify_repeater_out));
 429         if (byte < 0) {
 430                 drm_dbg_kms(&i915->drm, "intel_hdcp_gsc_msg_send failed. %zd\n", byte);
 431                 return byte;
 432         }
 433
 434         if (verify_repeater_out.header.status != FW_HDCP_STATUS_SUCCESS) {
 435                 drm_dbg_kms(&i915->drm, "FW cmd 0x%08X failed. status: 0x%X\n",
 436                             WIRED_VERIFY_REPEATER,
 437                             verify_repeater_out.header.status);
 438                 return -EIO;
 439         }
 440
 441         memcpy(rep_send_ack->v, verify_repeater_out.v,
 442                HDCP_2_2_V_PRIME_HALF_LEN);
 443         rep_send_ack->msg_id = HDCP_2_2_REP_SEND_ACK;
 444
 445         return 0;
 446 }
 447
 448 static int gsc_hdcp_verify_mprime(struct device *dev,
 449                                   struct hdcp_port_data *data,
 450                                   struct hdcp2_rep_stream_ready *stream_ready)
 451 {
 452         struct wired_cmd_repeater_auth_stream_req_in *verify_mprime_in;
 453         struct wired_cmd_repeater_auth_stream_req_out
 454                                         verify_mprime_out = { { 0 } };
 455         struct drm_i915_private *i915;
 456         ssize_t byte;
 457         size_t cmd_size;
 458
 459         if (!dev || !stream_ready || !data)
 460                 return -EINVAL;
 461
 462         i915 = kdev_to_i915(dev);
 463         if (!i915) {
 464                 dev_err(dev, "DRM not initialized, aborting HDCP.\n");
 465                 return -ENODEV;
 466         }
 467
 468         cmd_size = struct_size(verify_mprime_in, streams, data->k);
 469         if (cmd_size == SIZE_MAX)
 470                 return -EINVAL;
 471
 472         verify_mprime_in = kzalloc(cmd_size, GFP_KERNEL);
 473         if (!verify_mprime_in)
 474                 return -ENOMEM;
 475
 476         verify_mprime_in->header.api_version = HDCP_API_VERSION;
 477         verify_mprime_in->header.command_id = WIRED_REPEATER_AUTH_STREAM_REQ;
 478         verify_mprime_in->header.status = FW_HDCP_STATUS_SUCCESS;
 479         verify_mprime_in->header.buffer_len = cmd_size  - sizeof(verify_mprime_in->header);
 480
 481         verify_mprime_in->port.integrated_port_type = data->port_type;
 482         verify_mprime_in->port.physical_port = (u8)data->hdcp_ddi;
 483         verify_mprime_in->port.attached_transcoder = (u8)data->hdcp_transcoder;
 484
 485         memcpy(verify_mprime_in->m_prime, stream_ready->m_prime, HDCP_2_2_MPRIME_LEN);
 486         drm_hdcp_cpu_to_be24(verify_mprime_in->seq_num_m, data->seq_num_m);
 487
 488         memcpy(verify_mprime_in->streams, data->streams,
 489                array_size(data->k, sizeof(*data->streams)));
 490
 491         verify_mprime_in->k = cpu_to_be16(data->k);
 492
 493         byte = intel_hdcp_gsc_msg_send(i915, (u8 *)verify_mprime_in, cmd_size,
 494                                        (u8 *)&verify_mprime_out,
 495                                        sizeof(verify_mprime_out));
 496         kfree(verify_mprime_in);
 497         if (byte < 0) {
 498                 drm_dbg_kms(&i915->drm, "intel_hdcp_gsc_msg_send failed. %zd\n", byte);
 499                 return byte;
 500         }
 501
 502         if (verify_mprime_out.header.status != FW_HDCP_STATUS_SUCCESS) {
 503                 drm_dbg_kms(&i915->drm, "FW cmd 0x%08X failed. status: 0x%X\n",
 504                             WIRED_REPEATER_AUTH_STREAM_REQ,
 505                             verify_mprime_out.header.status);
 506                 return -EIO;
 507         }
 508
 509         return 0;
 510 }
 511
 512 static int gsc_hdcp_enable_authentication(struct device *dev,
 513                                           struct hdcp_port_data *data)
 514 {
 515         struct wired_cmd_enable_auth_in enable_auth_in = { { 0 } };
 516         struct wired_cmd_enable_auth_out enable_auth_out = { { 0 } };
 517         struct drm_i915_private *i915;
 518         ssize_t byte;
 519
 520         if (!dev || !data)
 521                 return -EINVAL;
 522
 523         i915 = kdev_to_i915(dev);
 524         if (!i915) {
 525                 dev_err(dev, "DRM not initialized, aborting HDCP.\n");
 526                 return -ENODEV;
 527         }
 528
 529         enable_auth_in.header.api_version = HDCP_API_VERSION;
 530         enable_auth_in.header.command_id = WIRED_ENABLE_AUTH;
 531         enable_auth_in.header.status = FW_HDCP_STATUS_SUCCESS;
 532         enable_auth_in.header.buffer_len = WIRED_CMD_BUF_LEN_ENABLE_AUTH_IN;
 533
 534         enable_auth_in.port.integrated_port_type = data->port_type;
 535         enable_auth_in.port.physical_port = (u8)data->hdcp_ddi;
 536         enable_auth_in.port.attached_transcoder = (u8)data->hdcp_transcoder;
 537         enable_auth_in.stream_type = data->streams[0].stream_type;
 538
 539         byte = intel_hdcp_gsc_msg_send(i915, (u8 *)&enable_auth_in,
 540                                        sizeof(enable_auth_in),
 541                                        (u8 *)&enable_auth_out,
 542                                        sizeof(enable_auth_out));
 543         if (byte < 0) {
 544                 drm_dbg_kms(&i915->drm, "intel_hdcp_gsc_msg_send failed. %zd\n", byte);
 545                 return byte;
 546         }
 547
 548         if (enable_auth_out.header.status != FW_HDCP_STATUS_SUCCESS) {
 549                 drm_dbg_kms(&i915->drm, "FW cmd 0x%08X failed. status: 0x%X\n",
 550                             WIRED_ENABLE_AUTH, enable_auth_out.header.status);
 551                 return -EIO;
 552         }
 553
 554         return 0;
 555 }
 556
 557 static int
 558 gsc_hdcp_close_session(struct device *dev, struct hdcp_port_data *data)
 559 {
 560         struct wired_cmd_close_session_in session_close_in = { { 0 } };
 561         struct wired_cmd_close_session_out session_close_out = { { 0 } };
 562         struct drm_i915_private *i915;
 563         ssize_t byte;
 564
 565         if (!dev || !data)
 566                 return -EINVAL;
 567
 568         i915 = kdev_to_i915(dev);
 569         if (!i915) {
 570                 dev_err(dev, "DRM not initialized, aborting HDCP.\n");
 571                 return -ENODEV;
 572         }
 573
 574         session_close_in.header.api_version = HDCP_API_VERSION;
 575         session_close_in.header.command_id = WIRED_CLOSE_SESSION;
 576         session_close_in.header.status = FW_HDCP_STATUS_SUCCESS;
 577         session_close_in.header.buffer_len =
 578                                 WIRED_CMD_BUF_LEN_CLOSE_SESSION_IN;
 579
 580         session_close_in.port.integrated_port_type = data->port_type;
 581         session_close_in.port.physical_port = (u8)data->hdcp_ddi;
 582         session_close_in.port.attached_transcoder = (u8)data->hdcp_transcoder;
 583
 584         byte = intel_hdcp_gsc_msg_send(i915, (u8 *)&session_close_in,
 585                                        sizeof(session_close_in),
 586                                        (u8 *)&session_close_out,
 587                                        sizeof(session_close_out));
 588         if (byte < 0) {
 589                 drm_dbg_kms(&i915->drm, "intel_hdcp_gsc_msg_send failed. %zd\n", byte);
 590                 return byte;
 591         }
 592
 593         if (session_close_out.header.status != FW_HDCP_STATUS_SUCCESS) {
 594                 drm_dbg_kms(&i915->drm, "Session Close Failed. status: 0x%X\n",
 595                             session_close_out.header.status);
 596                 return -EIO;
 597         }
 598
 599         return 0;
 600 }
 601
 602 static const struct i915_hdcp_ops gsc_hdcp_ops = {
 603         .initiate_hdcp2_session = gsc_hdcp_initiate_session,
 604         .verify_receiver_cert_prepare_km =
 605                                 gsc_hdcp_verify_receiver_cert_prepare_km,
 606         .verify_hprime = gsc_hdcp_verify_hprime,
 607         .store_pairing_info = gsc_hdcp_store_pairing_info,
 608         .initiate_locality_check = gsc_hdcp_initiate_locality_check,
 609         .verify_lprime = gsc_hdcp_verify_lprime,
 610         .get_session_key = gsc_hdcp_get_session_key,
 611         .repeater_check_flow_prepare_ack =
 612                                 gsc_hdcp_repeater_check_flow_prepare_ack,
 613         .verify_mprime = gsc_hdcp_verify_mprime,
 614         .enable_hdcp_authentication = gsc_hdcp_enable_authentication,
 615         .close_hdcp_session = gsc_hdcp_close_session,
 616 };
 617
 618 /*This function helps allocate memory for the command that we will send to gsc cs */
 619 static int intel_hdcp_gsc_initialize_message(struct drm_i915_private *i915,
 620                                              struct intel_hdcp_gsc_message *hdcp_message)
 621 {
 622         struct intel_gt *gt = i915->media_gt;
 623         struct drm_i915_gem_object *obj = NULL;
 624         struct i915_vma *vma = NULL;
 625         void *cmd_in, *cmd_out;
 626         int err;
 627
 628         /* allocate object of two page for HDCP command memory and store it */
 629         obj = i915_gem_object_create_shmem(i915, 2 * PAGE_SIZE);
 630
 631         if (IS_ERR(obj)) {
 632                 drm_err(&i915->drm, "Failed to allocate HDCP streaming command!\n");
 633                 return PTR_ERR(obj);
 634         }
 635
 636         cmd_in = i915_gem_object_pin_map_unlocked(obj, intel_gt_coherent_map_type(gt, obj, true));
 637         if (IS_ERR(cmd_in)) {
 638                 drm_err(&i915->drm, "Failed to map gsc message page!\n");
 639                 err = PTR_ERR(cmd_in);
 640                 goto out_unpin;
 641         }
 642
 643         cmd_out = cmd_in + PAGE_SIZE;
 644
 645         vma = i915_vma_instance(obj, &gt->ggtt->vm, NULL);
 646         if (IS_ERR(vma)) {
 647                 err = PTR_ERR(vma);
 648                 goto out_unmap;
 649         }
 650
 651         err = i915_vma_pin(vma, 0, 0, PIN_GLOBAL);
 652         if (err)
 653                 goto out_unmap;
 654
 655         memset(cmd_in, 0, obj->base.size);
 656
 657         hdcp_message->hdcp_cmd_in = cmd_in;
 658         hdcp_message->hdcp_cmd_out = cmd_out;
 659         hdcp_message->vma = vma;
 660
 661         return 0;
 662
 663 out_unmap:
 664         i915_gem_object_unpin_map(obj);
 665 out_unpin:
 666         i915_gem_object_put(obj);
 667         return err;
 668 }
 669
 670 static int intel_hdcp_gsc_hdcp2_init(struct drm_i915_private *i915)
 671 {
 672         struct intel_hdcp_gsc_message *hdcp_message;
 673         int ret;
 674
 675         hdcp_message = kzalloc(sizeof(*hdcp_message), GFP_KERNEL);
 676
 677         if (!hdcp_message)
 678                 return -ENOMEM;
 679
 680         /*
 681          * NOTE: No need to lock the comp mutex here as it is already
 682          * going to be taken before this function called
 683          */
 684         i915->display.hdcp.hdcp_message = hdcp_message;
 685         ret = intel_hdcp_gsc_initialize_message(i915, hdcp_message);
 686
 687         if (ret)
 688                 drm_err(&i915->drm, "Could not initialize hdcp_message\n");
 689
 690         return ret;
 691 }
 692
 693 static void intel_hdcp_gsc_free_message(struct drm_i915_private *i915)
 694 {
 695         struct intel_hdcp_gsc_message *hdcp_message =
 696                                         i915->display.hdcp.hdcp_message;
 697
 698         hdcp_message->hdcp_cmd_in = NULL;
 699         hdcp_message->hdcp_cmd_out = NULL;
 700         i915_vma_unpin_and_release(&hdcp_message->vma, I915_VMA_RELEASE_MAP);
 701         kfree(hdcp_message);
 702 }
 703
 704 int intel_hdcp_gsc_init(struct drm_i915_private *i915)
 705 {
 706         struct i915_hdcp_arbiter *data;
 707         int ret;
 708
 709         data = kzalloc(sizeof(struct i915_hdcp_arbiter), GFP_KERNEL);
 710         if (!data)
 711                 return -ENOMEM;
 712
 713         mutex_lock(&i915->display.hdcp.hdcp_mutex);
 714         i915->display.hdcp.arbiter = data;
 715         i915->display.hdcp.arbiter->hdcp_dev = i915->drm.dev;
 716         i915->display.hdcp.arbiter->ops = &gsc_hdcp_ops;
 717         ret = intel_hdcp_gsc_hdcp2_init(i915);
 718         mutex_unlock(&i915->display.hdcp.hdcp_mutex);
 719
 720         return ret;
 721 }
 722
 723 void intel_hdcp_gsc_fini(struct drm_i915_private *i915)
 724 {
 725         intel_hdcp_gsc_free_message(i915);
 726         kfree(i915->display.hdcp.arbiter);
 727 }
 728
 729 static int intel_gsc_send_sync(struct drm_i915_private *i915,
 730                                struct intel_gsc_mtl_header *header_in,
 731                                struct intel_gsc_mtl_header *header_out,
 732                                u64 addr_in, u64 addr_out,
 733                                size_t msg_out_len)
 734 {
 735         struct intel_gt *gt = i915->media_gt;
 736         int ret;
 737
 738         ret = intel_gsc_uc_heci_cmd_submit_packet(&gt->uc.gsc, addr_in,
 739                                                   header_in->message_size,
 740                                                   addr_out,
 741                                                   msg_out_len + sizeof(*header_out));
 742         if (ret) {
 743                 drm_err(&i915->drm, "failed to send gsc HDCP msg (%d)\n", ret);
 744                 return ret;
 745         }
 746
 747         /*
 748          * Checking validity marker and header status to see if some error has
 749          * blocked us from sending message to gsc cs
 750          */
 751         if (header_out->validity_marker != GSC_HECI_VALIDITY_MARKER) {
 752                 drm_err(&i915->drm, "invalid validity marker\n");
 753                 return -EINVAL;
 754         }
 755
 756         if (header_out->status != 0) {
 757                 drm_err(&i915->drm, "header status indicates error %d\n",
 758                         header_out->status);
 759                 return -EINVAL;
 760         }
 761
 762         if (header_out->flags & GSC_OUTFLAG_MSG_PENDING) {
 763                 header_in->gsc_message_handle = header_out->gsc_message_handle;
 764                 return -EAGAIN;
 765         }
 766
 767         return 0;
 768 }
 769
 770 /*
 771  * This function can now be used for sending requests and will also handle
 772  * receipt of reply messages hence no different function of message retrieval
 773  * is required. We will initialize intel_hdcp_gsc_message structure then add
 774  * gsc cs memory header as stated in specs after which the normal HDCP payload
 775  * will follow
 776  */
 777 ssize_t intel_hdcp_gsc_msg_send(struct drm_i915_private *i915, u8 *msg_in,
 778                                 size_t msg_in_len, u8 *msg_out,
 779                                 size_t msg_out_len)
 780 {
 781         struct intel_gt *gt = i915->media_gt;
 782         struct intel_gsc_mtl_header *header_in, *header_out;
 783         const size_t max_msg_size = PAGE_SIZE - sizeof(*header_in);
 784         struct intel_hdcp_gsc_message *hdcp_message;
 785         u64 addr_in, addr_out, host_session_id;
 786         u32 reply_size, msg_size_in, msg_size_out;
 787         int ret, tries = 0;
 788
 789         if (!intel_uc_uses_gsc_uc(&gt->uc))
 790                 return -ENODEV;
 791
 792         if (msg_in_len > max_msg_size || msg_out_len > max_msg_size)
 793                 return -ENOSPC;
 794
 795         msg_size_in = msg_in_len + sizeof(*header_in);
 796         msg_size_out = msg_out_len + sizeof(*header_out);
 797         hdcp_message = i915->display.hdcp.hdcp_message;
 798         header_in = hdcp_message->hdcp_cmd_in;
 799         header_out = hdcp_message->hdcp_cmd_out;
 800         addr_in = i915_ggtt_offset(hdcp_message->vma);
 801         addr_out = addr_in + PAGE_SIZE;
 802
 803         memset(header_in, 0, msg_size_in);
 804         memset(header_out, 0, msg_size_out);
 805         get_random_bytes(&host_session_id, sizeof(u64));
 806         intel_gsc_uc_heci_cmd_emit_mtl_header(header_in, HECI_MEADDRESS_HDCP,
 807                                               msg_size_in, host_session_id);
 808         memcpy(hdcp_message->hdcp_cmd_in + sizeof(*header_in), msg_in, msg_in_len);
 809
 810         /*
 811          * Keep sending request in case the pending bit is set no need to add
 812          * message handle as we are using same address hence loc. of header is
 813          * same and it will contain the message handle. we will send the message
 814          * 20 times each message 50 ms apart
 815          */
 816         do {
 817                 ret = intel_gsc_send_sync(i915, header_in, header_out, addr_in,
 818                                           addr_out, msg_out_len);
 819
 820                 /* Only try again if gsc says so */
 821                 if (ret != -EAGAIN)
 822                         break;
 823
 824                 msleep(50);
 825
 826         } while (++tries < 20);
 827
 828         if (ret)
 829                 goto err;
 830
 831         /* we use the same mem for the reply, so header is in the same loc */
 832         reply_size = header_out->message_size - sizeof(*header_out);
 833         if (reply_size > msg_out_len) {
 834                 drm_warn(&i915->drm, "caller with insufficient HDCP reply size %u (%d)\n",
 835                          reply_size, (u32)msg_out_len);
 836                 reply_size = msg_out_len;
 837         } else if (reply_size != msg_out_len) {
 838                 drm_dbg_kms(&i915->drm, "caller unexpected HCDP reply size %u (%d)\n",
 839                             reply_size, (u32)msg_out_len);
 840         }
 841
 842         memcpy(msg_out, hdcp_message->hdcp_cmd_out + sizeof(*header_out), msg_out_len);
 843
 844 err:
 845         return ret;
 846 }