iv/linux
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

drm/radeon: add timeout argument to radeon_fence_wait_seq v2

Browse Source 
This makes it possible to wait for a specific amount of time,
rather than wait until infinity.

v2 (chk): rebased on other changes

Signed-off-by: Maarten Lankhorst <maarten.lankhorst@canonical.com>
Signed-off-by: Christian König <christian.koenig@amd.com>
Signed-off-by: Alex Deucher <alexander.deucher@amd.com>
This commit is contained in:
Maarten Lankhorst 2014-08-27 15:21:59 +02:00 committed by Alex Deucher
parent 0bfa4b4126
commit 9867d00dba
1 changed files with 28 additions and 20 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

48
drivers/gpu/drm/radeon/radeon_fence.c
View File

@ -364,28 +364,31 @@ static bool radeon_fence_any_seq_signaled(struct radeon_device *rdev, u64 *seq)
} }
/** /**
* radeon_fence_wait_seq - wait for a specific sequence numbers * radeon_fence_wait_seq_timeout - wait for a specific sequence numbers
* *
* @rdev: radeon device pointer * @rdev: radeon device pointer
* @target_seq: sequence number(s) we want to wait for * @target_seq: sequence number(s) we want to wait for
* @intr: use interruptable sleep * @intr: use interruptable sleep
* @timeout: maximum time to wait, or MAX_SCHEDULE_TIMEOUT for infinite wait
* *
* Wait for the requested sequence number(s) to be written by any ring * Wait for the requested sequence number(s) to be written by any ring
* (all asics). Sequnce number array is indexed by ring id. * (all asics). Sequnce number array is indexed by ring id.
* @intr selects whether to use interruptable (true) or non-interruptable * @intr selects whether to use interruptable (true) or non-interruptable
* (false) sleep when waiting for the sequence number. Helper function * (false) sleep when waiting for the sequence number. Helper function
* for radeon_fence_wait_*(). * for radeon_fence_wait_*().
* Returns 0 if the sequence number has passed, error for all other cases. * Returns remaining time if the sequence number has passed, 0 when
* the wait timeout, or an error for all other cases.
* -EDEADLK is returned when a GPU lockup has been detected. * -EDEADLK is returned when a GPU lockup has been detected.
*/ */
static int radeon_fence_wait_seq(struct radeon_device *rdev, u64 *target_seq, static long radeon_fence_wait_seq_timeout(struct radeon_device *rdev,
bool intr) u64 *target_seq, bool intr,
long timeout)
{ {
long r; long r;
int i; int i;
if (radeon_fence_any_seq_signaled(rdev, target_seq)) if (radeon_fence_any_seq_signaled(rdev, target_seq))
return 0; return timeout;
/* enable IRQs and tracing */ /* enable IRQs and tracing */
for (i = 0; i < RADEON_NUM_RINGS; ++i) { for (i = 0; i < RADEON_NUM_RINGS; ++i) {
@ -399,11 +402,11 @@ static int radeon_fence_wait_seq(struct radeon_device *rdev, u64 *target_seq,
if (intr) { if (intr) {
r = wait_event_interruptible_timeout(rdev->fence_queue, ( r = wait_event_interruptible_timeout(rdev->fence_queue, (
radeon_fence_any_seq_signaled(rdev, target_seq) radeon_fence_any_seq_signaled(rdev, target_seq)
|| rdev->needs_reset), MAX_SCHEDULE_TIMEOUT); || rdev->needs_reset), timeout);
} else { } else {
r = wait_event_timeout(rdev->fence_queue, ( r = wait_event_timeout(rdev->fence_queue, (
radeon_fence_any_seq_signaled(rdev, target_seq) radeon_fence_any_seq_signaled(rdev, target_seq)
|| rdev->needs_reset), MAX_SCHEDULE_TIMEOUT); || rdev->needs_reset), timeout);
} }
if (rdev->needs_reset) if (rdev->needs_reset)
@ -417,14 +420,14 @@ static int radeon_fence_wait_seq(struct radeon_device *rdev, u64 *target_seq,
trace_radeon_fence_wait_end(rdev->ddev, i, target_seq[i]); trace_radeon_fence_wait_end(rdev->ddev, i, target_seq[i]);
} }
return r < 0 ? r : 0; return r;
} }
/** /**
* radeon_fence_wait - wait for a fence to signal * radeon_fence_wait - wait for a fence to signal
* *
* @fence: radeon fence object * @fence: radeon fence object
* @intr: use interruptable sleep * @intr: use interruptible sleep
* *
* Wait for the requested fence to signal (all asics). * Wait for the requested fence to signal (all asics).
* @intr selects whether to use interruptable (true) or non-interruptable * @intr selects whether to use interruptable (true) or non-interruptable
@ -434,7 +437,7 @@ static int radeon_fence_wait_seq(struct radeon_device *rdev, u64 *target_seq,
int radeon_fence_wait(struct radeon_fence *fence, bool intr) int radeon_fence_wait(struct radeon_fence *fence, bool intr)
{ {
uint64_t seq[RADEON_NUM_RINGS] = {}; uint64_t seq[RADEON_NUM_RINGS] = {};
int r; long r;
if (fence == NULL) { if (fence == NULL) {
WARN(1, "Querying an invalid fence : %p !\n", fence); WARN(1, "Querying an invalid fence : %p !\n", fence);
@ -445,9 +448,10 @@ int radeon_fence_wait(struct radeon_fence *fence, bool intr)
if (seq[fence->ring] == RADEON_FENCE_SIGNALED_SEQ) if (seq[fence->ring] == RADEON_FENCE_SIGNALED_SEQ)
return 0; return 0;
r = radeon_fence_wait_seq(fence->rdev, seq, intr); r = radeon_fence_wait_seq_timeout(fence->rdev, seq, intr, MAX_SCHEDULE_TIMEOUT);
if (r) if (r < 0) {
return r; return r;
}
fence->seq = RADEON_FENCE_SIGNALED_SEQ; fence->seq = RADEON_FENCE_SIGNALED_SEQ;
return 0; return 0;
@ -472,7 +476,7 @@ int radeon_fence_wait_any(struct radeon_device *rdev,
{ {
uint64_t seq[RADEON_NUM_RINGS]; uint64_t seq[RADEON_NUM_RINGS];
unsigned i, num_rings = 0; unsigned i, num_rings = 0;
int r; long r;
for (i = 0; i < RADEON_NUM_RINGS; ++i) { for (i = 0; i < RADEON_NUM_RINGS; ++i) {
seq[i] = 0; seq[i] = 0;
@ -493,8 +497,8 @@ int radeon_fence_wait_any(struct radeon_device *rdev,
if (num_rings == 0) if (num_rings == 0)
return -ENOENT; return -ENOENT;
r = radeon_fence_wait_seq(rdev, seq, intr); r = radeon_fence_wait_seq_timeout(rdev, seq, intr, MAX_SCHEDULE_TIMEOUT);
if (r) { if (r < 0) {
return r; return r;
} }
return 0; return 0;
@ -513,6 +517,7 @@ int radeon_fence_wait_any(struct radeon_device *rdev,
int radeon_fence_wait_next(struct radeon_device *rdev, int ring) int radeon_fence_wait_next(struct radeon_device *rdev, int ring)
{ {
uint64_t seq[RADEON_NUM_RINGS] = {}; uint64_t seq[RADEON_NUM_RINGS] = {};
long r;
seq[ring] = atomic64_read(&rdev->fence_drv[ring].last_seq) + 1ULL; seq[ring] = atomic64_read(&rdev->fence_drv[ring].last_seq) + 1ULL;
if (seq[ring] >= rdev->fence_drv[ring].sync_seq[ring]) { if (seq[ring] >= rdev->fence_drv[ring].sync_seq[ring]) {
@ -520,7 +525,10 @@ int radeon_fence_wait_next(struct radeon_device *rdev, int ring)
already the last emited fence */ already the last emited fence */
return -ENOENT; return -ENOENT;
} }
return radeon_fence_wait_seq(rdev, seq, false); r = radeon_fence_wait_seq_timeout(rdev, seq, false, MAX_SCHEDULE_TIMEOUT);
if (r < 0)
return r;
return 0;
} }
/** /**
@ -536,18 +544,18 @@ int radeon_fence_wait_next(struct radeon_device *rdev, int ring)
int radeon_fence_wait_empty(struct radeon_device *rdev, int ring) int radeon_fence_wait_empty(struct radeon_device *rdev, int ring)
{ {
uint64_t seq[RADEON_NUM_RINGS] = {}; uint64_t seq[RADEON_NUM_RINGS] = {};
int r; long r;
seq[ring] = rdev->fence_drv[ring].sync_seq[ring]; seq[ring] = rdev->fence_drv[ring].sync_seq[ring];
if (!seq[ring]) if (!seq[ring])
return 0; return 0;
r = radeon_fence_wait_seq(rdev, seq, false); r = radeon_fence_wait_seq_timeout(rdev, seq, false, MAX_SCHEDULE_TIMEOUT);
if (r) { if (r < 0) {
if (r == -EDEADLK) if (r == -EDEADLK)
return -EDEADLK; return -EDEADLK;
dev_err(rdev->dev, "error waiting for ring[%d] to become idle (%d)\n", dev_err(rdev->dev, "error waiting for ring[%d] to become idle (%ld)\n",
ring, r); ring, r);
} }
return 0; return 0;