Merge branch 'master' into modesetting-101 - TTM & typedef removal

Conflicts:

	linux-core/drmP.h
	linux-core/drm_bo.c
	linux-core/drm_drv.c
	linux-core/drm_objects.h
	shared-core/drm.h
	shared-core/i915_dma.c
	shared-core/i915_drv.h
	shared-core/i915_irq.c

Mostly removing typedefs that snuck into the modesetting code and
updating to the latest TTM APIs.  As of today, the i915 driver builds,
but there are likely to be problems, so debugging and bugfixes will
come next.

1 files changed, 205 insertions, 187 deletions

diff --git a/shared-core/i915_irq.c b/shared-core/i915_irq.c
index 98f51b2b..b280aa9d 100644
--- a/shared-core/i915_irq.c
+++ b/shared-core/i915_irq.c
@@ -38,47 +38,70 @@
 #define MAX_NOPID ((u32)~0)
 
 /**
+ * i915_get_pipe - return the the pipe associated with a given plane
+ * @dev: DRM device
+ * @plane: plane to look for
+ *
+ * We need to get the pipe associated with a given plane to correctly perform
+ * vblank driven swapping, and they may not always be equal.  So look up the
+ * pipe associated with @plane here.
+ */
+static int
+i915_get_pipe(struct drm_device *dev, int plane)
+{
+	struct drm_i915_private *dev_priv = (struct drm_i915_private *) dev->dev_private;
+	u32 dspcntr;
+
+	dspcntr = plane ? I915_READ(DSPBCNTR) : I915_READ(DSPACNTR);
+
+	return dspcntr & DISPPLANE_SEL_PIPE_MASK ? 1 : 0;
+}
+
+/**
  * Emit a synchronous flip.
  *
  * This function must be called with the drawable spinlock held.
  */
 static void
