Merge tag 'topic/drm-misc-2016-11-10' of git://anongit.freedesktop.org/drm-intel into drm-next

- better atomic state debugging from Rob
- fence prep from gustavo
- sumits flushed out his backlog of pending dma-buf/fence patches from
  various people
- drm_mm leak debugging plus trying to appease Kconfig (Chris)
- a few misc things all over

* tag 'topic/drm-misc-2016-11-10' of git://anongit.freedesktop.org/drm-intel: (35 commits)
  drm: Make DRM_DEBUG_MM depend on STACKTRACE_SUPPORT
  drm/i915: Restrict DRM_DEBUG_MM automatic selection
  drm: Restrict stackdepot usage to builtin drm.ko
  drm/msm: module param to dump state on error irq
  drm/msm/mdp5: add atomic_print_state support
  drm/atomic: add debugfs file to dump out atomic state
  drm/atomic: add new drm_debug bit to dump atomic state
  drm: add helpers to go from plane state to drm_rect
  drm: add helper for printing to log or seq_file
  drm: helper macros to print composite types
  reservation: revert "wait only with non-zero timeout specified (v3)" v2
  drm/ttm: fix ttm_bo_wait
  dma-buf/fence: revert "don't wait when specified timeout is zero" (v2)
  dma-buf/fence: make timeout handling in fence_default_wait consistent (v2)
  drm/amdgpu: add the interface of waiting multiple fences (v4)
  dma-buf: return index of the first signaled fence (v2)
  MAINTAINERS: update Sync File Framework files
  dma-buf/sw_sync: put fence reference from the fence creation
  dma-buf/sw_sync: mark sync_timeline_create() static
  drm: Add stackdepot include for DRM_DEBUG_MM
  ...

4 files changed, 179 insertions, 1 deletions

diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu.h b/drivers/gpu/drm/amd/amdgpu/amdgpu.h
index 2ec7b3baeec2..c2b8496cdf63 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu.h
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu.h
@@ -1212,6 +1212,8 @@ int amdgpu_gem_op_ioctl(struct drm_device *dev, void *data,
                         struct drm_file *filp);
 int amdgpu_cs_ioctl(struct drm_device *dev, void *data, struct drm_file *filp);
 int amdgpu_cs_wait_ioctl(struct drm_device *dev, void *data, struct drm_file *filp);
