drm/vc4: Add support for YUV planes.

This supports 420 and 422 subsampling with 2 or 3 planes, tested with
modetest.  It doesn't set up chroma subsampling position (which it
appears KMS doesn't deal with yet).

The LBM memory is overallocated in many cases, but apparently the docs
aren't quite correct and I'll probably need to look at the hardware
source to really figure it out.

Signed-off-by: Eric Anholt <eric@anholt.net>

2 files changed, 253 insertions, 59 deletions

diff --git a/drivers/gpu/drm/vc4/vc4_plane.c b/drivers/gpu/drm/vc4/vc4_plane.c
index 013ebff60fb5..7b0c72ae02a0 100644
--- a/drivers/gpu/drm/vc4/vc4_plane.c
+++ b/drivers/gpu/drm/vc4/vc4_plane.c
@@ -54,15 +54,19 @@ struct vc4_plane_state {
         /* Clipped coordinates of the plane on the display. */
         int crtc_x, crtc_y, crtc_w, crtc_h;
         /* Clipped area being scanned from in the FB. */
-        u32 src_x, src_y, src_w, src_h;
+        u32 src_x, src_y;
 
-        enum vc4_scaling_mode x_scaling, y_scaling;
+        u32 src_w[2], src_h[2];
+
+        /* Scaling selection for the RGB/Y plane and the Cb/Cr planes. */
+        enum vc4_scaling_mode x_scaling[2], y_scaling[2];
         bool is_unity;
+        bool is_yuv;
 
         /* Offset to start scanning out from the start of the plane's
          * BO.
          */
-        u32 offset;
+        u32 offsets[3];
 
         /* Our allocation in LBM for temporary storage during scaling. */
         struct drm_mm_node lbm;
@@ -79,6 +83,7 @@ static const struct hvs_format {
         u32 hvs; /* HVS_FORMAT_* */
         u32 pixel_order;
         bool has_alpha;
+        bool flip_cbcr;
 } hvs_formats[] = {
         {
                 .drm = DRM_FORMAT_XRGB8888, .hvs = HVS_PIXEL_FORMAT_RGBA8888,
@@ -104,6 +109,32 @@ static const struct hvs_format {
                 .drm = DRM_FORMAT_XRGB1555, .hvs = HVS_PIXEL_FORMAT_RGBA5551,
                 .pixel_order = HVS_PIXEL_ORDER_ABGR, .has_alpha = false,
         },
+        {
+                .drm = DRM_FORMAT_YUV422,
+                .hvs = HVS_PIXEL_FORMAT_YCBCR_YUV422_3PLANE,
+        },
+        {
+                .drm = DRM_FORMAT_YVU422,
+                .hvs = HVS_PIXEL_FORMAT_YCBCR_YUV422_3PLANE,
+                .flip_cbcr = true,
+        },
+        {
+                .drm = DRM_FORMAT_YUV420,
+                .hvs = HVS_PIXEL_FORMAT_YCBCR_YUV420_3PLANE,
+        },
+        {
+                .drm = DRM_FORMAT_YVU420,
+                .hvs = HVS_PIXEL_FORMAT_YCBCR_YUV420_3PLANE,
+                .flip_cbcr = true,
+        },
+        {
+                .drm = DRM_FORMAT_NV12,
+                .hvs = HVS_PIXEL_FORMAT_YCBCR_YUV420_2PLANE,
+        },
+        {
+                .drm = DRM_FORMAT_NV16,
+                .hvs = HVS_PIXEL_FORMAT_YCBCR_YUV422_2PLANE,
+        },
 };
 
 static const struct hvs_format *vc4_get_hvs_format(u32 drm_format)
@@ -219,11 +250,11 @@ static void vc4_dlist_write(struct vc4_plane_state *vc4_state, u32 val)
  *
  * This is a replication of a table from the spec.
  */
-static u32 vc4_get_scl_field(struct drm_plane_state *state)
+static u32 vc4_get_scl_field(struct drm_plane_state *state, int plane)
 {
         struct vc4_plane_state *vc4_state = to_vc4_plane_state(state);
 
-        switch (vc4_state->x_scaling << 2 | vc4_state->y_scaling) {
+        switch (vc4_state->x_scaling[plane] << 2 | vc4_state->y_scaling[plane]) {
         case VC4_SCALING_PPF << 2 | VC4_SCALING_PPF:
                 return SCALER_CTL0_SCL_H_PPF_V_PPF;
         case VC4_SCALING_TPZ << 2 | VC4_SCALING_PPF:
@@ -254,9 +285,16 @@ static int vc4_plane_setup_clipping_and_scaling(struct drm_plane_state *state)
         struct drm_plane *plane = state->plane;
         struct vc4_plane_state *vc4_state = to_vc4_plane_state(state);
         struct drm_framebuffer *fb = state->fb;
+        struct drm_gem_cma_object *bo = drm_fb_cma_get_gem_obj(fb, 0);
         u32 subpixel_src_mask = (1 << 16) - 1;
+        u32 format = fb->pixel_format;
+        int num_planes = drm_format_num_planes(format);
+        u32 h_subsample = 1;
+        u32 v_subsample = 1;
+        int i;
 
-        vc4_state->offset = fb->offsets[0];
+        for (i = 0; i < num_planes; i++)
+                vc4_state->offsets[i] = bo->paddr + fb->offsets[i];
 
         /* We don't support subpixel source positioning for scaling. */
         if ((state->src_x & subpixel_src_mask) ||
@@ -268,20 +306,48 @@ static int vc4_plane_setup_clipping_and_scaling(struct drm_plane_state *state)
 
         vc4_state->src_x = state->src_x >> 16;
         vc4_state->src_y = state->src_y >> 16;
-        vc4_state->src_w = state->src_w >> 16;
-        vc4_state->src_h = state->src_h >> 16;
+        vc4_state->src_w[0] = state->src_w >> 16;
+        vc4_state->src_h[0] = state->src_h >> 16;
 
         vc4_state->crtc_x = state->crtc_x;
         vc4_state->crtc_y = state->crtc_y;
         vc4_state->crtc_w = state->crtc_w;
         vc4_state->crtc_h = state->crtc_h;
 
-        vc4_state->x_scaling = vc4_get_scaling_mode(vc4_state->src_w,
-                                                    vc4_state->crtc_w);
-        vc4_state->y_scaling = vc4_get_scaling_mode(vc4_state->src_h,
-                                                    vc4_state->crtc_h);
-        vc4_state->is_unity = (vc4_state->x_scaling == VC4_SCALING_NONE &&
-                               vc4_state->y_scaling == VC4_SCALING_NONE);
+        vc4_state->x_scaling[0] = vc4_get_scaling_mode(vc4_state->src_w[0],
+                                                       vc4_state->crtc_w);
+        vc4_state->y_scaling[0] = vc4_get_scaling_mode(vc4_state->src_h[0],
+                                                       vc4_state->crtc_h);
+
+        if (num_planes > 1) {
+                vc4_state->is_yuv = true;
+
+                h_subsample = drm_format_horz_chroma_subsampling(format);
+                v_subsample = drm_format_vert_chroma_subsampling(format);
+                vc4_state->src_w[1] = vc4_state->src_w[0] / h_subsample;
+                vc4_state->src_h[1] = vc4_state->src_h[0] / v_subsample;
+
+                vc4_state->x_scaling[1] =
+                        vc4_get_scaling_mode(vc4_state->src_w[1],
+                                             vc4_state->crtc_w);
+                vc4_state->y_scaling[1] =
+                        vc4_get_scaling_mode(vc4_state->src_h[1],
+                                             vc4_state->crtc_h);
+
+                /* YUV conversion requires that scaling be enabled,
+                 * even on a plane that's otherwise 1:1.  Choose TPZ
+                 * for simplicity.
+                 */
+                if (vc4_state->x_scaling[0] == VC4_SCALING_NONE)
+                        vc4_state->x_scaling[0] = VC4_SCALING_TPZ;
+                if (vc4_state->y_scaling[0] == VC4_SCALING_NONE)
+                        vc4_state->y_scaling[0] = VC4_SCALING_TPZ;
+        }
+
+        vc4_state->is_unity = (vc4_state->x_scaling[0] == VC4_SCALING_NONE &&
+                               vc4_state->y_scaling[0] == VC4_SCALING_NONE &&
+                               vc4_state->x_scaling[1] == VC4_SCALING_NONE &&
+                               vc4_state->y_scaling[1] == VC4_SCALING_NONE);
 
         /* No configuring scaling on the cursor plane, since it gets
            non-vblank-synced updates, and scaling requires requires
@@ -294,16 +360,27 @@ static int vc4_plane_setup_clipping_and_scaling(struct drm_plane_state *state)
          * support negative y, and negative x wastes bandwidth.
          */
         if (vc4_state->crtc_x < 0) {
-                vc4_state->offset += (drm_format_plane_cpp(fb->pixel_format,
-                                                           0) *
-                                      -vc4_state->crtc_x);
-                vc4_state->src_w += vc4_state->crtc_x;
+                for (i = 0; i < num_planes; i++) {
+                        u32 cpp = drm_format_plane_cpp(fb->pixel_format, i);
+                        u32 subs = ((i == 0) ? 1 : h_subsample);
+
+                        vc4_state->offsets[i] += (cpp *
+                                                  (-vc4_state->crtc_x) / subs);
+                }
+                vc4_state->src_w[0] += vc4_state->crtc_x;
+                vc4_state->src_w[1] += vc4_state->crtc_x / h_subsample;
                 vc4_state->crtc_x = 0;
         }