WebSVN – Kolibri OS – Diff – /drivers/video/drm/radeon/radeon_fence.c

  *    Jerome Glisse
  *    Dave Airlie
  */
 #include
 #include
-//#include
+#include
 #include
 #include
 #include
 #include
 #include "radeon_reg.h"
 		/* Save current last activity valuee, used to check for GPU lockups */
 		last_activity = rdev->fence_drv[ring].last_activity;
 //		trace_radeon_fence_wait_begin(rdev->ddev, seq);
 		radeon_irq_kms_sw_irq_get(rdev, ring);
-//       if (intr) {
+        if (intr) {
-//           r = wait_event_interruptible_timeout(rdev->fence_queue,
+			r = wait_event_interruptible_timeout(rdev->fence_queue,
-//               (signaled = radeon_fence_seq_signaled(rdev, target_seq, ring)),
+                (signaled = radeon_fence_seq_signaled(rdev, target_seq, ring)),
-//               timeout);
+                timeout);
-//                } else {
+            } else {
-//           r = wait_event_timeout(rdev->fence_queue,
+            r = wait_event_timeout(rdev->fence_queue,
-//               (signaled = radeon_fence_seq_signaled(rdev, target_seq, ring)),
+                (signaled = radeon_fence_seq_signaled(rdev, target_seq, ring)),
-//               timeout);
-//   }
+               timeout);
-        delay(1);
+            }
 		radeon_irq_kms_sw_irq_put(rdev, ring);
-//       if (unlikely(r < 0)) {
+        if (unlikely(r < 0)) {
-//           return r;
+            return r;
 //       }
 //		trace_radeon_fence_wait_end(rdev->ddev, seq);
 		if (unlikely(!signaled)) {
 		for (i = 0; i < RADEON_NUM_RINGS; ++i) {
 			if (target_seq[i]) {
 				radeon_irq_kms_sw_irq_get(rdev, i);
+			}
+		}
+		if (intr) {
+			r = wait_event_interruptible_timeout(rdev->fence_queue,
+				(signaled = radeon_fence_any_seq_signaled(rdev, target_seq)),
+				timeout);
+		} else {
-//        WaitEvent(fence->evnt);
+			r = wait_event_timeout(rdev->fence_queue,
+				(signaled = radeon_fence_any_seq_signaled(rdev, target_seq)),
-		r = 1;
+				timeout);
+		}
 		for (i = 0; i < RADEON_NUM_RINGS; ++i) {
 			if (target_seq[i]) {
 				radeon_irq_kms_sw_irq_put(rdev, i);
+			}
+		}
+ *
  * Wait for all fences on the requested ring to signal (all asics).
  * Returns 0 if the fences have passed, error for all other cases.
  * Caller must hold ring lock.
  */
-void radeon_fence_wait_empty_locked(struct radeon_device *rdev, int ring)
+int radeon_fence_wait_empty_locked(struct radeon_device *rdev, int ring)
+{
 	uint64_t seq = rdev->fence_drv[ring].sync_seq[ring];
-	while(1) {
 	int r;
 		r = radeon_fence_wait_seq(rdev, seq, ring, false, false);
+	if (r) {
 		if (r == -EDEADLK) {
-			mutex_unlock(&rdev->ring_lock);
-			r = radeon_gpu_reset(rdev);
-			mutex_lock(&rdev->ring_lock);
-			if (!r)
-				continue;
+			return -EDEADLK;
+	}
-		if (r) {
-			dev_err(rdev->dev, "error waiting for ring to become"
+		dev_err(rdev->dev, "error waiting for ring[%d] to become idle (%d)\n",
-				" idle (%d)\n", r);
-		}
-		return;
+			ring, r);
+	}
+	return 0;
+}
 /**
  * radeon_fence_ref - take a ref on a fence
+{
 	uint64_t index;
 	int r;
 	radeon_scratch_free(rdev, rdev->fence_drv[ring].scratch_reg);
-	if (rdev->wb.use_event) {
+	if (rdev->wb.use_event || !radeon_ring_supports_scratch_reg(rdev, &rdev->ring[ring])) {
 		rdev->fence_drv[ring].scratch_reg = 0;
 		index = R600_WB_EVENT_OFFSET + ring * 4;
 	} else {
 		r = radeon_scratch_get(rdev, &rdev->fence_drv[ring].scratch_reg);
+ *
  * Tear down the fence driver for all possible rings (all asics).
  */
 void radeon_fence_driver_fini(struct radeon_device *rdev)
+{
-	int ring;
+	int ring, r;
 	mutex_lock(&rdev->ring_lock);
 	for (ring = 0; ring < RADEON_NUM_RINGS; ring++) {
 		if (!rdev->fence_drv[ring].initialized)
 			continue;
+		r = radeon_fence_wait_empty_locked(rdev, ring);
+		if (r) {
+			/* no need to trigger GPU reset as we are unloading */
+			radeon_fence_driver_force_completion(rdev);
 		radeon_fence_wait_empty_locked(rdev, ring);
 		wake_up_all(&rdev->fence_queue);
 		radeon_scratch_free(rdev, rdev->fence_drv[ring].scratch_reg);
 		rdev->fence_drv[ring].initialized = false;
+	}
 	mutex_unlock(&rdev->ring_lock);
+}
+/**
+ * radeon_fence_driver_force_completion - force all fence waiter to complete
+ *
+ * @rdev: radeon device pointer
+ *
+ * In case of GPU reset failure make sure no process keep waiting on fence
+ * that will never complete.
+ */
+void radeon_fence_driver_force_completion(struct radeon_device *rdev)
+{
+	int ring;
+	for (ring = 0; ring < RADEON_NUM_RINGS; ring++) {
+		if (!rdev->fence_drv[ring].initialized)
+			continue;
+		radeon_fence_write(rdev, rdev->fence_drv[ring].sync_seq[ring], ring);
+	}
+}
 /*

Subversion Repositories Kolibri OS

(root)/drivers/video/drm/radeon/radeon_fence.c – Rev 3031 → 3192