Revert "drm/bridge: Add the necessary bits to support bus format negotiation"

[linux.git] / drivers / gpu / drm / drm_bridge.c

diff --git a/drivers/gpu/drm/drm_bridge.c b/drivers/gpu/drm/drm_bridge.c
index a213c9042f2c8fac694aa44f4da92e6696ce6972..8e4b799150b0e29d8806dc7aaab7acd5efd6a5a9 100644 (file)
--- a/drivers/gpu/drm/drm_bridge.c
+++ b/drivers/gpu/drm/drm_bridge.c
@@ -501,10 +501,19 @@ void drm_atomic_bridge_chain_disable(struct drm_bridge *bridge,
 
        encoder = bridge->encoder;
        list_for_each_entry_reverse(iter, &encoder->bridge_chain, chain_node) {
-               if (iter->funcs->atomic_disable)
-                       iter->funcs->atomic_disable(iter, old_state);
-               else if (iter->funcs->disable)
+               if (iter->funcs->atomic_disable) {
+                       struct drm_bridge_state *old_bridge_state;
+
+                       old_bridge_state =
+                               drm_atomic_get_old_bridge_state(old_state,
+                                                               iter);
+                       if (WARN_ON(!old_bridge_state))
+                               return;
+
+                       iter->funcs->atomic_disable(iter, old_bridge_state);
+               } else if (iter->funcs->disable) {
                        iter->funcs->disable(iter);
+               }
 
                if (iter == bridge)
                        break;
@@ -535,10 +544,20 @@ void drm_atomic_bridge_chain_post_disable(struct drm_bridge *bridge,
 
        encoder = bridge->encoder;
        list_for_each_entry_from(bridge, &encoder->bridge_chain, chain_node) {
-               if (bridge->funcs->atomic_post_disable)
-                       bridge->funcs->atomic_post_disable(bridge, old_state);
-               else if (bridge->funcs->post_disable)
+               if (bridge->funcs->atomic_post_disable) {
+                       struct drm_bridge_state *old_bridge_state;
+
+                       old_bridge_state =
+                               drm_atomic_get_old_bridge_state(old_state,
+                                                               bridge);
+                       if (WARN_ON(!old_bridge_state))
+                               return;
+
+                       bridge->funcs->atomic_post_disable(bridge,
+                                                          old_bridge_state);
+               } else if (bridge->funcs->post_disable) {
                        bridge->funcs->post_disable(bridge);
+               }
        }
 }
 EXPORT_SYMBOL(drm_atomic_bridge_chain_post_disable);
@@ -567,10 +586,19 @@ void drm_atomic_bridge_chain_pre_enable(struct drm_bridge *bridge,
 
        encoder = bridge->encoder;
        list_for_each_entry_reverse(iter, &encoder->bridge_chain, chain_node) {
-               if (iter->funcs->atomic_pre_enable)
-                       iter->funcs->atomic_pre_enable(iter, old_state);
-               else if (iter->funcs->pre_enable)
+               if (iter->funcs->atomic_pre_enable) {
+                       struct drm_bridge_state *old_bridge_state;
+
+                       old_bridge_state =
+                               drm_atomic_get_old_bridge_state(old_state,
+                                                               iter);
+                       if (WARN_ON(!old_bridge_state))
+                               return;
+
+                       iter->funcs->atomic_pre_enable(iter, old_bridge_state);
+               } else if (iter->funcs->pre_enable) {
                        iter->funcs->pre_enable(iter);
+               }
 
                if (iter == bridge)
                        break;
@@ -600,14 +628,85 @@ void drm_atomic_bridge_chain_enable(struct drm_bridge *bridge,
 
        encoder = bridge->encoder;
        list_for_each_entry_from(bridge, &encoder->bridge_chain, chain_node) {
-               if (bridge->funcs->atomic_enable)
-                       bridge->funcs->atomic_enable(bridge, old_state);
-               else if (bridge->funcs->enable)
+               if (bridge->funcs->atomic_enable) {
+                       struct drm_bridge_state *old_bridge_state;
+
+                       old_bridge_state =
+                               drm_atomic_get_old_bridge_state(old_state,
+                                                               bridge);
+                       if (WARN_ON(!old_bridge_state))
+                               return;
+
+                       bridge->funcs->atomic_enable(bridge, old_bridge_state);
+               } else if (bridge->funcs->enable) {
                        bridge->funcs->enable(bridge);
+               }
        }
 }
 EXPORT_SYMBOL(drm_atomic_bridge_chain_enable);
 
+static int drm_atomic_bridge_check(struct drm_bridge *bridge,
+                                  struct drm_crtc_state *crtc_state,
+                                  struct drm_connector_state *conn_state)
+{
+       if (bridge->funcs->atomic_check) {
+               struct drm_bridge_state *bridge_state;
+               int ret;
+
+               bridge_state = drm_atomic_get_new_bridge_state(crtc_state->state,
+                                                              bridge);
+               if (WARN_ON(!bridge_state))
+                       return -EINVAL;
+
+               ret = bridge->funcs->atomic_check(bridge, bridge_state,
+                                                 crtc_state, conn_state);
+               if (ret)
+                       return ret;
+       } else if (bridge->funcs->mode_fixup) {
+               if (!bridge->funcs->mode_fixup(bridge, &crtc_state->mode,
+                                              &crtc_state->adjusted_mode))
+                       return -EINVAL;
+       }
+
+       return 0;
+}
+
+/**
+ * drm_atomic_bridge_chain_check() - Do an atomic check on the bridge chain
+ * @bridge: bridge control structure
+ * @crtc_state: new CRTC state
+ * @conn_state: new connector state
+ *
+ * Calls &drm_bridge_funcs.atomic_check() (falls back on
+ * &drm_bridge_funcs.mode_fixup()) op for all the bridges in the encoder chain,
+ * starting from the last bridge to the first. These are called before calling
+ * &drm_encoder_helper_funcs.atomic_check()
+ *
+ * RETURNS:
+ * 0 on success, a negative error code on failure
+ */
+int drm_atomic_bridge_chain_check(struct drm_bridge *bridge,
+                                 struct drm_crtc_state *crtc_state,
+                                 struct drm_connector_state *conn_state)
+{
+       struct drm_encoder *encoder = bridge->encoder;
+       struct drm_bridge *iter;
+
+       list_for_each_entry_reverse(iter, &encoder->bridge_chain, chain_node) {
+               int ret;
+
+               ret = drm_atomic_bridge_check(iter, crtc_state, conn_state);
+               if (ret)
+                       return ret;
+
+               if (iter == bridge)
+                       break;
+       }
+
+       return 0;
+}
+EXPORT_SYMBOL(drm_atomic_bridge_chain_check);
+
 /**
  * __drm_atomic_helper_bridge_reset() - Initialize a bridge state to its
  *                                     default