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

  * S3->S5->S0: destroy path
  * S4->S5->S0: destroy path on current context
+ *
  * There are two confusing terms used above:
  *  The "current context" means the context which is currently running on the
- *  GPU. The GPU has loaded it's state already and has stored away the gtt
+ *  GPU. The GPU has loaded its state already and has stored away the gtt
  *  offset of the BO. The GPU is not actively referencing the data at this
  *  offset, but it will on the next context switch. The only way to avoid this
  *  is to do a GPU reset.
+ *
  *  An "active context' is one which was previously the "current context" and is
 		if (IS_HASWELL(dev))
 			ret = HSW_CXT_TOTAL_SIZE;
 		else
 			ret = GEN7_CXT_TOTAL_SIZE(reg) * 64;
 		break;
+	case 8:
+		ret = GEN8_CXT_TOTAL_SIZE;
+		break;
 	default:
 		BUG();
+	}
 void i915_gem_context_free(struct kref *ctx_ref)
+{
 	struct i915_hw_context *ctx = container_of(ctx_ref,
 						   typeof(*ctx), ref);
 	list_del(&ctx->link);
 	drm_gem_object_unreference(&ctx->obj->base);
 	kfree(ctx);
+}
 	if (ctx == NULL)
 		return ERR_PTR(-ENOMEM);
 	kref_init(&ctx->ref);
