intel: Rename dri_ and intel_ symbols to drm_intel_.

I wanted to avoid doing this, as it's a bunch of churn, but there was a
conflict between the dri_ symbols in libdrm and the symbols that were in
Mesa in 7.2, which broke Mesa 7.2 AIGLX when the 2D driver had loaded new
libdrm symbols.  The new naming was recommended by cworth for giving the
code a unique prefix identifying where the code lives.

Additionally, take the opportunity to fix up two API mistakes: emit_reloc's
arguments were in a nonsensical order, and set_tiling lacked the stride
argument that the kernel will want to use soon.  API compatibility with
released code is maintained using #defines.

5 files changed, 538 insertions, 484 deletions

diff --git a/libdrm/intel/intel_bufmgr.c b/libdrm/intel/intel_bufmgr.c
index 92b60467..188eac22 100644
--- a/libdrm/intel/intel_bufmgr.c
+++ b/libdrm/intel/intel_bufmgr.c
@@ -39,26 +39,26 @@
 #include "intel_bufmgr.h"
 #include "intel_bufmgr_priv.h"
 
-/** @file dri_bufmgr.c
+/** @file intel_bufmgr.c
  *
  * Convenience functions for buffer management methods.
  */
 
-dri_bo *
-dri_bo_alloc(dri_bufmgr *bufmgr, const char *name, unsigned long size,
-	     unsigned int alignment)
+drm_intel_bo *
+drm_intel_bo_alloc(drm_intel_bufmgr *bufmgr, const char *name,
+		   unsigned long size, unsigned int alignment)
 {
    return bufmgr->bo_alloc(bufmgr, name, size, alignment);
 }
 
 void
-dri_bo_reference(dri_bo *bo)
+drm_intel_bo_reference(drm_intel_bo *bo)
 {
    bo->bufmgr->bo_reference(bo);
 }
 
 void
-dri_bo_unreference(dri_bo *bo)
+drm_intel_bo_unreference(drm_intel_bo *bo)
 {
    if (bo == NULL)
       return;
@@ -67,38 +67,39 @@ dri_bo_unreference(dri_bo *bo)
 }
 
 int
-dri_bo_map(dri_bo *buf, int write_enable)
+drm_intel_bo_map(drm_intel_bo *buf, int write_enable)
 {
    return buf->bufmgr->bo_map(buf, write_enable);
 }
 
 int
-dri_bo_unmap(dri_bo *buf)
+drm_intel_bo_unmap(drm_intel_bo *buf)
 {
    return buf->bufmgr->bo_unmap(buf);
 }
 
 int
-dri_bo_subdata(dri_bo *bo, unsigned long offset,
-	       unsigned long size, const void *data)
+drm_intel_bo_subdata(drm_intel_bo *bo, unsigned long offset,
+		     unsigned long size, const void *data)
 {
    int ret;
+
    if (bo->bufmgr->bo_subdata)
       return bo->bufmgr->bo_subdata(bo, offset, size, data);
    if (size == 0 || data == NULL)
       return 0;
 
-   ret = dri_bo_map(bo, 1);
+   ret = drm_intel_bo_map(bo, 1);
    if (ret)
        return ret;
    memcpy((unsigned char *)bo->virtual + offset, data, size);
-   dri_bo_unmap(bo);
+   drm_intel_bo_unmap(bo);
    return 0;
 }
 
 int
