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

 //#include
 #include
+extern int x86_clflush_size;
+#define PROT_READ       0x1             /* page can be read */
+#define PROT_WRITE      0x2             /* page can be written */
-extern int x86_clflush_size;
+#define MAP_SHARED      0x01            /* Share changes */
 #undef mb
 #undef rmb
 #undef wmb
 #define mb() asm volatile("mfence")
+#define rmb() asm volatile ("lfence")
+#define wmb() asm volatile ("sfence")
+unsigned long vm_mmap(struct file *file, unsigned long addr,
-#define rmb() asm volatile ("lfence")
+         unsigned long len, unsigned long prot,
-#define wmb() asm volatile ("sfence")
+         unsigned long flag, unsigned long offset);
 static inline void clflush(volatile void *__p)
 	obj = drm_gem_object_lookup(dev, file, args->handle);
 	if (obj == NULL)
 		return -ENOENT;
-	dbgprintf("%s offset %lld size %lld not supported\n",
+    dbgprintf("%s offset %lld size %lld\n",
-				args->offset, args->size);
+                __FUNCTION__, args->offset, args->size);
 	/* prime objects have no backing filp to GEM mmap
 	 * pages from.
 	 */
 	if (!obj->filp) {
 		drm_gem_object_unreference_unlocked(obj);
 		return -EINVAL;
 	}
-//	addr = vm_mmap(obj->filp, 0, args->size,
+    addr = vm_mmap(obj->filp, 0, args->size,
-//		       PROT_READ | PROT_WRITE, MAP_SHARED,
+              PROT_READ | PROT_WRITE, MAP_SHARED,
-//		       args->offset);
+              args->offset);
 	drm_gem_object_unreference_unlocked(obj);
-//	if (IS_ERR((void *)addr))
-//		return addr;
+    if (IS_ERR((void *)addr))
         return addr;
+{
 //	struct inode *inode;
 //	i915_gem_object_free_mmap_offset(obj);
-//	if (obj->base.filp == NULL)
+	if (obj->base.filp == NULL)
-//		return;
+		return;
 	/* Our goal here is to return as much of the memory as
 	for_each_sg(obj->pages->sgl, sg, page_count, i) {
 		struct page *page = sg_page(sg);
-		page_cache_release(page);
+//       page_cache_release(page);
+	}
     request->emitted_jiffies = GetTimerTicks();
 	was_empty = list_empty(&ring->request_list);
 	list_add_tail(&request->list, &ring->request_list);
 	request->file_priv = NULL;
+	if (file) {
+		struct drm_i915_file_private *file_priv = file->driver_priv;
+		spin_lock(&file_priv->mm.lock);
+		request->file_priv = file_priv;
+		list_add_tail(&request->client_list,
+			      &file_priv->mm.request_list);
+		spin_unlock(&file_priv->mm.lock);
+	}
 	trace_i915_gem_request_add(ring, request->seqno);
 	ring->outstanding_lazy_request = 0;
 	if (out_seqno)
 		*out_seqno = request->seqno;
 	return 0;
+}
+static inline void
+i915_gem_request_remove_from_client(struct drm_i915_gem_request *request)
+{
+	struct drm_i915_file_private *file_priv = request->file_priv;
+	if (!file_priv)
+		return;
+	spin_lock(&file_priv->mm.lock);
+	if (request->file_priv) {
+		list_del(&request->client_list);
+		request->file_priv = NULL;
+	}
 	spin_unlock(&file_priv->mm.lock);
+}
 		request = list_first_entry(&ring->request_list,
 					   struct drm_i915_gem_request,
 					   list);
 		list_del(&request->list);
-//       i915_gem_request_remove_from_client(request);
+		i915_gem_request_remove_from_client(request);
 		kfree(request);
+	}
 void
 i915_gem_retire_requests_ring(struct intel_ring_buffer *ring)
+{
 	uint32_t seqno;
+    ENTER();
 	if (list_empty(&ring->request_list))
 		return;
 		 * of the GPU head.
 		 */
 		ring->last_retired_head = request->tail;
+		list_del(&request->list);
-		list_del(&request->list);
+		i915_gem_request_remove_from_client(request);
 		kfree(request);
+	}
 		ring->irq_put(ring);
 		ring->trace_irq_seqno = 0;
