Merge tag 'drm-misc-next-2018-02-13' of git://anongit.freedesktop.org/drm/drm-misc into drm-next

drm-misc-next for 4.17:

UAPI Changes:
- drm/vc4: Expose performance counters to userspace (Boris)

Cross-subsystem Changes:
- MAINTAINERS: Linus to maintain panel-arm-versatile in -misc (Linus)

Core Changes:
- Only use swiotlb when necessary (Chunming)

Driver Changes:
- drm/panel: Add support for ARM Versatile panels (Linus)
- pl111: Improvements around versatile panel support (Linus)

----------------------------------------
Tagged on 2018-02-06:
drm-misc-next for 4.17:

UAPI Changes:
- Validate mode flags + type (Ville)
- Deprecate unused mode flags PIXMUX, BCAST (Ville)
- Deprecate unused mode types BUILTIN, CRTC_C, CLOCK_C, DEFAULT (Ville)

Cross-subsystem Changes:
- MAINTAINERS: s/Daniel/Maarten/ for drm-misc (Daniel)

Core Changes:
- gem: Export gem functions for drivers to use (Samuel)
- bridge: Introduce bridge timings in drm_bridge (Linus)
- dma-buf: Allow exclusive fence to be bundled in fence array when
	   calling reservation_object_get_fences_rcu (Christian)
- dp: Add training pattern 4 and HBR3 support to dp helpers (Manasi)
- fourcc: Add alpha bit to formats to avoid driver format LUTs (Maxime)
- mode: Various cleanups + add new device-wide .mode_valid hook (Ville)
- atomic: Fix state leak when non-blocking commits fail (Leo)
	  NOTE: IIRC, this was cross-picked to -fixes so it might fall out
- crc: Allow polling on the data fd (Maarten)

Driver Changes:
- bridge/vga-dac: Add THS8134* support (Linus)
- tinydrm: Various MIPI DBI improvements/cleanups (Noralf)
- bridge/dw-mipi-dsi: Cleanups + use create_packet helper (Brian)
- drm/sun4i: Add Display Engine frontend support (Maxime)
- drm/sun4i: Add zpos support + increase num planes from 2 to 4 (Maxime)
- various: Use drm_mode_get_hv_timing() to fill plane clip rectangle (Ville)
- stm: Add 8-bit clut support, add dsi phy v1.31 support, +fixes (Phillipe)

Cc: Boris Brezillon <boris.brezillon@free-electrons.com>
Cc: Chunming Zhou <david1.zhou@amd.com>
Cc: Samuel Li <Samuel.Li@amd.com>
Cc: Linus Walleij <linus.walleij@linaro.org>
Cc: Noralf Trønnes <noralf@tronnes.org>
Cc: Brian Norris <briannorris@chromium.org>
Cc: Maxime Ripard <maxime.ripard@free-electrons.com>
Cc: Ville Syrjala <ville.syrjala@linux.intel.com>
Cc: Christian König <christian.koenig@amd.com>
Cc: Manasi Navare <manasi.d.navare@intel.com>
Cc: Philippe Cornu <philippe.cornu@st.com>
Cc: Leo (Sunpeng) Li <sunpeng.li@amd.com>
Cc: Daniel Vetter <daniel.vetter@ffwll.ch>
Cc: Maarten Lankhorst <maarten.lankhorst@linux.intel.com>

* tag 'drm-misc-next-2018-02-13' of git://anongit.freedesktop.org/drm/drm-misc: (115 commits)
  drm/radeon: only enable swiotlb path when need v2
  drm/amdgpu: only enable swiotlb alloc when need v2
  drm: add func to get max iomem address v2
  drm/vc4: Expose performance counters to userspace
  drm: Print the pid when debug logging an ioctl error.
  drm/stm: ltdc: remove non-alpha color formats on layer 2 for older hw
  drm/stm: ltdc: add non-alpha color formats
  drm/bridge/synopsys: dsi: Add 1.31 version support
  drm/bridge/synopsys: dsi: Add read feature
  drm/pl111: Support multiple endpoints on the CLCD
  drm/pl111: Support variants with broken VBLANK
  drm/pl111: Support variants with broken clock divider
  drm/pl111: Handle the Versatile RGB/BGR565 mode
  drm/pl111: Properly detect the ARM PL110 variants
  drm/panel: Add support for ARM Versatile panels
  drm/panel: Device tree bindings for ARM Versatile panels
  drm/bridge: Rename argument from crtc to bridge
  drm/crc: Add support for polling on the data fd.
  drm/sun4i: Use drm_mode_get_hv_timing() to populate plane clip rectangle
  drm/rcar-du: Use drm_mode_get_hv_timing() to populate plane clip rectangle
  ...

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),