-dri_bo_get_subdata(dri_bo *bo, unsigned long offset,
-		   unsigned long size, void *data)
+drm_intel_bo_get_subdata(drm_intel_bo *bo, unsigned long offset,
+			 unsigned long size, void *data)
 {
    int ret;
    if (bo->bufmgr->bo_subdata)
@@ -107,48 +108,48 @@ dri_bo_get_subdata(dri_bo *bo, unsigned long offset,
    if (size == 0 || data == NULL)
       return 0;
 
-   ret = dri_bo_map(bo, 0);
+   ret = drm_intel_bo_map(bo, 0);
    if (ret)
        return ret;
    memcpy(data, (unsigned char *)bo->virtual + offset, size);
-   dri_bo_unmap(bo);
+   drm_intel_bo_unmap(bo);
    return 0;
 }
 
 void
-dri_bo_wait_rendering(dri_bo *bo)
+drm_intel_bo_wait_rendering(drm_intel_bo *bo)
 {
    bo->bufmgr->bo_wait_rendering(bo);
 }
 
 void
-dri_bufmgr_destroy(dri_bufmgr *bufmgr)
+drm_intel_bufmgr_destroy(drm_intel_bufmgr *bufmgr)
 {
    bufmgr->destroy(bufmgr);
 }
 
 int
-dri_bo_exec(dri_bo *bo, int used,
-	    drm_clip_rect_t *cliprects, int num_cliprects,
-	    int DR4)
+drm_intel_bo_exec(drm_intel_bo *bo, int used,
+		  drm_clip_rect_t *cliprects, int num_cliprects,
+		  int DR4)
 {
    return bo->bufmgr->bo_exec(bo, used, cliprects, num_cliprects, DR4);
 }
 
 void
-dri_bufmgr_set_debug(dri_bufmgr *bufmgr, int enable_debug)
+drm_intel_bufmgr_set_debug(drm_intel_bufmgr *bufmgr, int enable_debug)
 {
    bufmgr->debug = enable_debug;
 }
 
 int
-dri_bufmgr_check_aperture_space(dri_bo **bo_array, int count)
+drm_intel_bufmgr_check_aperture_space(drm_intel_bo **bo_array, int count)
 {
 	return bo_array[0]->bufmgr->check_aperture_space(bo_array, count);
 }
 
 int
-dri_bo_flink(dri_bo *bo, uint32_t *name)
+drm_intel_bo_flink(drm_intel_bo *bo, uint32_t *name)
 {
     if (bo->bufmgr->bo_flink)
 	return bo->bufmgr->bo_flink(bo, name);
@@ -157,17 +158,17 @@ dri_bo_flink(dri_bo *bo, uint32_t *name)
 }
 
 int
-dri_bo_emit_reloc(dri_bo *reloc_buf,
-		  uint32_t read_domains, uint32_t write_domain,
-		  uint32_t delta, uint32_t offset, dri_bo *target_buf)
+drm_intel_bo_emit_reloc(drm_intel_bo *bo, uint32_t offset,
+			drm_intel_bo *target_bo, uint32_t target_offset,
+			uint32_t read_domains, uint32_t write_domain)
 {
-    return reloc_buf->bufmgr->bo_emit_reloc(reloc_buf,
-					    read_domains, write_domain,
-					    delta, offset, target_buf);
+	return bo->bufmgr->bo_emit_reloc(bo, offset,
+					 target_bo, target_offset,
+					 read_domains, write_domain);
 }
 
 int
-dri_bo_pin(dri_bo *bo, uint32_t alignment)
+drm_intel_bo_pin(drm_intel_bo *bo, uint32_t alignment)
 {
     if (bo->bufmgr->bo_pin)
 	return bo->bufmgr->bo_pin(bo, alignment);
@@ -176,7 +177,7 @@ dri_bo_pin(dri_bo *bo, uint32_t alignment)
 }
 
 int
-dri_bo_unpin(dri_bo *bo)
+drm_intel_bo_unpin(drm_intel_bo *bo)
 {
     if (bo->bufmgr->bo_unpin)
 	return bo->bufmgr->bo_unpin(bo);
@@ -184,16 +185,18 @@ dri_bo_unpin(dri_bo *bo)
     return -ENODEV;
 }
 
-int dri_bo_set_tiling(dri_bo *bo, uint32_t *tiling_mode)
+int drm_intel_bo_set_tiling(drm_intel_bo *bo, uint32_t *tiling_mode,
+			    uint32_t stride)
 {
     if (bo->bufmgr->bo_set_tiling)
-	return bo->bufmgr->bo_set_tiling(bo, tiling_mode);
+	return bo->bufmgr->bo_set_tiling(bo, tiling_mode, stride);
 
     *tiling_mode = I915_TILING_NONE;
     return 0;
 }
 
-int dri_bo_get_tiling(dri_bo *bo, uint32_t *tiling_mode, uint32_t *swizzle_mode)
+int drm_intel_bo_get_tiling(drm_intel_bo *bo, uint32_t *tiling_mode,
+			    uint32_t *swizzle_mode)
 {
     if (bo->bufmgr->bo_get_tiling)
 	return bo->bufmgr->bo_get_tiling(bo, tiling_mode, swizzle_mode);
diff --git a/libdrm/intel/intel_bufmgr.h b/libdrm/intel/intel_bufmgr.h
index 0c7b0e47..e3af886b 100644
--- a/libdrm/intel/intel_bufmgr.h
+++ b/libdrm/intel/intel_bufmgr.h
@@ -36,10 +36,10 @@
 
 #include <stdint.h>
 
-typedef struct _dri_bufmgr dri_bufmgr;
-typedef struct _dri_bo dri_bo;
+typedef struct _drm_intel_bufmgr drm_intel_bufmgr;
+typedef struct _drm_intel_bo drm_intel_bo;
 
-struct _dri_bo {
+struct _drm_intel_bo {
     /**
      * Size in bytes of the buffer object.
      *
@@ -58,72 +58,117 @@ struct _dri_bo {
     void *virtual;
 
     /** Buffer manager context associated with this buffer object */
-    dri_bufmgr *bufmgr;
+    drm_intel_bufmgr *bufmgr;
 };
 
-dri_bo *dri_bo_alloc(dri_bufmgr *bufmgr, const char *name, unsigned long size,
-		     unsigned int alignment);
-void dri_bo_reference(dri_bo *bo);
-void dri_bo_unreference(dri_bo *bo);
-int dri_bo_map(dri_bo *buf, int write_enable);
-int dri_bo_unmap(dri_bo *buf);
-
-int dri_bo_subdata(dri_bo *bo, unsigned long offset,
-		   unsigned long size, const void *data);
-int dri_bo_get_subdata(dri_bo *bo, unsigned long offset,
-		       unsigned long size, void *data);
-void dri_bo_wait_rendering(dri_bo *bo);
-
-void dri_bufmgr_set_debug(dri_bufmgr *bufmgr, int enable_debug);
-void dri_bufmgr_destroy(dri_bufmgr *bufmgr);
-int dri_bo_exec(dri_bo *bo, int used,
-		drm_clip_rect_t *cliprects, int num_cliprects,
-		int DR4);
-int dri_bufmgr_check_aperture_space(dri_bo **bo_array, int count);
-
-int dri_bo_emit_reloc(dri_bo *reloc_buf,
-		      uint32_t read_domains, uint32_t write_domain,
-		      uint32_t delta, uint32_t offset, dri_bo *target_buf);
-int dri_bo_pin(dri_bo *buf, uint32_t alignment);
-int dri_bo_unpin(dri_bo *buf);
-int dri_bo_set_tiling(dri_bo *buf, uint32_t *tiling_mode);
-int dri_bo_get_tiling(dri_bo *buf, uint32_t *tiling_mode,
-		      uint32_t *swizzle_mode);
-int dri_bo_flink(dri_bo *buf, uint32_t *name);
-
-/* intel_bufmgr_gem.c */
-dri_bufmgr *intel_bufmgr_gem_init(int fd, int batch_size);
-dri_bo *intel_bo_gem_create_from_name(dri_bufmgr *bufmgr, const char *name,
-				      unsigned int handle);
-void intel_bufmgr_gem_enable_reuse(dri_bufmgr *bufmgr);
-
-/* intel_bufmgr_fake.c */
-dri_bufmgr *intel_bufmgr_fake_init(int fd,
-				   unsigned long low_offset, void *low_virtual,
-				   unsigned long size,
-				   volatile unsigned int *last_dispatch);
-void intel_bufmgr_fake_set_last_dispatch(dri_bufmgr *bufmgr,
-					 volatile unsigned int *last_dispatch);
-void intel_bufmgr_fake_set_exec_callback(dri_bufmgr *bufmgr,
-					 int (*exec)(dri_bo *bo,
-						     unsigned int used,
-						     void *priv),
-					 void *priv);
-void intel_bufmgr_fake_set_fence_callback(dri_bufmgr *bufmgr,
-					  unsigned int (*emit)(void *priv),
-					  void (*wait)(unsigned int fence,
-						       void *priv),
-					  void *priv);
-dri_bo *intel_bo_fake_alloc_static(dri_bufmgr *bufmgr, const char *name,
-				   unsigned long offset, unsigned long size,
-				   void *virtual);
-void intel_bo_fake_disable_backing_store(dri_bo *bo,
-					 void (*invalidate_cb)(dri_bo *bo,
-							       void *ptr),
-					 void *ptr);
-
-void intel_bufmgr_fake_contended_lock_take(dri_bufmgr *bufmgr);
-void intel_bufmgr_fake_evict_all(dri_bufmgr *bufmgr);
+drm_intel_bo *drm_intel_bo_alloc(drm_intel_bufmgr *bufmgr, const char *name,
+				 unsigned long size, unsigned int alignment);
+void drm_intel_bo_reference(drm_intel_bo *bo);
+void drm_intel_bo_unreference(drm_intel_bo *bo);
+int drm_intel_bo_map(drm_intel_bo *bo, int write_enable);
+int drm_intel_bo_unmap(drm_intel_bo *bo);
+
+int drm_intel_bo_subdata(drm_intel_bo *bo, unsigned long offset,
+		     unsigned long size, const void *data);
+int drm_intel_bo_get_subdata(drm_intel_bo *bo, unsigned long offset,
+			 unsigned long size, void *data);
+void drm_intel_bo_wait_rendering(drm_intel_bo *bo);
+
+void drm_intel_bufmgr_set_debug(drm_intel_bufmgr *bufmgr, int enable_debug);
+void drm_intel_bufmgr_destroy(drm_intel_bufmgr *bufmgr);
+int drm_intel_bo_exec(drm_intel_bo *bo, int used,
+		      drm_clip_rect_t *cliprects, int num_cliprects,
+		      int DR4);
+int drm_intel_bufmgr_check_aperture_space(drm_intel_bo **bo_array, int count);
+
+int drm_intel_bo_emit_reloc(drm_intel_bo *bo, uint32_t offset,
+			    drm_intel_bo *target_bo, uint32_t target_offset,
+			    uint32_t read_domains, uint32_t write_domain);
+int drm_intel_bo_pin(drm_intel_bo *bo, uint32_t alignment);
+int drm_intel_bo_unpin(drm_intel_bo *bo);
+int drm_intel_bo_set_tiling(drm_intel_bo *bo, uint32_t *tiling_mode,
+			    uint32_t stride);
+int drm_intel_bo_get_tiling(drm_intel_bo *bo, uint32_t *tiling_mode,
+			uint32_t *swizzle_mode);
+int drm_intel_bo_flink(drm_intel_bo *bo, uint32_t *name);
+
+/* drm_intel_bufmgr_gem.c */
+drm_intel_bufmgr *drm_intel_bufmgr_gem_init(int fd, int batch_size);
+drm_intel_bo *drm_intel_bo_gem_create_from_name(drm_intel_bufmgr *bufmgr,
+						const char *name,
+						unsigned int handle);
+void drm_intel_bufmgr_gem_enable_reuse(drm_intel_bufmgr *bufmgr);
+
+/* drm_intel_bufmgr_fake.c */
+drm_intel_bufmgr *drm_intel_bufmgr_fake_init(int fd,
+					     unsigned long low_offset,
+					     void *low_virtual,
+					     unsigned long size,
+					     volatile unsigned int *last_dispatch);
+void drm_intel_bufmgr_fake_set_last_dispatch(drm_intel_bufmgr *bufmgr,
+					     volatile unsigned int *last_dispatch);
+void drm_intel_bufmgr_fake_set_exec_callback(drm_intel_bufmgr *bufmgr,
+					     int (*exec)(drm_intel_bo *bo,
+							 unsigned int used,
+							 void *priv),
+					     void *priv);
+void drm_intel_bufmgr_fake_set_fence_callback(drm_intel_bufmgr *bufmgr,
+					      unsigned int (*emit)(void *priv),
+					      void (*wait)(unsigned int fence,
+							   void *priv),
+					      void *priv);
+drm_intel_bo *drm_intel_bo_fake_alloc_static(drm_intel_bufmgr *bufmgr,
+					     const char *name,
+					     unsigned long offset, unsigned long size,
+					     void *virtual);
+void drm_intel_bo_fake_disable_backing_store(drm_intel_bo *bo,
+					     void (*invalidate_cb)(drm_intel_bo *bo,
+								   void *ptr),
+					     void *ptr);
+
+void drm_intel_bufmgr_fake_contended_lock_take(drm_intel_bufmgr *bufmgr);
+void drm_intel_bufmgr_fake_evict_all(drm_intel_bufmgr *bufmgr);
+
+/** @{ Compatibility defines to keep old code building despite the symbol rename
+ * from dri_* to drm_intel_*
+ */
+#define dri_bo drm_intel_bo
+#define dri_bufmgr drm_intel_bufmgr
+#define dri_bo_alloc drm_intel_bo_alloc
+#define dri_bo_reference drm_intel_bo_reference
+#define dri_bo_unreference drm_intel_bo_unreference
+#define dri_bo_map drm_intel_bo_map
+#define dri_bo_unmap drm_intel_bo_unmap
+#define dri_bo_subdata drm_intel_bo_subdata
+#define dri_bo_get_subdata drm_intel_bo_get_subdata
+#define dri_bo_wait_rendering drm_intel_bo_wait_rendering
+#define dri_bufmgr_set_debug drm_intel_bufmgr_set_debug
+#define dri_bufmgr_destroy drm_intel_bufmgr_destroy
+#define dri_bo_exec drm_intel_bo_exec
+#define dri_bufmgr_check_aperture_space drm_intel_bufmgr_check_aperture_space
+#define dri_bo_emit_reloc(reloc_bo, read, write, target_offset,		\
+			  reloc_offset, target_bo)			\
+	drm_intel_bo_emit_reloc(reloc_bo, reloc_offset,			\
+			    target_bo, target_offset,			\
+			    read, write);
+#define dri_bo_pin drm_intel_bo_pin
+#define dri_bo_unpin drm_intel_bo_unpin
+#define dri_bo_get_tiling drm_intel_bo_get_tiling
+#define dri_bo_set_tiling(bo, mode) drm_intel_bo_set_tiling(bo, mode, 0)
+#define dri_bo_flink drm_intel_bo_flink
+#define intel_bufmgr_gem_init drm_intel_bufmgr_gem_init
+#define intel_bo_gem_create_from_name drm_intel_bo_gem_create_from_name
+#define intel_bufmgr_gem_enable_reuse drm_intel_bufmgr_gem_enable_reuse
+#define intel_bufmgr_fake_init drm_intel_bufmgr_fake_init
+#define intel_bufmgr_fake_set_last_dispatch drm_intel_bufmgr_fake_set_last_dispatch
+#define intel_bufmgr_fake_set_exec_callback drm_intel_bufmgr_fake_set_exec_callback
+#define intel_bufmgr_fake_set_fence_callback drm_intel_bufmgr_fake_set_fence_callback
+#define intel_bo_fake_alloc_static drm_intel_bo_fake_alloc_static
+#define intel_bo_fake_disable_backing_store drm_intel_bo_fake_disable_backing_store
+#define intel_bufmgr_fake_contended_lock_take drm_intel_bufmgr_fake_contended_lock_take
+#define intel_bufmgr_fake_evict_all drm_intel_bufmgr_fake_evict_all
+
+/** @{ */
 
 #endif /* INTEL_BUFMGR_H */
 
diff --git a/libdrm/intel/intel_bufmgr_fake.c b/libdrm/intel/intel_bufmgr_fake.c
index c9545b35..6d8ee85a 100644
--- a/libdrm/intel/intel_bufmgr_fake.c
+++ b/libdrm/intel/intel_bufmgr_fake.c
@@ -75,7 +75,7 @@
 struct fake_buffer_reloc
 {
    /** Buffer object that the relocation points at. */
-   dri_bo *target_buf;
+   drm_intel_bo *target_buf;
    /** Offset of the relocation entry within reloc_buf. */
    uint32_t offset;
    /** Cached value of the offset when we last performed this relocation. */
@@ -106,12 +106,12 @@ struct block {
    /** Fence cookie for the block. */
    unsigned fence; /* Split to read_fence, write_fence */
 
-   dri_bo *bo;
+   drm_intel_bo *bo;
    void *virtual;
 };
 
 typedef struct _bufmgr_fake {
-   dri_bufmgr bufmgr;
+   drm_intel_bufmgr bufmgr;
 
    pthread_mutex_t lock;
 
@@ -163,7 +163,7 @@ typedef struct _bufmgr_fake {
     * This allows the driver to hook in a replacement for the DRM usage in
     * bufmgr_fake.
     */
-   int (*exec)(dri_bo *bo, unsigned int used, void *priv);
+   int (*exec)(drm_intel_bo *bo, unsigned int used, void *priv);
    void *exec_priv;
 
    /** Driver-supplied argument to driver callbacks */
@@ -176,10 +176,10 @@ typedef struct _bufmgr_fake {
    int debug;
 
    int performed_rendering;
-} dri_bufmgr_fake;
+} drm_intel_bufmgr_fake;
 
-typedef struct _dri_bo_fake {
-   dri_bo bo;
+typedef struct _drm_intel_bo_fake {
+   drm_intel_bo bo;
 
    unsigned id;			/* debug only */
    const char *name;
@@ -214,11 +214,11 @@ typedef struct _dri_bo_fake {
 
    struct block *block;
    void *backing_store;
-   void (*invalidate_cb)(dri_bo *bo, void *ptr);
+   void (*invalidate_cb)(drm_intel_bo *bo, void *ptr);
    void *invalidate_ptr;
-} dri_bo_fake;
+} drm_intel_bo_fake;
 
-static int clear_fenced(dri_bufmgr_fake *bufmgr_fake,
+static int clear_fenced(drm_intel_bufmgr_fake *bufmgr_fake,
 			unsigned int fence_cookie);
 
 #define MAXFENCE 0x7fffffff
@@ -237,13 +237,13 @@ static int FENCE_LTE( unsigned a, unsigned b )
    return 0;
 }
 
-void intel_bufmgr_fake_set_fence_callback(dri_bufmgr *bufmgr,
-					  unsigned int (*emit)(void *priv),
-					  void (*wait)(unsigned int fence,
-						       void *priv),
-					  void *priv)
+void drm_intel_bufmgr_fake_set_fence_callback(drm_intel_bufmgr *bufmgr,
+					      unsigned int (*emit)(void *priv),
+					      void (*wait)(unsigned int fence,
+							   void *priv),
+					      void *priv)
 {
-   dri_bufmgr_fake *bufmgr_fake = (dri_bufmgr_fake *)bufmgr;
+   drm_intel_bufmgr_fake *bufmgr_fake = (drm_intel_bufmgr_fake *)bufmgr;
 
    bufmgr_fake->fence_emit = emit;
    bufmgr_fake->fence_wait = wait;
@@ -251,7 +251,7 @@ void intel_bufmgr_fake_set_fence_callback(dri_bufmgr *bufmgr,
 }
 
 static unsigned int
-_fence_emit_internal(dri_bufmgr_fake *bufmgr_fake)
+_fence_emit_internal(drm_intel_bufmgr_fake *bufmgr_fake)
 {
    struct drm_i915_irq_emit ie;
    int ret, seq = 1;
@@ -274,7 +274,7 @@ _fence_emit_internal(dri_bufmgr_fake *bufmgr_fake)
 }
 
 static void
-_fence_wait_internal(dri_bufmgr_fake *bufmgr_fake, int seq)
+_fence_wait_internal(drm_intel_bufmgr_fake *bufmgr_fake, int seq)
 {
    struct drm_i915_irq_wait iw;
    int hw_seq, busy_count = 0;
@@ -397,7 +397,7 @@ _fence_wait_internal(dri_bufmgr_fake *bufmgr_fake, int seq)
 }
 
 static int
-_fence_test(dri_bufmgr_fake *bufmgr_fake, unsigned fence)
+_fence_test(drm_intel_bufmgr_fake *bufmgr_fake, unsigned fence)
 {
    /* Slight problem with wrap-around:
     */
@@ -408,10 +408,10 @@ _fence_test(dri_bufmgr_fake *bufmgr_fake, unsigned fence)
  * Allocate a memory manager block for the buffer.
  */
 static int
-alloc_block(dri_bo *bo)
+alloc_block(drm_intel_bo *bo)
 {
-   dri_bo_fake *bo_fake = (dri_bo_fake *)bo;
-   dri_bufmgr_fake *bufmgr_fake= (dri_bufmgr_fake *)bo->bufmgr;
+   drm_intel_bo_fake *bo_fake = (drm_intel_bo_fake *)bo;
+   drm_intel_bufmgr_fake *bufmgr_fake= (drm_intel_bufmgr_fake *)bo->bufmgr;
    struct block *block = (struct block *)calloc(sizeof *block, 1);
    unsigned int align_log2 = ffs(bo_fake->alignment) - 1;
    unsigned int sz;
@@ -444,15 +444,15 @@ alloc_block(dri_bo *bo)
 
 /* Release the card storage associated with buf:
  */
-static void free_block(dri_bufmgr_fake *bufmgr_fake, struct block *block)
+static void free_block(drm_intel_bufmgr_fake *bufmgr_fake, struct block *block)
 {
-   dri_bo_fake *bo_fake;
+   drm_intel_bo_fake *bo_fake;
    DBG("free block %p %08x %d %d\n", block, block->mem->ofs, block->on_hardware, block->fenced);
 
    if (!block)
       return;
 
-   bo_fake = (dri_bo_fake *)block->bo;
+   bo_fake = (drm_intel_bo_fake *)block->bo;
    if (!(bo_fake->flags & (BM_PINNED | BM_NO_BACKING_STORE)) && (bo_fake->card_dirty == 1)) {
      memcpy(bo_fake->backing_store, block->virtual, block->bo->size);
      bo_fake->card_dirty = 0;
@@ -475,10 +475,10 @@ static void free_block(dri_bufmgr_fake *bufmgr_fake, struct block *block)
 }
 
 static void
-alloc_backing_store(dri_bo *bo)
+alloc_backing_store(drm_intel_bo *bo)
 {
-   dri_bufmgr_fake *bufmgr_fake = (dri_bufmgr_fake *)bo->bufmgr;
-   dri_bo_fake *bo_fake = (dri_bo_fake *)bo;
+   drm_intel_bufmgr_fake *bufmgr_fake = (drm_intel_bufmgr_fake *)bo->bufmgr;
+   drm_intel_bo_fake *bo_fake = (drm_intel_bo_fake *)bo;
    assert(!bo_fake->backing_store);
    assert(!(bo_fake->flags & (BM_PINNED|BM_NO_BACKING_STORE)));
 
@@ -489,9 +489,9 @@ alloc_backing_store(dri_bo *bo)
 }
 
 static void
-free_backing_store(dri_bo *bo)
+free_backing_store(drm_intel_bo *bo)
 {
-   dri_bo_fake *bo_fake = (dri_bo_fake *)bo;
+   drm_intel_bo_fake *bo_fake = (drm_intel_bo_fake *)bo;
 
    if (bo_fake->backing_store) {
       assert(!(bo_fake->flags & (BM_PINNED|BM_NO_BACKING_STORE)));
@@ -501,10 +501,10 @@ free_backing_store(dri_bo *bo)
 }
 
 static void
-set_dirty(dri_bo *bo)
+set_dirty(drm_intel_bo *bo)
 {
-   dri_bufmgr_fake *bufmgr_fake = (dri_bufmgr_fake *)bo->bufmgr;
-   dri_bo_fake *bo_fake = (dri_bo_fake *)bo;
+   drm_intel_bufmgr_fake *bufmgr_fake = (drm_intel_bufmgr_fake *)bo->bufmgr;
+   drm_intel_bo_fake *bo_fake = (drm_intel_bo_fake *)bo;
 
    if (bo_fake->flags & BM_NO_BACKING_STORE && bo_fake->invalidate_cb != NULL)
       bo_fake->invalidate_cb(bo, bo_fake->invalidate_ptr);
@@ -516,14 +516,14 @@ set_dirty(dri_bo *bo)
 }
 
 static int
-evict_lru(dri_bufmgr_fake *bufmgr_fake, unsigned int max_fence)
+evict_lru(drm_intel_bufmgr_fake *bufmgr_fake, unsigned int max_fence)
 {
    struct block *block, *tmp;
 
    DBG("%s\n", __FUNCTION__);
 
    DRMLISTFOREACHSAFE(block, tmp, &bufmgr_fake->lru) {
-      dri_bo_fake *bo_fake = (dri_bo_fake *)block->bo;
+      drm_intel_bo_fake *bo_fake = (drm_intel_bo_fake *)block->bo;
 
       if (bo_fake != NULL && (bo_fake->flags & BM_NO_FENCE_SUBDATA))
 	 continue;
@@ -542,14 +542,14 @@ evict_lru(dri_bufmgr_fake *bufmgr_fake, unsigned int max_fence)
 }
 
 static int
-evict_mru(dri_bufmgr_fake *bufmgr_fake)
+evict_mru(drm_intel_bufmgr_fake *bufmgr_fake)
 {
    struct block *block, *tmp;
 
    DBG("%s\n", __FUNCTION__);
 
    DRMLISTFOREACHSAFEREVERSE(block, tmp, &bufmgr_fake->lru) {
-      dri_bo_fake *bo_fake = (dri_bo_fake *)block->bo;
+      drm_intel_bo_fake *bo_fake = (drm_intel_bo_fake *)block->bo;
 
       if (bo_fake && (bo_fake->flags & BM_NO_FENCE_SUBDATA))
 	 continue;
@@ -567,7 +567,7 @@ evict_mru(dri_bufmgr_fake *bufmgr_fake)
 /**
  * Removes all objects from the fenced list older than the given fence.
  */
-static int clear_fenced(dri_bufmgr_fake *bufmgr_fake,
+static int clear_fenced(drm_intel_bufmgr_fake *bufmgr_fake,
 			unsigned int fence_cookie)
 {
    struct block *block, *tmp;
@@ -611,7 +611,7 @@ static int clear_fenced(dri_bufmgr_fake *bufmgr_fake,
    return ret;
 }
 
-static void fence_blocks(dri_bufmgr_fake *bufmgr_fake, unsigned fence)
+static void fence_blocks(drm_intel_bufmgr_fake *bufmgr_fake, unsigned fence)
 {
    struct block *block, *tmp;
 
@@ -632,10 +632,10 @@ static void fence_blocks(dri_bufmgr_fake *bufmgr_fake, unsigned fence)
    assert(DRMLISTEMPTY(&bufmgr_fake->on_hardware));
 }
 
-static int evict_and_alloc_block(dri_bo *bo)
+static int evict_and_alloc_block(drm_intel_bo *bo)
 {
-   dri_bufmgr_fake *bufmgr_fake = (dri_bufmgr_fake *)bo->bufmgr;
-   dri_bo_fake *bo_fake = (dri_bo_fake *)bo;
+   drm_intel_bufmgr_fake *bufmgr_fake = (drm_intel_bufmgr_fake *)bo->bufmgr;
+   drm_intel_bo_fake *bo_fake = (drm_intel_bo_fake *)bo;
 
    assert(bo_fake->block == NULL);
 
@@ -702,7 +702,7 @@ static int evict_and_alloc_block(dri_bo *bo)
  * Wait for hardware idle by emitting a fence and waiting for it.
  */
 static void
-dri_bufmgr_fake_wait_idle(dri_bufmgr_fake *bufmgr_fake)
+drm_intel_bufmgr_fake_wait_idle(drm_intel_bufmgr_fake *bufmgr_fake)
 {
    unsigned int cookie;
 
@@ -717,10 +717,10 @@ dri_bufmgr_fake_wait_idle(dri_bufmgr_fake *bufmgr_fake)
  * the necessary flushing.
  */
 static void
-dri_fake_bo_wait_rendering_locked(dri_bo *bo)
+drm_intel_fake_bo_wait_rendering_locked(drm_intel_bo *bo)
 {
-   dri_bufmgr_fake *bufmgr_fake = (dri_bufmgr_fake *)bo->bufmgr;
-   dri_bo_fake *bo_fake = (dri_bo_fake *)bo;
+   drm_intel_bufmgr_fake *bufmgr_fake = (drm_intel_bufmgr_fake *)bo->bufmgr;
+   drm_intel_bo_fake *bo_fake = (drm_intel_bo_fake *)bo;
 
    if (bo_fake->block == NULL || !bo_fake->block->fenced)
       return;
@@ -729,12 +729,12 @@ dri_fake_bo_wait_rendering_locked(dri_bo *bo)
 }
 
 static void
-dri_fake_bo_wait_rendering(dri_bo *bo)
+drm_intel_fake_bo_wait_rendering(drm_intel_bo *bo)
 {
-   dri_bufmgr_fake *bufmgr_fake = (dri_bufmgr_fake *)bo->bufmgr;
+   drm_intel_bufmgr_fake *bufmgr_fake = (drm_intel_bufmgr_fake *)bo->bufmgr;
 
    pthread_mutex_lock(&bufmgr_fake->lock);
-   dri_fake_bo_wait_rendering_locked(bo);
+   drm_intel_fake_bo_wait_rendering_locked(bo);
    pthread_mutex_unlock(&bufmgr_fake->lock);
 }
 
@@ -743,9 +743,9 @@ dri_fake_bo_wait_rendering(dri_bo *bo)
  *  -- and wait for idle
  */
 void
-intel_bufmgr_fake_contended_lock_take(dri_bufmgr *bufmgr)
+drm_intel_bufmgr_fake_contended_lock_take(drm_intel_bufmgr *bufmgr)
 {
-   dri_bufmgr_fake *bufmgr_fake = (dri_bufmgr_fake *)bufmgr;
+   drm_intel_bufmgr_fake *bufmgr_fake = (drm_intel_bufmgr_fake *)bufmgr;
    struct block *block, *tmp;
 
    pthread_mutex_lock(&bufmgr_fake->lock);
@@ -757,7 +757,7 @@ intel_bufmgr_fake_contended_lock_take(dri_bufmgr *bufmgr)
     * happening, so we'll need to wait anyway before letting anything get
     * put on the card again.
     */
-   dri_bufmgr_fake_wait_idle(bufmgr_fake);
+   drm_intel_bufmgr_fake_wait_idle(bufmgr_fake);
 
    /* Check that we hadn't released the lock without having fenced the last
     * set of buffers.
@@ -773,14 +773,14 @@ intel_bufmgr_fake_contended_lock_take(dri_bufmgr *bufmgr)
    pthread_mutex_unlock(&bufmgr_fake->lock);
 }
 
-static dri_bo *
-dri_fake_bo_alloc(dri_bufmgr *bufmgr, const char *name,
-		  unsigned long size, unsigned int alignment)
+static drm_intel_bo *
+drm_intel_fake_bo_alloc(drm_intel_bufmgr *bufmgr, const char *name,
+			unsigned long size, unsigned int alignment)
 {
-   dri_bufmgr_fake *bufmgr_fake;
-   dri_bo_fake *bo_fake;
+   drm_intel_bufmgr_fake *bufmgr_fake;
+   drm_intel_bo_fake *bo_fake;
 
-   bufmgr_fake = (dri_bufmgr_fake *)bufmgr;
+   bufmgr_fake = (drm_intel_bufmgr_fake *)bufmgr;
 
    assert(size != 0);
 
@@ -810,15 +810,15 @@ dri_fake_bo_alloc(dri_bufmgr *bufmgr, const char *name,
    return &bo_fake->bo;
 }
 
-dri_bo *
-intel_bo_fake_alloc_static(dri_bufmgr *bufmgr, const char *name,
-			   unsigned long offset, unsigned long size,
-			   void *virtual)
+drm_intel_bo *
+drm_intel_bo_fake_alloc_static(drm_intel_bufmgr *bufmgr, const char *name,
+			       unsigned long offset, unsigned long size,
+			       void *virtual)
 {
-   dri_bufmgr_fake *bufmgr_fake;
-   dri_bo_fake *bo_fake;
+   drm_intel_bufmgr_fake *bufmgr_fake;
+   drm_intel_bo_fake *bo_fake;
 
-   bufmgr_fake = (dri_bufmgr_fake *)bufmgr;
+   bufmgr_fake = (drm_intel_bufmgr_fake *)bufmgr;
 
    assert(size != 0);
 
@@ -843,10 +843,10 @@ intel_bo_fake_alloc_static(dri_bufmgr *bufmgr, const char *name,
 }
 
 static void
-dri_fake_bo_reference(dri_bo *bo)
+drm_intel_fake_bo_reference(drm_intel_bo *bo)
 {
-   dri_bufmgr_fake *bufmgr_fake = (dri_bufmgr_fake *)bo->bufmgr;
-   dri_bo_fake *bo_fake = (dri_bo_fake *)bo;
+   drm_intel_bufmgr_fake *bufmgr_fake = (drm_intel_bufmgr_fake *)bo->bufmgr;
+   drm_intel_bo_fake *bo_fake = (drm_intel_bo_fake *)bo;
 
    pthread_mutex_lock(&bufmgr_fake->lock);
    bo_fake->refcount++;
@@ -854,18 +854,18 @@ dri_fake_bo_reference(dri_bo *bo)
 }
 
 static void
-dri_fake_bo_reference_locked(dri_bo *bo)
+drm_intel_fake_bo_reference_locked(drm_intel_bo *bo)
 {
-   dri_bo_fake *bo_fake = (dri_bo_fake *)bo;
+   drm_intel_bo_fake *bo_fake = (drm_intel_bo_fake *)bo;
 
    bo_fake->refcount++;
 }
 
 static void
-dri_fake_bo_unreference_locked(dri_bo *bo)
+drm_intel_fake_bo_unreference_locked(drm_intel_bo *bo)
 {
-   dri_bufmgr_fake *bufmgr_fake = (dri_bufmgr_fake *)bo->bufmgr;
-   dri_bo_fake *bo_fake = (dri_bo_fake *)bo;
+   drm_intel_bufmgr_fake *bufmgr_fake = (drm_intel_bufmgr_fake *)bo->bufmgr;
+   drm_intel_bo_fake *bo_fake = (drm_intel_bo_fake *)bo;
    int i;
 
    if (--bo_fake->refcount == 0) {
@@ -876,7 +876,7 @@ dri_fake_bo_unreference_locked(dri_bo *bo)
       free_backing_store(bo);
 
       for (i = 0; i < bo_fake->nr_relocs; i++)
-	 dri_fake_bo_unreference_locked(bo_fake->relocs[i].target_buf);
+	 drm_intel_fake_bo_unreference_locked(bo_fake->relocs[i].target_buf);
 
       DBG("drm_bo_unreference: free buf %d %s\n", bo_fake->id, bo_fake->name);
 
@@ -886,12 +886,12 @@ dri_fake_bo_unreference_locked(dri_bo *bo)
 }
 
 static void
-dri_fake_bo_unreference(dri_bo *bo)
+drm_intel_fake_bo_unreference(drm_intel_bo *bo)
 {
-   dri_bufmgr_fake *bufmgr_fake = (dri_bufmgr_fake *)bo->bufmgr;
+   drm_intel_bufmgr_fake *bufmgr_fake = (drm_intel_bufmgr_fake *)bo->bufmgr;
 
    pthread_mutex_lock(&bufmgr_fake->lock);
-   dri_fake_bo_unreference_locked(bo);
+   drm_intel_fake_bo_unreference_locked(bo);
    pthread_mutex_unlock(&bufmgr_fake->lock);
 }
 
@@ -899,13 +899,13 @@ dri_fake_bo_unreference(dri_bo *bo)
  * Set the buffer as not requiring backing store, and instead get the callback
  * invoked whenever it would be set dirty.
  */
-void intel_bo_fake_disable_backing_store(dri_bo *bo,
-					 void (*invalidate_cb)(dri_bo *bo,
-							       void *ptr),
-					 void *ptr)
+void drm_intel_bo_fake_disable_backing_store(drm_intel_bo *bo,
+					     void (*invalidate_cb)(drm_intel_bo *bo,
+								   void *ptr),
+					     void *ptr)
 {
-   dri_bufmgr_fake *bufmgr_fake = (dri_bufmgr_fake *)bo->bufmgr;
-   dri_bo_fake *bo_fake = (dri_bo_fake *)bo;
+   drm_intel_bufmgr_fake *bufmgr_fake = (drm_intel_bufmgr_fake *)bo->bufmgr;
+   drm_intel_bo_fake *bo_fake = (drm_intel_bo_fake *)bo;
 
    pthread_mutex_lock(&bufmgr_fake->lock);
 
@@ -934,15 +934,15 @@ void intel_bo_fake_disable_backing_store(dri_bo *bo,
  * BM_NO_BACKING_STORE or BM_PINNED) or backing store, as necessary.
  */
 static int
-dri_fake_bo_map_locked(dri_bo *bo, int write_enable)
+drm_intel_fake_bo_map_locked(drm_intel_bo *bo, int write_enable)
 {
-   dri_bufmgr_fake *bufmgr_fake = (dri_bufmgr_fake *)bo->bufmgr;
-   dri_bo_fake *bo_fake = (dri_bo_fake *)bo;
+   drm_intel_bufmgr_fake *bufmgr_fake = (drm_intel_bufmgr_fake *)bo->bufmgr;
+   drm_intel_bo_fake *bo_fake = (drm_intel_bo_fake *)bo;
 
    /* Static buffers are always mapped. */
    if (bo_fake->is_static) {
       if (bo_fake->card_dirty) {
-         dri_bufmgr_fake_wait_idle(bufmgr_fake);
+         drm_intel_bufmgr_fake_wait_idle(bufmgr_fake);
          bo_fake->card_dirty = 0;
       }
       return 0;
@@ -976,7 +976,7 @@ dri_fake_bo_map_locked(dri_bo *bo, int write_enable)
 
 	    if (!(bo_fake->flags & BM_NO_FENCE_SUBDATA) &&
 		bo_fake->block->fenced) {
-	       dri_fake_bo_wait_rendering_locked(bo);
+	       drm_intel_fake_bo_wait_rendering_locked(bo);
 	    }
 
 	    bo->virtual = bo_fake->block->virtual;
@@ -991,7 +991,7 @@ dri_fake_bo_map_locked(dri_bo *bo, int write_enable)
 
          if ((bo_fake->card_dirty == 1) && bo_fake->block) {
             if (bo_fake->block->fenced)
-               dri_fake_bo_wait_rendering_locked(bo);
+               drm_intel_fake_bo_wait_rendering_locked(bo);
 
             memcpy(bo_fake->backing_store, bo_fake->block->virtual, bo_fake->block->bo->size);
             bo_fake->card_dirty = 0;
@@ -1005,23 +1005,23 @@ dri_fake_bo_map_locked(dri_bo *bo, int write_enable)
 }
 
 static int
-dri_fake_bo_map(dri_bo *bo, int write_enable)
+drm_intel_fake_bo_map(drm_intel_bo *bo, int write_enable)
 {
-   dri_bufmgr_fake *bufmgr_fake = (dri_bufmgr_fake *)bo->bufmgr;
+   drm_intel_bufmgr_fake *bufmgr_fake = (drm_intel_bufmgr_fake *)bo->bufmgr;
    int ret;
 
    pthread_mutex_lock(&bufmgr_fake->lock);
-   ret = dri_fake_bo_map_locked(bo, write_enable);
+   ret = drm_intel_fake_bo_map_locked(bo, write_enable);
    pthread_mutex_unlock(&bufmgr_fake->lock);
 
    return ret;
 }
 
 static int
-dri_fake_bo_unmap_locked(dri_bo *bo)
+drm_intel_fake_bo_unmap_locked(drm_intel_bo *bo)
 {
-   dri_bufmgr_fake *bufmgr_fake = (dri_bufmgr_fake *)bo->bufmgr;
-   dri_bo_fake *bo_fake = (dri_bo_fake *)bo;
+   drm_intel_bufmgr_fake *bufmgr_fake = (drm_intel_bufmgr_fake *)bo->bufmgr;
+   drm_intel_bo_fake *bo_fake = (drm_intel_bo_fake *)bo;
 
    /* Static buffers are always mapped. */
    if (bo_fake->is_static)
@@ -1040,20 +1040,20 @@ dri_fake_bo_unmap_locked(dri_bo *bo)
 }
 
 static int
-dri_fake_bo_unmap(dri_bo *bo)
+drm_intel_fake_bo_unmap(drm_intel_bo *bo)
 {
-   dri_bufmgr_fake *bufmgr_fake = (dri_bufmgr_fake *)bo->bufmgr;
+   drm_intel_bufmgr_fake *bufmgr_fake = (drm_intel_bufmgr_fake *)bo->bufmgr;
    int ret;
 
    pthread_mutex_lock(&bufmgr_fake->lock);
-   ret = dri_fake_bo_unmap_locked(bo);
+   ret = drm_intel_fake_bo_unmap_locked(bo);
    pthread_mutex_unlock(&bufmgr_fake->lock);
 
    return ret;
 }
 
 static void
-dri_fake_kick_all_locked(dri_bufmgr_fake *bufmgr_fake)
+drm_intel_fake_kick_all_locked(drm_intel_bufmgr_fake *bufmgr_fake)
 {
    struct block *block, *tmp;
 
@@ -1061,7 +1061,7 @@ dri_fake_kick_all_locked(dri_bufmgr_fake *bufmgr_fake)
    /* okay for ever BO that is on the HW kick it off.
       seriously not afraid of the POLICE right now */
    DRMLISTFOREACHSAFE(block, tmp, &bufmgr_fake->on_hardware) {
-      dri_bo_fake *bo_fake = (dri_bo_fake *)block->bo;
+      drm_intel_bo_fake *bo_fake = (drm_intel_bo_fake *)block->bo;
 
       block->on_hardware = 0;
       free_block(bufmgr_fake, block);
@@ -1074,12 +1074,12 @@ dri_fake_kick_all_locked(dri_bufmgr_fake *bufmgr_fake)
 }
 
 static int
-dri_fake_bo_validate(dri_bo *bo)
+drm_intel_fake_bo_validate(drm_intel_bo *bo)
 {
-   dri_bufmgr_fake *bufmgr_fake;
-   dri_bo_fake *bo_fake = (dri_bo_fake *)bo;
+   drm_intel_bufmgr_fake *bufmgr_fake;
+   drm_intel_bo_fake *bo_fake = (drm_intel_bo_fake *)bo;
 
-   bufmgr_fake = (dri_bufmgr_fake *)bo->bufmgr;
+   bufmgr_fake = (drm_intel_bufmgr_fake *)bo->bufmgr;
 
    DBG("drm_bo_validate: (buf %d: %s, %d kb)\n", bo_fake->id, bo_fake->name,
        bo_fake->bo.size / 1024);
@@ -1120,7 +1120,7 @@ dri_fake_bo_validate(dri_bo *bo)
        * which we would be tracking when we free it.  Waiting for idle is
        * a sufficiently large hammer for now.
        */
-      dri_bufmgr_fake_wait_idle(bufmgr_fake);
+      drm_intel_bufmgr_fake_wait_idle(bufmgr_fake);
 
       /* we may never have mapped this BO so it might not have any backing
        * store if this happens it should be rare, but 0 the card memory
@@ -1145,9 +1145,9 @@ dri_fake_bo_validate(dri_bo *bo)
 }
 
 static void
-dri_fake_fence_validated(dri_bufmgr *bufmgr)
+drm_intel_fake_fence_validated(drm_intel_bufmgr *bufmgr)
 {
-   dri_bufmgr_fake *bufmgr_fake = (dri_bufmgr_fake *)bufmgr;
+   drm_intel_bufmgr_fake *bufmgr_fake = (drm_intel_bufmgr_fake *)bufmgr;
    unsigned int cookie;
 
    cookie = _fence_emit_internal(bufmgr_fake);
@@ -1157,9 +1157,9 @@ dri_fake_fence_validated(dri_bufmgr *bufmgr)
 }
 
 static void
-dri_fake_destroy(dri_bufmgr *bufmgr)
+drm_intel_fake_destroy(drm_intel_bufmgr *bufmgr)
 {
-   dri_bufmgr_fake *bufmgr_fake = (dri_bufmgr_fake *)bufmgr;
+   drm_intel_bufmgr_fake *bufmgr_fake = (drm_intel_bufmgr_fake *)bufmgr;
 
    pthread_mutex_destroy(&bufmgr_fake->lock);
    mmDestroy(bufmgr_fake->heap);
@@ -1167,47 +1167,46 @@ dri_fake_destroy(dri_bufmgr *bufmgr)
 }
 
 static int
-dri_fake_emit_reloc(dri_bo *reloc_buf,
-		    uint32_t read_domains, uint32_t write_domain,
-		    uint32_t delta, uint32_t offset, dri_bo *target_buf)
+drm_intel_fake_emit_reloc(drm_intel_bo *bo, uint32_t offset,
+			  drm_intel_bo *target_bo, uint32_t target_offset,
+			  uint32_t read_domains, uint32_t write_domain)
 {
-   dri_bufmgr_fake *bufmgr_fake = (dri_bufmgr_fake *)reloc_buf->bufmgr;
+   drm_intel_bufmgr_fake *bufmgr_fake = (drm_intel_bufmgr_fake *)bo->bufmgr;
    struct fake_buffer_reloc *r;
-   dri_bo_fake *reloc_fake = (dri_bo_fake *)reloc_buf;
-   dri_bo_fake *target_fake = (dri_bo_fake *)target_buf;
+   drm_intel_bo_fake *bo_fake = (drm_intel_bo_fake *)bo;
+   drm_intel_bo_fake *target_fake = (drm_intel_bo_fake *)target_bo;
    int i;
 
    pthread_mutex_lock(&bufmgr_fake->lock);
 
-   assert(reloc_buf);
-   assert(target_buf);
+   assert(bo);
+   assert(target_bo);
 
-   if (reloc_fake->relocs == NULL) {
-      reloc_fake->relocs = malloc(sizeof(struct fake_buffer_reloc) *
-				  MAX_RELOCS);
+   if (bo_fake->relocs == NULL) {
+      bo_fake->relocs = malloc(sizeof(struct fake_buffer_reloc) * MAX_RELOCS);
    }
 
-   r = &reloc_fake->relocs[reloc_fake->nr_relocs++];
+   r = &bo_fake->relocs[bo_fake->nr_relocs++];
 
-   assert(reloc_fake->nr_relocs <= MAX_RELOCS);
+   assert(bo_fake->nr_relocs <= MAX_RELOCS);
 
-   dri_fake_bo_reference_locked(target_buf);
+   drm_intel_fake_bo_reference_locked(target_bo);
 
    if (!target_fake->is_static) {
-      reloc_fake->child_size += ALIGN(target_buf->size, target_fake->alignment);
-      reloc_fake->child_size += target_fake->child_size;
+      bo_fake->child_size += ALIGN(target_bo->size, target_fake->alignment);
+      bo_fake->child_size += target_fake->child_size;
    }
-   r->target_buf = target_buf;
+   r->target_buf = target_bo;
    r->offset = offset;
-   r->last_target_offset = target_buf->offset;
-   r->delta = delta;
+   r->last_target_offset = target_bo->offset;
+   r->delta = target_offset;
    r->read_domains = read_domains;
    r->write_domain = write_domain;
 
    if (bufmgr_fake->debug) {
       /* Check that a conflicting relocation hasn't already been emitted. */
-      for (i = 0; i < reloc_fake->nr_relocs - 1; i++) {
-	 struct fake_buffer_reloc *r2 = &reloc_fake->relocs[i];
+      for (i = 0; i < bo_fake->nr_relocs - 1; i++) {
+	 struct fake_buffer_reloc *r2 = &bo_fake->relocs[i];
 
 	 assert(r->offset != r2->offset);
       }
@@ -1223,17 +1222,17 @@ dri_fake_emit_reloc(dri_bo *reloc_buf,
  * the combined validation flags for the buffer on this batchbuffer submission.
  */
 static void
-dri_fake_calculate_domains(dri_bo *bo)
+drm_intel_fake_calculate_domains(drm_intel_bo *bo)
 {
-   dri_bo_fake *bo_fake = (dri_bo_fake *)bo;
+   drm_intel_bo_fake *bo_fake = (drm_intel_bo_fake *)bo;
    int i;
 
    for (i = 0; i < bo_fake->nr_relocs; i++) {
       struct fake_buffer_reloc *r = &bo_fake->relocs[i];
-      dri_bo_fake *target_fake = (dri_bo_fake *)r->target_buf;
+      drm_intel_bo_fake *target_fake = (drm_intel_bo_fake *)r->target_buf;
 
       /* Do the same for the tree of buffers we depend on */
-      dri_fake_calculate_domains(r->target_buf);
+      drm_intel_fake_calculate_domains(r->target_buf);
 
       target_fake->read_domains |= r->read_domains;
       target_fake->write_domain |= r->write_domain;
@@ -1242,25 +1241,25 @@ dri_fake_calculate_domains(dri_bo *bo)
 
 
 static int
-dri_fake_reloc_and_validate_buffer(dri_bo *bo)
+drm_intel_fake_reloc_and_validate_buffer(drm_intel_bo *bo)
 {
-   dri_bufmgr_fake *bufmgr_fake = (dri_bufmgr_fake *)bo->bufmgr;
-   dri_bo_fake *bo_fake = (dri_bo_fake *)bo;
+   drm_intel_bufmgr_fake *bufmgr_fake = (drm_intel_bufmgr_fake *)bo->bufmgr;
+   drm_intel_bo_fake *bo_fake = (drm_intel_bo_fake *)bo;
    int i, ret;
 
    assert(bo_fake->map_count == 0);
 
    for (i = 0; i < bo_fake->nr_relocs; i++) {
       struct fake_buffer_reloc *r = &bo_fake->relocs[i];
-      dri_bo_fake *target_fake = (dri_bo_fake *)r->target_buf;
+      drm_intel_bo_fake *target_fake = (drm_intel_bo_fake *)r->target_buf;
       uint32_t reloc_data;
 
       /* Validate the target buffer if that hasn't been done. */
       if (!target_fake->validated) {
-         ret = dri_fake_reloc_and_validate_buffer(r->target_buf);
+         ret = drm_intel_fake_reloc_and_validate_buffer(r->target_buf);
          if (ret != 0) {
             if (bo->virtual != NULL)
-                dri_fake_bo_unmap_locked(bo);
+                drm_intel_fake_bo_unmap_locked(bo);
             return ret;
          }
       }
@@ -1270,7 +1269,7 @@ dri_fake_reloc_and_validate_buffer(dri_bo *bo)
 	 reloc_data = r->target_buf->offset + r->delta;
 
 	 if (bo->virtual == NULL)
-	    dri_fake_bo_map_locked(bo, 1);
+	    drm_intel_fake_bo_map_locked(bo, 1);
 
 	 *(uint32_t *)((uint8_t *)bo->virtual + r->offset) = reloc_data;
 
@@ -1279,7 +1278,7 @@ dri_fake_reloc_and_validate_buffer(dri_bo *bo)
    }
 
    if (bo->virtual != NULL)
-      dri_fake_bo_unmap_locked(bo);
+      drm_intel_fake_bo_unmap_locked(bo);
 
    if (bo_fake->write_domain != 0) {
       if (!(bo_fake->flags & (BM_NO_BACKING_STORE|BM_PINNED))) {
@@ -1290,22 +1289,22 @@ dri_fake_reloc_and_validate_buffer(dri_bo *bo)
       bufmgr_fake->performed_rendering = 1;
    }
 
-   return dri_fake_bo_validate(bo);
+   return drm_intel_fake_bo_validate(bo);
 }
 
 static void
-dri_bo_fake_post_submit(dri_bo *bo)
+drm_intel_bo_fake_post_submit(drm_intel_bo *bo)
 {
-   dri_bufmgr_fake *bufmgr_fake = (dri_bufmgr_fake *)bo->bufmgr;
-   dri_bo_fake *bo_fake = (dri_bo_fake *)bo;
+   drm_intel_bufmgr_fake *bufmgr_fake = (drm_intel_bufmgr_fake *)bo->bufmgr;
+   drm_intel_bo_fake *bo_fake = (drm_intel_bo_fake *)bo;
    int i;
 
    for (i = 0; i < bo_fake->nr_relocs; i++) {
       struct fake_buffer_reloc *r = &bo_fake->relocs[i];
-      dri_bo_fake *target_fake = (dri_bo_fake *)r->target_buf;
+      drm_intel_bo_fake *target_fake = (drm_intel_bo_fake *)r->target_buf;
 
       if (target_fake->validated)
-	 dri_bo_fake_post_submit(r->target_buf);
+	 drm_intel_bo_fake_post_submit(r->target_buf);
 
       DBG("%s@0x%08x + 0x%08x -> %s@0x%08x + 0x%08x\n",
 	  bo_fake->name, (uint32_t)bo->offset, r->offset,
@@ -1319,25 +1318,25 @@ dri_bo_fake_post_submit(dri_bo *bo)
 }
 
 
-void intel_bufmgr_fake_set_exec_callback(dri_bufmgr *bufmgr,
-					 int (*exec)(dri_bo *bo,
-						     unsigned int used,
-						     void *priv),
-					 void *priv)
+void drm_intel_bufmgr_fake_set_exec_callback(drm_intel_bufmgr *bufmgr,
+					     int (*exec)(drm_intel_bo *bo,
+							 unsigned int used,
+							 void *priv),
+					     void *priv)
 {
-   dri_bufmgr_fake *bufmgr_fake = (dri_bufmgr_fake *)bufmgr;
+   drm_intel_bufmgr_fake *bufmgr_fake = (drm_intel_bufmgr_fake *)bufmgr;
 
    bufmgr_fake->exec = exec;
    bufmgr_fake->exec_priv = priv;
 }
 
 static int
-dri_fake_bo_exec(dri_bo *bo, int used,
-		 drm_clip_rect_t *cliprects, int num_cliprects,
-		 int DR4)
+drm_intel_fake_bo_exec(drm_intel_bo *bo, int used,
+		       drm_clip_rect_t *cliprects, int num_cliprects,
+		       int DR4)
 {
-   dri_bufmgr_fake *bufmgr_fake = (dri_bufmgr_fake *)bo->bufmgr;
-   dri_bo_fake *batch_fake = (dri_bo_fake *)bo;
+   drm_intel_bufmgr_fake *bufmgr_fake = (drm_intel_bufmgr_fake *)bo->bufmgr;
+   drm_intel_bo_fake *batch_fake = (drm_intel_bo_fake *)bo;
    struct drm_i915_batchbuffer batch;
    int ret;
    int retry_count = 0;
@@ -1346,17 +1345,17 @@ dri_fake_bo_exec(dri_bo *bo, int used,
 
    bufmgr_fake->performed_rendering = 0;
 
-   dri_fake_calculate_domains(bo);
+   drm_intel_fake_calculate_domains(bo);
 
    batch_fake->read_domains = I915_GEM_DOMAIN_COMMAND;
 
    /* we've ran out of RAM so blow the whole lot away and retry */
  restart:
-   ret = dri_fake_reloc_and_validate_buffer(bo);
+   ret = drm_intel_fake_reloc_and_validate_buffer(bo);
    if (bufmgr_fake->fail == 1) {
       if (retry_count == 0) {
          retry_count++;
-         dri_fake_kick_all_locked(bufmgr_fake);
+         drm_intel_fake_kick_all_locked(bufmgr_fake);
          bufmgr_fake->fail = 0;
          goto restart;
       } else /* dump out the memory here */
@@ -1387,9 +1386,9 @@ dri_fake_bo_exec(dri_bo *bo, int used,
       }
    }
 
-   dri_fake_fence_validated(bo->bufmgr);
+   drm_intel_fake_fence_validated(bo->bufmgr);
 
-   dri_bo_fake_post_submit(bo);
+   drm_intel_bo_fake_post_submit(bo);
 
    pthread_mutex_unlock(&bufmgr_fake->lock);
 
@@ -1404,14 +1403,14 @@ dri_fake_bo_exec(dri_bo *bo, int used,
  * a set smaller than the aperture.
  */
 static int
-dri_fake_check_aperture_space(dri_bo **bo_array, int count)
+drm_intel_fake_check_aperture_space(drm_intel_bo **bo_array, int count)
 {
-   dri_bufmgr_fake *bufmgr_fake = (dri_bufmgr_fake *)bo_array[0]->bufmgr;
+   drm_intel_bufmgr_fake *bufmgr_fake = (drm_intel_bufmgr_fake *)bo_array[0]->bufmgr;
    unsigned int sz = 0;
    int i;
 
    for (i = 0; i < count; i++) {
-      dri_bo_fake *bo_fake = (dri_bo_fake *)bo_array[i];
+      drm_intel_bo_fake *bo_fake = (drm_intel_bo_fake *)bo_array[i];
 
       if (bo_fake == NULL)
 	 continue;
@@ -1440,9 +1439,9 @@ dri_fake_check_aperture_space(dri_bo **bo_array, int count)
  * own.
  */
 void
-intel_bufmgr_fake_evict_all(dri_bufmgr *bufmgr)
+drm_intel_bufmgr_fake_evict_all(drm_intel_bufmgr *bufmgr)
 {
-   dri_bufmgr_fake *bufmgr_fake = (dri_bufmgr_fake *)bufmgr;
+   drm_intel_bufmgr_fake *bufmgr_fake = (drm_intel_bufmgr_fake *)bufmgr;
    struct block *block, *tmp;
 
    pthread_mutex_lock(&bufmgr_fake->lock);
@@ -1454,7 +1453,7 @@ intel_bufmgr_fake_evict_all(dri_bufmgr *bufmgr)
     * happening, so we'll need to wait anyway before letting anything get
     * put on the card again.
     */
-   dri_bufmgr_fake_wait_idle(bufmgr_fake);
+   drm_intel_bufmgr_fake_wait_idle(bufmgr_fake);
 
    /* Check that we hadn't released the lock without having fenced the last
     * set of buffers.
@@ -1469,21 +1468,21 @@ intel_bufmgr_fake_evict_all(dri_bufmgr *bufmgr)
 
    pthread_mutex_unlock(&bufmgr_fake->lock);
 }
-void intel_bufmgr_fake_set_last_dispatch(dri_bufmgr *bufmgr,
+void drm_intel_bufmgr_fake_set_last_dispatch(drm_intel_bufmgr *bufmgr,
 					 volatile unsigned int *last_dispatch)
 {
-   dri_bufmgr_fake *bufmgr_fake = (dri_bufmgr_fake *)bufmgr;
+   drm_intel_bufmgr_fake *bufmgr_fake = (drm_intel_bufmgr_fake *)bufmgr;
 
    bufmgr_fake->last_dispatch = (volatile int *)last_dispatch;
 }
 
-dri_bufmgr *
-intel_bufmgr_fake_init(int fd,
+drm_intel_bufmgr *
+drm_intel_bufmgr_fake_init(int fd,
 		       unsigned long low_offset, void *low_virtual,
 		       unsigned long size,
 		       volatile unsigned int *last_dispatch)
 {
-   dri_bufmgr_fake *bufmgr_fake;
+   drm_intel_bufmgr_fake *bufmgr_fake;
 
    bufmgr_fake = calloc(1, sizeof(*bufmgr_fake));
 
@@ -1503,16 +1502,16 @@ intel_bufmgr_fake_init(int fd,
    bufmgr_fake->heap = mmInit(low_offset, size);
 
    /* Hook in methods */
-   bufmgr_fake->bufmgr.bo_alloc = dri_fake_bo_alloc;
-   bufmgr_fake->bufmgr.bo_reference = dri_fake_bo_reference;
-   bufmgr_fake->bufmgr.bo_unreference = dri_fake_bo_unreference;
-   bufmgr_fake->bufmgr.bo_map = dri_fake_bo_map;
-   bufmgr_fake->bufmgr.bo_unmap = dri_fake_bo_unmap;
-   bufmgr_fake->bufmgr.bo_wait_rendering = dri_fake_bo_wait_rendering;
-   bufmgr_fake->bufmgr.bo_emit_reloc = dri_fake_emit_reloc;
-   bufmgr_fake->bufmgr.destroy = dri_fake_destroy;
-   bufmgr_fake->bufmgr.bo_exec = dri_fake_bo_exec;
-   bufmgr_fake->bufmgr.check_aperture_space = dri_fake_check_aperture_space;
+   bufmgr_fake->bufmgr.bo_alloc = drm_intel_fake_bo_alloc;
+   bufmgr_fake->bufmgr.bo_reference = drm_intel_fake_bo_reference;
+   bufmgr_fake->bufmgr.bo_unreference = drm_intel_fake_bo_unreference;
+   bufmgr_fake->bufmgr.bo_map = drm_intel_fake_bo_map;
+   bufmgr_fake->bufmgr.bo_unmap = drm_intel_fake_bo_unmap;
+   bufmgr_fake->bufmgr.bo_wait_rendering = drm_intel_fake_bo_wait_rendering;
+   bufmgr_fake->bufmgr.bo_emit_reloc = drm_intel_fake_emit_reloc;
+   bufmgr_fake->bufmgr.destroy = drm_intel_fake_destroy;
+   bufmgr_fake->bufmgr.bo_exec = drm_intel_fake_bo_exec;
+   bufmgr_fake->bufmgr.check_aperture_space = drm_intel_fake_check_aperture_space;
    bufmgr_fake->bufmgr.debug = 0;
 
    bufmgr_fake->fd = fd;
diff --git a/libdrm/intel/intel_bufmgr_gem.c b/libdrm/intel/intel_bufmgr_gem.c
index dd74659a..5eaf5f5a 100644
--- a/libdrm/intel/intel_bufmgr_gem.c
+++ b/libdrm/intel/intel_bufmgr_gem.c
@@ -60,10 +60,10 @@
       fprintf(stderr, __VA_ARGS__);			\
 } while (0)
 
-typedef struct _dri_bo_gem dri_bo_gem;
+typedef struct _drm_intel_bo_gem drm_intel_bo_gem;
 
-struct dri_gem_bo_bucket {
-   dri_bo_gem *head, **tail;
+struct drm_intel_gem_bo_bucket {
+   drm_intel_bo_gem *head, **tail;
    /**
     * Limit on the number of entries in this bucket.
     *
@@ -77,9 +77,9 @@ struct dri_gem_bo_bucket {
 /* Arbitrarily chosen, 16 means that the maximum size we'll cache for reuse
  * is 1 << 16 pages, or 256MB.
  */
-#define INTEL_GEM_BO_BUCKETS	16
-typedef struct _dri_bufmgr_gem {
-    dri_bufmgr bufmgr;
+#define DRM_INTEL_GEM_BO_BUCKETS	16
+typedef struct _drm_intel_bufmgr_gem {
+    drm_intel_bufmgr bufmgr;
 
     int fd;
 
@@ -88,18 +88,18 @@ typedef struct _dri_bufmgr_gem {
     pthread_mutex_t lock;
 
     struct drm_i915_gem_exec_object *exec_objects;
-    dri_bo **exec_bos;
+    drm_intel_bo **exec_bos;
     int exec_size;
     int exec_count;
 
     /** Array of lists of cached gem objects of power-of-two sizes */
-    struct dri_gem_bo_bucket cache_bucket[INTEL_GEM_BO_BUCKETS];
+    struct drm_intel_gem_bo_bucket cache_bucket[DRM_INTEL_GEM_BO_BUCKETS];
 
     uint64_t gtt_size;
-} dri_bufmgr_gem;
+} drm_intel_bufmgr_gem;
 
-struct _dri_bo_gem {
-    dri_bo bo;
+struct _drm_intel_bo_gem {
+    drm_intel_bo bo;
 
     int refcount;
     /** Boolean whether the mmap ioctl has been called for this buffer yet. */
@@ -128,18 +128,18 @@ struct _dri_bo_gem {
     /** Array passed to the DRM containing relocation information. */
     struct drm_i915_gem_relocation_entry *relocs;
     /** Array of bos corresponding to relocs[i].target_handle */
-    dri_bo **reloc_target_bo;
+    drm_intel_bo **reloc_target_bo;
     /** Number of entries in relocs */
     int reloc_count;
     /** Mapped address for the buffer */
     void *virtual;
 
     /** free list */
-    dri_bo_gem *next;
+    drm_intel_bo_gem *next;
 
     /**
      * Boolean of whether this BO and its children have been included in
-     * the current dri_bufmgr_check_aperture_space() total.
+     * the current drm_intel_bufmgr_check_aperture_space() total.
      */
     char included_in_check_aperture;
 
@@ -153,13 +153,13 @@ struct _dri_bo_gem {
     /**
      * Size in bytes of this buffer and its relocation descendents.
      *
-     * Used to avoid costly tree walking in dri_bufmgr_check_aperture in
+     * Used to avoid costly tree walking in drm_intel_bufmgr_check_aperture in
      * the common case.
      */
     int reloc_tree_size;
 };
 
-static void dri_gem_bo_reference_locked(dri_bo *bo);
+static void drm_intel_gem_bo_reference_locked(drm_intel_bo *bo);
 
 static int
 logbase2(int n)
@@ -175,8 +175,9 @@ logbase2(int n)
    return log2;
 }
 
-static struct dri_gem_bo_bucket *
-dri_gem_bo_bucket_for_size(dri_bufmgr_gem *bufmgr_gem, unsigned long size)
+static struct drm_intel_gem_bo_bucket *
+drm_intel_gem_bo_bucket_for_size(drm_intel_bufmgr_gem *bufmgr_gem,
+				 unsigned long size)
 {
     int i;
 
@@ -189,20 +190,20 @@ dri_gem_bo_bucket_for_size(dri_bufmgr_gem *bufmgr_gem, unsigned long size)
 
     /* We always allocate in units of pages */
     i = ffs(size / 4096) - 1;
-    if (i >= INTEL_GEM_BO_BUCKETS)
+    if (i >= DRM_INTEL_GEM_BO_BUCKETS)
 	return NULL;
 
     return &bufmgr_gem->cache_bucket[i];
 }
 
 
-static void dri_gem_dump_validation_list(dri_bufmgr_gem *bufmgr_gem)
+static void drm_intel_gem_dump_validation_list(drm_intel_bufmgr_gem *bufmgr_gem)
 {
     int i, j;
 
     for (i = 0; i < bufmgr_gem->exec_count; i++) {
-	dri_bo *bo = bufmgr_gem->exec_bos[i];
-	dri_bo_gem *bo_gem = (dri_bo_gem *)bo;
+	drm_intel_bo *bo = bufmgr_gem->exec_bos[i];
+	drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
 
 	if (bo_gem->relocs == NULL) {
 	    DBG("%2d: %d (%s)\n", i, bo_gem->gem_handle, bo_gem->name);
@@ -210,8 +211,8 @@ static void dri_gem_dump_validation_list(dri_bufmgr_gem *bufmgr_gem)
 	}
 
 	for (j = 0; j < bo_gem->reloc_count; j++) {
-	    dri_bo *target_bo = bo_gem->reloc_target_bo[j];
-	    dri_bo_gem *target_gem = (dri_bo_gem *)target_bo;
+	    drm_intel_bo *target_bo = bo_gem->reloc_target_bo[j];
+	    drm_intel_bo_gem *target_gem = (drm_intel_bo_gem *)target_bo;
 
 	    DBG("%2d: %d (%s)@0x%08llx -> %d (%s)@0x%08lx + 0x%08x\n",
 		i,
@@ -231,10 +232,10 @@ static void dri_gem_dump_validation_list(dri_bufmgr_gem *bufmgr_gem)
  * access flags.
  */
 static void
-intel_add_validate_buffer(dri_bo *bo)
+drm_intel_add_validate_buffer(drm_intel_bo *bo)
 {
-    dri_bufmgr_gem *bufmgr_gem = (dri_bufmgr_gem *)bo->bufmgr;
-    dri_bo_gem *bo_gem = (dri_bo_gem *)bo;
+    drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr;
+    drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
     int index;
 
     if (bo_gem->validate_index != -1)
@@ -265,7 +266,7 @@ intel_add_validate_buffer(dri_bo *bo)
     bufmgr_gem->exec_objects[index].alignment = 0;
     bufmgr_gem->exec_objects[index].offset = 0;
     bufmgr_gem->exec_bos[index] = bo;
-    dri_gem_bo_reference_locked(bo);
+    drm_intel_gem_bo_reference_locked(bo);
     bufmgr_gem->exec_count++;
 }
 
@@ -274,27 +275,28 @@ intel_add_validate_buffer(dri_bo *bo)
 	sizeof(uint32_t))
 
 static int
-intel_setup_reloc_list(dri_bo *bo)
+drm_intel_setup_reloc_list(drm_intel_bo *bo)
 {
-    dri_bo_gem *bo_gem = (dri_bo_gem *)bo;
-    dri_bufmgr_gem *bufmgr_gem = (dri_bufmgr_gem *)bo->bufmgr;
+    drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
+    drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr;
 
     bo_gem->relocs = malloc(bufmgr_gem->max_relocs *
 			    sizeof(struct drm_i915_gem_relocation_entry));
-    bo_gem->reloc_target_bo = malloc(bufmgr_gem->max_relocs * sizeof(dri_bo *));
+    bo_gem->reloc_target_bo = malloc(bufmgr_gem->max_relocs *
+				     sizeof(drm_intel_bo *));
 
     return 0;
 }
 
-static dri_bo *
-dri_gem_bo_alloc(dri_bufmgr *bufmgr, const char *name,
-		 unsigned long size, unsigned int alignment)
+static drm_intel_bo *
+drm_intel_gem_bo_alloc(drm_intel_bufmgr *bufmgr, const char *name,
+		   unsigned long size, unsigned int alignment)
 {
-    dri_bufmgr_gem *bufmgr_gem = (dri_bufmgr_gem *)bufmgr;
-    dri_bo_gem *bo_gem;
+    drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bufmgr;
+    drm_intel_bo_gem *bo_gem;
     unsigned int page_size = getpagesize();
     int ret;
-    struct dri_gem_bo_bucket *bucket;
+    struct drm_intel_gem_bo_bucket *bucket;
     int alloc_from_cache = 0;
     unsigned long bo_size;
 
@@ -302,7 +304,7 @@ dri_gem_bo_alloc(dri_bufmgr *bufmgr, const char *name,
     bo_size = 1 << logbase2(size);
     if (bo_size < page_size)
 	bo_size = page_size;
-    bucket = dri_gem_bo_bucket_for_size(bufmgr_gem, bo_size);
+    bucket = drm_intel_gem_bo_bucket_for_size(bufmgr_gem, bo_size);
 
     /* If we don't have caching at this size, don't actually round the
      * allocation up.
@@ -366,17 +368,17 @@ dri_gem_bo_alloc(dri_bufmgr *bufmgr, const char *name,
 }
 
 /**
- * Returns a dri_bo wrapping the given buffer object handle.
+ * Returns a drm_intel_bo wrapping the given buffer object handle.
  *
  * This can be used when one application needs to pass a buffer object
  * to another.
  */
-dri_bo *
-intel_bo_gem_create_from_name(dri_bufmgr *bufmgr, const char *name,
-			      unsigned int handle)
+drm_intel_bo *
+drm_intel_bo_gem_create_from_name(drm_intel_bufmgr *bufmgr, const char *name,
+				  unsigned int handle)
 {
-    dri_bufmgr_gem *bufmgr_gem = (dri_bufmgr_gem *)bufmgr;
-    dri_bo_gem *bo_gem;
+    drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bufmgr;
+    drm_intel_bo_gem *bo_gem;
     int ret;
     struct drm_gem_open open_arg;
 
@@ -409,10 +411,10 @@ intel_bo_gem_create_from_name(dri_bufmgr *bufmgr, const char *name,
 }
 
 static void
-dri_gem_bo_reference(dri_bo *bo)
+drm_intel_gem_bo_reference(drm_intel_bo *bo)
 {
-    dri_bufmgr_gem *bufmgr_gem = (dri_bufmgr_gem *)bo->bufmgr;
-    dri_bo_gem *bo_gem = (dri_bo_gem *)bo;
+    drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr;
+    drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
 
     pthread_mutex_lock(&bufmgr_gem->lock);
     bo_gem->refcount++;
@@ -420,18 +422,18 @@ dri_gem_bo_reference(dri_bo *bo)
 }
 
 static void
-dri_gem_bo_reference_locked(dri_bo *bo)
+drm_intel_gem_bo_reference_locked(drm_intel_bo *bo)
 {
-    dri_bo_gem *bo_gem = (dri_bo_gem *)bo;
+    drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
 
     bo_gem->refcount++;
 }
 
 static void
-dri_gem_bo_free(dri_bo *bo)
+drm_intel_gem_bo_free(drm_intel_bo *bo)
 {
-    dri_bufmgr_gem *bufmgr_gem = (dri_bufmgr_gem *)bo->bufmgr;
-    dri_bo_gem *bo_gem = (dri_bo_gem *)bo;
+    drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr;
+    drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
     struct drm_gem_close close;
     int ret;
 
@@ -450,20 +452,20 @@ dri_gem_bo_free(dri_bo *bo)
 }
 
 static void
-dri_gem_bo_unreference_locked(dri_bo *bo)
+drm_intel_gem_bo_unreference_locked(drm_intel_bo *bo)
 {
-    dri_bufmgr_gem *bufmgr_gem = (dri_bufmgr_gem *)bo->bufmgr;
-    dri_bo_gem *bo_gem = (dri_bo_gem *)bo;
+    drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr;
+    drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
 
     if (--bo_gem->refcount == 0) {
-	struct dri_gem_bo_bucket *bucket;
+	struct drm_intel_gem_bo_bucket *bucket;
 
 	if (bo_gem->relocs != NULL) {
 	    int i;
 
 	    /* Unreference all the target buffers */
 	    for (i = 0; i < bo_gem->reloc_count; i++)
-		 dri_gem_bo_unreference_locked(bo_gem->reloc_target_bo[i]);
+		 drm_intel_gem_bo_unreference_locked(bo_gem->reloc_target_bo[i]);
 	    free(bo_gem->reloc_target_bo);
 	    free(bo_gem->relocs);
 	}
@@ -471,7 +473,7 @@ dri_gem_bo_unreference_locked(dri_bo *bo)
 	DBG("bo_unreference final: %d (%s)\n",
 	    bo_gem->gem_handle, bo_gem->name);
 
-	bucket = dri_gem_bo_bucket_for_size(bufmgr_gem, bo->size);
+	bucket = drm_intel_gem_bo_bucket_for_size(bufmgr_gem, bo->size);
 	/* Put the buffer into our internal cache for reuse if we can. */
 	if (bucket != NULL &&
 	    (bucket->max_entries == -1 ||
@@ -489,26 +491,26 @@ dri_gem_bo_unreference_locked(dri_bo *bo)
 	    bucket->tail = &bo_gem->next;
 	    bucket->num_entries++;
 	} else {
-	    dri_gem_bo_free(bo);
+	    drm_intel_gem_bo_free(bo);
 	}
     }
 }
 
 static void
-dri_gem_bo_unreference(dri_bo *bo)
+drm_intel_gem_bo_unreference(drm_intel_bo *bo)
 {
-    dri_bufmgr_gem *bufmgr_gem = (dri_bufmgr_gem *)bo->bufmgr;
+    drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr;
 
     pthread_mutex_lock(&bufmgr_gem->lock);
-    dri_gem_bo_unreference_locked(bo);
+    drm_intel_gem_bo_unreference_locked(bo);
     pthread_mutex_unlock(&bufmgr_gem->lock);
 }
 
 static int
-dri_gem_bo_map(dri_bo *bo, int write_enable)
+drm_intel_gem_bo_map(drm_intel_bo *bo, int write_enable)
 {
-    dri_bufmgr_gem *bufmgr_gem = (dri_bufmgr_gem *)bo->bufmgr;
-    dri_bo_gem *bo_gem = (dri_bo_gem *)bo;
+    drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr;
+    drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
     struct drm_i915_gem_set_domain set_domain;
     int ret;
 
@@ -568,10 +570,10 @@ dri_gem_bo_map(dri_bo *bo, int write_enable)
 }
 
 static int
-dri_gem_bo_unmap(dri_bo *bo)
+drm_intel_gem_bo_unmap(drm_intel_bo *bo)
 {
-    dri_bufmgr_gem *bufmgr_gem = (dri_bufmgr_gem *)bo->bufmgr;
-    dri_bo_gem *bo_gem = (dri_bo_gem *)bo;
+    drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr;
+    drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
     struct drm_i915_gem_sw_finish sw_finish;
     int ret;
 
@@ -594,11 +596,11 @@ dri_gem_bo_unmap(dri_bo *bo)
 }
 
 static int
-dri_gem_bo_subdata (dri_bo *bo, unsigned long offset,
-		    unsigned long size, const void *data)
+drm_intel_gem_bo_subdata (drm_intel_bo *bo, unsigned long offset,
+			  unsigned long size, const void *data)
 {
-    dri_bufmgr_gem *bufmgr_gem = (dri_bufmgr_gem *)bo->bufmgr;
-    dri_bo_gem *bo_gem = (dri_bo_gem *)bo;
+    drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr;
+    drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
     struct drm_i915_gem_pwrite pwrite;
     int ret;
 
@@ -620,11 +622,11 @@ dri_gem_bo_subdata (dri_bo *bo, unsigned long offset,
 }
 
 static int
-dri_gem_bo_get_subdata (dri_bo *bo, unsigned long offset,
-			unsigned long size, void *data)
+drm_intel_gem_bo_get_subdata (drm_intel_bo *bo, unsigned long offset,
+			      unsigned long size, void *data)
 {
-    dri_bufmgr_gem *bufmgr_gem = (dri_bufmgr_gem *)bo->bufmgr;
-    dri_bo_gem *bo_gem = (dri_bo_gem *)bo;
+    drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr;
+    drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
     struct drm_i915_gem_pread pread;
     int ret;
 
@@ -646,10 +648,10 @@ dri_gem_bo_get_subdata (dri_bo *bo, unsigned long offset,
 }
 
 static void
-dri_gem_bo_wait_rendering(dri_bo *bo)
+drm_intel_gem_bo_wait_rendering(drm_intel_bo *bo)
 {
-    dri_bufmgr_gem *bufmgr_gem = (dri_bufmgr_gem *)bo->bufmgr;
-    dri_bo_gem *bo_gem = (dri_bo_gem *)bo;
+    drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr;
+    drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
     struct drm_i915_gem_set_domain set_domain;
     int ret;
 
@@ -666,9 +668,9 @@ dri_gem_bo_wait_rendering(dri_bo *bo)
 }
 
 static void
-dri_bufmgr_gem_destroy(dri_bufmgr *bufmgr)
+drm_intel_bufmgr_gem_destroy(drm_intel_bufmgr *bufmgr)
 {
-    dri_bufmgr_gem *bufmgr_gem = (dri_bufmgr_gem *)bufmgr;
+    drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bufmgr;
     int i;
 
     free(bufmgr_gem->exec_objects);
@@ -677,9 +679,9 @@ dri_bufmgr_gem_destroy(dri_bufmgr *bufmgr)
     pthread_mutex_destroy(&bufmgr_gem->lock);
 
     /* Free any cached buffer objects we were going to reuse */
-    for (i = 0; i < INTEL_GEM_BO_BUCKETS; i++) {
-	struct dri_gem_bo_bucket *bucket = &bufmgr_gem->cache_bucket[i];
-	dri_bo_gem *bo_gem;
+    for (i = 0; i < DRM_INTEL_GEM_BO_BUCKETS; i++) {
+	struct drm_intel_gem_bo_bucket *bucket = &bufmgr_gem->cache_bucket[i];
+	drm_intel_bo_gem *bo_gem;
 
 	while ((bo_gem = bucket->head) != NULL) {
 	    bucket->head = bo_gem->next;
@@ -687,7 +689,7 @@ dri_bufmgr_gem_destroy(dri_bufmgr *bufmgr)
 		bucket->tail = &bucket->head;
 	    bucket->num_entries--;
 
-	    dri_gem_bo_free(&bo_gem->bo);
+	    drm_intel_gem_bo_free(&bo_gem->bo);
 	}
     }
 
@@ -704,18 +706,19 @@ dri_bufmgr_gem_destroy(dri_bufmgr *bufmgr)
  * last known offset in target_bo.
  */
 static int
-dri_gem_bo_emit_reloc(dri_bo *bo, uint32_t read_domains, uint32_t write_domain,
-		      uint32_t delta, uint32_t offset, dri_bo *target_bo)
+drm_intel_gem_bo_emit_reloc(drm_intel_bo *bo, uint32_t offset,
+			    drm_intel_bo *target_bo, uint32_t target_offset,
+			    uint32_t read_domains, uint32_t write_domain)
 {
-    dri_bufmgr_gem *bufmgr_gem = (dri_bufmgr_gem *)bo->bufmgr;
-    dri_bo_gem *bo_gem = (dri_bo_gem *)bo;
-    dri_bo_gem *target_bo_gem = (dri_bo_gem *)target_bo;
+    drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr;
+    drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
+    drm_intel_bo_gem *target_bo_gem = (drm_intel_bo_gem *)target_bo;
 
     pthread_mutex_lock(&bufmgr_gem->lock);
 
     /* Create a new relocation list if needed */
     if (bo_gem->relocs == NULL)
-	intel_setup_reloc_list(bo);
+	drm_intel_setup_reloc_list(bo);
 
     /* Check overflow */
     assert(bo_gem->reloc_count < bufmgr_gem->max_relocs);
@@ -734,7 +737,7 @@ dri_gem_bo_emit_reloc(dri_bo *bo, uint32_t read_domains, uint32_t write_domain,
     target_bo_gem->used_as_reloc_target = 1;
 
     bo_gem->relocs[bo_gem->reloc_count].offset = offset;
-    bo_gem->relocs[bo_gem->reloc_count].delta = delta;
+    bo_gem->relocs[bo_gem->reloc_count].delta = target_offset;
     bo_gem->relocs[bo_gem->reloc_count].target_handle =
 	target_bo_gem->gem_handle;
     bo_gem->relocs[bo_gem->reloc_count].read_domains = read_domains;
@@ -742,7 +745,7 @@ dri_gem_bo_emit_reloc(dri_bo *bo, uint32_t read_domains, uint32_t write_domain,
     bo_gem->relocs[bo_gem->reloc_count].presumed_offset = target_bo->offset;
 
     bo_gem->reloc_target_bo[bo_gem->reloc_count] = target_bo;
-    dri_gem_bo_reference_locked(target_bo);
+    drm_intel_gem_bo_reference_locked(target_bo);
 
     bo_gem->reloc_count++;
 
@@ -757,33 +760,33 @@ dri_gem_bo_emit_reloc(dri_bo *bo, uint32_t read_domains, uint32_t write_domain,
  * index values into the validation list.
  */
 static void
-dri_gem_bo_process_reloc(dri_bo *bo)
+drm_intel_gem_bo_process_reloc(drm_intel_bo *bo)
 {
-    dri_bo_gem *bo_gem = (dri_bo_gem *)bo;
+    drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
     int i;
 
     if (bo_gem->relocs == NULL)
 	return;
 
     for (i = 0; i < bo_gem->reloc_count; i++) {
-	dri_bo *target_bo = bo_gem->reloc_target_bo[i];
+	drm_intel_bo *target_bo = bo_gem->reloc_target_bo[i];
 
 	/* Continue walking the tree depth-first. */
-	dri_gem_bo_process_reloc(target_bo);
+	drm_intel_gem_bo_process_reloc(target_bo);
 
 	/* Add the target to the validate list */
-	intel_add_validate_buffer(target_bo);
+	drm_intel_add_validate_buffer(target_bo);
     }
 }
 
 static void
-intel_update_buffer_offsets (dri_bufmgr_gem *bufmgr_gem)
+drm_intel_update_buffer_offsets (drm_intel_bufmgr_gem *bufmgr_gem)
 {
     int i;
 
     for (i = 0; i < bufmgr_gem->exec_count; i++) {
-	dri_bo *bo = bufmgr_gem->exec_bos[i];
-	dri_bo_gem *bo_gem = (dri_bo_gem *)bo;
+	drm_intel_bo *bo = bufmgr_gem->exec_bos[i];
+	drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
 
 	/* Update the buffer offset */
 	if (bufmgr_gem->exec_objects[i].offset != bo->offset) {
@@ -796,22 +799,22 @@ intel_update_buffer_offsets (dri_bufmgr_gem *bufmgr_gem)
 }
 
 static int
-dri_gem_bo_exec(dri_bo *bo, int used,
-		drm_clip_rect_t *cliprects, int num_cliprects,
-		int DR4)
+drm_intel_gem_bo_exec(drm_intel_bo *bo, int used,
+		      drm_clip_rect_t *cliprects, int num_cliprects,
+		      int DR4)
 {
-    dri_bufmgr_gem *bufmgr_gem = (dri_bufmgr_gem *)bo->bufmgr;
+    drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr;
     struct drm_i915_gem_execbuffer execbuf;
     int ret, i;
 
     pthread_mutex_lock(&bufmgr_gem->lock);
     /* Update indices and set up the validate list. */
-    dri_gem_bo_process_reloc(bo);
+    drm_intel_gem_bo_process_reloc(bo);
 
     /* Add the batch buffer to the validation list.  There are no relocations
      * pointing to it.
      */
-    intel_add_validate_buffer(bo);
+    drm_intel_add_validate_buffer(bo);
 
     execbuf.buffers_ptr = (uintptr_t)bufmgr_gem->exec_objects;
     execbuf.buffer_count = bufmgr_gem->exec_count;
@@ -826,21 +829,21 @@ dri_gem_bo_exec(dri_bo *bo, int used,
 	ret = ioctl(bufmgr_gem->fd, DRM_IOCTL_I915_GEM_EXECBUFFER, &execbuf);
     } while (ret != 0 && errno == EAGAIN);
 
-    intel_update_buffer_offsets (bufmgr_gem);
+    drm_intel_update_buffer_offsets (bufmgr_gem);
 
     if (bufmgr_gem->bufmgr.debug)
-	dri_gem_dump_validation_list(bufmgr_gem);
+	drm_intel_gem_dump_validation_list(bufmgr_gem);
 
     for (i = 0; i < bufmgr_gem->exec_count; i++) {
-	dri_bo *bo = bufmgr_gem->exec_bos[i];
-	dri_bo_gem *bo_gem = (dri_bo_gem *)bo;
+	drm_intel_bo *bo = bufmgr_gem->exec_bos[i];
+	drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
 
 	/* Need to call swrast on next bo_map */
 	bo_gem->swrast = 0;
 
 	/* Disconnect the buffer from the validate list */
 	bo_gem->validate_index = -1;
-	dri_gem_bo_unreference_locked(bo);
+	drm_intel_gem_bo_unreference_locked(bo);
 	bufmgr_gem->exec_bos[i] = NULL;
     }
     bufmgr_gem->exec_count = 0;
@@ -850,10 +853,10 @@ dri_gem_bo_exec(dri_bo *bo, int used,
 }
 
 static int
-dri_gem_bo_pin(dri_bo *bo, uint32_t alignment)
+drm_intel_gem_bo_pin(drm_intel_bo *bo, uint32_t alignment)
 {
-    dri_bufmgr_gem *bufmgr_gem = (dri_bufmgr_gem *)bo->bufmgr;
-    dri_bo_gem *bo_gem = (dri_bo_gem *)bo;
+    drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr;
+    drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
     struct drm_i915_gem_pin pin;
     int ret;
 
@@ -869,10 +872,10 @@ dri_gem_bo_pin(dri_bo *bo, uint32_t alignment)
 }
 
 static int
-dri_gem_bo_unpin(dri_bo *bo)
+drm_intel_gem_bo_unpin(drm_intel_bo *bo)
 {
-    dri_bufmgr_gem *bufmgr_gem = (dri_bufmgr_gem *)bo->bufmgr;
-    dri_bo_gem *bo_gem = (dri_bo_gem *)bo;
+    drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr;
+    drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
     struct drm_i915_gem_unpin unpin;
     int ret;
 
@@ -886,15 +889,17 @@ dri_gem_bo_unpin(dri_bo *bo)
 }
 
 static int
-dri_gem_bo_set_tiling(dri_bo *bo, uint32_t *tiling_mode)
+drm_intel_gem_bo_set_tiling(drm_intel_bo *bo, uint32_t *tiling_mode,
+			    uint32_t stride)
 {
-    dri_bufmgr_gem *bufmgr_gem = (dri_bufmgr_gem *)bo->bufmgr;
-    dri_bo_gem *bo_gem = (dri_bo_gem *)bo;
+    drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr;
+    drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
     struct drm_i915_gem_set_tiling set_tiling;
     int ret;
 
     set_tiling.handle = bo_gem->gem_handle;
     set_tiling.tiling_mode = *tiling_mode;
+    set_tiling.stride = stride;
 
     ret = ioctl(bufmgr_gem->fd, DRM_IOCTL_I915_GEM_SET_TILING, &set_tiling);
     if (ret != 0) {
@@ -907,10 +912,11 @@ dri_gem_bo_set_tiling(dri_bo *bo, uint32_t *tiling_mode)
 }
 
 static int
-dri_gem_bo_get_tiling(dri_bo *bo, uint32_t *tiling_mode, uint32_t *swizzle_mode)
+drm_intel_gem_bo_get_tiling(drm_intel_bo *bo, uint32_t *tiling_mode,
+			    uint32_t *swizzle_mode)
 {
-    dri_bufmgr_gem *bufmgr_gem = (dri_bufmgr_gem *)bo->bufmgr;
-    dri_bo_gem *bo_gem = (dri_bo_gem *)bo;
+    drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr;
+    drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
     struct drm_i915_gem_get_tiling get_tiling;
     int ret;
 
@@ -929,10 +935,10 @@ dri_gem_bo_get_tiling(dri_bo *bo, uint32_t *tiling_mode, uint32_t *swizzle_mode)
 }
 
 static int
-dri_gem_bo_flink(dri_bo *bo, uint32_t *name)
+drm_intel_gem_bo_flink(drm_intel_bo *bo, uint32_t *name)
 {
-    dri_bufmgr_gem *bufmgr_gem = (dri_bufmgr_gem *)bo->bufmgr;
-    dri_bo_gem *bo_gem = (dri_bo_gem *)bo;
+    drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr;
+    drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
     struct drm_gem_flink flink;
     int ret;
 
@@ -957,12 +963,12 @@ dri_gem_bo_flink(dri_bo *bo, uint32_t *name)
  * in flight at once.
  */
 void
-intel_bufmgr_gem_enable_reuse(dri_bufmgr *bufmgr)
+drm_intel_bufmgr_gem_enable_reuse(drm_intel_bufmgr *bufmgr)
 {
-    dri_bufmgr_gem *bufmgr_gem = (dri_bufmgr_gem *)bufmgr;
+    drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bufmgr;
     int i;
 
-    for (i = 0; i < INTEL_GEM_BO_BUCKETS; i++) {
+    for (i = 0; i < DRM_INTEL_GEM_BO_BUCKETS; i++) {
 	bufmgr_gem->cache_bucket[i].max_entries = -1;
     }
 }
@@ -972,9 +978,9 @@ intel_bufmgr_gem_enable_reuse(dri_bufmgr *bufmgr)
  * rooted at bo.
  */
 static int
-dri_gem_bo_get_aperture_space(dri_bo *bo)
+drm_intel_gem_bo_get_aperture_space(drm_intel_bo *bo)
 {
-    dri_bo_gem *bo_gem = (dri_bo_gem *)bo;
+    drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
     int i;
     int total = 0;
 
@@ -985,19 +991,19 @@ dri_gem_bo_get_aperture_space(dri_bo *bo)
     bo_gem->included_in_check_aperture = 1;
 
     for (i = 0; i < bo_gem->reloc_count; i++)
-	total += dri_gem_bo_get_aperture_space(bo_gem->reloc_target_bo[i]);
+	total += drm_intel_gem_bo_get_aperture_space(bo_gem->reloc_target_bo[i]);
 
     return total;
 }
 
 /**
- * Clear the flag set by dri_gem_bo_get_aperture_space() so we're ready for
- * the next dri_bufmgr_check_aperture_space() call.
+ * Clear the flag set by drm_intel_gem_bo_get_aperture_space() so we're ready
+ * for the next drm_intel_bufmgr_check_aperture_space() call.
  */
 static void
-dri_gem_bo_clear_aperture_space_flag(dri_bo *bo)
+drm_intel_gem_bo_clear_aperture_space_flag(drm_intel_bo *bo)
 {
-    dri_bo_gem *bo_gem = (dri_bo_gem *)bo;
+    drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
     int i;
 
     if (bo == NULL || !bo_gem->included_in_check_aperture)
@@ -1006,7 +1012,7 @@ dri_gem_bo_clear_aperture_space_flag(dri_bo *bo)
     bo_gem->included_in_check_aperture = 0;
 
     for (i = 0; i < bo_gem->reloc_count; i++)
-	dri_gem_bo_clear_aperture_space_flag(bo_gem->reloc_target_bo[i]);
+	drm_intel_gem_bo_clear_aperture_space_flag(bo_gem->reloc_target_bo[i]);
 }
 
 /**
@@ -1026,15 +1032,15 @@ dri_gem_bo_clear_aperture_space_flag(dri_bo *bo)
  * get better parallelism.
  */
 static int
-dri_gem_check_aperture_space(dri_bo **bo_array, int count)
+drm_intel_gem_check_aperture_space(drm_intel_bo **bo_array, int count)
 {
-    dri_bufmgr_gem *bufmgr_gem = (dri_bufmgr_gem *)bo_array[0]->bufmgr;
+    drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo_array[0]->bufmgr;
     unsigned int total = 0;
     unsigned int threshold = bufmgr_gem->gtt_size * 3 / 4;
     int i;
 
     for (i = 0; i < count; i++) {
-	dri_bo_gem *bo_gem = (dri_bo_gem *)bo_array[i];
+	drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo_array[i];
 	if (bo_gem != NULL)
 		total += bo_gem->reloc_tree_size;
     }
@@ -1042,10 +1048,10 @@ dri_gem_check_aperture_space(dri_bo **bo_array, int count)
     if (total > threshold) {
 	total = 0;
 	for (i = 0; i < count; i++)
-	    total += dri_gem_bo_get_aperture_space(bo_array[i]);
+	    total += drm_intel_gem_bo_get_aperture_space(bo_array[i]);
 
 	for (i = 0; i < count; i++)
-	    dri_gem_bo_clear_aperture_space_flag(bo_array[i]);
+	    drm_intel_gem_bo_clear_aperture_space_flag(bo_array[i]);
     }
 
     if (total > bufmgr_gem->gtt_size * 3 / 4) {
@@ -1065,10 +1071,10 @@ dri_gem_check_aperture_space(dri_bo **bo_array, int count)
  *
  * \param fd File descriptor of the opened DRM device.
  */
-dri_bufmgr *
-intel_bufmgr_gem_init(int fd, int batch_size)
+drm_intel_bufmgr *
+drm_intel_bufmgr_gem_init(int fd, int batch_size)
 {
-    dri_bufmgr_gem *bufmgr_gem;
+    drm_intel_bufmgr_gem *bufmgr_gem;
     struct drm_i915_gem_get_aperture aperture;
     int ret, i;
 
@@ -1101,26 +1107,26 @@ intel_bufmgr_gem_init(int fd, int batch_size)
      */
     bufmgr_gem->max_relocs = batch_size / sizeof(uint32_t) / 2 - 2;
 
-    bufmgr_gem->bufmgr.bo_alloc = dri_gem_bo_alloc;
-    bufmgr_gem->bufmgr.bo_reference = dri_gem_bo_reference;
-    bufmgr_gem->bufmgr.bo_unreference = dri_gem_bo_unreference;
-    bufmgr_gem->bufmgr.bo_map = dri_gem_bo_map;
-    bufmgr_gem->bufmgr.bo_unmap = dri_gem_bo_unmap;
-    bufmgr_gem->bufmgr.bo_subdata = dri_gem_bo_subdata;
-    bufmgr_gem->bufmgr.bo_get_subdata = dri_gem_bo_get_subdata;
-    bufmgr_gem->bufmgr.bo_wait_rendering = dri_gem_bo_wait_rendering;
-    bufmgr_gem->bufmgr.bo_emit_reloc = dri_gem_bo_emit_reloc;
-    bufmgr_gem->bufmgr.bo_pin = dri_gem_bo_pin;
-    bufmgr_gem->bufmgr.bo_unpin = dri_gem_bo_unpin;
-    bufmgr_gem->bufmgr.bo_get_tiling = dri_gem_bo_get_tiling;
-    bufmgr_gem->bufmgr.bo_set_tiling = dri_gem_bo_set_tiling;
-    bufmgr_gem->bufmgr.bo_flink = dri_gem_bo_flink;
-    bufmgr_gem->bufmgr.bo_exec = dri_gem_bo_exec;
-    bufmgr_gem->bufmgr.destroy = dri_bufmgr_gem_destroy;
+    bufmgr_gem->bufmgr.bo_alloc = drm_intel_gem_bo_alloc;
+    bufmgr_gem->bufmgr.bo_reference = drm_intel_gem_bo_reference;
+    bufmgr_gem->bufmgr.bo_unreference = drm_intel_gem_bo_unreference;
+    bufmgr_gem->bufmgr.bo_map = drm_intel_gem_bo_map;
+    bufmgr_gem->bufmgr.bo_unmap = drm_intel_gem_bo_unmap;
+    bufmgr_gem->bufmgr.bo_subdata = drm_intel_gem_bo_subdata;
+    bufmgr_gem->bufmgr.bo_get_subdata = drm_intel_gem_bo_get_subdata;
+    bufmgr_gem->bufmgr.bo_wait_rendering = drm_intel_gem_bo_wait_rendering;
+    bufmgr_gem->bufmgr.bo_emit_reloc = drm_intel_gem_bo_emit_reloc;
+    bufmgr_gem->bufmgr.bo_pin = drm_intel_gem_bo_pin;
+    bufmgr_gem->bufmgr.bo_unpin = drm_intel_gem_bo_unpin;
+    bufmgr_gem->bufmgr.bo_get_tiling = drm_intel_gem_bo_get_tiling;
+    bufmgr_gem->bufmgr.bo_set_tiling = drm_intel_gem_bo_set_tiling;
+    bufmgr_gem->bufmgr.bo_flink = drm_intel_gem_bo_flink;
+    bufmgr_gem->bufmgr.bo_exec = drm_intel_gem_bo_exec;
+    bufmgr_gem->bufmgr.destroy = drm_intel_bufmgr_gem_destroy;
     bufmgr_gem->bufmgr.debug = 0;
-    bufmgr_gem->bufmgr.check_aperture_space = dri_gem_check_aperture_space;
+    bufmgr_gem->bufmgr.check_aperture_space = drm_intel_gem_check_aperture_space;
     /* Initialize the linked lists for BO reuse cache. */
-    for (i = 0; i < INTEL_GEM_BO_BUCKETS; i++)
+    for (i = 0; i < DRM_INTEL_GEM_BO_BUCKETS; i++)
 	bufmgr_gem->cache_bucket[i].tail = &bufmgr_gem->cache_bucket[i].head;
 
     return &bufmgr_gem->bufmgr;
diff --git a/libdrm/intel/intel_bufmgr_priv.h b/libdrm/intel/intel_bufmgr_priv.h
index cbf3b311..76d31e47 100644
--- a/libdrm/intel/intel_bufmgr_priv.h
+++ b/libdrm/intel/intel_bufmgr_priv.h
@@ -39,7 +39,7 @@
  *
  * Contains public methods followed by private storage for the buffer manager.
  */
-struct _dri_bufmgr {
+struct _drm_intel_bufmgr {
    /**
     * Allocate a buffer object.
     *
@@ -48,17 +48,17 @@ struct _dri_bufmgr {
     * bo_map() to be used by the CPU, and validated for use using bo_validate()
     * to be used from the graphics device.
     */
-   dri_bo *(*bo_alloc)(dri_bufmgr *bufmgr_ctx, const char *name,
-		       unsigned long size, unsigned int alignment);
+   drm_intel_bo *(*bo_alloc)(drm_intel_bufmgr *bufmgr, const char *name,
+			     unsigned long size, unsigned int alignment);
 
    /** Takes a reference on a buffer object */
-   void (*bo_reference)(dri_bo *bo);
+   void (*bo_reference)(drm_intel_bo *bo);
 
    /**
     * Releases a reference on a buffer object, freeing the data if
     * rerefences remain.
     */
-   void (*bo_unreference)(dri_bo *bo);
+   void (*bo_unreference)(drm_intel_bo *bo);
 
    /**
     * Maps the buffer into userspace.
@@ -67,28 +67,28 @@ struct _dri_bufmgr {
     * buffer to complete, first.  The resulting mapping is available at
     * buf->virtual.
     */
-   int (*bo_map)(dri_bo *buf, int write_enable);
+   int (*bo_map)(drm_intel_bo *bo, int write_enable);
 
    /** Reduces the refcount on the userspace mapping of the buffer object. */
-   int (*bo_unmap)(dri_bo *buf);
+   int (*bo_unmap)(drm_intel_bo *bo);
 
    /**
     * Write data into an object.
     *
     * This is an optional function, if missing,
-    * dri_bo will map/memcpy/unmap.
+    * drm_intel_bo will map/memcpy/unmap.
     */
-   int (*bo_subdata) (dri_bo *buf, unsigned long offset,
-		      unsigned long size, const void *data);
+   int (*bo_subdata)(drm_intel_bo *bo, unsigned long offset,
+		     unsigned long size, const void *data);
 
    /**
     * Read data from an object
     *
     * This is an optional function, if missing,
-    * dri_bo will map/memcpy/unmap.
+    * drm_intel_bo will map/memcpy/unmap.
     */
-   int (*bo_get_subdata) (dri_bo *bo, unsigned long offset,
-			  unsigned long size, void *data);
+   int (*bo_get_subdata)(drm_intel_bo *bo, unsigned long offset,
+			 unsigned long size, void *data);
 
    /**
     * Waits for rendering to an object by the GPU to have completed.
@@ -96,12 +96,12 @@ struct _dri_bufmgr {
     * This is not required for any access to the BO by bo_map, bo_subdata, etc.
     * It is merely a way for the driver to implement glFinish.
     */
-   void (*bo_wait_rendering) (dri_bo *bo);
+   void (*bo_wait_rendering)(drm_intel_bo *bo);
 
    /**
     * Tears down the buffer manager instance.
     */
-   void (*destroy)(dri_bufmgr *bufmgr);
+   void (*destroy)(drm_intel_bufmgr *bufmgr);
 
     /**
      * Add relocation entry in reloc_buf, which will be updated with the
@@ -109,23 +109,23 @@ struct _dri_bufmgr {
      *
      * Relocations remain in place for the lifetime of the buffer object.
      *
-     * \param reloc_buf Buffer to write the relocation into.
+     * \param bo Buffer to write the relocation into.
+     * \param offset Byte offset within reloc_bo of the pointer to target_bo.
+     * \param target_bo Buffer whose offset should be written into the
+     *                  relocation entry.
+     * \param target_offset Constant value to be added to target_bo's offset in
+     *	                    relocation entry.
      * \param read_domains GEM read domains which the buffer will be read into
      *	      by the command that this relocation is part of.
      * \param write_domains GEM read domains which the buffer will be dirtied
      *	      in by the command that this relocation is part of.
-     * \param delta Constant value to be added to the relocation target's
-     *	       offset.
-     * \param offset Byte offset within batch_buf of the relocated pointer.
-     * \param target Buffer whose offset should be written into the relocation
-     *	     entry.
      */
-    int (*bo_emit_reloc)(dri_bo *reloc_buf,
-			 uint32_t read_domains, uint32_t write_domain,
-			 uint32_t delta, uint32_t offset, dri_bo *target);
+    int (*bo_emit_reloc)(drm_intel_bo *bo, uint32_t offset,
+			 drm_intel_bo *target_bo, uint32_t target_offset,
+			 uint32_t read_domains, uint32_t write_domain);
 
     /** Executes the command buffer pointed to by bo. */
-    int (*bo_exec)(dri_bo *bo, int used,
+    int (*bo_exec)(drm_intel_bo *bo, int used,
 		   drm_clip_rect_t *cliprects, int num_cliprects,
 		   int DR4);
 
@@ -135,20 +135,21 @@ struct _dri_bufmgr {
      * \param buf Buffer to pin
      * \param alignment Required alignment for aperture, in bytes
      */
-    int (*bo_pin) (dri_bo *buf, uint32_t alignment);
+    int (*bo_pin)(drm_intel_bo *bo, uint32_t alignment);
     /**
      * Unpin a buffer from the aperture, allowing it to be removed
      *
      * \param buf Buffer to unpin
      */
-    int (*bo_unpin) (dri_bo *buf);
+    int (*bo_unpin)(drm_intel_bo *bo);
     /**
      * Ask that the buffer be placed in tiling mode
      *
      * \param buf Buffer to set tiling mode for
      * \param tiling_mode desired, and returned tiling mode
      */
-    int (*bo_set_tiling) (dri_bo *bo, uint32_t *tiling_mode);
+    int (*bo_set_tiling)(drm_intel_bo *bo, uint32_t *tiling_mode,
+			 uint32_t stride);
     /**
      * Get the current tiling (and resulting swizzling) mode for the bo.
      *
@@ -156,17 +157,17 @@ struct _dri_bufmgr {
      * \param tiling_mode returned tiling mode
      * \param swizzle_mode returned swizzling mode
      */
-    int (*bo_get_tiling) (dri_bo *bo, uint32_t *tiling_mode,
-			  uint32_t *swizzle_mode);
+    int (*bo_get_tiling)(drm_intel_bo *bo, uint32_t *tiling_mode,
+			 uint32_t *swizzle_mode);
     /**
      * Create a visible name for a buffer which can be used by other apps
      *
      * \param buf Buffer to create a name for
      * \param name Returned name
      */
-    int (*bo_flink) (dri_bo *buf, uint32_t *name);
+    int (*bo_flink)(drm_intel_bo *bo, uint32_t *name);
 
-    int (*check_aperture_space)(dri_bo **bo_array, int count);
+    int (*check_aperture_space)(drm_intel_bo **bo_array, int count);
     int debug; /**< Enables verbose debugging printouts */
 };