nouveau: switch to libdrm_nouveau-2.0

1 files changed, 248 insertions, 256 deletions

diff --git a/src/gallium/drivers/nvc0/nvc0_screen.c b/src/gallium/drivers/nvc0/nvc0_screen.c
index f7637eedc43..f314cb631f2 100644
--- a/src/gallium/drivers/nvc0/nvc0_screen.c
+++ b/src/gallium/drivers/nvc0/nvc0_screen.c
@@ -238,8 +238,8 @@ nvc0_screen_destroy(struct pipe_screen *pscreen)
       nouveau_fence_wait(screen->base.fence.current);
       nouveau_fence_ref(NULL, &screen->base.fence.current);
    }
-   if (screen->base.channel)
-      screen->base.channel->user_private = NULL;
+   if (screen->base.pushbuf)
+      screen->base.pushbuf->user_priv = NULL;
 
    if (screen->blitctx)
       FREE(screen->blitctx);
@@ -250,17 +250,17 @@ nvc0_screen_destroy(struct pipe_screen *pscreen)
    nouveau_bo_ref(NULL, &screen->fence.bo);
    nouveau_bo_ref(NULL, &screen->vfetch_cache);
 
-   nouveau_resource_destroy(&screen->lib_code);
-   nouveau_resource_destroy(&screen->text_heap);
+   nouveau_heap_destroy(&screen->lib_code);
+   nouveau_heap_destroy(&screen->text_heap);
 
    if (screen->tic.entries)
       FREE(screen->tic.entries);
 
    nouveau_mm_destroy(screen->mm_VRAM_fe0);
 
-   nouveau_grobj_free(&screen->fermi);
-   nouveau_grobj_free(&screen->eng2d);
-   nouveau_grobj_free(&screen->m2mf);
+   nouveau_object_del(&screen->fermi);
+   nouveau_object_del(&screen->eng2d);
+   nouveau_object_del(&screen->m2mf);
 
    nouveau_screen_fini(&screen->base);
 
@@ -271,102 +271,100 @@ static int
 nvc0_graph_set_macro(struct nvc0_screen *screen, uint32_t m, unsigned pos,
                      unsigned size, const uint32_t *data)
 {
-   struct nouveau_channel *chan = screen->base.channel;
+   struct nouveau_pushbuf *push = screen->base.pushbuf;
 
    size /= 4;
 
-   BEGIN_RING(chan, RING_3D_(NVC0_GRAPH_MACRO_ID), 2);
-   OUT_RING  (chan, (m - 0x3800) / 8);
-   OUT_RING  (chan, pos);
-   BEGIN_RING_1I(chan, RING_3D_(NVC0_GRAPH_MACRO_UPLOAD_POS), size + 1);
-   OUT_RING  (chan, pos);
-   OUT_RINGp (chan, data, size);
+   BEGIN_NVC0(push, SUBC_3D(NVC0_GRAPH_MACRO_ID), 2);
+   PUSH_DATA (push, (m - 0x3800) / 8);
+   PUSH_DATA (push, pos);
+   BEGIN_1IC0(push, SUBC_3D(NVC0_GRAPH_MACRO_UPLOAD_POS), size + 1);
+   PUSH_DATA (push, pos);
+   PUSH_DATAp(push, data, size);
 
    return pos + size;
 }
 
 static void
