drm/vc4: crtc: Lookup the encoder from the register at boot

[linux-2.6-microblaze.git] / drivers / gpu / drm / vc4 / vc4_crtc.c

diff --git a/drivers/gpu/drm/vc4/vc4_crtc.c b/drivers/gpu/drm/vc4/vc4_crtc.c
index 76657dc..18f5009 100644 (file)
--- a/drivers/gpu/drm/vc4/vc4_crtc.c
+++ b/drivers/gpu/drm/vc4/vc4_crtc.c
@@ -279,14 +279,22 @@ static u32 vc4_crtc_get_fifo_full_level_bits(struct vc4_crtc *vc4_crtc,
  * allows drivers to push pixels to more than one encoder from the
  * same CRTC.
  */
-static struct drm_encoder *vc4_get_crtc_encoder(struct drm_crtc *crtc)
+static struct drm_encoder *vc4_get_crtc_encoder(struct drm_crtc *crtc,
+                                               struct drm_atomic_state *state,
+                                               struct drm_connector_state *(*get_state)(struct drm_atomic_state *state,
+                                                                                        struct drm_connector *connector))
 {
        struct drm_connector *connector;
        struct drm_connector_list_iter conn_iter;
 
        drm_connector_list_iter_begin(crtc->dev, &conn_iter);
        drm_for_each_connector_iter(connector, &conn_iter) {
-               if (connector->state->crtc == crtc) {
+               struct drm_connector_state *conn_state = get_state(state, connector);
+
+               if (!conn_state)
+                       continue;
+
+               if (conn_state->crtc == crtc) {
                        drm_connector_list_iter_end(&conn_iter);
                        return connector->encoder;
                }
@@ -305,16 +313,17 @@ static void vc4_crtc_pixelvalve_reset(struct drm_crtc *crtc)
        CRTC_WRITE(PV_CONTROL, CRTC_READ(PV_CONTROL) | PV_CONTROL_FIFO_CLR);
 }
 
-static void vc4_crtc_config_pv(struct drm_crtc *crtc)
+static void vc4_crtc_config_pv(struct drm_crtc *crtc, struct drm_atomic_state *state)
 {
        struct drm_device *dev = crtc->dev;
        struct vc4_dev *vc4 = to_vc4_dev(dev);
-       struct drm_encoder *encoder = vc4_get_crtc_encoder(crtc);
+       struct drm_encoder *encoder = vc4_get_crtc_encoder(crtc, state,
+                                                          drm_atomic_get_new_connector_state);
        struct vc4_encoder *vc4_encoder = to_vc4_encoder(encoder);
        struct vc4_crtc *vc4_crtc = to_vc4_crtc(crtc);
        const struct vc4_pv_data *pv_data = vc4_crtc_to_vc4_pv_data(vc4_crtc);
-       struct drm_crtc_state *state = crtc->state;
-       struct drm_display_mode *mode = &state->adjusted_mode;
+       struct drm_crtc_state *crtc_state = crtc->state;
+       struct drm_display_mode *mode = &crtc_state->adjusted_mode;
        bool interlace = mode->flags & DRM_MODE_FLAG_INTERLACE;
        u32 pixel_rep = (mode->flags & DRM_MODE_FLAG_DBLCLK) ? 2 : 1;
        bool is_dsi = (vc4_encoder->type == VC4_ENCODER_TYPE_DSI0 ||
@@ -421,10 +430,10 @@ static void require_hvs_enabled(struct drm_device *dev)
 }
 
 static int vc4_crtc_disable(struct drm_crtc *crtc,
+                           struct drm_encoder *encoder,
                            struct drm_atomic_state *state,
                            unsigned int channel)
 {
-       struct drm_encoder *encoder = vc4_get_crtc_encoder(crtc);
        struct vc4_encoder *vc4_encoder = to_vc4_encoder(encoder);
        struct vc4_crtc *vc4_crtc = to_vc4_crtc(crtc);
        struct drm_device *dev = crtc->dev;
@@ -465,10 +474,29 @@ static int vc4_crtc_disable(struct drm_crtc *crtc,
        return 0;
 }
 
+static struct drm_encoder *vc4_crtc_get_encoder_by_type(struct drm_crtc *crtc,
+                                                       enum vc4_encoder_type type)
+{
+       struct drm_encoder *encoder;
+
+       drm_for_each_encoder(encoder, crtc->dev) {
+               struct vc4_encoder *vc4_encoder = to_vc4_encoder(encoder);
+
+               if (vc4_encoder->type == type)
+                       return encoder;
+       }
+
+       return NULL;
+}
+
 int vc4_crtc_disable_at_boot(struct drm_crtc *crtc)
 {
        struct drm_device *drm = crtc->dev;
        struct vc4_crtc *vc4_crtc = to_vc4_crtc(crtc);
+       enum vc4_encoder_type encoder_type;
+       const struct vc4_pv_data *pv_data;
+       struct drm_encoder *encoder;
+       unsigned encoder_sel;
        int channel;
 
        if (!(of_device_is_compatible(vc4_crtc->pdev->dev.of_node,
@@ -487,7 +515,17 @@ int vc4_crtc_disable_at_boot(struct drm_crtc *crtc)
        if (channel < 0)
                return 0;
 
-       return vc4_crtc_disable(crtc, NULL, channel);
+       encoder_sel = VC4_GET_FIELD(CRTC_READ(PV_CONTROL), PV_CONTROL_CLK_SELECT);
+       if (WARN_ON(encoder_sel != 0))
+               return 0;
+
+       pv_data = vc4_crtc_to_vc4_pv_data(vc4_crtc);
+       encoder_type = pv_data->encoder_types[encoder_sel];
+       encoder = vc4_crtc_get_encoder_by_type(crtc, encoder_type);
+       if (WARN_ON(!encoder))
+               return 0;
+
+       return vc4_crtc_disable(crtc, encoder, NULL, channel);
 }
 
 static void vc4_crtc_atomic_disable(struct drm_crtc *crtc,
@@ -496,6 +534,8 @@ static void vc4_crtc_atomic_disable(struct drm_crtc *crtc,
        struct drm_crtc_state *old_state = drm_atomic_get_old_crtc_state(state,
                                                                         crtc);
        struct vc4_crtc_state *old_vc4_state = to_vc4_crtc_state(old_state);
+       struct drm_encoder *encoder = vc4_get_crtc_encoder(crtc, state,
+                                                          drm_atomic_get_old_connector_state);
        struct drm_device *dev = crtc->dev;
 
        require_hvs_enabled(dev);
@@ -503,7 +543,7 @@ static void vc4_crtc_atomic_disable(struct drm_crtc *crtc,
        /* Disable vblank irq handling before crtc is disabled. */
        drm_crtc_vblank_off(crtc);
 
-       vc4_crtc_disable(crtc, state, old_vc4_state->assigned_channel);
+       vc4_crtc_disable(crtc, encoder, state, old_vc4_state->assigned_channel);
 
        /*
         * Make sure we issue a vblank event after disabling the CRTC if
@@ -524,7 +564,8 @@ static void vc4_crtc_atomic_enable(struct drm_crtc *crtc,
 {
        struct drm_device *dev = crtc->dev;
        struct vc4_crtc *vc4_crtc = to_vc4_crtc(crtc);
-       struct drm_encoder *encoder = vc4_get_crtc_encoder(crtc);
+       struct drm_encoder *encoder = vc4_get_crtc_encoder(crtc, state,
+                                                          drm_atomic_get_new_connector_state);
        struct vc4_encoder *vc4_encoder = to_vc4_encoder(encoder);
 
        require_hvs_enabled(dev);
@@ -539,7 +580,7 @@ static void vc4_crtc_atomic_enable(struct drm_crtc *crtc,
        if (vc4_encoder->pre_crtc_configure)
                vc4_encoder->pre_crtc_configure(encoder, state);
 
-       vc4_crtc_config_pv(crtc);
+       vc4_crtc_config_pv(crtc, state);
 
        CRTC_WRITE(PV_CONTROL, CRTC_READ(PV_CONTROL) | PV_CONTROL_EN);
 
@@ -994,7 +1035,7 @@ static const struct vc4_pv_data bcm2711_pv3_data = {
        .fifo_depth = 64,
        .pixels_per_clock = 1,
        .encoder_types = {
-               [0] = VC4_ENCODER_TYPE_VEC,
+               [PV_CONTROL_CLK_SELECT_VEC] = VC4_ENCODER_TYPE_VEC,
        },
 };
 
@@ -1035,6 +1076,9 @@ static void vc4_set_crtc_possible_masks(struct drm_device *drm,
                struct vc4_encoder *vc4_encoder;
                int i;
 
+               if (encoder->encoder_type == DRM_MODE_ENCODER_VIRTUAL)
+                       continue;
+
                vc4_encoder = to_vc4_encoder(encoder);
                for (i = 0; i < ARRAY_SIZE(pv_data->encoder_types); i++) {
                        if (vc4_encoder->type == encoder_types[i]) {