Merge airlied/drm-next into drm-misc-next

Bake in the conflict between the drm_print.h extraction and the
addition of DRM_DEBUG_LEASES since we lost it a few too many times.

Also fix a new use of drm_plane_helper_check_state in msm to follow
Ville's conversion in

commit a01cb8ba3f6282934cff65e89ab36b18b14cbe27
Author: Ville Syrjälä <ville.syrjala@linux.intel.com>
Date:   Wed Nov 1 22:16:19 2017 +0200

    drm: Move drm_plane_helper_check_state() into drm_atomic_helper.c

Acked-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>

diff --cc MAINTAINERS
Simple merge

diff --cc drivers/gpu/drm/amd/amdgpu/amdgpu_connectors.c
Simple merge

diff --cc drivers/gpu/drm/drm_atomic.c
Simple merge

diff --cc drivers/gpu/drm/drm_atomic_helper.c
Simple merge

diff --cc drivers/gpu/drm/drm_drv.c
Simple merge

diff --cc drivers/gpu/drm/drm_framebuffer.c
Simple merge

diff --cc drivers/gpu/drm/drm_internal.h
Simple merge

diff --cc drivers/gpu/drm/drm_syncobj.c
Simple merge

diff --cc drivers/gpu/drm/i915/intel_display.c
Simple merge

diff --cc drivers/gpu/drm/i915/intel_dp.c
Simple merge

diff --cc drivers/gpu/drm/i915/intel_modes.c
index b398466,28a778b..4e43f87
--- 1/drivers/gpu/drm/i915/intel_modes.c
--- 2/drivers/gpu/drm/i915/intel_modes.c
+++ b/drivers/gpu/drm/i915/intel_modes.c
@@@ -42,7 -57,10 +57,9 @@@ int intel_connector_update_modes(struc
  
        drm_mode_connector_update_edid_property(connector, edid);
        ret = drm_add_edid_modes(connector, edid);
 -      drm_edid_to_eld(connector, edid);
  
+       intel_connector_update_eld_conn_type(connector);
+ 
        return ret;
  }
  

diff --cc drivers/gpu/drm/msm/mdp/mdp5/mdp5_plane.c
index df3360a,be50445..ee41423
--- 1/drivers/gpu/drm/msm/mdp/mdp5/mdp5_plane.c
--- 2/drivers/gpu/drm/msm/mdp/mdp5/mdp5_plane.c
+++ b/drivers/gpu/drm/msm/mdp/mdp5/mdp5_plane.c
@@@ -488,6 -465,91 +466,92 @@@ static void mdp5_plane_atomic_update(st
        }
  }
  
 -      ret = drm_plane_helper_check_state(state, &clip, min_scale,
 -                                         max_scale, true, true);
