1 files changed, 86 insertions, 31 deletions

diff --git a/drivers/gpu/drm/sun4i/sun4i_layer.c b/drivers/gpu/drm/sun4i/sun4i_layer.c
index 7bddf12548d3..19be798e4fac 100644
--- a/drivers/gpu/drm/sun4i/sun4i_layer.c
+++ b/drivers/gpu/drm/sun4i/sun4i_layer.c
@@ -15,34 +15,107 @@
 #include <drm/drmP.h>
 
 #include "sun4i_backend.h"
+#include "sun4i_frontend.h"
 #include "sun4i_layer.h"
 #include "sunxi_engine.h"
 
 struct sun4i_plane_desc {
-               enum drm_plane_type     type;
-               u8                      pipe;
-               const uint32_t          *formats;
-               uint32_t                nformats;
+        enum drm_plane_type     type;
+        u8                      pipe;
+        const uint32_t          *formats;
+        uint32_t                nformats;
 };
 
+static void sun4i_backend_layer_reset(struct drm_plane *plane)
+{
+        struct sun4i_layer *layer = plane_to_sun4i_layer(plane);
+        struct sun4i_layer_state *state;
+
+        if (plane->state) {
+                state = state_to_sun4i_layer_state(plane->state);
+
+                __drm_atomic_helper_plane_destroy_state(&state->state);
+
+                kfree(state);
+                plane->state = NULL;
+        }
+
+        state = kzalloc(sizeof(*state), GFP_KERNEL);
+        if (state) {
+                plane->state = &state->state;
+                plane->state->plane = plane;
+                plane->state->zpos = layer->id;
+        }
+}
+
+static struct drm_plane_state *
+sun4i_backend_layer_duplicate_state(struct drm_plane *plane)
+{
+        struct sun4i_layer_state *orig = state_to_sun4i_layer_state(plane->state);
+        struct sun4i_layer_state *copy;
+
+        copy = kzalloc(sizeof(*copy), GFP_KERNEL);
+        if (!copy)
+                return NULL;
+
+        __drm_atomic_helper_plane_duplicate_state(plane, &copy->state);
+        copy->uses_frontend = orig->uses_frontend;
+
+        return &copy->state;
+}
+
+static void sun4i_backend_layer_destroy_state(struct drm_plane *plane,
+                                              struct drm_plane_state *state)
+{
+        struct sun4i_layer_state *s_state = state_to_sun4i_layer_state(state);
+
+        __drm_atomic_helper_plane_destroy_state(state);
+
+        kfree(s_state);
+}
+
 static void sun4i_backend_layer_atomic_disable(struct drm_plane *plane,
                                                struct drm_plane_state *old_state)
 {
+        struct sun4i_layer_state *layer_state = state_to_sun4i_layer_state(old_state);
         struct sun4i_layer *layer = plane_to_sun4i_layer(plane);
         struct sun4i_backend *backend = layer->backend;
 
         sun4i_backend_layer_enable(backend, layer->id, false);
+
+        if (layer_state->uses_frontend) {
+                unsigned long flags;
+
+                spin_lock_irqsave(&backend->frontend_lock, flags);
+                backend->frontend_teardown = true;
+                spin_unlock_irqrestore(&backend->frontend_lock, flags);
+        }
 }
 
 static void sun4i_backend_layer_atomic_update(struct drm_plane *plane,
                                               struct drm_plane_state *old_state)
 {
+        struct sun4i_layer_state *layer_state = state_to_sun4i_layer_state(plane->state);
         struct sun4i_layer *layer = plane_to_sun4i_layer(plane);
         struct sun4i_backend *backend = layer->backend;
+        struct sun4i_frontend *frontend = backend->frontend;
+
+        if (layer_state->uses_frontend) {
+                sun4i_frontend_init(frontend);
+                sun4i_frontend_update_coord(frontend, plane);
+                sun4i_frontend_update_buffer(frontend, plane);
+                sun4i_frontend_update_formats(frontend, plane,
+                                              DRM_FORMAT_ARGB8888);
+                sun4i_backend_update_layer_frontend(backend, layer->id,
+                                                    DRM_FORMAT_ARGB8888);
+                sun4i_frontend_enable(frontend);
+        } else {
+                sun4i_backend_update_layer_formats(backend, layer->id, plane);
+                sun4i_backend_update_layer_buffer(backend, layer->id, plane);
+        }
 
         sun4i_backend_update_layer_coord(backend, layer->id, plane);
-        sun4i_backend_update_layer_formats(backend, layer->id, plane);
-        sun4i_backend_update_layer_buffer(backend, layer->id, plane);
+        sun4i_backend_update_layer_zpos(backend, layer->id, plane);
         sun4i_backend_layer_enable(backend, layer->id, true);
 }
 