+	}
+	WARN_ON(i915_verify_lists(ring->dev));
-	WARN_ON(i915_verify_lists(ring->dev));
+    LEAVE();
+}
 void
 	struct drm_device *dev;
 	struct intel_ring_buffer *ring;
 	bool idle;
 	int i;
+    ENTER();
 	dev_priv = container_of(work, drm_i915_private_t,
 				mm.retire_work.work);
 	dev = dev_priv->dev;
        queue_delayed_work(dev_priv->wq, &dev_priv->mm.retire_work, HZ);
 	if (idle)
 		intel_mark_idle(dev);
+	mutex_unlock(&dev->struct_mutex);
-	mutex_unlock(&dev->struct_mutex);
+    LEAVE();
+}
 /**
 i915_gem_object_unbind(struct drm_i915_gem_object *obj)
+{
 	drm_i915_private_t *dev_priv = obj->base.dev->dev_private;
 	int ret = 0;
+    if(obj == get_fb_obj())
+        return 0;
 	if (obj->gtt_space == NULL)
 		return 0;
 					    old_write_domain);
 	return 0;
-}
+}
 #if 0
 /* Throttle our rendering by waiting until the ring has completed our requests
  * emitted over 20 msec ago.
+ *
 static int
 i915_gem_ring_throttle(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;
-	unsigned long recent_enough = GetTimerTics() - msecs_to_jiffies(20);
+	unsigned long recent_enough = GetTimerTicks() - msecs_to_jiffies(20);
 	struct drm_i915_gem_request *request;
 	struct intel_ring_buffer *ring = NULL;
 	u32 seqno = 0;
 	int ret;
 	if (ret == 0)
 		queue_delayed_work(dev_priv->wq, &dev_priv->mm.retire_work, 0);
 	return ret;
-}
 #endif
 int
 i915_gem_object_pin(struct drm_i915_gem_object *obj,
 	int ret;
 	if (WARN_ON(obj->pin_count == DRM_I915_GEM_OBJECT_MAX_PIN_COUNT))
-		return -EBUSY;
 		return -EBUSY;
 #if 0
 	if (obj->gtt_space != NULL) {
 		if ((alignment && obj->gtt_offset & (alignment - 1)) ||
 		    (map_and_fenceable && !obj->map_and_fenceable)) {
 			ret = i915_gem_object_unbind(obj);
 			if (ret)
 				return ret;
+		}
+	}
-#endif
 	if (obj->gtt_space == NULL) {
 		struct drm_i915_private *dev_priv = obj->base.dev->dev_private;
 unlock:
 	mutex_unlock(&dev->struct_mutex);
 	return ret;
+}
 #if 0
 int
 i915_gem_throttle_ioctl(struct drm_device *dev, void *data,
 			struct drm_file *file_priv)
+{
 	return i915_gem_ring_throttle(dev, file_priv);
+}
 #if 0
 int
 i915_gem_madvise_ioctl(struct drm_device *dev, void *data,
 		       struct drm_file *file_priv)
 	i915_gem_cleanup_ringbuffer(dev);
 	mutex_unlock(&dev->struct_mutex);
 	/* Cancel the retire work handler, which should be idle now. */
-//   cancel_delayed_work_sync(&dev_priv->mm.retire_work);
+	cancel_delayed_work_sync(&dev_priv->mm.retire_work);

Subversion Repositories Kolibri OS

(root)/drivers/video/drm/i915/i915_gem.c – Rev 3260 → 3263