+ static int mdp5_plane_atomic_async_check(struct drm_plane *plane,
+                                        struct drm_plane_state *state)
+ {
+       struct mdp5_plane_state *mdp5_state = to_mdp5_plane_state(state);
+       struct drm_crtc_state *crtc_state;
+       struct drm_rect clip;
+       int min_scale, max_scale;
+       int ret;
+ 
+       crtc_state = drm_atomic_get_existing_crtc_state(state->state,
+                                                       state->crtc);
+       if (WARN_ON(!crtc_state))
+               return -EINVAL;
+ 
+       if (!crtc_state->active)
+               return -EINVAL;
+ 
+       mdp5_state = to_mdp5_plane_state(state);
+ 
+       /* don't use fast path if we don't have a hwpipe allocated yet */
+       if (!mdp5_state->hwpipe)
+               return -EINVAL;
+ 
+       /* only allow changing of position(crtc x/y or src x/y) in fast path */
+       if (plane->state->crtc != state->crtc ||
+           plane->state->src_w != state->src_w ||
+           plane->state->src_h != state->src_h ||
+           plane->state->crtc_w != state->crtc_w ||
+           plane->state->crtc_h != state->crtc_h ||
+           !plane->state->fb ||
+           plane->state->fb != state->fb)
+               return -EINVAL;
+ 
+       clip.x1 = 0;
+       clip.y1 = 0;
+       clip.x2 = crtc_state->adjusted_mode.hdisplay;
+       clip.y2 = crtc_state->adjusted_mode.vdisplay;
+       min_scale = FRAC_16_16(1, 8);
+       max_scale = FRAC_16_16(8, 1);
+ 
++      ret = drm_atomic_helper_check_plane_state(state, crtc_state, &clip,
++                                                min_scale, max_scale,
++                                                true, true);
+       if (ret)
+               return ret;
+ 
+       /*
+        * if the visibility of the plane changes (i.e, if the cursor is
+        * clipped out completely, we can't take the async path because
+        * we need to stage/unstage the plane from the Layer Mixer(s). We
+        * also assign/unassign the hwpipe(s) tied to the plane. We avoid
+        * taking the fast path for both these reasons.
+        */
+       if (state->visible != plane->state->visible)
+               return -EINVAL;
+ 
+       return 0;
+ }
+ 
+ static void mdp5_plane_atomic_async_update(struct drm_plane *plane,
+                                          struct drm_plane_state *new_state)
+ {
+       plane->state->src_x = new_state->src_x;
+       plane->state->src_y = new_state->src_y;
+       plane->state->crtc_x = new_state->crtc_x;
+       plane->state->crtc_y = new_state->crtc_y;
+ 
+       if (plane_enabled(new_state)) {
+               struct mdp5_ctl *ctl;
+               struct mdp5_pipeline *pipeline =
+                                       mdp5_crtc_get_pipeline(plane->crtc);
+               int ret;
+ 
+               ret = mdp5_plane_mode_set(plane, new_state->crtc, new_state->fb,
+                               &new_state->src, &new_state->dst);
+               WARN_ON(ret < 0);
+ 
+               ctl = mdp5_crtc_get_ctl(new_state->crtc);
+ 
+               mdp5_ctl_commit(ctl, pipeline, mdp5_plane_get_flush(plane));
+       }
+ 
+       *to_mdp5_plane_state(plane->state) =
+               *to_mdp5_plane_state(new_state);
+ }
+ 
  static const struct drm_plane_helper_funcs mdp5_plane_helper_funcs = {
                .prepare_fb = mdp5_plane_prepare_fb,
                .cleanup_fb = mdp5_plane_cleanup_fb,

diff --cc drivers/gpu/drm/nouveau/nv50_display.c
Simple merge

diff --cc drivers/gpu/drm/qxl/qxl_ttm.c
Simple merge

diff --cc drivers/gpu/drm/radeon/radeon_connectors.c
Simple merge

diff --cc drivers/gpu/drm/rockchip/analogix_dp-rockchip.c
Simple merge

diff --cc drivers/gpu/drm/tegra/dc.c
Simple merge

diff --cc drivers/gpu/drm/tegra/output.c
Simple merge

diff --cc drivers/gpu/drm/vmwgfx/vmwgfx_kms.c
Simple merge

diff --cc include/drm/drm_connector.h
Simple merge

diff --cc include/drm/drm_dp_helper.h
Simple merge

diff --cc include/drm/drm_drv.h
Simple merge

diff --cc include/drm/drm_encoder.h
Simple merge

diff --cc include/drm/drm_framebuffer.h
Simple merge

diff --cc include/drm/drm_mode_config.h
Simple merge

diff --cc include/drm/drm_plane.h
Simple merge

diff --cc include/drm/drm_print.h
index 7dbfdeb,ca4d7c6..0968e41
--- 1/include/drm/drm_print.h
--- 2/include/drm/drm_print.h
+++ b/include/drm/drm_print.h
@@@ -136,196 -128,4 +136,200 @@@ static inline struct drm_printer drm_de
        };
        return p;
  }
 +
 +/*
 + * The following categories are defined:
 + *
 + * CORE: Used in the generic drm code: drm_ioctl.c, drm_mm.c, drm_memory.c, ...
 + *     This is the category used by the DRM_DEBUG() macro.
 + *
 + * DRIVER: Used in the vendor specific part of the driver: i915, radeon, ...
 + *       This is the category used by the DRM_DEBUG_DRIVER() macro.
 + *
 + * KMS: used in the modesetting code.
 + *    This is the category used by the DRM_DEBUG_KMS() macro.
 + *
 + * PRIME: used in the prime code.
 + *      This is the category used by the DRM_DEBUG_PRIME() macro.
 + *
 + * ATOMIC: used in the atomic code.
 + *      This is the category used by the DRM_DEBUG_ATOMIC() macro.
 + *
 + * VBL: used for verbose debug message in the vblank code
 + *      This is the category used by the DRM_DEBUG_VBL() macro.
 + *
 + * Enabling verbose debug messages is done through the drm.debug parameter,
 + * each category being enabled by a bit.
 + *
 + * drm.debug=0x1 will enable CORE messages
 + * drm.debug=0x2 will enable DRIVER messages
 + * drm.debug=0x3 will enable CORE and DRIVER messages
 + * ...
 + * drm.debug=0x3f will enable all messages
 + *
 + * An interesting feature is that it's possible to enable verbose logging at
 + * run-time by echoing the debug value in its sysfs node:
 + *   # echo 0xf > /sys/module/drm/parameters/debug
 + */
 +#define DRM_UT_NONE           0x00
 +#define DRM_UT_CORE           0x01
 +#define DRM_UT_DRIVER         0x02
 +#define DRM_UT_KMS            0x04
 +#define DRM_UT_PRIME          0x08
 +#define DRM_UT_ATOMIC         0x10
 +#define DRM_UT_VBL            0x20
 +#define DRM_UT_STATE          0x40
