Merge tag 'drm-intel-next-2014-06-20' of git://anongit.freedesktop.org/drm-intel into drm-next

- Accurate frontbuffer tracking and frontbuffer rendering invalidate, flush and
  flip events. This is prep work for proper PSR support and should also be
  useful for DRRS&fbc.
- Runtime suspend hardware on system suspend to support the new SOix sleep
  states, from Jesse.
- PSR updates for broadwell (Rodrigo)
- Universal plane support for cursors (Matt Roper), including core drm patches.
- Prefault gtt mappings (Chris)
- baytrail write-enable pte bit support (Akash Goel)
- mmio based flips (Sourab Gupta) instead of blitter ring flips
- interrupt handling race fixes (Oscar Mateo)

And old, not yet merged features from the previous round:
- rps/turbo support for chv (Deepak)
- some other straggling chv patches (Ville)
- proper universal plane conversion for the primary plane (Matt Roper)
- ppgtt on vlv from Jesse
- pile of cleanups, little fixes for insane corner cases and improved debug
  support all over

* tag 'drm-intel-next-2014-06-20' of git://anongit.freedesktop.org/drm-intel: (99 commits)
  drm/i915: Update DRIVER_DATE to 20140620
  drivers/i915: Fix unnoticed failure of init_ring_common()
  drm/i915: Track frontbuffer invalidation/flushing
  drm/i915: Use new frontbuffer bits to increase pll clock
  drm/i915: don't take runtime PM reference around freeze/thaw
  drm/i915: use runtime irq suspend/resume in freeze/thaw
  drm/i915: Properly track domain of the fbcon fb
  drm/i915: Print obj->frontbuffer_bits in debugfs output
  drm/i915: Introduce accurate frontbuffer tracking
  drm/i915: Drop schedule_back from psr_exit
  drm/i915: Ditch intel_edp_psr_update
  drm/i915: Drop unecessary complexity from psr_inactivate
  drm/i915: Remove ctx->last_ring
  drm/i915/chv: Ack interrupts before handling them (CHV)
  drm/i915/bdw: Ack interrupts before handling them (GEN8)
  drm/i915/vlv: Ack interrupts before handling them (VLV)
  drm/i915: Ack interrupts before handling them (GEN5 - GEN7)
  drm/i915: Don't BUG_ON in i915_gem_obj_offset
  drm/i915: Grab dev->struct_mutex in i915_gem_pageflip_info
  drm/i915: Add some L3 registers to the parser whitelist
  ...

Conflicts:
	drivers/gpu/drm/i915/i915_drv.c

1 files changed, 255 insertions, 102 deletions

diff --git a/drivers/gpu/drm/drm_crtc.c b/drivers/gpu/drm/drm_crtc.c
index bd7422676638..c808a092d824 100644
--- a/drivers/gpu/drm/drm_crtc.c
+++ b/drivers/gpu/drm/drm_crtc.c
@@ -41,6 +41,10 @@
 
 #include "drm_crtc_internal.h"
 
