Subversion Repositories Kolibri OS

}

}

static void

i915_gem_object_move_to_inactive(struct drm_i915_gem_object *obj)

{

	struct drm_device *dev = obj->base.dev;

	struct drm_i915_private *dev_priv = dev->dev_private;

	if (obj->pin_count != 0)

		list_move_tail(&obj->mm_list, &dev_priv->mm.pinned_list);

	else

		list_move_tail(&obj->mm_list, &dev_priv->mm.inactive_list);

	BUG_ON(!list_empty(&obj->gpu_write_list));

	BUG_ON(!obj->active);

	obj->ring = NULL;

	i915_gem_object_move_off_active(obj);

	obj->fenced_gpu_access = false;

	obj->active = 0;

			trace_i915_gem_object_change_domain(obj,

							    obj->base.read_domains,

}

int

i915_add_request(struct intel_ring_buffer *ring,

		 struct drm_file *file,

		 struct drm_i915_gem_request *request)

{

	drm_i915_private_t *dev_priv = ring->dev->dev_private;

	uint32_t seqno;

	int was_empty;

	int ret;

	BUG_ON(request == NULL);

	ret = ring->add_request(ring, &seqno);

	if (ret)

	    return ret;

	trace_i915_gem_request_add(ring, seqno);

	request->seqno = seqno;

	request->ring = ring;

	request->emitted_jiffies = jiffies;

	was_empty = list_empty(&ring->request_list);

	list_add_tail(&request->list, &ring->request_list);

	ring->outstanding_lazy_request = false;

//	if (!dev_priv->mm.suspended) {

//		if (i915_enable_hangcheck) {

//			mod_timer(&dev_priv->hangcheck_timer,

//				  jiffies +

//				  msecs_to_jiffies(DRM_I915_HANGCHECK_PERIOD));

//		}

/**

 * This function clears the request list as sequence numbers are passed.

 */

static void

i915_gem_retire_requests_ring(struct intel_ring_buffer *ring)

{

	uint32_t seqno;

	int i;

	if (list_empty(&ring->request_list))

		return;

	WARN_ON(i915_verify_lists(ring->dev));

	seqno = ring->get_seqno(ring);

	for (i = 0; i < ARRAY_SIZE(ring->sync_seqno); i++)

		if (seqno >= ring->sync_seqno[i])

			ring->sync_seqno[i] = 0;

	while (!list_empty(&ring->request_list)) {

		struct drm_i915_gem_request *request;

		request = list_first_entry(&ring->request_list,

					   struct drm_i915_gem_request,

					   list);

		if (!i915_seqno_passed(seqno, request->seqno))

			break;

		trace_i915_gem_request_retire(ring, request->seqno);

		list_del(&request->list);

		kfree(request);

	}

	/* Move any buffers on the active list that are no longer referenced

	 * by the ringbuffer to the flushing/inactive lists as appropriate.

	 */

	while (!list_empty(&ring->active_list)) {

		struct drm_i915_gem_object *obj;

		obj = list_first_entry(&ring->active_list,

				      struct drm_i915_gem_object,

				      ring_list);

		if (!i915_seqno_passed(seqno, obj->last_rendering_seqno))

			break;

		if (obj->base.write_domain != 0)

			i915_gem_object_move_to_flushing(obj);

		else

			i915_gem_object_move_to_inactive(obj);

	}

	if (unlikely(ring->trace_irq_seqno &&

		     i915_seqno_passed(seqno, ring->trace_irq_seqno))) {

		ring->irq_put(ring);

		ring->trace_irq_seqno = 0;

	}

	WARN_ON(i915_verify_lists(ring->dev));

}

void

i915_gem_retire_requests(struct drm_device *dev)

{

	drm_i915_private_t *dev_priv = dev->dev_private;

	int i;

/**

 * Waits for a sequence number to be signaled, and cleans up the

 * request and object lists appropriately for that event.

 */

int

i915_wait_request(struct intel_ring_buffer *ring,

		  uint32_t seqno)

{

	drm_i915_private_t *dev_priv = ring->dev->dev_private;

	u32 ier;

	int ret = 0;

	BUG_ON(seqno == 0);

//   if (atomic_read(&dev_priv->mm.wedged)) {

//       struct completion *x = &dev_priv->error_completion;

//       bool recovery_complete;

//       unsigned long flags;

		/* Give the error handler a chance to run. */

//       spin_lock_irqsave(&x->wait.lock, flags);

//       recovery_complete = x->done > 0;

//       spin_unlock_irqrestore(&x->wait.lock, flags);

//

//       return recovery_complete ? -EIO : -EAGAIN;

//   }

	if (seqno == ring->outstanding_lazy_request) {

		struct drm_i915_gem_request *request;

		request = kzalloc(sizeof(*request), GFP_KERNEL);

		if (request == NULL)

			return -ENOMEM;

		ret = i915_add_request(ring, NULL, request);

		if (ret) {

			kfree(request);

			return ret;

		}

		seqno = request->seqno;

	}

	if (!i915_seqno_passed(ring->get_seqno(ring), seqno)) {

		if (HAS_PCH_SPLIT(ring->dev))

			ier = I915_READ(DEIER) | I915_READ(GTIER);

		else

			ier = I915_READ(IER);

		if (!ier) {

			DRM_ERROR("something (likely vbetool) disabled "

				  "interrupts, re-enabling\n");

//           ring->dev->driver->irq_preinstall(ring->dev);

//           ring->dev->driver->irq_postinstall(ring->dev);

		}

		trace_i915_gem_request_wait_begin(ring, seqno);

		ring->waiting_seqno = seqno;

        if (ring->irq_get(ring)) {

//            printf("enter wait\n");

            wait_event(ring->irq_queue,

                      i915_seqno_passed(ring->get_seqno(ring), seqno)

                      || atomic_read(&dev_priv->mm.wedged));

           ring->irq_put(ring);

        } else if (wait_for_atomic(i915_seqno_passed(ring->get_seqno(ring),

							     seqno) ||

					   atomic_read(&dev_priv->mm.wedged), 3000))

			ret = -EBUSY;

		ring->waiting_seqno = 0;

		trace_i915_gem_request_wait_end(ring, seqno);

	}

	if (atomic_read(&dev_priv->mm.wedged))

		ret = -EAGAIN;

	if (ret && ret != -ERESTARTSYS)

		DRM_ERROR("%s returns %d (awaiting %d at %d, next %d)\n",

			  __func__, ret, seqno, ring->get_seqno(ring),

			  dev_priv->next_seqno);

	/* Directly dispatch request retiring.  While we have the work queue

	 * to handle this, the waiter on a request often wants an associated

	 * buffer to have made it to the inactive list, and we would need

	 * a separate wait queue to handle that.

	 */

	if (ret == 0)

		i915_gem_retire_requests_ring(ring);

	BUG_ON(obj->pin_count == DRM_I915_GEM_OBJECT_MAX_PIN_COUNT);