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