WebSVN – Kolibri OS – Diff – /drivers/video/drm/i915/i915_gem_execbuffer.c

 #include
 #include
 #include "i915_drv.h"
 #include "i915_trace.h"
 #include "intel_drv.h"
-//#include
+#include
 #define  __EXEC_OBJECT_HAS_PIN (1<<31)
+#define  __EXEC_OBJECT_HAS_FENCE (1<<30)
-#define  __EXEC_OBJECT_HAS_FENCE (1<<30)
-static unsigned long
-copy_to_user(void __user *to, const void *from, unsigned long n)
+#define  __EXEC_OBJECT_NEEDS_BIAS (1<<28)
-{
-    memcpy(to, from, n);
     return 0;
 #define BATCH_OFFSET_BIAS (256*1024)
 static unsigned long
 		  struct drm_i915_gem_exec_object2 *exec,
 		  const struct drm_i915_gem_execbuffer2 *args,
 	       struct i915_address_space *vm,
 		  struct drm_file *file)
+{
+	struct drm_i915_private *dev_priv = vm->dev->dev_private;
 	struct drm_i915_gem_object *obj;
 	struct list_head objects;
 	int i, ret;
 	spin_unlock(&file->table_lock);
 	i = 0;
 	while (!list_empty(&objects)) {
+		struct i915_vma *vma;
+		struct i915_address_space *bind_vm = vm;
+		if (exec[i].flags & EXEC_OBJECT_NEEDS_GTT &&
+		    USES_FULL_PPGTT(vm->dev)) {
+			ret = -EINVAL;
+			goto err;
+		}
+		/* If we have secure dispatch, or the userspace assures us that
+		 * they know what they're doing, use the GGTT VM.
+		 */
+		if (((args->flags & I915_EXEC_SECURE) &&
+		    (i == (args->buffer_count - 1))))
-		struct i915_vma *vma;
+			bind_vm = &dev_priv->gtt.base;
 		obj = list_first_entry(&objects,
 		 * vmas which are not actually bound. And since only
 		 * lookup_or_create exists as an interface to get at the vma
 		 * from the (obj, vm) we don't run the risk of creating
 		 * duplicated vmas for the same vm.
 		 */
-		vma = i915_gem_obj_lookup_or_create_vma(obj, vm);
+		vma = i915_gem_obj_lookup_or_create_vma(obj, bind_vm);
 		if (IS_ERR(vma)) {
 			DRM_DEBUG("Failed to lookup VMA\n");
 			ret = PTR_ERR(vma);
 			goto err;
+		}
 	if (entry->flags & __EXEC_OBJECT_HAS_FENCE)
 		i915_gem_object_unpin_fence(obj);
 	if (entry->flags & __EXEC_OBJECT_HAS_PIN)
-		i915_gem_object_unpin(obj);
+		vma->pin_count--;
 		obj->cache_level != I915_CACHE_NONE);
+}
 static int
 relocate_entry_cpu(struct drm_i915_gem_object *obj,
+		   struct drm_i915_gem_relocation_entry *reloc,
-		   struct drm_i915_gem_relocation_entry *reloc)
+		   uint64_t target_offset)
+{
     struct drm_device *dev = obj->base.dev;
     struct drm_i915_private *dev_priv = dev->dev_private;
+    uint32_t page_offset = offset_in_page(reloc->offset);
-	uint32_t page_offset = offset_in_page(reloc->offset);
+	uint64_t delta = reloc->delta + target_offset;
 	char *vaddr;
 	int ret;
 	ret = i915_gem_object_set_to_cpu_domain(obj, true);
 	if (ret)
 		return ret;
+	vaddr = (char*)dev_priv->gtt.mappable+4096;
+	MapPage(vaddr,(addr_t)i915_gem_object_get_page(obj,reloc->offset >> PAGE_SHIFT), PG_SW);
+	*(uint32_t *)(vaddr + page_offset) = lower_32_bits(delta);
+	if (INTEL_INFO(dev)->gen >= 8) {
+		page_offset = offset_in_page(page_offset + sizeof(uint32_t));
+		if (page_offset == 0) {
+			MapPage(vaddr,(addr_t)i915_gem_object_get_page(obj,
+			    (reloc->offset + sizeof(uint32_t)) >> PAGE_SHIFT), PG_SW);
+		}
     vaddr = dev_priv->gtt.mappable+4096;
-    MapPage(vaddr,(addr_t)i915_gem_object_get_page(obj,reloc->offset >> PAGE_SHIFT), PG_SW);
+		*(uint32_t *)(vaddr + page_offset) = upper_32_bits(delta);
 	*(uint32_t *)(vaddr + page_offset) = reloc->delta;
 	return 0;
+}
 static int
-static int
+relocate_entry_gtt(struct drm_i915_gem_object *obj,
+		   struct drm_i915_gem_relocation_entry *reloc,
-relocate_entry_gtt(struct drm_i915_gem_object *obj,
+		   uint64_t target_offset)
 		   struct drm_i915_gem_relocation_entry *reloc)
 	struct drm_device *dev = obj->base.dev;
-	struct drm_device *dev = obj->base.dev;
+	struct drm_i915_private *dev_priv = dev->dev_private;
     MapPage(dev_priv->gtt.mappable,dev_priv->gtt.mappable_base +
                                  (reloc->offset & PAGE_MASK), PG_SW);
 	reloc_page = dev_priv->gtt.mappable;
 	reloc_entry = (uint32_t __iomem *)
 		(reloc_page + offset_in_page(reloc->offset));
-	iowrite32(reloc->delta, reloc_entry);
+	iowrite32(lower_32_bits(delta), reloc_entry);
 	return 0;
+}
 static int
 i915_gem_execbuffer_relocate_entry(struct drm_i915_gem_object *obj,
-				   struct eb_vmas *eb,
-				   struct drm_i915_gem_relocation_entry *reloc,
+				   struct eb_vmas *eb,
-				   struct i915_address_space *vm)
+				   struct drm_i915_gem_relocation_entry *reloc)
+{
 	struct drm_device *dev = obj->base.dev;
 	struct drm_gem_object *target_obj;
 	struct drm_i915_gem_object *target_i915_obj;
 	struct i915_vma *target_vma;
-	uint32_t target_offset;
+	uint64_t target_offset;
 	int ret;
 	 * pipe_control writes because the gpu doesn't properly redirect them
 	 * through the ppgtt for non_secure batchbuffers. */
 	if (unlikely(IS_GEN6(dev) &&
 	    reloc->write_domain == I915_GEM_DOMAIN_INSTRUCTION &&
 	    !target_i915_obj->has_global_gtt_mapping)) {
+		struct i915_vma *vma =
-		i915_gem_gtt_bind_object(target_i915_obj,
+			list_first_entry(&target_i915_obj->vma_list,
+					 typeof(*vma), vma_link);
-					 target_i915_obj->cache_level);
+		vma->bind_vma(vma, target_i915_obj->cache_level, GLOBAL_BIND);
+	}
 	/* Validate that the target is in a valid r/w GPU domain */
 	if (unlikely(reloc->write_domain & (reloc->write_domain - 1))) {
 		return -EINVAL;
+	}
-	/* We can't wait for rendering with pagefaults disabled */
 	/* We can't wait for rendering with pagefaults disabled */
-	reloc->delta += target_offset;
 	if (use_cpu_reloc(obj))
-		ret = relocate_entry_cpu(obj, reloc);
+		ret = relocate_entry_cpu(obj, reloc, target_offset);
 	else
-		ret = relocate_entry_gtt(obj, reloc);
+		ret = relocate_entry_gtt(obj, reloc, target_offset);
         memcpy(r, user_relocs, count*sizeof(r[0]));
 		do {
 			u64 offset = r->presumed_offset;
 			ret = i915_gem_execbuffer_relocate_entry(vma->obj, eb, r,
-								 vma->vm);
+			ret = i915_gem_execbuffer_relocate_entry(vma->obj, eb, r);
 			if (ret)
 				return ret;
+{
 	const struct drm_i915_gem_exec_object2 *entry = vma->exec_entry;
 	int i, ret;
 	for (i = 0; i < entry->relocation_count; i++) {
-		ret = i915_gem_execbuffer_relocate_entry(vma->obj, eb, &relocs[i],
-							 vma->vm);
+		ret = i915_gem_execbuffer_relocate_entry(vma->obj, eb, &relocs[i]);
 		if (ret)
 			return ret;
+	}
 		i915_is_ggtt(vma->vm);
+}
 static int
 i915_gem_execbuffer_reserve_vma(struct i915_vma *vma,
-				   struct intel_ring_buffer *ring,
+				struct intel_engine_cs *ring,
 				   bool *need_reloc)
 {
-	struct drm_i915_private *dev_priv = ring->dev->dev_private;
+	struct drm_i915_gem_object *obj = vma->obj;
 	struct drm_i915_gem_exec_object2 *entry = vma->exec_entry;
 	bool has_fenced_gpu_access = INTEL_INFO(ring->dev)->gen < 4;
-	bool need_fence, need_mappable;
+	bool need_fence;
-	struct drm_i915_gem_object *obj = vma->obj;
+	uint64_t flags;
+	int ret;
-	int ret;
+	flags = 0;
 	need_fence =
 		has_fenced_gpu_access &&
 		entry->flags & EXEC_OBJECT_NEEDS_FENCE &&
+		obj->tiling_mode != I915_TILING_NONE;
+	if (need_fence || need_reloc_mappable(vma))
+		flags |= PIN_MAPPABLE;
+	if (entry->flags & EXEC_OBJECT_NEEDS_GTT)
+		flags |= PIN_GLOBAL;
-		obj->tiling_mode != I915_TILING_NONE;
+	if (entry->flags & __EXEC_OBJECT_NEEDS_BIAS)
-	need_mappable = need_fence || need_reloc_mappable(vma);
 		flags |= BATCH_OFFSET_BIAS | PIN_OFFSET_BIAS;
 	ret = i915_gem_object_pin(obj, vma->vm, entry->alignment, need_mappable,
-				  false);
+	ret = i915_gem_object_pin(obj, vma->vm, entry->alignment, flags);
 			obj->pending_fenced_gpu_access = true;
+		}
-	}
-	/* Ensure ppgtt mapping exists if needed */
-	if (dev_priv->mm.aliasing_ppgtt && !obj->has_aliasing_ppgtt_mapping) {
-		i915_ppgtt_bind_object(dev_priv->mm.aliasing_ppgtt,
-				       obj, obj->cache_level);
-		obj->has_aliasing_ppgtt_mapping = 1;
+	}
 	if (entry->offset != vma->node.start) {
 		entry->offset = vma->node.start;
 		*need_reloc = true;
+	}
 	if (entry->flags & EXEC_OBJECT_WRITE) {
-		obj->base.pending_read_domains = I915_GEM_DOMAIN_RENDER;
-		obj->base.pending_write_domain = I915_GEM_DOMAIN_RENDER;
-	}
-	if (entry->flags & EXEC_OBJECT_NEEDS_GTT &&
+		obj->base.pending_read_domains = I915_GEM_DOMAIN_RENDER;
-	    !obj->has_global_gtt_mapping)
+		obj->base.pending_write_domain = I915_GEM_DOMAIN_RENDER;
+	}
+	return 0;
+}
+static bool
+eb_vma_misplaced(struct i915_vma *vma, bool has_fenced_gpu_access)
+{
+	struct drm_i915_gem_exec_object2 *entry = vma->exec_entry;
+	struct drm_i915_gem_object *obj = vma->obj;
+	bool need_fence, need_mappable;
+	need_fence =
+		has_fenced_gpu_access &&
+		entry->flags & EXEC_OBJECT_NEEDS_FENCE &&
+		obj->tiling_mode != I915_TILING_NONE;
+	need_mappable = need_fence || need_reloc_mappable(vma);
+	WARN_ON((need_mappable || need_fence) &&
+	       !i915_is_ggtt(vma->vm));
+	if (entry->alignment &&
+	    vma->node.start & (entry->alignment - 1))
+		return true;
+	if (need_mappable && !obj->map_and_fenceable)
+		return true;
+	if (entry->flags & __EXEC_OBJECT_NEEDS_BIAS &&
+	    vma->node.start < BATCH_OFFSET_BIAS)
-		i915_gem_gtt_bind_object(obj, obj->cache_level);
+		return true;
-	return 0;
+	return false;
+}
 static int
