drm/msm/mdp5: Assign 'right' mixer to CRTC state

Dynamically assign a right mixer to mdp5_crtc_state in the CRTC's
atomic_check path. Assigning the right mixer has some constraints,
i.e, only a few LMs can be paired together. Update mdp5_mixer_assign
to handle these constraints.

Firstly, we need to identify whether we need a right mixer or not.
At the moment, there are 2 scenarios where a right mixer might be
needed:
- If any of the planes connected to this CRTC is too wide (i.e, is
  comprised of 2 hwpipes).
- If the CRTC's mode itself is too wide (i.e, a 4K mode on HDMI).

We implement both these checks in the mdp5_crtc_atomic_check(), and
pass 'need_right_mixer' to mdp5_setup_pipeline.

If a CRTC is already assigned a single mixer, and a new atomic commit
brings in a drm_plane that needs 2 hwpipes, we can successfully commit
this mode without requiring a full modeset, provided that we still use
the previously assigned mixer as the left mixer. If such an assignment
isn't possible, we'd need to do a full modeset. This scenario has been
ignored for now.

The mixer assignment code is a bit messy, considering we have at most
4 LM instances in hardware. This can probably be re-visited later with
simplified logic.

Signed-off-by: Archit Taneja <architt@codeaurora.org>
Signed-off-by: Rob Clark <robdclark@gmail.com>

