Merge branch 'for-airlied-next' of git://people.freedesktop.org/~mlankhorst/linux into drm-next (6ba59f3b) · Commits · 戴 / test

drivers/gpu/drm/nouveau/nouveau_bo.c

+13 −51

Original line number	Diff line number	Diff line
		@@ -88,13 +88,13 @@ nv10_bo_get_tile_region(struct drm_device *dev, int i)

		static void
		nv10_bo_put_tile_region(struct drm_device dev, struct nouveau_drm_tile tile,
		struct nouveau_fence *fence)
		struct fence *fence)
		{
		struct nouveau_drm *drm = nouveau_drm(dev);

		if (tile) {
		spin_lock(&drm->tile.lock);
		tile->fence = nouveau_fence_ref(fence);
		tile->fence = (struct nouveau_fence *)fence_get(fence);
		tile->used = false;
		spin_unlock(&drm->tile.lock);
		}
		@@ -970,13 +970,14 @@ nouveau_bo_move_m2mf(struct ttm_buffer_object *bo, int evict, bool intr,
		}

		mutex_lock_nested(&cli->mutex, SINGLE_DEPTH_NESTING);
		ret = nouveau_fence_sync(bo->sync_obj, chan);
		ret = nouveau_fence_sync(nouveau_bo(bo), chan, true);
		if (ret == 0) {
		ret = drm->ttm.move(chan, bo, &bo->mem, new_mem);
		if (ret == 0) {
		ret = nouveau_fence_new(chan, false, &fence);
		if (ret == 0) {
		ret = ttm_bo_move_accel_cleanup(bo, fence,
		ret = ttm_bo_move_accel_cleanup(bo,
		&fence->base,
		evict,
		no_wait_gpu,
		new_mem);
		@@ -1167,8 +1168,9 @@ nouveau_bo_vm_cleanup(struct ttm_buffer_object *bo,
		{
		struct nouveau_drm *drm = nouveau_bdev(bo->bdev);
		struct drm_device *dev = drm->dev;
		struct fence *fence = reservation_object_get_excl(bo->resv);

		nv10_bo_put_tile_region(dev, *old_tile, bo->sync_obj);
		nv10_bo_put_tile_region(dev, *old_tile, fence);
		*old_tile = new_tile;
		}

		@@ -1212,9 +1214,7 @@ nouveau_bo_move(struct ttm_buffer_object *bo, bool evict, bool intr,
		}

		/* Fallback to software copy. */
		spin_lock(&bo->bdev->fence_lock);
		ret = ttm_bo_wait(bo, true, intr, no_wait_gpu);
		spin_unlock(&bo->bdev->fence_lock);
		if (ret == 0)
		ret = ttm_bo_move_memcpy(bo, evict, no_wait_gpu, new_mem);

		@@ -1458,47 +1458,14 @@ nouveau_ttm_tt_unpopulate(struct ttm_tt *ttm)
		}

		void
		nouveau_bo_fence(struct nouveau_bo nvbo, struct nouveau_fence fence)
		nouveau_bo_fence(struct nouveau_bo nvbo, struct nouveau_fence fence, bool exclusive)
		{
		struct nouveau_fence *new_fence = nouveau_fence_ref(fence);
		struct nouveau_fence *old_fence = NULL;
		struct reservation_object *resv = nvbo->bo.resv;

		spin_lock(&nvbo->bo.bdev->fence_lock);
		old_fence = nvbo->bo.sync_obj;
		nvbo->bo.sync_obj = new_fence;
		spin_unlock(&nvbo->bo.bdev->fence_lock);

		nouveau_fence_unref(&old_fence);
		}

		static void
		nouveau_bo_fence_unref(void **sync_obj)
		{
		nouveau_fence_unref((struct nouveau_fence **)sync_obj);
		}

		static void *
		nouveau_bo_fence_ref(void *sync_obj)
		{
		return nouveau_fence_ref(sync_obj);
		}

		static bool
		nouveau_bo_fence_signalled(void *sync_obj)
		{
		return nouveau_fence_done(sync_obj);
		}

		static int
		nouveau_bo_fence_wait(void *sync_obj, bool lazy, bool intr)
		{
		return nouveau_fence_wait(sync_obj, lazy, intr);
		}

		static int
		nouveau_bo_fence_flush(void *sync_obj)
		{
		return 0;
		if (exclusive)
		reservation_object_add_excl_fence(resv, &fence->base);
		else if (fence)
		reservation_object_add_shared_fence(resv, &fence->base);
		}

		struct ttm_bo_driver nouveau_bo_driver = {
		@@ -1511,11 +1478,6 @@ struct ttm_bo_driver nouveau_bo_driver = {
		.move_notify = nouveau_bo_move_ntfy,
		.move = nouveau_bo_move,
		.verify_access = nouveau_bo_verify_access,
		.sync_obj_signaled = nouveau_bo_fence_signalled,
		.sync_obj_wait = nouveau_bo_fence_wait,
		.sync_obj_flush = nouveau_bo_fence_flush,
		.sync_obj_unref = nouveau_bo_fence_unref,
		.sync_obj_ref = nouveau_bo_fence_ref,
		.fault_reserve_notify = &nouveau_ttm_fault_reserve_notify,
		.io_mem_reserve = &nouveau_ttm_io_mem_reserve,
		.io_mem_free = &nouveau_ttm_io_mem_free,

drivers/gpu/drm/nouveau/nouveau_bo.h

+1 −1

Original line number	Diff line number	Diff line
		@@ -78,7 +78,7 @@ u16 nouveau_bo_rd16(struct nouveau_bo *, unsigned index);
		void nouveau_bo_wr16(struct nouveau_bo *, unsigned index, u16 val);
		u32 nouveau_bo_rd32(struct nouveau_bo *, unsigned index);
		void nouveau_bo_wr32(struct nouveau_bo *, unsigned index, u32 val);
		void nouveau_bo_fence(struct nouveau_bo , struct nouveau_fence );
		void nouveau_bo_fence(struct nouveau_bo , struct nouveau_fence , bool exclusive);
		int nouveau_bo_validate(struct nouveau_bo *, bool interruptible,
		bool no_wait_gpu);

drivers/gpu/drm/nouveau/nouveau_display.c

+16 −11

Original line number	Diff line number	Diff line
		@@ -658,7 +658,7 @@ nouveau_page_flip_emit(struct nouveau_channel *chan,
		spin_unlock_irqrestore(&dev->event_lock, flags);

		/* Synchronize with the old framebuffer */
		ret = nouveau_fence_sync(old_bo->bo.sync_obj, chan);
		ret = nouveau_fence_sync(old_bo, chan, false);
		if (ret)
		goto fail;

		@@ -717,19 +717,24 @@ nouveau_crtc_page_flip(struct drm_crtc crtc, struct drm_framebuffer fb,
		}

		mutex_lock(&cli->mutex);
		ret = ttm_bo_reserve(&new_bo->bo, true, false, false, NULL);
		if (ret)
		goto fail_unpin;

		/* synchronise rendering channel with the kernel's channel */
		spin_lock(&new_bo->bo.bdev->fence_lock);
		fence = nouveau_fence_ref(new_bo->bo.sync_obj);
		spin_unlock(&new_bo->bo.bdev->fence_lock);
		ret = nouveau_fence_sync(fence, chan);
		nouveau_fence_unref(&fence);
		if (ret)
		ret = nouveau_fence_sync(new_bo, chan, false);
		if (ret) {
		ttm_bo_unreserve(&new_bo->bo);
		goto fail_unpin;
		}

		if (new_bo != old_bo) {
		ttm_bo_unreserve(&new_bo->bo);

		ret = ttm_bo_reserve(&old_bo->bo, true, false, false, NULL);
		if (ret)
		goto fail_unpin;
		}

		/* Initialize a page flip struct */
		*s = (struct nouveau_page_flip_state)
		@@ -775,7 +780,7 @@ nouveau_crtc_page_flip(struct drm_crtc crtc, struct drm_framebuffer fb,
		/* Update the crtc struct and cleanup */
		crtc->primary->fb = fb;

		nouveau_bo_fence(old_bo, fence);
		nouveau_bo_fence(old_bo, fence, false);
		ttm_bo_unreserve(&old_bo->bo);
		if (old_bo != new_bo)
		nouveau_bo_unpin(old_bo);

drivers/gpu/drm/nouveau/nouveau_fence.c

+344 −174

Original line number	Diff line number	Diff line
		@@ -28,6 +28,7 @@

		#include <linux/ktime.h>
		#include <linux/hrtimer.h>
		#include <trace/events/fence.h>

		#include <nvif/notify.h>
		#include <nvif/event.h>
		@@ -36,123 +37,210 @@
		#include "nouveau_dma.h"
		#include "nouveau_fence.h"

		struct fence_work {
		struct work_struct base;
		struct list_head head;
		void (func)(void );
		void *data;
		};
		static const struct fence_ops nouveau_fence_ops_uevent;
		static const struct fence_ops nouveau_fence_ops_legacy;

		static inline struct nouveau_fence *
		from_fence(struct fence *fence)
		{
		return container_of(fence, struct nouveau_fence, base);
		}

		static inline struct nouveau_fence_chan *
		nouveau_fctx(struct nouveau_fence *fence)
		{
		return container_of(fence->base.lock, struct nouveau_fence_chan, lock);
		}

		static void
		nouveau_fence_signal(struct nouveau_fence *fence)
		{
		struct fence_work work, temp;
		fence_signal_locked(&fence->base);
		list_del(&fence->head);

		if (test_bit(FENCE_FLAG_USER_BITS, &fence->base.flags)) {
		struct nouveau_fence_chan *fctx = nouveau_fctx(fence);

		list_for_each_entry_safe(work, temp, &fence->work, head) {
		schedule_work(&work->base);
		list_del(&work->head);
		if (!--fctx->notify_ref)
		nvif_notify_put(&fctx->notify);
		}

		fence->channel = NULL;
		list_del(&fence->head);
		fence_put(&fence->base);
		}

		static struct nouveau_fence *
		nouveau_local_fence(struct fence fence, struct nouveau_drm drm) {
		struct nouveau_fence_priv priv = (void)drm->fence;

		if (fence->ops != &nouveau_fence_ops_legacy &&
		fence->ops != &nouveau_fence_ops_uevent)
		return NULL;

		if (fence->context < priv->context_base \|\|
		fence->context >= priv->context_base + priv->contexts)
		return NULL;

		return from_fence(fence);
		}

		void
		nouveau_fence_context_del(struct nouveau_fence_chan *fctx)
		{
		struct nouveau_fence fence, fnext;
		spin_lock(&fctx->lock);
		list_for_each_entry_safe(fence, fnext, &fctx->pending, head) {
		struct nouveau_fence *fence;

		nvif_notify_fini(&fctx->notify);

		spin_lock_irq(&fctx->lock);
		while (!list_empty(&fctx->pending)) {
		fence = list_entry(fctx->pending.next, typeof(*fence), head);

		nouveau_fence_signal(fence);
		fence->channel = NULL;
		}
		spin_unlock(&fctx->lock);
		spin_unlock_irq(&fctx->lock);
		}

		static void
		nouveau_fence_update(struct nouveau_channel chan, struct nouveau_fence_chan fctx)
		{
		struct nouveau_fence *fence;

		u32 seq = fctx->read(chan);

		while (!list_empty(&fctx->pending)) {
		fence = list_entry(fctx->pending.next, typeof(*fence), head);

		if ((int)(seq - fence->base.seqno) < 0)
		return;

		nouveau_fence_signal(fence);
		}
		}

		static int
		nouveau_fence_wait_uevent_handler(struct nvif_notify *notify)
		{
		struct nouveau_fence_chan *fctx =
		container_of(notify, typeof(*fctx), notify);
		unsigned long flags;

		spin_lock_irqsave(&fctx->lock, flags);
		if (!list_empty(&fctx->pending)) {
		struct nouveau_fence *fence;

		fence = list_entry(fctx->pending.next, typeof(*fence), head);
		nouveau_fence_update(fence->channel, fctx);
		}
		spin_unlock_irqrestore(&fctx->lock, flags);

		/* Always return keep here. NVIF refcount is handled with nouveau_fence_update */
		return NVIF_NOTIFY_KEEP;
		}

		void
		nouveau_fence_context_new(struct nouveau_fence_chan *fctx)
		nouveau_fence_context_new(struct nouveau_channel chan, struct nouveau_fence_chan fctx)
		{
		struct nouveau_fence_priv priv = (void)chan->drm->fence;
		int ret;

		INIT_LIST_HEAD(&fctx->flip);
		INIT_LIST_HEAD(&fctx->pending);
		spin_lock_init(&fctx->lock);
		fctx->context = priv->context_base + chan->chid;

		if (!priv->uevent)
		return;

		ret = nvif_notify_init(chan->object, NULL,
		nouveau_fence_wait_uevent_handler, false,
		G82_CHANNEL_DMA_V0_NTFY_UEVENT,
		&(struct nvif_notify_uevent_req) { },
		sizeof(struct nvif_notify_uevent_req),
		sizeof(struct nvif_notify_uevent_rep),
		&fctx->notify);

		WARN_ON(ret);
		}

		struct nouveau_fence_work {
		struct work_struct work;
		struct fence_cb cb;
		void (func)(void );
		void *data;
		};

		static void
		nouveau_fence_work_handler(struct work_struct *kwork)
		{
		struct fence_work work = container_of(kwork, typeof(work), base);
		struct nouveau_fence_work work = container_of(kwork, typeof(work), work);
		work->func(work->data);
		kfree(work);
		}

		static void nouveau_fence_work_cb(struct fence fence, struct fence_cb cb)
		{
		struct nouveau_fence_work work = container_of(cb, typeof(work), cb);

		schedule_work(&work->work);
		}

		void
		nouveau_fence_work(struct nouveau_fence *fence,
		nouveau_fence_work(struct fence *fence,
		void (func)(void ), void *data)
		{
		struct nouveau_channel *chan = fence->channel;
		struct nouveau_fence_chan *fctx;
		struct fence_work *work = NULL;
		struct nouveau_fence_work *work;

		if (nouveau_fence_done(fence)) {
		func(data);
		return;
		}
		if (fence_is_signaled(fence))
		goto err;

		fctx = chan->fence;
		work = kmalloc(sizeof(*work), GFP_KERNEL);
		if (!work) {
		WARN_ON(nouveau_fence_wait(fence, false, false));
		func(data);
		return;
		WARN_ON(nouveau_fence_wait((struct nouveau_fence *)fence,
		false, false));
		goto err;
		}

		spin_lock(&fctx->lock);
		if (!fence->channel) {
		spin_unlock(&fctx->lock);
		kfree(work);
		func(data);
		return;
		}

		INIT_WORK(&work->base, nouveau_fence_work_handler);
		INIT_WORK(&work->work, nouveau_fence_work_handler);
		work->func = func;
		work->data = data;
		list_add(&work->head, &fence->work);
		spin_unlock(&fctx->lock);
		}

		static void
		nouveau_fence_update(struct nouveau_channel *chan)
		{
		struct nouveau_fence_chan *fctx = chan->fence;
		struct nouveau_fence fence, fnext;

		spin_lock(&fctx->lock);
		list_for_each_entry_safe(fence, fnext, &fctx->pending, head) {
		if (fctx->read(chan) < fence->sequence)
		break;
		if (fence_add_callback(fence, &work->cb, nouveau_fence_work_cb) < 0)
		goto err_free;
		return;

		nouveau_fence_signal(fence);
		nouveau_fence_unref(&fence);
		}
		spin_unlock(&fctx->lock);
		err_free:
		kfree(work);
		err:
		func(data);
		}

		int
		nouveau_fence_emit(struct nouveau_fence fence, struct nouveau_channel chan)
		{
		struct nouveau_fence_chan *fctx = chan->fence;
		struct nouveau_fence_priv priv = (void)chan->drm->fence;
		int ret;

		fence->channel = chan;
		fence->timeout = jiffies + (15 * HZ);
		fence->sequence = ++fctx->sequence;

		if (priv->uevent)
		fence_init(&fence->base, &nouveau_fence_ops_uevent,
		&fctx->lock,
		priv->context_base + chan->chid, ++fctx->sequence);
		else
		fence_init(&fence->base, &nouveau_fence_ops_legacy,
		&fctx->lock,
		priv->context_base + chan->chid, ++fctx->sequence);

		trace_fence_emit(&fence->base);
		ret = fctx->emit(fence);
		if (!ret) {
		kref_get(&fence->kref);
		spin_lock(&fctx->lock);
		fence_get(&fence->base);
		spin_lock_irq(&fctx->lock);
		nouveau_fence_update(chan, fctx);
		list_add_tail(&fence->head, &fctx->pending);
		spin_unlock(&fctx->lock);
		spin_unlock_irq(&fctx->lock);
		}

		return ret;
		@@ -161,114 +249,70 @@ nouveau_fence_emit(struct nouveau_fence fence, struct nouveau_channel chan)
		bool
		nouveau_fence_done(struct nouveau_fence *fence)
		{
		if (fence->channel)
		nouveau_fence_update(fence->channel);
		return !fence->channel;
		}
		if (fence->base.ops == &nouveau_fence_ops_legacy \|\|
		fence->base.ops == &nouveau_fence_ops_uevent) {
		struct nouveau_fence_chan *fctx = nouveau_fctx(fence);
		unsigned long flags;

		struct nouveau_fence_wait {
		struct nouveau_fence_priv *priv;
		struct nvif_notify notify;
		};
		if (test_bit(FENCE_FLAG_SIGNALED_BIT, &fence->base.flags))
		return true;

		static int
		nouveau_fence_wait_uevent_handler(struct nvif_notify *notify)
		{
		struct nouveau_fence_wait *wait =
		container_of(notify, typeof(*wait), notify);
		wake_up_all(&wait->priv->waiting);
		return NVIF_NOTIFY_KEEP;
		spin_lock_irqsave(&fctx->lock, flags);
		nouveau_fence_update(fence->channel, fctx);
		spin_unlock_irqrestore(&fctx->lock, flags);
		}
		return fence_is_signaled(&fence->base);
		}

		static int
		nouveau_fence_wait_uevent(struct nouveau_fence *fence, bool intr)

		static long
		nouveau_fence_wait_legacy(struct fence *f, bool intr, long wait)
		{
		struct nouveau_channel *chan = fence->channel;
		struct nouveau_fence_priv *priv = chan->drm->fence;
		struct nouveau_fence_wait wait = { .priv = priv };
		int ret = 0;

		ret = nvif_notify_init(chan->object, NULL,
		nouveau_fence_wait_uevent_handler, false,
		G82_CHANNEL_DMA_V0_NTFY_UEVENT,
		&(struct nvif_notify_uevent_req) {
		},
		sizeof(struct nvif_notify_uevent_req),
		sizeof(struct nvif_notify_uevent_rep),
		&wait.notify);
		if (ret)
		return ret;
		struct nouveau_fence *fence = from_fence(f);
		unsigned long sleep_time = NSEC_PER_MSEC / 1000;
		unsigned long t = jiffies, timeout = t + wait;

		nvif_notify_get(&wait.notify);
		while (!nouveau_fence_done(fence)) {
		ktime_t kt;

		if (fence->timeout) {
		unsigned long timeout = fence->timeout - jiffies;
		t = jiffies;

		if (time_before(jiffies, fence->timeout)) {
		if (intr) {
		ret = wait_event_interruptible_timeout(
		priv->waiting,
		nouveau_fence_done(fence),
		timeout);
		} else {
		ret = wait_event_timeout(priv->waiting,
		nouveau_fence_done(fence),
		timeout);
		}
		if (wait != MAX_SCHEDULE_TIMEOUT && time_after_eq(t, timeout)) {
		__set_current_state(TASK_RUNNING);
		return 0;
		}

		if (ret >= 0) {
		fence->timeout = jiffies + ret;
		if (time_after_eq(jiffies, fence->timeout))
		ret = -EBUSY;
		}
		} else {
		if (intr) {
		ret = wait_event_interruptible(priv->waiting,
		nouveau_fence_done(fence));
		} else {
		wait_event(priv->waiting, nouveau_fence_done(fence));
		}
		__set_current_state(intr ? TASK_INTERRUPTIBLE :
		TASK_UNINTERRUPTIBLE);

		kt = ktime_set(0, sleep_time);
		schedule_hrtimeout(&kt, HRTIMER_MODE_REL);
		sleep_time *= 2;
		if (sleep_time > NSEC_PER_MSEC)
		sleep_time = NSEC_PER_MSEC;

		if (intr && signal_pending(current))
		return -ERESTARTSYS;
		}

		nvif_notify_fini(&wait.notify);
		if (unlikely(ret < 0))
		return ret;
		__set_current_state(TASK_RUNNING);

		return 0;
		return timeout - t;
		}

		int
		nouveau_fence_wait(struct nouveau_fence *fence, bool lazy, bool intr)
		static int
		nouveau_fence_wait_busy(struct nouveau_fence *fence, bool intr)
		{
		struct nouveau_channel *chan = fence->channel;
		struct nouveau_fence_priv *priv = chan ? chan->drm->fence : NULL;
		unsigned long sleep_time = NSEC_PER_MSEC / 1000;
		ktime_t t;
		int ret = 0;

		while (priv && priv->uevent && lazy && !nouveau_fence_done(fence)) {
		ret = nouveau_fence_wait_uevent(fence, intr);
		if (ret < 0)
		return ret;
		}

		while (!nouveau_fence_done(fence)) {
		if (fence->timeout && time_after_eq(jiffies, fence->timeout)) {
		if (time_after_eq(jiffies, fence->timeout)) {
		ret = -EBUSY;
		break;
		}

		__set_current_state(intr ? TASK_INTERRUPTIBLE :
		__set_current_state(intr ?
		TASK_INTERRUPTIBLE :
		TASK_UNINTERRUPTIBLE);
		if (lazy) {
		t = ktime_set(0, sleep_time);
		schedule_hrtimeout(&t, HRTIMER_MODE_REL);
		sleep_time *= 2;
		if (sleep_time > NSEC_PER_MSEC)
		sleep_time = NSEC_PER_MSEC;
		}

		if (intr && signal_pending(current)) {
		ret = -ERESTARTSYS;
		@@ -281,47 +325,86 @@ nouveau_fence_wait(struct nouveau_fence *fence, bool lazy, bool intr)
		}

		int
		nouveau_fence_sync(struct nouveau_fence fence, struct nouveau_channel chan)
		nouveau_fence_wait(struct nouveau_fence *fence, bool lazy, bool intr)
		{
		long ret;

		if (!lazy)
		return nouveau_fence_wait_busy(fence, intr);

		ret = fence_wait_timeout(&fence->base, intr, 15 * HZ);
		if (ret < 0)
		return ret;
		else if (!ret)
		return -EBUSY;
		else
		return 0;
		}

		int
		nouveau_fence_sync(struct nouveau_bo nvbo, struct nouveau_channel chan, bool exclusive)
		{
		struct nouveau_fence_chan *fctx = chan->fence;
		struct nouveau_channel *prev;
		int ret = 0;
		struct fence *fence;
		struct reservation_object *resv = nvbo->bo.resv;
		struct reservation_object_list *fobj;
		struct nouveau_fence *f;
		int ret = 0, i;

		if (!exclusive) {
		ret = reservation_object_reserve_shared(resv);

		prev = fence ? fence->channel : NULL;
		if (prev) {
		if (unlikely(prev != chan && !nouveau_fence_done(fence))) {
		ret = fctx->sync(fence, prev, chan);
		if (unlikely(ret))
		ret = nouveau_fence_wait(fence, true, false);
		if (ret)
		return ret;
		}

		fobj = reservation_object_get_list(resv);
		fence = reservation_object_get_excl(resv);

		if (fence && (!exclusive \|\| !fobj \|\| !fobj->shared_count)) {
		struct nouveau_channel *prev = NULL;

		f = nouveau_local_fence(fence, chan->drm);
		if (f)
		prev = f->channel;

		if (!prev \|\| (prev != chan && (ret = fctx->sync(f, prev, chan))))
		ret = fence_wait(fence, true);

		return ret;
		}

		if (!exclusive \|\| !fobj)
		return ret;

		for (i = 0; i < fobj->shared_count && !ret; ++i) {
		struct nouveau_channel *prev = NULL;

		fence = rcu_dereference_protected(fobj->shared[i],
		reservation_object_held(resv));

		f = nouveau_local_fence(fence, chan->drm);
		if (f)
		prev = f->channel;

		if (!prev \|\| (ret = fctx->sync(f, prev, chan)))
		ret = fence_wait(fence, true);

		if (ret)
		break;
		}

		static void
		nouveau_fence_del(struct kref *kref)
		{
		struct nouveau_fence fence = container_of(kref, typeof(fence), kref);
		kfree(fence);
		return ret;
		}

		void
		nouveau_fence_unref(struct nouveau_fence **pfence)
		{
		if (*pfence)
		kref_put(&(*pfence)->kref, nouveau_fence_del);
		fence_put(&(*pfence)->base);
		*pfence = NULL;
		}

		struct nouveau_fence *
		nouveau_fence_ref(struct nouveau_fence *fence)
		{
		if (fence)
		kref_get(&fence->kref);
		return fence;
		}

		int
		nouveau_fence_new(struct nouveau_channel *chan, bool sysmem,
		struct nouveau_fence **pfence)
		@@ -336,9 +419,7 @@ nouveau_fence_new(struct nouveau_channel *chan, bool sysmem,
		if (!fence)
		return -ENOMEM;

		INIT_LIST_HEAD(&fence->work);
		fence->sysmem = sysmem;
		kref_init(&fence->kref);

		ret = nouveau_fence_emit(fence, chan);
		if (ret)
		@@ -347,3 +428,92 @@ nouveau_fence_new(struct nouveau_channel *chan, bool sysmem,
		*pfence = fence;
		return ret;
		}

		static const char nouveau_fence_get_get_driver_name(struct fence fence)
		{
		return "nouveau";
		}

		static const char nouveau_fence_get_timeline_name(struct fence f)
		{
		struct nouveau_fence *fence = from_fence(f);
		struct nouveau_fence_chan *fctx = nouveau_fctx(fence);

		return fence->channel ? fctx->name : "dead channel";
		}

		/*
		* In an ideal world, read would not assume the channel context is still alive.
		* This function may be called from another device, running into free memory as a
		* result. The drm node should still be there, so we can derive the index from
		* the fence context.
		*/
		static bool nouveau_fence_is_signaled(struct fence *f)
		{
		struct nouveau_fence *fence = from_fence(f);
		struct nouveau_fence_chan *fctx = nouveau_fctx(fence);
		struct nouveau_channel *chan = fence->channel;

		return (int)(fctx->read(chan) - fence->base.seqno) >= 0;
		}

		static bool nouveau_fence_no_signaling(struct fence *f)
		{
		struct nouveau_fence *fence = from_fence(f);

		/*
		* caller should have a reference on the fence,
		* else fence could get freed here
		*/
		WARN_ON(atomic_read(&fence->base.refcount.refcount) <= 1);

		/*
		* This needs uevents to work correctly, but fence_add_callback relies on
		* being able to enable signaling. It will still get signaled eventually,
		* just not right away.
		*/
		if (nouveau_fence_is_signaled(f)) {
		list_del(&fence->head);

		fence_put(&fence->base);
		return false;
		}

		return true;
		}

		static const struct fence_ops nouveau_fence_ops_legacy = {
		.get_driver_name = nouveau_fence_get_get_driver_name,
		.get_timeline_name = nouveau_fence_get_timeline_name,
		.enable_signaling = nouveau_fence_no_signaling,
		.signaled = nouveau_fence_is_signaled,
		.wait = nouveau_fence_wait_legacy,
		.release = NULL
		};

		static bool nouveau_fence_enable_signaling(struct fence *f)
		{
		struct nouveau_fence *fence = from_fence(f);
		struct nouveau_fence_chan *fctx = nouveau_fctx(fence);
		bool ret;

		if (!fctx->notify_ref++)
		nvif_notify_get(&fctx->notify);

		ret = nouveau_fence_no_signaling(f);
		if (ret)
		set_bit(FENCE_FLAG_USER_BITS, &fence->base.flags);
		else if (!--fctx->notify_ref)
		nvif_notify_put(&fctx->notify);

		return ret;
		}

		static const struct fence_ops nouveau_fence_ops_uevent = {
		.get_driver_name = nouveau_fence_get_get_driver_name,
		.get_timeline_name = nouveau_fence_get_timeline_name,
		.enable_signaling = nouveau_fence_enable_signaling,
		.signaled = nouveau_fence_is_signaled,
		.wait = fence_default_wait,
		.release = NULL
		};

drivers/gpu/drm/nouveau/nouveau_fence.h

+16 −10

Original line number	Diff line number	Diff line
		#ifndef __NOUVEAU_FENCE_H__
		#define __NOUVEAU_FENCE_H__

		#include <linux/fence.h>
		#include <nvif/notify.h>

		struct nouveau_drm;
		struct nouveau_bo;

		struct nouveau_fence {
		struct fence base;

		struct list_head head;
		struct list_head work;
		struct kref kref;

		bool sysmem;

		struct nouveau_channel *channel;
		unsigned long timeout;
		u32 sequence;
		};

		int nouveau_fence_new(struct nouveau_channel *, bool sysmem,
		struct nouveau_fence **);
		struct nouveau_fence *
		nouveau_fence_ref(struct nouveau_fence *);
		void nouveau_fence_unref(struct nouveau_fence **);

		int nouveau_fence_emit(struct nouveau_fence , struct nouveau_channel );
		bool nouveau_fence_done(struct nouveau_fence *);
		void nouveau_fence_work(struct nouveau_fence , void ()(void ), void );
		void nouveau_fence_work(struct fence , void ()(void ), void );
		int nouveau_fence_wait(struct nouveau_fence *, bool lazy, bool intr);
		int nouveau_fence_sync(struct nouveau_fence , struct nouveau_channel );
		int nouveau_fence_sync(struct nouveau_bo , struct nouveau_channel , bool exclusive);

		struct nouveau_fence_chan {
		spinlock_t lock;
		struct list_head pending;
		struct list_head flip;

		@@ -38,8 +40,12 @@ struct nouveau_fence_chan {
		int (emit32)(struct nouveau_channel , u64, u32);
		int (sync32)(struct nouveau_channel , u64, u32);

		spinlock_t lock;
		u32 sequence;
		u32 context;
		char name[24];

		struct nvif_notify notify;
		int notify_ref;
		};

		struct nouveau_fence_priv {
		@@ -49,13 +55,13 @@ struct nouveau_fence_priv {
		int (context_new)(struct nouveau_channel );
		void (context_del)(struct nouveau_channel );

		wait_queue_head_t waiting;
		u32 contexts, context_base;
		bool uevent;
		};

		#define nouveau_fence(drm) ((struct nouveau_fence_priv *)(drm)->fence)

		void nouveau_fence_context_new(struct nouveau_fence_chan *);
		void nouveau_fence_context_new(struct nouveau_channel , struct nouveau_fence_chan );
		void nouveau_fence_context_del(struct nouveau_fence_chan *);

		int nv04_fence_create(struct nouveau_drm *);

Admin message