drm/msm/dpu: support plane splitting in quad-pipe case

The content of every half of screen is sent out via one interface in
dual-DSI case. The content for every interface is blended by a LM
pair in quad-pipe case, thus a LM pair should not blend any content
that cross the half of screen in this case. Clip plane into pipes per
left and right half screen ROI if topology is quad pipe case.
The clipped rectangle on every half of screen is futher handled by two
pipes if its width exceeds a limit for a single pipe.

For non-virtual-plane case, there is always one stage config to serve
a LM or LM pair. So the clipping does not occur when interating stages
in this case. The plane is mapped to 2 pipes only when width or clock
rate exceeds hardware constrain within stage check.

Signed-off-by: Jun Nie <jun.nie@linaro.org>
Reviewed-by: Dmitry Baryshkov <dmitry.baryshkov@linaro.org>
Reviewed-by: Jessica Zhang <jessica.zhang@oss.qualcomm.com>
Patchwork: https://patchwork.freedesktop.org/patch/711324/
Link: https://lore.kernel.org/r/20260312-msm-next-quad-pipe-split-v19-3-4ffa2b06c996@linaro.org
Signed-off-by: Dmitry Baryshkov <dmitry.baryshkov@oss.qualcomm.com>

diff --git a/drivers/gpu/drm/msm/disp/dpu1/dpu_crtc.c b/drivers/gpu/drm/msm/disp/dpu1/dpu_crtc.c
index a4aaa43a62e3cbeb7991c6582a9d69a1a18f2cb4..bd0e720b484fd7ce38d9913e4d35e01d06ae55df 100644 (file)
--- a/drivers/gpu/drm/msm/disp/dpu1/dpu_crtc.c
+++ b/drivers/gpu/drm/msm/disp/dpu1/dpu_crtc.c
@@ -1667,6 +1667,17 @@ int dpu_crtc_vblank(struct drm_crtc *crtc, bool en)
        return 0;
 }
 
