drm/i915/hdcp: pass the context to the HDCP GSC message interface

The opaque HDCP GSC context nicely abstracts the differences between
drivers. Pass that instead of struct drm_i915_private or struct
xe_device to intel_hdcp_gsc_msg_send(). We can store the driver specific
data in the context.

This lets us drop the dependency on i915_drv.h from
intel_hdcp_gsc_message.c.

Cc: Suraj Kandpal <suraj.kandpal@intel.com>
Reviewed-by: Suraj Kandpal <suraj.kandpal@intel.com>
Link: https://lore.kernel.org/r/df1653212f9014e717701b017e78e0017884b870.1745524803.git.jani.nikula@intel.com
Signed-off-by: Jani Nikula <jani.nikula@intel.com>

diff --git a/drivers/gpu/drm/i915/display/intel_hdcp_gsc.c b/drivers/gpu/drm/i915/display/intel_hdcp_gsc.c
index efcd3a4b41edf8cb0780c253ce9afbc99db46d77..77c4df6c6181370621bd58ddd722afe52a72643f 100644 (file)
--- a/drivers/gpu/drm/i915/display/intel_hdcp_gsc.c
+++ b/drivers/gpu/drm/i915/display/intel_hdcp_gsc.c
@@ -13,6 +13,7 @@
 #include "intel_hdcp_gsc.h"
 
 struct intel_hdcp_gsc_context {
+       struct drm_i915_private *i915;
        struct i915_vma *vma;
        void *hdcp_cmd_in;
        void *hdcp_cmd_out;
@@ -80,6 +81,7 @@ static int intel_hdcp_gsc_initialize_message(struct drm_i915_private *i915,
        gsc_context->hdcp_cmd_in = cmd_in;
        gsc_context->hdcp_cmd_out = cmd_out;
        gsc_context->vma = vma;
+       gsc_context->i915 = i915;
 
        return 0;
 
@@ -171,14 +173,14 @@ static int intel_gsc_send_sync(struct drm_i915_private *i915,
  * gsc cs memory header as stated in specs after which the normal HDCP payload
  * will follow
  */
-ssize_t intel_hdcp_gsc_msg_send(struct drm_i915_private *i915, u8 *msg_in,
-                               size_t msg_in_len, u8 *msg_out,
-                               size_t msg_out_len)
+ssize_t intel_hdcp_gsc_msg_send(struct intel_hdcp_gsc_context *gsc_context,
+                               u8 *msg_in, size_t msg_in_len,
+                               u8 *msg_out, size_t msg_out_len)
 {
+       struct drm_i915_private *i915 = gsc_context->i915;
        struct intel_gt *gt = i915->media_gt;
        struct intel_gsc_mtl_header *header_in, *header_out;
        const size_t max_msg_size = PAGE_SIZE - sizeof(*header_in);
-       struct intel_hdcp_gsc_context *gsc_context;
        u64 addr_in, addr_out, host_session_id;
        u32 reply_size, msg_size_in, msg_size_out;
        int ret, tries = 0;
@@ -191,7 +193,6 @@ ssize_t intel_hdcp_gsc_msg_send(struct drm_i915_private *i915, u8 *msg_in,
 
        msg_size_in = msg_in_len + sizeof(*header_in);
        msg_size_out = msg_out_len + sizeof(*header_out);
-       gsc_context = i915->display.hdcp.gsc_context;
        header_in = gsc_context->hdcp_cmd_in;
        header_out = gsc_context->hdcp_cmd_out;
        addr_in = i915_ggtt_offset(gsc_context->vma);

diff --git a/drivers/gpu/drm/i915/display/intel_hdcp_gsc.h b/drivers/gpu/drm/i915/display/intel_hdcp_gsc.h
index 227c00a837d80c3f403d7dd8dd0f8e85a9537b6e..7133e631a938d45a8f1f872792b4df0a4fe7650f 100644 (file)
--- a/drivers/gpu/drm/i915/display/intel_hdcp_gsc.h
+++ b/drivers/gpu/drm/i915/display/intel_hdcp_gsc.h
@@ -9,14 +9,13 @@
 #include <linux/err.h>
 #include <linux/types.h>
 
-struct drm_i915_private;
 struct intel_display;
 struct intel_hdcp_gsc_context;
 
 bool intel_hdcp_gsc_cs_required(struct intel_display *display);
-ssize_t intel_hdcp_gsc_msg_send(struct drm_i915_private *i915, u8 *msg_in,
-                               size_t msg_in_len, u8 *msg_out,
-                               size_t msg_out_len);
+ssize_t intel_hdcp_gsc_msg_send(struct intel_hdcp_gsc_context *gsc_context,
+                               u8 *msg_in, size_t msg_in_len,
+                               u8 *msg_out, size_t msg_out_len);
 bool intel_hdcp_gsc_check_status(struct intel_display *display);
 
 struct intel_hdcp_gsc_context *intel_hdcp_gsc_context_alloc(struct intel_display *display);

diff --git a/drivers/gpu/drm/i915/display/intel_hdcp_gsc_message.c b/drivers/gpu/drm/i915/display/intel_hdcp_gsc_message.c
index 92143226858c58234e70cc65080eb07727069f8c..d87f61d773ca821905a12e1380b8016c85aea241 100644 (file)
--- a/drivers/gpu/drm/i915/display/intel_hdcp_gsc_message.c
+++ b/drivers/gpu/drm/i915/display/intel_hdcp_gsc_message.c
@@ -4,9 +4,11 @@
  */
 
 #include <linux/err.h>
+
+#include <drm/drm_print.h>
 #include <drm/intel/i915_hdcp_interface.h>
 
-#include "i915_drv.h"
+#include "intel_display_core.h"
 #include "intel_display_types.h"
 #include "intel_hdcp_gsc.h"
 #include "intel_hdcp_gsc_message.h"
@@ -17,8 +19,8 @@ intel_hdcp_gsc_initiate_session(struct device *dev, struct hdcp_port_data *data,
 {
        struct wired_cmd_initiate_hdcp2_session_in session_init_in = {};
        struct wired_cmd_initiate_hdcp2_session_out session_init_out = {};
+       struct intel_hdcp_gsc_context *gsc_context;
        struct intel_display *display;
-       struct drm_i915_private *i915;
        ssize_t byte;
 
        if (!dev || !data || !ake_data)
@@ -29,7 +31,7 @@ intel_hdcp_gsc_initiate_session(struct device *dev, struct hdcp_port_data *data,
                dev_err(dev, "DRM not initialized, aborting HDCP.\n");
                return -ENODEV;
        }
-       i915 = to_i915(display->drm);
+       gsc_context = display->hdcp.gsc_context;
 
        session_init_in.header.api_version = HDCP_API_VERSION;
        session_init_in.header.command_id = WIRED_INITIATE_HDCP2_SESSION;
@@ -42,7 +44,7 @@ intel_hdcp_gsc_initiate_session(struct device *dev, struct hdcp_port_data *data,
        session_init_in.port.attached_transcoder = (u8)data->hdcp_transcoder;
        session_init_in.protocol = data->protocol;
 
-       byte = intel_hdcp_gsc_msg_send(i915, (u8 *)&session_init_in,
+       byte = intel_hdcp_gsc_msg_send(gsc_context, (u8 *)&session_init_in,
                                       sizeof(session_init_in),
                                       (u8 *)&session_init_out,
                                       sizeof(session_init_out));
@@ -76,8 +78,8 @@ intel_hdcp_gsc_verify_receiver_cert_prepare_km(struct device *dev,
 {
        struct wired_cmd_verify_receiver_cert_in verify_rxcert_in = {};
        struct wired_cmd_verify_receiver_cert_out verify_rxcert_out = {};
+       struct intel_hdcp_gsc_context *gsc_context;
        struct intel_display *display;
-       struct drm_i915_private *i915;
        ssize_t byte;
 
        if (!dev || !data || !rx_cert || !km_stored || !ek_pub_km || !msg_sz)
@@ -88,7 +90,7 @@ intel_hdcp_gsc_verify_receiver_cert_prepare_km(struct device *dev,
                dev_err(dev, "DRM not initialized, aborting HDCP.\n");
                return -ENODEV;
        }
-       i915 = to_i915(display->drm);
+       gsc_context = display->hdcp.gsc_context;
 
        verify_rxcert_in.header.api_version = HDCP_API_VERSION;
        verify_rxcert_in.header.command_id = WIRED_VERIFY_RECEIVER_CERT;
@@ -104,7 +106,7 @@ intel_hdcp_gsc_verify_receiver_cert_prepare_km(struct device *dev,
        memcpy(verify_rxcert_in.r_rx, &rx_cert->r_rx, HDCP_2_2_RRX_LEN);
        memcpy(verify_rxcert_in.rx_caps, rx_cert->rx_caps, HDCP_2_2_RXCAPS_LEN);
 
-       byte = intel_hdcp_gsc_msg_send(i915, (u8 *)&verify_rxcert_in,
+       byte = intel_hdcp_gsc_msg_send(gsc_context, (u8 *)&verify_rxcert_in,
                                       sizeof(verify_rxcert_in),
                                       (u8 *)&verify_rxcert_out,
                                       sizeof(verify_rxcert_out));
@@ -141,8 +143,8 @@ intel_hdcp_gsc_verify_hprime(struct device *dev, struct hdcp_port_data *data,
 {
        struct wired_cmd_ake_send_hprime_in send_hprime_in = {};
        struct wired_cmd_ake_send_hprime_out send_hprime_out = {};
+       struct intel_hdcp_gsc_context *gsc_context;
        struct intel_display *display;
-       struct drm_i915_private *i915;
        ssize_t byte;
 
        if (!dev || !data || !rx_hprime)
@@ -153,7 +155,7 @@ intel_hdcp_gsc_verify_hprime(struct device *dev, struct hdcp_port_data *data,
                dev_err(dev, "DRM not initialized, aborting HDCP.\n");
                return -ENODEV;
        }
-       i915 = to_i915(display->drm);
+       gsc_context = display->hdcp.gsc_context;
 
        send_hprime_in.header.api_version = HDCP_API_VERSION;
        send_hprime_in.header.command_id = WIRED_AKE_SEND_HPRIME;
@@ -167,7 +169,7 @@ intel_hdcp_gsc_verify_hprime(struct device *dev, struct hdcp_port_data *data,
        memcpy(send_hprime_in.h_prime, rx_hprime->h_prime,
               HDCP_2_2_H_PRIME_LEN);
 
-       byte = intel_hdcp_gsc_msg_send(i915, (u8 *)&send_hprime_in,
+       byte = intel_hdcp_gsc_msg_send(gsc_context, (u8 *)&send_hprime_in,
                                       sizeof(send_hprime_in),
                                       (u8 *)&send_hprime_out,
                                       sizeof(send_hprime_out));
@@ -191,8 +193,8 @@ intel_hdcp_gsc_store_pairing_info(struct device *dev, struct hdcp_port_data *dat
 {
        struct wired_cmd_ake_send_pairing_info_in pairing_info_in = {};
        struct wired_cmd_ake_send_pairing_info_out pairing_info_out = {};
+       struct intel_hdcp_gsc_context *gsc_context;
        struct intel_display *display;
-       struct drm_i915_private *i915;
        ssize_t byte;
 
        if (!dev || !data || !pairing_info)
@@ -203,7 +205,7 @@ intel_hdcp_gsc_store_pairing_info(struct device *dev, struct hdcp_port_data *dat
                dev_err(dev, "DRM not initialized, aborting HDCP.\n");
                return -ENODEV;
        }
-       i915 = to_i915(display->drm);
+       gsc_context = display->hdcp.gsc_context;
 
        pairing_info_in.header.api_version = HDCP_API_VERSION;
        pairing_info_in.header.command_id = WIRED_AKE_SEND_PAIRING_INFO;
@@ -218,7 +220,7 @@ intel_hdcp_gsc_store_pairing_info(struct device *dev, struct hdcp_port_data *dat
        memcpy(pairing_info_in.e_kh_km, pairing_info->e_kh_km,
               HDCP_2_2_E_KH_KM_LEN);
 
-       byte = intel_hdcp_gsc_msg_send(i915, (u8 *)&pairing_info_in,
+       byte = intel_hdcp_gsc_msg_send(gsc_context, (u8 *)&pairing_info_in,
                                       sizeof(pairing_info_in),
                                       (u8 *)&pairing_info_out,
                                       sizeof(pairing_info_out));
@@ -244,8 +246,8 @@ intel_hdcp_gsc_initiate_locality_check(struct device *dev,
 {
        struct wired_cmd_init_locality_check_in lc_init_in = {};
        struct wired_cmd_init_locality_check_out lc_init_out = {};
+       struct intel_hdcp_gsc_context *gsc_context;
        struct intel_display *display;
-       struct drm_i915_private *i915;
        ssize_t byte;
 
        if (!dev || !data || !lc_init_data)
@@ -256,7 +258,7 @@ intel_hdcp_gsc_initiate_locality_check(struct device *dev,
                dev_err(dev, "DRM not initialized, aborting HDCP.\n");
                return -ENODEV;
        }
-       i915 = to_i915(display->drm);
+       gsc_context = display->hdcp.gsc_context;
 
        lc_init_in.header.api_version = HDCP_API_VERSION;
        lc_init_in.header.command_id = WIRED_INIT_LOCALITY_CHECK;
@@ -267,7 +269,7 @@ intel_hdcp_gsc_initiate_locality_check(struct device *dev,
        lc_init_in.port.physical_port = (u8)data->hdcp_ddi;
        lc_init_in.port.attached_transcoder = (u8)data->hdcp_transcoder;
 
-       byte = intel_hdcp_gsc_msg_send(i915, (u8 *)&lc_init_in, sizeof(lc_init_in),
+       byte = intel_hdcp_gsc_msg_send(gsc_context, (u8 *)&lc_init_in, sizeof(lc_init_in),
                                       (u8 *)&lc_init_out, sizeof(lc_init_out));
        if (byte < 0) {
                drm_dbg_kms(display->drm, "intel_hdcp_gsc_msg_send failed. %zd\n", byte);
@@ -292,8 +294,8 @@ intel_hdcp_gsc_verify_lprime(struct device *dev, struct hdcp_port_data *data,
 {
        struct wired_cmd_validate_locality_in verify_lprime_in = {};
        struct wired_cmd_validate_locality_out verify_lprime_out = {};
+       struct intel_hdcp_gsc_context *gsc_context;
        struct intel_display *display;
-       struct drm_i915_private *i915;
        ssize_t byte;
 
        if (!dev || !data || !rx_lprime)
@@ -304,7 +306,7 @@ intel_hdcp_gsc_verify_lprime(struct device *dev, struct hdcp_port_data *data,
                dev_err(dev, "DRM not initialized, aborting HDCP.\n");
                return -ENODEV;
        }
-       i915 = to_i915(display->drm);
+       gsc_context = display->hdcp.gsc_context;
 
        verify_lprime_in.header.api_version = HDCP_API_VERSION;
        verify_lprime_in.header.command_id = WIRED_VALIDATE_LOCALITY;
@@ -319,7 +321,7 @@ intel_hdcp_gsc_verify_lprime(struct device *dev, struct hdcp_port_data *data,
        memcpy(verify_lprime_in.l_prime, rx_lprime->l_prime,
               HDCP_2_2_L_PRIME_LEN);
 
-       byte = intel_hdcp_gsc_msg_send(i915, (u8 *)&verify_lprime_in,
+       byte = intel_hdcp_gsc_msg_send(gsc_context, (u8 *)&verify_lprime_in,
                                       sizeof(verify_lprime_in),
                                       (u8 *)&verify_lprime_out,
                                       sizeof(verify_lprime_out));
@@ -345,8 +347,8 @@ intel_hdcp_gsc_get_session_key(struct device *dev,
 {
        struct wired_cmd_get_session_key_in get_skey_in = {};
        struct wired_cmd_get_session_key_out get_skey_out = {};
+       struct intel_hdcp_gsc_context *gsc_context;
        struct intel_display *display;
-       struct drm_i915_private *i915;
        ssize_t byte;
 
        if (!dev || !data || !ske_data)
@@ -357,7 +359,7 @@ intel_hdcp_gsc_get_session_key(struct device *dev,
                dev_err(dev, "DRM not initialized, aborting HDCP.\n");
                return -ENODEV;
        }
-       i915 = to_i915(display->drm);
+       gsc_context = display->hdcp.gsc_context;
 
        get_skey_in.header.api_version = HDCP_API_VERSION;
        get_skey_in.header.command_id = WIRED_GET_SESSION_KEY;
@@ -368,7 +370,7 @@ intel_hdcp_gsc_get_session_key(struct device *dev,
        get_skey_in.port.physical_port = (u8)data->hdcp_ddi;
        get_skey_in.port.attached_transcoder = (u8)data->hdcp_transcoder;
 
-       byte = intel_hdcp_gsc_msg_send(i915, (u8 *)&get_skey_in, sizeof(get_skey_in),
+       byte = intel_hdcp_gsc_msg_send(gsc_context, (u8 *)&get_skey_in, sizeof(get_skey_in),
                                       (u8 *)&get_skey_out, sizeof(get_skey_out));
        if (byte < 0) {
                drm_dbg_kms(display->drm, "intel_hdcp_gsc_msg_send failed. %zd\n", byte);
@@ -399,8 +401,8 @@ intel_hdcp_gsc_repeater_check_flow_prepare_ack(struct device *dev,
 {
        struct wired_cmd_verify_repeater_in verify_repeater_in = {};
        struct wired_cmd_verify_repeater_out verify_repeater_out = {};
+       struct intel_hdcp_gsc_context *gsc_context;
        struct intel_display *display;
-       struct drm_i915_private *i915;
        ssize_t byte;
 
        if (!dev || !rep_topology || !rep_send_ack || !data)
@@ -411,7 +413,7 @@ intel_hdcp_gsc_repeater_check_flow_prepare_ack(struct device *dev,
                dev_err(dev, "DRM not initialized, aborting HDCP.\n");
                return -ENODEV;
        }
-       i915 = to_i915(display->drm);
+       gsc_context = display->hdcp.gsc_context;
 
        verify_repeater_in.header.api_version = HDCP_API_VERSION;
        verify_repeater_in.header.command_id = WIRED_VERIFY_REPEATER;
@@ -432,7 +434,7 @@ intel_hdcp_gsc_repeater_check_flow_prepare_ack(struct device *dev,
        memcpy(verify_repeater_in.receiver_ids, rep_topology->receiver_ids,
               HDCP_2_2_RECEIVER_IDS_MAX_LEN);
 
-       byte = intel_hdcp_gsc_msg_send(i915, (u8 *)&verify_repeater_in,
+       byte = intel_hdcp_gsc_msg_send(gsc_context, (u8 *)&verify_repeater_in,
                                       sizeof(verify_repeater_in),
                                       (u8 *)&verify_repeater_out,
                                       sizeof(verify_repeater_out));
@@ -462,8 +464,8 @@ intel_hdcp_gsc_verify_mprime(struct device *dev,
 {
        struct wired_cmd_repeater_auth_stream_req_in *verify_mprime_in;
        struct wired_cmd_repeater_auth_stream_req_out verify_mprime_out = {};
+       struct intel_hdcp_gsc_context *gsc_context;
        struct intel_display *display;
-       struct drm_i915_private *i915;
        ssize_t byte;
        size_t cmd_size;
 
@@ -475,7 +477,7 @@ intel_hdcp_gsc_verify_mprime(struct device *dev,
                dev_err(dev, "DRM not initialized, aborting HDCP.\n");
                return -ENODEV;
        }
-       i915 = to_i915(display->drm);
+       gsc_context = display->hdcp.gsc_context;
 
        cmd_size = struct_size(verify_mprime_in, streams, data->k);
        if (cmd_size == SIZE_MAX)
@@ -502,7 +504,7 @@ intel_hdcp_gsc_verify_mprime(struct device *dev,
 
        verify_mprime_in->k = cpu_to_be16(data->k);
 
-       byte = intel_hdcp_gsc_msg_send(i915, (u8 *)verify_mprime_in, cmd_size,
+       byte = intel_hdcp_gsc_msg_send(gsc_context, (u8 *)verify_mprime_in, cmd_size,
                                       (u8 *)&verify_mprime_out,
                                       sizeof(verify_mprime_out));
        kfree(verify_mprime_in);
@@ -526,8 +528,8 @@ static int intel_hdcp_gsc_enable_authentication(struct device *dev,
 {
        struct wired_cmd_enable_auth_in enable_auth_in = {};
        struct wired_cmd_enable_auth_out enable_auth_out = {};
+       struct intel_hdcp_gsc_context *gsc_context;
        struct intel_display *display;
-       struct drm_i915_private *i915;
        ssize_t byte;
 
        if (!dev || !data)
@@ -538,7 +540,7 @@ static int intel_hdcp_gsc_enable_authentication(struct device *dev,
                dev_err(dev, "DRM not initialized, aborting HDCP.\n");
                return -ENODEV;
        }
-       i915 = to_i915(display->drm);
+       gsc_context = display->hdcp.gsc_context;
 
        enable_auth_in.header.api_version = HDCP_API_VERSION;
        enable_auth_in.header.command_id = WIRED_ENABLE_AUTH;
@@ -550,7 +552,7 @@ static int intel_hdcp_gsc_enable_authentication(struct device *dev,
        enable_auth_in.port.attached_transcoder = (u8)data->hdcp_transcoder;
        enable_auth_in.stream_type = data->streams[0].stream_type;
 
-       byte = intel_hdcp_gsc_msg_send(i915, (u8 *)&enable_auth_in,
+       byte = intel_hdcp_gsc_msg_send(gsc_context, (u8 *)&enable_auth_in,
                                       sizeof(enable_auth_in),
                                       (u8 *)&enable_auth_out,
                                       sizeof(enable_auth_out));
@@ -573,8 +575,8 @@ intel_hdcp_gsc_close_session(struct device *dev, struct hdcp_port_data *data)
 {
        struct wired_cmd_close_session_in session_close_in = {};
        struct wired_cmd_close_session_out session_close_out = {};
+       struct intel_hdcp_gsc_context *gsc_context;
        struct intel_display *display;
-       struct drm_i915_private *i915;
        ssize_t byte;
 
        if (!dev || !data)
@@ -585,7 +587,7 @@ intel_hdcp_gsc_close_session(struct device *dev, struct hdcp_port_data *data)
                dev_err(dev, "DRM not initialized, aborting HDCP.\n");
                return -ENODEV;
        }
-       i915 = to_i915(display->drm);
+       gsc_context = display->hdcp.gsc_context;
 
        session_close_in.header.api_version = HDCP_API_VERSION;
        session_close_in.header.command_id = WIRED_CLOSE_SESSION;
@@ -597,7 +599,7 @@ intel_hdcp_gsc_close_session(struct device *dev, struct hdcp_port_data *data)
        session_close_in.port.physical_port = (u8)data->hdcp_ddi;
        session_close_in.port.attached_transcoder = (u8)data->hdcp_transcoder;
 
-       byte = intel_hdcp_gsc_msg_send(i915, (u8 *)&session_close_in,
+       byte = intel_hdcp_gsc_msg_send(gsc_context, (u8 *)&session_close_in,
                                       sizeof(session_close_in),
                                       (u8 *)&session_close_out,
                                       sizeof(session_close_out));

diff --git a/drivers/gpu/drm/xe/display/xe_hdcp_gsc.c b/drivers/gpu/drm/xe/display/xe_hdcp_gsc.c
index 16458c1ddbe6385fa8b38f571f9c95a20b3f5259..7b8237a5aeee6dbfe854d66c0cb6520b6e3b9be0 100644 (file)
--- a/drivers/gpu/drm/xe/display/xe_hdcp_gsc.c
+++ b/drivers/gpu/drm/xe/display/xe_hdcp_gsc.c
@@ -22,6 +22,7 @@
 #define HECI_MEADDRESS_HDCP 18
 
 struct intel_hdcp_gsc_context {
+       struct xe_device *xe;
        struct xe_bo *hdcp_bo;
        u64 hdcp_cmd_in;
        u64 hdcp_cmd_out;
@@ -95,6 +96,8 @@ static int intel_hdcp_gsc_initialize_message(struct intel_display *display,
        gsc_context->hdcp_bo = bo;
        gsc_context->hdcp_cmd_in = cmd_in;
        gsc_context->hdcp_cmd_out = cmd_out;
+       gsc_context->xe = xe;
+
 out:
        return ret;
 }
@@ -157,12 +160,12 @@ static int xe_gsc_send_sync(struct xe_device *xe,
        return ret;
 }
 
-ssize_t intel_hdcp_gsc_msg_send(struct xe_device *xe, u8 *msg_in,
-                               size_t msg_in_len, u8 *msg_out,
-                               size_t msg_out_len)
+ssize_t intel_hdcp_gsc_msg_send(struct intel_hdcp_gsc_context *gsc_context,
+                               u8 *msg_in, size_t msg_in_len,
+                               u8 *msg_out, size_t msg_out_len)
 {
+       struct xe_device *xe = gsc_context->xe;
        const size_t max_msg_size = PAGE_SIZE - HDCP_GSC_HEADER_SIZE;
-       struct intel_hdcp_gsc_context *gsc_context;
        u64 host_session_id;
        u32 msg_size_in, msg_size_out;
        u32 addr_out_off, addr_in_wr_off = 0;
@@ -175,7 +178,6 @@ ssize_t intel_hdcp_gsc_msg_send(struct xe_device *xe, u8 *msg_in,
 
        msg_size_in = msg_in_len + HDCP_GSC_HEADER_SIZE;
        msg_size_out = msg_out_len + HDCP_GSC_HEADER_SIZE;
-       gsc_context = xe->display.hdcp.gsc_context;
        addr_out_off = PAGE_SIZE;
 
        host_session_id = xe_gsc_create_host_session_id();