-nvc0_magic_3d_init(struct nouveau_channel *chan)
+nvc0_magic_3d_init(struct nouveau_pushbuf *push)
 {
-   BEGIN_RING(chan, RING_3D_(0x10cc), 1);
-   OUT_RING  (chan, 0xff);
-   BEGIN_RING(chan, RING_3D_(0x10e0), 2);
-   OUT_RING(chan, 0xff);
-   OUT_RING(chan, 0xff);
-   BEGIN_RING(chan, RING_3D_(0x10ec), 2);
-   OUT_RING(chan, 0xff);
-   OUT_RING(chan, 0xff);
-   BEGIN_RING(chan, RING_3D_(0x074c), 1);
-   OUT_RING  (chan, 0x3f);
-
-   BEGIN_RING(chan, RING_3D_(0x16a8), 1);
-   OUT_RING  (chan, (3 << 16) | 3);
-   BEGIN_RING(chan, RING_3D_(0x1794), 1);
-   OUT_RING  (chan, (2 << 16) | 2);
-   BEGIN_RING(chan, RING_3D_(0x0de8), 1);
-   OUT_RING  (chan, 1);
+   BEGIN_NVC0(push, SUBC_3D(0x10cc), 1);
+   PUSH_DATA (push, 0xff);
+   BEGIN_NVC0(push, SUBC_3D(0x10e0), 2);
+   PUSH_DATA(push, 0xff);
+   PUSH_DATA(push, 0xff);
+   BEGIN_NVC0(push, SUBC_3D(0x10ec), 2);
+   PUSH_DATA(push, 0xff);
+   PUSH_DATA(push, 0xff);
+   BEGIN_NVC0(push, SUBC_3D(0x074c), 1);
+   PUSH_DATA (push, 0x3f);
+
+   BEGIN_NVC0(push, SUBC_3D(0x16a8), 1);
+   PUSH_DATA (push, (3 << 16) | 3);
+   BEGIN_NVC0(push, SUBC_3D(0x1794), 1);
+   PUSH_DATA (push, (2 << 16) | 2);
+   BEGIN_NVC0(push, SUBC_3D(0x0de8), 1);
+   PUSH_DATA (push, 1);
 
 #if 0 /* software method */
-   BEGIN_RING(chan, RING_3D_(0x1528), 1); /* MP poke */
-   OUT_RING  (chan, 0);
+   BEGIN_NVC0(push, SUBC_3D(0x1528), 1); /* MP poke */
+   PUSH_DATA (push, 0);
 #endif
 
-   BEGIN_RING(chan, RING_3D_(0x12ac), 1);
-   OUT_RING  (chan, 0);
-   BEGIN_RING(chan, RING_3D_(0x0218), 1);
-   OUT_RING  (chan, 0x10);
-   BEGIN_RING(chan, RING_3D_(0x10fc), 1);
-   OUT_RING  (chan, 0x10);
-   BEGIN_RING(chan, RING_3D_(0x1290), 1);
-   OUT_RING  (chan, 0x10);
-   BEGIN_RING(chan, RING_3D_(0x12d8), 2);
-   OUT_RING  (chan, 0x10);
-   OUT_RING  (chan, 0x10);
-   BEGIN_RING(chan, RING_3D_(0x06d4), 1);
-   OUT_RING  (chan, 8);
-   BEGIN_RING(chan, RING_3D_(0x1140), 1);
-   OUT_RING  (chan, 0x10);
-   BEGIN_RING(chan, RING_3D_(0x1610), 1);
-   OUT_RING  (chan, 0xe);
-
-   BEGIN_RING(chan, RING_3D_(0x164c), 1);
-   OUT_RING  (chan, 1 << 12);
-   BEGIN_RING(chan, RING_3D_(0x151c), 1);
-   OUT_RING  (chan, 1);
-   BEGIN_RING(chan, RING_3D_(0x030c), 1);
-   OUT_RING  (chan, 0);
-   BEGIN_RING(chan, RING_3D_(0x0300), 1);
-   OUT_RING  (chan, 3);
+   BEGIN_NVC0(push, SUBC_3D(0x12ac), 1);
+   PUSH_DATA (push, 0);
+   BEGIN_NVC0(push, SUBC_3D(0x0218), 1);
+   PUSH_DATA (push, 0x10);
+   BEGIN_NVC0(push, SUBC_3D(0x10fc), 1);
+   PUSH_DATA (push, 0x10);
+   BEGIN_NVC0(push, SUBC_3D(0x1290), 1);
+   PUSH_DATA (push, 0x10);
+   BEGIN_NVC0(push, SUBC_3D(0x12d8), 2);
+   PUSH_DATA (push, 0x10);
+   PUSH_DATA (push, 0x10);
+   BEGIN_NVC0(push, SUBC_3D(0x06d4), 1);
+   PUSH_DATA (push, 8);
+   BEGIN_NVC0(push, SUBC_3D(0x1140), 1);
+   PUSH_DATA (push, 0x10);
+   BEGIN_NVC0(push, SUBC_3D(0x1610), 1);
+   PUSH_DATA (push, 0xe);
+
+   BEGIN_NVC0(push, SUBC_3D(0x164c), 1);
+   PUSH_DATA (push, 1 << 12);
+   BEGIN_NVC0(push, SUBC_3D(0x151c), 1);
+   PUSH_DATA (push, 1);
+   BEGIN_NVC0(push, SUBC_3D(0x030c), 1);
+   PUSH_DATA (push, 0);
+   BEGIN_NVC0(push, SUBC_3D(0x0300), 1);
+   PUSH_DATA (push, 3);
 #if 0 /* software method */
-   BEGIN_RING(chan, RING_3D_(0x1280), 1); /* PGRAPH poke */
-   OUT_RING  (chan, 0);
+   BEGIN_NVC0(push, SUBC_3D(0x1280), 1); /* PGRAPH poke */
+   PUSH_DATA (push, 0);
 #endif
-   BEGIN_RING(chan, RING_3D_(0x02d0), 1);
-   OUT_RING  (chan, 0x1f40);
-   BEGIN_RING(chan, RING_3D_(0x00fdc), 1);
-   OUT_RING  (chan, 1);
-   BEGIN_RING(chan, RING_3D_(0x19c0), 1);
-   OUT_RING  (chan, 1);
-   BEGIN_RING(chan, RING_3D_(0x075c), 1);
-   OUT_RING  (chan, 3);
+   BEGIN_NVC0(push, SUBC_3D(0x02d0), 1);
+   PUSH_DATA (push, 0x1f40);
+   BEGIN_NVC0(push, SUBC_3D(0x0fdc), 1);
+   PUSH_DATA (push, 1);
+   BEGIN_NVC0(push, SUBC_3D(0x19c0), 1);
+   PUSH_DATA (push, 1);
+   BEGIN_NVC0(push, SUBC_3D(0x075c), 1);
+   PUSH_DATA (push, 3);
 }
 
 static void
 nvc0_screen_fence_emit(struct pipe_screen *pscreen, u32 *sequence)
 {
    struct nvc0_screen *screen = nvc0_screen(pscreen);
-   struct nouveau_channel *chan = screen->base.channel;
-
-   MARK_RING (chan, 5, 2);
+   struct nouveau_pushbuf *push = screen->base.pushbuf;
 
    /* we need to do it after possible flush in MARK_RING */
    *sequence = ++screen->base.fence.sequence;
 
-   BEGIN_RING(chan, RING_3D(QUERY_ADDRESS_HIGH), 4);
-   OUT_RELOCh(chan, screen->fence.bo, 0, NOUVEAU_BO_WR);
-   OUT_RELOCl(chan, screen->fence.bo, 0, NOUVEAU_BO_WR);
-   OUT_RING  (chan, *sequence);
-   OUT_RING  (chan, NVC0_3D_QUERY_GET_FENCE | NVC0_3D_QUERY_GET_SHORT |
+   BEGIN_NVC0(push, NVC0_3D(QUERY_ADDRESS_HIGH), 4);
+   PUSH_DATAh(push, screen->fence.bo->offset);
+   PUSH_DATA (push, screen->fence.bo->offset);
+   PUSH_DATA (push, *sequence);
+   PUSH_DATA (push, NVC0_3D_QUERY_GET_FENCE | NVC0_3D_QUERY_GET_SHORT |
               (0xf << NVC0_3D_QUERY_GET_UNIT__SHIFT));
 }
 
@@ -388,10 +386,12 @@ struct pipe_screen *
 nvc0_screen_create(struct nouveau_device *dev)
 {
    struct nvc0_screen *screen;
-   struct nouveau_channel *chan;
    struct pipe_screen *pscreen;
+   struct nouveau_object *chan;
+   struct nouveau_pushbuf *push;
    int ret;
    unsigned i;
+   union nouveau_bo_config mm_config;
 
    screen = CALLOC_STRUCT(nvc0_screen);
    if (!screen)
@@ -406,7 +406,8 @@ nvc0_screen_create(struct nouveau_device *dev)
       return NULL;
    }
    chan = screen->base.channel;
-   chan->user_private = screen;
+   push = screen->base.pushbuf;
+   push->user_priv = screen;
 
    pscreen->destroy = nvc0_screen_destroy;
    pscreen->context_create = nvc0_create;
@@ -419,203 +420,210 @@ nvc0_screen_create(struct nouveau_device *dev)
 
    nouveau_screen_init_vdec(&screen->base);
 
-   ret = nouveau_bo_new(dev, NOUVEAU_BO_GART | NOUVEAU_BO_MAP, 0, 4096,
+   ret = nouveau_bo_new(dev, NOUVEAU_BO_GART | NOUVEAU_BO_MAP, 0, 4096, NULL,
                         &screen->fence.bo);
    if (ret)
       goto fail;
-   nouveau_bo_map(screen->fence.bo, NOUVEAU_BO_RDWR);
+   nouveau_bo_map(screen->fence.bo, 0, NULL);
    screen->fence.map = screen->fence.bo->map;
-   nouveau_bo_unmap(screen->fence.bo);
    screen->base.fence.emit = nvc0_screen_fence_emit;
    screen->base.fence.update = nvc0_screen_fence_update;
 
    for (i = 0; i < NVC0_SCRATCH_NR_BUFFERS; ++i) {
-      ret = nouveau_bo_new(dev, NOUVEAU_BO_GART, 0, NVC0_SCRATCH_SIZE,
+      ret = nouveau_bo_new(dev, NOUVEAU_BO_GART, 0, NVC0_SCRATCH_SIZE, NULL,
                            &screen->scratch.bo[i]);
       if (ret)
          goto fail;
    }
 
-   ret = nouveau_grobj_alloc(chan, 0xbeef9039, NVC0_M2MF, &screen->m2mf);
+   ret = nouveau_object_new(chan, 0xbeef9039, NVC0_M2MF_CLASS, NULL, 0,
+                            &screen->m2mf);
    if (ret)
       FAIL_SCREEN_INIT("Error allocating PGRAPH context for M2MF: %d\n", ret);
 
-   BIND_RING (chan, screen->m2mf, NVC0_SUBCH_MF);
-   BEGIN_RING(chan, RING_MF(NOTIFY_ADDRESS_HIGH), 3);
-   OUT_RELOCh(chan, screen->fence.bo, 16, NOUVEAU_BO_GART | NOUVEAU_BO_RDWR);
-   OUT_RELOCl(chan, screen->fence.bo, 16, NOUVEAU_BO_GART | NOUVEAU_BO_RDWR);
-   OUT_RING  (chan, 0);
+   BEGIN_NVC0(push, SUBC_M2MF(NV01_SUBCHAN_OBJECT), 1);
+   PUSH_DATA (push, screen->m2mf->oclass);
+   BEGIN_NVC0(push, NVC0_M2MF(NOTIFY_ADDRESS_HIGH), 3);
+   PUSH_DATAh(push, screen->fence.bo->offset + 16);
+   PUSH_DATA (push, screen->fence.bo->offset + 16);
+   PUSH_DATA (push, 0);
 
-   ret = nouveau_grobj_alloc(chan, 0xbeef902d, NVC0_2D, &screen->eng2d);
+   ret = nouveau_object_new(chan, 0xbeef902d, NVC0_2D_CLASS, NULL, 0,
+                            &screen->eng2d);
    if (ret)
       FAIL_SCREEN_INIT("Error allocating PGRAPH context for 2D: %d\n", ret);
 
-   BIND_RING (chan, screen->eng2d, NVC0_SUBCH_2D);
-   BEGIN_RING(chan, RING_2D(OPERATION), 1);
-   OUT_RING  (chan, NVC0_2D_OPERATION_SRCCOPY);
-   BEGIN_RING(chan, RING_2D(CLIP_ENABLE), 1);
-   OUT_RING  (chan, 0);
-   BEGIN_RING(chan, RING_2D(COLOR_KEY_ENABLE), 1);
-   OUT_RING  (chan, 0);
-   BEGIN_RING(chan, RING_2D_(0x0884), 1);
-   OUT_RING  (chan, 0x3f);
-   BEGIN_RING(chan, RING_2D_(0x0888), 1);
-   OUT_RING  (chan, 1);
-
-   ret = nouveau_grobj_alloc(chan, 0xbeef9097, NVC0_3D, &screen->fermi);
+   BEGIN_NVC0(push, SUBC_2D(NV01_SUBCHAN_OBJECT), 1);
+   PUSH_DATA (push, screen->eng2d->oclass);
+   BEGIN_NVC0(push, NVC0_2D(OPERATION), 1);
+   PUSH_DATA (push, NVC0_2D_OPERATION_SRCCOPY);
+   BEGIN_NVC0(push, NVC0_2D(CLIP_ENABLE), 1);
+   PUSH_DATA (push, 0);
+   BEGIN_NVC0(push, NVC0_2D(COLOR_KEY_ENABLE), 1);
+   PUSH_DATA (push, 0);
+   BEGIN_NVC0(push, SUBC_2D(0x0884), 1);
+   PUSH_DATA (push, 0x3f);
+   BEGIN_NVC0(push, SUBC_2D(0x0888), 1);
+   PUSH_DATA (push, 1);
+
+   ret = nouveau_object_new(chan, 0xbeef9097, NVC0_3D_CLASS, NULL, 0,
+                            &screen->fermi);
    if (ret)
       FAIL_SCREEN_INIT("Error allocating PGRAPH context for 3D: %d\n", ret);
 
-   BIND_RING (chan, screen->fermi, NVC0_SUBCH_3D);
-   BEGIN_RING(chan, RING_3D(NOTIFY_ADDRESS_HIGH), 3);
-   OUT_RELOCh(chan, screen->fence.bo, 32, NOUVEAU_BO_GART | NOUVEAU_BO_RDWR);
-   OUT_RELOCl(chan, screen->fence.bo, 32, NOUVEAU_BO_GART | NOUVEAU_BO_RDWR);
-   OUT_RING  (chan, 0);
+   BEGIN_NVC0(push, SUBC_3D(NV01_SUBCHAN_OBJECT), 1);
+   PUSH_DATA (push, screen->fermi->oclass);
+   BEGIN_NVC0(push, NVC0_3D(NOTIFY_ADDRESS_HIGH), 3);
+   PUSH_DATAh(push, screen->fence.bo->offset + 32);
+   PUSH_DATA (push, screen->fence.bo->offset + 32);
+   PUSH_DATA (push, 0);
 
-   BEGIN_RING(chan, RING_3D(COND_MODE), 1);
-   OUT_RING  (chan, NVC0_3D_COND_MODE_ALWAYS);
+   BEGIN_NVC0(push, NVC0_3D(COND_MODE), 1);
+   PUSH_DATA (push, NVC0_3D_COND_MODE_ALWAYS);
 
    if (debug_get_bool_option("NOUVEAU_SHADER_WATCHDOG", TRUE)) {
       /* kill shaders after about 1 second (at 100 MHz) */
-      BEGIN_RING(chan, RING_3D(WATCHDOG_TIMER), 1);
-      OUT_RING  (chan, 0x17);
+      BEGIN_NVC0(push, NVC0_3D(WATCHDOG_TIMER), 1);
+      PUSH_DATA (push, 0x17);
    }
 
-   BEGIN_RING(chan, RING_3D(RT_CONTROL), 1);
-   OUT_RING  (chan, 1);
-
-   BEGIN_RING(chan, RING_3D(CSAA_ENABLE), 1);
-   OUT_RING  (chan, 0);
-   BEGIN_RING(chan, RING_3D(MULTISAMPLE_ENABLE), 1);
-   OUT_RING  (chan, 0);
-   BEGIN_RING(chan, RING_3D(MULTISAMPLE_MODE), 1);
-   OUT_RING  (chan, NVC0_3D_MULTISAMPLE_MODE_MS1);
-   BEGIN_RING(chan, RING_3D(MULTISAMPLE_CTRL), 1);
-   OUT_RING  (chan, 0);
-   BEGIN_RING(chan, RING_3D(LINE_WIDTH_SEPARATE), 1);
-   OUT_RING  (chan, 1);
-   BEGIN_RING(chan, RING_3D(LINE_LAST_PIXEL), 1);
-   OUT_RING  (chan, 0);
-   BEGIN_RING(chan, RING_3D(BLEND_SEPARATE_ALPHA), 1);
-   OUT_RING  (chan, 1);
-   BEGIN_RING(chan, RING_3D(BLEND_ENABLE_COMMON), 1);
-   OUT_RING  (chan, 0);
-   BEGIN_RING(chan, RING_3D(TEX_MISC), 1);
-   OUT_RING  (chan, NVC0_3D_TEX_MISC_SEAMLESS_CUBE_MAP);
-
-   nvc0_magic_3d_init(chan);
-
-   ret = nouveau_bo_new(dev, NOUVEAU_BO_VRAM, 1 << 17, 1 << 20, &screen->text);
+   BEGIN_NVC0(push, NVC0_3D(RT_CONTROL), 1);
+   PUSH_DATA (push, 1);
+
+   BEGIN_NVC0(push, NVC0_3D(CSAA_ENABLE), 1);
+   PUSH_DATA (push, 0);
+   BEGIN_NVC0(push, NVC0_3D(MULTISAMPLE_ENABLE), 1);
+   PUSH_DATA (push, 0);
+   BEGIN_NVC0(push, NVC0_3D(MULTISAMPLE_MODE), 1);
+   PUSH_DATA (push, NVC0_3D_MULTISAMPLE_MODE_MS1);
+   BEGIN_NVC0(push, NVC0_3D(MULTISAMPLE_CTRL), 1);
+   PUSH_DATA (push, 0);
+   BEGIN_NVC0(push, NVC0_3D(LINE_WIDTH_SEPARATE), 1);
+   PUSH_DATA (push, 1);
+   BEGIN_NVC0(push, NVC0_3D(LINE_LAST_PIXEL), 1);
+   PUSH_DATA (push, 0);
+   BEGIN_NVC0(push, NVC0_3D(BLEND_SEPARATE_ALPHA), 1);
+   PUSH_DATA (push, 1);
+   BEGIN_NVC0(push, NVC0_3D(BLEND_ENABLE_COMMON), 1);
+   PUSH_DATA (push, 0);
+   BEGIN_NVC0(push, NVC0_3D(TEX_MISC), 1);
+   PUSH_DATA (push, NVC0_3D_TEX_MISC_SEAMLESS_CUBE_MAP);
+
+   nvc0_magic_3d_init(push);
+
+   ret = nouveau_bo_new(dev, NOUVEAU_BO_VRAM, 1 << 17, 1 << 20, NULL,
+                        &screen->text);
    if (ret)
       goto fail;
 
    /* XXX: getting a page fault at the end of the code buffer every few
     *  launches, don't use the last 256 bytes to work around them - prefetch ?
     */
-   nouveau_resource_init(&screen->text_heap, 0, (1 << 20) - 0x100);
+   nouveau_heap_init(&screen->text_heap, 0, (1 << 20) - 0x100);
 
-   ret = nouveau_bo_new(dev, NOUVEAU_BO_VRAM, 1 << 12, 6 << 16,
+   ret = nouveau_bo_new(dev, NOUVEAU_BO_VRAM, 1 << 12, 6 << 16, NULL,
                         &screen->uniforms);
    if (ret)
       goto fail;
 
    /* auxiliary constants (6 user clip planes, base instance id) */
-   BEGIN_RING(chan, RING_3D(CB_SIZE), 3);
-   OUT_RING  (chan, 256);
-   OUT_RELOCh(chan, screen->uniforms, 5 << 16, NOUVEAU_BO_VRAM | NOUVEAU_BO_RD);
-   OUT_RELOCl(chan, screen->uniforms, 5 << 16, NOUVEAU_BO_VRAM | NOUVEAU_BO_RD);
+   BEGIN_NVC0(push, NVC0_3D(CB_SIZE), 3);
+   PUSH_DATA (push, 256);
+   PUSH_DATAh(push, screen->uniforms->offset + (5 << 16));
+   PUSH_DATA (push, screen->uniforms->offset + (5 << 16));
    for (i = 0; i < 5; ++i) {
-      BEGIN_RING(chan, RING_3D(CB_BIND(i)), 1);
-      OUT_RING  (chan, (15 << 4) | 1);
+      BEGIN_NVC0(push, NVC0_3D(CB_BIND(i)), 1);
+      PUSH_DATA (push, (15 << 4) | 1);
    }
 
    screen->tls_size = (16 * 32) * (NVC0_CAP_MAX_PROGRAM_TEMPS * 16);
    ret = nouveau_bo_new(dev, NOUVEAU_BO_VRAM, 1 << 17,
-                        screen->tls_size, &screen->tls);
+                        screen->tls_size, NULL, &screen->tls);
    if (ret)
       goto fail;
 
-   BEGIN_RING(chan, RING_3D(CODE_ADDRESS_HIGH), 2);
-   OUT_RELOCh(chan, screen->text, 0, NOUVEAU_BO_VRAM | NOUVEAU_BO_RD);
-   OUT_RELOCl(chan, screen->text, 0, NOUVEAU_BO_VRAM | NOUVEAU_BO_RD);
-   BEGIN_RING(chan, RING_3D(LOCAL_ADDRESS_HIGH), 4);
-   OUT_RELOCh(chan, screen->tls, 0, NOUVEAU_BO_VRAM | NOUVEAU_BO_RDWR);
-   OUT_RELOCl(chan, screen->tls, 0, NOUVEAU_BO_VRAM | NOUVEAU_BO_RDWR);
-   OUT_RING  (chan, screen->tls_size >> 32);
-   OUT_RING  (chan, screen->tls_size);
-   BEGIN_RING(chan, RING_3D_(0x07a0), 1);
-   OUT_RING  (chan, 0);
-   BEGIN_RING(chan, RING_3D(LOCAL_BASE), 1);
-   OUT_RING  (chan, 0);
+   BEGIN_NVC0(push, NVC0_3D(CODE_ADDRESS_HIGH), 2);
+   PUSH_DATAh(push, screen->text->offset);
+   PUSH_DATA (push, screen->text->offset);
+   BEGIN_NVC0(push, NVC0_3D(TEMP_ADDRESS_HIGH), 4);
+   PUSH_DATAh(push, screen->tls->offset);
+   PUSH_DATA (push, screen->tls->offset);
+   PUSH_DATA (push, screen->tls_size >> 32);
+   PUSH_DATA (push, screen->tls_size);
+   BEGIN_NVC0(push, NVC0_3D(WARP_TEMP_ALLOC), 1);
+   PUSH_DATA (push, 0);
+   BEGIN_NVC0(push, NVC0_3D(LOCAL_BASE), 1);
+   PUSH_DATA (push, 0);
 
    for (i = 0; i < 5; ++i) {
-      BEGIN_RING(chan, RING_3D(TEX_LIMITS(i)), 1);
-      OUT_RING  (chan, 0x54);
+      BEGIN_NVC0(push, NVC0_3D(TEX_LIMITS(i)), 1);
+      PUSH_DATA (push, 0x54);
    }
-   BEGIN_RING(chan, RING_3D(LINKED_TSC), 1);
-   OUT_RING  (chan, 0);
+   BEGIN_NVC0(push, NVC0_3D(LINKED_TSC), 1);
+   PUSH_DATA (push, 0);
 
-   ret = nouveau_bo_new(dev, NOUVEAU_BO_VRAM, 1 << 17, 1 << 20,
+   ret = nouveau_bo_new(dev, NOUVEAU_BO_VRAM, 1 << 17, 1 << 20, NULL,
                         &screen->vfetch_cache);
    if (ret)
       goto fail;
 
-   BEGIN_RING(chan, RING_3D(VERTEX_QUARANTINE_ADDRESS_HIGH), 3);
-   OUT_RELOCh(chan, screen->vfetch_cache, 0, NOUVEAU_BO_VRAM | NOUVEAU_BO_RDWR);
-   OUT_RELOCl(chan, screen->vfetch_cache, 0, NOUVEAU_BO_VRAM | NOUVEAU_BO_RDWR);
-   OUT_RING  (chan, 3);
+   BEGIN_NVC0(push, NVC0_3D(VERTEX_QUARANTINE_ADDRESS_HIGH), 3);
+   PUSH_DATAh(push, screen->vfetch_cache->offset);
+   PUSH_DATA (push, screen->vfetch_cache->offset);
+   PUSH_DATA (push, 3);
 
-   ret = nouveau_bo_new(dev, NOUVEAU_BO_VRAM, 1 << 17, 1 << 17, &screen->txc);
+   ret = nouveau_bo_new(dev, NOUVEAU_BO_VRAM, 1 << 17, 1 << 17, NULL,
+                        &screen->txc);
    if (ret)
       goto fail;
 
-   BEGIN_RING(chan, RING_3D(TIC_ADDRESS_HIGH), 3);
-   OUT_RELOCh(chan, screen->txc, 0, NOUVEAU_BO_VRAM | NOUVEAU_BO_RD);
-   OUT_RELOCl(chan, screen->txc, 0, NOUVEAU_BO_VRAM | NOUVEAU_BO_RD);
-   OUT_RING  (chan, NVC0_TIC_MAX_ENTRIES - 1);
-
-   BEGIN_RING(chan, RING_3D(TSC_ADDRESS_HIGH), 3);
-   OUT_RELOCh(chan, screen->txc, 65536, NOUVEAU_BO_VRAM | NOUVEAU_BO_RD);
-   OUT_RELOCl(chan, screen->txc, 65536, NOUVEAU_BO_VRAM | NOUVEAU_BO_RD);
-   OUT_RING  (chan, NVC0_TSC_MAX_ENTRIES - 1);
-
-   BEGIN_RING(chan, RING_3D(SCREEN_Y_CONTROL), 1);
-   OUT_RING  (chan, 0);
-   BEGIN_RING(chan, RING_3D(WINDOW_OFFSET_X), 2);
-   OUT_RING  (chan, 0);
-   OUT_RING  (chan, 0);
-   BEGIN_RING(chan, RING_3D_(0x1590), 1); /* deactivate ZCULL */
-   OUT_RING  (chan, 0x3f);
-
-   BEGIN_RING(chan, RING_3D(CLIP_RECTS_MODE), 1);
-   OUT_RING  (chan, NVC0_3D_CLIP_RECTS_MODE_INSIDE_ANY);
-   BEGIN_RING(chan, RING_3D(CLIP_RECT_HORIZ(0)), 8 * 2);
+   BEGIN_NVC0(push, NVC0_3D(TIC_ADDRESS_HIGH), 3);
+   PUSH_DATAh(push, screen->txc->offset);
+   PUSH_DATA (push, screen->txc->offset);
+   PUSH_DATA (push, NVC0_TIC_MAX_ENTRIES - 1);
+
+   BEGIN_NVC0(push, NVC0_3D(TSC_ADDRESS_HIGH), 3);
+   PUSH_DATAh(push, screen->txc->offset + 65536);
+   PUSH_DATA (push, screen->txc->offset + 65536);
+   PUSH_DATA (push, NVC0_TSC_MAX_ENTRIES - 1);
+
+   BEGIN_NVC0(push, NVC0_3D(SCREEN_Y_CONTROL), 1);
+   PUSH_DATA (push, 0);
+   BEGIN_NVC0(push, NVC0_3D(WINDOW_OFFSET_X), 2);
+   PUSH_DATA (push, 0);
+   PUSH_DATA (push, 0);
+   BEGIN_NVC0(push, NVC0_3D(ZCULL_REGION), 1); /* deactivate ZCULL */
+   PUSH_DATA (push, 0x3f);
+
+   BEGIN_NVC0(push, NVC0_3D(CLIP_RECTS_MODE), 1);
+   PUSH_DATA (push, NVC0_3D_CLIP_RECTS_MODE_INSIDE_ANY);
+   BEGIN_NVC0(push, NVC0_3D(CLIP_RECT_HORIZ(0)), 8 * 2);
    for (i = 0; i < 8 * 2; ++i)
-      OUT_RING(chan, 0);
-   BEGIN_RING(chan, RING_3D(CLIP_RECTS_EN), 1);
-   OUT_RING  (chan, 0);
-   BEGIN_RING(chan, RING_3D(CLIPID_ENABLE), 1);
-   OUT_RING  (chan, 0);
+      PUSH_DATA(push, 0);
+   BEGIN_NVC0(push, NVC0_3D(CLIP_RECTS_EN), 1);
+   PUSH_DATA (push, 0);
+   BEGIN_NVC0(push, NVC0_3D(CLIPID_ENABLE), 1);
+   PUSH_DATA (push, 0);
 
    /* neither scissors, viewport nor stencil mask should affect clears */
-   BEGIN_RING(chan, RING_3D(CLEAR_FLAGS), 1);
-   OUT_RING  (chan, 0);
+   BEGIN_NVC0(push, NVC0_3D(CLEAR_FLAGS), 1);
+   PUSH_DATA (push, 0);
 
-   BEGIN_RING(chan, RING_3D(VIEWPORT_TRANSFORM_EN), 1);
-   OUT_RING  (chan, 1);
-   BEGIN_RING(chan, RING_3D(DEPTH_RANGE_NEAR(0)), 2);
-   OUT_RINGf (chan, 0.0f);
-   OUT_RINGf (chan, 1.0f);
-   BEGIN_RING(chan, RING_3D(VIEW_VOLUME_CLIP_CTRL), 1);
-   OUT_RING  (chan, NVC0_3D_VIEW_VOLUME_CLIP_CTRL_UNK1_UNK1);
+   BEGIN_NVC0(push, NVC0_3D(VIEWPORT_TRANSFORM_EN), 1);
+   PUSH_DATA (push, 1);
+   BEGIN_NVC0(push, NVC0_3D(DEPTH_RANGE_NEAR(0)), 2);
+   PUSH_DATAf(push, 0.0f);
+   PUSH_DATAf(push, 1.0f);
+   BEGIN_NVC0(push, NVC0_3D(VIEW_VOLUME_CLIP_CTRL), 1);
+   PUSH_DATA (push, NVC0_3D_VIEW_VOLUME_CLIP_CTRL_UNK1_UNK1);
 
    /* We use scissors instead of exact view volume clipping,
     * so they're always enabled.
     */
-   BEGIN_RING(chan, RING_3D(SCISSOR_ENABLE(0)), 3);
-   OUT_RING  (chan, 1);
-   OUT_RING  (chan, 8192 << 16);
-   OUT_RING  (chan, 8192 << 16);
+   BEGIN_NVC0(push, NVC0_3D(SCISSOR_ENABLE(0)), 3);
+   PUSH_DATA (push, 1);
+   PUSH_DATA (push, 8192 << 16);
+   PUSH_DATA (push, 8192 << 16);
 
 #define MK_MACRO(m, n) i = nvc0_graph_set_macro(screen, m, i, sizeof(n), n);
 
@@ -627,41 +635,42 @@ nvc0_screen_create(struct nouveau_device *dev)
    MK_MACRO(NVC0_3D_POLYGON_MODE_FRONT, nvc0_9097_poly_mode_front);
    MK_MACRO(NVC0_3D_POLYGON_MODE_BACK, nvc0_9097_poly_mode_back);
 
-   BEGIN_RING(chan, RING_3D(RASTERIZE_ENABLE), 1);
-   OUT_RING  (chan, 1);
-   BEGIN_RING(chan, RING_3D(RT_SEPARATE_FRAG_DATA), 1);
-   OUT_RING  (chan, 1);
-   BEGIN_RING(chan, RING_3D(GP_SELECT), 1);
-   OUT_RING  (chan, 0x40);
-   BEGIN_RING(chan, RING_3D(LAYER), 1);
-   OUT_RING  (chan, 0);
-   BEGIN_RING(chan, RING_3D(TEP_SELECT), 1);
-   OUT_RING  (chan, 0x30);
-   BEGIN_RING(chan, RING_3D(PATCH_VERTICES), 1);
-   OUT_RING  (chan, 3);
-   BEGIN_RING(chan, RING_3D(SP_SELECT(2)), 1);
-   OUT_RING  (chan, 0x20);
-   BEGIN_RING(chan, RING_3D(SP_SELECT(0)), 1);
-   OUT_RING  (chan, 0x00);
-
-   BEGIN_RING(chan, RING_3D(POINT_COORD_REPLACE), 1);
-   OUT_RING  (chan, 0);
-   BEGIN_RING(chan, RING_3D(POINT_RASTER_RULES), 1);
-   OUT_RING  (chan, NVC0_3D_POINT_RASTER_RULES_OGL);
-
-   BEGIN_RING(chan, RING_3D(EDGEFLAG_ENABLE), 1);
-   OUT_RING  (chan, 1);
-
-   BEGIN_RING(chan, RING_3D(VERTEX_RUNOUT_ADDRESS_HIGH), 2);
-   OUT_RING  (chan, 0xab);
-   OUT_RING  (chan, 0x00000000);
-
-   FIRE_RING (chan);
+   BEGIN_NVC0(push, NVC0_3D(RASTERIZE_ENABLE), 1);
+   PUSH_DATA (push, 1);
+   BEGIN_NVC0(push, NVC0_3D(RT_SEPARATE_FRAG_DATA), 1);
+   PUSH_DATA (push, 1);
+   BEGIN_NVC0(push, NVC0_3D(GP_SELECT), 1);
+   PUSH_DATA (push, 0x40);
+   BEGIN_NVC0(push, NVC0_3D(LAYER), 1);
+   PUSH_DATA (push, 0);
+   BEGIN_NVC0(push, NVC0_3D(TEP_SELECT), 1);
+   PUSH_DATA (push, 0x30);
+   BEGIN_NVC0(push, NVC0_3D(PATCH_VERTICES), 1);
+   PUSH_DATA (push, 3);
+   BEGIN_NVC0(push, NVC0_3D(SP_SELECT(2)), 1);
+   PUSH_DATA (push, 0x20);
+   BEGIN_NVC0(push, NVC0_3D(SP_SELECT(0)), 1);
+   PUSH_DATA (push, 0x00);
+
+   BEGIN_NVC0(push, NVC0_3D(POINT_COORD_REPLACE), 1);
+   PUSH_DATA (push, 0);
+   BEGIN_NVC0(push, NVC0_3D(POINT_RASTER_RULES), 1);
+   PUSH_DATA (push, NVC0_3D_POINT_RASTER_RULES_OGL);
+
+   IMMED_NVC0(push, NVC0_3D(EDGEFLAG), 1);
+
+   BEGIN_NVC0(push, NVC0_3D(VERTEX_RUNOUT_ADDRESS_HIGH), 2);
+   PUSH_DATA (push, 0xab);
+   PUSH_DATA (push, 0x00000000);
+
+   PUSH_KICK (push);
 
    screen->tic.entries = CALLOC(4096, sizeof(void *));
    screen->tsc.entries = screen->tic.entries + 2048;
 
-   screen->mm_VRAM_fe0 = nouveau_mm_create(dev, NOUVEAU_BO_VRAM, 0xfe0);
+   mm_config.nvc0.tile_mode = 0;
+   mm_config.nvc0.memtype = 0xfe0;
+   screen->mm_VRAM_fe0 = nouveau_mm_create(dev, NOUVEAU_BO_VRAM, &mm_config);
 
    if (!nvc0_blitctx_create(screen))
       goto fail;
@@ -675,23 +684,6 @@ fail:
    return NULL;
 }
 
-void
-nvc0_screen_make_buffers_resident(struct nvc0_screen *screen)
-{
-   struct nouveau_channel *chan = screen->base.channel;
-
-   const unsigned flags = NOUVEAU_BO_VRAM | NOUVEAU_BO_RD;
-
-   MARK_RING(chan, 0, 5);
-   nouveau_bo_validate(chan, screen->text, flags);
-   nouveau_bo_validate(chan, screen->uniforms, flags);
-   nouveau_bo_validate(chan, screen->txc, flags);
-   nouveau_bo_validate(chan, screen->vfetch_cache, flags);
-
-   if (screen->cur_ctx && screen->cur_ctx->state.tls_required)
-      nouveau_bo_validate(chan, screen->tls, flags);
-}
-
 int
 nvc0_screen_tic_alloc(struct nvc0_screen *screen, void *entry)
 {