diff --git a/drivers/gpu/drm/msm/mdp/mdp5/mdp5_crtc.c b/drivers/gpu/drm/msm/mdp/mdp5/mdp5_crtc.c
index 708d748..9217e0d 100644 (file)
--- a/drivers/gpu/drm/msm/mdp/mdp5/mdp5_crtc.c
+++ b/drivers/gpu/drm/msm/mdp/mdp5/mdp5_crtc.c
@@ -449,7 +449,8 @@ static void mdp5_crtc_enable(struct drm_crtc *crtc)
 }
 
 int mdp5_crtc_setup_pipeline(struct drm_crtc *crtc,
-                            struct drm_crtc_state *new_crtc_state)
+                            struct drm_crtc_state *new_crtc_state,
+                            bool need_right_mixer)
 {
        struct mdp5_crtc_state *mdp5_cstate =
                        to_mdp5_crtc_state(new_crtc_state);
@@ -459,15 +460,32 @@ int mdp5_crtc_setup_pipeline(struct drm_crtc *crtc,
 
        new_mixer = !pipeline->mixer;
 
+       if ((need_right_mixer && !pipeline->r_mixer) ||
+           (!need_right_mixer && pipeline->r_mixer))
+               new_mixer = true;
+
        if (new_mixer) {
                struct mdp5_hw_mixer *old_mixer = pipeline->mixer;
+               struct mdp5_hw_mixer *old_r_mixer = pipeline->r_mixer;
+               u32 caps;
+               int ret;
+
+               caps = MDP_LM_CAP_DISPLAY;
+               if (need_right_mixer)
+                       caps |= MDP_LM_CAP_PAIR;
 
-               pipeline->mixer = mdp5_mixer_assign(new_crtc_state->state, crtc,
-                                                   MDP_LM_CAP_DISPLAY);
-               if (IS_ERR(pipeline->mixer))
-                       return PTR_ERR(pipeline->mixer);
+               ret = mdp5_mixer_assign(new_crtc_state->state, crtc, caps,
+                                       &pipeline->mixer, need_right_mixer ?
+                                       &pipeline->r_mixer : NULL);
+               if (ret)
+                       return ret;
 
                mdp5_mixer_release(new_crtc_state->state, old_mixer);
+               if (old_r_mixer) {
+                       mdp5_mixer_release(new_crtc_state->state, old_r_mixer);
+                       if (!need_right_mixer)
+                               pipeline->r_mixer = NULL;
+               }
        }
 
        /*
@@ -544,7 +562,9 @@ static int mdp5_crtc_atomic_check(struct drm_crtc *crtc,
        struct plane_state pstates[STAGE_MAX + 1];
        const struct mdp5_cfg_hw *hw_cfg;
        const struct drm_plane_state *pstate;
+       const struct drm_display_mode *mode = &state->adjusted_mode;
        bool cursor_plane = false;
+       bool need_right_mixer = false;
        int cnt = 0, i;
        int ret;
        enum mdp_mixer_stage_id start;
@@ -555,6 +575,12 @@ static int mdp5_crtc_atomic_check(struct drm_crtc *crtc,
                pstates[cnt].plane = plane;
                pstates[cnt].state = to_mdp5_plane_state(pstate);
 
+               /*
+                * if any plane on this crtc uses 2 hwpipes, then we need
+                * the crtc to have a right hwmixer.
+                */
+               if (pstates[cnt].state->r_hwpipe)
+                       need_right_mixer = true;
                cnt++;
 
                if (plane->type == DRM_PLANE_TYPE_CURSOR)
@@ -565,7 +591,16 @@ static int mdp5_crtc_atomic_check(struct drm_crtc *crtc,
        if (!cnt)
                return 0;
 
-       ret = mdp5_crtc_setup_pipeline(crtc, state);
+       hw_cfg = mdp5_cfg_get_hw_config(mdp5_kms->cfg);
+
+       /*
+        * we need a right hwmixer if the mode's width is greater than a single
+        * LM's max width
+        */
+       if (mode->hdisplay > hw_cfg->lm.max_width)
+               need_right_mixer = true;
+
+       ret = mdp5_crtc_setup_pipeline(crtc, state, need_right_mixer);
        if (ret) {
                dev_err(dev->dev, "couldn't assign mixers %d\n", ret);
                return ret;
@@ -583,8 +618,6 @@ static int mdp5_crtc_atomic_check(struct drm_crtc *crtc,
        /* verify that there are not too many planes attached to crtc
         * and that we don't have conflicting mixer stages:
         */
-       hw_cfg = mdp5_cfg_get_hw_config(mdp5_kms->cfg);
-
        if ((cnt + start - 1) >= hw_cfg->lm.nb_stages) {
                dev_err(dev->dev, "too many planes! cnt=%d, start stage=%d\n",
                        cnt, start);

diff --git a/drivers/gpu/drm/msm/mdp/mdp5/mdp5_mixer.c b/drivers/gpu/drm/msm/mdp/mdp5/mdp5_mixer.c
index 9bb1f82..8a00991 100644 (file)
--- a/drivers/gpu/drm/msm/mdp/mdp5/mdp5_mixer.c
+++ b/drivers/gpu/drm/msm/mdp/mdp5/mdp5_mixer.c
@@ -16,42 +16,115 @@
 
 #include "mdp5_kms.h"
 
-struct mdp5_hw_mixer *mdp5_mixer_assign(struct drm_atomic_state *s,
-                                       struct drm_crtc *crtc, uint32_t caps)
+/*
+ * As of now, there are only 2 combinations possible for source split:
+ *
+ * Left | Right
+ * -----|------
+ *  LM0 | LM1
+ *  LM2 | LM5
+ *
+ */
+static int lm_right_pair[] = { 1, -1, 5, -1, -1, -1 };
+
+static int get_right_pair_idx(struct mdp5_kms *mdp5_kms, int lm)
+{
+       int i;
+       int pair_lm;
+
+       pair_lm = lm_right_pair[lm];
+       if (pair_lm < 0)
+               return -EINVAL;
+
+       for (i = 0; i < mdp5_kms->num_hwmixers; i++) {
+               struct mdp5_hw_mixer *mixer = mdp5_kms->hwmixers[i];
+
+               if (mixer->lm == pair_lm)
+                       return mixer->idx;
+       }
+
+       return -1;
+}
+
+int mdp5_mixer_assign(struct drm_atomic_state *s, struct drm_crtc *crtc,
+                     uint32_t caps, struct mdp5_hw_mixer **mixer,
+                     struct mdp5_hw_mixer **r_mixer)
 {
        struct msm_drm_private *priv = s->dev->dev_private;
        struct mdp5_kms *mdp5_kms = to_mdp5_kms(to_mdp_kms(priv->kms));
        struct mdp5_state *state = mdp5_get_state(s);
        struct mdp5_hw_mixer_state *new_state;
-       struct mdp5_hw_mixer *mixer = NULL;
        int i;
 
        if (IS_ERR(state))
-               return ERR_CAST(state);
+               return PTR_ERR(state);
 
        new_state = &state->hwmixer;
 
        for (i = 0; i < mdp5_kms->num_hwmixers; i++) {
                struct mdp5_hw_mixer *cur = mdp5_kms->hwmixers[i];
 
-               /* skip if already in-use */
-               if (new_state->hwmixer_to_crtc[cur->idx])
+               /*
+                * skip if already in-use by a different CRTC. If there is a
+                * mixer already assigned to this CRTC, it means this call is
+                * a request to get an additional right mixer. Assume that the
+                * existing mixer is the 'left' one, and try to see if we can
+                * get its corresponding 'right' pair.
+                */
+               if (new_state->hwmixer_to_crtc[cur->idx] &&
+                   new_state->hwmixer_to_crtc[cur->idx] != crtc)
                        continue;
 
                /* skip if doesn't support some required caps: */
                if (caps & ~cur->caps)
                        continue;
 
-               if (!mixer)
-                       mixer = cur;
+               if (r_mixer) {
+                       int pair_idx;
+
+                       pair_idx = get_right_pair_idx(mdp5_kms, cur->lm);
+                       if (pair_idx < 0)
+                               return -EINVAL;
+
+                       if (new_state->hwmixer_to_crtc[pair_idx])
+                               continue;
+
+                       *r_mixer = mdp5_kms->hwmixers[pair_idx];
+               }
+
+               /*
+                * prefer a pair-able LM over an unpairable one. We can
+                * switch the CRTC from Normal mode to Source Split mode
+                * without requiring a full modeset if we had already
+                * assigned this CRTC a pair-able LM.
+                *
+                * TODO: There will be assignment sequences which would
+                * result in the CRTC requiring a full modeset, even
+                * if we have the LM resources to prevent it. For a platform
+                * with a few displays, we don't run out of pair-able LMs
+                * so easily. For now, ignore the possibility of requiring
+                * a full modeset.
+                */
+               if (!(*mixer) || cur->caps & MDP_LM_CAP_PAIR)
+                       *mixer = cur;
        }
 
-       if (!mixer)
-               return ERR_PTR(-ENOMEM);
+       if (!(*mixer))
+               return -ENOMEM;
 
-       new_state->hwmixer_to_crtc[mixer->idx] = crtc;
+       if (r_mixer && !(*r_mixer))
+               return -ENOMEM;
 
-       return mixer;
+       DBG("assigning Layer Mixer %d to crtc %s", (*mixer)->lm, crtc->name);
+
+       new_state->hwmixer_to_crtc[(*mixer)->idx] = crtc;
+       if (r_mixer) {
+               DBG("assigning Right Layer Mixer %d to crtc %s", (*r_mixer)->lm,
+                   crtc->name);
+               new_state->hwmixer_to_crtc[(*r_mixer)->idx] = crtc;
+       }
+
+       return 0;
 }
 
 void mdp5_mixer_release(struct drm_atomic_state *s, struct mdp5_hw_mixer *mixer)

diff --git a/drivers/gpu/drm/msm/mdp/mdp5/mdp5_mixer.h b/drivers/gpu/drm/msm/mdp/mdp5/mdp5_mixer.h
index 18ed933..9be94f5 100644 (file)
--- a/drivers/gpu/drm/msm/mdp/mdp5/mdp5_mixer.h
+++ b/drivers/gpu/drm/msm/mdp/mdp5/mdp5_mixer.h
@@ -38,8 +38,9 @@ struct mdp5_hw_mixer_state {
 
 struct mdp5_hw_mixer *mdp5_mixer_init(const struct mdp5_lm_instance *lm);
 void mdp5_mixer_destroy(struct mdp5_hw_mixer *lm);
-struct mdp5_hw_mixer *mdp5_mixer_assign(struct drm_atomic_state *s,
-                                       struct drm_crtc *crtc, uint32_t caps);
+int mdp5_mixer_assign(struct drm_atomic_state *s, struct drm_crtc *crtc,
+                     uint32_t caps, struct mdp5_hw_mixer **mixer,
+                     struct mdp5_hw_mixer **r_mixer);
 void mdp5_mixer_release(struct drm_atomic_state *s,
                        struct mdp5_hw_mixer *mixer);