+int amdgpu_cs_wait_fences_ioctl(struct drm_device *dev, void *data,
+                                struct drm_file *filp);
 
 int amdgpu_gem_metadata_ioctl(struct drm_device *dev, void *data,
                                 struct drm_file *filp);
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_cs.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_cs.c
index a370101d923f..78da52f90099 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_cs.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_cs.c
@@ -1141,6 +1141,180 @@ int amdgpu_cs_wait_ioctl(struct drm_device *dev, void *data,
 }
 
 /**
+ * amdgpu_cs_get_fence - helper to get fence from drm_amdgpu_fence
+ *
+ * @adev: amdgpu device
+ * @filp: file private
+ * @user: drm_amdgpu_fence copied from user space
+ */
+static struct dma_fence *amdgpu_cs_get_fence(struct amdgpu_device *adev,
+                                             struct drm_file *filp,
+                                             struct drm_amdgpu_fence *user)
+{
+        struct amdgpu_ring *ring;
+        struct amdgpu_ctx *ctx;
+        struct dma_fence *fence;
+        int r;
+
+        r = amdgpu_cs_get_ring(adev, user->ip_type, user->ip_instance,
+                               user->ring, &ring);
+        if (r)
+                return ERR_PTR(r);
+
+        ctx = amdgpu_ctx_get(filp->driver_priv, user->ctx_id);
+        if (ctx == NULL)
+                return ERR_PTR(-EINVAL);
+
+        fence = amdgpu_ctx_get_fence(ctx, ring, user->seq_no);
+        amdgpu_ctx_put(ctx);
+
+        return fence;
+}
+
+/**
+ * amdgpu_cs_wait_all_fence - wait on all fences to signal
+ *
+ * @adev: amdgpu device
+ * @filp: file private
+ * @wait: wait parameters
+ * @fences: array of drm_amdgpu_fence
+ */
+static int amdgpu_cs_wait_all_fences(struct amdgpu_device *adev,
+                                     struct drm_file *filp,
+                                     union drm_amdgpu_wait_fences *wait,
+                                     struct drm_amdgpu_fence *fences)
+{
+        uint32_t fence_count = wait->in.fence_count;
+        unsigned int i;
+        long r = 1;
+
+        for (i = 0; i < fence_count; i++) {
+                struct dma_fence *fence;
+                unsigned long timeout = amdgpu_gem_timeout(wait->in.timeout_ns);
+
+                fence = amdgpu_cs_get_fence(adev, filp, &fences[i]);
+                if (IS_ERR(fence))
+                        return PTR_ERR(fence);
+                else if (!fence)
+                        continue;
+
+                r = dma_fence_wait_timeout(fence, true, timeout);
+                if (r < 0)
+                        return r;
+
+                if (r == 0)
+                        break;
+        }
+
+        memset(wait, 0, sizeof(*wait));
+        wait->out.status = (r > 0);
+
+        return 0;
+}
+
+/**
+ * amdgpu_cs_wait_any_fence - wait on any fence to signal
+ *
+ * @adev: amdgpu device
+ * @filp: file private
+ * @wait: wait parameters
+ * @fences: array of drm_amdgpu_fence
+ */
+static int amdgpu_cs_wait_any_fence(struct amdgpu_device *adev,
+                                    struct drm_file *filp,
+                                    union drm_amdgpu_wait_fences *wait,
+                                    struct drm_amdgpu_fence *fences)
+{
+        unsigned long timeout = amdgpu_gem_timeout(wait->in.timeout_ns);
+        uint32_t fence_count = wait->in.fence_count;
+        uint32_t first = ~0;
+        struct dma_fence **array;
+        unsigned int i;
+        long r;
+
+        /* Prepare the fence array */
+        array = kcalloc(fence_count, sizeof(struct dma_fence *), GFP_KERNEL);
+
+        if (array == NULL)
+                return -ENOMEM;
+
+        for (i = 0; i < fence_count; i++) {
+                struct dma_fence *fence;
+
+                fence = amdgpu_cs_get_fence(adev, filp, &fences[i]);
+                if (IS_ERR(fence)) {
+                        r = PTR_ERR(fence);
+                        goto err_free_fence_array;
+                } else if (fence) {
+                        array[i] = fence;
+                } else { /* NULL, the fence has been already signaled */
+                        r = 1;
+                        goto out;
+                }
+        }
+
+        r = dma_fence_wait_any_timeout(array, fence_count, true, timeout,
+                                       &first);
+        if (r < 0)
+                goto err_free_fence_array;
+
+out:
+        memset(wait, 0, sizeof(*wait));
+        wait->out.status = (r > 0);
+        wait->out.first_signaled = first;
+        /* set return value 0 to indicate success */
+        r = 0;
+
+err_free_fence_array:
+        for (i = 0; i < fence_count; i++)
+                dma_fence_put(array[i]);
+        kfree(array);
+
+        return r;
+}
+
+/**
+ * amdgpu_cs_wait_fences_ioctl - wait for multiple command submissions to finish
+ *
+ * @dev: drm device
+ * @data: data from userspace
+ * @filp: file private
+ */
+int amdgpu_cs_wait_fences_ioctl(struct drm_device *dev, void *data,
+                                struct drm_file *filp)
+{
+        struct amdgpu_device *adev = dev->dev_private;
+        union drm_amdgpu_wait_fences *wait = data;
+        uint32_t fence_count = wait->in.fence_count;
+        struct drm_amdgpu_fence *fences_user;
+        struct drm_amdgpu_fence *fences;
+        int r;
+
+        /* Get the fences from userspace */
+        fences = kmalloc_array(fence_count, sizeof(struct drm_amdgpu_fence),
+                        GFP_KERNEL);
+        if (fences == NULL)
+                return -ENOMEM;
+
+        fences_user = (void __user *)(unsigned long)(wait->in.fences);
+        if (copy_from_user(fences, fences_user,
+                sizeof(struct drm_amdgpu_fence) * fence_count)) {
+                r = -EFAULT;
+                goto err_free_fences;
+        }
+
+        if (wait->in.wait_all)
+                r = amdgpu_cs_wait_all_fences(adev, filp, wait, fences);
+        else
+                r = amdgpu_cs_wait_any_fence(adev, filp, wait, fences);
+
+err_free_fences:
+        kfree(fences);
+
+        return r;
+}
+
+/**
  * amdgpu_cs_find_bo_va - find bo_va for VM address
  *
  * @parser: command submission parser context
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_kms.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_kms.c
index 55c413a55a40..ad908612aff9 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_kms.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_kms.c
@@ -823,6 +823,7 @@ const struct drm_ioctl_desc amdgpu_ioctls_kms[] = {
         DRM_IOCTL_DEF_DRV(AMDGPU_CS, amdgpu_cs_ioctl, DRM_AUTH|DRM_RENDER_ALLOW),
         DRM_IOCTL_DEF_DRV(AMDGPU_INFO, amdgpu_info_ioctl, DRM_AUTH|DRM_RENDER_ALLOW),
         DRM_IOCTL_DEF_DRV(AMDGPU_WAIT_CS, amdgpu_cs_wait_ioctl, DRM_AUTH|DRM_RENDER_ALLOW),
+        DRM_IOCTL_DEF_DRV(AMDGPU_WAIT_FENCES, amdgpu_cs_wait_fences_ioctl, DRM_AUTH|DRM_RENDER_ALLOW),
         DRM_IOCTL_DEF_DRV(AMDGPU_GEM_METADATA, amdgpu_gem_metadata_ioctl, DRM_AUTH|DRM_RENDER_ALLOW),
         DRM_IOCTL_DEF_DRV(AMDGPU_GEM_VA, amdgpu_gem_va_ioctl, DRM_AUTH|DRM_RENDER_ALLOW),
         DRM_IOCTL_DEF_DRV(AMDGPU_GEM_OP, amdgpu_gem_op_ioctl, DRM_AUTH|DRM_RENDER_ALLOW),
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_sa.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_sa.c
index fd26c4b8d793..34a795463988 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_sa.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_sa.c
@@ -361,7 +361,8 @@ int amdgpu_sa_bo_new(struct amdgpu_sa_manager *sa_manager,
                 if (count) {
                         spin_unlock(&sa_manager->wq.lock);
                         t = dma_fence_wait_any_timeout(fences, count, false,
-                                                       MAX_SCHEDULE_TIMEOUT);
+                                                       MAX_SCHEDULE_TIMEOUT,
+                                                       NULL);
                         for (i = 0; i < count; ++i)
                                 dma_fence_put(fences[i]);