driver/etnaviv: refactor etna_vidmem into etna_bo

First step towards making the libetnaviv API more like freedreno_drm.
Bo's are not yet fully emulated, but this is a step closer.

26 files changed, 787 insertions, 675 deletions

diff --git a/src/driver/etna_pipe.h b/src/driver/etna_pipe.h
index 4fec1dc..fe231ff 100644
--- a/src/driver/etna_pipe.h
+++ b/src/driver/etna_pipe.h
@@ -27,7 +27,7 @@
 
 #include <stdint.h>
 #include <etnaviv/etna.h>
-#include <etnaviv/etna_mem.h>
+#include <etnaviv/etna_bo.h>
 #include <etnaviv/etna_rs.h>
 #include <etnaviv/etna_tex.h>
 
@@ -84,8 +84,8 @@ struct etna_resource
     enum etna_surface_layout layout;
     /* Horizontal alignment for texture unit (TEXTURE_HALIGN_*) */
     unsigned halign;
-    struct etna_vidmem *surface; /* Surface video memory */
-    struct etna_vidmem *ts; /* Tile status video memory */
+    struct etna_bo *bo; /* Surface video memory */
+    struct etna_bo *ts_bo; /* Tile status video memory */
 
     struct etna_resource_level levels[ETNA_NUM_LOD];
     struct etna_pipe_context *last_ctx; /* Last bound context */
