Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 6ba59f3b authored by Dave Airlie's avatar Dave Airlie
Browse files

Merge branch 'for-airlied-next' of git://people.freedesktop.org/~mlankhorst/linux into drm-next 

Merge the move to generic fences for TTM using drivers.

* 'for-airlied-next' of git://people.freedesktop.org/~mlankhorst/linux:
  drm/nouveau: use shared fences for readable objects
  drm/nouveau: Keep only a single list for validation.
  drm/ttm: use rcu in core ttm
  drm/vmwgfx: use rcu in vmw_user_dmabuf_synccpu_grab
  drm/radeon: use rcu waits in some ioctls
  drm/nouveau: use rcu in nouveau_gem_ioctl_cpu_prep
  drm/ttm: flip the switch, and convert to dma_fence
  drm/qxl: rework to new fence interface
  drm/nouveau: rework to new fence interface
  drm/vmwgfx: rework to new fence interface, v2
  drm/vmwgfx: get rid of different types of fence_flags entirely
  drm/radeon: use common fence implementation for fences, v4
  drm/ttm: kill off some members to ttm_validate_buffer
  drm/ttm: add interruptible parameter to ttm_eu_reserve_buffers
  drm/ttm: kill fence_lock
  drm/ttm: call ttm_bo_wait while inside a reservation
  drm/nouveau: require reservations for nouveau_fence_sync and nouveau_bo_fence
  drm/nouveau: add reservation to nouveau_gem_ioctl_cpu_prep
parents a18b29f0 809e9447

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 *);