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

 		ret = GEN6_CXT_TOTAL_SIZE(reg) * 64;
 		break;
 	case 7:
 		reg = I915_READ(GEN7_CXT_SIZE);
 		if (IS_HASWELL(dev))
-			ret = HSW_CXT_TOTAL_SIZE(reg) * 64;
+			ret = HSW_CXT_TOTAL_SIZE;
 		else
 			ret = GEN7_CXT_TOTAL_SIZE(reg) * 64;
 		break;
 	default:
 		BUG();
+	}
 	return ret;
 }
-static void do_destroy(struct i915_hw_context *ctx)
+void i915_gem_context_free(struct kref *ctx_ref)
 {
-	if (ctx->file_priv)
+	struct i915_hw_context *ctx = container_of(ctx_ref,
-		idr_remove(&ctx->file_priv->context_idr, ctx->id);
+						   typeof(*ctx), ref);
 	ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
 	if (ctx == NULL)
+		return ERR_PTR(-ENOMEM);
 		return ERR_PTR(-ENOMEM);
 	kref_init(&ctx->ref);
 	ctx->obj = i915_gem_alloc_object(dev, dev_priv->hw_context_size);
 	if (ctx->obj == NULL) {
 		kfree(ctx);
 		DRM_DEBUG_DRIVER("Context object allocated failed\n");
 		return ERR_PTR(-ENOMEM);
+	}
+	if (INTEL_INFO(dev)->gen >= 7) {
-	if (INTEL_INFO(dev)->gen >= 7) {
+		ret = i915_gem_object_set_cache_level(ctx->obj,
-		ret = i915_gem_object_set_cache_level(ctx->obj,
+						      I915_CACHE_L3_LLC);
-						      I915_CACHE_LLC_MLC);
+		/* Failure shouldn't ever happen this early */
-		if (ret)
+		if (WARN_ON(ret))
 			goto err_out;
 	/* Default context will never have a file_priv */
 	if (file_priv == NULL)
-		return ctx;
-	ctx->file_priv = file_priv;
+		return ctx;
 	ret = idr_alloc(&file_priv->context_idr, ctx, DEFAULT_CONTEXT_ID + 1, 0,
 			GFP_KERNEL);
+	if (ret < 0)
+		goto err_out;
 	if (ret < 0)
-		goto err_out;
+	ctx->file_priv = file_priv;
 	ctx->id = ret;
 	return ctx;
 err_out:
-	do_destroy(ctx);
+	i915_gem_context_unreference(ctx);
 	 * 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_object_pin(ctx->obj, CONTEXT_ALIGN, false, false);
+	ret = i915_gem_obj_ggtt_pin(ctx->obj, CONTEXT_ALIGN, false, false);
-	if (ret)
+	if (ret) {
+		DRM_DEBUG_DRIVER("Couldn't pin %d\n", ret);
 		goto err_destroy;
+	}
 	ret = do_switch(ctx);
+	if (ret) {
-	if (ret)
+		DRM_DEBUG_DRIVER("Switch failed %d\n", ret);
+		goto err_unpin;
 		goto err_unpin;
 	DRM_DEBUG_DRIVER("Default HW context loaded\n");
 	return 0;
 err_unpin:
 	i915_gem_object_unpin(ctx->obj);
 err_destroy:
-	do_destroy(ctx);
+	i915_gem_context_unreference(ctx);
 	return ret;
+}
 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)) {
-	if (!HAS_HW_CONTEXTS(dev)) {
+		dev_priv->hw_contexts_disabled = true;
 	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;
-		dev_priv->hw_contexts_disabled = true;
+		DRM_DEBUG_DRIVER("Disabling HW Contexts; invalid size\n");
 		return;
+	}
 	if (create_default_context(dev_priv)) {
-	if (create_default_context(dev_priv)) {
+		dev_priv->hw_contexts_disabled = true;
-		dev_priv->hw_contexts_disabled = true;
+		DRM_DEBUG_DRIVER("Disabling HW Contexts; create failed\n");
 		return;
+	}
 	DRM_DEBUG_DRIVER("HW context support initialized\n");
+}
 void i915_gem_context_fini(struct drm_device *dev)
 void i915_gem_context_fini(struct drm_device *dev)
 	struct drm_i915_private *dev_priv = dev->dev_private;
-	struct drm_i915_private *dev_priv = dev->dev_private;
+	struct i915_hw_context *dctx = dev_priv->ring[RCS].default_context;
 	if (dev_priv->hw_contexts_disabled)
+		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
+	 * other code, leading to spurious errors. */
-		return;
+	intel_gpu_reset(dev);
-	/* The only known way to stop the gpu from accessing the hw context is
+	i915_gem_object_unpin(dctx->obj);
 	 * to reset it. Do this as the very last operation to avoid confusing
-	 * other code, leading to spurious errors. */
+	/* When default context is created and switched to, base object refcount
-//	intel_gpu_reset(dev);
+	 * will be 2 (+1 from object creation and +1 from do_switch()).
+	 * i915_gem_context_fini() will be called after gpu_idle() has switched
-	i915_gem_object_unpin(dev_priv->ring[RCS].default_context->obj);
+	 * to default context. So we need to unreference the base object once
 	 * to offset the do_switch part, so that i915_gem_context_unreference()
-	do_destroy(dev_priv->ring[RCS].default_context);
+	 * can then free the base object correctly. */
 	ret = intel_ring_begin(ring, 6);
 	if (ret)
+		return ret;
 		return ret;
 	/* WaProgramMiArbOnOffAroundMiSetContext:ivb,vlv,hsw */
 	if (IS_GEN7(ring->dev))
 		intel_ring_emit(ring, MI_ARB_ON_OFF | MI_ARB_DISABLE);
 	else
 		intel_ring_emit(ring, MI_NOOP);
 	intel_ring_emit(ring, MI_NOOP);
 	intel_ring_emit(ring, MI_SET_CONTEXT);
-	intel_ring_emit(ring, new_context->obj->gtt_offset |
+	intel_ring_emit(ring, i915_gem_obj_ggtt_offset(new_context->obj) |
 			MI_MM_SPACE_GTT |
 			MI_SAVE_EXT_STATE_EN |
+}
 static int do_switch(struct i915_hw_context *to)
+{
 	struct intel_ring_buffer *ring = to->ring;
-	struct drm_i915_gem_object *from_obj = ring->last_context_obj;
+	struct i915_hw_context *from = ring->last_context;
 	u32 hw_flags = 0;
 	int ret;
-	BUG_ON(from_obj != NULL && from_obj->pin_count == 0);
+	BUG_ON(from != NULL && from->obj != NULL && from->obj->pin_count == 0);
-	if (from_obj == to->obj)
+	if (from == to)
 		return 0;
-	ret = i915_gem_object_pin(to->obj, CONTEXT_ALIGN, false, false);
+	ret = i915_gem_obj_ggtt_pin(to->obj, CONTEXT_ALIGN, false, false);
 	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_obj == to->obj)) /* not yet expected */
+	else if (WARN_ON_ONCE(from == to)) /* not yet expected */
 		hw_flags |= MI_FORCE_RESTORE;
 	ret = mi_set_context(ring, to, hw_flags);
 	 * *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_obj != NULL) {
+	if (from != NULL) {
+		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;
+		from->obj->base.read_domains = I915_GEM_DOMAIN_INSTRUCTION;
+		list_move_tail(&i915_gem_obj_to_vma(from->obj, ggtt)->mm_list, &ggtt->active_list);
-		i915_gem_object_move_to_active(from_obj, ring);
+		i915_gem_object_move_to_active(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;
+		from->obj->dirty = 1;
-		BUG_ON(from_obj->ring != ring);
+		BUG_ON(from->obj->ring != ring);
-		i915_gem_object_unpin(from_obj);
+		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));
+			return ret;
+		}
+		i915_gem_object_unpin(from->obj);
-		drm_gem_object_unreference(&from_obj->base);
+		i915_gem_context_unreference(from);
 	}
-	drm_gem_object_reference(&to->obj->base);
+	i915_gem_context_reference(to);
-	ring->last_context_obj = to->obj;
+	ring->last_context = to;
 	to->is_initialized = true;
 	struct i915_hw_context *to;
 	if (dev_priv->hw_contexts_disabled)
+		return 0;
-		return 0;
+	WARN_ON(!mutex_is_locked(&dev_priv->dev->struct_mutex));
 	if (ring != &dev_priv->ring[RCS])
 		return 0;
 	if (!ctx) {
 		mutex_unlock(&dev->struct_mutex);
 		return -ENOENT;
+	}
 	do_destroy(ctx);
 	mutex_unlock(&dev->struct_mutex);

Subversion Repositories Kolibri OS

(root)/drivers/video/drm/i915/i915_gem_context.c – Rev 3746 → 4104