drm/i915/dp: Use an intel_connector pointer everywhere

Following the convention, convert intel_dp.c to use an intel_connector
pointer everywhere, calling this pointer connector. If the intel
connector must be casted from a drm_connector, call this pointer
_connector and use this pointer only for the casting.

v2: Use for_each_intel_connector_iter(). (Jani)

Cc: Jani Nikula <jani.nikula@intel.com>
Reviewed-by: Jani Nikula <jani.nikula@intel.com>
Signed-off-by: Imre Deak <imre.deak@intel.com>
Link: https://lore.kernel.org/r/20250428134716.3396802-2-imre.deak@intel.com

diff --git a/drivers/gpu/drm/i915/display/intel_dp.c b/drivers/gpu/drm/i915/display/intel_dp.c
index 607aea1bf6fa28842bce5f67100b95e2baa18975..213bb92f3fff644108f49dcdbac206b97579bb1b 100644 (file)
--- a/drivers/gpu/drm/i915/display/intel_dp.c
+++ b/drivers/gpu/drm/i915/display/intel_dp.c
@@ -5832,20 +5832,21 @@ out_vdd_off:
 }
 
 static void
-intel_dp_force(struct drm_connector *connector)
+intel_dp_force(struct drm_connector *_connector)
 {
-       struct intel_display *display = to_intel_display(connector->dev);
-       struct intel_dp *intel_dp = intel_attached_dp(to_intel_connector(connector));
+       struct intel_connector *connector = to_intel_connector(_connector);
+       struct intel_display *display = to_intel_display(connector);
+       struct intel_dp *intel_dp = intel_attached_dp(connector);
 
        drm_dbg_kms(display->drm, "[CONNECTOR:%d:%s]\n",
-                   connector->base.id, connector->name);
+                   connector->base.base.id, connector->base.name);
 
        if (!intel_display_driver_check_access(display))
                return;
 
        intel_dp_unset_edid(intel_dp);
 
-       if (connector->status != connector_status_connected)
+       if (connector->base.status != connector_status_connected)
                return;
 
        intel_dp_set_edid(intel_dp);
@@ -5884,24 +5885,25 @@ static int intel_dp_get_modes(struct drm_connector *_connector)
 }
 
 static int
-intel_dp_connector_register(struct drm_connector *connector)
+intel_dp_connector_register(struct drm_connector *_connector)
 {
-       struct intel_display *display = to_intel_display(connector->dev);
-       struct intel_dp *intel_dp = intel_attached_dp(to_intel_connector(connector));
+       struct intel_connector *connector = to_intel_connector(_connector);
+       struct intel_display *display = to_intel_display(connector);
+       struct intel_dp *intel_dp = intel_attached_dp(connector);
        struct intel_digital_port *dig_port = dp_to_dig_port(intel_dp);
        int ret;
 
-       ret = intel_connector_register(connector);
+       ret = intel_connector_register(&connector->base);
        if (ret)
                return ret;
 
        drm_dbg_kms(display->drm, "registering %s bus for %s\n",
-                   intel_dp->aux.name, connector->kdev->kobj.name);
+                   intel_dp->aux.name, connector->base.kdev->kobj.name);
 
-       intel_dp->aux.dev = connector->kdev;
+       intel_dp->aux.dev = connector->base.kdev;
        ret = drm_dp_aux_register(&intel_dp->aux);
        if (!ret)
-               drm_dp_cec_register_connector(&intel_dp->aux, connector);
+               drm_dp_cec_register_connector(&intel_dp->aux, &connector->base);
 
        if (!intel_bios_encoder_is_lspcon(dig_port->base.devdata))
                return ret;
@@ -5912,20 +5914,21 @@ intel_dp_connector_register(struct drm_connector *connector)
         */
        if (intel_lspcon_init(dig_port)) {
                if (intel_lspcon_detect_hdr_capability(dig_port))
-                       drm_connector_attach_hdr_output_metadata_property(connector);
+                       drm_connector_attach_hdr_output_metadata_property(&connector->base);
        }
 
        return ret;
 }
 
 static void
