bool *capable);
 
        /* Write HDCP2.2 messages */
-       int (*write_2_2_msg)(struct intel_digital_port *dig_port,
+       int (*write_2_2_msg)(struct intel_connector *connector,
                             void *buf, size_t size);
 
        /* Read HDCP2.2 messages */
-       int (*read_2_2_msg)(struct intel_digital_port *dig_port,
+       int (*read_2_2_msg)(struct intel_connector *connector,
                            u8 msg_id, void *buf, size_t size);
 
        /*
         * type to Receivers. In DP HDCP2.2 Stream type is one of the input to
         * the HDCP2.2 Cipher for En/De-Cryption. Not applicable for HDMI.
         */
-       int (*config_stream_type)(struct intel_digital_port *dig_port,
+       int (*config_stream_type)(struct intel_connector *connector,
                                  bool is_repeater, u8 type);
 
        /* Enable/Disable HDCP 2.2 stream encryption on DP MST Transport Link */
 
 }
 
 static
-int intel_dp_hdcp2_write_msg(struct intel_digital_port *dig_port,
+int intel_dp_hdcp2_write_msg(struct intel_connector *connector,
                             void *buf, size_t size)
 {
+       struct intel_digital_port *dig_port = intel_attached_dig_port(connector);
        unsigned int offset;
        u8 *byte = buf;
        ssize_t ret, bytes_to_write, len;
 }
 
 static
-int intel_dp_hdcp2_read_msg(struct intel_digital_port *dig_port,
+int intel_dp_hdcp2_read_msg(struct intel_connector *connector,
                            u8 msg_id, void *buf, size_t size)
 {
+       struct intel_digital_port *dig_port = intel_attached_dig_port(connector);
        struct drm_i915_private *i915 = to_i915(dig_port->base.base.dev);
        struct intel_dp *dp = &dig_port->dp;
        struct intel_hdcp *hdcp = &dp->attached_connector->hdcp;
 }
 
 static
-int intel_dp_hdcp2_config_stream_type(struct intel_digital_port *dig_port,
+int intel_dp_hdcp2_config_stream_type(struct intel_connector *connector,
                                      bool is_repeater, u8 content_type)
 {
        int ret;
        stream_type_msg.msg_id = HDCP_2_2_ERRATA_DP_STREAM_TYPE;
        stream_type_msg.stream_type = content_type;
 
-       ret =  intel_dp_hdcp2_write_msg(dig_port, &stream_type_msg,
+       ret =  intel_dp_hdcp2_write_msg(connector, &stream_type_msg,
                                        sizeof(stream_type_msg));
 
        return ret < 0 ? ret : 0;
 
 /* Authentication flow starts from here */
 static int hdcp2_authentication_key_exchange(struct intel_connector *connector)
 {
-       struct intel_digital_port *dig_port = intel_attached_dig_port(connector);
        struct drm_i915_private *i915 = to_i915(connector->base.dev);
        struct intel_hdcp *hdcp = &connector->hdcp;
        union {
        if (ret < 0)
                return ret;
 
-       ret = shim->write_2_2_msg(dig_port, &msgs.ake_init,
+       ret = shim->write_2_2_msg(connector, &msgs.ake_init,
                                  sizeof(msgs.ake_init));
        if (ret < 0)
                return ret;
 
-       ret = shim->read_2_2_msg(dig_port, HDCP_2_2_AKE_SEND_CERT,
+       ret = shim->read_2_2_msg(connector, HDCP_2_2_AKE_SEND_CERT,
                                 &msgs.send_cert, sizeof(msgs.send_cert));
        if (ret < 0)
                return ret;
        if (ret < 0)
                return ret;
 
-       ret = shim->write_2_2_msg(dig_port, &msgs.no_stored_km, size);
+       ret = shim->write_2_2_msg(connector, &msgs.no_stored_km, size);
        if (ret < 0)
                return ret;
 
-       ret = shim->read_2_2_msg(dig_port, HDCP_2_2_AKE_SEND_HPRIME,
+       ret = shim->read_2_2_msg(connector, HDCP_2_2_AKE_SEND_HPRIME,
                                 &msgs.send_hprime, sizeof(msgs.send_hprime));
        if (ret < 0)
                return ret;
 
        if (!hdcp->is_paired) {
                /* Pairing is required */
-               ret = shim->read_2_2_msg(dig_port,
+               ret = shim->read_2_2_msg(connector,
                                         HDCP_2_2_AKE_SEND_PAIRING_INFO,
                                         &msgs.pairing_info,
                                         sizeof(msgs.pairing_info));
 
 static int hdcp2_locality_check(struct intel_connector *connector)
 {
-       struct intel_digital_port *dig_port = intel_attached_dig_port(connector);
        struct intel_hdcp *hdcp = &connector->hdcp;
        union {
                struct hdcp2_lc_init lc_init;
                if (ret < 0)
                        continue;
 
-               ret = shim->write_2_2_msg(dig_port, &msgs.lc_init,
+               ret = shim->write_2_2_msg(connector, &msgs.lc_init,
                                      sizeof(msgs.lc_init));
                if (ret < 0)
                        continue;
 
-               ret = shim->read_2_2_msg(dig_port,
+               ret = shim->read_2_2_msg(connector,
                                         HDCP_2_2_LC_SEND_LPRIME,
                                         &msgs.send_lprime,
                                         sizeof(msgs.send_lprime));
 
 static int hdcp2_session_key_exchange(struct intel_connector *connector)
 {
-       struct intel_digital_port *dig_port = intel_attached_dig_port(connector);
        struct intel_hdcp *hdcp = &connector->hdcp;
        struct hdcp2_ske_send_eks send_eks;
        int ret;
        if (ret < 0)
                return ret;
 
-       ret = hdcp->shim->write_2_2_msg(dig_port, &send_eks,
+       ret = hdcp->shim->write_2_2_msg(connector, &send_eks,
                                        sizeof(send_eks));
        if (ret < 0)
                return ret;
        streams_size_delta = (HDCP_2_2_MAX_CONTENT_STREAMS_CNT - data->k) *
                                sizeof(struct hdcp2_streamid_type);
        /* Send it to Repeater */
-       ret = shim->write_2_2_msg(dig_port, &msgs.stream_manage,
+       ret = shim->write_2_2_msg(connector, &msgs.stream_manage,
                                  sizeof(msgs.stream_manage) - streams_size_delta);
        if (ret < 0)
                goto out;
 
-       ret = shim->read_2_2_msg(dig_port, HDCP_2_2_REP_STREAM_READY,
+       ret = shim->read_2_2_msg(connector, HDCP_2_2_REP_STREAM_READY,
                                 &msgs.stream_ready, sizeof(msgs.stream_ready));
        if (ret < 0)
                goto out;
        u8 *rx_info;
        int ret;
 
-       ret = shim->read_2_2_msg(dig_port, HDCP_2_2_REP_SEND_RECVID_LIST,
+       ret = shim->read_2_2_msg(connector, HDCP_2_2_REP_SEND_RECVID_LIST,
                                 &msgs.recvid_list, sizeof(msgs.recvid_list));
        if (ret < 0)
                return ret;
                return ret;
 
        hdcp->seq_num_v = seq_num_v;
-       ret = shim->write_2_2_msg(dig_port, &msgs.rep_ack,
+       ret = shim->write_2_2_msg(connector, &msgs.rep_ack,
                                  sizeof(msgs.rep_ack));
        if (ret < 0)
                return ret;
 
 static int hdcp2_authenticate_sink(struct intel_connector *connector)
 {
-       struct intel_digital_port *dig_port = intel_attached_dig_port(connector);
        struct drm_i915_private *i915 = to_i915(connector->base.dev);
        struct intel_hdcp *hdcp = &connector->hdcp;
        const struct intel_hdcp_shim *shim = hdcp->shim;
        }
 
        if (shim->config_stream_type) {
-               ret = shim->config_stream_type(dig_port,
+               ret = shim->config_stream_type(connector,
                                               hdcp->is_repeater,
                                               hdcp->content_type);
                if (ret < 0)