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.

1 files changed, 184 insertions, 185 deletions

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;