+/**
+ * dpu_crtc_get_num_lm - Get mixer number in this CRTC pipeline
+ * @state: Pointer to drm crtc state object
+ */
+unsigned int dpu_crtc_get_num_lm(const struct drm_crtc_state *state)
+{
+       struct dpu_crtc_state *cstate = to_dpu_crtc_state(state);
+
+       return cstate->num_mixers;
+}
+
 #ifdef CONFIG_DEBUG_FS
 static int _dpu_debugfs_status_show(struct seq_file *s, void *data)
 {

diff --git a/drivers/gpu/drm/msm/disp/dpu1/dpu_crtc.h b/drivers/gpu/drm/msm/disp/dpu1/dpu_crtc.h
index 94392b9b924546f96e738ae20920cf9afd568e6b..6eaba5696e8e6bd1246a9895c4c8714ca6589b10 100644 (file)
--- a/drivers/gpu/drm/msm/disp/dpu1/dpu_crtc.h
+++ b/drivers/gpu/drm/msm/disp/dpu1/dpu_crtc.h
@@ -267,4 +267,6 @@ static inline enum dpu_crtc_client_type dpu_crtc_get_client_type(
 
 void dpu_crtc_frame_event_cb(struct drm_crtc *crtc, u32 event);
 
+unsigned int dpu_crtc_get_num_lm(const struct drm_crtc_state *state);
+
 #endif /* _DPU_CRTC_H_ */

diff --git a/drivers/gpu/drm/msm/disp/dpu1/dpu_plane.c b/drivers/gpu/drm/msm/disp/dpu1/dpu_plane.c
index 14fea0a1529597c1b4a6826055dbc1401fb17fa4..22d80b6ef8a4462d4888a0b06227ccadd2621395 100644 (file)
--- a/drivers/gpu/drm/msm/disp/dpu1/dpu_plane.c
+++ b/drivers/gpu/drm/msm/disp/dpu1/dpu_plane.c
@@ -878,47 +878,111 @@ static int dpu_plane_split(struct drm_plane *plane,
        struct dpu_plane_state *pstate = to_dpu_plane_state(new_plane_state);
        struct dpu_sw_pipe_cfg *pipe_cfg;
        struct dpu_sw_pipe_cfg *r_pipe_cfg;
+       const struct drm_display_mode *mode = &crtc_state->adjusted_mode;
        uint32_t max_linewidth;
+       u32 num_lm;
+       int stage_id, num_stages;
 
-       /* move the assignment here, to ease handling to another pairs later */
-       pipe_cfg = &pstate->pipe_cfg[0];
-       r_pipe_cfg = &pstate->pipe_cfg[1];
-       /* state->src is 16.16, src_rect is not */
-       drm_rect_fp_to_int(&pipe_cfg->src_rect, &new_plane_state->src);
+       max_linewidth = pdpu->catalog->caps->max_linewidth;
 
-       pipe_cfg->dst_rect = new_plane_state->dst;
+       /* In non-virtual plane case, one mixer pair is always needed. */
+       num_lm = dpu_crtc_get_num_lm(crtc_state);
+       if (dpu_use_virtual_planes)
+               num_stages = (num_lm + 1) / 2;
+       else
+               num_stages = 1;
 
-       max_linewidth = pdpu->catalog->caps->max_linewidth;
+       /*
+        * For wide plane that exceeds SSPP rectangle constrain, it needed to
+        * be split and mapped to 2 rectangles with 1 config for 2:2:1.
+        * For 2 interfaces cases, such as dual DSI, 2:2:2 topology is needed.
+        * If the width or clock exceeds hardware limitation in every half of
+        * screen, 4:4:2 topology is needed and virtual plane feature should
+        * be enabled to map plane to more than 1 SSPP. 2 stage configs are
+        * needed to serve 2 mixer pairs in this 4:4:2 case. So both left/right
+        * half of plane splitting, and splitting within the half of screen is
+        * needed in quad-pipe case. Check dest rectangle left/right clipping
+        * and iterate mixer configs for this plane first, then check wide
+        * rectangle splitting in every half next.
+        */
+       for (stage_id = 0; stage_id < num_stages; stage_id++) {
+               struct drm_rect mixer_rect = {
+                       .x1 = stage_id * mode->hdisplay / num_stages,
+                       .y1 = 0,
+                       .x2 = (stage_id + 1) * mode->hdisplay / num_stages,
+                       .y2 = mode->vdisplay
+                       };
+               int cfg_idx = stage_id * PIPES_PER_STAGE;
 
-       drm_rect_rotate(&pipe_cfg->src_rect,
-                       new_plane_state->fb->width, new_plane_state->fb->height,
-                       new_plane_state->rotation);
+               pipe_cfg = &pstate->pipe_cfg[cfg_idx];
+               r_pipe_cfg = &pstate->pipe_cfg[cfg_idx + 1];
 
-       if ((drm_rect_width(&pipe_cfg->src_rect) > max_linewidth) ||
-            _dpu_plane_calc_clk(&crtc_state->adjusted_mode, pipe_cfg) > max_mdp_clk_rate) {
-               if (drm_rect_width(&pipe_cfg->src_rect) > 2 * max_linewidth) {
-                       DPU_DEBUG_PLANE(pdpu, "invalid src " DRM_RECT_FMT " line:%u\n",
-                                       DRM_RECT_ARG(&pipe_cfg->src_rect), max_linewidth);
-                       return -E2BIG;
+               drm_rect_fp_to_int(&pipe_cfg->src_rect, &new_plane_state->src);
+
+               drm_rect_rotate(&pipe_cfg->src_rect,
+                               new_plane_state->fb->width, new_plane_state->fb->height,
+                               new_plane_state->rotation);
+
+               pipe_cfg->dst_rect = new_plane_state->dst;
+
+               DPU_DEBUG_PLANE(pdpu, "checking src " DRM_RECT_FMT
+                               " vs clip window " DRM_RECT_FMT "\n",
+                               DRM_RECT_ARG(&pipe_cfg->src_rect),
+                               DRM_RECT_ARG(&mixer_rect));
+
+               /*
+                * If this plane does not fall into mixer rect, check next
+                * mixer rect.
+                */
+               if (!drm_rect_clip_scaled(&pipe_cfg->src_rect,
+                                         &pipe_cfg->dst_rect,
+                                         &mixer_rect)) {
+                       memset(pipe_cfg, 0, 2 * sizeof(struct dpu_sw_pipe_cfg));
+
+                       continue;
                }
 
-               *r_pipe_cfg = *pipe_cfg;
-               pipe_cfg->src_rect.x2 = (pipe_cfg->src_rect.x1 + pipe_cfg->src_rect.x2) >> 1;
-               pipe_cfg->dst_rect.x2 = (pipe_cfg->dst_rect.x1 + pipe_cfg->dst_rect.x2) >> 1;
-               r_pipe_cfg->src_rect.x1 = pipe_cfg->src_rect.x2;
-               r_pipe_cfg->dst_rect.x1 = pipe_cfg->dst_rect.x2;
-       } else {
-               memset(r_pipe_cfg, 0, sizeof(*r_pipe_cfg));
-       }
+               pipe_cfg->dst_rect.x1 -= mixer_rect.x1;
+               pipe_cfg->dst_rect.x2 -= mixer_rect.x1;
+
+               DPU_DEBUG_PLANE(pdpu, "Got clip src:" DRM_RECT_FMT " dst: " DRM_RECT_FMT "\n",
+                               DRM_RECT_ARG(&pipe_cfg->src_rect), DRM_RECT_ARG(&pipe_cfg->dst_rect));
+
+               /* Split wide rect into 2 rect */
+               if ((drm_rect_width(&pipe_cfg->src_rect) > max_linewidth) ||
+                    _dpu_plane_calc_clk(mode, pipe_cfg) > max_mdp_clk_rate) {
+
+                       if (drm_rect_width(&pipe_cfg->src_rect) > 2 * max_linewidth) {
+                               DPU_DEBUG_PLANE(pdpu, "invalid src " DRM_RECT_FMT " line:%u\n",
+                                               DRM_RECT_ARG(&pipe_cfg->src_rect), max_linewidth);
+                               return -E2BIG;
+                       }
+
+                       memcpy(r_pipe_cfg, pipe_cfg, sizeof(struct dpu_sw_pipe_cfg));
+                       pipe_cfg->src_rect.x2 = (pipe_cfg->src_rect.x1 + pipe_cfg->src_rect.x2) >> 1;
+                       pipe_cfg->dst_rect.x2 = (pipe_cfg->dst_rect.x1 + pipe_cfg->dst_rect.x2) >> 1;
+                       r_pipe_cfg->src_rect.x1 = pipe_cfg->src_rect.x2;
+                       r_pipe_cfg->dst_rect.x1 = pipe_cfg->dst_rect.x2;
+                       DPU_DEBUG_PLANE(pdpu, "Split wide plane into:"
+                                       DRM_RECT_FMT " and " DRM_RECT_FMT "\n",
+                                       DRM_RECT_ARG(&pipe_cfg->src_rect),
+                                       DRM_RECT_ARG(&r_pipe_cfg->src_rect));
+               } else {
+                       memset(r_pipe_cfg, 0, sizeof(struct dpu_sw_pipe_cfg));
+               }
 
-       drm_rect_rotate_inv(&pipe_cfg->src_rect,
-                           new_plane_state->fb->width, new_plane_state->fb->height,
-                           new_plane_state->rotation);
-       if (drm_rect_width(&r_pipe_cfg->src_rect) != 0)
-               drm_rect_rotate_inv(&r_pipe_cfg->src_rect,
-                                   new_plane_state->fb->width, new_plane_state->fb->height,
+               drm_rect_rotate_inv(&pipe_cfg->src_rect,
+                                   new_plane_state->fb->width,
+                                   new_plane_state->fb->height,
                                    new_plane_state->rotation);
 
+               if (drm_rect_width(&r_pipe_cfg->src_rect) != 0)
+                       drm_rect_rotate_inv(&r_pipe_cfg->src_rect,
+                                           new_plane_state->fb->width,
+                                           new_plane_state->fb->height,
+                                           new_plane_state->rotation);
+       }
+
        return 0;
 }
 
@@ -992,20 +1056,18 @@ static int dpu_plane_atomic_check_sspp(struct drm_plane *plane,
                drm_atomic_get_new_plane_state(state, plane);
        struct dpu_plane *pdpu = to_dpu_plane(plane);
        struct dpu_plane_state *pstate = to_dpu_plane_state(new_plane_state);
-       struct dpu_sw_pipe *pipe = &pstate->pipe[0];
-       struct dpu_sw_pipe *r_pipe = &pstate->pipe[1];
-       struct dpu_sw_pipe_cfg *pipe_cfg = &pstate->pipe_cfg[0];
-       struct dpu_sw_pipe_cfg *r_pipe_cfg = &pstate->pipe_cfg[1];
-       int ret = 0;
 
-       ret = dpu_plane_atomic_check_pipe(pdpu, pipe, pipe_cfg,
-                                         &crtc_state->adjusted_mode,
-                                         new_plane_state);
-       if (ret)
-               return ret;
+       struct dpu_sw_pipe *pipe;
+       struct dpu_sw_pipe_cfg *pipe_cfg;
+       int ret = 0, i;
 
-       if (drm_rect_width(&r_pipe_cfg->src_rect) != 0) {
-               ret = dpu_plane_atomic_check_pipe(pdpu, r_pipe, r_pipe_cfg,
+       for (i = 0; i < PIPES_PER_PLANE; i++) {
+               pipe = &pstate->pipe[i];
+               pipe_cfg = &pstate->pipe_cfg[i];
+               if (!drm_rect_width(&pipe_cfg->src_rect))
+                       continue;
+               DPU_DEBUG_PLANE(pdpu, "pipe %d is in use, validate it\n", i);
+               ret = dpu_plane_atomic_check_pipe(pdpu, pipe, pipe_cfg,
                                                  &crtc_state->adjusted_mode,
                                                  new_plane_state);
                if (ret)