diff --git a/src/driver/etna_resource.c b/src/driver/etna_resource.c
index f7c68f6..1f6dc53 100644
--- a/src/driver/etna_resource.c
+++ b/src/driver/etna_resource.c
@@ -51,28 +51,29 @@ bool etna_screen_resource_alloc_ts(struct pipe_screen *screen, struct etna_resou
 {
     struct etna_screen *priv = etna_screen(screen);
     size_t rt_ts_size;
-    assert(!resource->ts);
+    assert(!resource->ts_bo);
     /* TS only for level 0 -- XXX is this formula correct? */
     rt_ts_size = align(resource->levels[0].size*priv->specs.bits_per_tile/0x80, 0x100);
     if(rt_ts_size == 0)
         return true;
 
     DBG_F(ETNA_DBG_RESOURCE_MSGS, "%p: Allocating tile status of size %i", resource, rt_ts_size);
-    struct etna_vidmem *rt_ts = 0;
-    if(unlikely(etna_vidmem_alloc_linear(priv->dev, &rt_ts, rt_ts_size, VIV_SURF_TILE_STATUS, VIV_POOL_DEFAULT, true)!=ETNA_OK))
+    struct etna_bo *rt_ts = 0;
+    if(unlikely((rt_ts = etna_bo_new(priv->dev, rt_ts_size, DRM_ETNA_GEM_TYPE_TS)) == NULL))
     {
         BUG("Problem allocating tile status for resource");
         return false;
     }
-    resource->ts = rt_ts;
-    resource->levels[0].ts_address = resource->ts->address;
-    resource->levels[0].ts_size = resource->ts->size;
+    resource->ts_bo = rt_ts;
+    resource->levels[0].ts_address = etna_bo_gpu_address(resource->ts_bo);
+    resource->levels[0].ts_size = etna_bo_size(resource->ts_bo);
     /* It is important to initialize the TS, as random pattern
      * can result in crashes. Do this on the CPU as this only happens once
      * per surface anyway and it's a small area, so it may not be worth
      * queuing this to the GPU.
      */
-    memset(rt_ts->logical, priv->specs.ts_clear_value, rt_ts_size);
+    void *ts_map = etna_bo_map(rt_ts);
+    memset(ts_map, priv->specs.ts_clear_value, rt_ts_size);
     return true;
 }
 
@@ -215,25 +216,26 @@ static struct pipe_resource * etna_screen_resource_create(struct pipe_screen *sc
     size_t rt_size = offset;
 
     /* determine memory type */
+    uint32_t flags = 0; /* XXX DRM_ETNA_GEM_CACHE_xxx */
     enum viv_surf_type memtype = VIV_SURF_UNKNOWN;
     if(templat->bind & PIPE_BIND_SAMPLER_VIEW)
-        memtype = VIV_SURF_TEXTURE;
+        flags |= DRM_ETNA_GEM_TYPE_TEX;
     else if(templat->bind & PIPE_BIND_RENDER_TARGET)
-        memtype = VIV_SURF_RENDER_TARGET;
+        flags |= DRM_ETNA_GEM_TYPE_RT;
     else if(templat->bind & PIPE_BIND_DEPTH_STENCIL)
-        memtype = VIV_SURF_DEPTH;
+        flags |= DRM_ETNA_GEM_TYPE_ZS;
     else if(templat->bind & PIPE_BIND_INDEX_BUFFER)
-        memtype = VIV_SURF_INDEX;
+        flags |= DRM_ETNA_GEM_TYPE_IDX;
     else if(templat->bind & PIPE_BIND_VERTEX_BUFFER)
-        memtype = VIV_SURF_VERTEX;
+        flags |= DRM_ETNA_GEM_TYPE_VTX;
 
     DBG_F(ETNA_DBG_RESOURCE_MSGS, "%p: Allocate surface of %ix%i (padded to %ix%i) of format %s (%i bpe %ix%i), size %08x flags %08x, memtype %i",
             resource,
             templat->width0, templat->height0, resource->levels[0].padded_width, resource->levels[0].padded_height, util_format_name(templat->format),
             element_size, divSizeX, divSizeY, rt_size, templat->bind, memtype);
 
-    struct etna_vidmem *rt = 0;
-    if(unlikely(etna_vidmem_alloc_linear(priv->dev, &rt, rt_size, memtype, VIV_POOL_DEFAULT, true) != ETNA_OK))
+    struct etna_bo *rt = 0;
+    if(unlikely((rt = etna_bo_new(priv->dev, rt_size, flags)) == NULL))
     {
         BUG("Problem allocating video memory for resource");
         return NULL;
@@ -245,20 +247,26 @@ static struct pipe_resource * etna_screen_resource_create(struct pipe_screen *sc
     resource->base.nr_samples = nr_samples;
     resource->layout = layout;
     resource->halign = halign;
-    resource->surface = rt;
-    resource->ts = 0; /* TS is only created when first bound to surface */
+    resource->bo = rt;
+    resource->ts_bo = 0; /* TS is only created when first bound to surface */
     pipe_reference_init(&resource->base.reference, 1);
 
     if(DBG_ENABLED(ETNA_DBG_ZERO))
     {
-        memset(resource->surface->logical, 0, rt_size);
+        void *map = etna_bo_map(resource->bo);
+        memset(map, 0, rt_size);
     }
 
+    /* Set up cached mipmap level addresses
+     * (this is pretty pointless, XXX remove it)
+     */
+    uint32_t gpu_address = etna_bo_gpu_address(resource->bo);
+    void *map = etna_bo_map(resource->bo);
     for(unsigned ix=0; ix<=resource->base.last_level; ++ix)
     {
         struct etna_resource_level *mip = &resource->levels[ix];
-        mip->address = resource->surface->address + mip->offset;
-        mip->logical = resource->surface->logical + mip->offset;
+        mip->address = gpu_address + mip->offset;
+        mip->logical = map + mip->offset;
         DBG_F(ETNA_DBG_RESOURCE_MSGS, "  %08x level %i: %ix%i (%i) stride=%i layer_stride=%i",
                 (int)mip->address, ix, (int)mip->width, (int)mip->height, (int)mip->size,
                 (int)mip->stride, (int)mip->layer_stride);
@@ -274,21 +282,21 @@ static void etna_screen_resource_destroy(struct pipe_screen *screen,
     struct etna_resource *resource = etna_resource(resource_);
     if(resource == NULL)
         return;
+    struct etna_queue *queue = NULL;
     if(resource->last_ctx != NULL)
     {
         /* XXX This could fail when multiple contexts share this resource,
          * (the last one to bind it will "own" it) or fail miserably if
          * the context was since destroyed.
+         * Integrate this into etna_bo_del...
          */
-        struct etna_pipe_context *ectx = resource->last_ctx;
         DBG_F(ETNA_DBG_RESOURCE_MSGS, "%p: resource queued destroyed (%ix%ix%i)", resource, resource_->width0, resource_->height0, resource_->depth0);
-        etna_vidmem_queue_free(ectx->ctx->queue, resource->surface);
-        etna_vidmem_queue_free(ectx->ctx->queue, resource->ts);
+        queue = resource->last_ctx->ctx->queue;
     } else {
         DBG_F(ETNA_DBG_RESOURCE_MSGS, "%p: resource destroyed (%ix%ix%i)", resource, resource_->width0, resource_->height0, resource_->depth0);
-        etna_vidmem_free(priv->dev, resource->surface);
-        etna_vidmem_free(priv->dev, resource->ts);
     }
+    etna_bo_del(priv->dev, resource->bo, queue);
+    etna_bo_del(priv->dev, resource->ts_bo, queue);
     FREE(resource);
 }
 
diff --git a/src/driver/etna_surface.c b/src/driver/etna_surface.c
index bab2f4f..73ad33d 100644
--- a/src/driver/etna_surface.c
+++ b/src/driver/etna_surface.c
@@ -61,7 +61,7 @@ static struct pipe_surface *etna_pipe_create_surface(struct pipe_context *pipe,
      * is not stable.
      */
     if(!DBG_ENABLED(ETNA_DBG_NO_TS) &&
-            !resource->ts &&
+            !resource->ts_bo &&
             !(resource->base.bind & (PIPE_BIND_SAMPLER_VIEW)) &&
             (resource->levels[level].padded_width & ETNA_RS_WIDTH_MASK) == 0 &&
             (resource->levels[level].padded_height & ETNA_RS_HEIGHT_MASK) == 0)
diff --git a/src/etnaviv/Makefile b/src/etnaviv/Makefile
index ad7f61e..c18ae7e 100644
--- a/src/etnaviv/Makefile
+++ b/src/etnaviv/Makefile
@@ -5,7 +5,7 @@ include $(TOP)/Makefile.inc
 COMMON_FLAGS +=
 #-DDEBUG
 LDFLAGS +=
-ETNAVIV_OBJS = etna.o viv.o viv_profile.o etna_mem.o etna_queue.o etna_tex.o etna_fb.o etna_rs.o
+ETNAVIV_OBJS = etna.o viv.o viv_profile.o etna_bo.o etna_queue.o etna_tex.o etna_fb.o etna_rs.o
 
 ifeq ($(ETNAVIV_HOOK), 1)
 # Define ETNAVIV_HOOK=1 to enable hook mechanism
diff --git a/src/etnaviv/etna.c b/src/etnaviv/etna.c
index cf15cda..5763bd6 100644
--- a/src/etnaviv/etna.c
+++ b/src/etnaviv/etna.c
@@ -21,6 +21,7 @@
  * DEALINGS IN THE SOFTWARE.
  */
 #include <etnaviv/etna.h>
+#include <etnaviv/etna_bo.h>
 #include <etnaviv/viv.h>
 #include <etnaviv/etna_queue.h>
 #include <etnaviv/state.xml.h>
@@ -55,54 +56,6 @@ static int gpu_context_clear(struct etna_ctx *ctx);
 
 #define GCCTX(x) ((gcoCONTEXT)(size_t)((x)->ctx))
 
-/* Allocate new command buffer for context */
-static int gpu_context_allocate_buffer(struct etna_ctx *ctx, struct etna_context_info *ctx_info)
-{
-    if(viv_alloc_contiguous(ctx->conn, COMMAND_BUFFER_SIZE,
-                &ctx_info->physical,
-                &ctx_info->logical,
-                &ctx_info->bytes)!=0)
-    {
-#ifdef DEBUG
-        fprintf(stderr, "Error allocating contiguous host memory for context\n");
-#endif
-        return ETNA_OUT_OF_MEMORY;
-    }
-#ifdef DEBUG
-    printf("Allocated buffer (size 0x%x) for context: phys=%08x log=%08x\n", (int)ctx_info->bytes, (int)ctx_info->physical, (int)ctx_info->logical);
-#endif
-    return ETNA_OK;
-}
-
-/* Free command buffer for context, either immediately or queued for when the
- * GPU is finished with it. */
-static int gpu_context_free_buffer(struct etna_ctx *ctx, struct etna_context_info *ctx_info, bool queued)
-{
-    int rv;
-    if(queued)
-    {
-        rv = etna_queue_free_contiguous(ctx->queue,
-                    ctx_info->bytes,
-                    ctx_info->physical,
-                    ctx_info->logical);
-    } else {
-        rv = viv_free_contiguous(ctx->conn,
-                    ctx_info->bytes,
-                    ctx_info->physical,
-                    ctx_info->logical);
-    }
-    if(rv != ETNA_OK)
-    {
-#ifdef DEBUG
-        fprintf(stderr, "Error releasing contiguous host memory for context (%i)\n", rv);
-#endif
-        return rv;
-    }
-    ctx_info->bytes = ctx_info->physical = 0;
-    ctx_info->logical = NULL;
-    return ETNA_OK;
-}
-
 static int gpu_context_initialize(struct etna_ctx *ctx)
 {
     int rv;
@@ -133,10 +86,11 @@ static int gpu_context_initialize(struct etna_ctx *ctx)
 
     ctx->ctx = VIV_TO_HANDLE(vctx);
     /* Allocate initial context buffer */
-    if((rv = gpu_context_allocate_buffer(ctx, &ctx->ctx_info)) != ETNA_OK)
+    /*   XXX DRM_ETNA_GEM_CACHE_xxx */
+    if((ctx->ctx_info = etna_bo_new(ctx->conn, COMMAND_BUFFER_SIZE, DRM_ETNA_GEM_TYPE_CMD)) == NULL)
     {
         ETNA_FREE(vctx);
-        return rv;
+        return ETNA_OUT_OF_MEMORY;
     }
     /* Set context to initial sane values */
     gpu_context_clear(ctx);
@@ -160,13 +114,13 @@ static int gpu_context_clear(struct etna_ctx *ctx)
 #ifdef DEBUG
         printf("gpu_context_clear: context was in use, deferred freeing and reallocating it\n");
 #endif
-        if((rv = gpu_context_free_buffer(ctx, &ctx->ctx_info, true)) != ETNA_OK)
+        if((rv = etna_bo_del(ctx->conn, ctx->ctx_info, ctx->queue)) != ETNA_OK)
         {
             return rv;
         }
-        if((rv = gpu_context_allocate_buffer(ctx, &ctx->ctx_info)) != ETNA_OK)
+        if((ctx->ctx_info = etna_bo_new(ctx->conn, COMMAND_BUFFER_SIZE, DRM_ETNA_GEM_TYPE_CMD)) == NULL)
         {
-            return rv;
+            return ETNA_OUT_OF_MEMORY;
         }
     }
     /* Leave space at beginning of buffer for PIPE switch */
@@ -318,7 +272,7 @@ int etna_create(struct viv_conn *conn, struct etna_ctx **ctx_out)
     for(int x=0; x<NUM_COMMAND_BUFFERS; ++x)
     {
         ctx->cmdbuf[x] = ETNA_CALLOC_STRUCT(_gcoCMDBUF);
-        if(viv_alloc_contiguous(conn, COMMAND_BUFFER_SIZE, &ctx->cmdbufi[x].physical, &ctx->cmdbufi[x].logical, &ctx->cmdbufi[x].bytes)!=0)
+        if((ctx->cmdbufi[x].bo = etna_bo_new(conn, COMMAND_BUFFER_SIZE, DRM_ETNA_GEM_TYPE_CMD))==NULL)
         {
 #ifdef DEBUG
             fprintf(stderr, "Error allocating host memory for command buffer\n");
@@ -327,10 +281,10 @@ int etna_create(struct viv_conn *conn, struct etna_ctx **ctx_out)
         }
         ctx->cmdbuf[x]->object.type = gcvOBJ_COMMANDBUFFER;
 #ifdef GCABI_CMDBUF_HAS_PHYSICAL
-        ctx->cmdbuf[x]->physical = PTR_TO_VIV((void*)ctx->cmdbufi[x].physical);
+        ctx->cmdbuf[x]->physical = PTR_TO_VIV((void*)etna_bo_gpu_address(ctx->cmdbufi[x].bo));
         ctx->cmdbuf[x]->bytes = ctx->cmdbufi[x].bytes;
 #endif
-        ctx->cmdbuf[x]->logical = PTR_TO_VIV((void*)ctx->cmdbufi[x].logical);
+        ctx->cmdbuf[x]->logical = PTR_TO_VIV((void*)etna_bo_map(ctx->cmdbufi[x].bo));
 
         if(viv_user_signal_create(conn, 0, &ctx->cmdbufi[x].sig_id) != 0 ||
            viv_user_signal_signal(conn, ctx->cmdbufi[x].sig_id, 1) != 0)
@@ -404,12 +358,12 @@ int etna_free(struct etna_ctx *ctx)
     etna_queue_free(ctx->queue);
 #ifdef GCABI_HAVE_CONTEXT
     /* Free context buffer */
-    gpu_context_free_buffer(ctx, &ctx->ctx_info, false);
+    etna_bo_del(ctx->conn, ctx->ctx_info, NULL);
 #endif
     /* Free command buffers */
     for(int x=0; x<NUM_COMMAND_BUFFERS; ++x)
     {
-        viv_free_contiguous(ctx->conn, ctx->cmdbufi[x].bytes, (viv_addr_t)ctx->cmdbufi[x].physical, VIV_TO_PTR(ctx->cmdbufi[x].logical));
+        etna_bo_del(ctx->conn, ctx->cmdbufi[x].bo, NULL);
         ETNA_FREE(ctx->cmdbuf[x]);
     }
     ETNA_FREE(ctx);
diff --git a/src/etnaviv/etna.h b/src/etnaviv/etna.h
index 8fc51d8..c5b6c8b 100644
--- a/src/etnaviv/etna.h
+++ b/src/etnaviv/etna.h
@@ -89,6 +89,7 @@ enum etna_pipe {
 struct _gcoCMDBUF;
 struct etna_queue;
 struct etna_ctx;
+struct etna_bo;
 
 struct etna_context_info {
     size_t bytes;
@@ -100,12 +101,9 @@ typedef int (*etna_context_snapshot_cb_t)(void *data, struct etna_ctx *ctx,
         enum etna_pipe *initial_pipe, enum etna_pipe *final_pipe);
 
 struct etna_cmdbuf {
-    /* sync signals for command buffer */
+    /* sync signal for command buffer */
     int sig_id;
-    /* memory info */
-    size_t bytes;
-    viv_addr_t physical;
-    void *logical;
+    struct etna_bo *bo;
 };
 
 struct etna_ctx {
@@ -134,7 +132,7 @@ struct etna_ctx {
     int flushes;
     /* context */
     viv_context_t ctx;
-    struct etna_context_info ctx_info;
+    struct etna_bo *ctx_bo;
     etna_context_snapshot_cb_t ctx_cb;
     void *ctx_cb_data;
     /* command queue */
diff --git a/src/etnaviv/etna_bo.c b/src/etnaviv/etna_bo.c
new file mode 100644
index 0000000..0231896
--- /dev/null
+++ b/src/etnaviv/etna_bo.c
@@ -0,0 +1,293 @@
+/*
+ * Copyright (c) 2012-2013 Etnaviv Project
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sub license,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+#include <etnaviv/etna_bo.h>
+#include <etnaviv/etna.h>
+#include <etnaviv/etna_queue.h>
+
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "gc_abi.h"
+
+//#define DEBUG
+#define ETNA_VIDMEM_ALIGNMENT (0x40)
+
+enum etna_bo_type {
+    ETNA_BO_TYPE_VIDMEM,    /* Main vidmem */
+    ETNA_BO_TYPE_USERMEM,   /* Mapped user memory */
+    ETNA_BO_TYPE_CONTIGUOUS,/* Contiguous memory */
+    ETNA_BO_TYPE_PHYSICAL   /* Direct physical mapping */
+};
+
+/* Structure describing a block of video or user memory */
+struct etna_bo {
+    enum etna_bo_type bo_type;
+    size_t size;
+    enum viv_surf_type type;
+    viv_node_t node;
+    viv_addr_t address;
+    void *logical;
+    viv_usermem_t usermem_info;
+};
+
+/* Lock (map) memory into both CPU and GPU memory space. */
+static int etna_bo_lock(struct viv_conn *conn, struct etna_bo *mem)
+{
+    if(mem == NULL) return ETNA_INVALID_ADDR;
+    if(mem->logical != NULL) return ETNA_ALREADY_LOCKED;
+
+    if(viv_lock_vidmem(conn, mem->node, &mem->address, &mem->logical)!=0)
+    {
+#ifdef DEBUG
+        fprintf(stderr, "Error locking render target memory\n");
+#endif
+        return ETNA_INTERNAL_ERROR;
+    }
+#ifdef DEBUG
+    printf("Locked: phys=%08x log=%08x\n", (uint32_t)mem->address, (uint32_t)mem->logical);
+#endif
+
+    return ETNA_OK;
+}
+
+/* Unlock memory from both CPU and GPU memory space */
+static int etna_bo_unlock(struct viv_conn *conn, struct etna_bo *mem, struct etna_queue *queue)
+{
+    if(mem == NULL) return ETNA_INVALID_ADDR;
+    int async = 0;
+    /* Unlocking video memory seems to be a two-step process. First try it synchronously
+     * then the kernel can request an asynchronous component. Just queueing it asynchronously
+     * in the first place will not free the virtual memory on v4 */
+    if(viv_unlock_vidmem(conn, mem->node, mem->type, false, &async) != ETNA_OK)
+    {
+        return ETNA_INTERNAL_ERROR;
+    }
+    if(async)
+    {
+        if(queue)
+        {
+            /* If a queue is passed, add the async part at the end of the queue, to be submitted
+             * with next flush.
+             */
+            if(etna_queue_unlock_vidmem(queue, mem->node, mem->type) != ETNA_OK)
+            {
+                return ETNA_INTERNAL_ERROR;
+            }
+        } else { /* No queue, need to submit async part directly as event */
+            if(viv_unlock_vidmem(conn, mem->node, mem->type, true, &async) != ETNA_OK)
+            {
+                return ETNA_INTERNAL_ERROR;
+            }
+        }
+    }
+    mem->logical = NULL;
+    mem->address = 0;
+    return ETNA_OK;
+}
+
+struct etna_bo* etna_bo_new(struct viv_conn *conn, size_t bytes, uint32_t flags)
+{
+    struct etna_bo *mem = ETNA_CALLOC_STRUCT(etna_bo);
+    if(mem == NULL) return NULL;
+
+    if((flags & DRM_ETNA_GEM_TYPE_MASK) == DRM_ETNA_GEM_TYPE_CMD)
+    {
+        mem->bo_type = ETNA_BO_TYPE_CONTIGUOUS;
+        /* Command buffers must be allocated with viv_alloc_contiguous */
+        if(viv_alloc_contiguous(conn, bytes,
+                    &mem->address,
+                    &mem->logical,
+                    &mem->size)!=0)
+        {
+            ETNA_FREE(mem);
+            return NULL;
+        }
+    } else {
+        enum viv_surf_type type = VIV_SURF_UNKNOWN;
+        enum viv_pool pool = VIV_POOL_DEFAULT;
+        /* Convert GEM bits to surface type */
+        switch(flags & DRM_ETNA_GEM_TYPE_MASK)
+        {
+        case DRM_ETNA_GEM_TYPE_IDX: type = VIV_SURF_INDEX; break;
+        case DRM_ETNA_GEM_TYPE_VTX: type = VIV_SURF_VERTEX; break;
+        case DRM_ETNA_GEM_TYPE_TEX: type = VIV_SURF_TEXTURE; break;
+        case DRM_ETNA_GEM_TYPE_RT:  type = VIV_SURF_RENDER_TARGET; break;
+        case DRM_ETNA_GEM_TYPE_ZS:  type = VIV_SURF_DEPTH; break;
+        case DRM_ETNA_GEM_TYPE_HZ:  type = VIV_SURF_HIERARCHICAL_DEPTH; break;
+        case DRM_ETNA_GEM_TYPE_BMP: type = VIV_SURF_BITMAP; break;
+        case DRM_ETNA_GEM_TYPE_TS:  type = VIV_SURF_TILE_STATUS; break;
+        default: /* Invalid type */
+            ETNA_FREE(mem);
+            return NULL;
+            break;
+        }
+
+        mem->bo_type = ETNA_BO_TYPE_VIDMEM;
+        mem->type = type;
+        if(viv_alloc_linear_vidmem(conn, bytes, ETNA_VIDMEM_ALIGNMENT, type, pool, &mem->node, &mem->size)!=0)
+        {
+#ifdef DEBUG
+            fprintf(stderr, "Error allocating memory\n");
+#endif
+            return NULL;
+        }
+#ifdef DEBUG
+        printf("Allocated: mem=%p node=%08x size=%08x\n", mem, (uint32_t)mem->node, mem->size);
+#endif
+        int status = etna_bo_lock(conn, mem);
+        if(status != ETNA_OK)
+        {
+            etna_bo_del(conn, mem, NULL);
+            return NULL;
+        }
+    }
+    return mem;
+}
+
+struct etna_bo *etna_bo_from_usermem(struct viv_conn *conn, void *memory, size_t size)
+{
+    struct etna_bo *mem = ETNA_CALLOC_STRUCT(etna_bo);
+    if(mem == NULL) return NULL;
+
+    mem->bo_type = ETNA_BO_TYPE_USERMEM;
+    mem->logical = memory;
+    mem->size = size;
+
+    if(viv_map_user_memory(conn, memory, size, &mem->usermem_info, &mem->address)!=0)
+    {
+        ETNA_FREE(mem);
+        return NULL;
+    }
+
+    return mem;
+}
+
+struct etna_bo *etna_bo_from_fbdev(struct viv_conn *conn, size_t offset, size_t size)
+{
+    /* TODO */
+    return NULL;
+}
+
+struct etna_bo *etna_bo_from_name(struct viv_conn *conn, uint32_t name)
+{
+    /* TODO */
+    return NULL;
+}
+
+struct etna_bo *etna_bo_ref(struct etna_bo *bo)
+{
+    /* TODO */
+    return bo;
+}
+
+int etna_bo_del(struct viv_conn *conn, struct etna_bo *mem, struct etna_queue *queue)
+{
+    int rv = ETNA_OK;
+    if(mem == NULL) return ETNA_OK;
+    switch(mem->bo_type)
+    {
+    case ETNA_BO_TYPE_VIDMEM:
+        if(mem->logical != NULL)
+        {
+            if((rv = etna_bo_unlock(conn, mem, queue)) != ETNA_OK)
+            {
+                printf("etna: Warning: could not unlock memory\n");
+            }
+        }
+        if(queue)
+        {
+            if((rv = etna_queue_free_vidmem(queue, mem->node)) != ETNA_OK)
+            {
+                printf("etna: Warning: could not queue free video memory\n");
+            }
+        } else {
+            if((rv = viv_free_vidmem(conn, mem->node)) != ETNA_OK)
+            {
+                printf("etna: Warning: could not free video memory\n");
+            }
+        }
+        break;
+    case ETNA_BO_TYPE_USERMEM:
+        if(queue)
+        {
+            rv = etna_queue_unmap_user_memory(queue, mem->logical, mem->size, mem->usermem_info, mem->address);
+        } else
+        {
+            rv = viv_unmap_user_memory(conn, mem->logical, mem->size, mem->usermem_info, mem->address);
+        }
+        break;
+    case ETNA_BO_TYPE_CONTIGUOUS:
+        if(queue)
+        {
+            rv = etna_queue_free_contiguous(queue, mem->size, mem->address, mem->logical);
+        } else {
+            rv = viv_free_contiguous(conn, mem->size, mem->address, mem->logical);
+        }
+        break;
+    case ETNA_BO_TYPE_PHYSICAL:
+        /* Nothing to do */
+        break;
+    }
+    ETNA_FREE(mem);
+    return rv;
+}
+
+int etna_bo_get_name(struct etna_bo *bo, uint32_t *name)
+{
+    /* TODO */
+    return -1;
+}
+
+uint32_t etna_bo_handle(struct etna_bo *bo)
+{
+    /* TODO */
+    return 0;
+}
+
+uint32_t etna_bo_size(struct etna_bo *bo)
+{
+    return bo->size;
+}
+
+void *etna_bo_map(struct etna_bo *bo)
+{
+    return bo->logical;
+}
+
+int etna_bo_cpu_prep(struct etna_bo *bo, struct etna_ctx *pipe, uint32_t op)
+{
+    /* TODO */
+    return 0;
+}
+
+void etna_bo_cpu_fini(struct etna_bo *bo)
+{
+    /* No-op */
+}
+
+uint32_t etna_bo_gpu_address(struct etna_bo *bo)
+{
+    return bo->address;
+}
+
diff --git a/src/etnaviv/etna_bo.h b/src/etnaviv/etna_bo.h
new file mode 100644
index 0000000..750d291
--- /dev/null
+++ b/src/etnaviv/etna_bo.h
@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) 2012-2013 Etnaviv Project
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sub license,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+/* etna: memory management functions */
+#ifndef H_ETNA_BO
+#define H_ETNA_BO
+
+#include <stdbool.h>
+#include <unistd.h>
+#include <stdint.h>
+
+/* bo create flags */
+#define DRM_ETNA_GEM_TYPE_CMD        0x00000000 /* Command buffer */
+#define DRM_ETNA_GEM_TYPE_IDX        0x00000001 /* Index buffer */
+#define DRM_ETNA_GEM_TYPE_VTX        0x00000002 /* Vertex buffer */
+#define DRM_ETNA_GEM_TYPE_TEX        0x00000003 /* Texture */
+#define DRM_ETNA_GEM_TYPE_RT         0x00000004 /* Color render target */
+#define DRM_ETNA_GEM_TYPE_ZS         0x00000005 /* Depth stencil target */
+#define DRM_ETNA_GEM_TYPE_HZ         0x00000006 /* Hierarchical depth render target */
+#define DRM_ETNA_GEM_TYPE_BMP        0x00000007 /* Bitmap */
+#define DRM_ETNA_GEM_TYPE_TS         0x00000008 /* Tile status cache */
+#define DRM_ETNA_GEM_TYPE_MASK       0x0000000F
+
+#define DRM_ETNA_GEM_CACHE_NONE      0x00000000
+#define DRM_ETNA_GEM_CACHE_WCOMBINE  0x00100000
+#define DRM_ETNA_GEM_CACHE_WTHROUGH  0x00200000
+#define DRM_ETNA_GEM_CACHE_WBACK     0x00400000
+#define DRM_ETNA_GEM_CACHE_WBACKWA   0x00800000
+#define DRM_ETNA_GEM_CACHE_MASK      0x00f00000
+
+#define DRM_ETNA_GEM_GPUREADONLY     0x01000000
+
+/* bo access flags */
+#define DRM_ETNA_PREP_READ           0x01
+#define DRM_ETNA_PREP_WRITE          0x02
+#define DRM_ETNA_PREP_NOSYNC         0x04
+
+struct viv_conn;
+struct etna_queue;
+struct etna_ctx;
+struct etna_bo;
+
+/* Allocate linear block of video memory */
+struct etna_bo *etna_bo_new(struct viv_conn *conn, size_t bytes, uint32_t flags);
+
+/* Map user memory into GPU memory space */
+struct etna_bo *etna_bo_from_usermem(struct viv_conn *conn, void *memory, size_t size);
+
+/* Buffer object from framebuffer */
+struct etna_bo *etna_bo_from_fbdev(struct viv_conn *conn, size_t offset, size_t size);
+
+/* Buffer object from flink name */
+struct etna_bo *etna_bo_from_name(struct viv_conn *conn, uint32_t name);
+
+/* Increase reference count */
+struct etna_bo *etna_bo_ref(struct etna_bo *bo);
+
+/* Decrease reference count orfree video memory node */
+int etna_bo_del(struct viv_conn *conn, struct etna_bo *mem, struct etna_queue *queue);
+
+/* Return flink name of buffer object */
+int etna_bo_get_name(struct etna_bo *bo, uint32_t *name);
+
+/* Return handle of buffer object */
+uint32_t etna_bo_handle(struct etna_bo *bo);
+
+/* Return size of buffer object */
+uint32_t etna_bo_size(struct etna_bo *bo);
+
+/* Map buffer object into CPU memory and return pointer. If the buffer object
+ * is already mapped, return the existing mapping. */
+void *etna_bo_map(struct etna_bo *bo);
+
+/* Prepare for CPU access to buffer object */
+int etna_bo_cpu_prep(struct etna_bo *bo, struct etna_ctx *pipe, uint32_t op);
+
+/* Finish CPU access to buffer object */
+void etna_bo_cpu_fini(struct etna_bo *bo);
+
+/* Temporary: get GPU address of buffer */
+uint32_t etna_bo_gpu_address(struct etna_bo *bo);
+
+#endif
+
diff --git a/src/etnaviv/etna_mem.c b/src/etnaviv/etna_mem.c
deleted file mode 100644
index bac6dbd..0000000
--- a/src/etnaviv/etna_mem.c
+++ /dev/null
@@ -1,189 +0,0 @@
-/*
- * Copyright (c) 2012-2013 Etnaviv Project
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sub license,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
- * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#include <etnaviv/etna_mem.h>
-#include <etnaviv/etna.h>
-#include <etnaviv/etna_queue.h>
-
-#include <string.h>
-#include <stdlib.h>
-#include <stdio.h>
-
-#include "gc_abi.h"
-
-//#define DEBUG
-#define ETNA_VIDMEM_ALIGNMENT (0x40)
-
-int etna_vidmem_alloc_linear(struct viv_conn *conn, struct etna_vidmem **mem_out, size_t bytes, enum viv_surf_type type, enum viv_pool pool, bool lock)
-{
-    if(mem_out == NULL) return ETNA_INVALID_ADDR;
-    struct etna_vidmem *mem = ETNA_CALLOC_STRUCT(etna_vidmem);
-    if(mem == NULL) return ETNA_OUT_OF_MEMORY;
-
-    mem->type = type;
-
-    if(viv_alloc_linear_vidmem(conn, bytes, ETNA_VIDMEM_ALIGNMENT, type, pool, &mem->node, &mem->size)!=0)
-    {
-#ifdef DEBUG
-        fprintf(stderr, "Error allocating render target tile status memory\n");
-#endif
-        return ETNA_OUT_OF_MEMORY;
-    }
-#ifdef DEBUG
-    printf("Allocated: node=%08x size=%08x\n", (uint32_t)mem->node, mem->size);
-#endif
-    if(lock)
-    {
-        int status = etna_vidmem_lock(conn, mem);
-        if(status != ETNA_OK)
-        {
-            etna_vidmem_free(conn, mem);
-            return status;
-        }
-    }
-    *mem_out = mem;
-    return ETNA_OK;
-}
-
-int etna_vidmem_lock(struct viv_conn *conn, struct etna_vidmem *mem)
-{
-    if(mem == NULL) return ETNA_INVALID_ADDR;
-    if(mem->logical != NULL) return ETNA_ALREADY_LOCKED;
-
-    if(viv_lock_vidmem(conn, mem->node, &mem->address, &mem->logical)!=0)
-    {
-#ifdef DEBUG
-        fprintf(stderr, "Error locking render target memory\n");
-#endif
-        return ETNA_INTERNAL_ERROR;
-    }
-#ifdef DEBUG
-    printf("Locked: phys=%08x log=%08x\n", (uint32_t)mem->address, (uint32_t)mem->logical);
-#endif
-
-    return ETNA_OK;
-}
-
-int etna_vidmem_unlock(struct viv_conn *conn, struct etna_queue *queue, struct etna_vidmem *mem)
-{
-    if(mem == NULL) return ETNA_INVALID_ADDR;
-    int async = 0;
-    /* Unlocking video memory seems to be a two-step process. First try it synchronously
-     * then the kernel can request an asynchronous component. Just queueing it asynchronously
-     * in the first place will not free the virtual memory on v4 */
-    if(viv_unlock_vidmem(conn, mem->node, mem->type, false, &async) != ETNA_OK)
-    {
-        return ETNA_INTERNAL_ERROR;
-    }
-    if(async)
-    {
-        if(queue)
-        {
-            /* If a queue is passed, add the async part at the end of the queue, to be submitted
-             * with next flush.
-             */
-            if(etna_queue_unlock_vidmem(queue, mem->node, mem->type) != ETNA_OK)
-            {
-                return ETNA_INTERNAL_ERROR;
-            }
-        } else { /* No queue, need to submit async part directly as event */
-            if(viv_unlock_vidmem(conn, mem->node, mem->type, true, &async) != ETNA_OK)
-            {
-                return ETNA_INTERNAL_ERROR;
-            }
-        }
-    }
-    mem->logical = NULL;
-    mem->address = 0;
-    return ETNA_OK;
-}
-
-int etna_vidmem_free(struct viv_conn *conn, struct etna_vidmem *mem)
-{
-    if(mem == NULL) return ETNA_OK;
-    if(mem->logical != NULL)
-    {
-        if(etna_vidmem_unlock(conn, NULL, mem) != ETNA_OK)
-        {
-            printf("etna: Warning: could not unlock memory\n");
-        }
-    }
-    if(viv_free_vidmem(conn, mem->node) != ETNA_OK)
-    {
-        printf("etna: Warning: could not free video memory\n");
-    }
-    ETNA_FREE(mem);
-    return ETNA_OK;
-}
-
-int etna_vidmem_queue_free(struct etna_queue *queue, struct etna_vidmem *mem)
-{
-    if(mem == NULL) return ETNA_OK;
-    if(mem->logical != NULL)
-    {
-        if(etna_vidmem_unlock(queue->ctx->conn, queue, mem) != ETNA_OK)
-        {
-            printf("etna: Warning: could not queue unlock memory\n");
-        }
-    }
-    if(etna_queue_free_vidmem(queue, mem->node) != ETNA_OK)
-    {
-        printf("etna: Warning: could not queue free video memory\n");
-    }
-    ETNA_FREE(mem);
-    return ETNA_OK;
-}
-
-int etna_usermem_map(struct viv_conn *conn, struct etna_usermem **mem_out, void *memory, size_t size)
-{
-    if(mem_out == NULL) return ETNA_INVALID_ADDR;
-    struct etna_usermem *mem = ETNA_CALLOC_STRUCT(etna_usermem);
-
-    mem->memory = memory;
-    mem->size = size;
-
-    if(viv_map_user_memory(conn, memory, size, &mem->info, &mem->address)!=0)
-    {
-        return ETNA_INTERNAL_ERROR;
-    }
-
-    *mem_out = mem;
-    return ETNA_OK;
-}
-
-int etna_usermem_unmap(struct viv_conn *conn, struct etna_usermem *mem)
-{
-    if(mem == NULL) return ETNA_INVALID_ADDR;
-    viv_unmap_user_memory(conn, mem->memory, mem->size, mem->info, mem->address);
-    ETNA_FREE(mem);
-    return ETNA_OK;
-}
-
-int etna_usermem_queue_unmap(struct etna_queue *queue, struct etna_usermem *mem)
-{
-    if(mem == NULL) return ETNA_INVALID_ADDR;
-    etna_queue_unmap_user_memory(queue, mem->memory, mem->size, mem->info, mem->address);
-    ETNA_FREE(mem);
-    return ETNA_OK;
-}
-
-
diff --git a/src/etnaviv/etna_mem.h b/src/etnaviv/etna_mem.h
deleted file mode 100644
index 165295d..0000000
--- a/src/etnaviv/etna_mem.h
+++ /dev/null
@@ -1,74 +0,0 @@
-/*
- * Copyright (c) 2012-2013 Etnaviv Project
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sub license,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
- * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-/* etna: memory management functions */
-#ifndef H_ETNA_MEM
-#define H_ETNA_MEM
-
-#include <etnaviv/viv.h>
-#include <stdbool.h>
-
-/* Structure describing a block of video memory */
-struct etna_vidmem {
-    size_t size;
-    enum viv_surf_type type;
-    viv_node_t node;
-    viv_addr_t address;
-    void *logical;
-};
-
-/* Structure describing a block of mapped user memory */
-struct etna_usermem {
-    void *memory;
-    size_t size;
-    viv_usermem_t info;
-    viv_addr_t address;
-};
-
-struct etna_queue;
-
-/* Allocate linear block of video memory */
-int etna_vidmem_alloc_linear(struct viv_conn *conn, struct etna_vidmem **mem_out, size_t bytes, enum viv_surf_type type, enum viv_pool pool, bool lock);
-
-/* Lock video memory into GPU and CPU memory space */
-int etna_vidmem_lock(struct viv_conn *conn, struct etna_vidmem *mem);
-
-/* Unlock video memory. Pass a queue for deferred usage, otherwise pass queue as NULL. */
-int etna_vidmem_unlock(struct viv_conn *conn, struct etna_queue *queue, struct etna_vidmem *mem);
-
-/* Free video memory node */
-int etna_vidmem_free(struct viv_conn *conn, struct etna_vidmem *mem);
-
-/* Deferred free video memory node */
-int etna_vidmem_queue_free(struct etna_queue *queue, struct etna_vidmem *mem);
-
-/* Map user memory into GPU memory space */
-int etna_usermem_map(struct viv_conn *conn, struct etna_usermem **mem_out, void *memory, size_t size);
-
-/* Unmap user memory from GPU memory space */
-int etna_usermem_unmap(struct viv_conn *conn, struct etna_usermem *mem);
-
-/* Deferred unmap user memory */
-int etna_usermem_queue_unmap(struct etna_queue *queue, struct etna_usermem *mem);
-
-#endif
-
diff --git a/src/fb_old/cube_companion.c b/src/fb_old/cube_companion.c
index 34c764d..f005a0f 100644
--- a/src/fb_old/cube_companion.c
+++ b/src/fb_old/cube_companion.c
@@ -57,7 +57,7 @@
 #include <etnaviv/viv.h>
 #include <etnaviv/etna.h>
 #include <etnaviv/etna_rs.h>
-#include <etnaviv/etna_mem.h>
+#include <etnaviv/etna_bo.h>
 #include <etnaviv/etna_util.h>
 
 #include "write_bmp.h"
@@ -143,16 +143,16 @@ int main(int argc, char **argv)
 
     printf("padded_width %i padded_height %i\n", padded_width, padded_height);
 
-    struct etna_vidmem *rt = 0; /* main render target */
-    struct etna_vidmem *rt_ts = 0; /* tile status for main render target */
-    struct etna_vidmem *z = 0; /* depth for main render target */
-    struct etna_vidmem *z_ts = 0; /* depth ts for main render target */
-    struct etna_vidmem *vtx = 0; /* vertex buffer */
-    struct etna_vidmem *idx = 0; /* index buffer */
-    struct etna_vidmem *aux_rt = 0; /* auxilary render target */
-    struct etna_vidmem *aux_rt_ts = 0; /* tile status for auxilary render target */
-    struct etna_vidmem *tex = 0; /* texture */
-    struct etna_vidmem *bmp = 0; /* bitmap */
+    struct etna_bo *rt = 0; /* main render target */
+    struct etna_bo *rt_ts = 0; /* tile status for main render target */
+    struct etna_bo *z = 0; /* depth for main render target */
+    struct etna_bo *z_ts = 0; /* depth ts for main render target */
+    struct etna_bo *vtx = 0; /* vertex buffer */
+    struct etna_bo *idx = 0; /* index buffer */
+    struct etna_bo *aux_rt = 0; /* auxilary render target */
+    struct etna_bo *aux_rt_ts = 0; /* tile status for auxilary render target */
+    struct etna_bo *tex = 0; /* texture */
+    struct etna_bo *bmp = 0; /* bitmap */
 
     /* TODO: anti aliasing (doubles width/height) */
     size_t rt_size = padded_width * padded_height * 4;
@@ -161,16 +161,16 @@ int main(int argc, char **argv)
     size_t z_ts_size = etna_align_up((padded_width * padded_height * 2)*bits_per_tile/0x80, 0x100);
     size_t bmp_size = width * height * 4;
 
-    if(etna_vidmem_alloc_linear(conn, &rt, rt_size, VIV_SURF_RENDER_TARGET, VIV_POOL_DEFAULT, true)!=ETNA_OK ||
-       etna_vidmem_alloc_linear(conn, &rt_ts, rt_ts_size, VIV_SURF_TILE_STATUS, VIV_POOL_DEFAULT, true)!=ETNA_OK ||
-       etna_vidmem_alloc_linear(conn, &z, z_size, VIV_SURF_DEPTH, VIV_POOL_DEFAULT, true)!=ETNA_OK ||
-       etna_vidmem_alloc_linear(conn, &z_ts, z_ts_size, VIV_SURF_TILE_STATUS, VIV_POOL_DEFAULT, true)!=ETNA_OK ||
-       etna_vidmem_alloc_linear(conn, &vtx, VERTEX_BUFFER_SIZE, VIV_SURF_VERTEX, VIV_POOL_DEFAULT, true)!=ETNA_OK ||
-       etna_vidmem_alloc_linear(conn, &idx, INDEX_BUFFER_SIZE, VIV_SURF_INDEX, VIV_POOL_DEFAULT, true)!=ETNA_OK ||
-       etna_vidmem_alloc_linear(conn, &aux_rt, 0x4000, VIV_SURF_RENDER_TARGET, VIV_POOL_SYSTEM, true)!=ETNA_OK ||
-       etna_vidmem_alloc_linear(conn, &aux_rt_ts, 0x100, VIV_SURF_TILE_STATUS, VIV_POOL_DEFAULT, true)!=ETNA_OK ||
-       etna_vidmem_alloc_linear(conn, &tex, 0x100000, VIV_SURF_TEXTURE, VIV_POOL_DEFAULT, true)!=ETNA_OK ||
-       etna_vidmem_alloc_linear(conn, &bmp, bmp_size, VIV_SURF_BITMAP, VIV_POOL_DEFAULT, true)!=ETNA_OK
+    if((rt=etna_bo_new(conn, rt_size, DRM_ETNA_GEM_TYPE_RT))==NULL ||
+       (rt_ts=etna_bo_new(conn, rt_ts_size, DRM_ETNA_GEM_TYPE_TS))==NULL ||
+       (z=etna_bo_new(conn, z_size, DRM_ETNA_GEM_TYPE_ZS))==NULL ||
+       (z_ts=etna_bo_new(conn, z_ts_size, DRM_ETNA_GEM_TYPE_TS))==NULL ||
+       (vtx=etna_bo_new(conn, VERTEX_BUFFER_SIZE, DRM_ETNA_GEM_TYPE_VTX))==NULL ||
+       (idx=etna_bo_new(conn, INDEX_BUFFER_SIZE, DRM_ETNA_GEM_TYPE_IDX))==NULL ||
+       (aux_rt=etna_bo_new(conn, 0x4000, DRM_ETNA_GEM_TYPE_RT))==NULL ||
+       (aux_rt_ts=etna_bo_new(conn, 0x100, DRM_ETNA_GEM_TYPE_TS))==NULL ||
+       (tex=etna_bo_new(conn, 0x100000, DRM_ETNA_GEM_TYPE_TEX))==NULL ||
+       (bmp=etna_bo_new(conn, bmp_size, DRM_ETNA_GEM_TYPE_BMP))==NULL
        )
     {
         fprintf(stderr, "Error allocating video memory\n");
@@ -182,7 +182,7 @@ int main(int argc, char **argv)
      * Unlike the GL example we only do this once, not every time glDrawArrays is called, the same would be accomplished
      * from GL by using a vertex buffer object.
      */
-    memset(vtx->logical, 0, 0x5ef80);
+    memset(etna_bo_map(vtx), 0, VERTEX_BUFFER_SIZE);
 #ifndef INDEXED
     printf("Interleaving vertices...\n");
     float *vertices_array = companion_vertices_array();
@@ -190,31 +190,33 @@ int main(int argc, char **argv)
             companion_texture_coordinates_array();
     float *normals_array = companion_normals_array();
     assert(COMPANION_ARRAY_COUNT*(3+3+2)*sizeof(float) < VERTEX_BUFFER_SIZE);
+    float *vtx_map = (float*)etna_bo_map(vtx);
     for(int vert=0; vert<COMPANION_ARRAY_COUNT; ++vert)
     {
         int dest_idx = vert * (3 + 3 + 2);
         for(int comp=0; comp<3; ++comp)
-            ((float*)vtx->logical)[dest_idx+comp+0] = vertices_array[vert*3 + comp]; /* 0 */
+            vtx_map[dest_idx+comp+0] = vertices_array[vert*3 + comp]; /* 0 */
         for(int comp=0; comp<3; ++comp)
-            ((float*)vtx->logical)[dest_idx+comp+3] = normals_array[vert*3 + comp]; /* 1 */
+            vtx_map[dest_idx+comp+3] = normals_array[vert*3 + comp]; /* 1 */
         for(int comp=0; comp<2; ++comp)
-            ((float*)vtx->logical)[dest_idx+comp+6] = texture_coordinates_array[vert*2 + comp]; /* 2 */
+            vtx_map[dest_idx+comp+6] = texture_coordinates_array[vert*2 + comp]; /* 2 */
     }
 #else
     printf("Interleaving vertices and copying index buffer...\n");
     assert(COMPANION_VERTEX_COUNT*(3+3+2)*sizeof(float) < VERTEX_BUFFER_SIZE);
+    float *vtx_map = (float*)etna_bo_map(vtx);
     for(int vert=0; vert<COMPANION_VERTEX_COUNT; ++vert)
     {
         int dest_idx = vert * (3 + 3 + 2);
         for(int comp=0; comp<3; ++comp)
-            ((float*)vtx->logical)[dest_idx+comp+0] = companion_vertices[vert][comp]; /* 0 */
+            vtx_map[dest_idx+comp+0] = companion_vertices[vert][comp]; /* 0 */
         for(int comp=0; comp<3; ++comp)
-            ((float*)vtx->logical)[dest_idx+comp+3] = companion_normals[vert][comp]; /* 1 */
+            vtx_map[dest_idx+comp+3] = companion_normals[vert][comp]; /* 1 */
         for(int comp=0; comp<2; ++comp)
-            ((float*)vtx->logical)[dest_idx+comp+6] = companion_texture_coordinates[vert][comp]; /* 2 */
+            vtx_map[dest_idx+comp+6] = companion_texture_coordinates[vert][comp]; /* 2 */
     }
     assert(COMPANION_TRIANGLE_COUNT*3*sizeof(unsigned short) < INDEX_BUFFER_SIZE);
-    memcpy(idx->logical, &companion_triangles[0][0], COMPANION_TRIANGLE_COUNT*3*sizeof(unsigned short));
+    memcpy(etna_bo_map(idx), &companion_triangles[0][0], COMPANION_TRIANGLE_COUNT*3*sizeof(unsigned short));
 #endif
     /* Fill in texture (convert from RGB linear to tiled) */
 #define TILE_WIDTH (4)
@@ -223,6 +225,7 @@ int main(int argc, char **argv)
     unsigned ytiles = COMPANION_TEXTURE_HEIGHT / TILE_HEIGHT;
     unsigned xtiles = COMPANION_TEXTURE_WIDTH / TILE_WIDTH;
     unsigned dst_stride = xtiles * TILE_WORDS;
+    uint32_t *tex_map = (uint32_t*)etna_bo_map(tex);
 
     for(unsigned ty=0; ty<ytiles; ++ty)
     {
@@ -246,7 +249,7 @@ int main(int argc, char **argv)
 #endif
                     a = 255;
 
-                    ((uint32_t*)tex->logical)[ofs] = ((a&0xFF) << 24) | ((b&0xFF) << 16) | ((g&0xFF) << 8) | (r&0xFF);
+                    tex_map[ofs] = ((a&0xFF) << 24) | ((b&0xFF) << 16) | ((g&0xFF) << 8) | (r&0xFF);
                     ofs += 1;
                 }
             }
@@ -315,7 +318,7 @@ int main(int argc, char **argv)
                 ETNA_MASKED(VIVS_PE_COLOR_FORMAT_FORMAT, RS_FORMAT_X8R8G8B8) &
                 ETNA_MASKED_BIT(VIVS_PE_COLOR_FORMAT_SUPER_TILED, supertiled));
 
-        etna_set_state(ctx, VIVS_PE_COLOR_ADDR, rt->address);
+        etna_set_state(ctx, VIVS_PE_COLOR_ADDR, etna_bo_gpu_address(rt));
         etna_set_state(ctx, VIVS_PE_COLOR_STRIDE, padded_width * 4);
 
         uint32_t ts_msaa_config;
@@ -374,23 +377,23 @@ int main(int argc, char **argv)
         etna_set_state(ctx, VIVS_GL_FLUSH_CACHE, VIVS_GL_FLUSH_CACHE_COLOR);
 
         etna_set_state(ctx, VIVS_TS_COLOR_CLEAR_VALUE, 0);
-        etna_set_state(ctx, VIVS_TS_COLOR_STATUS_BASE, rt_ts->address);
-        etna_set_state(ctx, VIVS_TS_COLOR_SURFACE_BASE, rt->address);
+        etna_set_state(ctx, VIVS_TS_COLOR_STATUS_BASE, etna_bo_gpu_address(rt_ts));
+        etna_set_state(ctx, VIVS_TS_COLOR_SURFACE_BASE, etna_bo_gpu_address(rt));
 
         etna_set_state(ctx, VIVS_PE_DEPTH_CONFIG,
                 ETNA_MASKED_BIT(VIVS_PE_DEPTH_CONFIG_WRITE_ENABLE, 0) &
                 ETNA_MASKED_INL(VIVS_PE_DEPTH_CONFIG_DEPTH_FORMAT, D16) &
                 ETNA_MASKED_BIT(VIVS_PE_DEPTH_CONFIG_SUPER_TILED, supertiled) &
                 ETNA_MASKED_BIT(VIVS_PE_DEPTH_CONFIG_EARLY_Z, 1));
-        etna_set_state(ctx, VIVS_PE_DEPTH_ADDR, z->address);
+        etna_set_state(ctx, VIVS_PE_DEPTH_ADDR, etna_bo_gpu_address(z));
         etna_set_state(ctx, VIVS_PE_DEPTH_STRIDE, padded_width * 2);
         etna_set_state(ctx, VIVS_PE_HDEPTH_CONTROL, VIVS_PE_HDEPTH_CONTROL_FORMAT_DISABLED);
         etna_set_state_f32(ctx, VIVS_PE_DEPTH_NORMALIZE, 65535.0);
         etna_set_state(ctx, VIVS_GL_FLUSH_CACHE, VIVS_GL_FLUSH_CACHE_DEPTH);
 
         etna_set_state(ctx, VIVS_TS_DEPTH_CLEAR_VALUE, 0xffffffff);
-        etna_set_state(ctx, VIVS_TS_DEPTH_STATUS_BASE, z_ts->address);
-        etna_set_state(ctx, VIVS_TS_DEPTH_SURFACE_BASE, z->address);
+        etna_set_state(ctx, VIVS_TS_DEPTH_STATUS_BASE, etna_bo_gpu_address(z_ts));
+        etna_set_state(ctx, VIVS_TS_DEPTH_SURFACE_BASE, etna_bo_gpu_address(z));
         etna_set_state(ctx, VIVS_TS_MEM_CONFIG,
                 VIVS_TS_MEM_CONFIG_DEPTH_FAST_CLEAR |
                 VIVS_TS_MEM_CONFIG_COLOR_FAST_CLEAR |
@@ -401,7 +404,7 @@ int main(int argc, char **argv)
 #ifdef EXTRA_DELAYS
         /* Warm up RS on aux render target (is this needed?) */
         etna_set_state(ctx, VIVS_GL_FLUSH_CACHE, VIVS_GL_FLUSH_CACHE_COLOR | VIVS_GL_FLUSH_CACHE_DEPTH);
-        etna_warm_up_rs(ctx, aux_rt->address, aux_rt_ts->address);
+        etna_warm_up_rs(ctx, etna_bo_gpu_address(aux_rt), etna_bo_gpu_address(aux_rt_ts));
 
         etna_set_state(ctx, VIVS_TS_COLOR_STATUS_BASE, rt_ts_physical);
         etna_set_state(ctx, VIVS_TS_COLOR_SURFACE_BASE, rt_physical);
@@ -435,14 +438,14 @@ int main(int argc, char **argv)
                 (0xffff << VIVS_RS_CLEAR_CONTROL_BITS__SHIFT));
         etna_set_state(ctx, VIVS_RS_EXTRA_CONFIG, 0);
         /*    clear color ts */
-        etna_set_state(ctx, VIVS_RS_DEST_ADDR, rt_ts->address);
+        etna_set_state(ctx, VIVS_RS_DEST_ADDR, etna_bo_gpu_address(rt_ts));
         etna_set_state(ctx, VIVS_RS_DEST_STRIDE, 0x40);
         etna_set_state(ctx, VIVS_RS_WINDOW_SIZE,
                 ((rt_ts_size/0x40) << VIVS_RS_WINDOW_SIZE_HEIGHT__SHIFT) |
                 (16 << VIVS_RS_WINDOW_SIZE_WIDTH__SHIFT));
         etna_set_state(ctx, VIVS_RS_KICKER, 0xbeebbeeb);
         /*    clear depth ts */
-        etna_set_state(ctx, VIVS_RS_DEST_ADDR, z_ts->address);
+        etna_set_state(ctx, VIVS_RS_DEST_ADDR, etna_bo_gpu_address(z_ts));
         etna_set_state(ctx, VIVS_RS_DEST_STRIDE, 0x40);
         etna_set_state(ctx, VIVS_RS_WINDOW_SIZE,
                 ((z_ts_size/0x40) << VIVS_RS_WINDOW_SIZE_HEIGHT__SHIFT) |
@@ -453,8 +456,8 @@ int main(int argc, char **argv)
         etna_set_state(ctx, VIVS_TS_COLOR_CLEAR_VALUE, 0xff7f7f7f);
         etna_set_state(ctx, VIVS_GL_FLUSH_CACHE, VIVS_GL_FLUSH_CACHE_COLOR);
 
-        etna_set_state(ctx, VIVS_TS_COLOR_STATUS_BASE, rt_ts->address);
-        etna_set_state(ctx, VIVS_TS_COLOR_SURFACE_BASE, rt->address);
+        etna_set_state(ctx, VIVS_TS_COLOR_STATUS_BASE, etna_bo_gpu_address(rt_ts));
+        etna_set_state(ctx, VIVS_TS_COLOR_SURFACE_BASE, etna_bo_gpu_address(rt));
         etna_set_state(ctx, VIVS_GL_FLUSH_CACHE, VIVS_GL_FLUSH_CACHE_COLOR | VIVS_GL_FLUSH_CACHE_DEPTH);
 
         /* depth setup */
@@ -485,7 +488,7 @@ int main(int argc, char **argv)
         etna_set_state(ctx, VIVS_TE_SAMPLER_LOG_SIZE(0),
                 VIVS_TE_SAMPLER_LOG_SIZE_WIDTH(9<<5) |
                 VIVS_TE_SAMPLER_LOG_SIZE_HEIGHT(9<<5));
-        etna_set_state(ctx, VIVS_TE_SAMPLER_LOD_ADDR(0,0), tex->address);
+        etna_set_state(ctx, VIVS_TE_SAMPLER_LOD_ADDR(0,0), etna_bo_gpu_address(tex));
         etna_set_state(ctx, VIVS_TE_SAMPLER_CONFIG0(0),
                 VIVS_TE_SAMPLER_CONFIG0_TYPE(TEXTURE_TYPE_2D)|
                 VIVS_TE_SAMPLER_CONFIG0_UWRAP(TEXTURE_WRAPMODE_CLAMP_TO_EDGE)|
@@ -570,10 +573,10 @@ int main(int argc, char **argv)
         etna_set_state_multi(ctx, VIVS_VS_UNIFORMS(24), 3, (uint32_t*)&normal.m[2][0]); /* u6.xyz */
         etna_set_state_multi(ctx, VIVS_VS_UNIFORMS(28), 16, (uint32_t*)&modelview.m[0][0]);
 #ifdef INDEXED
-        etna_set_state(ctx, VIVS_FE_INDEX_STREAM_BASE_ADDR, idx->address);
+        etna_set_state(ctx, VIVS_FE_INDEX_STREAM_BASE_ADDR, etna_bo_gpu_address(idx));
         etna_set_state(ctx, VIVS_FE_INDEX_STREAM_CONTROL, VIVS_FE_INDEX_STREAM_CONTROL_TYPE_UNSIGNED_SHORT);
 #endif
-        etna_set_state(ctx, VIVS_FE_VERTEX_STREAM_BASE_ADDR, vtx->address);
+        etna_set_state(ctx, VIVS_FE_VERTEX_STREAM_BASE_ADDR, etna_bo_gpu_address(vtx));
         etna_set_state(ctx, VIVS_FE_VERTEX_STREAM_CONTROL,
                 FE_VERTEX_STREAM_CONTROL_VERTEX_STRIDE((3 + 3 + 2)*4));
         etna_set_state(ctx, VIVS_FE_VERTEX_ELEMENT_CONFIG(0),
@@ -625,8 +628,8 @@ int main(int argc, char **argv)
         etna_set_state(ctx, VIVS_RS_DITHER(1), 0xffffffff);
         etna_set_state(ctx, VIVS_RS_CLEAR_CONTROL, VIVS_RS_CLEAR_CONTROL_MODE_DISABLED);
         etna_set_state(ctx, VIVS_RS_EXTRA_CONFIG, 0);
-        etna_set_state(ctx, VIVS_RS_SOURCE_ADDR, rt->address);
-        etna_set_state(ctx, VIVS_RS_DEST_ADDR, rt->address);
+        etna_set_state(ctx, VIVS_RS_SOURCE_ADDR, etna_bo_gpu_address(rt));
+        etna_set_state(ctx, VIVS_RS_DEST_ADDR, etna_bo_gpu_address(rt));
         etna_set_state(ctx, VIVS_RS_WINDOW_SIZE,
                 VIVS_RS_WINDOW_SIZE_HEIGHT(padded_height) |
                 VIVS_RS_WINDOW_SIZE_WIDTH(padded_width));
@@ -634,11 +637,11 @@ int main(int argc, char **argv)
 #ifdef EXTRA_DELAYS
         etna_flush(ctx, NULL);
 
-        etna_warm_up_rs(ctx, aux_rt->address, aux_rt_ts->address);
+        etna_warm_up_rs(ctx, etna_bo_gpu_address(aux_rt), etna_bo_gpu_address(aux_rt_ts));
 #endif
 
-        etna_set_state(ctx, VIVS_TS_COLOR_STATUS_BASE, rt_ts->address);
-        etna_set_state(ctx, VIVS_TS_COLOR_SURFACE_BASE, rt->address);
+        etna_set_state(ctx, VIVS_TS_COLOR_STATUS_BASE, etna_bo_gpu_address(rt_ts));
+        etna_set_state(ctx, VIVS_TS_COLOR_SURFACE_BASE, etna_bo_gpu_address(rt));
         etna_set_state(ctx, VIVS_GL_FLUSH_CACHE, VIVS_GL_FLUSH_CACHE_COLOR);
         etna_set_state(ctx, VIVS_TS_MEM_CONFIG,
                 VIVS_TS_MEM_CONFIG_DEPTH_FAST_CLEAR |
@@ -668,7 +671,7 @@ int main(int argc, char **argv)
         etna_set_state(ctx, VIVS_RS_DITHER(1), 0xffffffff);
         etna_set_state(ctx, VIVS_RS_CLEAR_CONTROL, VIVS_RS_CLEAR_CONTROL_MODE_DISABLED);
         etna_set_state(ctx, VIVS_RS_EXTRA_CONFIG, 0);
-        etna_set_state(ctx, VIVS_RS_SOURCE_ADDR, rt->address);
+        etna_set_state(ctx, VIVS_RS_SOURCE_ADDR, etna_bo_gpu_address(rt));
         etna_set_state(ctx, VIVS_RS_DEST_ADDR, fbs->fb.physical[backbuffer]);
         etna_set_state(ctx, VIVS_RS_WINDOW_SIZE,
                 VIVS_RS_WINDOW_SIZE_HEIGHT(height * supersample_y) |
diff --git a/src/fb_old/etna_test.c b/src/fb_old/etna_test.c
index cf6f93c..7b65144 100644
--- a/src/fb_old/etna_test.c
+++ b/src/fb_old/etna_test.c
@@ -46,7 +46,7 @@
 #include "etna.h"
 #include "etna_rs.h"
 #include "etna_fb.h"
-#include "etna_mem.h"
+#include "etna_bo.h"
 #include "etna_util.h"
 
 #include "esTransform.h"
@@ -98,14 +98,14 @@ int main(int argc, char **argv)
     }
     printf("Succesfully opened device\n");
 
-    struct etna_vidmem *rt = 0; /* main render target */
-    struct etna_vidmem *rt_ts = 0; /* tile status for main render target */
-    struct etna_vidmem *z = 0; /* depth for main render target */
-    struct etna_vidmem *z_ts = 0; /* depth ts for main render target */
-    struct etna_vidmem *vtx = 0; /* vertex buffer */
-    struct etna_vidmem *aux_rt = 0; /* auxilary render target */
-    struct etna_vidmem *aux_rt_ts = 0; /* tile status for auxilary render target */
-    struct etna_vidmem *bmp = 0; /* bitmap */
+    struct etna_bo *rt = 0; /* main render target */
+    struct etna_bo *rt_ts = 0; /* tile status for main render target */
+    struct etna_bo *z = 0; /* depth for main render target */
+    struct etna_bo *z_ts = 0; /* depth ts for main render target */
+    struct etna_bo *vtx = 0; /* vertex buffer */
+    struct etna_bo *aux_rt = 0; /* auxilary render target */
+    struct etna_bo *aux_rt_ts = 0; /* tile status for auxilary render target */
+    struct etna_bo *bmp = 0; /* bitmap */
 
     size_t rt_size = padded_width * padded_height * 4;
     size_t rt_ts_size = etna_align_up((padded_width * padded_height * 4)/0x100, 0x100);
@@ -113,14 +113,14 @@ int main(int argc, char **argv)
     size_t z_ts_size = etna_align_up((padded_width * padded_height * 2)/0x100, 0x100);
     size_t bmp_size = width * height * 4;
 
-    if(etna_vidmem_alloc_linear(conn, &rt, rt_size, gcvSURF_RENDER_TARGET, gcvPOOL_DEFAULT, true)!=ETNA_OK ||
-       etna_vidmem_alloc_linear(conn, &rt_ts, rt_ts_size, gcvSURF_TILE_STATUS, gcvPOOL_DEFAULT, true)!=ETNA_OK ||
-       etna_vidmem_alloc_linear(conn, &z, z_size, gcvSURF_DEPTH, gcvPOOL_DEFAULT, true)!=ETNA_OK ||
-       etna_vidmem_alloc_linear(conn, &z_ts, z_ts_size, gcvSURF_TILE_STATUS, gcvPOOL_DEFAULT, true)!=ETNA_OK ||
-       etna_vidmem_alloc_linear(conn, &vtx, VERTEX_BUFFER_SIZE, gcvSURF_VERTEX, gcvPOOL_DEFAULT, true)!=ETNA_OK ||
-       etna_vidmem_alloc_linear(conn, &aux_rt, 0x4000, gcvSURF_RENDER_TARGET, gcvPOOL_SYSTEM, true)!=ETNA_OK ||
-       etna_vidmem_alloc_linear(conn, &aux_rt_ts, 0x100, gcvSURF_TILE_STATUS, gcvPOOL_DEFAULT, true)!=ETNA_OK ||
-       etna_vidmem_alloc_linear(conn, &bmp, bmp_size, gcvSURF_BITMAP, gcvPOOL_DEFAULT, true)!=ETNA_OK
+    if(etna_bo_new(conn, &rt, rt_size, gcvSURF_RENDER_TARGET, gcvPOOL_DEFAULT, true)!=ETNA_OK ||
+       etna_bo_new(conn, &rt_ts, rt_ts_size, gcvSURF_TILE_STATUS, gcvPOOL_DEFAULT, true)!=ETNA_OK ||
+       etna_bo_new(conn, &z, z_size, gcvSURF_DEPTH, gcvPOOL_DEFAULT, true)!=ETNA_OK ||
+       etna_bo_new(conn, &z_ts, z_ts_size, gcvSURF_TILE_STATUS, gcvPOOL_DEFAULT, true)!=ETNA_OK ||
+       etna_bo_new(conn, &vtx, VERTEX_BUFFER_SIZE, gcvSURF_VERTEX, gcvPOOL_DEFAULT, true)!=ETNA_OK ||
+       etna_bo_new(conn, &aux_rt, 0x4000, gcvSURF_RENDER_TARGET, gcvPOOL_SYSTEM, true)!=ETNA_OK ||
+       etna_bo_new(conn, &aux_rt_ts, 0x100, gcvSURF_TILE_STATUS, gcvPOOL_DEFAULT, true)!=ETNA_OK ||
+       etna_bo_new(conn, &bmp, bmp_size, gcvSURF_BITMAP, gcvPOOL_DEFAULT, true)!=ETNA_OK
        )
     {
         fprintf(stderr, "Error allocating video memory\n");
@@ -132,13 +132,14 @@ int main(int argc, char **argv)
      * Unlike the GL example we only do this once, not every time glDrawArrays is called, the same would be accomplished
      * from GL by using a vertex buffer object.
      */
+    float *vtx_map = (float*)etna_bo_map(vtx);
     for(int vert=0; vert<NUM_VERTICES; ++vert)
     {
         int dest_idx = vert * (3 + 2);
         for(int comp=0; comp<3; ++comp)
-            ((float*)vtx->logical)[dest_idx+comp+0] = vVertices[vert*3 + comp]; /* 0 */
+            vtx_map[dest_idx+comp+0] = vVertices[vert*3 + comp]; /* 0 */
         for(int comp=0; comp<2; ++comp)
-            ((float*)vtx->logical)[dest_idx+comp+3] = vTexCoords[vert*2 + comp]; /* 1 */
+            vtx_map[dest_idx+comp+3] = vTexCoords[vert*2 + comp]; /* 1 */
     }
     struct etna_ctx *ctx = 0;
     if(etna_create(conn, &ctx) != ETNA_OK)
@@ -235,7 +236,7 @@ int main(int argc, char **argv)
                 ETNA_MASKED(VIVS_PE_COLOR_FORMAT_FORMAT, RS_FORMAT_A8R8G8B8) &
                 ETNA_MASKED_BIT(VIVS_PE_COLOR_FORMAT_SUPER_TILED, 1));
 
-        etna_set_state(ctx, VIVS_PE_COLOR_ADDR, rt->address); /* ADDR_A */
+        etna_set_state(ctx, VIVS_PE_COLOR_ADDR, etna_bo_gpu_address(rt)); /* ADDR_A */
         etna_set_state(ctx, VIVS_PE_COLOR_STRIDE, padded_width * 4); 
         etna_set_state(ctx, VIVS_GL_MULTI_SAMPLE_CONFIG, 
                 ETNA_MASKED_INL(VIVS_GL_MULTI_SAMPLE_CONFIG_MSAA_SAMPLES, NONE) &
@@ -248,15 +249,15 @@ int main(int argc, char **argv)
         etna_set_state(ctx, VIVS_GL_FLUSH_CACHE, VIVS_GL_FLUSH_CACHE_COLOR);
 
         etna_set_state(ctx, VIVS_TS_COLOR_CLEAR_VALUE, 0);
-        etna_set_state(ctx, VIVS_TS_COLOR_STATUS_BASE, rt_ts->address); /* ADDR_B */
-        etna_set_state(ctx, VIVS_TS_COLOR_SURFACE_BASE, rt->address); /* ADDR_A */
+        etna_set_state(ctx, VIVS_TS_COLOR_STATUS_BASE, etna_bo_gpu_address(rt_ts)); /* ADDR_B */
+        etna_set_state(ctx, VIVS_TS_COLOR_SURFACE_BASE, etna_bo_gpu_address(rt)); /* ADDR_A */
         etna_set_state(ctx, VIVS_TS_MEM_CONFIG, VIVS_TS_MEM_CONFIG_COLOR_FAST_CLEAR); /* ADDR_A */
 
         etna_set_state(ctx, VIVS_PE_DEPTH_CONFIG, 
                 ETNA_MASKED_INL(VIVS_PE_DEPTH_CONFIG_DEPTH_FORMAT, D16) &
                 ETNA_MASKED_BIT(VIVS_PE_DEPTH_CONFIG_SUPER_TILED, 1)
                 );
-        etna_set_state(ctx, VIVS_PE_DEPTH_ADDR, z->address); /* ADDR_C */
+        etna_set_state(ctx, VIVS_PE_DEPTH_ADDR, etna_bo_gpu_address(z)); /* ADDR_C */
         etna_set_state(ctx, VIVS_PE_DEPTH_STRIDE, padded_width * 2);
         etna_set_state(ctx, VIVS_PE_STENCIL_CONFIG, ETNA_MASKED_INL(VIVS_PE_STENCIL_CONFIG_MODE, DISABLED));
         etna_set_state(ctx, VIVS_PE_HDEPTH_CONTROL, VIVS_PE_HDEPTH_CONTROL_FORMAT_DISABLED);
@@ -265,8 +266,8 @@ int main(int argc, char **argv)
         etna_set_state(ctx, VIVS_GL_FLUSH_CACHE, VIVS_GL_FLUSH_CACHE_DEPTH);
 
         etna_set_state(ctx, VIVS_TS_DEPTH_CLEAR_VALUE, 0xffffffff);
-        etna_set_state(ctx, VIVS_TS_DEPTH_STATUS_BASE, z_ts->address); /* ADDR_D */
-        etna_set_state(ctx, VIVS_TS_DEPTH_SURFACE_BASE, z->address); /* ADDR_C */
+        etna_set_state(ctx, VIVS_TS_DEPTH_STATUS_BASE, etna_bo_gpu_address(z_ts)); /* ADDR_D */
+        etna_set_state(ctx, VIVS_TS_DEPTH_SURFACE_BASE, etna_bo_gpu_address(z)); /* ADDR_C */
         etna_set_state(ctx, VIVS_TS_MEM_CONFIG, 
                 VIVS_TS_MEM_CONFIG_DEPTH_FAST_CLEAR |
                 VIVS_TS_MEM_CONFIG_COLOR_FAST_CLEAR |
@@ -276,26 +277,26 @@ int main(int argc, char **argv)
 
         /* Warm up RS on aux render target */
         etna_set_state(ctx, VIVS_GL_FLUSH_CACHE, VIVS_GL_FLUSH_CACHE_COLOR | VIVS_GL_FLUSH_CACHE_DEPTH);
-        etna_warm_up_rs(ctx, aux_rt->address, aux_rt_ts->address);
+        etna_warm_up_rs(ctx, etna_bo_gpu_address(aux_rt), etna_bo_gpu_address(aux_rt_ts));
 
         /* Phew, now that's one hell of a setup; the serious rendering starts now */
-        etna_set_state(ctx, VIVS_TS_COLOR_STATUS_BASE, rt_ts->address); /* ADDR_B */
-        etna_set_state(ctx, VIVS_TS_COLOR_SURFACE_BASE, rt->address); /* ADDR_A */
+        etna_set_state(ctx, VIVS_TS_COLOR_STATUS_BASE, etna_bo_gpu_address(rt_ts)); /* ADDR_B */
+        etna_set_state(ctx, VIVS_TS_COLOR_SURFACE_BASE, etna_bo_gpu_address(rt)); /* ADDR_A */
 
         /* ... or so we thought */
         etna_set_state(ctx, VIVS_GL_FLUSH_CACHE, VIVS_GL_FLUSH_CACHE_COLOR | VIVS_GL_FLUSH_CACHE_DEPTH);
-        etna_warm_up_rs(ctx, aux_rt->address, aux_rt_ts->address);
+        etna_warm_up_rs(ctx, etna_bo_gpu_address(aux_rt), etna_bo_gpu_address(aux_rt_ts));
 
         /* maybe now? */
-        etna_set_state(ctx, VIVS_TS_COLOR_STATUS_BASE, rt_ts->address); /* ADDR_B */
-        etna_set_state(ctx, VIVS_TS_COLOR_SURFACE_BASE, rt->address); /* ADDR_A */
+        etna_set_state(ctx, VIVS_TS_COLOR_STATUS_BASE, etna_bo_gpu_address(rt_ts)); /* ADDR_B */
+        etna_set_state(ctx, VIVS_TS_COLOR_SURFACE_BASE, etna_bo_gpu_address(rt)); /* ADDR_A */
         etna_set_state(ctx, VIVS_GL_FLUSH_CACHE, VIVS_GL_FLUSH_CACHE_COLOR | VIVS_GL_FLUSH_CACHE_DEPTH);
        
         /* nope, not really... */ 
         etna_set_state(ctx, VIVS_GL_FLUSH_CACHE, VIVS_GL_FLUSH_CACHE_COLOR | VIVS_GL_FLUSH_CACHE_DEPTH);
-        etna_warm_up_rs(ctx, aux_rt->address, aux_rt_ts->address);
-        etna_set_state(ctx, VIVS_TS_COLOR_STATUS_BASE, rt_ts->address); /* ADDR_B */
-        etna_set_state(ctx, VIVS_TS_COLOR_SURFACE_BASE, rt->address); /* ADDR_A */
+        etna_warm_up_rs(ctx, etna_bo_gpu_address(aux_rt), etna_bo_gpu_address(aux_rt_ts));
+        etna_set_state(ctx, VIVS_TS_COLOR_STATUS_BASE, etna_bo_gpu_address(rt_ts)); /* ADDR_B */
+        etna_set_state(ctx, VIVS_TS_COLOR_SURFACE_BASE, etna_bo_gpu_address(rt)); /* ADDR_A */
 
         etna_stall(ctx, SYNC_RECIPIENT_RA, SYNC_RECIPIENT_PE);
 
@@ -309,7 +310,7 @@ int main(int argc, char **argv)
                 VIVS_RS_CONFIG_DEST_FORMAT(RS_FORMAT_A8R8G8B8)
                 );
         etna_set_state_multi(ctx, VIVS_RS_DITHER(0), 2, (uint32_t[]){0xffffffff, 0xffffffff});
-        etna_set_state(ctx, VIVS_RS_DEST_ADDR, rt_ts->address); /* ADDR_B */
+        etna_set_state(ctx, VIVS_RS_DEST_ADDR, etna_bo_gpu_address(rt_ts)); /* ADDR_B */
         etna_set_state(ctx, VIVS_RS_DEST_STRIDE, 0x100); /* 0x100 iso 0x40! seems it uses a width of 256 if width divisible by 256, XXX need to figure out these rules */
         etna_set_state(ctx, VIVS_RS_WINDOW_SIZE, 
                 VIVS_RS_WINDOW_SIZE_HEIGHT(rt_ts_size/0x100) |
@@ -325,8 +326,8 @@ int main(int argc, char **argv)
         
         etna_set_state(ctx, VIVS_TS_COLOR_CLEAR_VALUE, 0xff7f7f7f);
         etna_set_state(ctx, VIVS_GL_FLUSH_CACHE, VIVS_GL_FLUSH_CACHE_COLOR);
-        etna_set_state(ctx, VIVS_TS_COLOR_STATUS_BASE, rt_ts->address); /* ADDR_B */
-        etna_set_state(ctx, VIVS_TS_COLOR_SURFACE_BASE, rt->address); /* ADDR_A */
+        etna_set_state(ctx, VIVS_TS_COLOR_STATUS_BASE, etna_bo_gpu_address(rt_ts)); /* ADDR_B */
+        etna_set_state(ctx, VIVS_TS_COLOR_SURFACE_BASE, etna_bo_gpu_address(rt)); /* ADDR_A */
         etna_set_state(ctx, VIVS_TS_MEM_CONFIG, 
                 VIVS_TS_MEM_CONFIG_DEPTH_FAST_CLEAR |
                 VIVS_TS_MEM_CONFIG_COLOR_FAST_CLEAR |
@@ -406,7 +407,7 @@ int main(int argc, char **argv)
         etna_set_state(ctx, VIVS_VS_OUTPUT_COUNT, 2);
         etna_set_state(ctx, VIVS_PA_CONFIG, ETNA_MASKED_BIT(VIVS_PA_CONFIG_POINT_SIZE_ENABLE, 0));
         
-        etna_set_state(ctx, VIVS_FE_VERTEX_STREAM_BASE_ADDR, vtx->address); /* ADDR_E */
+        etna_set_state(ctx, VIVS_FE_VERTEX_STREAM_BASE_ADDR, etna_bo_gpu_address(vtx)); /* ADDR_E */
         etna_set_state(ctx, VIVS_FE_VERTEX_STREAM_CONTROL, 
                 VIVS_FE_VERTEX_STREAM_CONTROL_VERTEX_STRIDE(0x14));
         etna_set_state(ctx, VIVS_FE_VERTEX_ELEMENT_CONFIG(0), 
@@ -448,8 +449,8 @@ int main(int argc, char **argv)
         etna_set_state(ctx, VIVS_RS_DITHER(1), 0xffffffff);
         etna_set_state(ctx, VIVS_RS_CLEAR_CONTROL, VIVS_RS_CLEAR_CONTROL_MODE_DISABLED);
         etna_set_state(ctx, VIVS_RS_EXTRA_CONFIG, 0); /* no AA, no endian switch */
-        etna_set_state(ctx, VIVS_RS_SOURCE_ADDR, rt->address); /* ADDR_A */
-        etna_set_state(ctx, VIVS_RS_DEST_ADDR, rt->address); /* ADDR_A */
+        etna_set_state(ctx, VIVS_RS_SOURCE_ADDR, etna_bo_gpu_address(rt)); /* ADDR_A */
+        etna_set_state(ctx, VIVS_RS_DEST_ADDR, etna_bo_gpu_address(rt)); /* ADDR_A */
         etna_set_state(ctx, VIVS_RS_WINDOW_SIZE, 
                 VIVS_RS_WINDOW_SIZE_HEIGHT(padded_height) |
                 VIVS_RS_WINDOW_SIZE_WIDTH(padded_width));
@@ -458,10 +459,10 @@ int main(int argc, char **argv)
         /* Submit second command buffer */
         etna_flush(ctx, NULL);
 
-        etna_warm_up_rs(ctx, aux_rt->address, aux_rt_ts->address);
+        etna_warm_up_rs(ctx, etna_bo_gpu_address(aux_rt), etna_bo_gpu_address(aux_rt_ts));
 
-        etna_set_state(ctx, VIVS_TS_COLOR_STATUS_BASE, rt_ts->address); /* ADDR_B */
-        etna_set_state(ctx, VIVS_TS_COLOR_SURFACE_BASE, rt->address); /* ADDR_A */
+        etna_set_state(ctx, VIVS_TS_COLOR_STATUS_BASE, etna_bo_gpu_address(rt_ts)); /* ADDR_B */
+        etna_set_state(ctx, VIVS_TS_COLOR_SURFACE_BASE, etna_bo_gpu_address(rt)); /* ADDR_A */
         etna_set_state(ctx, VIVS_GL_FLUSH_CACHE, VIVS_GL_FLUSH_CACHE_COLOR);
         etna_set_state(ctx, VIVS_TS_MEM_CONFIG, 
                 VIVS_TS_MEM_CONFIG_DEPTH_FAST_CLEAR |
@@ -488,7 +489,7 @@ int main(int argc, char **argv)
         etna_set_state(ctx, VIVS_RS_CLEAR_CONTROL, VIVS_RS_CLEAR_CONTROL_MODE_DISABLED);
         etna_set_state(ctx, VIVS_RS_EXTRA_CONFIG, 
                 0); /* no AA, no endian switch */
-        etna_set_state(ctx, VIVS_RS_SOURCE_ADDR, rt->address); /* ADDR_A */
+        etna_set_state(ctx, VIVS_RS_SOURCE_ADDR, etna_bo_gpu_address(rt)); /* ADDR_A */
         etna_set_state(ctx, VIVS_RS_DEST_ADDR, fb.physical[backbuffer]); /* ADDR_J */
         etna_set_state(ctx, VIVS_RS_WINDOW_SIZE, 
                 VIVS_RS_WINDOW_SIZE_HEIGHT(height) |
diff --git a/src/fb_old/mip_cube_raw.c b/src/fb_old/mip_cube_raw.c
index 0b10348..b80d98b 100644
--- a/src/fb_old/mip_cube_raw.c
+++ b/src/fb_old/mip_cube_raw.c
@@ -47,7 +47,7 @@
 #include "etna_state.h"
 #include "etna_rs.h"
 #include "etna_fb.h"
-#include "etna_mem.h"
+#include "etna_bo.h"
 #include "etna_bswap.h"
 #include "etna_tex.h"
 #include "etna_util.h"
@@ -237,14 +237,14 @@ int main(int argc, char **argv)
     }
 
     /* Allocate video memory */
-    struct etna_vidmem *rt = 0; /* main render target */
-    struct etna_vidmem *rt_ts = 0; /* tile status for main render target */
-    struct etna_vidmem *z = 0; /* depth for main render target */
-    struct etna_vidmem *z_ts = 0; /* depth ts for main render target */
-    struct etna_vidmem *vtx = 0; /* vertex buffer */
-    struct etna_vidmem *aux_rt = 0; /* auxilary render target */
-    struct etna_vidmem *aux_rt_ts = 0; /* tile status for auxilary render target */
-    struct etna_vidmem *tex = 0; /* texture */
+    struct etna_bo *rt = 0; /* main render target */
+    struct etna_bo *rt_ts = 0; /* tile status for main render target */
+    struct etna_bo *z = 0; /* depth for main render target */
+    struct etna_bo *z_ts = 0; /* depth ts for main render target */
+    struct etna_bo *vtx = 0; /* vertex buffer */
+    struct etna_bo *aux_rt = 0; /* auxilary render target */
+    struct etna_bo *aux_rt_ts = 0; /* tile status for auxilary render target */
+    struct etna_bo *tex = 0; /* texture */
 
     size_t rt_size = padded_width * padded_height * 4;
     size_t rt_ts_size = etna_align_up((padded_width * padded_height * 4)/0x100, 0x100);
@@ -258,14 +258,14 @@ int main(int argc, char **argv)
         exit(1);
     }
 
-    if(etna_vidmem_alloc_linear(conn, &rt, rt_size, gcvSURF_RENDER_TARGET, gcvPOOL_DEFAULT, true)!=ETNA_OK ||
-       etna_vidmem_alloc_linear(conn, &rt_ts, rt_ts_size, gcvSURF_TILE_STATUS, gcvPOOL_DEFAULT, true)!=ETNA_OK ||
-       etna_vidmem_alloc_linear(conn, &z, z_size, gcvSURF_DEPTH, gcvPOOL_DEFAULT, true)!=ETNA_OK ||
-       etna_vidmem_alloc_linear(conn, &z_ts, z_ts_size, gcvSURF_TILE_STATUS, gcvPOOL_DEFAULT, true)!=ETNA_OK ||
-       etna_vidmem_alloc_linear(conn, &vtx, VERTEX_BUFFER_SIZE, gcvSURF_VERTEX, gcvPOOL_DEFAULT, true)!=ETNA_OK ||
-       etna_vidmem_alloc_linear(conn, &aux_rt, 0x4000, gcvSURF_RENDER_TARGET, gcvPOOL_SYSTEM, true)!=ETNA_OK ||
-       etna_vidmem_alloc_linear(conn, &aux_rt_ts, 0x100, gcvSURF_TILE_STATUS, gcvPOOL_DEFAULT, true)!=ETNA_OK ||
-       etna_vidmem_alloc_linear(conn, &tex, dds->size, gcvSURF_TEXTURE, gcvPOOL_DEFAULT, true)!=ETNA_OK
+    if(etna_bo_new(conn, &rt, rt_size, gcvSURF_RENDER_TARGET, gcvPOOL_DEFAULT, true)!=ETNA_OK ||
+       etna_bo_new(conn, &rt_ts, rt_ts_size, gcvSURF_TILE_STATUS, gcvPOOL_DEFAULT, true)!=ETNA_OK ||
+       etna_bo_new(conn, &z, z_size, gcvSURF_DEPTH, gcvPOOL_DEFAULT, true)!=ETNA_OK ||
+       etna_bo_new(conn, &z_ts, z_ts_size, gcvSURF_TILE_STATUS, gcvPOOL_DEFAULT, true)!=ETNA_OK ||
+       etna_bo_new(conn, &vtx, VERTEX_BUFFER_SIZE, gcvSURF_VERTEX, gcvPOOL_DEFAULT, true)!=ETNA_OK ||
+       etna_bo_new(conn, &aux_rt, 0x4000, gcvSURF_RENDER_TARGET, gcvPOOL_SYSTEM, true)!=ETNA_OK ||
+       etna_bo_new(conn, &aux_rt_ts, 0x100, gcvSURF_TILE_STATUS, gcvPOOL_DEFAULT, true)!=ETNA_OK ||
+       etna_bo_new(conn, &tex, dds->size, gcvSURF_TEXTURE, gcvPOOL_DEFAULT, true)!=ETNA_OK
        )
     {
         fprintf(stderr, "Error allocating video memory\n");
@@ -283,14 +283,14 @@ int main(int argc, char **argv)
         for(int ix=0; ix<dds->num_mipmaps; ++ix)
         {
             printf("%08x: Tiling mipmap %i (%ix%i)\n", dds->slices[0][ix].offset, ix, dds->slices[0][ix].width, dds->slices[0][ix].height);
-            etna_texture_tile((void*)((size_t)tex->logical + dds->slices[0][ix].offset), 
+            etna_texture_tile(etna_bo_map(tex) + dds->slices[0][ix].offset,
                     dds->slices[0][ix].data, dds->slices[0][ix].width, dds->slices[0][ix].height, dds->slices[0][ix].stride, 4);
         }
         tex_format = TEXTURE_FORMAT_X8R8G8B8;
     } else if(dds->fmt == FMT_DXT1 || dds->fmt == FMT_DXT3 || dds->fmt == FMT_DXT5 || dds->fmt == FMT_ETC1)
     {
         printf("Uploading compressed texture\n");
-        memcpy(tex->logical, dds->data, dds->size);
+        memcpy(etna_bo_map(tex), dds->data, dds->size);
         switch(dds->fmt)
         {
         case FMT_DXT1: tex_format = TEXTURE_FORMAT_DXT1; break;
@@ -309,15 +309,16 @@ int main(int argc, char **argv)
      * Unlike the GL example we only do this once, not every time glDrawArrays is called, the same would be accomplished
      * from GL by using a vertex buffer object.
      */
+    float *vtx_map = (float*)etna_bo_map(vtx);
     for(int vert=0; vert<NUM_VERTICES; ++vert)
     {
         int dest_idx = vert * (3 + 3 + 2);
         for(int comp=0; comp<3; ++comp)
-            ((float*)vtx->logical)[dest_idx+comp+0] = vVertices[vert*3 + comp]; /* 0 */
+            vtx_map[dest_idx+comp+0] = vVertices[vert*3 + comp]; /* 0 */
         for(int comp=0; comp<3; ++comp)
-            ((float*)vtx->logical)[dest_idx+comp+3] = vNormals[vert*3 + comp]; /* 1 */
+            vtx_map[dest_idx+comp+3] = vNormals[vert*3 + comp]; /* 1 */
         for(int comp=0; comp<2; ++comp)
-            ((float*)vtx->logical)[dest_idx+comp+6] = vTexCoords[vert*2 + comp]; /* 2 */
+            vtx_map[dest_idx+comp+6] = vTexCoords[vert*2 + comp]; /* 2 */
     }
 
     for(int frame=0; frame<1000; ++frame)
@@ -436,11 +437,11 @@ int main(int argc, char **argv)
                 VIVS_PE_DEPTH_CONFIG_DEPTH_MODE_Z
                 /* VIVS_PE_DEPTH_CONFIG_ONLY_DEPTH */
                 );
-        etna_set_state(ctx, VIVS_PE_DEPTH_ADDR, z->address);
+        etna_set_state(ctx, VIVS_PE_DEPTH_ADDR, etna_bo_gpu_address(z));
         etna_set_state(ctx, VIVS_PE_DEPTH_STRIDE, padded_width * 2);
         etna_set_state(ctx, VIVS_PE_HDEPTH_CONTROL, VIVS_PE_HDEPTH_CONTROL_FORMAT_DISABLED);
         etna_set_state_f32(ctx, VIVS_PE_DEPTH_NORMALIZE, 65535.0);
-        etna_set_state(ctx, VIVS_PE_COLOR_ADDR, rt->address);
+        etna_set_state(ctx, VIVS_PE_COLOR_ADDR, etna_bo_gpu_address(rt));
         etna_set_state(ctx, VIVS_PE_COLOR_STRIDE, padded_width * 4); 
         etna_set_state_f32(ctx, VIVS_PE_DEPTH_NEAR, 0.0);
         etna_set_state_f32(ctx, VIVS_PE_DEPTH_FAR, 1.0);
@@ -460,7 +461,7 @@ int main(int argc, char **argv)
                 VIVS_RS_CONFIG_DEST_FORMAT(RS_FORMAT_X8R8G8B8)
                 );
         etna_set_state_multi(ctx, VIVS_RS_DITHER(0), 2, (uint32_t[]){0xffffffff, 0xffffffff});
-        etna_set_state(ctx, VIVS_RS_DEST_ADDR, rt_ts->address); /* ADDR_B */
+        etna_set_state(ctx, VIVS_RS_DEST_ADDR, etna_bo_gpu_address(rt_ts)); /* ADDR_B */
         etna_set_state(ctx, VIVS_RS_DEST_STRIDE, 0x40);
         etna_set_state(ctx, VIVS_RS_WINDOW_SIZE, 
                 ((rt_ts_size/0x40) << VIVS_RS_WINDOW_SIZE_HEIGHT__SHIFT) |
@@ -480,11 +481,11 @@ int main(int argc, char **argv)
                 VIVS_TS_MEM_CONFIG_DEPTH_16BPP | 
                 VIVS_TS_MEM_CONFIG_DEPTH_COMPRESSION);
         etna_set_state(ctx, VIVS_TS_DEPTH_CLEAR_VALUE, 0xffffffff);
-        etna_set_state(ctx, VIVS_TS_DEPTH_STATUS_BASE, z_ts->address);
-        etna_set_state(ctx, VIVS_TS_DEPTH_SURFACE_BASE, z->address);
+        etna_set_state(ctx, VIVS_TS_DEPTH_STATUS_BASE, etna_bo_gpu_address(z_ts));
+        etna_set_state(ctx, VIVS_TS_DEPTH_SURFACE_BASE, etna_bo_gpu_address(z));
         etna_set_state(ctx, VIVS_TS_COLOR_CLEAR_VALUE, 0xff303030);
-        etna_set_state(ctx, VIVS_TS_COLOR_STATUS_BASE, rt_ts->address);
-        etna_set_state(ctx, VIVS_TS_COLOR_SURFACE_BASE, rt->address);
+        etna_set_state(ctx, VIVS_TS_COLOR_STATUS_BASE, etna_bo_gpu_address(rt_ts));
+        etna_set_state(ctx, VIVS_TS_COLOR_SURFACE_BASE, etna_bo_gpu_address(rt));
         etna_set_state(ctx, VIVS_GL_FLUSH_CACHE, VIVS_GL_FLUSH_CACHE_COLOR | VIVS_GL_FLUSH_CACHE_DEPTH);
 
         /* set up texture unit */
@@ -497,7 +498,7 @@ int main(int argc, char **argv)
                 VIVS_TE_SAMPLER_LOG_SIZE_HEIGHT(tex_base_log_height));
         for(int ix=0; ix<dds->num_mipmaps; ++ix)
         {
-            etna_set_state(ctx, VIVS_TE_SAMPLER_LOD_ADDR(0,ix), tex->address + dds->slices[0][ix].offset);
+            etna_set_state(ctx, VIVS_TE_SAMPLER_LOD_ADDR(0,ix), etna_bo_gpu_address(tex) + dds->slices[0][ix].offset);
         }
         etna_set_state(ctx, VIVS_TE_SAMPLER_CONFIG0(0), 
                 VIVS_TE_SAMPLER_CONFIG0_TYPE(TEXTURE_TYPE_2D)|
@@ -548,7 +549,7 @@ int main(int argc, char **argv)
         etna_set_state(ctx, VIVS_PS_CONTROL, VIVS_PS_CONTROL_UNK1);
         etna_set_state_f32(ctx, VIVS_PS_UNIFORMS(0), 1.0); /* u0.x */
 
-        etna_set_state(ctx, VIVS_FE_VERTEX_STREAM_BASE_ADDR, vtx->address); /* ADDR_E */
+        etna_set_state(ctx, VIVS_FE_VERTEX_STREAM_BASE_ADDR, etna_bo_gpu_address(vtx)); /* ADDR_E */
         etna_set_state(ctx, VIVS_FE_VERTEX_STREAM_CONTROL, 
                 VIVS_FE_VERTEX_STREAM_CONTROL_VERTEX_STRIDE((3 + 3 + 2)*4));
         etna_set_state(ctx, VIVS_FE_VERTEX_ELEMENT_CONFIG(0), 
@@ -595,8 +596,8 @@ int main(int argc, char **argv)
         etna_set_state(ctx, VIVS_RS_DITHER(1), 0xffffffff);
         etna_set_state(ctx, VIVS_RS_CLEAR_CONTROL, VIVS_RS_CLEAR_CONTROL_MODE_DISABLED);
         etna_set_state(ctx, VIVS_RS_EXTRA_CONFIG, 0); /* no AA, no endian switch */
-        etna_set_state(ctx, VIVS_RS_SOURCE_ADDR, rt->address); /* ADDR_A */
-        etna_set_state(ctx, VIVS_RS_DEST_ADDR, rt->address); /* ADDR_A */
+        etna_set_state(ctx, VIVS_RS_SOURCE_ADDR, etna_bo_gpu_address(rt)); /* ADDR_A */
+        etna_set_state(ctx, VIVS_RS_DEST_ADDR, etna_bo_gpu_address(rt)); /* ADDR_A */
         etna_set_state(ctx, VIVS_RS_WINDOW_SIZE, 
                 VIVS_RS_WINDOW_SIZE_HEIGHT(padded_height) |
                 VIVS_RS_WINDOW_SIZE_WIDTH(padded_width));
@@ -604,8 +605,8 @@ int main(int argc, char **argv)
 
         etna_set_state(ctx, VIVS_TS_FLUSH_CACHE, VIVS_TS_FLUSH_CACHE_FLUSH);
 
-        etna_set_state(ctx, VIVS_TS_COLOR_STATUS_BASE, rt_ts->address); /* ADDR_B */
-        etna_set_state(ctx, VIVS_TS_COLOR_SURFACE_BASE, rt->address); /* ADDR_A */
+        etna_set_state(ctx, VIVS_TS_COLOR_STATUS_BASE, etna_bo_gpu_address(rt_ts)); /* ADDR_B */
+        etna_set_state(ctx, VIVS_TS_COLOR_SURFACE_BASE, etna_bo_gpu_address(rt)); /* ADDR_A */
         etna_set_state(ctx, VIVS_GL_FLUSH_CACHE, VIVS_GL_FLUSH_CACHE_COLOR);
         etna_set_state(ctx, VIVS_TS_MEM_CONFIG, 
                 VIVS_TS_MEM_CONFIG_DEPTH_FAST_CLEAR |
@@ -630,7 +631,7 @@ int main(int argc, char **argv)
         etna_set_state(ctx, VIVS_RS_CLEAR_CONTROL, VIVS_RS_CLEAR_CONTROL_MODE_DISABLED);
         etna_set_state(ctx, VIVS_RS_EXTRA_CONFIG, 
                 0); /* no AA, no endian switch */
-        etna_set_state(ctx, VIVS_RS_SOURCE_ADDR, rt->address); /* ADDR_A */
+        etna_set_state(ctx, VIVS_RS_SOURCE_ADDR, etna_bo_gpu_address(rt)); /* ADDR_A */
         etna_set_state(ctx, VIVS_RS_DEST_ADDR, fb.physical[buffers->backbuffer]); /* ADDR_J */
         etna_set_state(ctx, VIVS_RS_WINDOW_SIZE, 
                 VIVS_RS_WINDOW_SIZE_HEIGHT(height) |
diff --git a/src/fb_old/rotate_cube.c b/src/fb_old/rotate_cube.c
index 4226f83..c4c416b 100644
--- a/src/fb_old/rotate_cube.c
+++ b/src/fb_old/rotate_cube.c
@@ -46,7 +46,7 @@
 #include "etna_state.h"
 #include "etna_rs.h"
 #include "etna_fb.h"
-#include "etna_mem.h"
+#include "etna_bo.h"
 #include "etna_util.h"
 
 #include "esTransform.h"
@@ -218,14 +218,14 @@ int main(int argc, char **argv)
     unsigned bits_per_tile = VIV_FEATURE(conn, chipMinorFeatures0,2BITPERTILE)?2:4;
     printf("supertiled: %i bits per tile: %i\n", supertiled, bits_per_tile);
 
-    struct etna_vidmem *rt = 0; /* main render target */
-    struct etna_vidmem *rt_ts = 0; /* tile status for main render target */
-    struct etna_vidmem *z = 0; /* depth for main render target */
-    struct etna_vidmem *z_ts = 0; /* depth ts for main render target */
-    struct etna_vidmem *vtx = 0; /* vertex buffer */
-    struct etna_vidmem *aux_rt = 0; /* auxilary render target */
-    struct etna_vidmem *aux_rt_ts = 0; /* tile status for auxilary render target */
-    struct etna_vidmem *bmp = 0; /* bitmap */
+    struct etna_bo *rt = 0; /* main render target */
+    struct etna_bo *rt_ts = 0; /* tile status for main render target */
+    struct etna_bo *z = 0; /* depth for main render target */
+    struct etna_bo *z_ts = 0; /* depth ts for main render target */
+    struct etna_bo *vtx = 0; /* vertex buffer */
+    struct etna_bo *aux_rt = 0; /* auxilary render target */
+    struct etna_bo *aux_rt_ts = 0; /* tile status for auxilary render target */
+    struct etna_bo *bmp = 0; /* bitmap */
 
     size_t rt_size = padded_width * padded_height * 4;
     size_t rt_ts_size = etna_align_up((padded_width * padded_height * 4)*bits_per_tile/0x80, 0x100);
@@ -233,14 +233,14 @@ int main(int argc, char **argv)
     size_t z_ts_size = etna_align_up((padded_width * padded_height * 2)*bits_per_tile/0x80, 0x100);
     size_t bmp_size = width * height * 4;
 
-    if(etna_vidmem_alloc_linear(conn, &rt, rt_size, gcvSURF_RENDER_TARGET, gcvPOOL_DEFAULT, true)!=ETNA_OK ||
-       etna_vidmem_alloc_linear(conn, &rt_ts, rt_ts_size, gcvSURF_TILE_STATUS, gcvPOOL_DEFAULT, true)!=ETNA_OK ||
-       etna_vidmem_alloc_linear(conn, &z, z_size, gcvSURF_DEPTH, gcvPOOL_DEFAULT, true)!=ETNA_OK ||
-       etna_vidmem_alloc_linear(conn, &z_ts, z_ts_size, gcvSURF_TILE_STATUS, gcvPOOL_DEFAULT, true)!=ETNA_OK ||
-       etna_vidmem_alloc_linear(conn, &vtx, VERTEX_BUFFER_SIZE, gcvSURF_VERTEX, gcvPOOL_DEFAULT, true)!=ETNA_OK ||
-       etna_vidmem_alloc_linear(conn, &aux_rt, 0x4000, gcvSURF_RENDER_TARGET, gcvPOOL_SYSTEM, true)!=ETNA_OK ||
-       etna_vidmem_alloc_linear(conn, &aux_rt_ts, 0x80*bits_per_tile, gcvSURF_TILE_STATUS, gcvPOOL_DEFAULT, true)!=ETNA_OK ||
-       etna_vidmem_alloc_linear(conn, &bmp, bmp_size, gcvSURF_BITMAP, gcvPOOL_DEFAULT, true)!=ETNA_OK
+    if(etna_bo_new(conn, &rt, rt_size, gcvSURF_RENDER_TARGET, gcvPOOL_DEFAULT, true)!=ETNA_OK ||
+       etna_bo_new(conn, &rt_ts, rt_ts_size, gcvSURF_TILE_STATUS, gcvPOOL_DEFAULT, true)!=ETNA_OK ||
+       etna_bo_new(conn, &z, z_size, gcvSURF_DEPTH, gcvPOOL_DEFAULT, true)!=ETNA_OK ||
+       etna_bo_new(conn, &z_ts, z_ts_size, gcvSURF_TILE_STATUS, gcvPOOL_DEFAULT, true)!=ETNA_OK ||
+       etna_bo_new(conn, &vtx, VERTEX_BUFFER_SIZE, gcvSURF_VERTEX, gcvPOOL_DEFAULT, true)!=ETNA_OK ||
+       etna_bo_new(conn, &aux_rt, 0x4000, gcvSURF_RENDER_TARGET, gcvPOOL_SYSTEM, true)!=ETNA_OK ||
+       etna_bo_new(conn, &aux_rt_ts, 0x80*bits_per_tile, gcvSURF_TILE_STATUS, gcvPOOL_DEFAULT, true)!=ETNA_OK ||
+       etna_bo_new(conn, &bmp, bmp_size, gcvSURF_BITMAP, gcvPOOL_DEFAULT, true)!=ETNA_OK
        )
     {
         fprintf(stderr, "Error allocating video memory\n");
@@ -252,15 +252,16 @@ int main(int argc, char **argv)
      * Unlike the GL example we only do this once, not every time glDrawArrays is called, the same would be accomplished
      * from GL by using a vertex buffer object.
      */
+    float *vtx_map = (float*)etna_bo_map(vtx);
     for(int vert=0; vert<NUM_VERTICES; ++vert)
     {
         int src_idx = vert * COMPONENTS_PER_VERTEX;
         int dest_idx = vert * COMPONENTS_PER_VERTEX * 3;
         for(int comp=0; comp<COMPONENTS_PER_VERTEX; ++comp)
         {
-            ((float*)vtx->logical)[dest_idx+comp+0] = vVertices[src_idx + comp]; /* 0 */
-            ((float*)vtx->logical)[dest_idx+comp+3] = vNormals[src_idx + comp]; /* 1 */
-            ((float*)vtx->logical)[dest_idx+comp+6] = vColors[src_idx + comp]; /* 2 */
+            vtx_map[dest_idx+comp+0] = vVertices[src_idx + comp]; /* 0 */
+            vtx_map[dest_idx+comp+3] = vNormals[src_idx + comp]; /* 1 */
+            vtx_map[dest_idx+comp+6] = vColors[src_idx + comp]; /* 2 */
         }
     }
 
@@ -334,7 +335,7 @@ int main(int argc, char **argv)
                 ETNA_MASKED(VIVS_PE_COLOR_FORMAT_FORMAT, RS_FORMAT_X8R8G8B8) &
                 ETNA_MASKED_BIT(VIVS_PE_COLOR_FORMAT_SUPER_TILED, supertiled));
 
-        etna_set_state(ctx, VIVS_PE_COLOR_ADDR, rt->address); /* ADDR_A */
+        etna_set_state(ctx, VIVS_PE_COLOR_ADDR, etna_bo_gpu_address(rt)); /* ADDR_A */
         etna_set_state(ctx, VIVS_PE_COLOR_STRIDE, padded_width * 4); 
         etna_set_state(ctx, VIVS_GL_MULTI_SAMPLE_CONFIG, 
                 ETNA_MASKED_INL(VIVS_GL_MULTI_SAMPLE_CONFIG_MSAA_SAMPLES, NONE) &
@@ -346,15 +347,15 @@ int main(int argc, char **argv)
         etna_set_state(ctx, VIVS_PE_COLOR_FORMAT, ETNA_MASKED_BIT(VIVS_PE_COLOR_FORMAT_OVERWRITE, 1));
         etna_set_state(ctx, VIVS_GL_FLUSH_CACHE, VIVS_GL_FLUSH_CACHE_COLOR);
         etna_set_state(ctx, VIVS_TS_COLOR_CLEAR_VALUE, 0);
-        etna_set_state(ctx, VIVS_TS_COLOR_STATUS_BASE, rt_ts->address); /* ADDR_B */
-        etna_set_state(ctx, VIVS_TS_COLOR_SURFACE_BASE, rt->address); /* ADDR_A */
+        etna_set_state(ctx, VIVS_TS_COLOR_STATUS_BASE, etna_bo_gpu_address(rt_ts)); /* ADDR_B */
+        etna_set_state(ctx, VIVS_TS_COLOR_SURFACE_BASE, etna_bo_gpu_address(rt)); /* ADDR_A */
         etna_set_state(ctx, VIVS_TS_MEM_CONFIG, VIVS_TS_MEM_CONFIG_COLOR_FAST_CLEAR);
 
         etna_set_state(ctx, VIVS_PE_DEPTH_CONFIG, 
                 ETNA_MASKED_INL(VIVS_PE_DEPTH_CONFIG_DEPTH_FORMAT, D16) &
                 ETNA_MASKED_BIT(VIVS_PE_DEPTH_CONFIG_SUPER_TILED, supertiled)
                 );
-        etna_set_state(ctx, VIVS_PE_DEPTH_ADDR, z->address); /* ADDR_C */
+        etna_set_state(ctx, VIVS_PE_DEPTH_ADDR, etna_bo_gpu_address(z)); /* ADDR_C */
         etna_set_state(ctx, VIVS_PE_DEPTH_STRIDE, padded_width * 2);
         etna_set_state(ctx, VIVS_PE_HDEPTH_CONTROL, VIVS_PE_HDEPTH_CONTROL_FORMAT_DISABLED);
         etna_set_state_f32(ctx, VIVS_PE_DEPTH_NORMALIZE, 65535.0);
@@ -362,8 +363,8 @@ int main(int argc, char **argv)
         etna_set_state(ctx, VIVS_GL_FLUSH_CACHE, VIVS_GL_FLUSH_CACHE_DEPTH);
 
         etna_set_state(ctx, VIVS_TS_DEPTH_CLEAR_VALUE, 0xffffffff);
-        etna_set_state(ctx, VIVS_TS_DEPTH_STATUS_BASE, z_ts->address); /* ADDR_D */
-        etna_set_state(ctx, VIVS_TS_DEPTH_SURFACE_BASE, z->address); /* ADDR_C */
+        etna_set_state(ctx, VIVS_TS_DEPTH_STATUS_BASE, etna_bo_gpu_address(z_ts)); /* ADDR_D */
+        etna_set_state(ctx, VIVS_TS_DEPTH_SURFACE_BASE, etna_bo_gpu_address(z)); /* ADDR_C */
         etna_set_state(ctx, VIVS_TS_MEM_CONFIG, 
                 VIVS_TS_MEM_CONFIG_DEPTH_FAST_CLEAR |
                 VIVS_TS_MEM_CONFIG_COLOR_FAST_CLEAR |
@@ -373,22 +374,22 @@ int main(int argc, char **argv)
 
         /* Warm up RS on aux render target */
         etna_set_state(ctx, VIVS_GL_FLUSH_CACHE, VIVS_GL_FLUSH_CACHE_COLOR | VIVS_GL_FLUSH_CACHE_DEPTH);
-        etna_warm_up_rs(ctx, aux_rt->address, aux_rt_ts->address);
+        etna_warm_up_rs(ctx, etna_bo_gpu_address(aux_rt), etna_bo_gpu_address(aux_rt_ts));
 
-        etna_set_state(ctx, VIVS_TS_COLOR_STATUS_BASE, rt_ts->address); /* ADDR_B */
-        etna_set_state(ctx, VIVS_TS_COLOR_SURFACE_BASE, rt->address); /* ADDR_A */
+        etna_set_state(ctx, VIVS_TS_COLOR_STATUS_BASE, etna_bo_gpu_address(rt_ts)); /* ADDR_B */
+        etna_set_state(ctx, VIVS_TS_COLOR_SURFACE_BASE, etna_bo_gpu_address(rt)); /* ADDR_A */
 
         etna_set_state(ctx, VIVS_GL_FLUSH_CACHE, VIVS_GL_FLUSH_CACHE_COLOR | VIVS_GL_FLUSH_CACHE_DEPTH);
-        etna_warm_up_rs(ctx, aux_rt->address, aux_rt_ts->address);
+        etna_warm_up_rs(ctx, etna_bo_gpu_address(aux_rt), etna_bo_gpu_address(aux_rt_ts));
 
-        etna_set_state(ctx, VIVS_TS_COLOR_STATUS_BASE, rt_ts->address); /* ADDR_B */
-        etna_set_state(ctx, VIVS_TS_COLOR_SURFACE_BASE, rt->address); /* ADDR_A */
+        etna_set_state(ctx, VIVS_TS_COLOR_STATUS_BASE, etna_bo_gpu_address(rt_ts)); /* ADDR_B */
+        etna_set_state(ctx, VIVS_TS_COLOR_SURFACE_BASE, etna_bo_gpu_address(rt)); /* ADDR_A */
         etna_set_state(ctx, VIVS_GL_FLUSH_CACHE, VIVS_GL_FLUSH_CACHE_COLOR | VIVS_GL_FLUSH_CACHE_DEPTH);
        
         etna_set_state(ctx, VIVS_GL_FLUSH_CACHE, VIVS_GL_FLUSH_CACHE_COLOR | VIVS_GL_FLUSH_CACHE_DEPTH);
-        etna_warm_up_rs(ctx, aux_rt->address, aux_rt_ts->address);
-        etna_set_state(ctx, VIVS_TS_COLOR_STATUS_BASE, rt_ts->address); /* ADDR_B */
-        etna_set_state(ctx, VIVS_TS_COLOR_SURFACE_BASE, rt->address); /* ADDR_A */
+        etna_warm_up_rs(ctx, etna_bo_gpu_address(aux_rt), etna_bo_gpu_address(aux_rt_ts));
+        etna_set_state(ctx, VIVS_TS_COLOR_STATUS_BASE, etna_bo_gpu_address(rt_ts)); /* ADDR_B */
+        etna_set_state(ctx, VIVS_TS_COLOR_SURFACE_BASE, etna_bo_gpu_address(rt)); /* ADDR_A */
         
         etna_stall(ctx, SYNC_RECIPIENT_RA, SYNC_RECIPIENT_PE);
 
@@ -401,7 +402,7 @@ int main(int argc, char **argv)
                 (RS_FORMAT_A8R8G8B8 << VIVS_RS_CONFIG_DEST_FORMAT__SHIFT)
                 );
         etna_set_state_multi(ctx, VIVS_RS_DITHER(0), 2, (uint32_t[]){0xffffffff, 0xffffffff});
-        etna_set_state(ctx, VIVS_RS_DEST_ADDR, rt_ts->address); /* ADDR_B */
+        etna_set_state(ctx, VIVS_RS_DEST_ADDR, etna_bo_gpu_address(rt_ts)); /* ADDR_B */
         etna_set_state(ctx, VIVS_RS_DEST_STRIDE, 0x40);
         etna_set_state(ctx, VIVS_RS_WINDOW_SIZE, 
                 ((rt_ts_size/0x40) << VIVS_RS_WINDOW_SIZE_HEIGHT__SHIFT) |
@@ -418,8 +419,8 @@ int main(int argc, char **argv)
         
         etna_set_state(ctx, VIVS_GL_FLUSH_CACHE, VIVS_GL_FLUSH_CACHE_COLOR);
         etna_set_state(ctx, VIVS_TS_COLOR_CLEAR_VALUE, 0xff7f7f7f);
-        etna_set_state(ctx, VIVS_TS_COLOR_STATUS_BASE, rt_ts->address); /* ADDR_B */
-        etna_set_state(ctx, VIVS_TS_COLOR_SURFACE_BASE, rt->address); /* ADDR_A */
+        etna_set_state(ctx, VIVS_TS_COLOR_STATUS_BASE, etna_bo_gpu_address(rt_ts)); /* ADDR_B */
+        etna_set_state(ctx, VIVS_TS_COLOR_SURFACE_BASE, etna_bo_gpu_address(rt)); /* ADDR_A */
         etna_set_state(ctx, VIVS_TS_MEM_CONFIG, 
                 VIVS_TS_MEM_CONFIG_DEPTH_FAST_CLEAR |
                 VIVS_TS_MEM_CONFIG_COLOR_FAST_CLEAR |
@@ -527,7 +528,7 @@ int main(int argc, char **argv)
         etna_set_state_multi(ctx, VIVS_VS_UNIFORMS(20), 3, (uint32_t*)&normal.m[1][0]); /* u5.xyz */
         etna_set_state_multi(ctx, VIVS_VS_UNIFORMS(24), 3, (uint32_t*)&normal.m[2][0]); /* u6.xyz */
         etna_set_state_multi(ctx, VIVS_VS_UNIFORMS(28), 16, (uint32_t*)&modelview.m[0][0]);
-        etna_set_state(ctx, VIVS_FE_VERTEX_STREAM_BASE_ADDR, vtx->address); /* ADDR_E */
+        etna_set_state(ctx, VIVS_FE_VERTEX_STREAM_BASE_ADDR, etna_bo_gpu_address(vtx)); /* ADDR_E */
         etna_set_state(ctx, VIVS_FE_VERTEX_STREAM_CONTROL, 
                 0x24 << VIVS_FE_VERTEX_STREAM_CONTROL_VERTEX_STRIDE__SHIFT);
         etna_set_state(ctx, VIVS_FE_VERTEX_ELEMENT_CONFIG(0), 
@@ -580,8 +581,8 @@ int main(int argc, char **argv)
         etna_set_state(ctx, VIVS_RS_DITHER(1), 0xffffffff);
         etna_set_state(ctx, VIVS_RS_CLEAR_CONTROL, VIVS_RS_CLEAR_CONTROL_MODE_DISABLED);
         etna_set_state(ctx, VIVS_RS_EXTRA_CONFIG, 0); /* no AA, no endian switch */
-        etna_set_state(ctx, VIVS_RS_SOURCE_ADDR, rt->address); /* ADDR_A */
-        etna_set_state(ctx, VIVS_RS_DEST_ADDR, rt->address); /* ADDR_A */
+        etna_set_state(ctx, VIVS_RS_SOURCE_ADDR, etna_bo_gpu_address(rt)); /* ADDR_A */
+        etna_set_state(ctx, VIVS_RS_DEST_ADDR, etna_bo_gpu_address(rt)); /* ADDR_A */
         etna_set_state(ctx, VIVS_RS_WINDOW_SIZE, 
                 VIVS_RS_WINDOW_SIZE_HEIGHT(padded_height) |
                 VIVS_RS_WINDOW_SIZE_WIDTH(padded_width));
@@ -590,10 +591,10 @@ int main(int argc, char **argv)
         /* Submit second command buffer */
         etna_flush(ctx, NULL);
 
-        etna_warm_up_rs(ctx, aux_rt->address, aux_rt_ts->address);
+        etna_warm_up_rs(ctx, etna_bo_gpu_address(aux_rt), etna_bo_gpu_address(aux_rt_ts));
 
-        etna_set_state(ctx, VIVS_TS_COLOR_STATUS_BASE, rt_ts->address); /* ADDR_B */
-        etna_set_state(ctx, VIVS_TS_COLOR_SURFACE_BASE, rt->address); /* ADDR_A */
+        etna_set_state(ctx, VIVS_TS_COLOR_STATUS_BASE, etna_bo_gpu_address(rt_ts)); /* ADDR_B */
+        etna_set_state(ctx, VIVS_TS_COLOR_SURFACE_BASE, etna_bo_gpu_address(rt)); /* ADDR_A */
         etna_set_state(ctx, VIVS_GL_FLUSH_CACHE, VIVS_GL_FLUSH_CACHE_COLOR);
         etna_set_state(ctx, VIVS_TS_MEM_CONFIG, 
                 VIVS_TS_MEM_CONFIG_DEPTH_FAST_CLEAR |
@@ -620,7 +621,7 @@ int main(int argc, char **argv)
         etna_set_state(ctx, VIVS_RS_CLEAR_CONTROL, VIVS_RS_CLEAR_CONTROL_MODE_DISABLED);
         etna_set_state(ctx, VIVS_RS_EXTRA_CONFIG, 
                 0); /* no AA, no endian switch */
-        etna_set_state(ctx, VIVS_RS_SOURCE_ADDR, rt->address); /* ADDR_A */
+        etna_set_state(ctx, VIVS_RS_SOURCE_ADDR, etna_bo_gpu_address(rt)); /* ADDR_A */
         etna_set_state(ctx, VIVS_RS_DEST_ADDR, fb.physical[backbuffer]); /* ADDR_J */
         etna_set_state(ctx, VIVS_RS_WINDOW_SIZE, 
                 VIVS_RS_WINDOW_SIZE_HEIGHT(height) |
diff --git a/src/fb_old/rstests.c b/src/fb_old/rstests.c
index 8b86512..4628afa 100644
--- a/src/fb_old/rstests.c
+++ b/src/fb_old/rstests.c
@@ -48,7 +48,7 @@
 #include "etnaviv/etna_fb.h"
 #include "etnaviv/etna_util.h"
 #include "etnaviv/etna_rs.h"
-#include "etnaviv/etna_mem.h"
+#include "etnaviv/etna_bo.h"
 
 #include "etna_pipe.h"
 #include "esTransform.h"
@@ -69,22 +69,22 @@ int main(int argc, char **argv)
 
     printf("padded_width %i padded_height %i\n", padded_width, padded_height);
 
-    struct etna_vidmem *rt1 = 0; /* main render target */
-    struct etna_vidmem *rt2 = 0; /* main render target */
-    struct etna_vidmem *rt_ts = 0; /* tile status for main render target */
-    struct etna_vidmem *z = 0; /* depth for main render target */
-    struct etna_vidmem *z_ts = 0; /* depth ts for main render target */
+    struct etna_bo *rt1 = 0; /* main render target */
+    struct etna_bo *rt2 = 0; /* main render target */
+    struct etna_bo *rt_ts = 0; /* tile status for main render target */
+    struct etna_bo *z = 0; /* depth for main render target */
+    struct etna_bo *z_ts = 0; /* depth ts for main render target */
 
     size_t rt_size = padded_width * padded_height * 4;
     size_t rt_ts_size = etna_align_up((padded_width * padded_height * 4)/0x100, 0x100);
     size_t z_size = padded_width * padded_height * 2;
     size_t z_ts_size = etna_align_up((padded_width * padded_height * 2)/0x100, 0x100);
 
-    if(etna_vidmem_alloc_linear(conn, &rt1, rt_size, VIV_SURF_RENDER_TARGET, VIV_POOL_DEFAULT, true)!=ETNA_OK ||
-       etna_vidmem_alloc_linear(conn, &rt2, rt_size, VIV_SURF_RENDER_TARGET, VIV_POOL_DEFAULT, true)!=ETNA_OK ||
-       etna_vidmem_alloc_linear(conn, &rt_ts, rt_ts_size, VIV_SURF_TILE_STATUS, VIV_POOL_DEFAULT, true)!=ETNA_OK ||
-       etna_vidmem_alloc_linear(conn, &z, z_size, VIV_SURF_DEPTH, VIV_POOL_DEFAULT, true)!=ETNA_OK ||
-       etna_vidmem_alloc_linear(conn, &z_ts, z_ts_size, VIV_SURF_TILE_STATUS, VIV_POOL_DEFAULT, true)!=ETNA_OK
+    if((rt1=etna_bo_new(conn, rt_size, DRM_ETNA_GEM_TYPE_RT))==NULL ||
+       (rt2=etna_bo_new(conn, rt_size, DRM_ETNA_GEM_TYPE_RT))==NULL ||
+       (rt_ts=etna_bo_new(conn, rt_ts_size, DRM_ETNA_GEM_TYPE_TS))==NULL ||
+       (z=etna_bo_new(conn, z_size, DRM_ETNA_GEM_TYPE_ZS))==NULL ||
+       (z_ts=etna_bo_new(conn, z_ts_size, DRM_ETNA_GEM_TYPE_TS))==NULL
        )
     {
         fprintf(stderr, "Error allocating video memory\n");
@@ -98,10 +98,10 @@ int main(int argc, char **argv)
         exit(1);
     }
 
-    memset(rt_ts->logical, 0x55, rt_ts->size);  // Pattern: cleared
-    //memset(rt_ts->logical, 0xAA, rt_ts->size);  // Pattern: weird pattern fill
-    //memset(rt_ts->logical, 0x00, rt_ts->size);  // Pattern: filled in (nothing to do)
-    //memset(rt_ts->logical, 0xFF, rt_ts->size);  // Pattern: weird pattern fill
+    memset(etna_bo_map(rt_ts), 0x55, rt_ts->size);  // Pattern: cleared
+    //memset(etna_bo_map(rt_ts), 0xAA, rt_ts->size);  // Pattern: weird pattern fill
+    //memset(etna_bo_map(rt_ts), 0x00, rt_ts->size);  // Pattern: filled in (nothing to do)
+    //memset(etna_bo_map(rt_ts), 0xFF, rt_ts->size);  // Pattern: weird pattern fill
     //
     /* pattern in:
      * <32b> [<32b>] <32b> [<32b>] ...  delete odd groups of 32 bytes
@@ -225,12 +225,12 @@ int main(int argc, char **argv)
 
         /* Set up resolve to self */
         etna_set_state(ctx, VIVS_TS_COLOR_CLEAR_VALUE, 0xff7f7f7f);
-        etna_set_state(ctx, VIVS_TS_COLOR_STATUS_BASE, rt_ts->address); /* ADDR_B */
-        etna_set_state(ctx, VIVS_TS_COLOR_SURFACE_BASE, rt->address); /* ADDR_A */
+        etna_set_state(ctx, VIVS_TS_COLOR_STATUS_BASE, etna_bo_gpu_address(rt_ts)); /* ADDR_B */
+        etna_set_state(ctx, VIVS_TS_COLOR_SURFACE_BASE, etna_bo_gpu_address(rt)); /* ADDR_A */
 #if 0   /* don't care about depth, for now */
         etna_set_state(ctx, VIVS_TS_DEPTH_CLEAR_VALUE, 0xffffffff);
-        etna_set_state(ctx, VIVS_TS_DEPTH_STATUS_BASE, z_ts->address); /* ADDR_D */
-        etna_set_state(ctx, VIVS_TS_DEPTH_SURFACE_BASE, z->address); /* ADDR_C */
+        etna_set_state(ctx, VIVS_TS_DEPTH_STATUS_BASE, etna_bo_gpu_address(z_ts)); /* ADDR_D */
+        etna_set_state(ctx, VIVS_TS_DEPTH_SURFACE_BASE, etna_bo_gpu_address(z)); /* ADDR_C */
 #endif
 
         etna_set_state(ctx, VIVS_TS_MEM_CONFIG,
@@ -249,8 +249,8 @@ int main(int argc, char **argv)
         etna_set_state(ctx, VIVS_RS_DITHER(1), 0xffffffff);
         etna_set_state(ctx, VIVS_RS_CLEAR_CONTROL, VIVS_RS_CLEAR_CONTROL_MODE_DISABLED);
         etna_set_state(ctx, VIVS_RS_EXTRA_CONFIG, 0); /* no AA, no endian switch */
-        etna_set_state(ctx, VIVS_RS_SOURCE_ADDR, rt->address); /* ADDR_A */
-        etna_set_state(ctx, VIVS_RS_DEST_ADDR, rt->address); /* ADDR_A */
+        etna_set_state(ctx, VIVS_RS_SOURCE_ADDR, etna_bo_gpu_address(rt)); /* ADDR_A */
+        etna_set_state(ctx, VIVS_RS_DEST_ADDR, etna_bo_gpu_address(rt)); /* ADDR_A */
         etna_set_state(ctx, VIVS_RS_WINDOW_SIZE,
                 VIVS_RS_WINDOW_SIZE_HEIGHT(padded_height) |
                 VIVS_RS_WINDOW_SIZE_WIDTH(padded_width));
@@ -269,7 +269,7 @@ int main(int argc, char **argv)
         etna_set_state(ctx, VIVS_RS_FILL_VALUE(2), 0xff0000ff);
         etna_set_state(ctx, VIVS_RS_FILL_VALUE(3), 0xffff00ff);
         etna_set_state(ctx, VIVS_RS_SOURCE_ADDR, 0); /* fill disregards source anyway */
-        etna_set_state(ctx, VIVS_RS_DEST_ADDR, rt->address + 64*64*4); /* Offset one entire 64*64 tile. Interesting things happen if only a partial tile is offset. */
+        etna_set_state(ctx, VIVS_RS_DEST_ADDR, etna_bo_gpu_address(rt) + 64*64*4); /* Offset one entire 64*64 tile. Interesting things happen if only a partial tile is offset. */
         /* Pure FILL_VALUE(0) */
         //etna_set_state(ctx, VIVS_RS_CLEAR_CONTROL, VIVS_RS_CLEAR_CONTROL_MODE_ENABLED1 | VIVS_RS_CLEAR_CONTROL_BITS(0xffff));
         /* Vertical line pattern */
@@ -285,12 +285,13 @@ int main(int argc, char **argv)
 
 #if 0
         /* manually fill, to figure out tiling pattern */
+        void *rt_map = etna_bo_map(rt);
         for(int x=0; x<16384/4; ++x)
         {
             int a = (x & 0x3F) << 2;
             int b = ((x >> 3) & 0x3F) << 2;
             int c = ((x >> 6) & 0x3F) << 2;
-            ((uint32_t*)(rt->logical + 16384*6))[x] = (a & 0xFF) | ((b & 0xFF) << 8) | ((c & 0xFF) << 16);
+            ((uint32_t*)(rt_map + 16384*6))[x] = (a & 0xFF) | ((b & 0xFF) << 8) | ((c & 0xFF) << 16);
             printf("%08x\n", (a & 0xFF) | ((b & 0xFF) << 8) | ((c & 0xFF) << 16));
         }
 #endif
@@ -310,7 +311,7 @@ int main(int argc, char **argv)
         etna_set_state(ctx, VIVS_RS_CLEAR_CONTROL, VIVS_RS_CLEAR_CONTROL_MODE_DISABLED);
         etna_set_state(ctx, VIVS_RS_EXTRA_CONFIG,
                 0); /* no AA, no endian switch */
-        etna_set_state(ctx, VIVS_RS_SOURCE_ADDR, rt->address); /* ADDR_A */
+        etna_set_state(ctx, VIVS_RS_SOURCE_ADDR, etna_bo_gpu_address(rt)); /* ADDR_A */
         etna_set_state(ctx, VIVS_RS_DEST_ADDR, fb.physical[backbuffer]); /* ADDR_J */
         etna_set_state(ctx, VIVS_RS_WINDOW_SIZE,
                 VIVS_RS_WINDOW_SIZE_HEIGHT(height) |
diff --git a/src/test2d/bitblt2d.c b/src/test2d/bitblt2d.c
index d9c5f7c..ffa57e3 100644
--- a/src/test2d/bitblt2d.c
+++ b/src/test2d/bitblt2d.c
@@ -40,7 +40,7 @@
 #include <etnaviv/cmdstream.xml.h>
 #include <etnaviv/viv.h>
 #include <etnaviv/etna.h>
-#include <etnaviv/etna_mem.h>
+#include <etnaviv/etna_bo.h>
 #include <etnaviv/etna_util.h>
 #include <etnaviv/etna_rs.h>
 
@@ -65,14 +65,14 @@ int main(int argc, char **argv)
     }
     printf("Succesfully opened device\n");
     
-    struct etna_vidmem *bmp = 0; /* bitmap */
-    struct etna_vidmem *src = 0; /* source */
+    struct etna_bo *bmp = 0; /* bitmap */
+    struct etna_bo *src = 0; /* source */
 
     size_t bmp_size = width * height * 4;
     size_t src_size = width * height * 4;
 
-    if(etna_vidmem_alloc_linear(conn, &bmp, bmp_size, VIV_SURF_BITMAP, VIV_POOL_DEFAULT, true)!=ETNA_OK ||
-       etna_vidmem_alloc_linear(conn, &src, src_size, VIV_SURF_BITMAP, VIV_POOL_DEFAULT, true)!=ETNA_OK)
+    if((bmp=etna_bo_new(conn, bmp_size, DRM_ETNA_GEM_TYPE_BMP))==NULL ||
+       (src=etna_bo_new(conn, src_size, DRM_ETNA_GEM_TYPE_BMP))==NULL)
     {
         fprintf(stderr, "Error allocating video memory\n");
         exit(1);
@@ -90,8 +90,10 @@ int main(int argc, char **argv)
     /* pre-clear surface. Could use the 2D engine for this,
      * but we're lazy.
      */
+    uint32_t *bmp_map = etna_bo_map(bmp);
     for(int i=0; i<bmp_size/4; ++i)
-        ((uint32_t*)bmp->logical)[i] = 0xff000000;
+        bmp_map[i] = 0xff000000;
+    uint32_t *src_map = etna_bo_map(src);
     for(int y=0; y<height; ++y)
     {
         for(int x=0; x<width; ++x)
@@ -100,7 +102,7 @@ int main(int argc, char **argv)
             uint8_t r = x*13;
             uint8_t g = y*13;
             uint8_t b = (x+y)*0x12;
-            ((uint32_t*)src->logical)[y*width+x] = ((uint32_t)a << 24)|((uint32_t)b<<16)|((uint32_t)g<<8)|(uint32_t)r;
+            src_map[y*width+x] = ((uint32_t)a << 24)|((uint32_t)b<<16)|((uint32_t)g<<8)|(uint32_t)r;
         }
     }
 
@@ -108,7 +110,7 @@ int main(int argc, char **argv)
     {
         printf("*** FRAME %i ****\n", frame);
 
-        etna_set_state(ctx, VIVS_DE_SRC_ADDRESS, src->address);
+        etna_set_state(ctx, VIVS_DE_SRC_ADDRESS, etna_bo_gpu_address(src));
         etna_set_state(ctx, VIVS_DE_SRC_STRIDE, width*4);
         etna_set_state(ctx, VIVS_DE_SRC_ROTATION_CONFIG, 0);
         etna_set_state(ctx, VIVS_DE_SRC_CONFIG, 
@@ -126,7 +128,7 @@ int main(int argc, char **argv)
         etna_set_state(ctx, VIVS_DE_SRC_COLOR_FG, 0xff12ff56);
         etna_set_state(ctx, VIVS_DE_STRETCH_FACTOR_LOW, 0);
         etna_set_state(ctx, VIVS_DE_STRETCH_FACTOR_HIGH, 0);
-        etna_set_state(ctx, VIVS_DE_DEST_ADDRESS, bmp->address);
+        etna_set_state(ctx, VIVS_DE_DEST_ADDRESS, etna_bo_gpu_address(bmp));
         etna_set_state(ctx, VIVS_DE_DEST_STRIDE, width*4);
         etna_set_state(ctx, VIVS_DE_DEST_ROTATION_CONFIG, 0);
         etna_set_state(ctx, VIVS_DE_DEST_CONFIG, 
@@ -194,7 +196,7 @@ int main(int argc, char **argv)
         etna_set_state(ctx, VIVS_GL_FLUSH_CACHE, VIVS_GL_FLUSH_CACHE_PE2D);
         etna_finish(ctx);
     }
-    bmp_dump32(bmp->logical, width, height, false, "/tmp/fb.bmp");
+    bmp_dump32(etna_bo_map(bmp), width, height, false, "/tmp/fb.bmp");
     printf("Dump complete\n");
 
     etna_free(ctx);
diff --git a/src/test2d/bitblt2d_alpha.c b/src/test2d/bitblt2d_alpha.c
index 461df19..491872d 100644
--- a/src/test2d/bitblt2d_alpha.c
+++ b/src/test2d/bitblt2d_alpha.c
@@ -40,7 +40,7 @@
 #include <etnaviv/cmdstream.xml.h>
 #include <etnaviv/viv.h>
 #include <etnaviv/etna.h>
-#include <etnaviv/etna_mem.h>
+#include <etnaviv/etna_bo.h>
 #include <etnaviv/etna_util.h>
 #include <etnaviv/etna_rs.h>
 
@@ -76,14 +76,14 @@ int main(int argc, char **argv)
     }
     printf("Succesfully opened device\n");
     
-    struct etna_vidmem *bmp = 0; /* bitmap */
-    struct etna_vidmem *src = 0; /* source */
+    struct etna_bo *bmp = 0; /* bitmap */
+    struct etna_bo *src = 0; /* source */
 
     size_t bmp_size = width * height * 4;
     size_t src_size = width * height * 4;
 
-    if(etna_vidmem_alloc_linear(conn, &bmp, bmp_size, VIV_SURF_BITMAP, VIV_POOL_DEFAULT, true)!=ETNA_OK ||
-       etna_vidmem_alloc_linear(conn, &src, src_size, VIV_SURF_BITMAP, VIV_POOL_DEFAULT, true)!=ETNA_OK)
+    if((bmp=etna_bo_new(conn, bmp_size, DRM_ETNA_GEM_TYPE_BMP))==NULL ||
+       (src=etna_bo_new(conn, src_size, DRM_ETNA_GEM_TYPE_BMP))==NULL)
     {
         fprintf(stderr, "Error allocating video memory\n");
         exit(1);
@@ -101,8 +101,10 @@ int main(int argc, char **argv)
     /* pre-clear surface. Could use the 2D engine for this,
      * but we're lazy.
      */
+    uint32_t *bmp_map = etna_bo_map(bmp);
     for(int i=0; i<bmp_size/4; ++i)
-        ((uint32_t*)bmp->logical)[i] = 0xff000000;
+        bmp_map[i] = 0xff000000;
+    uint32_t *src_map = etna_bo_map(src);
     for(int y=0; y<height; ++y)
     {
         for(int x=0; x<width; ++x)
@@ -111,7 +113,7 @@ int main(int argc, char **argv)
             uint8_t r = 0x00;
             uint8_t g = 0xc0;
             uint8_t b = 0x00;
-            ((uint32_t*)src->logical)[y*width+x] = ((uint32_t)a << 24)|((uint32_t)b<<16)|((uint32_t)g<<8)|(uint32_t)r;
+            src_map[y*width+x] = ((uint32_t)a << 24)|((uint32_t)b<<16)|((uint32_t)g<<8)|(uint32_t)r;
         }
     }
 
@@ -119,7 +121,7 @@ int main(int argc, char **argv)
     {
         printf("*** FRAME %i ****\n", frame);
 
-        etna_set_state(ctx, VIVS_DE_SRC_ADDRESS, src->address);
+        etna_set_state(ctx, VIVS_DE_SRC_ADDRESS, etna_bo_gpu_address(src));
         etna_set_state(ctx, VIVS_DE_SRC_STRIDE, width*4);
         etna_set_state(ctx, VIVS_DE_SRC_ROTATION_CONFIG, 0);
         etna_set_state(ctx, VIVS_DE_SRC_CONFIG, 
@@ -137,7 +139,7 @@ int main(int argc, char **argv)
         etna_set_state(ctx, VIVS_DE_SRC_COLOR_FG, 0xff12ff56);
         etna_set_state(ctx, VIVS_DE_STRETCH_FACTOR_LOW, 0);
         etna_set_state(ctx, VIVS_DE_STRETCH_FACTOR_HIGH, 0);
-        etna_set_state(ctx, VIVS_DE_DEST_ADDRESS, bmp->address);
+        etna_set_state(ctx, VIVS_DE_DEST_ADDRESS, etna_bo_gpu_address(bmp));
         etna_set_state(ctx, VIVS_DE_DEST_STRIDE, width*4);
         etna_set_state(ctx, VIVS_DE_DEST_ROTATION_CONFIG, 0);
         etna_set_state(ctx, VIVS_DE_DEST_CONFIG, 
@@ -223,7 +225,7 @@ int main(int argc, char **argv)
         etna_set_state(ctx, VIVS_GL_FLUSH_CACHE, VIVS_GL_FLUSH_CACHE_PE2D);
         etna_finish(ctx);
     }
-    bmp_dump32(bmp->logical, width, height, false, "/tmp/fb.bmp");
+    bmp_dump32(etna_bo_map(bmp), width, height, false, "/tmp/fb.bmp");
     printf("Dump complete\n");
 
     etna_free(ctx);
diff --git a/src/test2d/bitblt2d_from_stream.c b/src/test2d/bitblt2d_from_stream.c
index 0831b2f..76ed1aa 100644
--- a/src/test2d/bitblt2d_from_stream.c
+++ b/src/test2d/bitblt2d_from_stream.c
@@ -40,7 +40,7 @@
 #include <etnaviv/cmdstream.xml.h>
 #include <etnaviv/viv.h>
 #include <etnaviv/etna.h>
-#include <etnaviv/etna_mem.h>
+#include <etnaviv/etna_bo.h>
 #include <etnaviv/etna_util.h>
 #include <etnaviv/etna_rs.h>
 
@@ -78,14 +78,14 @@ int main(int argc, char **argv)
     }
     printf("Succesfully opened device\n");
     
-    struct etna_vidmem *bmp = 0; /* bitmap */
-    struct etna_vidmem *src = 0; /* source */
+    struct etna_bo *bmp = 0; /* bitmap */
+    struct etna_bo *src = 0; /* source */
 
     size_t bmp_size = width * height * 4;
     size_t src_size = width * height * 4;
 
-    if(etna_vidmem_alloc_linear(conn, &bmp, bmp_size, VIV_SURF_BITMAP, VIV_POOL_DEFAULT, true)!=ETNA_OK ||
-       etna_vidmem_alloc_linear(conn, &src, src_size, VIV_SURF_BITMAP, VIV_POOL_DEFAULT, true)!=ETNA_OK)
+    if((bmp=etna_bo_new(conn, bmp_size, DRM_ETNA_GEM_TYPE_BMP))==NULL ||
+       (src=etna_bo_new(conn, src_size, DRM_ETNA_GEM_TYPE_BMP))==NULL)
     {
         fprintf(stderr, "Error allocating video memory\n");
         exit(1);
@@ -103,15 +103,16 @@ int main(int argc, char **argv)
     /* pre-clear surface. Could use the 2D engine for this,
      * but we're lazy.
      */
-    memset(src->logical, 255, src_size);
+    memset(etna_bo_map(src), 255, src_size);
+    uint32_t *bmp_map = etna_bo_map(bmp);
     for(int i=0; i<bmp_size/4; ++i)
-        ((uint32_t*)bmp->logical)[i] = 0xff2020ff;
+        bmp_map[i] = 0xff2020ff;
     for(int frame=0; frame<1; ++frame)
     {
         printf("*** FRAME %i ****\n", frame);
 
         etna_set_state(ctx, VIVS_DE_SRC_ADDRESS, 0); /* source address is ignored for monochrome blits */
-        //etna_set_state(ctx, VIVS_DE_SRC_ADDRESS, src->address);
+        //etna_set_state(ctx, VIVS_DE_SRC_ADDRESS, etna_bo_gpu_address(src));
         etna_set_state(ctx, VIVS_DE_SRC_STRIDE, 4);
         etna_set_state(ctx, VIVS_DE_SRC_ROTATION_CONFIG, 0);
         etna_set_state(ctx, VIVS_DE_SRC_CONFIG, 
@@ -126,7 +127,7 @@ int main(int argc, char **argv)
         etna_set_state(ctx, VIVS_DE_SRC_COLOR_FG, 0xffffffff);
         etna_set_state(ctx, VIVS_DE_STRETCH_FACTOR_LOW, 0);
         etna_set_state(ctx, VIVS_DE_STRETCH_FACTOR_HIGH, 0);
-        etna_set_state(ctx, VIVS_DE_DEST_ADDRESS, bmp->address);
+        etna_set_state(ctx, VIVS_DE_DEST_ADDRESS, etna_bo_gpu_address(bmp));
         etna_set_state(ctx, VIVS_DE_DEST_STRIDE, width*4);
         etna_set_state(ctx, VIVS_DE_DEST_ROTATION_CONFIG, 0);
         etna_set_state(ctx, VIVS_DE_DEST_CONFIG, 
@@ -206,7 +207,7 @@ int main(int argc, char **argv)
         etna_set_state(ctx, VIVS_GL_FLUSH_CACHE, VIVS_GL_FLUSH_CACHE_PE2D);
         etna_finish(ctx);
     }
-    bmp_dump32_noflip(bmp->logical, width, height, true, "/tmp/fb.bmp");
+    bmp_dump32_noflip(etna_bo_map(bmp), width, height, true, "/tmp/fb.bmp");
     printf("Dump complete\n");
 
     etna_free(ctx);
diff --git a/src/test2d/bitblt2d_palette.c b/src/test2d/bitblt2d_palette.c
index 3c36b4c..e83d08b 100644
--- a/src/test2d/bitblt2d_palette.c
+++ b/src/test2d/bitblt2d_palette.c
@@ -40,7 +40,7 @@
 #include <etnaviv/cmdstream.xml.h>
 #include <etnaviv/viv.h>
 #include <etnaviv/etna.h>
-#include <etnaviv/etna_mem.h>
+#include <etnaviv/etna_bo.h>
 #include <etnaviv/etna_util.h>
 #include <etnaviv/etna_rs.h>
 
@@ -126,14 +126,14 @@ int main(int argc, char **argv)
     }
     printf("Succesfully opened device\n");
     
-    struct etna_vidmem *bmp = 0; /* bitmap */
-    struct etna_vidmem *src = 0; /* source */
+    struct etna_bo *bmp = 0; /* bitmap */
+    struct etna_bo *src = 0; /* source */
 
     size_t bmp_size = width * height * 4;
     size_t src_size = width * height * 4;
 
-    if(etna_vidmem_alloc_linear(conn, &bmp, bmp_size, VIV_SURF_BITMAP, VIV_POOL_DEFAULT, true)!=ETNA_OK ||
-       etna_vidmem_alloc_linear(conn, &src, src_size, VIV_SURF_BITMAP, VIV_POOL_DEFAULT, true)!=ETNA_OK)
+    if((bmp=etna_bo_new(conn, bmp_size, DRM_ETNA_GEM_TYPE_BMP))==NULL ||
+       (src=etna_bo_new(conn, src_size, DRM_ETNA_GEM_TYPE_BMP))==NULL)
     {
         fprintf(stderr, "Error allocating video memory\n");
         exit(1);
@@ -151,18 +151,19 @@ int main(int argc, char **argv)
     /* pre-clear surface. Could use the 2D engine for this,
      * but we're lazy.
      */
+    uint32_t *bmp_map = etna_bo_map(bmp);
     for(int i=0; i<bmp_size/4; ++i)
-        ((uint32_t*)bmp->logical)[i] = 0xff000000;
+        bmp_map[i] = 0xff000000;
 
     uint32_t palette[256];
     sr8_palette(palette);
-    sr8_decompress(image_sr8, (uint8_t*)src->logical);
+    sr8_decompress(image_sr8, (uint8_t*)etna_bo_map(src));
 
     for(int frame=0; frame<1; ++frame)
     {
         printf("*** FRAME %i ****\n", frame);
 
-        etna_set_state(ctx, VIVS_DE_SRC_ADDRESS, src->address);
+        etna_set_state(ctx, VIVS_DE_SRC_ADDRESS, etna_bo_gpu_address(src));
         etna_set_state(ctx, VIVS_DE_SRC_STRIDE, width);
         etna_set_state(ctx, VIVS_DE_SRC_ROTATION_CONFIG, 0);
         etna_set_state(ctx, VIVS_DE_SRC_CONFIG, 
@@ -180,7 +181,7 @@ int main(int argc, char **argv)
         etna_set_state(ctx, VIVS_DE_SRC_COLOR_FG, 0xff12ff56);
         etna_set_state(ctx, VIVS_DE_STRETCH_FACTOR_LOW, 0);
         etna_set_state(ctx, VIVS_DE_STRETCH_FACTOR_HIGH, 0);
-        etna_set_state(ctx, VIVS_DE_DEST_ADDRESS, bmp->address);
+        etna_set_state(ctx, VIVS_DE_DEST_ADDRESS, etna_bo_gpu_address(bmp));
         etna_set_state(ctx, VIVS_DE_DEST_STRIDE, width*4);
         etna_set_state(ctx, VIVS_DE_DEST_ROTATION_CONFIG, 0);
         etna_set_state(ctx, VIVS_DE_DEST_CONFIG, 
@@ -238,7 +239,7 @@ int main(int argc, char **argv)
         etna_set_state(ctx, VIVS_GL_FLUSH_CACHE, VIVS_GL_FLUSH_CACHE_PE2D);
         etna_finish(ctx);
     }
-    bmp_dump32_noflip(bmp->logical, width, height, true, "/tmp/fb.bmp");
+    bmp_dump32_noflip(etna_bo_map(bmp), width, height, true, "/tmp/fb.bmp");
     printf("Dump complete\n");
 
     etna_free(ctx);
diff --git a/src/test2d/bitblt2d_rotate.c b/src/test2d/bitblt2d_rotate.c
index ebafcc3..4f0fd77 100644
--- a/src/test2d/bitblt2d_rotate.c
+++ b/src/test2d/bitblt2d_rotate.c
@@ -40,7 +40,7 @@
 #include <etnaviv/cmdstream.xml.h>
 #include <etnaviv/viv.h>
 #include <etnaviv/etna.h>
-#include <etnaviv/etna_mem.h>
+#include <etnaviv/etna_bo.h>
 #include <etnaviv/etna_util.h>
 #include <etnaviv/etna_rs.h>
 
@@ -73,14 +73,14 @@ int main(int argc, char **argv)
         exit(1);
     }
     
-    struct etna_vidmem *bmp = 0; /* bitmap */
-    struct etna_vidmem *src = 0; /* source */
+    struct etna_bo *bmp = 0; /* bitmap */
+    struct etna_bo *src = 0; /* source */
 
     size_t bmp_size = dst_stride * height;
     size_t src_size = src_stride * src_height;
 
-    if(etna_vidmem_alloc_linear(conn, &bmp, bmp_size, VIV_SURF_BITMAP, VIV_POOL_DEFAULT, true)!=ETNA_OK ||
-       etna_vidmem_alloc_linear(conn, &src, src_size, VIV_SURF_BITMAP, VIV_POOL_DEFAULT, true)!=ETNA_OK)
+    if((bmp=etna_bo_new(conn, bmp_size, DRM_ETNA_GEM_TYPE_BMP))==NULL ||
+       (src=etna_bo_new(conn, src_size, DRM_ETNA_GEM_TYPE_BMP))==NULL)
     {
         fprintf(stderr, "Error allocating video memory\n");
         exit(1);
@@ -98,15 +98,16 @@ int main(int argc, char **argv)
     /* pre-clear surface. Could use the 2D engine for this,
      * but we're lazy.
      */
+    uint32_t *bmp_map = etna_bo_map(bmp);
     for(int i=0; i<bmp_size/4; ++i)
-        ((uint32_t*)bmp->logical)[i] = 0xff000000;
-    memcpy(src->logical, src_data, src_height * src_stride);
+        bmp_map[i] = 0xff000000;
+    memcpy(etna_bo_map(src), src_data, src_height * src_stride);
 
     for(int frame=0; frame<1; ++frame)
     {
         printf("*** FRAME %i ****\n", frame);
 
-        etna_set_state(ctx, VIVS_DE_SRC_ADDRESS, src->address);
+        etna_set_state(ctx, VIVS_DE_SRC_ADDRESS, etna_bo_gpu_address(src));
         etna_set_state(ctx, VIVS_DE_SRC_STRIDE, src_stride);
         etna_set_state(ctx, VIVS_DE_SRC_ROTATION_CONFIG, 
                 VIVS_DE_SRC_ROTATION_CONFIG_WIDTH(src_width) |
@@ -128,7 +129,7 @@ int main(int argc, char **argv)
         etna_set_state(ctx, VIVS_DE_SRC_COLOR_FG, 0xff12ff56);
         etna_set_state(ctx, VIVS_DE_STRETCH_FACTOR_LOW, 0);
         etna_set_state(ctx, VIVS_DE_STRETCH_FACTOR_HIGH, 0);
-        etna_set_state(ctx, VIVS_DE_DEST_ADDRESS, bmp->address);
+        etna_set_state(ctx, VIVS_DE_DEST_ADDRESS, etna_bo_gpu_address(bmp));
         etna_set_state(ctx, VIVS_DE_DEST_STRIDE, dst_stride);
         etna_set_state(ctx, VIVS_DE_DEST_ROTATION_CONFIG, 
                 VIVS_DE_DEST_ROTATION_CONFIG_WIDTH(width) |
@@ -202,7 +203,7 @@ int main(int argc, char **argv)
         etna_set_state(ctx, VIVS_GL_FLUSH_CACHE, VIVS_GL_FLUSH_CACHE_PE2D);
         etna_finish(ctx);
     }
-    bmp_dump32_noflip(bmp->logical, width, height, true, "/tmp/fb.bmp");
+    bmp_dump32_noflip(etna_bo_map(bmp), width, height, true, "/tmp/fb.bmp");
     printf("Dump complete\n");
 
     etna_free(ctx);
diff --git a/src/test2d/clear2d.c b/src/test2d/clear2d.c
index 4af8c5b..8f01fc6 100644
--- a/src/test2d/clear2d.c
+++ b/src/test2d/clear2d.c
@@ -40,7 +40,7 @@
 #include <etnaviv/cmdstream.xml.h>
 #include <etnaviv/viv.h>
 #include <etnaviv/etna.h>
-#include <etnaviv/etna_mem.h>
+#include <etnaviv/etna_bo.h>
 #include <etnaviv/etna_util.h>
 #include <etnaviv/etna_rs.h>
 
@@ -65,11 +65,11 @@ int main(int argc, char **argv)
     }
     printf("Succesfully opened device\n");
     
-    struct etna_vidmem *bmp = 0; /* bitmap */
+    struct etna_bo *bmp = 0; /* bitmap */
 
     size_t bmp_size = width * height * 4;
 
-    if(etna_vidmem_alloc_linear(conn, &bmp, bmp_size, VIV_SURF_BITMAP, VIV_POOL_DEFAULT, true)!=ETNA_OK)
+    if((bmp = etna_bo_new(conn, bmp_size, DRM_ETNA_GEM_TYPE_BMP)) == NULL)
     {
         fprintf(stderr, "Error allocating video memory\n");
         exit(1);
@@ -87,7 +87,7 @@ int main(int argc, char **argv)
     /* pre-clear surface. Could use the 2D engine for this,
      * but we're lazy.
      */
-    memset(bmp->logical, 0, bmp_size);
+    memset(etna_bo_map(bmp), 0, bmp_size);
     for(int frame=0; frame<1; ++frame)
     {
         printf("*** FRAME %i ****\n", frame);
@@ -102,7 +102,7 @@ int main(int argc, char **argv)
         etna_set_state(ctx, VIVS_DE_SRC_COLOR_FG, 0);
         etna_set_state(ctx, VIVS_DE_STRETCH_FACTOR_LOW, 0);
         etna_set_state(ctx, VIVS_DE_STRETCH_FACTOR_HIGH, 0);
-        etna_set_state(ctx, VIVS_DE_DEST_ADDRESS, bmp->address);
+        etna_set_state(ctx, VIVS_DE_DEST_ADDRESS, etna_bo_gpu_address(bmp));
         etna_set_state(ctx, VIVS_DE_DEST_STRIDE, width*4);
         etna_set_state(ctx, VIVS_DE_DEST_ROTATION_CONFIG, 0);
         etna_set_state(ctx, VIVS_DE_DEST_CONFIG, 
@@ -168,7 +168,7 @@ int main(int argc, char **argv)
         etna_set_state(ctx, VIVS_GL_FLUSH_CACHE, VIVS_GL_FLUSH_CACHE_PE2D);
         etna_finish(ctx);
     }
-    bmp_dump32(bmp->logical, width, height, false, "/tmp/fb.bmp");
+    bmp_dump32(etna_bo_map(bmp), width, height, false, "/tmp/fb.bmp");
     printf("Dump complete\n");
 
     etna_free(ctx);
diff --git a/src/test2d/filterblt2d.c b/src/test2d/filterblt2d.c
index 8051547..5c2a1f4 100644
--- a/src/test2d/filterblt2d.c
+++ b/src/test2d/filterblt2d.c
@@ -42,7 +42,7 @@
 #include <etnaviv/cmdstream.xml.h>
 #include <etnaviv/viv.h>
 #include <etnaviv/etna.h>
-#include <etnaviv/etna_mem.h>
+#include <etnaviv/etna_bo.h>
 #include <etnaviv/etna_util.h>
 #include <etnaviv/etna_rs.h>
 
@@ -94,14 +94,14 @@ int main(int argc, char **argv)
         exit(1);
     }
 
-    struct etna_vidmem *bmp = 0; /* bitmap */
-    struct etna_vidmem *src = 0; /* source */
+    struct etna_bo *bmp = 0; /* bitmap */
+    struct etna_bo *src = 0; /* source */
 
     size_t bmp_size = width * height * 4;
     size_t src_size = src_stride * height;
 
-    if(etna_vidmem_alloc_linear(conn, &bmp, bmp_size, VIV_SURF_BITMAP, VIV_POOL_DEFAULT, true)!=ETNA_OK ||
-       etna_vidmem_alloc_linear(conn, &src, src_size, VIV_SURF_BITMAP, VIV_POOL_DEFAULT, true)!=ETNA_OK)
+    if((bmp=etna_bo_new(conn, bmp_size, DRM_ETNA_GEM_TYPE_BMP))==NULL ||
+       (src=etna_bo_new(conn, src_size, DRM_ETNA_GEM_TYPE_BMP))==NULL)
     {
         fprintf(stderr, "Error allocating video memory\n");
         exit(1);
@@ -120,9 +120,10 @@ int main(int argc, char **argv)
     /* pre-clear surface. Could use the 2D engine for this,
      * but we're lazy.
      */
+    uint32_t *bmp_map = etna_bo_map(bmp);
     for(int i=0; i<bmp_size/4; ++i)
-        ((uint32_t*)bmp->logical)[i] = 0xff404040;
-    memcpy(src->logical, src_data, src_size);
+        bmp_map[i] = 0xff404040;
+    memcpy(etna_bo_map(src), src_data, src_size);
 
     /* Compute lanczos filter kernel */
     uint32_t filter_kernel[FB_DWORD_COUNT] = {0};
@@ -185,7 +186,7 @@ int main(int argc, char **argv)
     {
         printf("*** FRAME %i ****\n", frame);
         /* Source configuration */
-        etna_set_state(ctx, VIVS_DE_SRC_ADDRESS, src->address);
+        etna_set_state(ctx, VIVS_DE_SRC_ADDRESS, etna_bo_gpu_address(src));
         etna_set_state(ctx, VIVS_DE_SRC_STRIDE, src_stride);
         etna_set_state(ctx, VIVS_DE_UPLANE_ADDRESS, 0);
         etna_set_state(ctx, VIVS_DE_UPLANE_STRIDE, 0);
@@ -215,7 +216,7 @@ int main(int argc, char **argv)
                 VIVS_DE_STRETCH_FACTOR_HIGH_Y(((src_height - 1) << 16) / (height - 1)));
 
         /* Destination setup */
-        etna_set_state(ctx, VIVS_DE_DEST_ADDRESS, bmp->address);
+        etna_set_state(ctx, VIVS_DE_DEST_ADDRESS, etna_bo_gpu_address(bmp));
         etna_set_state(ctx, VIVS_DE_DEST_STRIDE, width*4);
         etna_set_state(ctx, VIVS_DE_DEST_ROTATION_CONFIG, 0);
         etna_set_state(ctx, VIVS_DE_DEST_CONFIG,
@@ -286,7 +287,7 @@ int main(int argc, char **argv)
         etna_set_state(ctx, VIVS_GL_FLUSH_CACHE, VIVS_GL_FLUSH_CACHE_PE2D);
         etna_finish(ctx);
     }
-    bmp_dump32_noflip(bmp->logical, width, height, true, "/tmp/fb.bmp");
+    bmp_dump32_noflip(etna_bo_map(bmp), width, height, true, "/tmp/fb.bmp");
     printf("Dump complete\n");
 
     etna_free(ctx);
diff --git a/src/test2d/filterblt2d_fromplanar.c b/src/test2d/filterblt2d_fromplanar.c
index fdcdfb8..5833fbe 100644
--- a/src/test2d/filterblt2d_fromplanar.c
+++ b/src/test2d/filterblt2d_fromplanar.c
@@ -45,7 +45,7 @@
 #include <etnaviv/cmdstream.xml.h>
 #include <etnaviv/viv.h>
 #include <etnaviv/etna.h>
-#include <etnaviv/etna_mem.h>
+#include <etnaviv/etna_bo.h>
 #include <etnaviv/etna_util.h>
 #include <etnaviv/etna_rs.h>
 
@@ -92,16 +92,16 @@ int main(int argc, char **argv)
     printf("Succesfully opened device\n");
 
     /* Allocate target bitmap */
-    struct etna_vidmem *bmp = 0;
+    struct etna_bo *bmp = 0;
     size_t bmp_size = dest_stride * height;
-    if(etna_vidmem_alloc_linear(conn, &bmp, bmp_size, VIV_SURF_BITMAP, VIV_POOL_DEFAULT, true) != ETNA_OK)
+    if((bmp=etna_bo_new(conn, bmp_size, DRM_ETNA_GEM_TYPE_BMP))==NULL)
     {
         fprintf(stderr, "Error allocating video memory\n");
         exit(1);
     }
 
     /* Allocate and read test YV12 image */
-    struct etna_vidmem *src[3] = {0}; /* source */
+    struct etna_bo *src[3] = {0}; /* source */
     int src_width[3], src_height[3], src_stride[3];
     size_t src_size[3];
     src_width[0] = 284;
@@ -117,7 +117,7 @@ int main(int argc, char **argv)
     for(int plane=0; plane<3; ++plane)
     {
         src_size[plane] = src_stride[plane] * src_height[plane];
-        if(etna_vidmem_alloc_linear(conn, &src[plane], src_size[plane], VIV_SURF_BITMAP, VIV_POOL_DEFAULT, true) != ETNA_OK)
+        if((src[plane]=etna_bo_new(conn, src_size[plane], DRM_ETNA_GEM_TYPE_BMP))==NULL)
         {
             fprintf(stderr, "Error allocating video memory\n");
             exit(1);
@@ -133,22 +133,22 @@ int main(int argc, char **argv)
     for(int plane=0; plane<3; ++plane)
     {
         for(int line=0; line<src_height[plane]; ++line)
-            fread(src[plane]->logical + src_stride[plane]*line, etna_align_up(src_width[plane], 4), 1, f);
+            fread(etna_bo_map(src[plane]) + src_stride[plane]*line, etna_align_up(src_width[plane], 4), 1, f);
     }
     fclose(f);
     printf("Succesfully loaded test image\n");
     // Debug: uncomment to disable planes
-    //memset(src[0]->logical, 0, src_stride[0]*src_height[0]);
-    //memset(src[1]->logical, 0, src_stride[1]*src_height[1]);
-    //memset(src[2]->logical, 0, src_stride[2]*src_height[2]);
+    //memset(etna_bo_map(src[0]), 0, src_stride[0]*src_height[0]);
+    //memset(etna_bo_map(src[1]), 0, src_stride[1]*src_height[1]);
+    //memset(etna_bo_map(src[2]), 0, src_stride[2]*src_height[2]);
 
     /* Allocate temporary surface for scaling */
-    struct etna_vidmem *temp = 0;
+    struct etna_bo *temp = 0;
     size_t temp_width = width; // horizontal pass first
     size_t temp_height = src_height[0];
     size_t temp_stride = etna_align_up(temp_width, 8) * 4; // always align to 8 pixels
     size_t temp_size = temp_stride * temp_height;
-    if(etna_vidmem_alloc_linear(conn, &temp, temp_size, VIV_SURF_BITMAP, VIV_POOL_DEFAULT, true) != ETNA_OK)
+    if((temp=etna_bo_new(conn, temp_size, DRM_ETNA_GEM_TYPE_BMP))==NULL)
     {
         fprintf(stderr, "Error allocating video memory\n");
         exit(1);
@@ -168,7 +168,7 @@ int main(int argc, char **argv)
      * but we're lazy.
      */
     for(int i=0; i<bmp_size/4; ++i)
-        ((uint32_t*)bmp->logical)[i] = 0xff404040;
+        ((uint32_t*)etna_bo_map(bmp))[i] = 0xff404040;
 
     /* Compute lanczos filter kernel */
     uint32_t filter_kernel[FB_DWORD_COUNT] = {0};
@@ -237,11 +237,11 @@ int main(int argc, char **argv)
         /*((( Horizontal pass )))*/
 
         /* Source configuration */
-        etna_set_state(ctx, VIVS_DE_SRC_ADDRESS, src[0]->address);
+        etna_set_state(ctx, VIVS_DE_SRC_ADDRESS, etna_bo_gpu_address(src[0]));
         etna_set_state(ctx, VIVS_DE_SRC_STRIDE, src_stride[0]);
-        etna_set_state(ctx, VIVS_DE_UPLANE_ADDRESS, src[1]->address);
+        etna_set_state(ctx, VIVS_DE_UPLANE_ADDRESS, etna_bo_gpu_address(src[1]));
         etna_set_state(ctx, VIVS_DE_UPLANE_STRIDE, src_stride[1]);
-        etna_set_state(ctx, VIVS_DE_VPLANE_ADDRESS, src[2]->address);
+        etna_set_state(ctx, VIVS_DE_VPLANE_ADDRESS, etna_bo_gpu_address(src[2]));
         etna_set_state(ctx, VIVS_DE_VPLANE_STRIDE, src_stride[2]);
 
         /* Are these used in VR blit?
@@ -260,7 +260,7 @@ int main(int argc, char **argv)
                 VIVS_DE_STRETCH_FACTOR_HIGH_Y(((src_height[0] - 1) << 16) / (height - 1)));
 
         /* Destination setup */
-        etna_set_state(ctx, VIVS_DE_DEST_ADDRESS, temp->address);
+        etna_set_state(ctx, VIVS_DE_DEST_ADDRESS, etna_bo_gpu_address(temp));
         etna_set_state(ctx, VIVS_DE_DEST_STRIDE, temp_stride);
         etna_set_state(ctx, VIVS_DE_DEST_ROTATION_CONFIG, 0);
         etna_set_state(ctx, VIVS_DE_DEST_CONFIG,
@@ -326,7 +326,7 @@ int main(int argc, char **argv)
                 VIVS_DE_VR_CONFIG_START_HORIZONTAL_BLIT);
 
         /* (((Vertical pass))) */
-        etna_set_state(ctx, VIVS_DE_SRC_ADDRESS, temp->address);
+        etna_set_state(ctx, VIVS_DE_SRC_ADDRESS, etna_bo_gpu_address(temp));
         etna_set_state(ctx, VIVS_DE_SRC_STRIDE, temp_stride);
         etna_set_state(ctx, VIVS_DE_UPLANE_ADDRESS, 0);
         etna_set_state(ctx, VIVS_DE_UPLANE_STRIDE, 0);
@@ -343,7 +343,7 @@ int main(int argc, char **argv)
                 VIVS_DE_VR_SOURCE_IMAGE_HIGH_RIGHT(temp_width) |
                 VIVS_DE_VR_SOURCE_IMAGE_HIGH_BOTTOM(temp_height));
 
-        etna_set_state(ctx, VIVS_DE_DEST_ADDRESS, bmp->address);
+        etna_set_state(ctx, VIVS_DE_DEST_ADDRESS, etna_bo_gpu_address(bmp));
         etna_set_state(ctx, VIVS_DE_DEST_STRIDE, dest_stride);
 
         etna_set_state(ctx, VIVS_DE_VR_TARGET_WINDOW_LOW,
@@ -360,7 +360,7 @@ int main(int argc, char **argv)
         etna_set_state(ctx, VIVS_GL_FLUSH_CACHE, VIVS_GL_FLUSH_CACHE_PE2D);
         etna_finish(ctx);
     }
-    bmp_dump32_noflip(bmp->logical, width, height, true, "/tmp/fb.bmp");
+    bmp_dump32_noflip(etna_bo_map(bmp), width, height, true, "/tmp/fb.bmp");
     printf("Dump complete\n");
 
     etna_free(ctx);
diff --git a/src/test2d/line2d.c b/src/test2d/line2d.c
index e5b2b43..05f69d0 100644
--- a/src/test2d/line2d.c
+++ b/src/test2d/line2d.c
@@ -40,7 +40,7 @@
 #include <etnaviv/cmdstream.xml.h>
 #include <etnaviv/viv.h>
 #include <etnaviv/etna.h>
-#include <etnaviv/etna_mem.h>
+#include <etnaviv/etna_bo.h>
 #include <etnaviv/etna_util.h>
 #include <etnaviv/etna_rs.h>
 
@@ -65,14 +65,14 @@ int main(int argc, char **argv)
     }
     printf("Succesfully opened device\n");
     
-    struct etna_vidmem *bmp = 0; /* bitmap */
-    struct etna_vidmem *src = 0; /* source */
+    struct etna_bo *bmp = 0; /* bitmap */
+    struct etna_bo *src = 0; /* source */
 
     size_t bmp_size = width * height * 4;
     size_t src_size = width * height * 4;
 
-    if(etna_vidmem_alloc_linear(conn, &bmp, bmp_size, VIV_SURF_BITMAP, VIV_POOL_DEFAULT, true)!=ETNA_OK ||
-       etna_vidmem_alloc_linear(conn, &src, src_size, VIV_SURF_BITMAP, VIV_POOL_DEFAULT, true)!=ETNA_OK)
+    if((bmp=etna_bo_new(conn, bmp_size, DRM_ETNA_GEM_TYPE_BMP))==NULL ||
+       (src=etna_bo_new(conn, src_size, DRM_ETNA_GEM_TYPE_BMP))==NULL)
     {
         fprintf(stderr, "Error allocating video memory\n");
         exit(1);
@@ -90,8 +90,8 @@ int main(int argc, char **argv)
     /* pre-clear surface. Could use the 2D engine for this,
      * but we're lazy.
      */
-    memset(src->logical, 255, src_size);
-    memset(bmp->logical, 0, bmp_size);
+    memset(etna_bo_map(src), 255, src_size);
+    memset(etna_bo_map(bmp), 0, bmp_size);
     for(int frame=0; frame<1; ++frame)
     {
         printf("*** FRAME %i ****\n", frame);
@@ -111,7 +111,7 @@ int main(int argc, char **argv)
         etna_set_state(ctx, VIVS_DE_SRC_COLOR_FG, 0xff44ff44);
         etna_set_state(ctx, VIVS_DE_STRETCH_FACTOR_LOW, 0);
         etna_set_state(ctx, VIVS_DE_STRETCH_FACTOR_HIGH, 0);
-        etna_set_state(ctx, VIVS_DE_DEST_ADDRESS, bmp->address);
+        etna_set_state(ctx, VIVS_DE_DEST_ADDRESS, etna_bo_gpu_address(bmp));
         etna_set_state(ctx, VIVS_DE_DEST_STRIDE, width*4);
         etna_set_state(ctx, VIVS_DE_DEST_ROTATION_CONFIG, 0);
         etna_set_state(ctx, VIVS_DE_DEST_CONFIG, 
@@ -186,7 +186,7 @@ int main(int argc, char **argv)
         etna_set_state(ctx, VIVS_GL_FLUSH_CACHE, VIVS_GL_FLUSH_CACHE_PE2D);
         etna_finish(ctx);
     }
-    bmp_dump32(bmp->logical, width, height, false, "/tmp/fb.bmp");
+    bmp_dump32(etna_bo_map(bmp), width, height, false, "/tmp/fb.bmp");
     printf("Dump complete\n");
 
     etna_free(ctx);
diff --git a/src/test2d/line2d_patterned.c b/src/test2d/line2d_patterned.c
index a7aaa2c..3cb7a8b 100644
--- a/src/test2d/line2d_patterned.c
+++ b/src/test2d/line2d_patterned.c
@@ -40,7 +40,7 @@
 #include <etnaviv/cmdstream.xml.h>
 #include <etnaviv/viv.h>
 #include <etnaviv/etna.h>
-#include <etnaviv/etna_mem.h>
+#include <etnaviv/etna_bo.h>
 #include <etnaviv/etna_util.h>
 #include <etnaviv/etna_rs.h>
 
@@ -65,14 +65,14 @@ int main(int argc, char **argv)
     }
     printf("Succesfully opened device\n");
     
-    struct etna_vidmem *bmp = 0; /* bitmap */
-    struct etna_vidmem *src = 0; /* source */
+    struct etna_bo *bmp = 0; /* bitmap */
+    struct etna_bo *src = 0; /* source */
 
     size_t bmp_size = width * height * 4;
     size_t src_size = width * height * 4;
 
-    if(etna_vidmem_alloc_linear(conn, &bmp, bmp_size, VIV_SURF_BITMAP, VIV_POOL_DEFAULT, true)!=ETNA_OK ||
-       etna_vidmem_alloc_linear(conn, &src, src_size, VIV_SURF_BITMAP, VIV_POOL_DEFAULT, true)!=ETNA_OK)
+    if((bmp=etna_bo_new(conn, bmp_size, DRM_ETNA_GEM_TYPE_BMP))==NULL ||
+       (src=etna_bo_new(conn, src_size, DRM_ETNA_GEM_TYPE_BMP))==NULL)
     {
         fprintf(stderr, "Error allocating video memory\n");
         exit(1);
@@ -90,10 +90,12 @@ int main(int argc, char **argv)
     /* pre-clear surface. Could use the 2D engine for this,
      * but we're lazy.
      */
+    uint32_t *bmp_map = etna_bo_map(bmp);
     for(int i=0; i<bmp_size/4; ++i)
-        ((uint32_t*)bmp->logical)[i] = 0xff000000;
+        bmp_map[i] = 0xff000000;
 
     /* Make pattern */
+    uint32_t *src_map = etna_bo_map(src);
     for(int y=0; y<8; ++y)
     {
         for(int x=0; x<8; ++x)
@@ -102,7 +104,7 @@ int main(int argc, char **argv)
             uint8_t r = x*32;
             uint8_t g = y*32;
             uint8_t b = 0x12;
-            ((uint32_t*)src->logical)[y*8+x] = ((uint32_t)a << 24)|((uint32_t)b<<16)|((uint32_t)g<<8)|(uint32_t)r;
+            src_map[y*8+x] = ((uint32_t)a << 24)|((uint32_t)b<<16)|((uint32_t)g<<8)|(uint32_t)r;
         }
     }
     for(int frame=0; frame<1; ++frame)
@@ -124,7 +126,7 @@ int main(int argc, char **argv)
         etna_set_state(ctx, VIVS_DE_SRC_COLOR_FG, 0xff44ff44);
         etna_set_state(ctx, VIVS_DE_STRETCH_FACTOR_LOW, 0);
         etna_set_state(ctx, VIVS_DE_STRETCH_FACTOR_HIGH, 0);
-        etna_set_state(ctx, VIVS_DE_DEST_ADDRESS, bmp->address);
+        etna_set_state(ctx, VIVS_DE_DEST_ADDRESS, etna_bo_gpu_address(bmp));
         etna_set_state(ctx, VIVS_DE_DEST_STRIDE, width*4);
         etna_set_state(ctx, VIVS_DE_DEST_ROTATION_CONFIG, 0);
         etna_set_state(ctx, VIVS_DE_DEST_CONFIG, 
@@ -152,7 +154,7 @@ int main(int argc, char **argv)
         etna_set_state(ctx, VIVS_DE_SRC_ROTATION_HEIGHT, 0);
         etna_set_state(ctx, VIVS_DE_ROT_ANGLE, 0);
 
-        etna_set_state(ctx, VIVS_DE_PATTERN_ADDRESS, src->address);
+        etna_set_state(ctx, VIVS_DE_PATTERN_ADDRESS, etna_bo_gpu_address(src));
         etna_set_state(ctx, VIVS_DE_PATTERN_CONFIG, 
                 VIVS_DE_PATTERN_CONFIG_FORMAT(DE_FORMAT_A8R8G8B8) |
                 VIVS_DE_PATTERN_CONFIG_TYPE_PATTERN);
@@ -189,7 +191,7 @@ int main(int argc, char **argv)
         etna_set_state(ctx, VIVS_GL_FLUSH_CACHE, VIVS_GL_FLUSH_CACHE_PE2D);
         etna_finish(ctx);
     }
-    bmp_dump32(bmp->logical, width, height, false, "/tmp/fb.bmp");
+    bmp_dump32(etna_bo_map(bmp), width, height, false, "/tmp/fb.bmp");
     printf("Dump complete\n");
 
     etna_free(ctx);
diff --git a/src/test2d/stretchblt2d.c b/src/test2d/stretchblt2d.c
index 2b34510..fbfad56 100644
--- a/src/test2d/stretchblt2d.c
+++ b/src/test2d/stretchblt2d.c
@@ -41,7 +41,7 @@
 #include <etnaviv/cmdstream.xml.h>
 #include <etnaviv/viv.h>
 #include <etnaviv/etna.h>
-#include <etnaviv/etna_mem.h>
+#include <etnaviv/etna_bo.h>
 #include <etnaviv/etna_util.h>
 #include <etnaviv/etna_rs.h>
 
@@ -66,14 +66,14 @@ int main(int argc, char **argv)
     }
     printf("Succesfully opened device\n");
     
-    struct etna_vidmem *bmp = 0; /* bitmap */
-    struct etna_vidmem *src = 0; /* source */
+    struct etna_bo *bmp = 0; /* bitmap */
+    struct etna_bo *src = 0; /* source */
 
     size_t bmp_size = width * height * 4;
     size_t src_size = width * height * 4;
 
-    if(etna_vidmem_alloc_linear(conn, &bmp, bmp_size, VIV_SURF_BITMAP, VIV_POOL_DEFAULT, true)!=ETNA_OK ||
-       etna_vidmem_alloc_linear(conn, &src, src_size, VIV_SURF_BITMAP, VIV_POOL_DEFAULT, true)!=ETNA_OK)
+    if((bmp=etna_bo_new(conn, bmp_size, DRM_ETNA_GEM_TYPE_BMP))==NULL ||
+       (src=etna_bo_new(conn, src_size, DRM_ETNA_GEM_TYPE_BMP))==NULL)
     {
         fprintf(stderr, "Error allocating video memory\n");
         exit(1);
@@ -91,19 +91,21 @@ int main(int argc, char **argv)
     /* pre-clear surface. Could use the 2D engine for this,
      * but we're lazy.
      */
+    uint32_t *bmp_map = etna_bo_map(bmp);
     for(int i=0; i<bmp_size/4; ++i)
-        ((uint32_t*)bmp->logical)[i] = 0xff000000;
-    for(int i=0; i<bmp_size/4; ++i)
-        ((uint32_t*)src->logical)[i] = 0xff808080;
-   
+        bmp_map[i] = 0xff000000;
+    uint32_t *src_map = etna_bo_map(src);
+    for(int i=0; i<src_size/4; ++i)
+        src_map[i] = 0xff808080;
+
     /* Size of source rectangle */
     int src_width = 2;
     int src_height = 2;
     int src_stride = width*4;
-    ((uint32_t*)src->logical)[0] = 0xffff0000;
-    ((uint32_t*)src->logical)[1] = 0xff00ff00;
-    ((uint32_t*)src->logical)[src_stride/4+0] = 0xffff00ff;
-    ((uint32_t*)src->logical)[src_stride/4+1] = 0xff00ffff;
+    src_map[0] = 0xffff0000;
+    src_map[1] = 0xff00ff00;
+    src_map[src_stride/4+0] = 0xffff00ff;
+    src_map[src_stride/4+1] = 0xff00ffff;
 
     /* Size of destination rectangle */
     int dst_width = 30;
@@ -113,7 +115,7 @@ int main(int argc, char **argv)
     {
         printf("*** FRAME %i ****\n", frame);
 
-        etna_set_state(ctx, VIVS_DE_SRC_ADDRESS, src->address);
+        etna_set_state(ctx, VIVS_DE_SRC_ADDRESS, etna_bo_gpu_address(src));
         etna_set_state(ctx, VIVS_DE_SRC_STRIDE, src_stride);
         etna_set_state(ctx, VIVS_DE_SRC_ROTATION_CONFIG, 0);
         etna_set_state(ctx, VIVS_DE_SRC_CONFIG, 
@@ -137,7 +139,7 @@ int main(int argc, char **argv)
         printf("%08x\n", ((src_width - 1) << 16) / (dst_width - 1));
         printf("%08x\n", ((src_height - 1) << 16) / (dst_height - 1));
         /* Destination setup */
-        etna_set_state(ctx, VIVS_DE_DEST_ADDRESS, bmp->address);
+        etna_set_state(ctx, VIVS_DE_DEST_ADDRESS, etna_bo_gpu_address(bmp));
         etna_set_state(ctx, VIVS_DE_DEST_STRIDE, width*4);
         etna_set_state(ctx, VIVS_DE_DEST_ROTATION_CONFIG, 0);
         etna_set_state(ctx, VIVS_DE_DEST_CONFIG, 
@@ -200,7 +202,7 @@ int main(int argc, char **argv)
         etna_set_state(ctx, VIVS_GL_FLUSH_CACHE, VIVS_GL_FLUSH_CACHE_PE2D);
         etna_finish(ctx);
     }
-    bmp_dump32(bmp->logical, width, height, false, "/tmp/fb.bmp");
+    bmp_dump32(etna_bo_map(bmp), width, height, false, "/tmp/fb.bmp");
     printf("Dump complete\n");
 
     etna_free(ctx);