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

  * IN THE SOFTWARE.
+ *
  */
 #include
 #include
-#include "intel_drv.h"
+#include "i915_drv.h"
 #include "intel_guc.h"
 /**
- * DOC: GuC Client
+ * DOC: GuC-based command submission
+ *
  * i915_guc_client:
  * We use the term client to avoid confusion with contexts. A i915_guc_client is
  * equivalent to GuC object guc_context_desc. This context descriptor is
 	if (WARN_ON(len < 1 || len > 15))
 		return -EINVAL;
 	intel_uncore_forcewake_get(dev_priv, FORCEWAKE_ALL);
-	spin_lock(&dev_priv->guc.host2guc_lock);
+	intel_uncore_forcewake_get(dev_priv, FORCEWAKE_ALL);
 		dev_priv->guc.action_fail += 1;
 		dev_priv->guc.action_err = ret;
+	}
 	dev_priv->guc.action_status = status;
 	spin_unlock(&dev_priv->guc.host2guc_lock);
 	intel_uncore_forcewake_put(dev_priv, FORCEWAKE_ALL);
 	u32 data[2];
 	data[0] = HOST2GUC_ACTION_SAMPLE_FORCEWAKE;
 	/* WaRsDisableCoarsePowerGating:skl,bxt */
 	if (!intel_enable_rc6(dev_priv->dev) ||
-	    (IS_BROXTON(dev) && (INTEL_REVID(dev) < BXT_REVID_B0)) ||
+	    IS_BXT_REVID(dev, 0, BXT_REVID_A1) ||
-	    (IS_SKL_GT3(dev) && (INTEL_REVID(dev) <= SKL_REVID_E0)) ||
+	    (IS_SKL_GT3(dev) && IS_SKL_REVID(dev, 0, SKL_REVID_E0)) ||
-	    (IS_SKL_GT4(dev) && (INTEL_REVID(dev) <= SKL_REVID_E0)))
+	    (IS_SKL_GT4(dev) && IS_SKL_REVID(dev, 0, SKL_REVID_E0)))
 		data[1] = 0;
 	else
 		/* bit 0 and 1 are for Render and Media domain separately */
 				 struct i915_guc_client *client)
