[PATCH 56/56] drm/i915: Update a bunch of LRC functions to take requests

John.C.Harrison
2015-03-05T13:57:36Z

From: John Harrison <John.C.Harrison@Intel.com>

A bunch of the low level LRC functions were passing around ringbuf and
ctx pairs. In a few cases, they took the r/c pair and a request as
well. This is all quite messy and unnecesary.

Updated those functions to just take the request structure.

For: VIZ-5115
Signed-off-by: John Harrison <John.C.Harrison@Intel.com>
---
drivers/gpu/drm/i915/intel_lrc.c | 61 ++++++++++++++++----------------------
1 file changed, 26 insertions(+), 35 deletions(-)

diff --git a/drivers/gpu/drm/i915/intel_lrc.c b/drivers/gpu/drm/i915/intel_lrc.c
index 1fa36de..ce5c19a 100644
--- a/drivers/gpu/drm/i915/intel_lrc.c
+++ b/drivers/gpu/drm/i915/intel_lrc.c
@@ -494,25 +494,20 @@ void intel_lrc_irq_handler(struct intel_engine_cs *ring)
((u32)ring->next_context_status_buffer & 0x07) << 8);
}

-static int execlists_context_queue(struct intel_engine_cs *ring,
- struct intel_context *to,
- u32 tail,
- struct drm_i915_gem_request *request)
+static int execlists_context_queue(struct drm_i915_gem_request *request)
{
+ struct intel_engine_cs *ring = request->ring;
struct drm_i915_gem_request *cursor;
struct drm_i915_private *dev_priv = ring->dev->dev_private;
unsigned long flags;
int num_elements = 0;

- if (to != ring->default_context)
- intel_lr_context_pin(ring, to);
-
- WARN_ON(!request);
- WARN_ON(to != request->ctx);
+ if (request->ctx != ring->default_context)
+ intel_lr_context_pin(ring, request->ctx);

i915_gem_request_reference(request);

- request->tail = tail;
+ request->tail = request->ringbuf->tail;

intel_runtime_pm_get(dev_priv);

@@ -529,7 +524,7 @@ static int execlists_context_queue(struct intel_engine_cs *ring,
struct drm_i915_gem_request,
execlist_link);

- if (to == tail_req->ctx) {
+ if (request->ctx == tail_req->ctx) {
WARN(tail_req->elsp_submitted != 0,
"More than 2 already-submitted reqs queued\n");
list_del(&tail_req->execlist_link);
@@ -636,7 +631,7 @@ static int logical_ring_wait_request(struct intel_ringbuffer *ringbuf,

/*
* intel_logical_ring_advance_and_submit() - advance the tail and submit the workload
- * @ringbuf: Logical Ringbuffer to advance.
+ * @request: Request to advance the logical ringbuffer of.
*
* The tail is updated in our logical ringbuffer struct, not in the actual context. What
* really happens during submission is that the context and current tail will be placed
@@ -644,32 +639,29 @@ static int logical_ring_wait_request(struct intel_ringbuffer *ringbuf,
* point, the tail *inside* the context is updated and the ELSP written to.
*/
static void
-intel_logical_ring_advance_and_submit(struct intel_ringbuffer *ringbuf,
- struct intel_context *ctx,
- struct drm_i915_gem_request *request)
+intel_logical_ring_advance_and_submit(struct drm_i915_gem_request *request)
{
- struct intel_engine_cs *ring = ringbuf->ring;
+ struct intel_engine_cs *ring = request->ring;

- intel_logical_ring_advance(ringbuf);
+ intel_logical_ring_advance(request->ringbuf);

if (intel_ring_stopped(ring))
return;

- execlists_context_queue(ring, ctx, ringbuf->tail, request);
+ execlists_context_queue(request);
}

-static int logical_ring_wait_for_space(struct intel_ringbuffer *ringbuf,
- struct intel_context *ctx,
+static int logical_ring_wait_for_space(struct drm_i915_gem_request *req,
int bytes)
{
- struct intel_engine_cs *ring = ringbuf->ring;
+ struct intel_engine_cs *ring = req->ring;
struct drm_device *dev = ring->dev;
struct drm_i915_private *dev_priv = dev->dev_private;
struct drm_i915_gem_request *local_req;
unsigned long end;
int ret;

- ret = logical_ring_wait_request(ringbuf, bytes);
+ ret = logical_ring_wait_request(req->ringbuf, bytes);
if (ret != -ENOSPC)
return ret;

@@ -686,10 +678,10 @@ static int logical_ring_wait_for_space(struct intel_ringbuffer *ringbuf,
* Thus the request cannot be submitted via i915_add_request() and
* can not be waiting on by i915_gem_wait_request().
*/
- ret = dev_priv->gt.alloc_request(ring, ctx, &local_req);
+ ret = dev_priv->gt.alloc_request(ring, req->ctx, &local_req);
if (ret)
return ret;
- intel_logical_ring_advance_and_submit(ringbuf, ctx, local_req);
+ intel_logical_ring_advance_and_submit(local_req);

/* With GEM the hangcheck timer should kick us out of the loop,
* leaving it early runs the risk of corrupting GEM state (due
@@ -700,7 +692,7 @@ static int logical_ring_wait_for_space(struct intel_ringbuffer *ringbuf,

ret = 0;
do {
- if (intel_ring_space(ringbuf) >= bytes)
+ if (intel_ring_space(req->ringbuf) >= bytes)
break;

msleep(1);
@@ -727,14 +719,14 @@ static int logical_ring_wait_for_space(struct intel_ringbuffer *ringbuf,
return ret;
}

-static int logical_ring_wrap_buffer(struct intel_ringbuffer *ringbuf,
- struct intel_context *ctx)
+static int logical_ring_wrap_buffer(struct drm_i915_gem_request *req)
{
+ struct intel_ringbuffer *ringbuf = req->ringbuf;
uint32_t __iomem *virt;
int rem = ringbuf->size - ringbuf->tail;

if (ringbuf->space < rem) {
- int ret = logical_ring_wait_for_space(ringbuf, ctx, rem);
+ int ret = logical_ring_wait_for_space(req, rem);

if (ret)
return ret;
@@ -751,19 +743,19 @@ static int logical_ring_wrap_buffer(struct intel_ringbuffer *ringbuf,
return 0;
}

-static int logical_ring_prepare(struct intel_ringbuffer *ringbuf,
- struct intel_context *ctx, int bytes)
+static int logical_ring_prepare(struct drm_i915_gem_request *req, int bytes)
{
+ struct intel_ringbuffer *ringbuf = req->ringbuf;
int ret;

if (unlikely(ringbuf->tail + bytes > ringbuf->effective_size)) {
- ret = logical_ring_wrap_buffer(ringbuf, ctx);
+ ret = logical_ring_wrap_buffer(req);
if (unlikely(ret))
return ret;
}

if (unlikely(ringbuf->space < bytes)) {
- ret = logical_ring_wait_for_space(ringbuf, ctx, bytes);
+ ret = logical_ring_wait_for_space(req, bytes);
if (unlikely(ret))
return ret;
}
@@ -799,8 +791,7 @@ static int intel_logical_ring_begin(struct drm_i915_gem_request *req,
if (ret)
return ret;

- ret = logical_ring_prepare(req->ringbuf, req->ctx,
- num_dwords * sizeof(uint32_t));
+ ret = logical_ring_prepare(req, num_dwords * sizeof(uint32_t));
if (ret)
return ret;

@@ -1334,7 +1325,7 @@ static int gen8_emit_request(struct drm_i915_gem_request *request)
intel_logical_ring_emit(ringbuf, i915_gem_request_get_seqno(request));
intel_logical_ring_emit(ringbuf, MI_USER_INTERRUPT);
intel_logical_ring_emit(ringbuf, MI_NOOP);
- intel_logical_ring_advance_and_submit(ringbuf, request->ctx, request);
+ intel_logical_ring_advance_and_submit(request);

return 0;
}
--
1.7.9.5