-intel_dp_connector_unregister(struct drm_connector *connector)
+intel_dp_connector_unregister(struct drm_connector *_connector)
 {
-       struct intel_dp *intel_dp = intel_attached_dp(to_intel_connector(connector));
+       struct intel_connector *connector = to_intel_connector(_connector);
+       struct intel_dp *intel_dp = intel_attached_dp(connector);
 
        drm_dp_cec_unregister_connector(&intel_dp->aux);
        drm_dp_aux_unregister(&intel_dp->aux);
-       intel_connector_unregister(connector);
+       intel_connector_unregister(&connector->base);
 }
 
 void intel_dp_connector_sync_state(struct intel_connector *connector,
@@ -5986,21 +5989,21 @@ static int intel_modeset_tile_group(struct intel_atomic_state *state,
 {
        struct intel_display *display = to_intel_display(state);
        struct drm_connector_list_iter conn_iter;
-       struct drm_connector *connector;
+       struct intel_connector *connector;
        int ret = 0;
 
        drm_connector_list_iter_begin(display->drm, &conn_iter);
-       drm_for_each_connector_iter(connector, &conn_iter) {
+       for_each_intel_connector_iter(connector, &conn_iter) {
                struct drm_connector_state *conn_state;
                struct intel_crtc_state *crtc_state;
                struct intel_crtc *crtc;
 
-               if (!connector->has_tile ||
-                   connector->tile_group->id != tile_group_id)
+               if (!connector->base.has_tile ||
+                   connector->base.tile_group->id != tile_group_id)
                        continue;
 
                conn_state = drm_atomic_get_connector_state(&state->base,
-                                                           connector);
+                                                           &connector->base);
                if (IS_ERR(conn_state)) {
                        ret = PTR_ERR(conn_state);
                        break;
@@ -6064,10 +6067,11 @@ static int intel_modeset_affected_transcoders(struct intel_atomic_state *state,
 }
 
 static int intel_modeset_synced_crtcs(struct intel_atomic_state *state,
-                                     struct drm_connector *connector)
+                                     struct drm_connector *_connector)
 {
+       struct intel_connector *connector = to_intel_connector(_connector);
        const struct drm_connector_state *old_conn_state =
-               drm_atomic_get_old_connector_state(&state->base, connector);
+               drm_atomic_get_old_connector_state(&state->base, &connector->base);
        const struct intel_crtc_state *old_crtc_state;
        struct intel_crtc *crtc;
        u8 transcoders;
@@ -6089,17 +6093,18 @@ static int intel_modeset_synced_crtcs(struct intel_atomic_state *state,
                                                  transcoders);
 }
 
-static int intel_dp_connector_atomic_check(struct drm_connector *conn,
+static int intel_dp_connector_atomic_check(struct drm_connector *_connector,
                                           struct drm_atomic_state *_state)
 {
-       struct intel_display *display = to_intel_display(conn->dev);
+       struct intel_connector *connector = to_intel_connector(_connector);
+       struct intel_display *display = to_intel_display(connector);
        struct intel_atomic_state *state = to_intel_atomic_state(_state);
-       struct drm_connector_state *conn_state = drm_atomic_get_new_connector_state(_state, conn);
-       struct intel_connector *intel_conn = to_intel_connector(conn);
-       struct intel_dp *intel_dp = enc_to_intel_dp(intel_conn->encoder);
+       struct drm_connector_state *conn_state =
+               drm_atomic_get_new_connector_state(_state, &connector->base);
+       struct intel_dp *intel_dp = enc_to_intel_dp(connector->encoder);
        int ret;
 
-       ret = intel_digital_connector_atomic_check(conn, &state->base);
+       ret = intel_digital_connector_atomic_check(&connector->base, &state->base);
        if (ret)
                return ret;
 
@@ -6109,12 +6114,12 @@ static int intel_dp_connector_atomic_check(struct drm_connector *conn,
                        return ret;
        }
 
-       if (!intel_connector_needs_modeset(state, conn))
+       if (!intel_connector_needs_modeset(state, &connector->base))
                return 0;
 
        ret = intel_dp_tunnel_atomic_check_state(state,
                                                 intel_dp,
-                                                intel_conn);
+                                                connector);
        if (ret)
                return ret;
 
@@ -6125,21 +6130,22 @@ static int intel_dp_connector_atomic_check(struct drm_connector *conn,
        if (DISPLAY_VER(display) < 9)
                return 0;
 
-       if (conn->has_tile) {
-               ret = intel_modeset_tile_group(state, conn->tile_group->id);
+       if (connector->base.has_tile) {
+               ret = intel_modeset_tile_group(state, connector->base.tile_group->id);
                if (ret)
                        return ret;
        }
 
-       return intel_modeset_synced_crtcs(state, conn);
+       return intel_modeset_synced_crtcs(state, &connector->base);
 }
 
-static void intel_dp_oob_hotplug_event(struct drm_connector *connector,
+static void intel_dp_oob_hotplug_event(struct drm_connector *_connector,
                                       enum drm_connector_status hpd_state)
 {
-       struct intel_display *display = to_intel_display(connector->dev);
-       struct intel_encoder *encoder = intel_attached_encoder(to_intel_connector(connector));
-       struct drm_i915_private *i915 = to_i915(connector->dev);
+       struct intel_connector *connector = to_intel_connector(_connector);
+       struct intel_display *display = to_intel_display(connector);
+       struct intel_encoder *encoder = intel_attached_encoder(connector);
+       struct drm_i915_private *i915 = to_i915(display->drm);
        bool hpd_high = hpd_state == connector_status_connected;
        unsigned int hpd_pin = encoder->hpd_pin;
        bool need_work = false;
@@ -6285,36 +6291,37 @@ intel_dp_has_gamut_metadata_dip(struct intel_encoder *encoder)
 }
 
 static void
-intel_dp_add_properties(struct intel_dp *intel_dp, struct drm_connector *connector)
+intel_dp_add_properties(struct intel_dp *intel_dp, struct drm_connector *_connector)
 {
+       struct intel_connector *connector = to_intel_connector(_connector);
        struct intel_display *display = to_intel_display(intel_dp);
        enum port port = dp_to_dig_port(intel_dp)->base.port;
 
        if (!intel_dp_is_edp(intel_dp))
-               drm_connector_attach_dp_subconnector_property(connector);
+               drm_connector_attach_dp_subconnector_property(&connector->base);
 
        if (!display->platform.g4x && port != PORT_A)
-               intel_attach_force_audio_property(connector);
+               intel_attach_force_audio_property(&connector->base);
 
-       intel_attach_broadcast_rgb_property(connector);
+       intel_attach_broadcast_rgb_property(&connector->base);
        if (HAS_GMCH(display))
-               drm_connector_attach_max_bpc_property(connector, 6, 10);
+               drm_connector_attach_max_bpc_property(&connector->base, 6, 10);
        else if (DISPLAY_VER(display) >= 5)
-               drm_connector_attach_max_bpc_property(connector, 6, 12);
+               drm_connector_attach_max_bpc_property(&connector->base, 6, 12);
 
        /* Register HDMI colorspace for case of lspcon */
        if (intel_bios_encoder_is_lspcon(dp_to_dig_port(intel_dp)->base.devdata)) {
-               drm_connector_attach_content_type_property(connector);
-               intel_attach_hdmi_colorspace_property(connector);
+               drm_connector_attach_content_type_property(&connector->base);
+               intel_attach_hdmi_colorspace_property(&connector->base);
        } else {
-               intel_attach_dp_colorspace_property(connector);
+               intel_attach_dp_colorspace_property(&connector->base);
        }
 
        if (intel_dp_has_gamut_metadata_dip(&dp_to_dig_port(intel_dp)->base))
-               drm_connector_attach_hdr_output_metadata_property(connector);
+               drm_connector_attach_hdr_output_metadata_property(&connector->base);
 
        if (HAS_VRR(display))
-               drm_connector_attach_vrr_capable_property(connector);
+               drm_connector_attach_vrr_capable_property(&connector->base);
 }
 
 static void