 @@ -792,28 +792,34 @@ static int i915_wait_irq(struct drm_devi
 	DRM_DEBUG_DRIVER("irq_nr=%d breadcrumb=%d\n", irq_nr,
 		  READ_BREADCRUMB(dev_priv));
 	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__
 		DRM_TIMED_WAIT_UNTIL(ret, &ring->irq_queue, &drm_global_mutex,
 * DRM_HZ,
 		    READ_BREADCRUMB(dev_priv) >= irq_nr);
 #else
 		DRM_WAIT_ON(ret, ring->irq_queue, 3 * DRM_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);
+	}
 	return ret;
+}
 /* Needs the lock as it touches the ring.

 @@ -1018,34 +1018,44 @@ static int __wait_seqno(struct intel_rin
 	timeout_jiffies = timespec_to_jiffies(&wait_time);
 	if (WARN_ON(!ring->irq_get(ring)))
 		return -ENODEV;
 	/* Record current time in case interrupted by signal, or wedged * */
 	getrawmonotonic(&before);
 #define EXIT_COND \
 	(i915_seqno_passed(ring->get_seqno(ring, false), seqno) || \
 	atomic_read(&dev_priv->mm.wedged))
 	do {
 #ifdef __NetBSD__
 		/*
 		 * XXX This wait is always interruptible; we should
 		 * heed the flag `interruptible'.
 		 */
 		DRM_TIMED_WAIT_UNTIL(end, &ring->irq_queue, &drm_global_mutex,
 		    timeout_jiffies,
 		    EXIT_COND);
 #else
 		if (interruptible)
 			end = wait_event_interruptible_timeout(ring->irq_queue,
 							       EXIT_COND,
 							       timeout_jiffies);
 		else
 			end = wait_event_timeout(ring->irq_queue, EXIT_COND,
 						 timeout_jiffies);
 #endif
 		ret = i915_gem_check_wedge(dev_priv, interruptible);
 		if (ret)
 			end = ret;
 	} while (end == 0 && wait_forever);
 	getrawmonotonic(&now);
 	ring->irq_put(ring);
 	trace_i915_gem_request_wait_end(ring, seqno);
 #undef EXIT_COND
 	if (timeout) {
 		struct timespec sleep_time = timespec_sub(now, before);

 @@ -343,27 +343,31 @@ static void ironlake_handle_rps_change(s
 	return;
+}
 static void notify_ring(struct drm_device *dev,
 			struct intel_ring_buffer *ring)
+{
 	struct drm_i915_private *dev_priv = dev->dev_private;
 	if (ring->obj == NULL)
 		return;
 	trace_i915_gem_request_complete(ring, ring->get_seqno(ring, false));
 #ifdef __NetBSD__
 	DRM_WAKEUP_ALL(&ring->irq_queue, &drm_global_mutex);
 #else
 	wake_up_all(&ring->irq_queue);
 #endif
 	if (i915_enable_hangcheck) {
 		dev_priv->hangcheck_count = 0;
 		mod_timer(&dev_priv->hangcheck_timer,
 			  round_jiffies_up(jiffies + DRM_I915_HANGCHECK_JIFFIES));
+	}
+}
 static void gen6_pm_rps_work(struct work_struct *work)
+{
 	drm_i915_private_t *dev_priv = container_of(work, drm_i915_private_t,
 						    rps.work);
 	u32 pm_iir, pm_imr;
 	u8 new_delay;
 @@ -1141,27 +1145,32 @@ static void i915_record_ring_state(struc
 		error->ipeir[ring->id] = I915_READ(RING_IPEIR(ring->mmio_base));
 		error->ipehr[ring->id] = I915_READ(RING_IPEHR(ring->mmio_base));
 		error->instdone[ring->id] = I915_READ(RING_INSTDONE(ring->mmio_base));
 		error->instps[ring->id] = I915_READ(RING_INSTPS(ring->mmio_base));
 		if (ring->id == RCS)
 			error->bbaddr = I915_READ64(BB_ADDR);
 	} else {
 		error->faddr[ring->id] = I915_READ(DMA_FADD_I8XX);
 		error->ipeir[ring->id] = I915_READ(IPEIR);
 		error->ipehr[ring->id] = I915_READ(IPEHR);
 		error->instdone[ring->id] = I915_READ(INSTDONE);
+	}
 #ifdef __NetBSD__
 	error->waiting[ring->id] = DRM_WAITERS_P(&ring->irq_queue,
 	    &drm_global_mutex);
 #else
 	error->waiting[ring->id] = waitqueue_active(&ring->irq_queue);
 #endif
 	error->instpm[ring->id] = I915_READ(RING_INSTPM(ring->mmio_base));
 	error->seqno[ring->id] = ring->get_seqno(ring, false);
 	error->acthd[ring->id] = intel_ring_get_active_head(ring);
 	error->head[ring->id] = I915_READ_HEAD(ring);
 	error->tail[ring->id] = I915_READ_TAIL(ring);
 	error->ctl[ring->id] = I915_READ_CTL(ring);
 	error->cpu_ring_head[ring->id] = ring->head;
 	error->cpu_ring_tail[ring->id] = ring->tail;
+}
 static void i915_gem_record_rings(struct drm_device *dev,
 				  struct drm_i915_error_state *error)
 @@ -1456,27 +1465,31 @@ void i915_handle_error(struct drm_device
 	int i;
 	i915_capture_error_state(dev);
 	i915_report_and_clear_eir(dev);
 	if (wedged) {
 		INIT_COMPLETION(dev_priv->error_completion);
 		atomic_set(&dev_priv->mm.wedged, 1);
 		/*
 		 * Wakeup waiting processes so they don't hang
 		 */
 		for_each_ring(ring, dev_priv, i)
 #ifdef __NetBSD__
 			DRM_WAKEUP_ALL(&ring->irq_queue, &drm_global_mutex);
 #else
 			wake_up_all(&ring->irq_queue);
 #endif
+	}
 	queue_work(dev_priv->wq, &dev_priv->error_work);
+}
 static void i915_pageflip_stall_check(struct drm_device *dev, int pipe)
+{
 	drm_i915_private_t *dev_priv = dev->dev_private;
 	struct drm_crtc *crtc = dev_priv->pipe_to_crtc_mapping[pipe];
 	struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
 	struct drm_i915_gem_object *obj;
 	struct intel_unpin_work *work;
 	unsigned long flags;
 @@ -1661,32 +1674,41 @@ static void valleyview_disable_vblank(st
 static u32
 ring_last_seqno(struct intel_ring_buffer *ring)
+{
 	return list_entry(ring->request_list.prev,
 			  struct drm_i915_gem_request, list)->seqno;
+}
 static bool i915_hangcheck_ring_idle(struct intel_ring_buffer *ring, bool *err)
+{
 	if (list_empty(&ring->request_list) ||
 	    i915_seqno_passed(ring->get_seqno(ring, false),
 			      ring_last_seqno(ring))) {
 		/* Issue a wake-up to catch stuck h/w. */
 #ifdef __NetBSD__
 		if (DRM_WAITERS_P(&ring->irq_queue, &drm_global_mutex)) {
 			DRM_ERROR("Hangcheck timer elapsed... %s idle\n",
 				  ring->name);
 			DRM_WAKEUP_ALL(&ring->irq_queue, &drm_global_mutex);
 			*err = true;
+		}
 #else
 		if (waitqueue_active(&ring->irq_queue)) {
 			DRM_ERROR("Hangcheck timer elapsed... %s idle\n",
 				  ring->name);
 			wake_up_all(&ring->irq_queue);
 			*err = true;
+		}
 #endif
 		return true;
+	}
 	return false;
+}
 static bool kick_ring(struct intel_ring_buffer *ring)
+{
 	struct drm_device *dev = ring->dev;
 	struct drm_i915_private *dev_priv = dev->dev_private;
 	u32 tmp = I915_READ_CTL(ring);
 	if (tmp & RING_WAIT) {
 		DRM_ERROR("Kicking stuck wait on %s\n",
 			  ring->name);

 @@ -1141,27 +1141,31 @@ static int init_phys_hws_pga(struct inte
 static int intel_init_ring_buffer(struct drm_device *dev,
 				  struct intel_ring_buffer *ring)
+{
 	struct drm_i915_gem_object *obj;
 	struct drm_i915_private *dev_priv = dev->dev_private;
 	int ret;
 	ring->dev = dev;
 	INIT_LIST_HEAD(&ring->active_list);
 	INIT_LIST_HEAD(&ring->request_list);
 	ring->size = 32 * PAGE_SIZE;
 	memset(ring->sync_seqno, 0, sizeof(ring->sync_seqno));
 #ifdef __NetBSD__
 	DRM_INIT_WAITQUEUE(&ring->irq_queue, "i915irq");
 #else
 	init_waitqueue_head(&ring->irq_queue);
 #endif
 	if (I915_NEED_GFX_HWS(dev)) {
 		ret = init_status_page(ring);
 		if (ret)
 			return ret;
 	} else {
 		BUG_ON(ring->id != RCS);
 		ret = init_phys_hws_pga(ring);
 		if (ret)
 			return ret;
+	}
 	obj = i915_gem_alloc_object(dev, ring->size);

 @@ -123,27 +123,31 @@ struct  intel_ring_buffer {
 	/**
 	 * List of breadcrumbs associated with GPU requests currently
 	 * outstanding.
 	 */
 	struct list_head request_list;
 	/**
 	 * Do we have some not yet emitted requests outstanding?
 	 */
 	u32 outstanding_lazy_request;
 	bool gpu_caches_dirty;
 #ifdef __NetBSD__
 	drm_waitqueue_t irq_queue;
 #else
 	wait_queue_head_t irq_queue;
 #endif
 	/**
 	 * Do an explicit TLB flush before MI_SET_CONTEXT
 	 */
 	bool itlb_before_ctx_switch;
 	struct i915_hw_context *default_context;
 	struct drm_i915_gem_object *last_context_obj;
 	void *private;
 };
 static inline bool
 intel_ring_initialized(struct intel_ring_buffer *ring)