+static struct drm_framebuffer *add_framebuffer_internal(struct drm_device *dev,
+                                                        struct drm_mode_fb_cmd2 *r,
+                                                        struct drm_file *file_priv);
+
 /**
  * drm_modeset_lock_all - take all modeset locks
  * @dev: drm device
@@ -723,7 +727,7 @@ DEFINE_WW_CLASS(crtc_ww_class);
  */
 int drm_crtc_init_with_planes(struct drm_device *dev, struct drm_crtc *crtc,
                               struct drm_plane *primary,
-                              void *cursor,
+                              struct drm_plane *cursor,
                               const struct drm_crtc_funcs *funcs)
 {
         struct drm_mode_config *config = &dev->mode_config;
@@ -748,8 +752,11 @@ int drm_crtc_init_with_planes(struct drm_device *dev, struct drm_crtc *crtc,
         config->num_crtc++;
 
         crtc->primary = primary;
+        crtc->cursor = cursor;
         if (primary)
                 primary->possible_crtcs = 1 << drm_crtc_index(crtc);
+        if (cursor)
+                cursor->possible_crtcs = 1 << drm_crtc_index(crtc);
 
  out:
         drm_modeset_unlock_all(dev);
@@ -2177,45 +2184,32 @@ out:
         return ret;
 }
 
-/**
- * drm_mode_setplane - configure a plane's configuration
- * @dev: DRM device
- * @data: ioctl data*
- * @file_priv: DRM file info
+/*
+ * setplane_internal - setplane handler for internal callers
  *
- * Set plane configuration, including placement, fb, scaling, and other factors.
- * Or pass a NULL fb to disable.
+ * Note that we assume an extra reference has already been taken on fb.  If the
+ * update fails, this reference will be dropped before return; if it succeeds,
+ * the previous framebuffer (if any) will be unreferenced instead.
  *
- * Returns:
- * Zero on success, errno on failure.
+ * src_{x,y,w,h} are provided in 16.16 fixed point format
  */
-int drm_mode_setplane(struct drm_device *dev, void *data,
-                      struct drm_file *file_priv)
+static int setplane_internal(struct drm_plane *plane,
+                             struct drm_crtc *crtc,
+                             struct drm_framebuffer *fb,
+                             int32_t crtc_x, int32_t crtc_y,
+                             uint32_t crtc_w, uint32_t crtc_h,
+                             /* src_{x,y,w,h} values are 16.16 fixed point */
+                             uint32_t src_x, uint32_t src_y,
+                             uint32_t src_w, uint32_t src_h)
 {
-        struct drm_mode_set_plane *plane_req = data;
-        struct drm_plane *plane;
-        struct drm_crtc *crtc;
-        struct drm_framebuffer *fb = NULL, *old_fb = NULL;
+        struct drm_device *dev = plane->dev;
+        struct drm_framebuffer *old_fb = NULL;
         int ret = 0;
         unsigned int fb_width, fb_height;
         int i;
 
-        if (!drm_core_check_feature(dev, DRIVER_MODESET))
-                return -EINVAL;
-
-        /*
-         * First, find the plane, crtc, and fb objects.  If not available,
-         * we don't bother to call the driver.
-         */
-        plane = drm_plane_find(dev, plane_req->plane_id);
-        if (!plane) {
-                DRM_DEBUG_KMS("Unknown plane ID %d\n",
-                              plane_req->plane_id);
-                return -ENOENT;
-        }
-
         /* No fb means shut it down */
-        if (!plane_req->fb_id) {
+        if (!fb) {
                 drm_modeset_lock_all(dev);
                 old_fb = plane->fb;
                 ret = plane->funcs->disable_plane(plane);
@@ -2229,14 +2223,6 @@ int drm_mode_setplane(struct drm_device *dev, void *data,
                 goto out;
         }
 
-        crtc = drm_crtc_find(dev, plane_req->crtc_id);
-        if (!crtc) {
-                DRM_DEBUG_KMS("Unknown crtc ID %d\n",
-                              plane_req->crtc_id);
-                ret = -ENOENT;
-                goto out;
-        }
-
         /* Check whether this plane is usable on this CRTC */
         if (!(plane->possible_crtcs & drm_crtc_mask(crtc))) {
                 DRM_DEBUG_KMS("Invalid crtc for plane\n");
@@ -2244,14 +2230,6 @@ int drm_mode_setplane(struct drm_device *dev, void *data,
                 goto out;
         }
 
-        fb = drm_framebuffer_lookup(dev, plane_req->fb_id);
-        if (!fb) {
-                DRM_DEBUG_KMS("Unknown framebuffer ID %d\n",
-                              plane_req->fb_id);
-                ret = -ENOENT;
-                goto out;
-        }
-
         /* Check whether this plane supports the fb pixel format. */
         for (i = 0; i < plane->format_count; i++)
                 if (fb->pixel_format == plane->format_types[i])
@@ -2267,43 +2245,25 @@ int drm_mode_setplane(struct drm_device *dev, void *data,
         fb_height = fb->height << 16;
 
         /* Make sure source coordinates are inside the fb. */
-        if (plane_req->src_w > fb_width ||
-            plane_req->src_x > fb_width - plane_req->src_w ||
-            plane_req->src_h > fb_height ||
-            plane_req->src_y > fb_height - plane_req->src_h) {
+        if (src_w > fb_width ||
+            src_x > fb_width - src_w ||
+            src_h > fb_height ||
+            src_y > fb_height - src_h) {
                 DRM_DEBUG_KMS("Invalid source coordinates "
                               "%u.%06ux%u.%06u+%u.%06u+%u.%06u\n",
-                              plane_req->src_w >> 16,
-                              ((plane_req->src_w & 0xffff) * 15625) >> 10,
-                              plane_req->src_h >> 16,
-                              ((plane_req->src_h & 0xffff) * 15625) >> 10,
-                              plane_req->src_x >> 16,
-                              ((plane_req->src_x & 0xffff) * 15625) >> 10,
-                              plane_req->src_y >> 16,
-                              ((plane_req->src_y & 0xffff) * 15625) >> 10);
+                              src_w >> 16, ((src_w & 0xffff) * 15625) >> 10,
+                              src_h >> 16, ((src_h & 0xffff) * 15625) >> 10,
+                              src_x >> 16, ((src_x & 0xffff) * 15625) >> 10,
+                              src_y >> 16, ((src_y & 0xffff) * 15625) >> 10);
                 ret = -ENOSPC;
                 goto out;
         }
 
-        /* Give drivers some help against integer overflows */
-        if (plane_req->crtc_w > INT_MAX ||
-            plane_req->crtc_x > INT_MAX - (int32_t) plane_req->crtc_w ||
-            plane_req->crtc_h > INT_MAX ||
-            plane_req->crtc_y > INT_MAX - (int32_t) plane_req->crtc_h) {
-                DRM_DEBUG_KMS("Invalid CRTC coordinates %ux%u+%d+%d\n",
-                              plane_req->crtc_w, plane_req->crtc_h,
-                              plane_req->crtc_x, plane_req->crtc_y);
-                ret = -ERANGE;
-                goto out;
-        }
-
         drm_modeset_lock_all(dev);
         old_fb = plane->fb;
         ret = plane->funcs->update_plane(plane, crtc, fb,
-                                         plane_req->crtc_x, plane_req->crtc_y,
-                                         plane_req->crtc_w, plane_req->crtc_h,
-                                         plane_req->src_x, plane_req->src_y,
-                                         plane_req->src_w, plane_req->src_h);
+                                         crtc_x, crtc_y, crtc_w, crtc_h,
+                                         src_x, src_y, src_w, src_h);
         if (!ret) {
                 plane->crtc = crtc;
                 plane->fb = fb;
@@ -2320,6 +2280,85 @@ out:
                 drm_framebuffer_unreference(old_fb);
 
         return ret;
+
+}
+
+/**
+ * drm_mode_setplane - configure a plane's configuration
+ * @dev: DRM device
+ * @data: ioctl data*
+ * @file_priv: DRM file info
+ *
+ * Set plane configuration, including placement, fb, scaling, and other factors.
+ * Or pass a NULL fb to disable (planes may be disabled without providing a
+ * valid crtc).
+ *
+ * Returns:
+ * Zero on success, errno on failure.
+ */
+int drm_mode_setplane(struct drm_device *dev, void *data,
+                      struct drm_file *file_priv)
+{
+        struct drm_mode_set_plane *plane_req = data;
+        struct drm_mode_object *obj;
+        struct drm_plane *plane;
+        struct drm_crtc *crtc = NULL;
+        struct drm_framebuffer *fb = NULL;
+
+        if (!drm_core_check_feature(dev, DRIVER_MODESET))
+                return -EINVAL;
+
+        /* Give drivers some help against integer overflows */
+        if (plane_req->crtc_w > INT_MAX ||
+            plane_req->crtc_x > INT_MAX - (int32_t) plane_req->crtc_w ||
+            plane_req->crtc_h > INT_MAX ||
+            plane_req->crtc_y > INT_MAX - (int32_t) plane_req->crtc_h) {
+                DRM_DEBUG_KMS("Invalid CRTC coordinates %ux%u+%d+%d\n",
+                              plane_req->crtc_w, plane_req->crtc_h,
+                              plane_req->crtc_x, plane_req->crtc_y);
+                return -ERANGE;
+        }
+
+        /*
+         * First, find the plane, crtc, and fb objects.  If not available,
+         * we don't bother to call the driver.
+         */
+        obj = drm_mode_object_find(dev, plane_req->plane_id,
+                                   DRM_MODE_OBJECT_PLANE);
+        if (!obj) {
+                DRM_DEBUG_KMS("Unknown plane ID %d\n",
+                              plane_req->plane_id);
+                return -ENOENT;
+        }
+        plane = obj_to_plane(obj);
+
+        if (plane_req->fb_id) {
+                fb = drm_framebuffer_lookup(dev, plane_req->fb_id);
+                if (!fb) {
+                        DRM_DEBUG_KMS("Unknown framebuffer ID %d\n",
+                                      plane_req->fb_id);
+                        return -ENOENT;
+                }
+
+                obj = drm_mode_object_find(dev, plane_req->crtc_id,
+                                           DRM_MODE_OBJECT_CRTC);
+                if (!obj) {
+                        DRM_DEBUG_KMS("Unknown crtc ID %d\n",
+                                      plane_req->crtc_id);
+                        return -ENOENT;
+                }
+                crtc = obj_to_crtc(obj);
+        }
+
+        /*
+         * setplane_internal will take care of deref'ing either the old or new
+         * framebuffer depending on success.
+         */
+        return setplane_internal(plane, crtc, fb,
+                                 plane_req->crtc_x, plane_req->crtc_y,
+                                 plane_req->crtc_w, plane_req->crtc_h,
+                                 plane_req->src_x, plane_req->src_y,
+                                 plane_req->src_w, plane_req->src_h);
 }
 
 /**
@@ -2568,6 +2607,102 @@ out:
         return ret;
 }
 
+/**
+ * drm_mode_cursor_universal - translate legacy cursor ioctl call into a
+ *     universal plane handler call
+ * @crtc: crtc to update cursor for
+ * @req: data pointer for the ioctl
+ * @file_priv: drm file for the ioctl call
+ *
+ * Legacy cursor ioctl's work directly with driver buffer handles.  To
+ * translate legacy ioctl calls into universal plane handler calls, we need to
+ * wrap the native buffer handle in a drm_framebuffer.
+ *
+ * Note that we assume any handle passed to the legacy ioctls was a 32-bit ARGB
+ * buffer with a pitch of 4*width; the universal plane interface should be used
+ * directly in cases where the hardware can support other buffer settings and
+ * userspace wants to make use of these capabilities.
+ *
+ * Returns:
+ * Zero on success, errno on failure.
+ */
+static int drm_mode_cursor_universal(struct drm_crtc *crtc,
+                                     struct drm_mode_cursor2 *req,
+                                     struct drm_file *file_priv)
+{
+        struct drm_device *dev = crtc->dev;
+        struct drm_framebuffer *fb = NULL;
+        struct drm_mode_fb_cmd2 fbreq = {
+                .width = req->width,
+                .height = req->height,
+                .pixel_format = DRM_FORMAT_ARGB8888,
+                .pitches = { req->width * 4 },
+                .handles = { req->handle },
+        };
+        int32_t crtc_x, crtc_y;
+        uint32_t crtc_w = 0, crtc_h = 0;
+        uint32_t src_w = 0, src_h = 0;
+        int ret = 0;
+
+        BUG_ON(!crtc->cursor);
+
+        /*
+         * Obtain fb we'll be using (either new or existing) and take an extra
+         * reference to it if fb != null.  setplane will take care of dropping
+         * the reference if the plane update fails.
+         */
+        if (req->flags & DRM_MODE_CURSOR_BO) {
+                if (req->handle) {
+                        fb = add_framebuffer_internal(dev, &fbreq, file_priv);
+                        if (IS_ERR(fb)) {
+                                DRM_DEBUG_KMS("failed to wrap cursor buffer in drm framebuffer\n");
+                                return PTR_ERR(fb);
+                        }
+
+                        drm_framebuffer_reference(fb);
+                } else {
+                        fb = NULL;
+                }
+        } else {
+                mutex_lock(&dev->mode_config.mutex);
+                fb = crtc->cursor->fb;
+                if (fb)
+                        drm_framebuffer_reference(fb);
+                mutex_unlock(&dev->mode_config.mutex);
+        }
+
+        if (req->flags & DRM_MODE_CURSOR_MOVE) {
+                crtc_x = req->x;
+                crtc_y = req->y;
+        } else {
+                crtc_x = crtc->cursor_x;
+                crtc_y = crtc->cursor_y;
+        }
+
+        if (fb) {
+                crtc_w = fb->width;
+                crtc_h = fb->height;
+                src_w = fb->width << 16;
+                src_h = fb->height << 16;
+        }
+
+        /*
+         * setplane_internal will take care of deref'ing either the old or new
+         * framebuffer depending on success.
+         */
+        ret = setplane_internal(crtc->cursor, crtc, fb,
+                                crtc_x, crtc_y, crtc_w, crtc_h,
+                                0, 0, src_w, src_h);
+
+        /* Update successful; save new cursor position, if necessary */
+        if (ret == 0 && req->flags & DRM_MODE_CURSOR_MOVE) {
+                crtc->cursor_x = req->x;
+                crtc->cursor_y = req->y;
+        }
+
+        return ret;
+}
+
 static int drm_mode_cursor_common(struct drm_device *dev,
                                   struct drm_mode_cursor2 *req,
                                   struct drm_file *file_priv)
@@ -2587,6 +2722,13 @@ static int drm_mode_cursor_common(struct drm_device *dev,
                 return -ENOENT;
         }
 
+        /*
+         * If this crtc has a universal cursor plane, call that plane's update
+         * handler rather than using legacy cursor handlers.
+         */
+        if (crtc->cursor)
+                return drm_mode_cursor_universal(crtc, req, file_priv);
+
         drm_modeset_lock(&crtc->mutex, NULL);
         if (req->flags & DRM_MODE_CURSOR_BO) {
                 if (!crtc->funcs->cursor_set && !crtc->funcs->cursor_set2) {
@@ -2886,56 +3028,38 @@ static int framebuffer_check(const struct drm_mode_fb_cmd2 *r)
         return 0;
 }
 
-/**
- * drm_mode_addfb2 - add an FB to the graphics configuration
- * @dev: drm device for the ioctl
- * @data: data pointer for the ioctl
- * @file_priv: drm file for the ioctl call
- *
- * Add a new FB to the specified CRTC, given a user request with format. This is
- * the 2nd version of the addfb ioctl, which supports multi-planar framebuffers
- * and uses fourcc codes as pixel format specifiers.
- *
- * Called by the user via ioctl.
- *
- * Returns:
- * Zero on success, errno on failure.
- */
-int drm_mode_addfb2(struct drm_device *dev,
-                    void *data, struct drm_file *file_priv)
+static struct drm_framebuffer *add_framebuffer_internal(struct drm_device *dev,
+                                                        struct drm_mode_fb_cmd2 *r,
+                                                        struct drm_file *file_priv)
 {
-        struct drm_mode_fb_cmd2 *r = data;
         struct drm_mode_config *config = &dev->mode_config;
         struct drm_framebuffer *fb;
         int ret;
 
-        if (!drm_core_check_feature(dev, DRIVER_MODESET))
-                return -EINVAL;
-
         if (r->flags & ~DRM_MODE_FB_INTERLACED) {
                 DRM_DEBUG_KMS("bad framebuffer flags 0x%08x\n", r->flags);
-                return -EINVAL;
+                return ERR_PTR(-EINVAL);
         }
 
         if ((config->min_width > r->width) || (r->width > config->max_width)) {
                 DRM_DEBUG_KMS("bad framebuffer width %d, should be >= %d && <= %d\n",
                           r->width, config->min_width, config->max_width);
-                return -EINVAL;
+                return ERR_PTR(-EINVAL);
         }
         if ((config->min_height > r->height) || (r->height > config->max_height)) {
                 DRM_DEBUG_KMS("bad framebuffer height %d, should be >= %d && <= %d\n",
                           r->height, config->min_height, config->max_height);
-                return -EINVAL;
+                return ERR_PTR(-EINVAL);
         }
 
         ret = framebuffer_check(r);
         if (ret)
-                return ret;
+                return ERR_PTR(ret);
 
         fb = dev->mode_config.funcs->fb_create(dev, file_priv, r);
         if (IS_ERR(fb)) {
                 DRM_DEBUG_KMS("could not create framebuffer\n");
-                return PTR_ERR(fb);
+                return fb;
         }
 
         mutex_lock(&file_priv->fbs_lock);
@@ -2944,8 +3068,37 @@ int drm_mode_addfb2(struct drm_device *dev,
         DRM_DEBUG_KMS("[FB:%d]\n", fb->base.id);
         mutex_unlock(&file_priv->fbs_lock);
 
+        return fb;
+}
 
-        return ret;
+/**
+ * drm_mode_addfb2 - add an FB to the graphics configuration
+ * @dev: drm device for the ioctl
+ * @data: data pointer for the ioctl
+ * @file_priv: drm file for the ioctl call
+ *
+ * Add a new FB to the specified CRTC, given a user request with format. This is
+ * the 2nd version of the addfb ioctl, which supports multi-planar framebuffers
+ * and uses fourcc codes as pixel format specifiers.
+ *
+ * Called by the user via ioctl.
+ *
+ * Returns:
+ * Zero on success, errno on failure.
+ */
+int drm_mode_addfb2(struct drm_device *dev,
+                    void *data, struct drm_file *file_priv)
+{
+        struct drm_framebuffer *fb;
+
+        if (!drm_core_check_feature(dev, DRIVER_MODESET))
+                return -EINVAL;
+
+        fb = add_framebuffer_internal(dev, data, file_priv);
+        if (IS_ERR(fb))
+                return PTR_ERR(fb);
+
+        return 0;
 }
 
 /**