 @@ -1283,40 +1283,34 @@ int drm_wait_vblank(struct drm_device *d
+	}
 	if ((flags & _DRM_VBLANK_NEXTONMISS) &&
 	    (seq - vblwait->request.sequence) <= (1<<23)) {
 		vblwait->request.sequence = seq + 1;
+	}
 	DRM_DEBUG("waiting on vblank count %d, crtc %d\n",
 		  vblwait->request.sequence, crtc);
 	dev->vblank[crtc].last_wait = vblwait->request.sequence;
 #ifdef __NetBSD__
+    {
 	unsigned long irqflags;
 	spin_lock_irqsave(&dev->vbl_lock, irqflags);
-	DRM_SPIN_TIMED_WAIT_UNTIL(ret, &dev->vblank[crtc].queue,
+	DRM_SPIN_WAIT_ON(ret, &dev->vblank[crtc].queue, &dev->vbl_lock,
-	    &dev->vbl_lock,
+* HZ,
 	    (3 * HZ),
 	    (((drm_vblank_count(dev, crtc) -
 		    vblwait->request.sequence) <= (1 << 23)) ||
 		!dev->irq_enabled));
 	spin_unlock_irqrestore(&dev->vbl_lock, irqflags);
 	if (ret < 0)		/* Failed: return negative error as is.  */
 	else if (ret == 0)	/* Timed out: return -EBUSY like Linux.  */
 		ret = -EBUSY;
 	else			/* Succeeded (ret > 0): return 0.  */
 		ret = 0;
+    }
 #else
 	DRM_WAIT_ON(ret, dev->vblank[crtc].queue, 3 * HZ,
 		    (((drm_vblank_count(dev, crtc) -
 		       vblwait->request.sequence) <= (1 << 23)) ||
 		     !dev->irq_enabled));
 #endif
 	if (ret != -EINTR) {
 		struct timeval now;
 		vblwait->reply.sequence = drm_vblank_count_and_time(dev, crtc, &now);
 		vblwait->reply.tval_sec = now.tv_sec;

 @@ -802,36 +802,29 @@ static int i915_wait_irq(struct drm_devi
 	if (READ_BREADCRUMB(dev_priv) >= irq_nr) {
 		if (master_priv->sarea_priv)
 			master_priv->sarea_priv->last_dispatch = READ_BREADCRUMB(dev_priv);
 		return 0;
+	}
 	if (master_priv->sarea_priv)
 		master_priv->sarea_priv->perf_boxes |= I915_BOX_WAIT;
 	if (ring->irq_get(ring)) {
 #ifdef __NetBSD__
 		unsigned long flags;
 		spin_lock_irqsave(&dev_priv->irq_lock, flags);
-		DRM_SPIN_TIMED_WAIT_UNTIL(ret, &ring->irq_queue,
+		DRM_SPIN_WAIT_ON(ret, &ring->irq_queue, &dev_priv->irq_lock,
 		    &dev_priv->irq_lock,
 * DRM_HZ,
 		    READ_BREADCRUMB(dev_priv) >= irq_nr);
 		if (ret < 0)	/* Failure: return negative error as is.  */
 		else if (ret == 0) /* Timed out: return -EBUSY like Linux.  */
 			ret = -EBUSY;
 		else		/* Succeeded (ret > 0): return 0.  */
 			ret = 0;
 		spin_unlock_irqrestore(&dev_priv->irq_lock, flags);
 #else
 		DRM_WAIT_ON(ret, ring->irq_queue, 3 * HZ,
 			    READ_BREADCRUMB(dev_priv) >= irq_nr);
 #endif
 		ring->irq_put(ring);
 	} else if (wait_for(READ_BREADCRUMB(dev_priv) >= irq_nr, 3000))
 		ret = -EBUSY;
 	if (ret == -EBUSY) {
 		DRM_ERROR("EBUSY -- rec: %d emitted: %d\n",
 			  READ_BREADCRUMB(dev_priv), (int)dev_priv->dri1.counter);
+	}

 @@ -587,35 +587,28 @@ via_dmablit_sync(struct drm_device *dev,
 	drm_via_private_t *dev_priv = (drm_via_private_t *)dev->dev_private;
 	drm_via_blitq_t *blitq = dev_priv->blit_queues + engine;
 #ifdef __NetBSD__
 	drm_waitqueue_t *queue;
 #else
 	wait_queue_head_t *queue;
 #endif
 	int ret = 0;
 #ifdef __NetBSD__
 	spin_lock(&blitq->blit_lock);
 	if (via_dmablit_active(blitq, engine, handle, &queue)) {
-		DRM_SPIN_TIMED_WAIT_UNTIL(ret, queue, &blitq->blit_lock,
+		DRM_SPIN_WAIT_ON(ret, queue, &blitq->blit_lock, 3*DRM_HZ,
 *DRM_HZ,
 		    !via_dmablit_active(blitq, engine, handle, NULL));
 		if (ret < 0)	/* Failure: return negative error as is.  */
 		else if (ret == 0) /* Timed out: return -EBUSY like Linux.  */
 			ret = -EBUSY;
 		else		/* Succeeded (ret > 0): return 0.  */
 			ret = 0;
+	}
 	spin_unlock(&blitq->blit_lock);
 #else
 	if (via_dmablit_active(blitq, engine, handle, &queue)) {
 		DRM_WAIT_ON(ret, *queue, 3 * HZ,
 			    !via_dmablit_active(blitq, engine, handle, NULL));
+	}
 #endif
 	DRM_DEBUG("DMA blit sync handle 0x%x engine %d returned %d\n",
 		  handle, engine, ret);
 	return ret;
+}
 @@ -871,35 +864,29 @@ via_build_sg_info(struct drm_device *dev
  * to become available. Otherwise -EBUSY is returned.
  */
 static int
 via_dmablit_grab_slot(drm_via_blitq_t *blitq, int engine)
+{
 	int ret = 0;
 	unsigned long irqsave;
 	DRM_DEBUG("Num free is %d\n", blitq->num_free);
 	spin_lock_irqsave(&blitq->blit_lock, irqsave);
 	while (blitq->num_free == 0) {
 #ifdef __NetBSD__
-		DRM_SPIN_TIMED_WAIT_UNTIL(ret, &blitq->busy_queue,
+		DRM_SPIN_WAIT_ON(ret, &blitq->busy_queue, &blitq->blit_lock,
-		    &blitq->blit_lock, DRM_HZ,
+		    DRM_HZ,
 		    blitq->num_free > 0);
 		if (ret < 0)	/* Failure: return negative error as is.  */
 		else if (ret == 0) /* Timed out: return -EBUSY like Linux.  */
 			ret = -EBUSY;
 		else		/* Success (ret > 0): return 0.  */
 			ret = 0;
 		/* Map -EINTR to -EAGAIN.  */
 		if (ret == -EINTR)
 			ret = -EAGAIN;
 		/* Bail on failure.  */
 		if (ret) {
 			spin_unlock_irqrestore(&blitq->blit_lock, irqsave);
 			return ret;
+		}
 #else
 		spin_unlock_irqrestore(&blitq->blit_lock, irqsave);
 		DRM_WAIT_ON(ret, blitq->busy_queue, HZ, blitq->num_free > 0);
 		if (ret)

 @@ -239,43 +239,37 @@ via_driver_irq_wait(struct drm_device *d
 	if (real_irq < 0) {
 		DRM_ERROR("Video IRQ %d not available on this hardware.\n",
 			  irq);
 		return -EINVAL;
+	}
 	masks = dev_priv->irq_masks;
 	cur_irq = dev_priv->via_irqs + real_irq;
 #ifdef __NetBSD__
 	spin_lock(&cur_irq->irq_lock);
 	if (masks[real_irq][2] && !force_sequence) {
-		DRM_SPIN_TIMED_WAIT_UNTIL(ret, &cur_irq->irq_queue,
+		DRM_SPIN_WAIT_ON(ret, &cur_irq->irq_queue, &cur_irq->irq_lock,
-		    &cur_irq->irq_lock, 3 * DRM_HZ,
+* DRM_HZ,
 		    ((VIA_READ(masks[irq][2]) & masks[irq][3]) ==
 			masks[irq][4]));
 		cur_irq_sequence = cur_irq->irq_received;
 	} else {
-		DRM_SPIN_TIMED_WAIT_UNTIL(ret, &cur_irq->irq_queue,
+		DRM_SPIN_WAIT_ON(ret, &cur_irq->irq_queue, &cur_irq->irq_lock,
-		    &cur_irq->irq_lock, 3 * DRM_HZ,
+* DRM_HZ,
 		    (((cur_irq_sequence = cur_irq->irq_received) -
 			*sequence) <= (1 << 23)));
+	}
 	if (ret < 0)		/* Failure: return negative error as is.  */
 	else if (ret == 0)	/* Timed out: return -EBUSY like Linux.  */
 		ret = -EBUSY;
 	else			/* Success (ret > 0): return 0.  */
 		ret = 0;
 	spin_unlock(&cur_irq->irq_lock);
 #else
 	if (masks[real_irq][2] && !force_sequence) {
 		DRM_WAIT_ON(ret, cur_irq->irq_queue, 3 * HZ,
 			    ((VIA_READ(masks[irq][2]) & masks[irq][3]) ==
 			     masks[irq][4]));
 		cur_irq_sequence = atomic_read(&cur_irq->irq_received);
 	} else {
 		DRM_WAIT_ON(ret, cur_irq->irq_queue, 3 * HZ,
 			    (((cur_irq_sequence =
 			       atomic_read(&cur_irq->irq_received)) -
 			      *sequence) <= (1 << 23)));
+	}

 @@ -27,65 +27,65 @@
 #include <drm/drmP.h>
 #include <drm/via_drm.h>
 #include "via_drv.h"
 void via_init_futex(drm_via_private_t *dev_priv)
+{
 	unsigned int i;
 	DRM_DEBUG("\n");
 	for (i = 0; i < VIA_NR_XVMC_LOCKS; ++i) {
 #ifdef __NetBSD__
-		linux_mutex_init(&dev_priv->decoder_lock[i]);
+		spin_lock_init(&dev_priv->decoder_lock[i]);
 		DRM_INIT_WAITQUEUE(&dev_priv->decoder_queue[i], "viadec");
 #else
 		init_waitqueue_head(&(dev_priv->decoder_queue[i]));
 #endif
 		XVMCLOCKPTR(dev_priv->sarea_priv, i)->lock = 0;
+	}
+}
 void via_cleanup_futex(drm_via_private_t *dev_priv)
+{
 #ifdef __NetBSD__
 	unsigned i;
 	for (i = 0; i < VIA_NR_XVMC_LOCKS; ++i) {
 		DRM_DESTROY_WAITQUEUE(&dev_priv->decoder_queue[i]);
-		linux_mutex_destroy(&dev_priv->decoder_lock[i]);
+		spin_lock_destroy(&dev_priv->decoder_lock[i]);
+	}
 #endif
+}
 void via_release_futex(drm_via_private_t *dev_priv, int context)
+{
 	unsigned int i;
 	volatile int *lock;
 	if (!dev_priv->sarea_priv)
 		return;
 	for (i = 0; i < VIA_NR_XVMC_LOCKS; ++i) {
 		lock = (volatile int *)XVMCLOCKPTR(dev_priv->sarea_priv, i);
 		if ((_DRM_LOCKING_CONTEXT(*lock) == context)) {
 			if (_DRM_LOCK_IS_HELD(*lock)
 			    && (*lock & _DRM_LOCK_CONT)) {
 #ifdef __NetBSD__
-				mutex_lock(&dev_priv->decoder_lock[i]);
+				spin_lock(&dev_priv->decoder_lock[i]);
-				DRM_WAKEUP_ALL(&dev_priv->decoder_queue[i],
+				DRM_SPIN_WAKEUP_ALL(&dev_priv->decoder_queue[i],
 				    &dev_priv->decoder_lock[i]);
-				mutex_unlock(&dev_priv->decoder_lock[i]);
+				spin_unlock(&dev_priv->decoder_lock[i]);
 #else
 				wake_up(&(dev_priv->decoder_queue[i]));
 #endif
+			}
 			*lock = 0;
+		}
+	}
+}
 int via_decoder_futex(struct drm_device *dev, void *data, struct drm_file *file_priv)
+{
 	drm_via_futex_t *fx = data;
 	volatile int *lock;
 @@ -93,38 +93,32 @@ int via_decoder_futex(struct drm_device
 	drm_via_sarea_t *sAPriv = dev_priv->sarea_priv;
 	int ret = 0;
 	DRM_DEBUG("\n");
 	if (fx->lock >= VIA_NR_XVMC_LOCKS)
 		return -EFAULT;
 	lock = (volatile int *)XVMCLOCKPTR(sAPriv, fx->lock);
 	switch (fx->func) {
 	case VIA_FUTEX_WAIT:
 #ifdef __NetBSD__
-		mutex_lock(&dev_priv->decoder_lock[fx->lock]);
+		spin_lock(&dev_priv->decoder_lock[fx->lock]);
-		DRM_TIMED_WAIT_UNTIL(ret, &dev_priv->decoder_queue[fx->lock],
+		DRM_SPIN_WAIT_ON(ret, &dev_priv->decoder_queue[fx->lock],
 		    &dev_priv->decoder_lock[fx->lock],
 		    (fx->ms / 10) * (DRM_HZ / 100),
 		    *lock != fx->val);
-		if (ret < 0)	/* Failure: return negative error as is.  */
+		spin_unlock(&dev_priv->decoder_lock[fx->lock]);
 		else if (ret == 0) /* Timed out: return -EBUSY like Linux.  */
 			ret = -EBUSY;
 		else		/* Success (ret > 0): return 0.  */
 			ret = 0;
 		mutex_unlock(&dev_priv->decoder_lock[fx->lock]);
 #else
 		DRM_WAIT_ON(ret, dev_priv->decoder_queue[fx->lock],
 			    (fx->ms / 10) * (HZ / 100), *lock != fx->val);
 #endif
 		return ret;
 	case VIA_FUTEX_WAKE:
 #ifdef __NetBSD__
 		mutex_lock(&dev_priv->decoder_lock[fx->lock]);
 		DRM_WAKEUP_ALL(&dev_priv->decoder_queue[fx->lock],
 		    &dev_priv->decoder_lock[fx->lock]);
 		mutex_unlock(&dev_priv->decoder_lock[fx->lock]);
 #else
 		wake_up(&(dev_priv->decoder_queue[fx->lock]));

 @@ -1,14 +1,14 @@
-/*	$NetBSD: drm_wait_netbsd.h,v 1.8 2015/02/28 04:57:12 riastradh Exp $	*/
+/*	$NetBSD: drm_wait_netbsd.h,v 1.9 2015/02/28 18:25:39 riastradh Exp $	*/
 /*-
  * Copyright (c) 2013 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Taylor R. Campbell.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
 @@ -95,51 +95,100 @@ DRM_SPIN_WAKEUP_ONE(drm_waitqueue_t *q,
+{
 	KASSERT(spin_is_locked(interlock));
 	cv_signal(q);
+}
 static inline void
 DRM_SPIN_WAKEUP_ALL(drm_waitqueue_t *q, spinlock_t *interlock)
+{
 	KASSERT(spin_is_locked(interlock));
 	cv_broadcast(q);
+}
 /*
- * WARNING: These DRM_*WAIT*_UNTIL macros are designed to replace the
+ * DRM_SPIN_WAIT_ON is a replacement for the legacy DRM_WAIT_ON
- * Linux wait_event* macros.  They have a different return value
+ * portability macro.  It requires a spin interlock, which may require
- * convention from the legacy portability DRM_WAIT_ON macro and a
+ * changes to the surrounding code so that the waits actually are
  * interlocked by a spin lock.  It also polls the condition at every
  * tick, which masks missing wakeups.  Since DRM_WAIT_ON is going away,
  * in favour of Linux's native wait_event* API, waits in new code
  * should be written to use the DRM_*WAIT*_UNTIL macros below.
+ *
  * Like the legacy DRM_WAIT_ON, DRM_SPIN_WAIT_ON returns
+ *
  * . -EBUSY if timed out (yes, -EBUSY, not -ETIMEDOUT or -EWOULDBLOCK),
  * . -EINTR/-ERESTART if interrupted by a signal, or
  * . 0 if the condition was true before or just after the timeout.
+ *
  * Note that cv_timedwait* return -EWOULDBLOCK, not -EBUSY, on timeout.
  */
 #define	DRM_SPIN_WAIT_ON(RET, Q, INTERLOCK, TICKS, CONDITION)	do	      \
 {									      \
 	extern int hardclock_ticks;					      \
 	const int _dswo_start = hardclock_ticks;			      \
 	const int _dswo_end = _dswo_start + (TICKS);			      \
+									      \
 	KASSERT(spin_is_locked((INTERLOCK)));				      \
 	KASSERT(!cpu_intr_p());						      \
 	KASSERT(!cpu_softintr_p());					      \
 	KASSERT(!cold);							      \
+									      \
 	for (;;) {							      \
 		if (CONDITION) {					      \
 			(RET) = 0;					      \
 			break;						      \
 		}							      \
 		const int _dswo_now = hardclock_ticks;			      \
 		if (_dswo_end < _dswo_now) {				      \
 			(RET) = -EBUSY;		/* Match Linux...  */	      \
 			break;						      \
 		}							      \
 		/* XXX errno NetBSD->Linux */				      \
 		(RET) = -cv_timedwait_sig((Q), &(INTERLOCK)->sl_lock,	      \
 		    (_dswo_end - _dswo_now));				      \
 		if (RET) {						      \
 			if ((RET) == -EWOULDBLOCK)			      \
 				(RET) = (CONDITION) ? 0 : -EBUSY;	      \
+									      \
 			break;						      \
 		}							      \
 	}								      \
 } while (0)
 /*
  * The DRM_*WAIT*_UNTIL macros are replacements for the Linux
  * wait_event* macros.  Like DRM_SPIN_WAIT_ON, they add an interlock,
  * and so may require some changes to the surrounding code.  They have
  * a different return value convention from DRM_SPIN_WAIT_ON and a
  * different return value convention from cv_*wait*.
+ *
- * Specifically, the untimed macros
+ * The untimed DRM_*WAIT*_UNTIL macros return
+ *
- * - return negative error code on failure (interruption), and
+ * . -EINTR/-ERESTART if interrupted by a signal, or
- * - return zero on sucess.
+ * . zero if the condition evaluated
+ *
- * The timed macros
+ * The timed DRM_*TIMED_WAIT*_UNTIL macros return
+ *
- * - return negative error code on failure (interruption),
+ * . -EINTR/-ERESTART if interrupted by a signal,
- * - return zero on timeout, and
+ * . 0 if the condition was false after the timeout,
- * - return one on success.
+ * . 1 if the condition was true just after the timeout, or
  * . the number of ticks remaining if the condition was true before the
  * timeout.
+ *
- * Contrast DRM_WAIT_ON which returns -EINTR/-ERESTART on interruption,
+ * Contrast DRM_SPIN_WAIT_ON which returns -EINTR/-ERESTART on signal,
  * -EBUSY on timeout, and zero on success; and cv_*wait*, which return
- * -EINTR/-ERESTART on interruption, -EWOULDBLOCK on timeout, and zero
+ * -EINTR/-ERESTART on signal, -EWOULDBLOCK on timeout, and zero on
- * on success.
+ * success.
  * We don't simply implement DRM_WAIT_ON because, like Linux
  * wait_event*, it lacks an interlock, whereas we require an interlock
  * for any waits in order to avoid the standard race conditions
  * associated with non-interlocked waits that plague Linux drivers.
+ *
  * XXX In retrospect, giving the timed and untimed macros a different
  * return convention from one another to match Linux may have been a
  * bad idea.  All of this inconsistent timeout return convention logic
  * has been a consistent source of bugs.
  */
 #define	_DRM_WAIT_UNTIL(RET, WAIT, Q, INTERLOCK, CONDITION) do		\
 {									\
 	KASSERT(mutex_is_locked((INTERLOCK)));				\
 	ASSERT_SLEEPABLE();						\
 	KASSERT(!cold);							\
 	for (;;) {							\
 @@ -152,39 +201,26 @@ DRM_SPIN_WAKEUP_ALL(drm_waitqueue_t *q,
 		if (RET)						\
 			break;						\
 	}								\
 } while (0)
 #define	cv_wait_nointr(Q, I)	(cv_wait((Q), (I)), 0)
 #define	DRM_WAIT_NOINTR_UNTIL(RET, Q, I, C)				\
 	_DRM_WAIT_UNTIL(RET, cv_wait_nointr, Q, I, C)
 #define	DRM_WAIT_UNTIL(RET, Q, I, C)				\
 	_DRM_WAIT_UNTIL(RET, cv_wait_sig, Q, I, C)
 /*
  * Timed wait.  Return:
  * - 0 if condition is false after timeout,
  * - 1 if condition is true after timeout or one tick before timeout,
  * - number of ticks left if condition evaluated to true before timeout, or
  * - negative error if failure (e.g., interrupted).
  * XXX Comments in Linux say it returns -ERESTARTSYS if interrupted.
  * What if by a signal without SA_RESTART?  Shouldn't it be -EINTR
  * then?  I'm going to leave it as what cv_timedwait returned, which is
  * ERESTART for signals with SA_RESTART and EINTR otherwise.
  */
 #define	_DRM_TIMED_WAIT_UNTIL(RET, WAIT, Q, INTERLOCK, TICKS, CONDITION) do \
 {									\
 	extern int hardclock_ticks;					\
 	const int _dtwu_start = hardclock_ticks;			\
 	int _dtwu_ticks = (TICKS);					\
 	KASSERT(mutex_is_locked((INTERLOCK)));				\
 	ASSERT_SLEEPABLE();						\
 	KASSERT(!cold);							\
 	for (;;) {							\
 		if (CONDITION) {					\
 			(RET) = _dtwu_ticks;				\
 			break;						\
 		}							\

 @@ -63,27 +63,27 @@ typedef struct drm_via_irq {
 	drm_waitqueue_t irq_queue;
 #else
 	wait_queue_head_t irq_queue;
 #endif
 } drm_via_irq_t;
 typedef struct drm_via_private {
 	drm_via_sarea_t *sarea_priv;
 	drm_local_map_t *sarea;
 	drm_local_map_t *fb;
 	drm_local_map_t *mmio;
 	unsigned long agpAddr;
 #ifdef __NetBSD__
-	struct mutex decoder_lock[VIA_NR_XVMC_LOCKS];
+	spinlock_t decoder_lock[VIA_NR_XVMC_LOCKS];
 	drm_waitqueue_t decoder_queue[VIA_NR_XVMC_LOCKS];
 #else
 	wait_queue_head_t decoder_queue[VIA_NR_XVMC_LOCKS];
 #endif
 	char *dma_ptr;
 	unsigned int dma_low;
 	unsigned int dma_high;
 	unsigned int dma_offset;
 	uint32_t dma_wrap;
 	volatile uint32_t *last_pause_ptr;
 	volatile uint32_t *hw_addr_ptr;
 	drm_via_ring_buffer_t ring;
 	struct timeval last_vblank;