-i915_gem_execbuffer_reserve(struct intel_ring_buffer *ring,
+i915_gem_execbuffer_reserve(struct intel_engine_cs *ring,
 	int retry;
 	if (list_empty(vmas))
+		return 0;
-		return 0;
+	i915_gem_retire_requests_ring(ring);
 	vm = list_first_entry(vmas, struct i915_vma, exec_list)->vm;
 	do {
 		int ret = 0;
 		/* Unbind any ill-fitting objects or pin. */
-		list_for_each_entry(vma, vmas, exec_list) {
-			struct drm_i915_gem_exec_object2 *entry = vma->exec_entry;
-			bool need_fence, need_mappable;
-			obj = vma->obj;
 		list_for_each_entry(vma, vmas, exec_list) {
 			if (!drm_mm_node_allocated(&vma->node))
-				continue;
+				continue;
-			need_fence =
-				has_fenced_gpu_access &&
-				entry->flags & EXEC_OBJECT_NEEDS_FENCE &&
-				obj->tiling_mode != I915_TILING_NONE;
-			need_mappable = need_fence || need_reloc_mappable(vma);
-			WARN_ON((need_mappable || need_fence) &&
-			       !i915_is_ggtt(vma->vm));
-			if ((entry->alignment &&
 			     vma->node.start & (entry->alignment - 1)) ||
-			    (need_mappable && !obj->map_and_fenceable))
+			if (eb_vma_misplaced(vma, has_fenced_gpu_access))
 				ret = i915_vma_unbind(vma);
 			else
 				ret = i915_gem_execbuffer_reserve_vma(vma, ring, need_relocs);
 		/* Decrement pin count for bound objects */
 		list_for_each_entry(vma, vmas, exec_list)
 			i915_gem_execbuffer_unreserve_vma(vma);
-//		ret = i915_gem_evict_vm(vm, true);
+		ret = i915_gem_evict_vm(vm, true);
 		if (ret)
 			return ret;
 	} while (1);
+}
 static int
 i915_gem_execbuffer_relocate_slow(struct drm_device *dev,
 				  struct drm_i915_gem_execbuffer2 *args,
 				  struct drm_file *file,
-				  struct intel_ring_buffer *ring,
+				  struct intel_engine_cs *ring,
 				  struct eb_vmas *eb,
 				  struct drm_i915_gem_exec_object2 *exec)
 		 * presumed_offset before the next execbuffer - if that
 		 * happened we would make the mistake of assuming that the
 		 * relocations were valid.
 		 */
 		for (j = 0; j < exec[i].relocation_count; j++) {
-			if (copy_to_user(&user_relocs[j].presumed_offset,
+			if (__copy_to_user(&user_relocs[j].presumed_offset,
 					 &invalid_offset,
 					 sizeof(invalid_offset))) {
 				ret = -EFAULT;
 				mutex_lock(&dev->struct_mutex);
 				goto err;
     kfree(reloc_offset);
 	return ret;
+}
 static int
-i915_gem_execbuffer_move_to_gpu(struct intel_ring_buffer *ring,
+i915_gem_execbuffer_move_to_gpu(struct intel_engine_cs *ring,
 				struct list_head *vmas)
+{
 	struct i915_vma *vma;
 	uint32_t flush_domains = 0;
+	}
 	return 0;
 }
-static int
+static struct intel_context *
 i915_gem_validate_context(struct drm_device *dev, struct drm_file *file,
+			  struct intel_engine_cs *ring, const u32 ctx_id)
 			  const u32 ctx_id)
-{
+	struct intel_context *ctx = NULL;
-	struct i915_ctx_hang_stats *hs;
+	struct i915_ctx_hang_stats *hs;
+	if (ring->id != RCS && ctx_id != DEFAULT_CONTEXT_HANDLE)
+		return ERR_PTR(-EINVAL);
+	ctx = i915_gem_context_get(file->driver_priv, ctx_id);
-	hs = i915_gem_context_get_hang_stats(dev, file, ctx_id);
+	if (IS_ERR(ctx))
-	if (IS_ERR(hs))
+		return ctx;
-		return PTR_ERR(hs);
 	hs = &ctx->hang_stats;
 	if (hs->banned) {
 		DRM_DEBUG("Context %u tried to submit while banned\n", ctx_id);
-		return -EIO;
+		return ERR_PTR(-EIO);
+	}
-	return 0;
+	return ctx;
+}
 static void
 		i915_vma_move_to_active(vma, ring);
 		if (obj->base.write_domain) {
 			obj->dirty = 1;
+			obj->last_write_seqno = intel_ring_get_seqno(ring);
+			intel_fb_obj_invalidate(obj, ring);
-			obj->last_write_seqno = intel_ring_get_seqno(ring);
-			if (obj->pin_count) /* check for potential scanout */
+			/* update for the implicit flush after a batch */
-				intel_mark_fb_busy(obj, ring);
+			obj->base.write_domain &= ~I915_GEM_GPU_DOMAINS;
+		}
 		trace_i915_gem_object_change_domain(obj, old_read, old_write);
+	}
+}
 static void
 i915_gem_execbuffer_retire_commands(struct drm_device *dev,
 				    struct drm_file *file,
-				    struct intel_ring_buffer *ring,
+				    struct intel_engine_cs *ring,
 				    struct drm_i915_gem_object *obj)
 	(void)__i915_add_request(ring, file, obj, NULL);
+}
 static int
 i915_reset_gen7_sol_offsets(struct drm_device *dev,
-			    struct intel_ring_buffer *ring)
+			    struct intel_engine_cs *ring)
 {
-	drm_i915_private_t *dev_priv = dev->dev_private;
+	struct drm_i915_private *dev_priv = dev->dev_private;
 	int ret, i;
+	if (!IS_GEN7(dev) || ring != &dev_priv->ring[RCS]) {
+		DRM_DEBUG("sol reset is gen7/rcs only\n");
-	if (!IS_GEN7(dev) || ring != &dev_priv->ring[RCS])
+		return -EINVAL;
 		return 0;
 	return 0;
+}
 static int
+legacy_ringbuffer_submission(struct drm_device *dev, struct drm_file *file,
-i915_gem_do_execbuffer(struct drm_device *dev, void *data,
+			     struct intel_engine_cs *ring,
+			     struct intel_context *ctx,
-		       struct drm_file *file,
+			     struct drm_i915_gem_execbuffer2 *args,
-		       struct drm_i915_gem_execbuffer2 *args,
+			     struct list_head *vmas,
-		       struct drm_i915_gem_exec_object2 *exec,
+			     struct drm_i915_gem_object *batch_obj,
-		       struct i915_address_space *vm)
-{
-	drm_i915_private_t *dev_priv = dev->dev_private;
-	struct eb_vmas *eb;
+			     u64 exec_start, u32 flags)
-	struct drm_i915_gem_object *batch_obj;
-	struct drm_clip_rect *cliprects = NULL;
+{
-	struct intel_ring_buffer *ring;
+	struct drm_clip_rect *cliprects = NULL;
-	const u32 ctx_id = i915_execbuffer2_get_context_id(*args);
+	struct drm_i915_private *dev_priv = dev->dev_private;
-	u32 exec_start, exec_len;
+	u64 exec_len;
-	u32 mask, flags;
+	int instp_mode;
-	int ret, mode, i;
+	u32 instp_mask;
+	int i, ret = 0;
-	bool need_relocs;
+	if (args->num_cliprects != 0) {
+		if (ring != &dev_priv->ring[RCS]) {
+			DRM_DEBUG("clip rectangles are only valid with the render ring\n");
+			return -EINVAL;
-	if (!i915_gem_check_execbuffer(args))
-		return -EINVAL;
+		}
-	ret = validate_exec_list(exec, args->buffer_count);
-	if (ret)
+		if (INTEL_INFO(dev)->gen >= 5) {
+			DRM_DEBUG("clip rectangles are only valid on pre-gen5\n");
-		return ret;
+			return -EINVAL;
+		}
-	flags = 0;
-	if (args->flags & I915_EXEC_SECURE) {
+		if (args->num_cliprects > UINT_MAX / sizeof(*cliprects)) {
-		flags |= I915_DISPATCH_SECURE;
-	}
-	if (args->flags & I915_EXEC_IS_PINNED)
+			DRM_DEBUG("execbuf with %u cliprects\n",
-		flags |= I915_DISPATCH_PINNED;
+				  args->num_cliprects);
-	switch (args->flags & I915_EXEC_RING_MASK) {
-	case I915_EXEC_DEFAULT:
+			return -EINVAL;
-	case I915_EXEC_RENDER:
-		ring = &dev_priv->ring[RCS];
+		}
-		break;
-	case I915_EXEC_BSD:
+		cliprects = kcalloc(args->num_cliprects,
-		ring = &dev_priv->ring[VCS];
+				    sizeof(*cliprects),
-		if (ctx_id != DEFAULT_CONTEXT_ID) {
-			DRM_DEBUG("Ring %s doesn't support contexts\n",
+				    GFP_KERNEL);
-				  ring->name);
+		if (cliprects == NULL) {
-			return -EPERM;
+			ret = -ENOMEM;
-		}
+			goto error;
-		break;
+		}
 	case I915_EXEC_BLT:
-		ring = &dev_priv->ring[BCS];
+		if (copy_from_user(cliprects,
-		if (ctx_id != DEFAULT_CONTEXT_ID) {
-			DRM_DEBUG("Ring %s doesn't support contexts\n",
-				  ring->name);
+				   to_user_ptr(args->cliprects_ptr),
-			return -EPERM;
+				   sizeof(*cliprects)*args->num_cliprects)) {
-		}
+			ret = -EFAULT;
-		break;
-	case I915_EXEC_VEBOX:
+			goto error;
-		ring = &dev_priv->ring[VECS];
-		if (ctx_id != DEFAULT_CONTEXT_ID) {
-			DRM_DEBUG("Ring %s doesn't support contexts\n",
+		}
-				  ring->name);
+	} else {
-			return -EPERM;
+		if (args->DR4 == 0xffffffff) {
 			DRM_DEBUG("UXA submitting garbage DR4, fixing up\n");
-		break;
-	default:
-		DRM_DEBUG("execbuf with unknown ring: %d\n",
-			  (int)(args->flags & I915_EXEC_RING_MASK));
+			args->DR4 = 0;
+		}
+		if (args->DR1 || args->DR4 || args->cliprects_ptr) {
+			DRM_DEBUG("0 cliprects but dirt in cliprects fields\n");
+			return -EINVAL;
+		}
+	}
-		return -EINVAL;
+	ret = i915_gem_execbuffer_move_to_gpu(ring, vmas);
-	}
+	if (ret)
-	if (!intel_ring_initialized(ring)) {
+		goto error;
 		DRM_DEBUG("execbuf with invalid ring: %d\n",
-			  (int)(args->flags & I915_EXEC_RING_MASK));
+	ret = i915_switch_context(ring, ctx);
-		return -EINVAL;
+	if (ret)
-	}
+		goto error;
+	instp_mode = args->flags & I915_EXEC_CONSTANTS_MASK;
+	instp_mask = I915_EXEC_CONSTANTS_MASK;
+	switch (instp_mode) {
+	case I915_EXEC_CONSTANTS_REL_GENERAL:
+	case I915_EXEC_CONSTANTS_ABSOLUTE:
-	mode = args->flags & I915_EXEC_CONSTANTS_MASK;
+	case I915_EXEC_CONSTANTS_REL_SURFACE:
+		if (instp_mode != 0 && ring != &dev_priv->ring[RCS]) {
-	mask = I915_EXEC_CONSTANTS_MASK;
+			DRM_DEBUG("non-0 rel constants mode on non-RCS\n");
+			ret = -EINVAL;
+			goto error;
 	switch (mode) {
-	case I915_EXEC_CONSTANTS_REL_GENERAL:
+		if (instp_mode != dev_priv->relative_constants_mode) {
-	case I915_EXEC_CONSTANTS_ABSOLUTE:
+			if (INTEL_INFO(dev)->gen < 4) {
+				DRM_DEBUG("no rel constants on pre-gen4\n");
+				ret = -EINVAL;
-	case I915_EXEC_CONSTANTS_REL_SURFACE:
+				goto error;
 		if (ring == &dev_priv->ring[RCS] &&
-		    mode != dev_priv->relative_constants_mode) {
-			if (INTEL_INFO(dev)->gen < 4)
+			if (INTEL_INFO(dev)->gen > 5 &&
-				return -EINVAL;
+			    instp_mode == I915_EXEC_CONSTANTS_REL_SURFACE) {
 				DRM_DEBUG("rel surface constants mode invalid on gen5+\n");
-			if (INTEL_INFO(dev)->gen > 5 &&
+				ret = -EINVAL;
-			    mode == I915_EXEC_CONSTANTS_REL_SURFACE)
+				goto error;
+			}
 				return -EINVAL;
+			/* The HW changed the meaning on this bit on gen6 */
-			/* The HW changed the meaning on this bit on gen6 */
+			if (INTEL_INFO(dev)->gen >= 6)
+				instp_mask &= ~I915_EXEC_CONSTANTS_REL_SURFACE;
+		}
-			if (INTEL_INFO(dev)->gen >= 6)
+		break;
+	default:
+		DRM_DEBUG("execbuf with unknown constants: %d\n", instp_mode);
+		ret = -EINVAL;
+		goto error;
+	}
+	if (ring == &dev_priv->ring[RCS] &&
+			instp_mode != dev_priv->relative_constants_mode) {
-				mask &= ~I915_EXEC_CONSTANTS_REL_SURFACE;
+		ret = intel_ring_begin(ring, 4);
-		}
+		if (ret)
-		break;
+			goto error;
-	default:
-		DRM_DEBUG("execbuf with unknown constants: %d\n", mode);
+		intel_ring_emit(ring, MI_NOOP);
-		return -EINVAL;
+		intel_ring_emit(ring, MI_LOAD_REGISTER_IMM(1));
+		intel_ring_emit(ring, INSTPM);
+		intel_ring_emit(ring, instp_mask << 16 | instp_mode);
-	}
+		intel_ring_advance(ring);
+		dev_priv->relative_constants_mode = instp_mode;
+	}
+	if (args->flags & I915_EXEC_GEN7_SOL_RESET) {
+		ret = i915_reset_gen7_sol_offsets(dev, ring);
+		if (ret)
+			goto error;
+	}
+	exec_len = args->batch_len;
+	if (cliprects) {
+		for (i = 0; i < args->num_cliprects; i++) {
+			ret = i915_emit_box(dev, &cliprects[i],
+					    args->DR1, args->DR4);
+			if (ret)
-	if (args->buffer_count < 1) {
+				goto error;
 		DRM_DEBUG("execbuf with %d buffers\n", args->buffer_count);
-		return -EINVAL;
+			ret = ring->dispatch_execbuffer(ring,
+							exec_start, exec_len,
-	}
+							flags);
+			if (ret)
+				goto error;
+		}
+	} else {
+		ret = ring->dispatch_execbuffer(ring,
+						exec_start, exec_len,
+						flags);
+		if (ret)
+			return ret;
+	}
+	trace_i915_gem_ring_dispatch(ring, intel_ring_get_seqno(ring), flags);
+	i915_gem_execbuffer_move_to_active(vmas, ring);
+	i915_gem_execbuffer_retire_commands(dev, file, ring, batch_obj);
+error:
+	kfree(cliprects);
+	return ret;
+}
+/**
+ * Find one BSD ring to dispatch the corresponding BSD command.
+ * The Ring ID is returned.
+ */
+static int gen8_dispatch_bsd_ring(struct drm_device *dev,
+				  struct drm_file *file)
+{
+	struct drm_i915_private *dev_priv = dev->dev_private;
+	struct drm_i915_file_private *file_priv = file->driver_priv;
+	/* Check whether the file_priv is using one ring */
+	if (file_priv->bsd_ring)
+		return file_priv->bsd_ring->id;
+	else {
+		/* If no, use the ping-pong mechanism to select one ring */
+		int ring_id;
+		mutex_lock(&dev->struct_mutex);
+		if (dev_priv->mm.bsd_ring_dispatch_index == 0) {
+			ring_id = VCS;
+			dev_priv->mm.bsd_ring_dispatch_index = 1;
+		} else {
+			ring_id = VCS2;
+			dev_priv->mm.bsd_ring_dispatch_index = 0;
+		}
+		file_priv->bsd_ring = &dev_priv->ring[ring_id];
+		mutex_unlock(&dev->struct_mutex);
+		return ring_id;
+	}
+}
+static struct drm_i915_gem_object *
+eb_get_batch(struct eb_vmas *eb)
+{
+	struct i915_vma *vma = list_entry(eb->vmas.prev, typeof(*vma), exec_list);
+	/*
+	 * SNA is doing fancy tricks with compressing batch buffers, which leads
+	 * to negative relocation deltas. Usually that works out ok since the
+	 * relocate address is still positive, except when the batch is placed
+	 * very low in the GTT. Ensure this doesn't happen.
+	 *
+	 * Note that actual hangs have only been observed on gen7, but for
+	 * paranoia do it everywhere.
+	 */
+	vma->exec_entry->flags |= __EXEC_OBJECT_NEEDS_BIAS;
+	return vma->obj;
+}
+static int
+i915_gem_do_execbuffer(struct drm_device *dev, void *data,
+		       struct drm_file *file,
+		       struct drm_i915_gem_execbuffer2 *args,
+		       struct drm_i915_gem_exec_object2 *exec)
 	if (args->num_cliprects != 0) {
+	struct drm_i915_private *dev_priv = dev->dev_private;
+	struct eb_vmas *eb;
+	struct drm_i915_gem_object *batch_obj;
+	struct intel_engine_cs *ring;
+	struct intel_context *ctx;
+	struct i915_address_space *vm;
+	const u32 ctx_id = i915_execbuffer2_get_context_id(*args);
+	u64 exec_start = args->batch_start_offset;
+	u32 flags;
-		if (ring != &dev_priv->ring[RCS]) {
+	int ret;
+	bool need_relocs;
-			DRM_DEBUG("clip rectangles are only valid with the render ring\n");
+	if (!i915_gem_check_execbuffer(args))
-			return -EINVAL;
+		return -EINVAL;
-		}
-		if (INTEL_INFO(dev)->gen >= 5) {
+	ret = validate_exec_list(exec, args->buffer_count);
-			DRM_DEBUG("clip rectangles are only valid on pre-gen5\n");
-			return -EINVAL;
+	if (ret)
+		return ret;
+	flags = 0;
-		}
+	if (args->flags & I915_EXEC_SECURE) {
+		flags |= I915_DISPATCH_SECURE;
-		if (args->num_cliprects > UINT_MAX / sizeof(*cliprects)) {
+	}
+	if (args->flags & I915_EXEC_IS_PINNED)
-			DRM_DEBUG("execbuf with %u cliprects\n",
+		flags |= I915_DISPATCH_PINNED;
+	if ((args->flags & I915_EXEC_RING_MASK) > LAST_USER_RING) {
+		DRM_DEBUG("execbuf with unknown ring: %d\n",
+			  (int)(args->flags & I915_EXEC_RING_MASK));
+		return -EINVAL;
+	}
-				  args->num_cliprects);
-			return -EINVAL;
+	if ((args->flags & I915_EXEC_RING_MASK) == I915_EXEC_DEFAULT)
+		ring = &dev_priv->ring[RCS];
+	else if ((args->flags & I915_EXEC_RING_MASK) == I915_EXEC_BSD) {
+		if (HAS_BSD2(dev)) {
+			int ring_id;
 			ring_id = gen8_dispatch_bsd_ring(dev, file);
 			ring = &dev_priv->ring[ring_id];
-		cliprects = kcalloc(args->num_cliprects,
+		} else
 		mutex_unlock(&dev->struct_mutex);
 		ret = -EBUSY;
 		goto pre_mutex_err;
+	}
-	ret = i915_gem_validate_context(dev, file, ctx_id);
+	ctx = i915_gem_validate_context(dev, file, ring, ctx_id);
-	if (ret) {
+	if (IS_ERR(ctx)) {
+		mutex_unlock(&dev->struct_mutex);
-		mutex_unlock(&dev->struct_mutex);
+		ret = PTR_ERR(ctx);
 		goto pre_mutex_err;
+	}
+	i915_gem_context_reference(ctx);
+	vm = ctx->vm;
+	if (!USES_FULL_PPGTT(dev))
 		vm = &dev_priv->gtt.base;
+	eb = eb_create(args);
-	eb = eb_create(args);
+	if (eb == NULL) {
-	if (eb == NULL) {
+		i915_gem_context_unreference(ctx);
 		mutex_unlock(&dev->struct_mutex);
 		ret = -ENOMEM;
 	ret = eb_lookup_vmas(eb, exec, args, vm, file);
 	if (ret)
 			goto err;
 	/* take note of the batch buffer before we might reorder the lists */
-	batch_obj = list_entry(eb->vmas.prev, struct i915_vma, exec_list)->obj;
+	batch_obj = eb_get_batch(eb);
 	/* Move the objects en-masse into the GTT, evicting if necessary. */
 	need_relocs = (args->flags & I915_EXEC_NO_RELOC) == 0;
 		DRM_DEBUG("Attempting to use self-modifying batch buffer\n");
 		ret = -EINVAL;
 		goto err;
+	}
 	batch_obj->base.pending_read_domains |= I915_GEM_DOMAIN_COMMAND;
-	/* snb/ivb/vlv conflate the "batch in ppgtt" bit with the "non-secure
-	 * batch" bit. Hence we need to pin secure batches into the global gtt.
-	 * hsw should have this fixed, but bdw mucks it up again. */
-	if (flags & I915_DISPATCH_SECURE && !batch_obj->has_global_gtt_mapping)
-		i915_gem_gtt_bind_object(batch_obj, batch_obj->cache_level);
-	ret = i915_gem_execbuffer_move_to_gpu(ring, &eb->vmas);
-	if (ret)
+#if 0
-		goto err;
+	if (i915_needs_cmd_parser(ring)) {
-	ret = i915_switch_context(ring, file, ctx_id);
+		ret = i915_parse_cmds(ring,
-	if (ret)
-		goto err;
+				      batch_obj,
-	if (ring == &dev_priv->ring[RCS] &&
-	    mode != dev_priv->relative_constants_mode) {
+				      args->batch_start_offset,
-		ret = intel_ring_begin(ring, 4);
+				      file->is_master);
 		if (ret)
-				goto err;
+			goto err;
+		/*
+		 * XXX: Actually do this when enabling batch copy...
-		intel_ring_emit(ring, MI_NOOP);
+		 *
-		intel_ring_emit(ring, MI_LOAD_REGISTER_IMM(1));
+		 * Set the DISPATCH_SECURE bit to remove the NON_SECURE bit
-		intel_ring_emit(ring, INSTPM);
+		 * from MI_BATCH_BUFFER_START commands issued in the
-		intel_ring_emit(ring, mask << 16 | mode);
+		 * dispatch_execbuffer implementations. We specifically don't
-		intel_ring_advance(ring);
+		 * want that set when the command parser is enabled.
-		dev_priv->relative_constants_mode = mode;
+		 */
 	}
+#endif
+	/* snb/ivb/vlv conflate the "batch in ppgtt" bit with the "non-secure
+	 * batch" bit. Hence we need to pin secure batches into the global gtt.
+	 * hsw should have this fixed, but bdw mucks it up again. */
-	if (args->flags & I915_EXEC_GEN7_SOL_RESET) {
+	if (flags & I915_DISPATCH_SECURE &&
+	    !batch_obj->has_global_gtt_mapping) {
-		ret = i915_reset_gen7_sol_offsets(dev, ring);
+		/* When we have multiple VMs, we'll need to make sure that we
+		 * allocate space first */
-		if (ret)
+		struct i915_vma *vma = i915_gem_obj_to_ggtt(batch_obj);
+		BUG_ON(!vma);
-			goto err;
+		vma->bind_vma(vma, batch_obj->cache_level, GLOBAL_BIND);
-	}
+	}
-	exec_start = i915_gem_obj_offset(batch_obj, vm) +
-		args->batch_start_offset;
+	if (flags & I915_DISPATCH_SECURE)
-	exec_len = args->batch_len;
-	if (cliprects) {
+		exec_start += i915_gem_obj_ggtt_offset(batch_obj);
-		for (i = 0; i < args->num_cliprects; i++) {
-			ret = i915_emit_box(dev, &cliprects[i],
-					    args->DR1, args->DR4);
-			if (ret)
+	else
-				goto err;
+		exec_start += i915_gem_obj_offset(batch_obj, vm);
 			ret = ring->dispatch_execbuffer(ring,
-							exec_start, exec_len,
+	ret = legacy_ringbuffer_submission(dev, file, ring, ctx,
-							flags);
-			if (ret)
-				goto err;
-		}
-	} else {
-		ret = ring->dispatch_execbuffer(ring,
-						exec_start, exec_len,
-						flags);
-		if (ret)
-			goto err;
-	}
-	trace_i915_gem_ring_dispatch(ring, intel_ring_get_seqno(ring), flags);
 			args, &eb->vmas, batch_obj, exec_start, flags);
+   	if (ret)
+		goto err;
 	i915_gem_execbuffer_move_to_active(&eb->vmas, ring);
-	i915_gem_execbuffer_retire_commands(dev, file, ring, batch_obj);
+err:
 	/* the request owns the ref now */
-err:
-	eb_destroy(eb);
 	i915_gem_context_unreference(ctx);
-	mutex_unlock(&dev->struct_mutex);
+	eb_destroy(eb);
-pre_mutex_err:
+	mutex_unlock(&dev->struct_mutex);
     kfree(cliprects);
  */
 int
 i915_gem_execbuffer(struct drm_device *dev, void *data,
 		    struct drm_file *file)
+{
-	struct drm_i915_private *dev_priv = dev->dev_private;
 	struct drm_i915_gem_execbuffer *args = data;
 	struct drm_i915_gem_execbuffer2 exec2;
 	struct drm_i915_gem_exec_object *exec_list = NULL;
 	struct drm_i915_gem_exec_object2 *exec2_list = NULL;
 	int ret, i;
 	exec2.num_cliprects = args->num_cliprects;
 	exec2.cliprects_ptr = args->cliprects_ptr;
 	exec2.flags = I915_EXEC_RENDER;
 	i915_execbuffer2_set_context_id(exec2, 0);
-	ret = i915_gem_do_execbuffer(dev, data, file, &exec2, exec2_list,
-				     &dev_priv->gtt.base);
+	ret = i915_gem_do_execbuffer(dev, data, file, &exec2, exec2_list);
+	if (!ret) {
+		struct drm_i915_gem_exec_object __user *user_exec_list =
+			to_user_ptr(args->buffers_ptr);
 	if (!ret) {
 		/* Copy the new buffer offsets back to the user's exec list. */
-		for (i = 0; i < args->buffer_count; i++)
-			exec_list[i].offset = exec2_list[i].offset;
-		/* ... and back out to userspace */
+		for (i = 0; i < args->buffer_count; i++) {
-		ret = copy_to_user(to_user_ptr(args->buffers_ptr),
+			ret = __copy_to_user(&user_exec_list[i].offset,
-				   exec_list,
+					     &exec2_list[i].offset,
-				   sizeof(*exec_list) * args->buffer_count);
+					     sizeof(user_exec_list[i].offset));
 		if (ret) {
 			ret = -EFAULT;
 			DRM_DEBUG("failed to copy %d exec entries "
 				  "back to user (%d)\n",
+				  args->buffer_count, ret);
+				break;
 				  args->buffer_count, ret);
+		}
+	}
 int
 i915_gem_execbuffer2(struct drm_device *dev, void *data,
 		     struct drm_file *file)
-{
 	struct drm_i915_private *dev_priv = dev->dev_private;
 	struct drm_i915_gem_execbuffer2 *args = data;
 	struct drm_i915_gem_exec_object2 *exec2_list = NULL;
 	int ret;
 	if (args->buffer_count < 1 ||
 	    args->buffer_count > UINT_MAX / sizeof(*exec2_list)) {
 		DRM_DEBUG("execbuf2 with %d buffers\n", args->buffer_count);
+		return -EINVAL;
+	}
+	if (args->rsvd2 != 0) {
+		DRM_DEBUG("dirty rvsd2 field\n");
 		return -EINVAL;
+	}
 	exec2_list = kmalloc(sizeof(*exec2_list)*args->buffer_count,
 			     GFP_TEMPORARY | __GFP_NOWARN | __GFP_NORETRY);
         kfree(exec2_list);
         FAIL();
 		return -EFAULT;
+	}
-	ret = i915_gem_do_execbuffer(dev, data, file, args, exec2_list,
-				     &dev_priv->gtt.base);
+	ret = i915_gem_do_execbuffer(dev, data, file, args, exec2_list);
 	if (!ret) {
+		/* Copy the new buffer offsets back to the user's exec list. */
-		/* Copy the new buffer offsets back to the user's exec list. */
+		struct drm_i915_gem_exec_object2 __user *user_exec_list =
+				   to_user_ptr(args->buffers_ptr);
+		int i;
+		for (i = 0; i < args->buffer_count; i++) {
-		ret = copy_to_user(to_user_ptr(args->buffers_ptr),
+			ret = __copy_to_user(&user_exec_list[i].offset,
-				   exec2_list,
+					     &exec2_list[i].offset,
-				   sizeof(*exec2_list) * args->buffer_count);
+					     sizeof(user_exec_list[i].offset));
 		if (ret) {
 			ret = -EFAULT;
 			DRM_DEBUG("failed to copy %d exec entries "
-				  "back to user (%d)\n",
+					  "back to user\n",
+					  args->buffer_count);
+				break;
 				  args->buffer_count, ret);
+		}
+	}

Subversion Repositories Kolibri OS

(root)/drivers/video/drm/i915/i915_gem_execbuffer.c – Rev 4560 → 5060