+	ctx->obj = i915_gem_alloc_object(dev, dev_priv->hw_context_size);
-	ctx->obj = i915_gem_alloc_object(dev, dev_priv->hw_context_size);
+	INIT_LIST_HEAD(&ctx->link);
 	if (ctx->obj == NULL) {
 		kfree(ctx);
 		DRM_DEBUG_DRIVER("Context object allocated failed\n");
 		return ERR_PTR(-ENOMEM);
 	/* The ring associated with the context object is handled by the normal
 	 * object tracking code. We give an initial ring value simple to pass an
 	 * assertion in the context switch code.
 	 */
 	ctx->ring = &dev_priv->ring[RCS];
+	list_add_tail(&ctx->link, &dev_priv->context_list);
 	/* Default context will never have a file_priv */
 	if (file_priv == NULL)
 	if (ret < 0)
 		goto err_out;
 	ctx->file_priv = file_priv;
+	ctx->id = ret;
+	/* NB: Mark all slices as needing a remap so that when the context first
+	 * loads it will restore whatever remap state already exists. If there
+	 * is no remap info, it will be a NOP. */
-	ctx->id = ret;
+	ctx->remap_slice = (1 << NUM_L3_SLICES(dev)) - 1;
 	return ctx;
 	 * immediately switch back to the default context. This can cause a
 	 * problem as pinning the default context also requires GTT space which
 	 * may not be available. To avoid this we always pin the
 	 * default context.
 	 */
-	dev_priv->ring[RCS].default_context = ctx;
 	ret = i915_gem_obj_ggtt_pin(ctx->obj, CONTEXT_ALIGN, false, false);
 	if (ret) {
 		DRM_DEBUG_DRIVER("Couldn't pin %d\n", ret);
 		goto err_destroy;
+	}
 	if (ret) {
 		DRM_DEBUG_DRIVER("Switch failed %d\n", ret);
 		goto err_unpin;
+	}
+	dev_priv->ring[RCS].default_context = ctx;
 	DRM_DEBUG_DRIVER("Default HW context loaded\n");
 	return 0;
 err_unpin:
 	i915_gem_object_unpin(ctx->obj);
 err_destroy:
 	i915_gem_context_unreference(ctx);
 	return ret;
+}
+int i915_gem_context_init(struct drm_device *dev)
-void i915_gem_context_init(struct drm_device *dev)
+{
-{
-	struct drm_i915_private *dev_priv = dev->dev_private;
+	struct drm_i915_private *dev_priv = dev->dev_private;
-	if (!HAS_HW_CONTEXTS(dev)) {
-		dev_priv->hw_contexts_disabled = true;
+	int ret;
-		DRM_DEBUG_DRIVER("Disabling HW Contexts; old hardware\n");
-		return;
-	}
+	if (!HAS_HW_CONTEXTS(dev))
 		return 0;
 	/* If called from reset, or thaw... we've been here already */
-	if (dev_priv->hw_contexts_disabled ||
-	    dev_priv->ring[RCS].default_context)
+	/* If called from reset, or thaw... we've been here already */
-		return;
+	if (dev_priv->ring[RCS].default_context)
 		return 0;
-	dev_priv->hw_context_size = round_up(get_context_size(dev), 4096);
+	dev_priv->hw_context_size = round_up(get_context_size(dev), 4096);
-	if (dev_priv->hw_context_size > (1<<20)) {
+	if (dev_priv->hw_context_size > (1<<20)) {
-		dev_priv->hw_contexts_disabled = true;
+		DRM_DEBUG_DRIVER("Disabling HW Contexts; invalid size\n");
-		DRM_DEBUG_DRIVER("Disabling HW Contexts; invalid size\n");
+		return -E2BIG;
 		return;
 	ret = create_default_context(dev_priv);
 	if (ret) {
-	if (create_default_context(dev_priv)) {
+		DRM_DEBUG_DRIVER("Disabling HW Contexts; create failed %d\n",
-		dev_priv->hw_contexts_disabled = true;
+				 ret);
-		DRM_DEBUG_DRIVER("Disabling HW Contexts; create failed\n");
+		return ret;
-		return;
+	}
 	DRM_DEBUG_DRIVER("HW context support initialized\n");
-	DRM_DEBUG_DRIVER("HW context support initialized\n");
+	return 0;
+}
-void i915_gem_context_fini(struct drm_device *dev)
-{
-	struct drm_i915_private *dev_priv = dev->dev_private;
+void i915_gem_context_fini(struct drm_device *dev)
 	struct i915_hw_context *dctx = dev_priv->ring[RCS].default_context;
 	struct drm_i915_private *dev_priv = dev->dev_private;
-	if (dev_priv->hw_contexts_disabled)
+	struct i915_hw_context *dctx = dev_priv->ring[RCS].default_context;
 		return;
 	if (!HAS_HW_CONTEXTS(dev))
+		return;
+	/* The only known way to stop the gpu from accessing the hw context is
+	 * to reset it. Do this as the very last operation to avoid confusing
-	/* The only known way to stop the gpu from accessing the hw context is
+	 * other code, leading to spurious errors. */
-	 * to reset it. Do this as the very last operation to avoid confusing
+	intel_gpu_reset(dev);
 	 * other code, leading to spurious errors. */
+	/* When default context is created and switched to, base object refcount
+	 * will be 2 (+1 from object creation and +1 from do_switch()).
+	 * i915_gem_context_fini() will be called after gpu_idle() has switched
+	 * to default context. So we need to unreference the base object once
+	 * to offset the do_switch part, so that i915_gem_context_unreference()
+	 * can then free the base object correctly. */
-	intel_gpu_reset(dev);
+	WARN_ON(!dev_priv->ring[RCS].last_context);
 	if (dev_priv->ring[RCS].last_context == dctx) {
-	i915_gem_object_unpin(dctx->obj);
+		/* Fake switch to NULL context */
 		WARN_ON(dctx->obj->active);
 struct i915_ctx_hang_stats *
 i915_gem_context_get_hang_stats(struct drm_device *dev,
 				struct drm_file *file,
 				u32 id)
+{
-	struct drm_i915_private *dev_priv = dev->dev_private;
 	struct drm_i915_file_private *file_priv = file->driver_priv;
 	struct i915_hw_context *ctx;
 	if (id == DEFAULT_CONTEXT_ID)
 		return &file_priv->hang_stats;
+	if (!HAS_HW_CONTEXTS(dev))
-	ctx = NULL;
+		return ERR_PTR(-ENOENT);
 	if (!dev_priv->hw_contexts_disabled)
 		ctx = i915_gem_context_get(file->driver_priv, id);
 	if (ctx == NULL)
 static int do_switch(struct i915_hw_context *to)
+{
 	struct intel_ring_buffer *ring = to->ring;
 	struct i915_hw_context *from = ring->last_context;
 	u32 hw_flags = 0;
-	int ret;
+	int ret, i;
 	BUG_ON(from != NULL && from->obj != NULL && from->obj->pin_count == 0);
-	if (from == to)
+	if (from == to && !to->remap_slice)
 		return 0;
 	if (!to->obj->has_global_gtt_mapping)
 		i915_gem_gtt_bind_object(to->obj, to->obj->cache_level);
 	if (!to->is_initialized || is_default_context(to))
-		hw_flags |= MI_RESTORE_INHIBIT;
-	else if (WARN_ON_ONCE(from == to)) /* not yet expected */
-		hw_flags |= MI_FORCE_RESTORE;
+		hw_flags |= MI_RESTORE_INHIBIT;
 	ret = mi_set_context(ring, to, hw_flags);
 	if (ret) {
 		i915_gem_object_unpin(to->obj);
+		return ret;
+	}
+	for (i = 0; i < MAX_L3_SLICES; i++) {
+		if (!(to->remap_slice & (1<
+			continue;
+		ret = i915_gem_l3_remap(ring, i);
+		/* If it failed, try again next round */
+		if (ret)
+			DRM_DEBUG_DRIVER("L3 remapping failed\n");
+		else
-		return ret;
+			to->remap_slice &= ~(1<
+	}
 	/* The backing object for the context is done after switching to the
 	 * *next* context. Therefore we cannot retire the previous context until
 	 * the next context has already started running. In fact, the below code
 	 * is a bit suboptimal because the retiring can occur simply after the
-	 * MI_SET_CONTEXT instead of when the next seqno has completed.
-	 */
-	if (from != NULL) {
+	 * MI_SET_CONTEXT instead of when the next seqno has completed.
-		struct drm_i915_private *dev_priv = from->obj->base.dev->dev_private;
-		struct i915_address_space *ggtt = &dev_priv->gtt.base;
+	 */
-		from->obj->base.read_domains = I915_GEM_DOMAIN_INSTRUCTION;
+	if (from != NULL) {
-		list_move_tail(&i915_gem_obj_to_vma(from->obj, ggtt)->mm_list, &ggtt->active_list);
+		from->obj->base.read_domains = I915_GEM_DOMAIN_INSTRUCTION;
-		i915_gem_object_move_to_active(from->obj, ring);
+		i915_vma_move_to_active(i915_gem_obj_to_ggtt(from->obj), ring);
 		/* As long as MI_SET_CONTEXT is serializing, ie. it flushes the
 		 * whole damn pipeline, we don't need to explicitly mark the
 		 * object dirty. The only exception is that the context must be
 		 * correct in case the object gets swapped out. Ideally we'd be
 		 * able to defer doing this until we know the object would be
 		 * swapped, but there is no way to do that yet.
-		 */
-		from->obj->dirty = 1;
-		BUG_ON(from->obj->ring != ring);
-		ret = i915_add_request(ring, NULL);
+		 */
-		if (ret) {
-			/* Too late, we've already scheduled a context switch.
-			 * Try to undo the change so that the hw state is
-			 * consistent with out tracking. In case of emergency,
-			 * scream.
-			 */
-			WARN_ON(mi_set_context(ring, from, MI_RESTORE_INHIBIT));
+		from->obj->dirty = 1;
-			return ret;
+		BUG_ON(from->obj->ring != ring);
 		/* obj is kept alive until the next request by its active ref */
 /**
  * i915_switch_context() - perform a GPU context switch.
  * @ring: ring for which we'll execute the context switch
  * @file_priv: file_priv associated with the context, may be NULL
  * @id: context id number
- * @seqno: sequence number by which the new context will be switched to
- * @flags:
+ *
  * The context life cycle is simple. The context refcount is incremented and
  * decremented by 1 and create and destroy. If the context is in use by the GPU,
  * it will have a refoucnt > 1. This allows us to destroy the context abstract
  * object while letting the normal object tracking destroy the backing BO.
 			int to_id)
+{
 	struct drm_i915_private *dev_priv = ring->dev->dev_private;
 	struct i915_hw_context *to;
-	if (dev_priv->hw_contexts_disabled)
+	if (!HAS_HW_CONTEXTS(ring->dev))
 		return 0;
+}
 int i915_gem_context_create_ioctl(struct drm_device *dev, void *data,
 				  struct drm_file *file)
-{
 	struct drm_i915_private *dev_priv = dev->dev_private;
 	struct drm_i915_gem_context_create *args = data;
 	struct drm_i915_file_private *file_priv = file->driver_priv;
 	struct i915_hw_context *ctx;
 	int ret;
 	if (!(dev->driver->driver_features & DRIVER_GEM))
 		return -ENODEV;
-	if (dev_priv->hw_contexts_disabled)
+	if (!HAS_HW_CONTEXTS(dev))
 		return -ENODEV;

Subversion Repositories Kolibri OS

(root)/drivers/video/drm/i915/i915_gem_context.c – Rev 4539 → 4560