-i915_dispatch_vsync_flip(drm_device_t *dev, drm_drawable_info_t *drw, int pipe)
+i915_dispatch_vsync_flip(struct drm_device *dev, struct drm_drawable_info *drw,
+			 int plane)
 {
-	drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
-	drm_i915_sarea_t *sarea_priv = dev_priv->sarea_priv;
+	struct drm_i915_private *dev_priv = (struct drm_i915_private *) dev->dev_private;
+	struct drm_i915_sarea *sarea_priv = dev_priv->sarea_priv;
 	u16 x1, y1, x2, y2;
-	int pf_pipes = 1 << pipe;
+	int pf_planes = 1 << plane;
 
-	/* If the window is visible on the other pipe, we have to flip on that
-	 * pipe as well.
+	DRM_SPINLOCK_ASSERT(&dev->drw_lock);
+
+	/* If the window is visible on the other plane, we have to flip on that
+	 * plane as well.
 	 */
-	if (pipe == 1) {
-		x1 = sarea_priv->pipeA_x;
-		y1 = sarea_priv->pipeA_y;
-		x2 = x1 + sarea_priv->pipeA_w;
-		y2 = y1 + sarea_priv->pipeA_h;
+	if (plane == 1) {
+		x1 = sarea_priv->planeA_x;
+		y1 = sarea_priv->planeA_y;
+		x2 = x1 + sarea_priv->planeA_w;
+		y2 = y1 + sarea_priv->planeA_h;
 	} else {
-		x1 = sarea_priv->pipeB_x;
-		y1 = sarea_priv->pipeB_y;
-		x2 = x1 + sarea_priv->pipeB_w;
-		y2 = y1 + sarea_priv->pipeB_h;
+		x1 = sarea_priv->planeB_x;
+		y1 = sarea_priv->planeB_y;
+		x2 = x1 + sarea_priv->planeB_w;
+		y2 = y1 + sarea_priv->planeB_h;
 	}
 
 	if (x2 > 0 && y2 > 0) {
 		int i, num_rects = drw->num_rects;
-		drm_clip_rect_t *rect = drw->rects;
+		struct drm_clip_rect *rect = drw->rects;
 
 		for (i = 0; i < num_rects; i++)
 			if (!(rect[i].x1 >= x2 || rect[i].y1 >= y2 ||
 			      rect[i].x2 <= x1 || rect[i].y2 <= y1)) {
-				pf_pipes = 0x3;
+				pf_planes = 0x3;
 
 				break;
 			}
 	}
 
-	i915_dispatch_flip(dev, pf_pipes, 1);
+	i915_dispatch_flip(dev, pf_planes, 1);
 }
 
 /**
@@ -86,16 +109,15 @@ i915_dispatch_vsync_flip(drm_device_t *dev, drm_drawable_info_t *drw, int pipe)
  *
  * This function will be called with the HW lock held.
  */
-static void i915_vblank_tasklet(drm_device_t *dev)
+static void i915_vblank_tasklet(struct drm_device *dev)
 {
-	drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
-	unsigned long irqflags;
+	struct drm_i915_private *dev_priv = (struct drm_i915_private *) dev->dev_private;
 	struct list_head *list, *tmp, hits, *hit;
 	int nhits, nrects, slice[2], upper[2], lower[2], i, num_pages;
 	unsigned counter[2] = { atomic_read(&dev->vbl_received),
 				atomic_read(&dev->vbl_received2) };
-	drm_drawable_info_t *drw;
-	drm_i915_sarea_t *sarea_priv = dev_priv->sarea_priv;
+	struct drm_drawable_info *drw;
+	struct drm_i915_sarea *sarea_priv = dev_priv->sarea_priv;
 	u32 cpp = dev_priv->cpp,  offsets[3];
 	u32 cmd = (cpp == 4) ? (XY_SRC_COPY_BLT_CMD |
 				XY_SRC_COPY_BLT_WRITE_ALPHA |
@@ -111,35 +133,41 @@ static void i915_vblank_tasklet(drm_device_t *dev)
 
 	nhits = nrects = 0;
 
-	spin_lock_irqsave(&dev_priv->swaps_lock, irqflags);
+	/* No irqsave/restore necessary.  This tasklet may be run in an
+	 * interrupt context or normal context, but we don't have to worry
+	 * about getting interrupted by something acquiring the lock, because
+	 * we are the interrupt context thing that acquires the lock.
+	 */
+	DRM_SPINLOCK(&dev_priv->swaps_lock);
 
 	/* Find buffer swaps scheduled for this vertical blank */
 	list_for_each_safe(list, tmp, &dev_priv->vbl_swaps.head) {
-		drm_i915_vbl_swap_t *vbl_swap =
-			list_entry(list, drm_i915_vbl_swap_t, head);
+		struct drm_i915_vbl_swap *vbl_swap =
+			list_entry(list, struct drm_i915_vbl_swap, head);
+		int pipe = i915_get_pipe(dev, vbl_swap->plane);
 
-		if ((counter[vbl_swap->pipe] - vbl_swap->sequence) > (1<<23))
+		if ((counter[pipe] - vbl_swap->sequence) > (1<<23))
 			continue;
 
 		list_del(list);
 		dev_priv->swaps_pending--;
 
-		spin_unlock(&dev_priv->swaps_lock);
-		spin_lock(&dev->drw_lock);
+		DRM_SPINUNLOCK(&dev_priv->swaps_lock);
+		DRM_SPINLOCK(&dev->drw_lock);
 
 		drw = drm_get_drawable_info(dev, vbl_swap->drw_id);
 
 		if (!drw) {
-			spin_unlock(&dev->drw_lock);
+			DRM_SPINUNLOCK(&dev->drw_lock);
 			drm_free(vbl_swap, sizeof(*vbl_swap), DRM_MEM_DRIVER);
-			spin_lock(&dev_priv->swaps_lock);
+			DRM_SPINLOCK(&dev_priv->swaps_lock);
 			continue;
 		}
 
 		list_for_each(hit, &hits) {
-			drm_i915_vbl_swap_t *swap_cmp =
-				list_entry(hit, drm_i915_vbl_swap_t, head);
-			drm_drawable_info_t *drw_cmp =
+			struct drm_i915_vbl_swap *swap_cmp =
+				list_entry(hit, struct drm_i915_vbl_swap, head);
+			struct drm_drawable_info *drw_cmp =
 				drm_get_drawable_info(dev, swap_cmp->drw_id);
 
 			if (drw_cmp &&
@@ -149,7 +177,7 @@ static void i915_vblank_tasklet(drm_device_t *dev)
 			}
 		}
 
-		spin_unlock(&dev->drw_lock);
+		DRM_SPINUNLOCK(&dev->drw_lock);
 
 		/* List of hits was empty, or we reached the end of it */
 		if (hit == &hits)
@@ -157,30 +185,29 @@ static void i915_vblank_tasklet(drm_device_t *dev)
 
 		nhits++;
 
-		spin_lock(&dev_priv->swaps_lock);
+		DRM_SPINLOCK(&dev_priv->swaps_lock);
 	}
 
+	DRM_SPINUNLOCK(&dev_priv->swaps_lock);
+
 	if (nhits == 0) {
-		spin_unlock_irqrestore(&dev_priv->swaps_lock, irqflags);
 		return;
 	}
 
-	spin_unlock(&dev_priv->swaps_lock);
-
 	i915_kernel_lost_context(dev);
 
 	upper[0] = upper[1] = 0;
-	slice[0] = max(sarea_priv->pipeA_h / nhits, 1);
-	slice[1] = max(sarea_priv->pipeB_h / nhits, 1);
-	lower[0] = sarea_priv->pipeA_y + slice[0];
-	lower[1] = sarea_priv->pipeB_y + slice[0];
+	slice[0] = max(sarea_priv->planeA_h / nhits, 1);
+	slice[1] = max(sarea_priv->planeB_h / nhits, 1);
+	lower[0] = sarea_priv->planeA_y + slice[0];
+	lower[1] = sarea_priv->planeB_y + slice[0];
 
 	offsets[0] = sarea_priv->front_offset;
 	offsets[1] = sarea_priv->back_offset;
 	offsets[2] = sarea_priv->third_offset;
 	num_pages = sarea_priv->third_handle ? 3 : 2;
 
-	spin_lock(&dev->drw_lock);
+	DRM_SPINLOCK(&dev->drw_lock);
 
 	/* Emit blits for buffer swaps, partitioning both outputs into as many
 	 * slices as there are buffer swaps scheduled in order to avoid tearing
@@ -196,10 +223,10 @@ static void i915_vblank_tasklet(drm_device_t *dev)
 			lower[0] = lower[1] = sarea_priv->height;
 
 		list_for_each(hit, &hits) {
-			drm_i915_vbl_swap_t *swap_hit =
-				list_entry(hit, drm_i915_vbl_swap_t, head);
-			drm_clip_rect_t *rect;
-			int num_rects, pipe, front, back;
+			struct drm_i915_vbl_swap *swap_hit =
+				list_entry(hit, struct drm_i915_vbl_swap, head);
+			struct drm_clip_rect *rect;
+			int num_rects, plane, front, back;
 			unsigned short top, bottom;
 
 			drw = drm_get_drawable_info(dev, swap_hit->drw_id);
@@ -207,10 +234,10 @@ static void i915_vblank_tasklet(drm_device_t *dev)
 			if (!drw)
 				continue;
 
-			pipe = swap_hit->pipe;
+			plane = swap_hit->plane;
 
 			if (swap_hit->flip) {
-				i915_dispatch_vsync_flip(dev, drw, pipe);
+				i915_dispatch_vsync_flip(dev, drw, plane);
 				continue;
 			}
 
@@ -232,11 +259,11 @@ static void i915_vblank_tasklet(drm_device_t *dev)
 			}
 
 			rect = drw->rects;
-			top = upper[pipe];
-			bottom = lower[pipe];
+			top = upper[plane];
+			bottom = lower[plane];
 
 			front = (dev_priv->sarea_priv->pf_current_page >>
-				 (2 * pipe)) & 0x3;
+				 (2 * plane)) & 0x3;
 			back = (front + 1) % num_pages;
 
 			for (num_rects = drw->num_rects; num_rects--; rect++) {
@@ -262,11 +289,11 @@ static void i915_vblank_tasklet(drm_device_t *dev)
 		}
 	}
 
-	spin_unlock_irqrestore(&dev->drw_lock, irqflags);
+	DRM_SPINUNLOCK(&dev->drw_lock);
 
 	list_for_each_safe(hit, tmp, &hits) {
-		drm_i915_vbl_swap_t *swap_hit =
-			list_entry(hit, drm_i915_vbl_swap_t, head);
+		struct drm_i915_vbl_swap *swap_hit =
+			list_entry(hit, struct drm_i915_vbl_swap, head);
 
 		list_del(hit);
 
@@ -276,8 +303,8 @@ static void i915_vblank_tasklet(drm_device_t *dev)
 
 irqreturn_t i915_driver_irq_handler(DRM_IRQ_ARGS)
 {
-	drm_device_t *dev = (drm_device_t *) arg;
-	drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
+	struct drm_device *dev = (struct drm_device *) arg;
+	struct drm_i915_private *dev_priv = (struct drm_i915_private *) dev->dev_private;
 	u16 temp;
 	u32 pipea_stats, pipeb_stats;
 
@@ -338,10 +365,10 @@ irqreturn_t i915_driver_irq_handler(DRM_IRQ_ARGS)
 	return IRQ_HANDLED;
 }
 
-int i915_emit_irq(drm_device_t * dev)
+int i915_emit_irq(struct drm_device * dev)
 {
 	
-	drm_i915_private_t *dev_priv = dev->dev_private;
+	struct drm_i915_private *dev_priv = dev->dev_private;
 	RING_LOCALS;
 
 	i915_kernel_lost_context(dev);
@@ -360,31 +387,31 @@ int i915_emit_irq(drm_device_t * dev)
 
 }
 
-void i915_user_irq_on(drm_i915_private_t *dev_priv)
+void i915_user_irq_on(struct drm_i915_private *dev_priv)
 {
-	spin_lock(&dev_priv->user_irq_lock);
+	DRM_SPINLOCK(&dev_priv->user_irq_lock);
 	if (dev_priv->irq_enabled && (++dev_priv->user_irq_refcount == 1)){
 		dev_priv->irq_enable_reg |= USER_INT_FLAG;
 		I915_WRITE16(I915REG_INT_ENABLE_R, dev_priv->irq_enable_reg);
 	}
-	spin_unlock(&dev_priv->user_irq_lock);
+	DRM_SPINUNLOCK(&dev_priv->user_irq_lock);
 
 }
 		
-void i915_user_irq_off(drm_i915_private_t *dev_priv)
+void i915_user_irq_off(struct drm_i915_private *dev_priv)
 {
-	spin_lock(&dev_priv->user_irq_lock);
+	DRM_SPINLOCK(&dev_priv->user_irq_lock);
 	if (dev_priv->irq_enabled && (--dev_priv->user_irq_refcount == 0)) {
 		//		dev_priv->irq_enable_reg &= ~USER_INT_FLAG;
 		//		I915_WRITE16(I915REG_INT_ENABLE_R, dev_priv->irq_enable_reg);
 	}
-	spin_unlock(&dev_priv->user_irq_lock);
+	DRM_SPINUNLOCK(&dev_priv->user_irq_lock);
 }
 		
 
-static int i915_wait_irq(drm_device_t * dev, int irq_nr)
+static int i915_wait_irq(struct drm_device * dev, int irq_nr)
 {
-	drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
+	struct drm_i915_private *dev_priv = (struct drm_i915_private *) dev->dev_private;
 	int ret = 0;
 
 	DRM_DEBUG("%s irq_nr=%d breadcrumb=%d\n", __FUNCTION__, irq_nr,
@@ -400,7 +427,7 @@ static int i915_wait_irq(drm_device_t * dev, int irq_nr)
 		    READ_BREADCRUMB(dev_priv) >= irq_nr);
 	i915_user_irq_off(dev_priv);
 
-	if (ret == DRM_ERR(EBUSY)) {
+	if (ret == -EBUSY) {
 		DRM_ERROR("%s: EBUSY -- rec: %d emitted: %d\n",
 			  __FUNCTION__,
 			  READ_BREADCRUMB(dev_priv), (int)dev_priv->counter);
@@ -410,16 +437,17 @@ static int i915_wait_irq(drm_device_t * dev, int irq_nr)
 	return ret;
 }
 
-static int i915_driver_vblank_do_wait(drm_device_t *dev, unsigned int *sequence,
+static int i915_driver_vblank_do_wait(struct drm_device *dev,
+				      unsigned int *sequence,
 				      atomic_t *counter)
 {
-	drm_i915_private_t *dev_priv = dev->dev_private;
+	struct drm_i915_private *dev_priv = dev->dev_private;
 	unsigned int cur_vblank;
 	int ret = 0;
 
 	if (!dev_priv) {
 		DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
-		return DRM_ERR(EINVAL);
+		return -EINVAL;
 	}
 
 	DRM_WAIT_ON(ret, dev->vbl_queue, 3 * DRM_HZ,
@@ -431,7 +459,7 @@ static int i915_driver_vblank_do_wait(drm_device_t *dev, unsigned int *sequence,
 	return ret;
 }
 
-void i915_driver_wait_next_vblank(drm_device_t *dev, int pipe)
+void i915_driver_wait_next_vblank(struct drm_device *dev, int pipe)
 {
 	unsigned int seq;
 
@@ -444,40 +472,36 @@ void i915_driver_wait_next_vblank(drm_device_t *dev, int pipe)
 		i915_driver_vblank_do_wait(dev, &seq, &dev->vbl_received2);
 }
 
-int i915_driver_vblank_wait(drm_device_t *dev, unsigned int *sequence)
+int i915_driver_vblank_wait(struct drm_device *dev, unsigned int *sequence)
 {
 	return i915_driver_vblank_do_wait(dev, sequence, &dev->vbl_received);
 }
 
-int i915_driver_vblank_wait2(drm_device_t *dev, unsigned int *sequence)
+int i915_driver_vblank_wait2(struct drm_device *dev, unsigned int *sequence)
 {
 	return i915_driver_vblank_do_wait(dev, sequence, &dev->vbl_received2);
 }
 
 /* Needs the lock as it touches the ring.
  */
-int i915_irq_emit(DRM_IOCTL_ARGS)
+int i915_irq_emit(struct drm_device *dev, void *data, struct drm_file *file_priv)
 {
-	DRM_DEVICE;
-	drm_i915_private_t *dev_priv = dev->dev_private;
-	drm_i915_irq_emit_t emit;
+	struct drm_i915_private *dev_priv = dev->dev_private;
+	struct drm_i915_irq_emit *emit = data;
 	int result;
 
-	LOCK_TEST_WITH_RETURN(dev, filp);
+	LOCK_TEST_WITH_RETURN(dev, file_priv);
 
 	if (!dev_priv) {
 		DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
-		return DRM_ERR(EINVAL);
+		return -EINVAL;
 	}
 
-	DRM_COPY_FROM_USER_IOCTL(emit, (drm_i915_irq_emit_t __user *) data,
-				 sizeof(emit));
-
 	result = i915_emit_irq(dev);
 
-	if (DRM_COPY_TO_USER(emit.irq_seq, &result, sizeof(int))) {
+	if (DRM_COPY_TO_USER(emit->irq_seq, &result, sizeof(int))) {
 		DRM_ERROR("copy_to_user\n");
-		return DRM_ERR(EFAULT);
+		return -EFAULT;
 	}
 
 	return 0;
@@ -485,26 +509,23 @@ int i915_irq_emit(DRM_IOCTL_ARGS)
 
 /* Doesn't need the hardware lock.
  */
-int i915_irq_wait(DRM_IOCTL_ARGS)
+int i915_irq_wait(struct drm_device *dev, void *data,
+		  struct drm_file *file_priv)
 {
-	DRM_DEVICE;
-	drm_i915_private_t *dev_priv = dev->dev_private;
-	drm_i915_irq_wait_t irqwait;
+	struct drm_i915_private *dev_priv = dev->dev_private;
+	struct drm_i915_irq_wait *irqwait = data;
 
 	if (!dev_priv) {
 		DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
-		return DRM_ERR(EINVAL);
+		return -EINVAL;
 	}
 
-	DRM_COPY_FROM_USER_IOCTL(irqwait, (drm_i915_irq_wait_t __user *) data,
-				 sizeof(irqwait));
-
-	return i915_wait_irq(dev, irqwait.irq_seq);
+	return i915_wait_irq(dev, irqwait->irq_seq);
 }
 
-void i915_enable_interrupt (drm_device_t *dev)
+void i915_enable_interrupt (struct drm_device *dev)
 {
-	drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
+	struct drm_i915_private *dev_priv = (struct drm_i915_private *) dev->dev_private;
 	
 	dev_priv->irq_enable_reg = USER_INT_FLAG; 
 	if (dev_priv->vblank_pipe & DRM_I915_VBLANK_PIPE_A)
@@ -518,221 +539,218 @@ void i915_enable_interrupt (drm_device_t *dev)
 
 /* Set the vblank monitor pipe
  */
-int i915_vblank_pipe_set(DRM_IOCTL_ARGS)
+int i915_vblank_pipe_set(struct drm_device *dev, void *data,
+			 struct drm_file *file_priv)
 {
-	DRM_DEVICE;
-	drm_i915_private_t *dev_priv = dev->dev_private;
-	drm_i915_vblank_pipe_t pipe;
+	struct drm_i915_private *dev_priv = dev->dev_private;
+	struct drm_i915_vblank_pipe *pipe = data;
 
 	if (!dev_priv) {
 		DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
-		return DRM_ERR(EINVAL);
+		return -EINVAL;
 	}
 
-	DRM_COPY_FROM_USER_IOCTL(pipe, (drm_i915_vblank_pipe_t __user *) data,
-				 sizeof(pipe));
-
-	if (pipe.pipe & ~(DRM_I915_VBLANK_PIPE_A|DRM_I915_VBLANK_PIPE_B)) {
+	if (pipe->pipe & ~(DRM_I915_VBLANK_PIPE_A|DRM_I915_VBLANK_PIPE_B)) {
 		DRM_ERROR("%s called with invalid pipe 0x%x\n", 
-			  __FUNCTION__, pipe.pipe);
-		return DRM_ERR(EINVAL);
+			  __FUNCTION__, pipe->pipe);
+		return -EINVAL;
 	}
 
-	dev_priv->vblank_pipe = pipe.pipe;
+	dev_priv->vblank_pipe = pipe->pipe;
 
 	i915_enable_interrupt (dev);
 
 	return 0;
 }
 
-int i915_vblank_pipe_get(DRM_IOCTL_ARGS)
+int i915_vblank_pipe_get(struct drm_device *dev, void *data,
+			 struct drm_file *file_priv)
 {
-	DRM_DEVICE;
-	drm_i915_private_t *dev_priv = dev->dev_private;
-	drm_i915_vblank_pipe_t pipe;
+	struct drm_i915_private *dev_priv = dev->dev_private;
+	struct drm_i915_vblank_pipe *pipe = data;
 	u16 flag;
 
 	if (!dev_priv) {
 		DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
-		return DRM_ERR(EINVAL);
+		return -EINVAL;
 	}
 
 	flag = I915_READ(I915REG_INT_ENABLE_R);
-	pipe.pipe = 0;
+	pipe->pipe = 0;
 	if (flag & VSYNC_PIPEA_FLAG)
-		pipe.pipe |= DRM_I915_VBLANK_PIPE_A;
+		pipe->pipe |= DRM_I915_VBLANK_PIPE_A;
 	if (flag & VSYNC_PIPEB_FLAG)
-		pipe.pipe |= DRM_I915_VBLANK_PIPE_B;
-	DRM_COPY_TO_USER_IOCTL((drm_i915_vblank_pipe_t __user *) data, pipe,
-				 sizeof(pipe));
+		pipe->pipe |= DRM_I915_VBLANK_PIPE_B;
+
 	return 0;
 }
 
 /**
  * Schedule buffer swap at given vertical blank.
  */
-int i915_vblank_swap(DRM_IOCTL_ARGS)
+int i915_vblank_swap(struct drm_device *dev, void *data,
+		     struct drm_file *file_priv)
 {
-	DRM_DEVICE;
-	drm_i915_private_t *dev_priv = dev->dev_private;
-	drm_i915_vblank_swap_t swap;
-	drm_i915_vbl_swap_t *vbl_swap;
-	unsigned int pipe, seqtype, curseq;
+	struct drm_i915_private *dev_priv = dev->dev_private;
+	struct drm_i915_vblank_swap *swap = data;
+	struct drm_i915_vbl_swap *vbl_swap;
+	unsigned int pipe, seqtype, curseq, plane;
 	unsigned long irqflags;
 	struct list_head *list;
 
 	if (!dev_priv) {
 		DRM_ERROR("%s called with no initialization\n", __func__);
-		return DRM_ERR(EINVAL);
+		return -EINVAL;
 	}
 
 	if (dev_priv->sarea_priv->rotation) {
 		DRM_DEBUG("Rotation not supported\n");
-		return DRM_ERR(EINVAL);
+		return -EINVAL;
 	}
 
-	DRM_COPY_FROM_USER_IOCTL(swap, (drm_i915_vblank_swap_t __user *) data,
-				 sizeof(swap));
-
-	if (swap.seqtype & ~(_DRM_VBLANK_RELATIVE | _DRM_VBLANK_ABSOLUTE |
+	if (swap->seqtype & ~(_DRM_VBLANK_RELATIVE | _DRM_VBLANK_ABSOLUTE |
 			     _DRM_VBLANK_SECONDARY | _DRM_VBLANK_NEXTONMISS |
 			     _DRM_VBLANK_FLIP)) {
-		DRM_ERROR("Invalid sequence type 0x%x\n", swap.seqtype);
-		return DRM_ERR(EINVAL);
+		DRM_ERROR("Invalid sequence type 0x%x\n", swap->seqtype);
+		return -EINVAL;
 	}
 
-	pipe = (swap.seqtype & _DRM_VBLANK_SECONDARY) ? 1 : 0;
+	plane = (swap->seqtype & _DRM_VBLANK_SECONDARY) ? 1 : 0;
+	pipe = i915_get_pipe(dev, plane);
 
-	seqtype = swap.seqtype & (_DRM_VBLANK_RELATIVE | _DRM_VBLANK_ABSOLUTE);
+	seqtype = swap->seqtype & (_DRM_VBLANK_RELATIVE | _DRM_VBLANK_ABSOLUTE);
 
 	if (!(dev_priv->vblank_pipe & (1 << pipe))) {
 		DRM_ERROR("Invalid pipe %d\n", pipe);
-		return DRM_ERR(EINVAL);
+		return -EINVAL;
 	}
 
-	spin_lock_irqsave(&dev->drw_lock, irqflags);
+	DRM_SPINLOCK_IRQSAVE(&dev->drw_lock, irqflags);
 
-	if (!drm_get_drawable_info(dev, swap.drawable)) {
-		spin_unlock_irqrestore(&dev->drw_lock, irqflags);
-		DRM_DEBUG("Invalid drawable ID %d\n", swap.drawable);
-		return DRM_ERR(EINVAL);
+	/* It makes no sense to schedule a swap for a drawable that doesn't have
+	 * valid information at this point. E.g. this could mean that the X
+	 * server is too old to push drawable information to the DRM, in which
+	 * case all such swaps would become ineffective.
+	 */
+	if (!drm_get_drawable_info(dev, swap->drawable)) {
+		DRM_SPINUNLOCK_IRQRESTORE(&dev->drw_lock, irqflags);
+		DRM_DEBUG("Invalid drawable ID %d\n", swap->drawable);
+		return -EINVAL;
 	}
 
-	spin_unlock_irqrestore(&dev->drw_lock, irqflags);
+	DRM_SPINUNLOCK_IRQRESTORE(&dev->drw_lock, irqflags);
 
 	curseq = atomic_read(pipe ? &dev->vbl_received2 : &dev->vbl_received);
 
 	if (seqtype == _DRM_VBLANK_RELATIVE)
-		swap.sequence += curseq;
+		swap->sequence += curseq;
 
-	if ((curseq - swap.sequence) <= (1<<23)) {
-		if (swap.seqtype & _DRM_VBLANK_NEXTONMISS) {
-			swap.sequence = curseq + 1;
+	if ((curseq - swap->sequence) <= (1<<23)) {
+		if (swap->seqtype & _DRM_VBLANK_NEXTONMISS) {
+			swap->sequence = curseq + 1;
 		} else {
 			DRM_DEBUG("Missed target sequence\n");
-			return DRM_ERR(EINVAL);
+			return -EINVAL;
 		}
 	}
 
-	if (swap.seqtype & _DRM_VBLANK_FLIP) {
-		swap.sequence--;
+	if (swap->seqtype & _DRM_VBLANK_FLIP) {
+		swap->sequence--;
 
-		if ((curseq - swap.sequence) <= (1<<23)) {
-			drm_drawable_info_t *drw;
+		if ((curseq - swap->sequence) <= (1<<23)) {
+			struct drm_drawable_info *drw;
 
-			LOCK_TEST_WITH_RETURN(dev, filp);
+			LOCK_TEST_WITH_RETURN(dev, file_priv);
 
-			spin_lock_irqsave(&dev->drw_lock, irqflags);
+			DRM_SPINLOCK_IRQSAVE(&dev->drw_lock, irqflags);
 
-			drw = drm_get_drawable_info(dev, swap.drawable);
+			drw = drm_get_drawable_info(dev, swap->drawable);
 
 			if (!drw) {
-				spin_unlock_irqrestore(&dev->drw_lock, irqflags);
+				DRM_SPINUNLOCK_IRQRESTORE(&dev->drw_lock,
+				    irqflags);
 				DRM_DEBUG("Invalid drawable ID %d\n",
-					  swap.drawable);
-				return DRM_ERR(EINVAL);
+					  swap->drawable);
+				return -EINVAL;
 			}
 
-			i915_dispatch_vsync_flip(dev, drw, pipe);
+			i915_dispatch_vsync_flip(dev, drw, plane);
 
-			spin_unlock_irqrestore(&dev->drw_lock, irqflags);
+			DRM_SPINUNLOCK_IRQRESTORE(&dev->drw_lock, irqflags);
 
 			return 0;
 		}
 	}
 
-	spin_lock_irqsave(&dev_priv->swaps_lock, irqflags);
+	DRM_SPINLOCK_IRQSAVE(&dev_priv->swaps_lock, irqflags);
 
 	list_for_each(list, &dev_priv->vbl_swaps.head) {
-		vbl_swap = list_entry(list, drm_i915_vbl_swap_t, head);
+		vbl_swap = list_entry(list, struct drm_i915_vbl_swap, head);
 
-		if (vbl_swap->drw_id == swap.drawable &&
-		    vbl_swap->pipe == pipe &&
-		    vbl_swap->sequence == swap.sequence) {
-			vbl_swap->flip = (swap.seqtype & _DRM_VBLANK_FLIP);
-			spin_unlock_irqrestore(&dev_priv->swaps_lock, irqflags);
+		if (vbl_swap->drw_id == swap->drawable &&
+		    vbl_swap->plane == plane &&
+		    vbl_swap->sequence == swap->sequence) {
+			vbl_swap->flip = (swap->seqtype & _DRM_VBLANK_FLIP);
+			DRM_SPINUNLOCK_IRQRESTORE(&dev_priv->swaps_lock, irqflags);
 			DRM_DEBUG("Already scheduled\n");
 			return 0;
 		}
 	}
 
-	spin_unlock_irqrestore(&dev_priv->swaps_lock, irqflags);
+	DRM_SPINUNLOCK_IRQRESTORE(&dev_priv->swaps_lock, irqflags);
 
 	if (dev_priv->swaps_pending >= 100) {
 		DRM_DEBUG("Too many swaps queued\n");
-		return DRM_ERR(EBUSY);
+		return -EBUSY;
 	}
 
 	vbl_swap = drm_calloc(1, sizeof(vbl_swap), DRM_MEM_DRIVER);
 
 	if (!vbl_swap) {
 		DRM_ERROR("Failed to allocate memory to queue swap\n");
-		return DRM_ERR(ENOMEM);
+		return -ENOMEM;
 	}
 
 	DRM_DEBUG("\n");
 
-	vbl_swap->drw_id = swap.drawable;
-	vbl_swap->pipe = pipe;
-	vbl_swap->sequence = swap.sequence;
-	vbl_swap->flip = (swap.seqtype & _DRM_VBLANK_FLIP);
+	vbl_swap->drw_id = swap->drawable;
+	vbl_swap->plane = plane;
+	vbl_swap->sequence = swap->sequence;
+	vbl_swap->flip = (swap->seqtype & _DRM_VBLANK_FLIP);
 
 	if (vbl_swap->flip)
-		swap.sequence++;
+		swap->sequence++;
 
-	spin_lock_irqsave(&dev_priv->swaps_lock, irqflags);
+	DRM_SPINLOCK_IRQSAVE(&dev_priv->swaps_lock, irqflags);
 
 	list_add_tail((struct list_head *)vbl_swap, &dev_priv->vbl_swaps.head);
 	dev_priv->swaps_pending++;
 
-	spin_unlock_irqrestore(&dev_priv->swaps_lock, irqflags);
-
-	DRM_COPY_TO_USER_IOCTL((drm_i915_vblank_swap_t __user *) data, swap,
-			       sizeof(swap));
+	DRM_SPINUNLOCK_IRQRESTORE(&dev_priv->swaps_lock, irqflags);
 
 	return 0;
 }
 
 /* drm_dma.h hooks
 */
-void i915_driver_irq_preinstall(drm_device_t * dev)
+void i915_driver_irq_preinstall(struct drm_device * dev)
 {
-	drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
+	struct drm_i915_private *dev_priv = (struct drm_i915_private *) dev->dev_private;
 
 	I915_WRITE16(I915REG_HWSTAM, 0xeffe);
 	I915_WRITE16(I915REG_INT_MASK_R, 0x0);
 	I915_WRITE16(I915REG_INT_ENABLE_R, 0x0);
 }
 
-void i915_driver_irq_postinstall(drm_device_t * dev)
+void i915_driver_irq_postinstall(struct drm_device * dev)
 {
-	drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
+	struct drm_i915_private *dev_priv = (struct drm_i915_private *) dev->dev_private;
 
-	spin_lock_init(&dev_priv->swaps_lock);
+	DRM_SPININIT(&dev_priv->swaps_lock, "swap");
 	INIT_LIST_HEAD(&dev_priv->vbl_swaps.head);
 	dev_priv->swaps_pending = 0;
 
-	dev_priv->user_irq_lock = SPIN_LOCK_UNLOCKED;
+	DRM_SPININIT(&dev_priv->user_irq_lock, "userirq");
 	dev_priv->user_irq_refcount = 0;
 
 	i915_enable_interrupt(dev);
@@ -745,9 +763,9 @@ void i915_driver_irq_postinstall(drm_device_t * dev)
 	I915_WRITE(I915REG_INSTPM, ( 1 << 5) | ( 1 << 21));
 }
 
-void i915_driver_irq_uninstall(drm_device_t * dev)
+void i915_driver_irq_uninstall(struct drm_device * dev)
 {
-	drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
+	struct drm_i915_private *dev_priv = (struct drm_i915_private *) dev->dev_private;
 	u16 temp;
 	if (!dev_priv)
 		return;