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

 #include
 #define RQ_BUG_ON(expr)
 extern int x86_clflush_size;
-#define __copy_to_user_inatomic __copy_to_user
+extern int x86_clflush_size;
-#define PROT_READ       0x1             /* page can be read */
-#define PROT_WRITE      0x2             /* page can be written */
-#define MAP_SHARED      0x01            /* Share changes */
+#define PROT_READ       0x1             /* page can be read */
 #define PROT_WRITE      0x2             /* page can be written */
 #define MAP_SHARED      0x01            /* Share changes */
 	struct i915_vma *vma;
 	size_t pinned;
 	pinned = 0;
 	mutex_lock(&dev->struct_mutex);
-	list_for_each_entry(vma, &ggtt->base.active_list, mm_list)
+	list_for_each_entry(vma, &ggtt->base.active_list, vm_link)
 		if (vma->pin_count)
 			pinned += vma->node.size;
-	list_for_each_entry(vma, &ggtt->base.inactive_list, mm_list)
+	list_for_each_entry(vma, &ggtt->base.inactive_list, vm_link)
 		if (vma->pin_count)
 			pinned += vma->node.size;
 	mutex_unlock(&dev->struct_mutex);
+{
 	struct i915_vma *vma, *next;
 	int ret;
 	drm_gem_object_reference(&obj->base);
-	list_for_each_entry_safe(vma, next, &obj->vma_list, vma_link)
+	list_for_each_entry_safe(vma, next, &obj->vma_list, obj_link)
 		if (i915_vma_unbind(vma))
 			break;
 /* This is the fast write path which cannot handle
  * page faults in the source data
+ */
+static inline int
+fast_user_write(struct io_mapping *mapping,
+		loff_t page_base, int page_offset,
+		char __user *user_data,
+		int length)
+{
+	void __iomem *vaddr_atomic;
+	void *vaddr;
+	unsigned long unwritten;
+	vaddr_atomic = io_mapping_map_atomic_wc(mapping, page_base);
+	/* We can use the cpu mem copy function because this is X86. */
+	vaddr = (void __force*)vaddr_atomic + page_offset;
+	unwritten = __copy_from_user_inatomic_nocache(vaddr,
+						      user_data, length);
+	io_mapping_unmap_atomic(vaddr_atomic);
- */
+	return unwritten;
+}
 /**
 		page_offset = offset_in_page(offset);
 		page_length = remain;
 		if ((page_offset + remain) > PAGE_SIZE)
 			page_length = PAGE_SIZE - page_offset;
-		MapPage(dev_priv->gtt.mappable,
+		/* If we get a fault while copying data, then (presumably) our
+		 * source page isn't available.  Return the error and we'll
-				dev_priv->gtt.mappable_base+page_base, PG_WRITEC|PG_SW);
+		 * retry in the slow path.
+		 */
+		if (fast_user_write(dev_priv->gtt.mappable, page_base,
+				    page_offset, user_data, page_length)) {
+			ret = -EFAULT;
+			goto out_flush;
 		memcpy((char*)dev_priv->gtt.mappable+page_offset, user_data, page_length);
 		remain -= page_length;
 		user_data += page_length;
 	vaddr = kmap_atomic(page);
 	if (needs_clflush_before)
 		drm_clflush_virt_range(vaddr + shmem_page_offset,
 				       page_length);
-	memcpy(vaddr + shmem_page_offset,
-						user_data,
+	ret = __copy_from_user_inatomic(vaddr + shmem_page_offset,
-						page_length);
+					user_data, page_length);
 	if (needs_clflush_after)
 		drm_clflush_virt_range(vaddr + shmem_page_offset,
 				       page_length);
 	const bool irq_test_in_progress =
 		ACCESS_ONCE(dev_priv->gpu_error.test_irq_rings) & intel_ring_flag(ring);
 	int state = interruptible ? TASK_INTERRUPTIBLE : TASK_UNINTERRUPTIBLE;
 	wait_queue_t wait;
 	unsigned long timeout_expire;
-	s64 before, now;
+	s64 before = 0; /* Only to silence a compiler warning. */
 	int ret;
 	WARN(!intel_irqs_enabled(dev_priv), "IRQs disabled");
 		if (*timeout == 0)
 			return -ETIME;
+		timeout_expire = jiffies + nsecs_to_jiffies_timeout(*timeout);
+		/*
+		 * Record current time in case interrupted by signal, or wedged.
 		 */
-		timeout_expire = jiffies + nsecs_to_jiffies_timeout(*timeout);
+		before = ktime_get_raw_ns();
+	}
 	if (INTEL_INFO(dev_priv)->gen >= 6)
-		gen6_rps_boost(dev_priv, rps, req->emitted_jiffies);
 	if (INTEL_INFO(dev_priv)->gen >= 6)
-	/* Record current time in case interrupted by signal, or wedged */
+		gen6_rps_boost(dev_priv, rps, req->emitted_jiffies);
 	trace_i915_gem_request_wait_begin(req);
-	before = ktime_get_raw_ns();
+	trace_i915_gem_request_wait_begin(req);
 		ring->irq_put(ring);
     DestroyEvent(wait.evnt);
 out:
-	now = ktime_get_raw_ns();
+out:
 	trace_i915_gem_request_wait_end(req);
 	if (timeout) {
-		s64 tres = *timeout - (now - before);
+		s64 tres = *timeout - (ktime_get_raw_ns() - before);
 	obj->active |= intel_ring_flag(ring);
 	list_move_tail(&obj->ring_list[ring->id], &ring->active_list);
 	i915_gem_request_assign(&obj->last_read_req[ring->id], req);
-	list_move_tail(&vma->mm_list, &vma->vm->active_list);
+	list_move_tail(&vma->vm_link, &vma->vm->active_list);
+}
 	 * (unless we are forced to ofc!)
 	 */
 	list_move_tail(&obj->global_list,
 		       &to_i915(obj->base.dev)->mm.bound_list);
-	list_for_each_entry(vma, &obj->vma_list, vma_link) {
+	list_for_each_entry(vma, &obj->vma_list, obj_link) {
-		if (!list_empty(&vma->mm_list))
+		if (!list_empty(&vma->vm_link))
-			list_move_tail(&vma->mm_list, &vma->vm->inactive_list);
+			list_move_tail(&vma->vm_link, &vma->vm->inactive_list);
+	}
 	i915_gem_request_assign(&obj->last_fenced_req, NULL);
 	ring->last_submitted_seqno = request->seqno;
 	list_add_tail(&request->list, &ring->request_list);
 	trace_i915_gem_request_add(request);
-//	i915_queue_hangcheck(ring->dev);
+	i915_queue_hangcheck(ring->dev);
 	queue_delayed_work(dev_priv->wq,
 	if (req->file_priv)
 		i915_gem_request_remove_from_client(req);
-	if (ctx) {
-		if (i915.enable_execlists) {
+	if (ctx) {
-			if (ctx != req->ring->default_context)
-				intel_lr_context_unpin(req);
+		if (i915.enable_execlists && ctx != req->i915->kernel_context)
 			intel_lr_context_unpin(ctx, req->ring);
 		i915_gem_context_unreference(ctx);
+	}
-	}
 	kfree(req);
 	kfree(req);
 static inline int
-int i915_gem_request_alloc(struct intel_engine_cs *ring,
+__i915_gem_request_alloc(struct intel_engine_cs *ring,
 err:
 	kfree(req);
 	return ret;
+}
+/**
+ * i915_gem_request_alloc - allocate a request structure
+ *
+ * @engine: engine that we wish to issue the request on.
+ * @ctx: context that the request will be associated with.
+ *       This can be NULL if the request is not directly related to
+ *       any specific user context, in which case this function will
+ *       choose an appropriate context to use.
+ *
+ * Returns a pointer to the allocated request if successful,
+ * or an error code if not.
+ */
+struct drm_i915_gem_request *
+i915_gem_request_alloc(struct intel_engine_cs *engine,
+		       struct intel_context *ctx)
+{
+	struct drm_i915_gem_request *req;
+	int err;
+	if (ctx == NULL)
+		ctx = to_i915(engine->dev)->kernel_context;
+	err = __i915_gem_request_alloc(engine, ctx, &req);
+	return err ? ERR_PTR(err) : req;
+}
 void i915_gem_request_cancel(struct drm_i915_gem_request *req)
+{
 	intel_ring_reserved_space_cancel(req->ringbuf);
 	for_each_ring(ring, dev_priv, i) {
 		i915_gem_retire_requests_ring(ring);
 		idle &= list_empty(&ring->request_list);
-		if (i915.enable_execlists) {
-			unsigned long flags;
+		if (i915.enable_execlists) {
-			spin_lock_irqsave(&ring->execlist_lock, flags);
+			spin_lock_irq(&ring->execlist_lock);
 			idle &= list_empty(&ring->execlist_queue);
-			spin_unlock_irqrestore(&ring->execlist_lock, flags);
+			spin_unlock_irq(&ring->execlist_lock);
 			intel_execlists_retire_requests(ring);
 		if (seqno <= from->semaphore.sync_seqno[idx])
 			return 0;
+		if (*to_req == NULL) {
+			struct drm_i915_gem_request *req;
-		if (*to_req == NULL) {
-			ret = i915_gem_request_alloc(to, to->default_context, to_req);
+			req = i915_gem_request_alloc(to, NULL);
+			if (IS_ERR(req))
+				return PTR_ERR(req);
 			if (ret)
-				return ret;
+			*to_req = req;
+		}
+{
 	struct drm_i915_gem_object *obj = vma->obj;
 	struct drm_i915_private *dev_priv = obj->base.dev->dev_private;
 	int ret;
-	if (list_empty(&vma->vma_link))
+	if (list_empty(&vma->obj_link))
 		return 0;
 	if (!drm_mm_node_allocated(&vma->node)) {
 		ret = i915_gem_object_wait_rendering(obj, false);
 		if (ret)
 			return ret;
+	}
-	if (i915_is_ggtt(vma->vm) &&
-	    vma->ggtt_view.type == I915_GGTT_VIEW_NORMAL) {
+	if (vma->is_ggtt && vma->ggtt_view.type == I915_GGTT_VIEW_NORMAL) {
 		i915_gem_object_finish_gtt(obj);
 		/* release the fence reg _after_ flushing */
 	trace_i915_vma_unbind(vma);
 	vma->vm->unbind_vma(vma);
 	vma->bound = 0;
-	list_del_init(&vma->mm_list);
+	list_del_init(&vma->vm_link);
-	if (i915_is_ggtt(vma->vm)) {
+	if (vma->is_ggtt) {
 		if (vma->ggtt_view.type == I915_GGTT_VIEW_NORMAL) {
 			obj->map_and_fenceable = false;
 		} else if (vma->ggtt_view.pages) {
 	/* Flush everything onto the inactive list. */
 	for_each_ring(ring, dev_priv, i) {
 		if (!i915.enable_execlists) {
 			struct drm_i915_gem_request *req;
-			ret = i915_gem_request_alloc(ring, ring->default_context, &req);
+			req = i915_gem_request_alloc(ring, NULL);
-			if (ret)
+			if (IS_ERR(req))
-				return ret;
+				return PTR_ERR(req);
 			ret = i915_switch_context(req);
 			if (ret) {
 	ret = i915_vma_bind(vma, obj->cache_level, flags);
 	if (ret)
 		goto err_remove_node;
 	list_move_tail(&obj->global_list, &dev_priv->mm.bound_list);
-	list_add_tail(&vma->mm_list, &vm->inactive_list);
+	list_add_tail(&vma->vm_link, &vm->inactive_list);
 	return vma;
 					    old_write_domain);
 	/* And bump the LRU for this access */
 	vma = i915_gem_obj_to_ggtt(obj);
 	if (vma && drm_mm_node_allocated(&vma->node) && !obj->active)
-		list_move_tail(&vma->mm_list,
+		list_move_tail(&vma->vm_link,
 			       &to_i915(obj->base.dev)->gtt.base.inactive_list);
 	/* Inspect the list of currently bound VMA and unbind any that would
 	 * be invalid given the new cache-level. This is principally to
 	 * catch the issue of the CS prefetch crossing page boundaries and
 	 * reading an invalid PTE on older architectures.
 	 */
-	list_for_each_entry_safe(vma, next, &obj->vma_list, vma_link) {
+	list_for_each_entry_safe(vma, next, &obj->vma_list, obj_link) {
 		if (!drm_mm_node_allocated(&vma->node))
 			continue;
 		if (vma->pin_count) {
 			 * rewrite it without confusing the GPU or having
 			 * to force userspace to fault back in its mmaps.
 			 */
+		}
-		list_for_each_entry(vma, &obj->vma_list, vma_link) {
+		list_for_each_entry(vma, &obj->vma_list, obj_link) {
 			if (!drm_mm_node_allocated(&vma->node))
 				continue;
 			ret = i915_vma_bind(vma, cache_level, PIN_UPDATE);
 			if (ret)
 				return ret;
 		}
+	}
-	list_for_each_entry(vma, &obj->vma_list, vma_link)
+	list_for_each_entry(vma, &obj->vma_list, obj_link)
 		vma->node.color = cache_level;
 	 */
 	ret = i915_gem_object_flush_active(obj);
 	if (ret)
 		goto unref;
+	args->busy = 0;
+	if (obj->active) {
+		int i;
+		for (i = 0; i < I915_NUM_RINGS; i++) {
+			struct drm_i915_gem_request *req;
-	BUILD_BUG_ON(I915_NUM_RINGS > 16);
+			req = obj->last_read_req[i];
+			if (req)
+				args->busy |= 1 << (16 + req->ring->exec_id);
 	args->busy = obj->active << 16;
-	if (obj->last_write_req)
+		if (obj->last_write_req)
+			args->busy |= obj->last_write_req->ring->exec_id;
 		args->busy |= obj->last_write_req->ring->id;
 unref:
 	drm_gem_object_unreference(&obj->base);
 	intel_runtime_pm_get(dev_priv);
 	trace_i915_gem_object_destroy(obj);
-	list_for_each_entry_safe(vma, next, &obj->vma_list, vma_link) {
+	list_for_each_entry_safe(vma, next, &obj->vma_list, obj_link) {
 		int ret;
 struct i915_vma *i915_gem_obj_to_vma(struct drm_i915_gem_object *obj,
 				     struct i915_address_space *vm)
+{
 	struct i915_vma *vma;
-	list_for_each_entry(vma, &obj->vma_list, vma_link) {
+	list_for_each_entry(vma, &obj->vma_list, obj_link) {
 		if (vma->ggtt_view.type == I915_GGTT_VIEW_NORMAL &&
 		    vma->vm == vm)
 			return vma;
+	}
 	struct i915_vma *vma;
 	if (WARN_ONCE(!view, "no view specified"))
 		return ERR_PTR(-EINVAL);
-	list_for_each_entry(vma, &obj->vma_list, vma_link)
+	list_for_each_entry(vma, &obj->vma_list, obj_link)
 		if (vma->vm == ggtt &&
 		    i915_ggtt_view_equal(&vma->ggtt_view, view))
 			return vma;
 	return NULL;
+}
 void i915_gem_vma_destroy(struct i915_vma *vma)
 void i915_gem_vma_destroy(struct i915_vma *vma)
 	struct i915_address_space *vm = NULL;
 	WARN_ON(vma->node.allocated);
-	/* Keep the vma as a placeholder in the execbuffer reservation lists */
-	if (!list_empty(&vma->exec_list))
-		return;
+	/* Keep the vma as a placeholder in the execbuffer reservation lists */
+	if (!list_empty(&vma->exec_list))
-	vm = vma->vm;
+		return;
-	if (!i915_is_ggtt(vm))
+	if (!vma->is_ggtt)
 	 * will prevent c3 entry. Makes sure all unused rings
 	 * are totally idle.
 	 */
 	init_unused_rings(dev);
-	BUG_ON(!dev_priv->ring[RCS].default_context);
+	BUG_ON(!dev_priv->kernel_context);
 	ret = i915_ppgtt_init_hw(dev);
 	if (ret) {
 	/* Now it is safe to go back round and do everything else: */
 	for_each_ring(ring, dev_priv, i) {
-		struct drm_i915_gem_request *req;
-		WARN_ON(!ring->default_context);
+		struct drm_i915_gem_request *req;
+		req = i915_gem_request_alloc(ring, NULL);
-		ret = i915_gem_request_alloc(ring, ring->default_context, &req);
+		if (IS_ERR(req)) {
-		if (ret) {
+			ret = PTR_ERR(req);
 			i915_gem_cleanup_ringbuffer(dev);
 			goto out;
 	struct intel_engine_cs *ring;
 	int i;
 	for_each_ring(ring, dev_priv, i)
+		dev_priv->gt.cleanup_ring(ring);
+    if (i915.enable_execlists)
+            /*
+             * Neither the BIOS, ourselves or any other kernel
+             * expects the system to be in execlists mode on startup,
+             * so we need to reset the GPU back to legacy mode.
+             */
-		dev_priv->gt.cleanup_ring(ring);
+            intel_gpu_reset(dev);
+}
 static void
 init_ring_lists(struct intel_engine_cs *ring)
+{
 	INIT_LIST_HEAD(&ring->active_list);
 	INIT_LIST_HEAD(&ring->request_list);
 }
 void
-i915_gem_load(struct drm_device *dev)
+i915_gem_load_init(struct drm_device *dev)
+{
 	/* Initialize fence registers to zero */
 	INIT_LIST_HEAD(&dev_priv->mm.fence_list);
 	i915_gem_restore_fences(dev);
+	i915_gem_detect_bit_6_swizzle(dev);
-	i915_gem_detect_bit_6_swizzle(dev);
+	init_waitqueue_head(&dev_priv->pending_flip_queue);
 	dev_priv->mm.interruptible = true;
 	INIT_LIST_HEAD(&file_priv->rps.link);
 	spin_lock_init(&file_priv->mm.lock);
+	INIT_LIST_HEAD(&file_priv->mm.request_list);
-	INIT_LIST_HEAD(&file_priv->mm.request_list);
+	file_priv->bsd_ring = -1;
 	ret = i915_gem_context_open(dev, file);
 	if (ret)
 	struct drm_i915_private *dev_priv = o->base.dev->dev_private;
 	struct i915_vma *vma;
 	WARN_ON(vm == &dev_priv->mm.aliasing_ppgtt->base);
-	list_for_each_entry(vma, &o->vma_list, vma_link) {
+	list_for_each_entry(vma, &o->vma_list, obj_link) {
-		if (i915_is_ggtt(vma->vm) &&
+		if (vma->is_ggtt &&
 		    vma->ggtt_view.type != I915_GGTT_VIEW_NORMAL)
 			continue;
 		if (vma->vm == vm)
 				  const struct i915_ggtt_view *view)
+{
 	struct i915_address_space *ggtt = i915_obj_to_ggtt(o);
 	struct i915_vma *vma;
-	list_for_each_entry(vma, &o->vma_list, vma_link)
+	list_for_each_entry(vma, &o->vma_list, obj_link)
 		if (vma->vm == ggtt &&
 		    i915_ggtt_view_equal(&vma->ggtt_view, view))
 			return vma->node.start;
 bool i915_gem_obj_bound(struct drm_i915_gem_object *o,
 			struct i915_address_space *vm)
+{
 	struct i915_vma *vma;
-	list_for_each_entry(vma, &o->vma_list, vma_link) {
+	list_for_each_entry(vma, &o->vma_list, obj_link) {
-		if (i915_is_ggtt(vma->vm) &&
+		if (vma->is_ggtt &&
 		    vma->ggtt_view.type != I915_GGTT_VIEW_NORMAL)
 			continue;
 		if (vma->vm == vm && drm_mm_node_allocated(&vma->node))
 			return true;
 				  const struct i915_ggtt_view *view)
+{
 	struct i915_address_space *ggtt = i915_obj_to_ggtt(o);
 	struct i915_vma *vma;
-	list_for_each_entry(vma, &o->vma_list, vma_link)
+	list_for_each_entry(vma, &o->vma_list, obj_link)
 		if (vma->vm == ggtt &&
 		    i915_ggtt_view_equal(&vma->ggtt_view, view) &&
 		    drm_mm_node_allocated(&vma->node))
 bool i915_gem_obj_bound_any(struct drm_i915_gem_object *o)
+{
 	struct i915_vma *vma;
-	list_for_each_entry(vma, &o->vma_list, vma_link)
+	list_for_each_entry(vma, &o->vma_list, obj_link)
 		if (drm_mm_node_allocated(&vma->node))
 			return true;
 	WARN_ON(vm == &dev_priv->mm.aliasing_ppgtt->base);
 	BUG_ON(list_empty(&o->vma_list));
-	list_for_each_entry(vma, &o->vma_list, vma_link) {
+	list_for_each_entry(vma, &o->vma_list, obj_link) {
-		if (i915_is_ggtt(vma->vm) &&
+		if (vma->is_ggtt &&
 		    vma->ggtt_view.type != I915_GGTT_VIEW_NORMAL)
 			continue;
+}
 bool i915_gem_obj_is_pinned(struct drm_i915_gem_object *obj)
+{
 	struct i915_vma *vma;
-	list_for_each_entry(vma, &obj->vma_list, vma_link)
+	list_for_each_entry(vma, &obj->vma_list, obj_link)
 		if (vma->pin_count > 0)
 			return true;

Subversion Repositories Kolibri OS

(root)/drivers/video/drm/i915/i915_gem.c – Rev 6937 → 7144