@@ -52,11 +125,11 @@ static const struct drm_plane_helper_funcs sun4i_backend_layer_helper_funcs = {
 };
 
 static const struct drm_plane_funcs sun4i_backend_layer_funcs = {
-        .atomic_destroy_state   = drm_atomic_helper_plane_destroy_state,
-        .atomic_duplicate_state = drm_atomic_helper_plane_duplicate_state,
+        .atomic_destroy_state   = sun4i_backend_layer_destroy_state,
+        .atomic_duplicate_state = sun4i_backend_layer_duplicate_state,
         .destroy                = drm_plane_cleanup,
         .disable_plane          = drm_atomic_helper_disable_plane,
-        .reset                  = drm_atomic_helper_plane_reset,
+        .reset                  = sun4i_backend_layer_reset,
         .update_plane           = drm_atomic_helper_update_plane,
 };
 
@@ -128,32 +201,12 @@ struct drm_plane **sun4i_layers_init(struct drm_device *drm,
         struct sun4i_backend *backend = engine_to_sun4i_backend(engine);
         int i;
 
-        planes = devm_kcalloc(drm->dev, ARRAY_SIZE(sun4i_backend_planes) + 1,
+        /* We need to have a sentinel at the need, hence the overallocation */
+        planes = devm_kcalloc(drm->dev, SUN4I_BACKEND_NUM_LAYERS + 1,
                               sizeof(*planes), GFP_KERNEL);
         if (!planes)
                 return ERR_PTR(-ENOMEM);
 
-        /*
-         * The hardware is a bit unusual here.
-         *
-         * Even though it supports 4 layers, it does the composition
-         * in two separate steps.
-         *
-         * The first one is assigning a layer to one of its two
-         * pipes. If more that 1 layer is assigned to the same pipe,
-         * and if pixels overlaps, the pipe will take the pixel from
-         * the layer with the highest priority.
-         *
-         * The second step is the actual alpha blending, that takes
-         * the two pipes as input, and uses the eventual alpha
-         * component to do the transparency between the two.
-         *
-         * This two steps scenario makes us unable to guarantee a
-         * robust alpha blending between the 4 layers in all
-         * situations. So we just expose two layers, one per pipe. On
-         * SoCs that support it, sprites could fill the need for more
-         * layers.
-         */
         for (i = 0; i < ARRAY_SIZE(sun4i_backend_planes); i++) {
                 const struct sun4i_plane_desc *plane = &sun4i_backend_planes[i];
                 struct sun4i_layer *layer;
@@ -165,6 +218,8 @@ struct drm_plane **sun4i_layers_init(struct drm_device *drm,
                         return ERR_CAST(layer);
                 };
 
+                drm_plane_create_zpos_immutable_property(&layer->plane, i);
+
                 DRM_DEBUG_DRIVER("Assigning %s plane to pipe %d\n",
                                  i ? "overlay" : "primary", plane->pipe);
                 regmap_update_bits(engine->regs, SUN4I_BACKEND_ATTCTL_REG0(i),