+{
 	struct drm_i915_private *dev_priv = guc_to_i915(guc);
 	struct guc_doorbell_info *doorbell;
 	void *base;
-	int drbreg = GEN8_DRBREGL(client->doorbell_id);
+	i915_reg_t drbreg = GEN8_DRBREGL(client->doorbell_id);
 	int value;
 	base = kmap_atomic(i915_gem_object_get_page(client->client_obj, 0));
 static uint32_t select_doorbell_cacheline(struct intel_guc *guc)
+{
 	const uint32_t cacheline_size = cache_line_size();
 	uint32_t offset;
-	spin_lock(&guc->host2guc_lock);
 	/* Doorbell uses a single cache line within a page */
 	offset = offset_in_page(guc->db_cacheline);
-	/* Moving to next cache line to reduce contention */
-	guc->db_cacheline += cacheline_size;
 	/* Moving to next cache line to reduce contention */
-	spin_unlock(&guc->host2guc_lock);
+	guc->db_cacheline += cacheline_size;
 	DRM_DEBUG_DRIVER("selected doorbell cacheline 0x%x, next 0x%x, linesize %u\n",
 	const uint16_t half = GUC_MAX_DOORBELLS / 2;
 	const uint16_t start = hi_pri ? half : 0;
 	const uint16_t end = start + half;
 	uint16_t id;
 	spin_lock(&guc->host2guc_lock);
 	id = find_next_zero_bit(guc->doorbell_bitmap, end, start);
 	if (id == end)
 		id = GUC_INVALID_DOORBELL_ID;
 	else
-		bitmap_set(guc->doorbell_bitmap, id, 1);
-	spin_unlock(&guc->host2guc_lock);
+		bitmap_set(guc->doorbell_bitmap, id, 1);
 	DRM_DEBUG_DRIVER("assigned %s priority doorbell id 0x%x\n",
 			hi_pri ? "high" : "normal", id);
 	return id;
-}
+}
-static void release_doorbell(struct intel_guc *guc, uint16_t id)
-	spin_lock(&guc->host2guc_lock);
+static void release_doorbell(struct intel_guc *guc, uint16_t id)
 	bitmap_clear(guc->doorbell_bitmap, id, 1);
-	spin_unlock(&guc->host2guc_lock);
+	bitmap_clear(guc->doorbell_bitmap, id, 1);
 static int guc_get_workqueue_space(struct i915_guc_client *gc, u32 *offset)
+{
 	struct guc_process_desc *desc;
 	void *base;
 	u32 size = sizeof(struct guc_wq_item);
-	int ret = 0, timeout_counter = 200;
+	int ret = -ETIMEDOUT, timeout_counter = 200;
 	base = kmap_atomic(i915_gem_object_get_page(gc->client_obj, 0));
 	desc = base + gc->proc_desc_offset;
-	while (timeout_counter-- > 0) {
-		ret = wait_for_atomic(CIRC_SPACE(gc->wq_tail, desc->head,
-				gc->wq_size) >= size, 1);
 	while (timeout_counter-- > 0) {
-		if (!ret) {
+		if (CIRC_SPACE(gc->wq_tail, desc->head, gc->wq_size) >= size) {
 			*offset = gc->wq_tail;
 			/* advance the tail for next workqueue item */
 			gc->wq_tail += size;
+			gc->wq_tail &= gc->wq_size - 1;
 			gc->wq_tail &= gc->wq_size - 1;
+			/* this will break the loop */
+			timeout_counter = 0;
+			ret = 0;
+		}
 			/* this will break the loop */
-			timeout_counter = 0;
+		if (timeout_counter)
 	BUG_ON(!ctx_obj);
 	WARN_ON(!i915_gem_obj_is_pinned(ctx_obj));
 	WARN_ON(!i915_gem_obj_is_pinned(rb_obj));
-	page = i915_gem_object_get_page(ctx_obj, LRC_STATE_PN);
+	page = i915_gem_object_get_dirty_page(ctx_obj, LRC_STATE_PN);
 	reg_state = kmap_atomic(page);
 	reg_state[CTX_RING_BUFFER_START+1] = i915_gem_obj_ggtt_offset(rb_obj);
 	kunmap_atomic(reg_state);
-}
+}
 /**
- * i915_guc_submit() - Submit commands through GuC
+/**
- * @client:	the guc client where commands will go through
+ * i915_guc_submit() - Submit commands through GuC
- * @ctx:	LRC where commands come from
+ * @client:	the guc client where commands will go through
- * @ring:	HW engine that will excute the commands
+ * @rq:		request associated with the commands
+ *
  * Return:	0 if succeed
  */
-int i915_guc_submit(struct i915_guc_client *client,
-		    struct drm_i915_gem_request *rq)
+int i915_guc_submit(struct i915_guc_client *client,
 		    struct drm_i915_gem_request *rq)
 	struct intel_guc *guc = client->guc;
-	enum intel_ring_id ring_id = rq->ring->id;
+	struct intel_guc *guc = client->guc;
-	unsigned long flags;
-	int q_ret, b_ret;
 	enum intel_ring_id ring_id = rq->ring->id;
-	/* Need this because of the deferred pin ctx and ring */
+	int q_ret, b_ret;
 	/* Shall we move this right after ring is pinned? */
-	lr_context_update(rq);
+	/* Need this because of the deferred pin ctx and ring */
 		client->b_fail += 1;
 		client->retcode = q_ret = b_ret;
 	} else {
 		client->retcode = 0;
+	}
-	spin_unlock_irqrestore(&client->wq_lock, flags);
-	spin_lock(&guc->host2guc_lock);
 	guc->submissions[ring_id] += 1;
 	guc->last_seqno[ring_id] = rq->seqno;
-	spin_unlock(&guc->host2guc_lock);
 	return q_ret;
+}
  * @dev:	drm device
  * @priority:	four levels priority _CRITICAL, _HIGH, _NORMAL and _LOW
  * 		The kernel client to replace ExecList submission is created with
  * 		NORMAL priority. Priority of a client for scheduler can be HIGH,
  * 		while a preemption context can use CRITICAL.
- * @ctx		the context to own the client (we use the default render context)
+ * @ctx:	the context that owns the client (we use the default render
+ * 		context)
+ *
  * Return:	An i915_guc_client object if success.
  */
 static struct i915_guc_client *guc_client_alloc(struct drm_device *dev,
 						uint32_t priority,
 		goto err;
 	client->client_obj = obj;
 	client->wq_offset = GUC_DB_SIZE;
-	client->wq_size = GUC_WQ_SIZE;
-	spin_lock_init(&client->wq_lock);
+	client->wq_size = GUC_WQ_SIZE;
 	client->doorbell_offset = select_doorbell_cacheline(guc);
 	guc->ctx_pool_obj = gem_allocate_guc_obj(dev_priv->dev, gemsize);
 	if (!guc->ctx_pool_obj)
-		return -ENOMEM;
-	spin_lock_init(&dev_priv->guc.host2guc_lock);
+		return -ENOMEM;
 	ida_init(&guc->ctx_ids);

Subversion Repositories Kolibri OS

(root)/drivers/video/drm/i915/i915_guc_submission.c – Rev 6320 → 6937