++#define DRM_UT_LEASE          0x80
 +
 +__printf(6, 7)
 +void drm_dev_printk(const struct device *dev, const char *level,
 +                  unsigned int category, const char *function_name,
 +                  const char *prefix, const char *format, ...);
 +__printf(3, 4)
 +void drm_printk(const char *level, unsigned int category,
 +              const char *format, ...);
 +
 +/* Macros to make printk easier */
 +
 +#define _DRM_PRINTK(once, level, fmt, ...)                            \
 +      do {                                                            \
 +              printk##once(KERN_##level "[" DRM_NAME "] " fmt,        \
 +                           ##__VA_ARGS__);                            \
 +      } while (0)
 +
 +#define DRM_INFO(fmt, ...)                                            \
 +      _DRM_PRINTK(, INFO, fmt, ##__VA_ARGS__)
 +#define DRM_NOTE(fmt, ...)                                            \
 +      _DRM_PRINTK(, NOTICE, fmt, ##__VA_ARGS__)
 +#define DRM_WARN(fmt, ...)                                            \
 +      _DRM_PRINTK(, WARNING, fmt, ##__VA_ARGS__)
 +
 +#define DRM_INFO_ONCE(fmt, ...)                                               \
 +      _DRM_PRINTK(_once, INFO, fmt, ##__VA_ARGS__)
 +#define DRM_NOTE_ONCE(fmt, ...)                                               \
 +      _DRM_PRINTK(_once, NOTICE, fmt, ##__VA_ARGS__)
 +#define DRM_WARN_ONCE(fmt, ...)                                               \
 +      _DRM_PRINTK(_once, WARNING, fmt, ##__VA_ARGS__)
 +
 +/**
 + * Error output.
 + *
 + * @dev: device pointer
 + * @fmt: printf() like format string.
 + */
 +#define DRM_DEV_ERROR(dev, fmt, ...)                                  \
 +      drm_dev_printk(dev, KERN_ERR, DRM_UT_NONE, __func__, " *ERROR*",\
 +                     fmt, ##__VA_ARGS__)
 +#define DRM_ERROR(fmt, ...)                                           \
 +      drm_printk(KERN_ERR, DRM_UT_NONE, fmt,  ##__VA_ARGS__)
 +
 +/**
 + * Rate limited error output.  Like DRM_ERROR() but won't flood the log.
 + *
 + * @dev: device pointer
 + * @fmt: printf() like format string.
 + */
 +#define DRM_DEV_ERROR_RATELIMITED(dev, fmt, ...)                      \
 +({                                                                    \
 +      static DEFINE_RATELIMIT_STATE(_rs,                              \
 +                                    DEFAULT_RATELIMIT_INTERVAL,       \
 +                                    DEFAULT_RATELIMIT_BURST);         \
 +                                                                      \
 +      if (__ratelimit(&_rs))                                          \
 +              DRM_DEV_ERROR(dev, fmt, ##__VA_ARGS__);                 \
 +})
 +#define DRM_ERROR_RATELIMITED(fmt, ...)                                       \
 +      DRM_DEV_ERROR_RATELIMITED(NULL, fmt, ##__VA_ARGS__)
 +
 +#define DRM_DEV_INFO(dev, fmt, ...)                                   \
 +      drm_dev_printk(dev, KERN_INFO, DRM_UT_NONE, __func__, "", fmt,  \
 +                     ##__VA_ARGS__)
 +
 +#define DRM_DEV_INFO_ONCE(dev, fmt, ...)                              \
 +({                                                                    \
 +      static bool __print_once __read_mostly;                         \
 +      if (!__print_once) {                                            \
 +              __print_once = true;                                    \
 +              DRM_DEV_INFO(dev, fmt, ##__VA_ARGS__);                  \
 +      }                                                               \
 +})
 +
 +/**
 + * Debug output.
 + *
 + * @dev: device pointer
 + * @fmt: printf() like format string.
 + */
 +#define DRM_DEV_DEBUG(dev, fmt, args...)                              \
 +      drm_dev_printk(dev, KERN_DEBUG, DRM_UT_CORE, __func__, "", fmt, \
 +                     ##args)
 +#define DRM_DEBUG(fmt, ...)                                           \
 +      drm_printk(KERN_DEBUG, DRM_UT_CORE, fmt, ##__VA_ARGS__)
 +
 +#define DRM_DEV_DEBUG_DRIVER(dev, fmt, args...)                               \
 +      drm_dev_printk(dev, KERN_DEBUG, DRM_UT_DRIVER, __func__, "",    \
 +                     fmt, ##args)
 +#define DRM_DEBUG_DRIVER(fmt, ...)                                    \
 +      drm_printk(KERN_DEBUG, DRM_UT_DRIVER, fmt, ##__VA_ARGS__)
 +
 +#define DRM_DEV_DEBUG_KMS(dev, fmt, args...)                          \
 +      drm_dev_printk(dev, KERN_DEBUG, DRM_UT_KMS, __func__, "", fmt,  \
 +                     ##args)
 +#define DRM_DEBUG_KMS(fmt, ...)                                       \
 +      drm_printk(KERN_DEBUG, DRM_UT_KMS, fmt, ##__VA_ARGS__)
 +
 +#define DRM_DEV_DEBUG_PRIME(dev, fmt, args...)                                \
 +      drm_dev_printk(dev, KERN_DEBUG, DRM_UT_PRIME, __func__, "",     \
 +                     fmt, ##args)
 +#define DRM_DEBUG_PRIME(fmt, ...)                                     \
 +      drm_printk(KERN_DEBUG, DRM_UT_PRIME, fmt, ##__VA_ARGS__)
 +
 +#define DRM_DEV_DEBUG_ATOMIC(dev, fmt, args...)                               \
 +      drm_dev_printk(dev, KERN_DEBUG, DRM_UT_ATOMIC, __func__, "",    \
 +                     fmt, ##args)
 +#define DRM_DEBUG_ATOMIC(fmt, ...)                                    \
 +      drm_printk(KERN_DEBUG, DRM_UT_ATOMIC, fmt, ##__VA_ARGS__)
 +
 +#define DRM_DEV_DEBUG_VBL(dev, fmt, args...)                          \
 +      drm_dev_printk(dev, KERN_DEBUG, DRM_UT_VBL, __func__, "", fmt,  \
 +                     ##args)
 +#define DRM_DEBUG_VBL(fmt, ...)                                       \
 +      drm_printk(KERN_DEBUG, DRM_UT_VBL, fmt, ##__VA_ARGS__)
 +
++#define DRM_DEBUG_LEASE(fmt, ...)                                     \
++      drm_printk(KERN_DEBUG, DRM_UT_LEASE, fmt, ##__VA_ARGS__)
++
 +#define _DRM_DEV_DEFINE_DEBUG_RATELIMITED(dev, level, fmt, args...)   \
 +({                                                                    \
 +      static DEFINE_RATELIMIT_STATE(_rs,                              \
 +                                    DEFAULT_RATELIMIT_INTERVAL,       \
 +                                    DEFAULT_RATELIMIT_BURST);         \
 +      if (__ratelimit(&_rs))                                          \
 +              drm_dev_printk(dev, KERN_DEBUG, DRM_UT_ ## level,       \
 +                             __func__, "", fmt, ##args);              \
 +})
 +
 +/**
 + * Rate limited debug output. Like DRM_DEBUG() but won't flood the log.
 + *
 + * @dev: device pointer
 + * @fmt: printf() like format string.
 + */
 +#define DRM_DEV_DEBUG_RATELIMITED(dev, fmt, args...)                  \
 +      DEV__DRM_DEFINE_DEBUG_RATELIMITED(dev, CORE, fmt, ##args)
 +#define DRM_DEBUG_RATELIMITED(fmt, args...)                           \
 +      DRM_DEV_DEBUG_RATELIMITED(NULL, fmt, ##args)
 +#define DRM_DEV_DEBUG_DRIVER_RATELIMITED(dev, fmt, args...)           \
 +      _DRM_DEV_DEFINE_DEBUG_RATELIMITED(dev, DRIVER, fmt, ##args)
 +#define DRM_DEBUG_DRIVER_RATELIMITED(fmt, args...)                    \
 +      DRM_DEV_DEBUG_DRIVER_RATELIMITED(NULL, fmt, ##args)
 +#define DRM_DEV_DEBUG_KMS_RATELIMITED(dev, fmt, args...)              \
 +      _DRM_DEV_DEFINE_DEBUG_RATELIMITED(dev, KMS, fmt, ##args)
 +#define DRM_DEBUG_KMS_RATELIMITED(fmt, args...)                               \
 +      DRM_DEV_DEBUG_KMS_RATELIMITED(NULL, fmt, ##args)
 +#define DRM_DEV_DEBUG_PRIME_RATELIMITED(dev, fmt, args...)            \
 +      _DRM_DEV_DEFINE_DEBUG_RATELIMITED(dev, PRIME, fmt, ##args)
 +#define DRM_DEBUG_PRIME_RATELIMITED(fmt, args...)                     \
 +      DRM_DEV_DEBUG_PRIME_RATELIMITED(NULL, fmt, ##args)
 +
  #endif /* DRM_PRINT_H_ */

diff --cc include/drm/drm_syncobj.h
Simple merge