return 0;
 
 err_hdcp:
-       intel_hdcp_component_fini(i915);
+       intel_hdcp_component_fini(display);
 err_mode_config:
        intel_mode_config_cleanup(i915);
 
 /* part #3: call after gem init */
 int intel_display_driver_probe(struct drm_i915_private *i915)
 {
+       struct intel_display *display = &i915->display;
        int ret;
 
        if (!HAS_DISPLAY(i915))
         * the BIOS fb takeover and whatever else magic ggtt reservations
         * happen during gem/ggtt init.
         */
-       intel_hdcp_component_init(i915);
+       intel_hdcp_component_init(display);
 
        /*
         * Force all active planes to recompute their states. So that on
        /* flush any delayed tasks or pending work */
        flush_workqueue(i915->unordered_wq);
 
-       intel_hdcp_component_fini(i915);
+       intel_hdcp_component_fini(display);
 
        intel_mode_config_cleanup(i915);
 
 
 intel_dp_init_connector(struct intel_digital_port *dig_port,
                        struct intel_connector *intel_connector)
 {
+       struct intel_display *display = to_intel_display(dig_port);
        struct drm_connector *connector = &intel_connector->base;
        struct intel_dp *intel_dp = &dig_port->dp;
        struct intel_encoder *intel_encoder = &dig_port->base;
 
        intel_dp_add_properties(intel_dp, connector);
 
-       if (is_hdcp_supported(dev_priv, port) && !intel_dp_is_edp(intel_dp)) {
+       if (is_hdcp_supported(display, port) && !intel_dp_is_edp(intel_dp)) {
                int ret = intel_dp_hdcp_init(dig_port, intel_connector);
                if (ret)
                        drm_dbg_kms(&dev_priv->drm,
 
 int intel_dp_hdcp_init(struct intel_digital_port *dig_port,
                       struct intel_connector *intel_connector)
 {
-       struct drm_device *dev = intel_connector->base.dev;
-       struct drm_i915_private *dev_priv = to_i915(dev);
+       struct intel_display *display = to_intel_display(dig_port);
        struct intel_encoder *intel_encoder = &dig_port->base;
        enum port port = intel_encoder->port;
        struct intel_dp *intel_dp = &dig_port->dp;
 
-       if (!is_hdcp_supported(dev_priv, port))
+       if (!is_hdcp_supported(display, port))
                return 0;
 
        if (intel_connector->mst_port)
 
        drm_connector_put(&connector->base);
 }
 
-bool is_hdcp_supported(struct drm_i915_private *i915, enum port port)
+bool is_hdcp_supported(struct intel_display *display, enum port port)
 {
-       return DISPLAY_RUNTIME_INFO(i915)->has_hdcp &&
-               (DISPLAY_VER(i915) >= 12 || port < PORT_E);
+       return DISPLAY_RUNTIME_INFO(display)->has_hdcp &&
+               (DISPLAY_VER(display) >= 12 || port < PORT_E);
 }
 
 static int
        return 0;
 }
 
-static bool is_hdcp2_supported(struct drm_i915_private *i915)
+static bool is_hdcp2_supported(struct intel_display *display)
 {
-       struct intel_display *display = to_intel_display(&i915->drm);
+       struct drm_i915_private *i915 = to_i915(display->drm);
 
        if (intel_hdcp_gsc_cs_required(display))
                return true;
                IS_COMETLAKE(i915));
 }
 
-void intel_hdcp_component_init(struct drm_i915_private *i915)
+void intel_hdcp_component_init(struct intel_display *display)
 {
-       struct intel_display *display = to_intel_display(&i915->drm);
        int ret;
 
-       if (!is_hdcp2_supported(i915))
+       if (!is_hdcp2_supported(display))
                return;
 
        mutex_lock(&display->hdcp.hdcp_mutex);
                    struct intel_digital_port *dig_port,
                    const struct intel_hdcp_shim *shim)
 {
-       struct drm_i915_private *i915 = to_i915(connector->base.dev);
+       struct intel_display *display = to_intel_display(connector);
        struct intel_hdcp *hdcp = &connector->hdcp;
        int ret;
 
        if (!shim)
                return -EINVAL;
 
-       if (is_hdcp2_supported(i915))
+       if (is_hdcp2_supported(display))
                intel_hdcp2_init(connector, dig_port, shim);
 
-       ret =
-       drm_connector_attach_content_protection_property(&connector->base,
-                                                        hdcp->hdcp2_supported);
+       ret = drm_connector_attach_content_protection_property(&connector->base,
+                                                              hdcp->hdcp2_supported);
        if (ret) {
                hdcp->hdcp2_supported = false;
                kfree(dig_port->hdcp_port_data.streams);
                hdcp->stream_transcoder = INVALID_TRANSCODER;
        }
 
-       if (DISPLAY_VER(i915) >= 12)
+       if (DISPLAY_VER(display) >= 12)
                dig_port->hdcp_port_data.hdcp_transcoder =
                        intel_get_hdcp_transcoder(hdcp->cpu_transcoder);
 
                _intel_hdcp_enable(state, encoder, crtc_state, conn_state);
 }
 
-void intel_hdcp_component_fini(struct drm_i915_private *i915)
+void intel_hdcp_component_fini(struct intel_display *display)
 {
-       struct intel_display *display = to_intel_display(&i915->drm);
-
        mutex_lock(&display->hdcp.hdcp_mutex);
        if (!display->hdcp.comp_added) {
                mutex_unlock(&display->hdcp.hdcp_mutex);
 
 
 struct drm_connector;
 struct drm_connector_state;
-struct drm_i915_private;
 struct intel_atomic_state;
 struct intel_connector;
 struct intel_crtc_state;
+struct intel_digital_port;
+struct intel_display;
 struct intel_encoder;
 struct intel_hdcp_shim;
-struct intel_digital_port;
 enum port;
 enum transcoder;
 
                            struct intel_encoder *encoder,
                            const struct intel_crtc_state *crtc_state,
                            const struct drm_connector_state *conn_state);
-bool is_hdcp_supported(struct drm_i915_private *i915, enum port port);
+bool is_hdcp_supported(struct intel_display *display, enum port port);
 bool intel_hdcp_get_capability(struct intel_connector *connector);
 bool intel_hdcp2_get_capability(struct intel_connector *connector);
 void intel_hdcp_get_remote_capability(struct intel_connector *connector,
                                      bool *hdcp_capable,
                                      bool *hdcp2_capable);
-void intel_hdcp_component_init(struct drm_i915_private *i915);
-void intel_hdcp_component_fini(struct drm_i915_private *i915);
+void intel_hdcp_component_init(struct intel_display *display);
+void intel_hdcp_component_fini(struct intel_display *display);
 void intel_hdcp_cleanup(struct intel_connector *connector);
 void intel_hdcp_handle_cp_irq(struct intel_connector *connector);
 
 
        struct intel_hdmi *intel_hdmi = &dig_port->hdmi;
        struct intel_encoder *intel_encoder = &dig_port->base;
        struct drm_device *dev = intel_encoder->base.dev;
-       struct drm_i915_private *dev_priv = to_i915(dev);
        enum port port = intel_encoder->port;
        struct cec_connector_info conn_info;
        u8 ddc_pin;
        intel_connector_attach_encoder(intel_connector, intel_encoder);
        intel_hdmi->attached_connector = intel_connector;
 
-       if (is_hdcp_supported(dev_priv, port)) {
+       if (is_hdcp_supported(display, port)) {
                int ret = intel_hdcp_init(intel_connector, dig_port,
                                          &intel_hdmi_hdcp_shim);
                if (ret)
 
 
 void xe_display_fini(struct xe_device *xe)
 {
+       struct intel_display *display = &xe->display;
+
        if (!xe->info.probe_display)
                return;
 
        intel_hpd_poll_fini(xe);
 
-       intel_hdcp_component_fini(xe);
+       intel_hdcp_component_fini(display);
        intel_audio_deinit(xe);
 }